如何使用现有的重载映射函数创建将ClassA列表转换为ClassB的泛型函数。（C#）

我有许多重载方法，用于将对象从一个类转换为另一个类。e、 g

    private ClassB MapClass(ClassA inputClass)
    {
        ClassB outputClass = new ClassB();
        outputClass.PropA = inputClass.PropA;
        outputClass.PropB = inputClass.PropB;
        ...
        return outputClass;
    }

    private ClassD MapClass(ClassC inputClass)
    {
        ...
    }

我的问题是，有时我可能有一个类a的列表，我想将其转换为类B的列表。有没有一种方法可以让我编写一个通用方法，它将接受一个ClassA列表，调用相应的转换函数并返回一个ClassB列表？当然，我可以简单地为每个接受列表的方法编写一个额外的转换方法，但是由于有大约20个这样的方法，如果可能的话，我希望避免代码重复

为了澄清这一点，我正在尝试做如下工作：

    private List<T1> MapModelList<T1, T2>(List<T2> inputList)
    {
        List<T1> outputList = new List<T1>();

        foreach (T2 input in inputList)
        {
            T1 output = new T1();
            output = MapClass(input);
            outputList.Add(output);
        }

        return outputList;
    }

私有列表MapModelList（列表输入列表）
{
List outputList=新列表（）；
foreach（输入列表中的T2输入）
{
T1输出=新的T1（）；
输出=映射类（输入）；
outputList.Add（输出）；
}
返回输出列表；
}

---

这显然不起作用。有没有一种方法可以实现这一点，或者可能有更好的方法？

您必须将一个参数传递给作为适当转换方法的委托的方法

private List<TOutput> MapModelList<TInput, TOutput>(List<TInput> input, Func<TInput, TOutput> mapper)
{
    return input.Select(mapper).ToList();
}

---

您可以使用以下方法创建T2的新实例：

System.Activator.CreateInstance<T2>()

或作为参数表传入映射函数：

private List<T1> MapModelList<T1, T2>(List<T2> inputList, Func<T2> map)

私有列表映射模型列表（列表输入列表，函数映射）

您可以更改方法以获取转换函数

private List<T1> MapModelList<T1, T2>(List<T2> inputList, Func<T2, T1> convert) {
    return inputList.Select(i => convert(i)).ToList();
}

私有列表MapModelList（列表输入列表，函数转换）{
返回inputList.Select（i=>convert（i））.ToList（）；
}

另外，如果让它们都实现相同的接口，那么只需编写一个方法

interface ISomeInterface {
    PropA { get; set; }
    PropB { get; set; }
}

private T MapClass<T>(ISomeInterface inputClass)
    where T : ISomeInterface, new()
{
    T outputClass = new T();
    outputClass.PropA = inputClass.PropA;
    outputClass.PropB = inputClass.PropB;
    ...
    return outputClass;
}

接口接口{
PropA{get；set；}
PropB{get；set；}
}
私有映射类（接口输入类）
其中T:ISomeInterface，new（）
{
T outputClass=新的T（）；
outputClass.PropA=inputClass.PropA；
outputClass.PropB=inputClass.PropB；
...
返回outputClass；
}

公共类MyBaseClass
{
公共虚拟虚空地图（T obj）
{
//在特定类中重写
//使用PropertyInfo映射类的属性
}
}
公共类MyFirstClass:MyBaseClass
{
}
公共类MySecondClass:MyBaseClass
{
}
公共类MyClassFactory
{
public T CreateMyClass（），其中T:MyBaseClass，new（）
{
返回新的T（）；
}
公共列表MapClass（List inputList），其中T1:MyBaseClass，new（）
{
List outputList=新列表（）；
foreach（输入列表中的T2输入）
{
T1输出=CreateMyClass（）；
输出映射（输入）；
outputList.Add（输出）；
}
返回输出列表；
}
}

你可以试试这样的

并且可以作为主要的

class Program
{
    static void Main(string[] args)
    {
        List<MyFirstClass> firstClasses = new List<MyFirstClass>();
        MyFirstClass obj1 = new MyFirstClass();
        MyFirstClass obj2 = new MyFirstClass();
        MyFirstClass obj3 = new MyFirstClass();
        MyFirstClass obj4 = new MyFirstClass();

        firstClasses.Add(obj1);
        firstClasses.Add(obj2);
        firstClasses.Add(obj3);
        firstClasses.Add(obj4);

        var secondClasses = new MyClassFactory().MapClass<MySecondClass, MyFirstClass>(firstClasses);
    }
}

类程序
{
静态void Main（字符串[]参数）
{
List firstClasses=新列表（）；
MyFirstClass obj1=新的MyFirstClass（）；
MyFirstClass obj2=新的MyFirstClass（）；
MyFirstClass obj3=新的MyFirstClass（）；
MyFirstClass obj4=新的MyFirstClass（）；
第一类。添加（obj1）；
第一类。添加（obj2）；
第一类。添加（obj3）；
第一类。添加（obj4）；
var secondClasses=new MyClassFactory（）.MapClass（firstClasses）；
}
}

查看Automapper（），除非我没有正确阅读您的需求，否则可以通过LINQ开箱即用，例如

var listB=listA.Select（item=>your_MAPPING_METHOD（item））.ToList（）@decPL你是对的，我没有意识到这可以用LINQ完成。这让事情简单多了，谢谢！
interface ISomeInterface {
    PropA { get; set; }
    PropB { get; set; }
}

private T MapClass<T>(ISomeInterface inputClass)
    where T : ISomeInterface, new()
{
    T outputClass = new T();
    outputClass.PropA = inputClass.PropA;
    outputClass.PropB = inputClass.PropB;
    ...
    return outputClass;
}

public class MyBaseClass
{
    public virtual void Map<T>(T obj)
    {
        // Override in specific class
        //Use PropertyInfo to map the properties of the class
    }
}

public class MyFirstClass : MyBaseClass
{
}

public class MySecondClass : MyBaseClass
{

}

public class MyClassFactory
{
    public T CreateMyClass<T>() where T : MyBaseClass, new()
    {
        return new T();
    }

    public List<T1> MapClass<T1, T2>(List<T2> inputList) where T1 : MyBaseClass, new()
    {
        List<T1> outputList = new List<T1>();

        foreach (T2 input in inputList)
        {
            T1 output = CreateMyClass<T1>();
            output.Map(input);
            outputList.Add(output);
        }

        return outputList;
    }
}

class Program
{
    static void Main(string[] args)
    {
        List<MyFirstClass> firstClasses = new List<MyFirstClass>();
        MyFirstClass obj1 = new MyFirstClass();
        MyFirstClass obj2 = new MyFirstClass();
        MyFirstClass obj3 = new MyFirstClass();
        MyFirstClass obj4 = new MyFirstClass();

        firstClasses.Add(obj1);
        firstClasses.Add(obj2);
        firstClasses.Add(obj3);
        firstClasses.Add(obj4);

        var secondClasses = new MyClassFactory().MapClass<MySecondClass, MyFirstClass>(firstClasses);
    }
}