Question

我有两个派生类（Sale和ServiceCharge）。两者都是交易。如果我有BusinessService，我想为它创建一个ServiceCharge。如果我传递产品，我想实例化销售。

这是我的想法。

private void CreateInstance(object element)
{
    Transaction transaction;
    if (element.GetType() == typeof(BussinessService))
    {
        transaction = new ServiceCharge((BussinessService)element))
    }
    else
    {
        transaction = new Sale((Product)element);
    }
{

你能告诉我一个更优雅的方式吗？我知道如何只用一个构造函数来使用泛型

private void CreateInstance<T>(T element)
{
   Transaction transaction = new Transaction((T)element);
}

但我不知道如何解决第一种情况。

Answer 1

定义如下通用界面：

public interface ITransactionable<T>
    where T : Transaction
{
    T CreateTransaction();
}

将您的BussinessService和Product装饰为：

public class BussinessService :
    ITransactionable<ServiceCharge>
{
    public T CreateTransaction() 
    { 
        return new ServiceCharge(this);
    }
}

public class Product :
    ITransactionable<Sale>
{
    public T CreateTransaction() 
    { 
        return new Sale(this);
    }
}

现在您的通用方法可以定义为：

private void CreateInstance<T>(ITransactionable<T> element)
{
   Transaction transaction = element.CreateTransaction();
   ...
}

Answer 2

在这种情况下，简单的界面也可以起作用：

interface ITransactionable
{
    Transaction CreateTransaction();
}

class BusinessService : ITransactionable
{
    public Transaction CreateTransaction() { return new ServiceCharge( this ); }
}

class Product : ITransactionable
{
    public Transaction CreateTransaction() { return new Sale( this ); }
}

private void CreateInstance(ITransactionable element)
{
   Transaction transaction = element.CreateTransaction();
   ...
}

Answer 3

只需创建两种不同的方法：

private void CreateInstance(Product product)
{
    Transaction transaction = new Sale(product);
}
private void CreateInstance(BusinessService service)
{
    Transaction transaction = new ServiceCharge(service);
}

编译器将根据您使用的参数类型知道您调用的方法。

Answer 4

BusinessService和Product在某种程度上应该是多态的，可能是通过共享界面，像

这样的

interface IChargable<out T> where T : Transaction
{
    Transaction Charge();
}

这样实现的界面，

class BusinessService : IChargable<ServiceCharge>
{
    public ServiceCharge Charge()
    {
        return new ServiceCharge(...
    }
}

class Product : IChargable<Sale>
{
    public Sale Charge()
    {
        return new Sale(...
    }
}

这意味着像这样的代码可以正常工作

var chargables = new IChargable<Transaction>[]
    {
        new BusinessService(),
        new Product()
    };

var transactions = chargables.Select(c => c.Charge());

Answer 5

为什么要使用泛型？这不是多态性的意义吗？（对我自己的理解感到好奇）

public interface ITransactionable
{
    Transaction CreateTransaction();
}

public class BussinessService : ITransactionable
{
    public Transaction CreateTransaction() 
    { 
        return new ServiceCharge();
    }
}

public class Product : ITransactionable
{
    public Transaction CreateTransaction() 
    { 
        return new Sale();
    }
}

一个优雅的方式来做到这一点？可能是泛型？

5 个答案: