Question

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

 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

Example on DotNetFiddle

使用基类进行C＃接口类型转换

2 个答案: