C# 将类型变量转换为泛型参数

目前我有这个方法

    public void HandleComponent<T>() where T : IComponent
    {
        // do something with T
    }

组件[i]

需要转换，因为当前这不是通用参数

我必须确保每个

类型

参数都实现了

IComponent

。我知道我可以在方法中检查这一点，但我想防止传递无效参数。因此，该方法必须看起来像（伪代码）

public void HandleComponents（类型[]components），其中components:IComponent
{
对于（int i=0；i

这是不可能的，对吗

完美的解决方案如下所示

public void HandleComponents<AListOfGenericTypes>() where EachGenericListItem : IComponent
{
    for (int i = 0; i < AListOfGenericTypes.Count; i++)
    {
        HandleComponent<AListOfGenericTypes[i]>();
    }
}

public void HandleComponents（），其中每个GenericListItem:IComponent
{
for（int i=0；i

如何使用：

类程序
{
静态void Main（字符串[]参数）
{
IComponent cp1=新组件1（）；//在此处或其他位置创建
IComponent cp2=新组件2（）；//在此处或其他位置创建
IComponent cp3=新组件3（）；//在此处或其他位置创建
手部组件（cp1、cp2、cp3）；
}
私有静态void HandleComponents（参数T[]components），其中T:IComponent
{
foreach（组件中的T组件）
{
手部组件（组件）；
}
}
私有静态无效句柄组件（T组件），其中T:IComponent
{
//用T做任何事
}
}
公共类组件1:IComponent{}
公共类组件2:IComponent{}
公共类组件3:IComponent{}
公共接口IComponent{}

如何使用：

类程序
{
静态void Main（字符串[]参数）
{
IComponent cp1=新组件1（）；//在此处或其他位置创建
IComponent cp2=新组件2（）；//在此处或其他位置创建
IComponent cp3=新组件3（）；//在此处或其他位置创建
手部组件（cp1、cp2、cp3）；
}
私有静态void HandleComponents（参数T[]components），其中T:IComponent
{
foreach（组件中的T组件）
{
手部组件（组件）；
}
}
私有静态无效句柄组件（T组件），其中T:IComponent
{
//用T做任何事
}
}
公共类组件1:IComponent{}
公共类组件2:IComponent{}
公共类组件3:IComponent{}
公共接口IComponent{}
没有思考是不可能的。我建议您重写方法
HandleComponent
：

public void HandleComponent(Type objectType)
{
    // do something with T
}

你可以打电话：

public void HandleComponents(Type[] components)
{
    for (int i = 0; i < components.Length; i++)
    {
        HandleComponent(components[i]);
    }
}

public void HandleComponents（类型[]组件）
{
对于（int i=0；i

反射解决方案：

public void HandleComponents(Type[] components)
{
    var method = this.GetType().GetMethod("HandleComponent");
    for (int i = 0; i < components.Length; i++)
    {
        method.MakeGenericMethod(components[i])
            .Invoke(this, null);
    }
}

public void HandleComponents（类型[]组件）
{
var method=this.GetType（）.GetMethod（“HandleComponent”）；
对于（int i=0；i
没有思考是不可能的。我建议您重写方法
HandleComponent
：

public void HandleComponent(Type objectType)
{
    // do something with T
}

你可以打电话：

public void HandleComponents(Type[] components)
{
    for (int i = 0; i < components.Length; i++)
    {
        HandleComponent(components[i]);
    }
}

public void HandleComponents（类型[]组件）
{
对于（int i=0；i

反射解决方案：

public void HandleComponents(Type[] components)
{
    var method = this.GetType().GetMethod("HandleComponent");
    for (int i = 0; i < components.Length; i++)
    {
        method.MakeGenericMethod(components[i])
            .Invoke(this, null);
    }
}

public void HandleComponents（类型[]组件）
{
var method=this.GetType（）.GetMethod（“HandleComponent”）；
对于（int i=0；i
如果您想这样做，并且能够接受可以传递的组件的实际数量有一个上限，请从
函数
、
操作
和
元组
类型族中汲取灵感，并预热您的复制和粘贴手指：

public void HandleComponent<T>(T component) where T : IComponent
{
    //Real logic
}

public void HandleComponents<T1, T2>(T1 component1, T2 component2)
    where T1 : IComponent
    where T2 : IComponent
{
    HandleComponent(component1);
    HandleComponent(component2);
}

public void HandleComponents<T1, T2, T3>(T1 component1, T2 component2, T3 component3)
    where T1 : IComponent
    where T2 : IComponent
    where T3 : IComponent
{
    HandleComponent(component1);
    HandleComponent(component2);
    HandleComponent(component3);
}

（您需要为这些方法应该进入的任何类编辑第8行，并确保在其他地方将其标记为部分。同时调整名称空间）
如果您想这样做，并且能够接受可以传递的组件的实际数量有一个上限，从
Func
、
Action
和
Tuple
类型系列中汲取灵感，让您的复制和粘贴手指热身：

public void HandleComponent<T>(T component) where T : IComponent
{
    //Real logic
}

public void HandleComponents<T1, T2>(T1 component1, T2 component2)
    where T1 : IComponent
    where T2 : IComponent
{
    HandleComponent(component1);
    HandleComponent(component2);
}

public void HandleComponents<T1, T2, T3>(T1 component1, T2 component2, T3 component3)
    where T1 : IComponent
    where T2 : IComponent
    where T3 : IComponent
{
    HandleComponent(component1);
    HandleComponent(component2);
    HandleComponent(component3);
}

（您需要为这些方法应该进入的任何类编辑第8行，并确保在其他地方将其标记为部分。还要针对名称空间进行调整）
我认为不可能完全实现您想要的，但是，您可以通过使用反射来克服这一问题，并获取泛型HandleComponent方法，并使用传入到HandleComponents方法的类型调用它，只需在for循环中过滤传入的类型，而不是通过泛型约束，因为该方法没有泛型

class Program
{
    public interface IComponent { }
    public class ComponentA : IComponent { }
    public class ComponentB : IComponent { }

    static void Main(string[] args)
    {
        HandleComponents(new[] { typeof(ComponentB), typeof(ComponentA) });
        Console.ReadKey();
    }

    private static void HandleComponent<T>()
        where T : IComponent
    {
        Console.WriteLine(typeof(T));
    }

    private static void HandleComponents(Type[] components)
    {
        var m = typeof(Program).GetMethod("HandleComponent", BindingFlags.NonPublic | BindingFlags.Static);
        foreach (var component in components)
        {
            if (typeof(IComponent).IsAssignableFrom(component))
            {
                var genericMethod = m.MakeGenericMethod(component);
                genericMethod.Invoke(null, null);
            }
        }
    }
}

类程序
{
公共接口IComponent{}
公共类组件A:IComponent{}
公共类组件B:IComponent{}
静态void Main（字符串[]参数）
{
HandleComponents（新[]{typeof（ComponentB），typeof（ComponentA）}）；
Console.ReadKey（）；
}
私有静态void HandleComponent（）
其中T:i组件
{
控制台写入线（类型为（T））；
}
专用静态void HandleComponents（类型[]组件）
{
var m=typeof（Program）.GetMethod（“HandleComponent”，BindingFlags.NonPublic | BindingFlags.Static）；
foreach（组件中的var组件）
{
if（类型（IComponent）.IsAssignableFrom（component））
{
var genericMethod=m.MakeGenericMethod（组件）；
调用（null，null）；
}
}
}
}
我认为不可能完全实现你想要的，但你可以
class Program
{
    public interface IComponent { }
    public class ComponentA : IComponent { }
    public class ComponentB : IComponent { }

    static void Main(string[] args)
    {
        HandleComponents(new[] { typeof(ComponentB), typeof(ComponentA) });
        Console.ReadKey();
    }

    private static void HandleComponent<T>()
        where T : IComponent
    {
        Console.WriteLine(typeof(T));
    }

    private static void HandleComponents(Type[] components)
    {
        var m = typeof(Program).GetMethod("HandleComponent", BindingFlags.NonPublic | BindingFlags.Static);
        foreach (var component in components)
        {
            if (typeof(IComponent).IsAssignableFrom(component))
            {
                var genericMethod = m.MakeGenericMethod(component);
                genericMethod.Invoke(null, null);
            }
        }
    }
}