Przekazywanie ogólnej funkcji jako parametru

Question

Wiem, że to, co robię, można zrobić w inny sposób, ale jestem ciekawy, jak to działa. Poniżej znajduje się uproszczony kod, który się nie kompiluje, ale powinien pokazać mój cel.

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 to ogólna Konwersja z ciąg do jakiegoś przedmiotu (myślę deserializacji). GeneralizedFunction wykorzystuje dwie specjalizacje transformacji: jedną dla typu A i jedną dla typu B. Wiem, że mogę to zrobić na wiele innych sposobów (np. Wprowadzając parametr dla typu obiektu), ale szukam wyjaśnienia, czy jest to możliwe lub niemożliwe w przypadku generycznych/lambdas. Jeśli Transform jest wyspecjalizowany, zanim zostanie przekazany jako parametr do GeneralizedFunction, wówczas jest to niemożliwe. Następnie pojawia się pytanie, dlaczego ta możliwość jest ograniczona.

Answer 1

Spróbuj następujący podpis:

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

(Zauważ, że GeneralizedFunction musi być rodzajowy; kompilator automatycznie odgadnąć typ parametru podczas wywoływania metody).

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

To, o co prosisz, nie jest możliwe przy użyciu samych leków generycznych. Kompilator musi wygenerować dwie wersje maszynowej wersji Transform: jedną, aby zwrócić typ A i jedną dla typu B. Kompilator nie ma możliwości wygenerowania tego podczas kompilacji; tylko przez uruchomienie kodu będzie wiedział, że A i B są wymagane.

Jednym ze sposobów rozwiązania tego byłoby przekazać w dwóch wersjach:

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); 
} 

Kompilator wie dokładnie to, czego potrzebuje, aby wygenerować w tym przypadku.

Answer 4

Wygląda na to, że odpowiedź brzmi "nie".

Po wywołaniu Transform bezpośrednio, trzeba określić parametr typu:

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

Tak hipotetycznie, jeśli można przekazać niekompletnie-skonstruowaną funkcję rodzajowy jak chcesz, to trzeba określić również parametry:

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 
} 

Wydaje mi się, że można to hipotetycznie zrobić, jeśli C# ma taką składnię.

Ale jaki jest przypadek użycia? Oprócz przekształcenia łańcuchów do wartości domyślnej dowolnego typu, nie widzę zbyt dużego wykorzystania tego. W jaki sposób można zdefiniować funkcję, która dałaby sensowny wynik w jednym z dwóch różnych typów przy użyciu tej samej serii instrukcji?

EDIT

Analiza dlaczego nie jest to możliwe:

Kiedy użyć wyrażenia lambda w kodzie, jest kompilowany do obu delegata lub drzewa ekspresji; w tym przypadku jest to delegat. Nie możesz mieć instancji typu "otwartego"; innymi słowy, aby utworzyć obiekt z rodzaju ogólnego, należy określić wszystkie parametry typu.Innymi słowy, nie ma sposobu, aby mieć instancję delegata bez dostarczania argumentów dla wszystkich jego parametrów typu.

Jedną z przydatnych funkcji kompilatora C# są niejawne konwersje grup metod, w których nazwa metody ("grupa metod") może zostać niejawnie przekształcona w typ delegata reprezentujący jedno z przeciążeń tej metody. Podobnie, kompilator niejawnie konwertuje wyrażenie lambda na typ delegata. W obu przypadkach kompilator wysyła kod, aby utworzyć instancję typu delegata (w tym przypadku, aby przekazać ją do funkcji). Ale instancja tego typu delegata nadal musi mieć argument typu dla każdego z jego parametrów typu.

Aby przejść funkcję ogólną jako ogólną funkcję Wydaje się, że kompilator musi być w stanie przejść grupę metody lub Wyrażenie lambda sposobu bez konwersji, tak aAction parametr miałby jakoś rodzaj "grupy metod" lub "wyrażenia lambda". Następnie niejawna konwersja do typu delegata może się zdarzyć w witrynach połączeń A result1 = aAction<A>(aStringA); i B result2 = aAction<B>(aStringB);. Oczywiście, w tym momencie jesteśmy dobrze we wszechświecie kontrowersyjnych i hipotetycznych.

Rozwiązanie wpadłem na obiad był to, zakładając funkcję Deserialize<T> który pobiera ciąg zawierający dane odcinkach i zwraca obiekt typu 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

Ta odpowiedź nie wyjaśnia przyczynę dlaczego, właśnie jak obejść ograniczenia.

Zamiast przechodzącą rzeczywistej funkcji można przekazać obiekt, który ma taką funkcję:

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); 
} 

dla konkretnego przypadku użycia, można uprościć do:

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"); 
}