Dlaczego C# nie wywnioskuje moich typów generycznych?

C# nie wywnioskuje typów generycznych na podstawie typu zwracanego przez metodę generyczną, tylko argumenty do metody.

Nie używa również ograniczeń jako części wnioskowania typu, co eliminuje ogólne Ograniczenie z dostarczania typu dla Ciebie.

Po szczegóły zobacz Post Erica Lipperta na ten temat .

Nie używa ograniczeń do wnioskowania typów. Raczej wnioskuje typy (jeśli to możliwe) , a następnie sprawdza ograniczenia.

Dlatego, chociaż jedyny możliwy TResult, który może być użyty z parametrem SomeQuery, nie zobaczy tego.

Zauważ również, że możliwe byłoby również zaimplementowanie SomeQuery IQuery<int>, co jest jednym z powodów, dla których jest to ograniczenie dla kompilatora, może nie być złym pomysłem.

Spec jasno to określa:

Sekcja 7.4.2 Wnioskowanie Typu

Jeżeli podana liczba argumentów jest inna niż liczba parametrów w metodzie, wtedy wnioskowanie natychmiast się nie powiedzie. w przeciwnym razie Załóżmy, że metoda generyczna ma następującą sygnaturę:

Tr M(T1 x1 ... Tm xm)

Z wywołaniem metody w postaci m(E1 ...Em) zadaniem wnioskowania typu jest znalezienie unikalnych argumentów typu S1...Sn dla każdego z wpisz parametry X1 ... Xn tak, aby wywołanie M(E1...Em) stało się poprawne.

Jak widać, Typ powrotu nie jest używany do wnioskowania typu. Jeśli wywołanie metody nie mapuje bezpośrednio do argumentów typu wnioskowanie natychmiast się nie powiedzie.

Kompilator nie tylko zakłada, że chcesz string jako argument TResult, ani nie może. Wyobraź sobie TResult pochodzące od string. Oba byłyby ważne, więc który wybrać? Lepiej być wyraźnym.

Dlaczego zostało dobrze wyjaśnione, ale istnieje alternatywne rozwiązanie. Często jednak mam do czynienia z tymi samymi problemami dynamic lub jakiekolwiek rozwiązanie wykorzystujące odbicie lub alokację danych nie wchodzi w grę w moim przypadku (radość z gier wideo...)

Więc zamiast tego przekazuję return jako out parametry, które są następnie poprawnie wywnioskowane.

interface IQueryProcessor
{
     void Process<TQuery, TResult>(TQuery query, out TResult result)
         where TQuery : IQuery<TResult>;
}

class Test
{
    void Test(IQueryProcessor p)
    {
        var query = new SomeQuery();

        // Instead of
        // string result = p.Process<SomeQuery, string>(query);

        // You write
        string result;
        p.Process(query, out result);
    }
}

Jedyną wadą, o której myślę, jest to, że zakazuje używania 'var'.

Nie będę znowu wdawał się w "Dlaczego", nie mam złudzeń, że jestem w stanie zrobić lepsze wyjaśnienie niż Eric Lippert.

Istnieje jednak rozwiązanie, które nie wymaga późnego wiązania lub dodatkowych parametrów do wywołania metody. Nie jest to jednak zbyt intuicyjne, więc pozostawiam czytelnikowi decyzję, czy jest to poprawa.

Po pierwsze, zmodyfikuj IQuery, aby było samodzielne:

public interface IQuery<TQuery, TResult> where TQuery: IQuery<TQuery, TResult>
{
}

Twoje IQueryProcessor wyglądałoby tak:

public interface IQueryProcessor
{
    Task<TResult> ProcessAsync<TQuery, TResult>(IQuery<TQuery, TResult> query)
        where TQuery: IQuery<TQuery, TResult>;
}

Rzeczywiste zapytanie "type": "content"]}

public class MyQuery: IQuery<MyQuery, MyResult>
{
    // Neccessary query parameters
}

Implementacja procesora może wyglądać następująco:

public Task<TResult> ProcessAsync<TQuery, TResult>(IQuery<TQuery, TResult> query)
    where TQuery: IQuery<TQuery, TResult>
{
    var handler = serviceProvider.Resolve<QueryHandler<TQuery, TResult>>();
    // etc.
}

Innym obejściem tego problemu jest dodanie dodatkowego parametru dla typu resolution.To unikaj zmian w istniejącej bazie kodowej taki parametr można dodać do metody rozszerzenia. Na przykład można dodać następującą metodę rozszerzenia:

static class QueryProcessorExtension
{
    public static TResult Process<TQuery, TResult>(
        this IQueryProcessor processor, TQuery query,
        //Additional parameter for TQuery -> IQuery<TResult> type resolution:
        Func<TQuery, IQuery<TResult>> typeResolver)
        where TQuery : IQuery<TResult>
    {
        return processor.Process<TQuery, TResult>(query);
    }
}

Teraz możemy użyć tego rozszerzenia w następujący sposób:

void Test(IQueryProcessor p)
{
    var query = new SomeQuery();

    //You can now call it like this:
    p.Process(query, x => x);
    //Instead of
    p.Process<SomeQuery, string>(query);
}

Co jest dalekie od ideału, ale znacznie lepsze niż jawne podawanie typów.

P. S. Odnośniki do tego numeru w dotnet repozytorium:

Https://github.com/dotnet/csharplang/issues/997

Https://github.com/dotnet/roslyn/pull/7850