C# 如何在C中实现模板等功能#

如何在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...

---

我想这有几个选择

您可以创建一个基类：

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);

---

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

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

---

我想这有几个选择

您可以创建一个基类：

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);

---

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

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

---

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

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();

---

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

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();

---

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

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

A类
{
//成员们。。。
公共静态隐式运算符ClassA（ClassB）
{
返回b.ToA（）；
}
公共静态隐式运算符ClassA（元组t）
{
返回新的ClassA（t.Item1、t.Item2、t.Item3）；
}
}
void FuncA（a类）
{
//做点什么
}
//我们不必实现采用ClassB或三个整数的重载FuncA函数。
void FuncB（ClassA a）{/*做某事*/}
void func（ClassA a）{/*做某事*/}

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

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

A类
{
//成员们。。。
公共静态隐式运算符ClassA（ClassB）
{
返回b.ToA（）；
}
公共静态隐式运算符ClassA（元组t）
{
返回新的ClassA（t.Item1、t.Item2、t.Item3）；
}
}
void FuncA（a类）
{
//做点什么
}
//我们不必实现采用ClassB或三个整数的重载FuncA函数。
void FuncB（ClassA a）{/*做某事*/}
void func（ClassA a）{/*做某事*/}

这似乎有点做作，但可能是因为简化了示例。我的问题是ClassA和ClassB之间的关系是什么，这些func方法是什么，它们是在助手类中还是在某个业务层中？。从外观上看（仅以您的示例为例），这里的职责可能是颠倒的，但很难说您想让我的类具有能够以相同方式处理某些类型数据的函数。像ClassA和ClassB这样的数据类型可以相互转换，因为它们只是在不同的坐标系中。这似乎有点做作，但可能是因为简化了示例。我的问题是ClassA和ClassB之间的关系是什么，这些func方法是什么，它们是在助手类中还是在某个业务层中？。从外观上看（仅以您的示例为例），这里的职责可能是颠倒的，但很难说您想让我的类具有能够以相同方式处理某些类型数据的函数。像ClassA和ClassB这样的数据类型可以相互转换，因为它们就像在不同的坐标系中一样。