如何在C#中实现类似模板的功能

Question

如何在C#中实现类似模板的功能？例如，FuncA、FuncB 和 FuncC 函数采用相同的参数，然后这些函数总是只对 ClassA 执行相同的操作。即使这些函数采用 ClassB 或三个整数，这些函数也会将 ClassB 或三个整数转换为 ClassA，以执行与将 ClassA 作为参数时相同的操作。不知道有没有什么好的方法，如果你知道，请告诉我。

void FuncA(ClassA a)
{
    // do something
}
void FuncA(ClassB b)
{
    FuncA(b.ToA());
}
void FuncA(int x, int y, int z)
{
    FuncA(new ClassA(x, y, z));
}

void FuncB(ClassA a)
{
    // do something
}
void FuncB(ClassB b)
{
    FuncB(b.ToA());
}
void FuncB(int x, int y, int z)
{
    FuncB(new ClassA(x, y, z));
}

void FuncC(ClassA a)
{
    // do something
}
void FuncC(ClassB b)
{
    FuncC(b.ToA());
}
void FuncC(int x, int y, int z)
{
    FuncC(new ClassA(x, y, z));
}

// FuncD, FuncE and so on...

Answer 1

我想有几个选择...

您可以创建一个基地 class:

public abstract class ActionerOnA
{
    public abstract void Execute(A a);

    public void Execute(B b) => Execute(b.ToA());
    public void Execute(int x, int y, int z) => Execute(new A(x, y, z));
}

public class Action1 : ActionerOnA
{
    public override void Execute(A a)
    {
        DoSomethingHereWith(a);
    }

    // no need to worry about the other overloads
}

您可以将其用于：

var actionerOnA = new Action1();
actionerOnA(a);
actionerOnA(b);
actionerOnA(x, y, z);

您可以使用助手 class，其中依赖项被移动到构造函数而不是方法：

public class ActionerOnA
{
    private A _a;
    private Action<A> _actionToExecute;

    public ActionerOnA(Action<A> action, A a) 
    {
        _a = a;
        _actionToExecute = action;
    }

    public ActionerOnA(Action<A> action, B b) : this(action, b.ToA()) { }
    public ActionerOnA(Action<A> action, int x, int y, int z) : this(action, new A(x, y, z)) { }
}

然后您可以像这样使用它：

var actionerOnA = new ActionerOnA(Func1, a);
var actionerOnA = new ActionerOnA(Func1, b);
var actionreOnA = new ActionerOnA(Func1, x, y, z);

actionerOnA.Execute();

public void Func1(A a) { }

Answer 2

这可能不是您要找的东西，但它可能会给您一些思考

public class MyBase
{
   public int X { get; set; }
   public int Y { get; set; }
   public int Z { get; set; }
   public void MethodA()
   {

   }
   public void MethodB()
   {

   }
   public void MethodC()
   {

   }
}

public class ClassA : MyBase
{
   public ClassA()
   {

   }
   public ClassA(int x, int y, int z)
   {
      X = x;
      Y = y;
      Z = z;
   }
}
public class ClassB : MyBase
{

}

用法

var classA = new ClassA(23,56,324);
classA.MethodA();
classA.MethodB();
classA.MethodC();

var classB = new ClassB();
classB.MethodA();
classB.MethodB();
classB.MethodC();

Answer 3

我使用隐式转换和元组解决了这个问题。

class ClassA
{
    // members...

    public static implicit operator ClassA(ClassB b)
    {
        return b.ToA();
    }

    public static implicit operator ClassA(Tuple<int, int, int> t)
    {
        return new ClassA(t.Item1, t.Item2, t.Item3);
    }
}

void FuncA(ClassA a)
{
    // do something
}
// we don't have to implement overloaded FuncA functions that take ClassB or three integers.
void FuncB(ClassA a) { /* do something */ }
void FuncC(ClassA a) { /* do something */ }

如何在C#中实现类似模板的功能

How to implement functions like template in C#

c#

coding-style