Próbuję pisać ogólne algorytmy w języku C #, które mogą pracować z elementami geometrycznymi o innym wymiarze.

W poniższym wymyślonym przykładzie mam Point2i Point3oba, implementujące prosty IPointinterfejs.

Teraz mam funkcję, GenericAlgorithmktóra wywołuje funkcję GetDim. Istnieje wiele definicji tej funkcji w zależności od typu. Istnieje również funkcja rezerwowa zdefiniowana dla wszystkiego, co implementuje IPoint.

Początkowo spodziewałem się, że wynikiem następującego programu będzie 2, 3. Jest to jednak 0, 0.

interface IPoint {
    public int NumDims { get; } 
}

public struct Point2 : IPoint {
    public int NumDims => 2;
}

public struct Point3 : IPoint {
    public int NumDims => 3;
}

class Program
{
    static int GetDim<T>(T point) where T: IPoint => 0;
    static int GetDim(Point2 point) => point.NumDims;
    static int GetDim(Point3 point) => point.NumDims;

    static int GenericAlgorithm<T>(T point) where T : IPoint => GetDim(point);

    static void Main(string[] args)
    {
        Point2 p2;
        Point3 p3;
        int d1 = GenericAlgorithm(p2);
        int d2 = GenericAlgorithm(p3);
        Console.WriteLine("{0:d}", d1);        // returns 0 !!
        Console.WriteLine("{0:d}", d2);        // returns 0 !!
    }
}

OK, więc z jakiegoś powodu zaginęła konkretna informacja o typie GenericAlgorithm. Nie do końca rozumiem, dlaczego tak się dzieje, ale dobrze. Jeśli nie mogę tego zrobić w ten sposób, jakie mam inne alternatywy?

Ta metoda:

static int GenericAlgorithm<T>(T point) where T : IPoint => GetDim(point);

... zawsze zadzwoni GetDim<T>(T point). Rozdzielczość przeciążenia jest wykonywana w czasie kompilacji i na tym etapie nie ma innej stosownej metody.

Jeśli chcesz, aby w czasie wykonywania wywoływana była rozdzielczość przeciążenia , musisz użyć dynamicznego pisania, np

static int GenericAlgorithm<T>(T point) where T : IPoint => GetDim((dynamic) point);

Ale generalnie lepszym pomysłem jest użycie do tego dziedziczenia - w twoim przykładzie oczywiście możesz mieć tylko jedną metodę i zwrócić point.NumDims. Zakładam, że w twoim prawdziwym kodzie istnieje jakiś powód, dla którego ekwiwalent jest trudniejszy, ale bez większego kontekstu nie możemy doradzić, jak użyć dziedziczenia do wykonania specjalizacji. Są to jednak twoje opcje:

• Dziedziczenie (preferowane) dla specjalizacji opartej na typie czasu wykonania celu
• Pisanie dynamiczne w celu rozwiązania problemu przeciążenia w czasie wykonywania

Począwszy od wersji C # 8.0 powinieneś być w stanie zapewnić domyślną implementację interfejsu, zamiast wymagać ogólnej metody.

interface IPoint {
    int NumDims { get => 0; }
}

Wdrożenie ogólnej metody i przeciążenia na IPointwdrożenie również narusza zasadę podstawienia Liskowa (L w SOLID). Lepiej byłoby wcisnąć algorytm do każdej IPointimplementacji, co oznacza, że ​​potrzebujesz tylko jednego wywołania metody:

static int GetDim(IPoint point) => point.NumDims;

Wzór gościa

jako alternatywę dla dynamicużycia możesz użyć wzorca gościa, jak poniżej:

interface IPoint
{
    public int NumDims { get; }
    public int Accept(IVisitor visitor);
}

public struct Point2 : IPoint
{
    public int NumDims => 2;

    public int Accept(IVisitor visitor)
    {
        return visitor.Visit(this);
    }
}

public struct Point3 : IPoint
{
    public int NumDims => 3;

    public int Accept(IVisitor visitor)
    {
        return visitor.Visit(this);
    }
}

public class Visitor : IVisitor
{
    public int Visit(Point2 toVisit)
    {
        return toVisit.NumDims;
    }

    public int Visit(Point3 toVisit)
    {
        return toVisit.NumDims;
    }
}

public interface IVisitor<T>
{
    int Visit(T toVisit);
}

public interface IVisitor : IVisitor<Point2>, IVisitor<Point3> { }

class Program
{
    static int GetDim<T>(T point) where T : IPoint => 0;
    static int GetDim(Point2 point) => point.NumDims;
    static int GetDim(Point3 point) => point.NumDims;

    static int GenericAlgorithm<T>(T point) where T : IPoint => point.Accept(new Visitor());

    static void Main(string[] args)
    {
        Point2 p2;
        Point3 p3;
        int d1 = GenericAlgorithm(p2);
        int d2 = GenericAlgorithm(p3);
        Console.WriteLine("{0:d}", d1);        // returns 2
        Console.WriteLine("{0:d}", d2);        // returns 3
    }
}

Dlaczego nie zdefiniujesz funkcji GetDim w klasie i interfejsie？ W rzeczywistości nie musisz definiować funkcji GetDim, po prostu użyj właściwości NumDims.