Estoy tratando de escribir algoritmos genéricos en C # que pueden funcionar con entidades geométricas de diferentes dimensiones.

En el siguiente ejemplo artificial que tengo Point2y Point3, ambos implementamos una IPointinterfaz simple .

Ahora tengo una función GenericAlgorithmque llama a una función GetDim. Existen múltiples definiciones de esta función según el tipo. También hay una función alternativa que se define para cualquier cosa que implemente IPoint.

Inicialmente esperaba que la salida del siguiente programa fuera 2, 3. Sin embargo, es 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, por alguna razón, la información del tipo concreto se pierde GenericAlgorithm. No entiendo completamente por qué sucede esto, pero está bien. Si no puedo hacerlo de esta manera, ¿qué otras alternativas tengo?

Este método:

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

... siempre llamará GetDim<T>(T point). La resolución de sobrecarga se realiza en tiempo de compilación , y en esa etapa no hay otro método aplicable.

Si desea que se invoque la resolución de sobrecarga en el momento de la ejecución , deberá usar la tipificación dinámica, p. Ej.

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

Pero generalmente es una mejor idea usar la herencia para esto; en su ejemplo, obviamente podría tener el método único y regresar point.NumDims. Supongo que en su código real hay alguna razón por la que es más difícil hacer el equivalente, pero sin más contexto no podemos aconsejar sobre cómo usar la herencia para realizar la especialización. Sin embargo, esas son sus opciones:

• Herencia (preferida) para especialización basada en el tipo de tiempo de ejecución del objetivo
• Escritura dinámica para resolución de sobrecarga en tiempo de ejecución

A partir de C # 8.0, debería poder proporcionar una implementación predeterminada para su interfaz, en lugar de requerir el método genérico.

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

Implementar un método genérico y sobrecargas por IPointimplementación también viola el Principio de sustitución de Liskov (la L en SÓLIDO). Sería mejor insertar el algoritmo en cada IPointimplementación, lo que significa que solo debería necesitar una sola llamada al método:

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

Patrón de visitante

Como alternativa al dynamicuso, es posible que desee utilizar un patrón de visitante como se muestra a continuación:

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

¿Por qué no define la función GetDim en clase e interfaz? En realidad, no necesita definir la función GetDim, solo use la propiedad NumDims.