Возможна ли неполная запись типа в С#?

Ответ 1

Если у вас есть только два типа регистрации (что, кажется, имеет место в вашем вопросе), вы можете просто реализовать два метода расширения:

public static DelegateRegistration Parameter<T>( 
   this DelegateRegistration p, string name, T value); 

public static ConcreteTypeRegistration Parameter<T>( 
   this ConcreteTypeRegistration p, string name, T value); 

Тогда вам не нужно будет указывать аргумент типа, поэтому вывод типа будет работать в примере, который вы упомянули. Обратите внимание, что вы можете реализовать оба метода расширения только путем делегирования на один общий метод расширения с двумя параметрами типа (один в вашем вопросе).

В общем, С# не поддерживает ничего, как o.Foo<int, ?>(..), чтобы вывести только параметр второго типа (это была бы хорошая функция - F # имеет его, и это весьма полезно:-)). Вероятно, вы могли бы применить обходное решение, которое позволит вам написать это (в основном, разделив вызов на два вызова метода, чтобы получить два места, где может применяться тип inferrence):

FooTrick<int>().Apply(); // where Apply is a generic method

Вот псевдокод, демонстрирующий структуру:

// in the original object
FooImmediateWrapper<T> FooTrick<T>() { 
  return new FooImmediateWrapper<T> { InvokeOn = this; } 
}
// in the FooImmediateWrapper<T> class
(...) Apply<R>(arguments) { 
  this.InvokeOn.Foo<T, R>(arguments);
}

Ответ 2

Я хотел создать метод расширения, который мог бы перечислить список вещей и вернуть список тех вещей, которые были определенного типа. Это будет выглядеть так:

listOfFruits.ThatAre<Banana>().Where(banana => banana.Peel != Color.Black) ...

К сожалению, это невозможно. Предложенная подпись для этого метода расширений выглядела бы так:

public static IEnumerable<TResult> ThatAre<TSource, TResult>
    (this IEnumerable<TSource> source) where TResult : TSource

... и вызов ToAre < > терпит неудачу, потому что должны быть указаны оба аргумента типа, хотя TSource может быть выведен из использования.

Следуя советам в других ответах, я создал две функции: одну, которая захватывает источник, а другую, которая позволяет вызывающим абонентам выражать результат:

public static ThatAreWrapper<TSource> That<TSource>
    (this IEnumerable<TSource> source)
{
    return new ThatAreWrapper<TSource>(source);
}

public class ThatAreWrapper<TSource>
{
    private readonly IEnumerable<TSource> SourceCollection;
    public ThatAreWrapper(IEnumerable<TSource> source)
    {
        SourceCollection = source;
    }
    public IEnumerable<TResult> Are<TResult>() where TResult : TSource
    {
        foreach (var sourceItem in SourceCollection)
            if (sourceItem is TResult) yield return (TResult)sourceItem;
        }
    }
}

В результате появляется следующий код:

listOfFruits.That().Are<Banana>().Where(banana => banana.Peel != Color.Black) ...

... что неплохо.

Обратите внимание, что из-за ограничений типа generic, следующий код:

listOfFruits.That().Are<Truck>().Where(truck => truck.Horn.IsBroken) ...

не будет компилироваться на этапе Are(), так как Trucks не является Fruits. Это превосходит предоставленную функцию .OfType < > :

listOfFruits.OfType<Truck>().Where(truck => truck.Horn.IsBroken) ...

Это компилируется, но всегда дает нулевые результаты и, действительно, не имеет смысла пытаться. Это гораздо приятнее, если компилятор поможет вам определить эти вещи.

Ответ 3

Почему бы вам не указать параметры нулевого типа? Оба могут быть выведены в ваш образец. Если это не приемлемое решение для вас, я часто сталкиваюсь с этой проблемой, и нет простого способа решить проблему "вывести только один параметр типа". Поэтому я перейду к дублирующим методам.

Ответ 4

Как насчет следующего:

Используйте предоставленное определение: public static TReg Parameter<TReg, T>( this TReg p, string name, T value) where TReg : ParameterizedRegistrationBase

Затем введите параметр, чтобы механизм вывода получил правильный тип:

ServiceContainerBuilder.Register<ISomeService>(r => r
.From(f => f.ConcreteType<FileService>(ct => ct
    .Parameter("source", (Stream)new FileStream(...)))));

Ответ 5

Я думаю, вам нужно разделить два параметра типа между двумя разными выражениями; сделать явный один частью типа параметра для метода расширения, поэтому вывод может затем поднять его.

Предположим, вы объявили класс-оболочку:

public class TypedValue<TValue>
{
    public TypedValue(TValue value)
    {
        Value = value;
    }

    public TValue Value { get; private set; }
}

Затем ваш метод расширения как:

public static class Extensions
{
    public static TReg Parameter<TValue, TReg>(
        this TReg p, string name, TypedValue<TValue> value) 
        where TReg : ParameterizedRegistrationBase
    {
        // can get at value.Value
        return p;
    }
}

Плюс более простая перегрузка (на самом деле это можно было назвать):

public static class Extensions
{
    public static TReg Parameter<TValue, TReg>(
        this TReg p, string name, TValue value) 
        where TReg : ParameterizedRegistrationBase
    {
        return p;
    }
}

Теперь в простом случае, когда вы с удовольствием выберете тип значения параметра:

ct.Parameter("name", "Lasse")

Но в случае, когда вам нужно явно указать тип, вы можете сделать это:

ct.Parameter("list", new TypedValue<IEnumerable<int>>(new List<int>()))

Выглядит уродливо, но, надеюсь, реже, чем простой, полностью выведенный вид.

Обратите внимание, что вы можете просто перезагрузить no-wrapper и написать:

ct.Parameter("list", (IEnumerable<int>)(new List<int>()))

Но у этого, конечно, есть недостаток неудачи во время выполнения, если у вас что-то не так. К сожалению, далеко от моего компилятора С# прямо сейчас, так извиняйтесь, если это не так.