Передача общей функции как параметра

Question

Я знаю, что то, что я делаю, может быть сделано по-другому, но мне интересно, как все работает. Ниже приведен упрощенный код, который не компилируется, но он должен показывать мою цель.

private void Execute() 
{ 
    GeneralizedFunction("1", "2", i => Transform(i)); 
} 

void GeneralizedFunction(string aStringA, string aStringB, Func<string, T> aAction) 
{ 
    A result1 = aAction(aStringA); 
    B result2 = aAction(aStringB); 
    // Do something with A and B here 
} 

T Transform<T>(string aString) 
{ 
    return default(T); 
} 

Transform является родовым Convertion из строки в какой-то объект (думаю десериализации). GeneralizedFunction использует две специализации преобразования: один для типа A и один для типа B. Я знаю, что могу сделать это несколькими способами (например, вводя параметр для типа объекта), но я ищу объяснения того, возможно ли это или невозможно сделать это с помощью дженериков/лямбда. Если Transform специализируется до того, как он будет передан как параметр для Обобщенной функции, это невозможно. Тогда возникает вопрос, почему эта возможность ограничена.

Answer 1

Попробуйте следующую подпись:

void GeneralizedFunction<T>(string aStringA, string aStringB, Func<string, T> aAction) 

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

Answer 2

void GeneralizedFunction<T>(string aStringA, string aStringB, Func<string, T> aAction) 
{ 
    A result1 = aAction(aStringA); 
    B result2 = aAction(aStringB); 
} 

T Transform<T>(string aString) 
{ 
    return default(T); 
} 

Answer 3

То, что вы просите сделать, невозможно только с использованием дженериков. Компилятор должен сгенерировать две типизированные версии вашей функции Transform: один для возврата типа A и один для типа B. Компилятор не может знать, чтобы генерировать это во время компиляции; только запустив код, он знает, что требуются A и B.

Один из способов решить эту проблему будет проходить в двух версиях:

private void Execute() 
{ 
    GeneralizedFunction("1", "2", i => Transform<A>(i), i => Transform<B>(i)); 
} 

void GeneralizedFunction(string aStringA, string aStringB, Func<string, A> aAction, Func<string, B> bAction) 
{ 
    A result1 = aAction(aStringA); 
    B result2 = bAction(aStringB); 
} 

компилятор точно знает, что ему нужно, чтобы произвести в этом случае.

Answer 4

Кажется, что ответ «нет».

Когда вы звоните Transform напрямую, вы должны указать параметр типа:

int i = Transform<int>(""); 

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

void GeneralizedFunction(string aStringA, string aStringB, Func<string, T> aAction) 
{ 
    A result1 = aAction<A>(aStringA); 
    B result2 = aAction<B>(aStringB); 
    // Do something with A and B here 
} 

так что, мне кажется, что вы могли бы гипотетически сделать это, если C# был синтаксис, как это.

Но какой прецедент? Помимо преобразования строк в значение по умолчанию для произвольного типа, я не вижу большого смысла для этого. Как вы могли бы определить функцию, которая обеспечивала бы значимый результат в любом из двух разных типов, используя ту же последовательность утверждений?

EDIT

Анализ, почему это не представляется возможным:

При использовании лямбда-выражения в коде, он компилируется в любой делегат или дерева выражений; в этом случае это делегат. Вы не можете иметь экземпляр «открытого» типа общего типа; другими словами, для создания объекта из общего типа необходимо указать все параметры типа.Другими словами, нет возможности иметь экземпляр делегата без предоставления аргументов для всех его параметров типа.

Одна из полезных функций компилятора C# - это неявные преобразования групп методов, где имя метода («группа методов») может быть неявно преобразовано в тип делегата, представляющий одну из перегрузок этого метода. Точно так же компилятор неявно преобразует лямбда-выражение в тип делегата. В обоих случаях компилятор испускает код для создания экземпляра типа делегата (в этом случае передать его функции). Но экземпляр этого типа делегата по-прежнему должен иметь аргумент типа для каждого из его параметров типа.

Чтобы передать общую функцию как обобщенная функция, кажется, компилятор должен был бы быть в состоянии пройти группу метод или лямбда-выражения методу без преобразования, поэтому aAction параметр каким-то образом будет иметь тип «группа методов» или «лямбда-выражение». Затем неявное преобразование в тип делегата может произойти на сайтах вызовов A result1 = aAction<A>(aStringA); и B result2 = aAction<B>(aStringB);. Конечно, на данный момент мы хорошо во вселенной противопоказаний и гипотез.

Решение, которое я придумал за обедом было это, предполагая, что функция Deserialize<T>, которая принимает строку, содержащую сериализованные данные и возвращает объект типа T:

void GeneralizedFunction<T>(string aStringA, string aStringB, Func<T, string> stringGetter) 
{ 
    A result1 = Deserialize<A>(stringGetter(aStringA)); 
    B result2 = Deserialize<B>(stringGetter(aStringB)); 
} 

void Example(string serializedA, string serializedB, string pathToA, string pathToB, FileInfo a, FileInfo b) 
{ 
    GeneralizedFunction(serializedA, serializedB, s => s); 
    GeneralizedFunction(pathToA, pathToB, File.ReadAllText); 
    GeneralizedFunction(a, b, fi => File.ReadAllText(fi.FullName)); 
} 

Answer 5

Этот ответ не объясняет причину почему, только как для работы вокруг ограничения.

Вместо передачи фактической функции, вы можете передать объект, который имеет такую ​​функцию:

interface IGenericFunc 
{ 
    TResult Call<TArg,TResult>(TArg arg); 
} 

// ... in some class: 

void Test(IGenericFunc genericFunc) 
{ 
    // for example's sake only: 
    int x = genericFunc.Call<String, int>("string"); 
    object y = genericFunc.Call<double, object>(2.3); 
} 

Для вашего конкретного случая использования, это может быть упрощено:

interface IDeserializerFunc 
{ 
    T Call<T>(string arg); 
} 

// ... in some class: 
void Test(IDeserializerFunc deserializer) 
{ 
    int x = deserializer.Call<int>("3"); 
    double y = deserializer.Call<double>("3.2"); 
}