0

用一个例子可以更好地解释这一点。目前我有这样的事情：

public class Car {
    internal string SaleCode {get; set;} //Spring, Summer, ...
    public string Name {get; set; }  //Model name
}

public interface ICarFactory 
{
    Car GetSummerSaleCar();
    Car GetSpringSaleCar();
}

public class FordFactory : ICarFactory 
{
    public Car GetSummerSaleCar() {
        return new Car() {Name="Fiesta"};
    }
    public Car GetSpringSaleCar() {
        return new Car() {Name="Fusion"};
    }
}

public class CarProvider {
    public void ProduceCars(ICarFactory factory) {
        var inventory = new List<Car>();
        Car car = null;
        car = factory.GetSummerSaleCar();
        car.SaleCode = "SMR";
        inventory.Add(car);

        car = factory.GetSpringSaleCar();
        car.SaleCode = "SPG";
        inventory.Add(car);
    }
}

对于每个方法，汽车的 SaleCode 应始终相同，因此 CarFactory 实现不应设置此值。现在我在 CarProvider 类中设置了它，但我想知道是否有办法将它从界面中取出。我唯一能想到的就是使用一个属性应用于接口内的方法定义，我可以在其中设置类型，但我觉得必须有另一种选择。

想法？

更新

如果您想知道，当我提到为接口中的每个方法添加属性时，这就是我所说的：

public class SaleAttribute : Attribute
{
    public string Code { get; set; }
}


public interface ICarFactory
{
    [Sale(Code = "SMR")]
    Car GetSummerSaleCar();
    [Sale(Code = "SPG")]
    Car GetSpringSaleCar();
}

public void ProduceCars(ICarFactory factory)
{
    var inventory = new List<Car>();
    foreach (var method in typeof(ICarFactory).GetMethods())
    {
        String carType = null;
        var attributes = method.GetCustomAttributes(typeof(SaleAttribute), false);
        if (attributes.Length == 1)
        {
            saleCode = ((SaleAttribute)attributes[0]).Name;
            Car car = (Car)method.Invoke(factory, null);
            car.SaleCode = saleCode;
            inventory.Add(car);
        }
    }
}

这有一个额外的好处，即如果在接口中添加方法，则 CarProvider 不需要修改。缺点显然是与反射相关的开销（性能和维护）。

更新2

我将示例从使用汽车类型更改为销售代码，因为这更好地反映了我的情况。

4

2 回答 2

3

Mike 我认为最好的方法是拥有一个抽象类型 Car 和两个派生类：CompactCar 和 MediumCar。

public abstract class Car { 
    internal string Type {get; protected set;} //Compact, Medium, Large, ... 
    public string Name {get; set; }  //Model name 
} 

public class CompactCar : Car
{
     public CompactCar() { this.Type = "Compact"; }
}

public class MediumCar : Car
{
     public MediumCar() { this.Type = "Compact"; }
}

因此，您可以返回特定类型，例如：

public interface ICarFactory      
{     
    CompactCar GetCompact();     
    MediumCar GetMedium();     
}  
public class FordFactory : ICarFactory    
{   
    public CompactCar GetCompact() {   
        return new CompactCar() {Name="Fiesta"};   
    }   
    public MediumCar GetMedium() {   
        return new MediumCar() {Name="Fusion"};   
    }   
}

这对使用它的源代码影响最小，因为它仍然可以引用具有抽象类型 Car 的汽车。

于 2012-05-04T19:22:11.453 回答
0

CarType.Create(Medium)代替呢new Car？

我建议一个工厂叫CarType

public class CarType{
   public class CarType(instName){
      this.instName = instName;
   }
   public Car Create(){
      return new Car(){Type=instName;}
      //or alternatively, if you have more implementations for the cars
      //return (Car)Activator.CreateInstance(this.instName);
   }
   public static CarType Compact = new CarType("Compact");
   public static CarType Medium = new CarType("Medium");
}

用法是

Medium.Create(){Name="Fiesta";}

但这仍然在 CarFactorys 方法中，所以对你没有多大帮助......

于 2012-05-04T19:11:49.953 回答