1

我有混乱的情况。

基本通用类型和继任者

public abstract class BaseType<TEntity> : where TEntity : BaseType<TEntity>
public class AnyType : BaseType<AnyType>

它看起来像一个通用循环）））

我需要类似的方法

public void Method<T>(T data)
{
if(typeof(T).IsSubclassOf(BaseType<????>))
 convert data to BaseType<???> and exec BaseType<>'s method
else
//Do that
}

在通用方法中，我需要定义 T 是 BaseType 和它的 exec 方法。我怎样才能做到这一点？？？？

4

3 回答 3

1

您可以使用以下代码：

static bool IsBaseType<T>()
{
    var t = typeof(T);

    do
    {
        if (t.IsGenericType && t.GetGenericTypeDefinition() == typeof(BaseType<>))
        {
            return true;
        }

        t = t.BaseType;
    }
    while (t != null);

    return false;
}
于 2010-07-22T10:21:48.247 回答
1

您可以使用反射并使用Type.BaseType. 请注意，根据具体的具体类，基类型仍然可以是开放的泛型类型，例如

class Foo<T> : BaseType<T>

您可以使用Type.IsGenericTypeDefinition和Type.GetGenericTypeDefinition尝试按照自己的方式工作BaseType<>。基本上，您想找出继承层次结构中的任何类是否具有泛型类型定义，即typeof(BaseType<>). 很高兴您没有处理接口，这使整个事情变得更加困难:)

于 2010-07-22T10:16:14.843 回答
0

在这种情况下，一个常见的模式是具有泛型基类型的非泛型基类型。如果您的方法不涉及类型参数，那么您就完成了。如果是这样，您可以添加一个执行类型转换的非泛型方法，类似于 Object.Equals：

public abstract class ReallyBaseType
{
    public abstract void SomeMethod();
    public abstract void SomeMethodWithParameter(object o);
}

public abstract class BaseType<TEntity> : ReallyBaseType
    where TEntity : BaseType<TEntity>
{
    public override void SomeMethodWithParameter(object o)
    {
        SomeMethodWithParameter((TEntity)o);
    }

    public abstract void SomeMethodWithParameter(TEntity entity);
}

public class AnyType : BaseType<AnyType>
{
    public override void SomeMethod() { }

    public override void SomeMethodWithParameter(AnyType entity) { }
}

然后，您可以检查数据的实际类型：

public void Method<T>(T data)
{
    if (data is ReallyBaseType)
    {
        ((ReallyBaseType)(object)data).SomeMethod();
    }
}

编辑：那么，我认为你被困住了。如果您希望能够针对具体类型编写代码，您可以创建一个泛型方法并使用反射调用它：

public class TestClass
{
    private static MethodInfo innerMethodDefinition =
        typeof(TestClass).GetMethod("InnerMethod");

    public void Method(object data)
    {
        var t = data.GetType();
        while (t != null &&
            !(t.IsGenericType &&
            t.GetGenericTypeDefinition() == typeof(BaseType<>)))
        {
            t = t.BaseType;
        }
        if (t != null &&
            t.GetGenericArguments()[0].IsAssignableFrom(data.GetType()))
        {
            innerMethodDefinition.MakeGenericMethod(
                t.GetGenericArguments()[0]).Invoke(this, new object[] { data });
        }
    }


    public void InnerMethod<TEntity>(TEntity data)
        where TEntity : BaseType<TEntity>
    {
        // Here you have the object with the correct type
    }
}
于 2010-07-22T11:51:52.773 回答