这是动态类的情况还是......？

Question

我什至不确定要搜索有关此问题的内容，所以我想我会将其发布在这里。

假设我有一堆接口，例如...

/// <summary>
/// All interesting classes will implement this interface
/// </summary>
interface IMasterInterface {}

/// <summary>
/// Interface to represent someone that creates / produces goods
/// </summary>
interface IProduceGoods : IMasterInterface { int Prop1 {get;} }

/// <summary>
/// Interface to represent someone that buys / consumes goods
/// </summary>
interface IConsumeGoods : IMasterInterface { int Prop2 {get;} }

/// <summary>
/// Interface to represent someone that stores goods
/// </summary>
interface IStoreGoods : IMasterInterface { double Prop3 {get;} string name {get;}}

/// <summary>
/// Interface to represent someone that enjoys looking at goods
/// </summary>
interface IEnjoyLookingAtGoods : IMasterInterface { int Prop4 {get;} DateTime Prop5 {get;} }

现在，我有一些我知道今天想要的组合，例如：

/// <summary>
/// Class to represent a farm which grows and stores crops
/// </summary>
class Farm : IProduceGoods, IStoreGoods {/*...*/}

/// <summary>
/// Class to represent a merchant who buys goods and stores them
/// </summary>
class Merchant : IConsumeGoods, IStoreGoods {/*...*/}

/// <summary>
/// Window Shopper represents someone who doesn't buy anything and only looks
/// </summary>
class WindowShopper : IEnjoyLookingAtGoods{ /*...*/ }

现在我很高兴我已经有了我的几个课程，但我认为明天不会最好还有一个有人实际上从商家那里购买的课程，所以我会转到我的代码并添加

/// <summary>
/// Princesses have lots of money to buy stuff and lots of time to look at stuff
/// </summary>
class Princess : IEnjoyLookingAtGoods, IConsumeGoods {/*...*/}

现在，我认为我不应该这样做......

我想做的是工厂（或类似）的东西并说：

IMasterInterface princess = MyFactory.Create(IEnjoyLookingAtGoods, IEnjoyLookingAtGoodsParameters, IConsumeGoods, IConsumeGoodsParameters)

/// This should be true
((princess is IEnjoyLookingAtGoods) && (princess is IConsumeGoods))

本质上，我会比如告诉工厂使用哪些接口来构造对象。我有包含 IMasterInterface 列表的容器

/// <summary>
/// My container class for interesting objects
/// </summary>
class InterestingObjectContainer
{ public ReadOnlyCollection<IMasterInterface> InterestingObjects {get;} }

现在，这就是问题的关键所在。让所有有趣的类实现 IMasterInterface 的原因是能够拥有一个 List 并使用更具体的接口作为过滤器。也许下面的内容会让它更清楚：

/// <summary>
/// I want to see the net population of producers and get there total production
/// </summary>
class ProducerProductionCalculator
{
  // THIS IS WHERE THE MEAT OF THE QUESTION RESIDES!
  ProductionResults Calculate(InterestingObjectContainer interestingObject)
  {
    List<IProduceGoods> producers = interestingObject.InterestingObjects.OfType<IProduceGoods>(); // Perhaps more interest LINQ
    return DoSomethingWithListToAggregate(producers);
  }
}

通过过滤出更具体的接口，我现在可以依赖传递给的所有对象 DoSomethingWithListToAggregate（ICollection 生产者） 具有 IProduceGoods 类的方法/属性。

我考虑过用字典和字符串属性查找来实现这一点，但感觉我可以用这种方式编写更强类型的代码，并确保某个地方的简单拼写错误不会把一切搞砸。

不管怎样，我想总结是：

这是在对象上实现变量属性的一种糟糕的方法吗？如果是的话，什么会更好。如果没有，有没有办法像我上面尝试解释的那样在工厂中创建对象？

编辑：

我认为这样做的想法有些好，这很酷。我想知道如何创建一个工厂，它接受一个仅具有属性的接口的参数，并且该属性仅具有 getters （我认为这是很重要的一点）以及属性的属性值，并返回一个实现该接口并具有所有属性的对象定义的属性。

例如，

/// <summary>
/// Factory to create any combination of properties
/// </summary>
class FactoryForInterestingObjects
{
  public static IMasterInterface Create(
  List<KeyValuePair</*what goes here is the interface that I want to use,
                      what goes here are the parameter values that 
                      should be returned by the getter */>> );
}

我将向工厂传递所有接口及其参数值，它将创建一些实现这些接口并具有这些值的类。希望这更清楚一点？

编辑2：如何使用装饰器？

根据我对装饰器的了解，您可以扩展对象的功能。这很酷。但是，您必须提前知道如何扩展该功能。你不能随意这样做。

考虑到我的代码库如上所述，我想使用装饰器。

我会说：

// Edited to be correct
class EnjoyLookingDecorator : IEnjoyLookingAtGoods
{
  private IMasterInterface instance;
  public EnjoyLookingDecorator(IMasterInterface wrappedObject)
  { this.instance = wrapped Object;}

  #region Implementation of IEnjoyLookingAtGoods
  /*...*/
  #endregion
}

编辑4：

我仍然认为这行不通。在您的示例中，我丢失了包含的类接口，我必须将其重定向。例如，

class EnjoyLookingDecorator : IEnjoyLookingAtGoods
{
  private IMasterInterface instance;
  public EnjoyLookingDecorator(IMasterInterface concrete)
  { this.instance = concrete;}

  #region Implementation of IEnjoyLookingAtGoods here
  /*...*/
  #endregion

  bool Is<T>() //this should be in the IMasterInterface
  {
     return this is T or instance is T;
  }
}

class ConsumesGoodsDecorator : IConsumeGoods
{
  private IMasterInterface instance;
  public ConsumesGoodsDecorator (IMasterInterface concrete)
  { this.instance = concrete;}

  #region Implementation of IConsumeGoods here
  /*...*/
  #endregion

  bool Is<T>()
  {
     return this is T or instance is T;
  }
}

当您

IMasterInterface princess = new MasterClass() //whatever your concrete type is named
princess = new ConsumesGoodsDecorator(new EnjoyLookingDecorator(princess))

不再可以执行 princess.PropertyOnIEnjoyLookingDecoratorInterface 时，您将丢失所有这些属性。这不是我想要的。保留属性的唯一方法是重定向

class ConsumesGoodsDecorator : IConsumeGoods, IEnjoyLookingAtGoods
{
  private IMasterInterface instance;
  public ConsumesGoodsDecorator (IMasterInterface concrete)
  { this.instance = concrete;}

  #region Implementation of IConsumeGoods here
  /*...*/
  #endregion

  #region Redirect all the IEnjoyLookingAtGoods Property Getters to instance
  /* ... */
  #endregion

  bool Is<T>()
  {
     return this is T or instance is T;
  }
}

通过执行重定向，我们必须实现接口。然后这些组合都必须有代码，这是我试图避免的。我对接口的组合没有限制。

编辑5：

也许我的问题仍然不清楚。想象一下上面的接口，并填充了它们的属性。

如果工厂可以做这样的事情：

/// <summary>
/// Factory to create any combination of properties
/// </summary>
class FactoryForInterestingObjects
{
  public static IMasterInterface Create(
    List<KeyValuePair<Type t, ArgSet customArguments>> interfaces))
  {
    object baseObject;
    foreach(KeyValuePair<Type, ArgSet> interface in interfaces)
    {
       AddInterface(interface, object);
    }
  }

  private static void AddInterface(KeyValuePair<Type, ArgSet> interface, ArgSet arguments)
  {
     // Delegate this to someone else
     if(interface.Key is typeof(IProduceGoods))
     {
       IProduceGoodsExtensions.AddInterface(o, interface.value);
     }
  }
}

public static class IProduceGoodsExtensions
{
   public static void AddInterface(object o, ArgSet arguments)
   {
      // do something to object to make it implement IProductGoods
      // and make all the getters return the arguments passed in ArgSet
   }
}

我意识到这不是它实际工作的方式，但说明了我想要表达的观点。我希望该对象实现接口的动态组合并具有设置器的默认值。

即使我可以做一些事情，比如让工厂编写一个包含代码的文本文件：

/// <summary>
/// Auto Generated by Factory to create a new type on the fly
/// </summary>
class ClassImplementingIProduceGoodsAndIEnjoyLookingAtGoods : IProduceGoods, IEnjoyLookingAtGoods
{
  // From IProduceGoods
  public int Prop1 {get; private set;}
  // From IEnjoyLookingAtGoods
  public int Prop4 {get; private set;}
  public DateTime Prop5 {get; private set;}
  public ClassImplementingIProduceGoodsAndIEnjoyLookingAtGoods(int prop1, int Prop4 , DateTime Prop5)
  {
    this.Prop1 = prop1; this.Prop4 = Prop4; this.Prop5 = Prop5;
  }
}

然后编译该类并以某种方式允许我创建它的实例。这就是我正在寻找的。希望这更有意义。

编辑6：

这是我可能会采用的解决方案，因为我目前没有看到替代方案。

//Update Master Interface
interface IMasterInterface
{
   bool Is(Type t);
   IMasterInterface As(Type t);
}

/// <summary>
/// Class to build up a final object
/// </summary>
class CompositionObject : IMasterInterface
{
  ICollection<IMasterInterface> parts;
  CompositionObject(IMasterInterface object){ parts = new List<IMasterInterface(object);}
  bool Is(Type t)
  {
     foreach(IMasterInterface part in parts)
     { if (part is t) return true; // not sure on this off top of head
     }
      return false;
  }

  IMasterInterface As(Type t)
  {
    foreach(IMasterInterface part in parts)
    { if(part is t) return part; }
  }

  bool Add(IMasterInterface interface)
  { this.Is(typeof(interface)) return false; // don't add again
    this.parts.Add(interface) }
}

