如何在 C# 中使用泛型返回接口

Question

我是 C# 泛型概念的新手，我想使用泛型概念返回接口实现类。下面是我目前没有泛型实现的示例：

1）返回接口的工厂类，该类有两个接受不同数据模型的重载方法：

public class Factory
{
    public ICommon Init(DBInfoData dbInfoData)
    {
        return new ClassA(dbInfoData);
    }

    public ICommon Init(WebInfoData webInfoData)
    {
        return new ClassB(webInfoData);
    }
}

2) 接口和接口实现两个类如下：

//=== Common Interface
public interface ICommon
{
    void MethodA();
    void MethodB();
}

//=== Internal access only ClassA
internal class ClassA : ICommon
{
    private DBInfoData _DBInfoData = null;
    public ClassA(DBInfoData dbInfoData)
    {
        _DBInfoData = dbInfoData;
    }

    public void MethodA()
    {
        throw new NotImplementedException();
    }

    public void MethodB()
    {
        throw new NotImplementedException();
    }
}

//=== Internal access only ClassB
internal class ClassB : ICommon
{
    private WebInfoData _WebInfoData = null;

    public ClassB(WebInfoData webInfoData)
    {
        _WebInfoData = webInfoData;
    }

    public void MethodA()
    {
        throw new NotImplementedException();
    }

    public void MethodB()
    {
        throw new NotImplementedException();
    }
}

3) 数据模型类如下：

//=== Database Information
public class DBInfoData
{
    public string Server { get; set; }
    public string Database { get; set; }
}

//=== Web Server Information
public class WebInfoData
{
    public string URL { get; set; }
    public int Port { get; set; }
}

现在我想实现 C# 的通用功能，在工厂类中我不想声明两个重载方法。使用单一方法，我可以根据数据模型传递返回 ClassA 或 ClassB。

Answer 1

您可以编辑Init 方法，而无需编辑任何其他内容。此方法将采用泛型类型参数T，它可以是任何类型。然后你可以使用is 操作符，它根据docs 用于类型测试。但是，您需要检查 T 的任何不受支持的类型，因为您没有向传递的泛型类型添加任何约束。一个原始的实现是：

public class Factory
{
    public ICommon Init<T>(T infoData)
    {
        if (infoData is DBInfoData dbInfoData) {
            return new ClassA(dbInfoData);
        }
        if (infoData is WebInfoData webInfoData) {
            return new ClassB(webInfoData);
        }

        throw new Exception($"Cannot create instance for info data of type {infoData.GetType().Name}");
    }
}

并对其进行测试：

    var factory = new Factory();

    var t1 = factory.Init(new DBInfoData()); // will be ClassA
    var t2 = factory.Init(new WebInfoData()); // ClassB

为了使其更加复杂，您可以在泛型 T 类中引入 type constraint，以确保您只能传递适当的类型。对于当前情况，您可以通过引入一个空接口例如IInfoData 为您的类DBInfoData 和WebInfoData 创建一个marker interface。然后你必须像这样继承你的类：

public interface IInfoData {}

public class DBInfoData : IInfoData
{
    public string Server { get; set; }
    public string Database { get; set; }
}

public class WebInfoData : IInfoData
{
    public string URL { get; set; }
    public int Port { get; set; }
}

现在两者都继承自（实际上是“标记为”）您的基本接口。通过添加我在上面链接的文档中显示的约束，向您的工厂引入一个约束，以仅允许 IInfoData 的后代作为参数传递（因此 DBInfoData 或 WebInfoData）：

public class Factory
{
    public ICommon Init<T>(T infoData) where T: IInfoData
    {
        if (infoData is DBInfoData dbInfoData) {
            return new ClassA(dbInfoData);
        }
        if (infoData is WebInfoData webInfoData) {
            return new ClassB(webInfoData);
        }

        throw new Exception($"Cannot create instance for info data of type {infoData.GetType().Name}");
    }
}

IInfoData 的后代以外的任何类型都会导致编译错误，您就完成了。像我之前的例子一样使用它：

    var factory = new Factory();

    var t1 = factory.Init(new DBInfoData()); // will be ClassA
    var t2 = factory.Init(new WebInfoData()); // ClassB