如何实现 C# 通用 class 其方法在结构上是通用的？

Question

Say we have this pair of structs, part of a widely used interchange format (so we cannot modify the source - and ideally shouldn't want to: we're not trying to alter the data itself):

struct Vector2 { public int x; public int y; }
struct Vector3 { public int x; public int y; public int z; }

And a class whose core is a list of one or the other, and contains many algorithms which are nearly-identical to implement for either struct, but have to reference the extra members in the 3-element struct (the z ):

public class Mesh<T>
{
    private List<T> _myVectors;
}

...how do you correctly implement the suite of methods that process them? eg:

public int Average()
{
    // if Vector2:
    int sum = 0, count = 0;
    foreach( var v2 in _MyVectors )
    {
        sum += v2.x + v2.y;
        count++;
    }

    // if Vector3:
    int sum = 0, count = 0;
    foreach( var v3 in _MyVectors )
    {
        sum += v3.x + v3.y + v3.z;
        count++;
    }

    return sum/count;
}

Noting especially : struct-specific methods already exist (millions of them), offered by API's that lack any in-built Generics. So, eg we can confidently write an algorithm to use a method in FOREIGN_API , knowing that one copy of the source code (but using Generics) will bind to an acceptable implementation either way:

public float FOREIGN_API_Average( Vector2 input );
public float FOREIGN_API_Average( Vector3 input );

---

The problems I'm trying to wrap my head around here are, approximately:

1. It is the // if Vector2: conceptual part in the example above that I can't figure out how to do in C#.
2. I'm simply not sure how to structure this. It feels like I have to do some mildly clever trick around stating "I have arbitrary generics args. But I have some specific versions of this class I will implement internally. (All other non-specific versions are illegal by implication, and I'll implement a set of methods that throw Exceptions)". But... I'm not sure how to pull that off.
3. Structs cannot "extend" one another. If they were classes I would start by constraining the using-class (Mesh) with a where T: BaseVector , and go from there. But that's not possible with structs.
4. The structs come from a (billion dollar) piece of software that I don't own; there are plenty of architectural decisions I wish they'd made differently, but TL;DR: got to work with what we've got.
5. This problem isn't just two structs: to support 3D math, I have to re-implement everything for Vector1 , Vector2 , Vector3 , Vector4 ... there's a lot of code I don't want to copy/pasta!
6. ...and the typical Mesh class has 4 internal lists, each of which can be any of those 4 types. If I have to write every combination by hand, and not use Generics, I will have 4^4 = 256 copies of the same code to write and maintain.

Answer 1

Truly makes you envy C++ and their stupid sexy templates, doesn't it?

Some assumptions first (correct them if they are wrong):

You've said that the mesh type can have four different lists, so I'll assume its signature is Mesh<T1, T2, T3, T4> . I'm also assuming you control this type, but not the VectorN types.

The issue is that you're lacking any generic support for Vectors and you cannot use polymorphism on them in any way. As you've said, wrapping them in an interface or introducing custom classes as wrappers will kill the performance.

So the thing you want to do is a variation on double-dispatch - call a different method based on the type of its arguments.

The simplest thing that comes to mind is a static wrapper for the existing FOREIGN_API calls:

public static class VectorExtensions
{
    public static int Sum<TVector>(this IEnumerable<TVector> vectors)
    {
        var type = typeof(TVector);
        if (type == typeof(Vector1))
        {
            return FOREIGN_API.Sum((IEnumerable<Vector1>)vectors);
        }
        else if (type == typeof(Vector2))
        {
            return FOREIGN_API.Sum((IEnumerable<Vector2>)vectors);
        }
        else if (...) // etc.

        throw new ArgumentException($"Invalid type of vector {typeof(TVector).Name}.");
    }
}