现在我的工厂可以返回这些组合对象，只要调用 As ，我就可以安全地向下转型。我觉得可能有一种方法可以使用泛型来避免强制转换。

任何实现 IMasterInterface 的具体类都可以在调用 As 时简单地返回自身。

编辑3：

感谢大家的评论。我很高兴我表达了我对模式的无知；D 感谢您的澄清！我喜欢这个网站和那里所有可爱的人！

Answer 1

尝试研究装饰设计模式。据我所知，它适用于您想到的那种情况，即可以包含从一组属性中提取的一组混合属性的对象。在装饰器模型中，每个属性都是它自己的一个类，您可以有效地动态连接这些类以创建具有所需属性的对象。

要实现过滤，您需要某种迭代器来遍历装饰器链，以查看您要查找的装饰器是否包含在您正在测试的对象中。

我没有在 C# 中使用过 Decorator，只在 C++ 中使用过，但我发现它是一种非常有用且灵活的前进方式。如果您发现自己创造了更多&更专业的类代表“属性”类的交集，那么我认为装饰器可能会很有帮助。

有关此模式的信息，请参阅C# 中的装饰器设计模式。 （并购买并阅读《GoF 设计模式》一书！）

Answer 2

根据您的更新，我发现您似乎不理解装饰器模式。

我不知道这是否是最好的方法，就好像您的行为没有任何差异并且您的接口是静态的（IenjoyLookingAtGoods、IConsumeGoods 等）您可以继续并使用抽象上的属性来实现这些输入，然后通过设置它们来创建新实例。

装饰器应该是这样的

class EnjoyLookingDecorator : IEnjoyLookingAtGoods
{
  private IMasterInterface instance;
  public EnjoyLookingDecorator(IMasterInterface concrete)
  { this.instance = concrete;}

  #region Implementation of IEnjoyLookingAtGoods here
  /*...*/
  #endregion

  bool Is<T>() //this should be in the IMasterInterface
  {
     return this is T || instance.Is<T>();
  }
}

class ConsumesGoodsDecorator : IConsumeGoods
{
  private IMasterInterface instance;
  public ConsumesGoodsDecorator (IMasterInterface concrete)
  { this.instance = concrete;}

  #region Implementation of IConsumeGoods here
  /*...*/
  #endregion

  bool Is<T>()
  {
     return this is T || instance.Is<T>();
  }
}

，如果你想得到实现两者的东西，你需要做这样的事情：

IMasterInterface princess = new MasterClass() //whatever your concrete type is named
princess = new ConsumesGoodsDecorator(new EnjoyLookingDecorator(princess))
var b = princess.Is<IEnjoysLookingAtGoods>()

编辑-
你可以像这样破解它：

  T As<T>()
  {
     return this is T ? this : instance.As<T>(); /*be careful here, the implementation in the concrete class should return null if he is not a T*/
  }

  /*continuing the example above*/
    var consumer = princess.As<IConsumesGoods>(); //this is good
    var producer = princess.As<IProducesGoods>(); //this will return null

但这很令人讨厌，我读你的问题最多，最似乎这些接口没有意义。您根本没有添加行为。
如果您不希望公主拥有 IProduceGoods，那么为什么不拥有一个实现 IMasterInterface 并具有 4 个具有不同接口（组合）的属性的类，请将其设置为 null。 仍然很难弄清楚

如果没有上下文HTH

Answer 3

我不喜欢 IMasterInterface 概念，但假设您只是使用抽象术语来表达问题 - 我可以看到这一点。我对你的例子中的用法也有一个小小的疑问：

IMasterInterface princess = MyFactory.Create(IEnjoyLookingAtGoods, IEnjoyLookingAtGoodsParameters, IConsumeGoods, IConsumeGoodsParameters)

/// This should be true
((princess is IEnjoyLookingAtGoods) && (princess is IConsumeGoods))

“公主”不应该是“喜欢看起来和消费商品的东西”吗？

除此之外，我认为过滤实现的接口类型的方法很好。

Answer 4

这是一个好办法。而且，坦率地说，我不认为它有任何问题。接口只是接口 - 它们仅提供一种描述一组公共成员的方法。问题是你的问题很笼统，很难理解你想要实现的目标。

接受接口的工厂方法很奇怪。例如，我们有以下代码：

public class A : IFoo { }
public class B : IFoo { }

var x = MyFactory.Create(IFoo);

工厂会创建什么？ A 或 B 的实例？

无论如何，我认为我能提出的最好建议是：不要想太多。

Answer 5

回答有关工厂的问题，您可以使用反射和/或原型模式来完成，但前提是接口的组合是唯一的。如果您有多个具体类可以满足所请求的接口列表（例如，Prices 和 Prince 类），那么工厂将无法知道要创建哪一个。

如果没有具体的类，并且您确实尝试在运行时创建/组合/等对象，那么那就是一匹不同颜色的马。您可能需要一个公共基类（或者可能在您的主界面中提供支持）来协助使用（正如另一张海报所建议的）装饰器方法，或者可能使用构面类型模式。