使用基类的 C# 接口类型转换

Question

嗨，我想知道是否可以通过以下方式在 Interface 及其具体实现中转换类型。

 public class BaseTypeClass

 public class BaseTypeV1 : BaseTypeClass

 public class BaseTypeV2 : BaseTypeClass

 public class BaseTypeV3 : BaseTypeClass



 public interface IProcessBaseType<T> where T : BaseTypeClass

      void Process(T baseType)



 public class ProcessBassTypeClass : IProcessBassType

      void Process(BaseTypeV1 data)

      void Process(BaseTypeV2 data)

      void Process(BaseTypeV3 data)

Answer 1

就像这样做一样简单：

public class ProcessBassTypeClass : IProcessBaseType<BaseTypeV1>, IProcessBaseType<BaseTypeV2>, IProcessBaseType<BaseTypeV3>
{
    public void Process(BaseTypeV1 baseType)
    {
        throw new NotImplementedException();
    }

    public void Process(BaseTypeV2 baseType)
    {
        throw new NotImplementedException();
    }

    public void Process(BaseTypeV3 baseType)
    {
        throw new NotImplementedException();
    }
}

您可能要考虑的另一种方法是：

public interface IProcessBaseType
{
    void Process<T>(T baseType) where T : BaseTypeClass;
}

public class ProcessBassTypeClass : IProcessBaseType
{
    public void Process<T>(T baseType) where T : BaseTypeClass
    {
        throw new NotImplementedException();
    }
}

这允许传递BaseTypeClass类型的任何对象，并允许Process调用typeof(T)以在运行时获取实际类型。 如果要动态构建可用的处理器列表，则很有用。

---

这是一个简单的示例，说明如何在使用第二个代码示例时在运行时添加特定于类型的处理器：

public class ProcessBassTypeClass : IProcessBaseType
{
    private Dictionary<Type, Delegate> _processors = new Dictionary<Type, Delegate>();

    public void AttachProcessor<T>(Action<T> processor) where T : BaseTypeClass
    {
        _processors[typeof(T)] = processor;
    }

    public void Process<T>(T baseType) where T : BaseTypeClass
    {
        if (_processors.ContainsKey(typeof(T)))
        {
            ((Action<T>)(_processors[typeof(T)])).Invoke(baseType);
        }
        else
        {
            throw new NotSupportedException();
        }
    }
}

Answer 2

没有IProcessBaseType这样的接口，它与IProcessBaseType<T>是不同的类型。

如果将其添加为通用接口，则可以做出解决方案：

public interface IProcessBaseType
{
    void Process(BaseTypeClass baseType);
}

public interface IProcessBaseType<T> : IProcessBaseType where T : BaseTypeClass
{
      void Process(T baseType);
}

现在你可以这样做：

public class ProcessBassTypeClass : IProcessBaseType
{
    public void Process(BaseTypeClass data)
    {
        Console.WriteLine("Processing as BaseTypeClass");
    }
    public void Process<T>(T data)
    {
        Console.WriteLine("Processing as generic with T = {0}", typeof(T).Name);
    }
}

测试程序：

public class MyProgram 
{ 
    static public void Main(string[] args) 
    {
        var processor = new ProcessBassTypeClass();

        processor.Process( new BaseTypeClass() );
        processor.Process( new BaseTypeV1() );
        processor.Process( new BaseTypeV2() );
        processor.Process( new BaseTypeV3() );
    } 
} 

输出：

Processing as BaseTypeClass
Processing as generic with T = BaseTypeV1
Processing as generic with T = BaseTypeV2
Processing as generic with T = BaseTypeV3

DotNetFiddle 上的示例