Then, implementing an Average on a mesh is easy (I'm assuming an average is an average of all lists combined):

public class Mesh<T1, T2, T3, T4>
{
    private List<T1> _myVectors1;
    private List<T2> _myVectors2;
    private List<T3> _myVectors3;
    private List<T4> _myVectors4;

    public float Average()
    {
        var sum1 = _myVectors1.Sum();
        var sum2 = _myVectors2.Sum();
        var sum3 = _myVectors3.Sum();
        var sum4 = _myVectors4.Sum();

        return (float)(sum1 + sum2 + sum3 + sum4) / 
            (_myVectors1.Count + _myVectors2.Count + _myVectors3.Count + _myVectors4.Count);
    }
}

This form of typechecking should be fast, as C# heavily optimizes typeof calls.

There is a simpler way of writing this that involves dynamic :

public static class VectorExtensions
{
    public static int Sum<TVector>(this IEnumerable<TVector> vectors) =>
        FOREIGN_API.Sum((dynamic)vectors);
}

The dynamic infrastructure is also faster than many expect due to caching, so you might want to give this solution a try first and then think about something else only when the performance is diagnosed to be an issue. As you can see this takes a ridiculously small amount of code to try out.

=============================================================================

Now let's assume we're looking for the most performant way possible. I'm pretty convinced that there's no way of entirely avoiding runtime typechecking. In the above case note, that there are only a handful of typechecks per method invocation. Unless you're calling the Mesh<,,,> methods millions of times, that should be fine. But assuming that you might want to do that, there's a way to trick our way out of this.

The idea is to perform all the typechecks required the moment you instantiate a mesh. Let us define helper types that we will call VectorOperationsN for all possible N in VectorN types. It will implement an interface IVectorOperations<TVector> that will define basic vector operations you want to have. Let's go with Sum for one or many vectors for now, just as examples:

public interface IVectorOperations<TVector>
{
    public int Sum(TVector vector);

    public int Sum(IEnumerable<TVector> vectors);
}

public class VectorOperations1 : IVectorOperations<Vector1>
{
    public int Sum(Vector1 vector) => vector.x;

    public int Sum(IEnumerable<Vector1> vectors) => vectors.Sum(v => Sum(v));
}


public class VectorOperations2 : IVectorOperations<Vector2>
{
    public int Sum(Vector2 vector) => vector.x + vector.y;

    public int Sum(IEnumerable<Vector2> vectors) => vectors.Sum(v => Sum(v));
}

Now we need a way to get the appropriate implementation - this will involve the typecheck:

public static class VectorOperations
{
    public static IVectorOperations<TVector> GetFor<TVector>()
    {
        var type = typeof(TVector);

        if (type == typeof(Vector1))
        {
            return (IVectorOperations<TVector>)new VectorOperations1();
        }
        else if (...) // etc.

        throw new ArgumentException($"Invalid type of vector {typeof(TVector).Name}.");
    }
}

Now when we create a mesh we will get an appropriate implementation and then use it all throught our methods:

public class Mesh<T1, T2, T3, T4>
{
    private List<T1> _myVectors1;
    private List<T2> _myVectors2;
    private List<T3> _myVectors3;
    private List<T4> _myVectors4;
    private readonly IVectorOperations<T1> _operations1;
    private readonly IVectorOperations<T2> _operations2;
    private readonly IVectorOperations<T3> _operations3;
    private readonly IVectorOperations<T4> _operations4;

    public Mesh()
    {
        _operations1 = VectorOperations.GetFor<T1>();
        _operations2 = VectorOperations.GetFor<T2>();
        _operations3 = VectorOperations.GetFor<T3>();
        _operations4 = VectorOperations.GetFor<T4>();
    }

    public float Average()
    {
        var sum1 = _operations1.Sum(_myVectors1);
        var sum2 = _operations2.Sum(_myVectors2);
        var sum3 = _operations3.Sum(_myVectors3);
        var sum4 = _operations4.Sum(_myVectors4);

        return (float)(sum1 + sum2 + sum3 + sum4) / 
            (_myVectors1.Count + _myVectors2.Count + _myVectors3.Count + _myVectors4.Count);
    }
}

This works and does a typecheck only when instantiating the mesh. Success. But we can optimize this further using two tricks.

One, we don't need new instances of IVectorOperations<TVector> implementations. We can make them singletons and never instantiate more than one object for one type of vector. This is perfectly safe as the implementations are always stateless anyway.

public static class VectorOperations
{
    private static VectorOperations1 Implementation1 = new VectorOperations1();
    private static VectorOperations2 Implementation2 = new VectorOperations2();
    ... // etc.

    public static IVectorOperations<TVector> GetFor<TVector>()
    {
        var type = typeof(TVector);

        if (type == typeof(Vector1))
        {
            return (IVectorOperations<TVector>)Implementation1;
        }
        else if (...) // etc.

        throw new ArgumentException($"Invalid type of vector {typeof(TVector).Name}.");
    }
}

Two, we don't really need to typecheck every time we instantiate a new mesh. It's easy to see that the implementations stay the same for every object of a mesh type with equal type arguments. They are static in terms of a single closed generic type. Therefore, we really can make them static:

public class Mesh<T1, T2, T3, T4>
{
    private List<T1> _myVectors1;
    private List<T2> _myVectors2;
    private List<T3> _myVectors3;
    private List<T4> _myVectors4;
    private static readonly IVectorOperations<T1> Operations1 =
        VectorOperations.GetFor<T1>();
    private static readonly IVectorOperations<T2> Operations2 =
        VectorOperations.GetFor<T2>();
    private static readonly IVectorOperations<T3> Operations3 =
        VectorOperations.GetFor<T3>();
    private static readonly IVectorOperations<T4> Operations4 =
        VectorOperations.GetFor<T4>();

    public float Average()
    {
        var sum1 = Operations1.Sum(_myVectors1);
        var sum2 = Operations2.Sum(_myVectors2);
        var sum3 = Operations3.Sum(_myVectors3);
        var sum4 = Operations4.Sum(_myVectors4);

        return (float)(sum1 + sum2 + sum3 + sum4) / 
            (_myVectors1.Count + _myVectors2.Count + _myVectors3.Count + _myVectors4.Count);
    }
}

This way, if there are N different vector types, we only ever instantiate N objects implementing IVectorOperations<> and perform exactly as many additional type checks as there are different mesh types, so at most 4^N . Individual mesh objects don't take any additional memory, but there are again at most 4^N * 4 references to vector operation implementations.

This still forces you to implement all the vector operations four times for different types. But note that now you've unlocked all options - you have a generic interface that depends on the TVector type that you control. Any tricks inside your VectorOperations implementations are allowed. You can be flexible there while being decoupled from the Mesh by the IVectorOperations<TVector> interface.

Wow this answer is long. Thanks for coming to my TED talk!

Answer 2

(I don't think this works, but it's the direction I tried to go in at first - comments welcome, maybe it'll inspire someone else to provide a better answer:)

I thought I could do something like (possible in C++, if I remember correctly, and C# has no direct equivalent for the fully general case, but I figured that for simple cases like this there might be an equivalent):

public class Mesh<T1,T2>
{
 // This class is basically going to fail at runtime:
 //   it cannot/will not prevent you from instancing it
 //   as - say - a Mesh<string,int> - which simply cannot
 //   be sensibly implemented.
 //
 // So: many methods will throw Exceptions - but some can be implemented
 //   (and hence: shared amongst all the other variants of the class)

     public List<T1> internalList;
     public int CountElements<List<T1>>() { return internalList.Count; }
     public int DoSomethingToList1<T1>() { ... }
}

public class Mesh<Vector2,T2>
{
     // Now we're saying: HEY compiler! I'll manually override the
     //    generic instance of Mesh<T1,T2> in all cases where the
     //    T1 is a Vector2!

     public int DoSomethingToList1<Vector2>() { ... }
}

---

Or another attempt to find a syntactically valid way to do the same thing (cf @Gserg's comment to the main question) - but obviously this fails because C# compiler forbids arbitrary type-casting:

    private List<T1> data;
    public void Main()
    {
        if( typeof(T1) == typeof(Vector2) )
            Main( (List<Vector2>) data );
        else if( typeof(T1) == typeof(Vector3) )
            Main( (List<Vector3>) data );
    }

    public void Main( List<Vector2> dataVector2s )
    {
        ...
    }
    public void Main( List<Vector3> dataVector3s )
    {
        ...
    }

Answer 3

I'm not sure if this is what you want, but perhaps you could solve this with a little runtime compilation. For example, you could generate a delegate that sums the fields of a struct;

        public Func<T, int> Sum { get; private set; }
        public void Compile()
        {
            var parm = Expression.Parameter(typeof(T), "parm");
            Expression sum = null;

            foreach(var p in typeof(T).GetFields())
            {
                var member = Expression.MakeMemberAccess(parm, p);
                sum = sum == null ? (Expression)member : Expression.Add(sum, member);
            }
            Sum = Expression.Lambda<Func<T, int>>(sum, parm).Compile();
        }

Or perhaps just a method that turns the struct into some other kind of enumerable that's easier to work with.

Answer 4

My advise would be to have Vector2 and Vector3 bring their own processing methods. Interfaces are the droid you are looking for:

• Have them implement a interface with the functions you need
• use that interface as the type for anything handed into your list
• Call the interface functions

A fitting name for the show process would be "Sumable".

Those might be the builtin implementations of the Vector struct . Of course those two can not be inherited. But the MVVM way of doing things is: "If you can not inherit or modify it, wrap it into something you can inherit and modify."

A simple wrapper (it can be a struct or class) around one of those vectors that implements the interface is all you need.

Another option would be to use LINQ for the processing. If it is only a one-off process, it is often a lot more lightweight then going all the way into inhertiance, classes, interfaces and the like.