c# - 如何向工厂模式添加新的派生类型？

Question

给定基类型 A

以及三种派生类型乙:甲丙:甲D:A

我有一个项目 P。我想要一个列表来表示 A 在 P 中的出现。

有一个从P中提取B的策略，我想成为B类的一部分。有一个从 P 中提取 Cs 的策略，我想成为 C 类的一部分。ETC。我希望它们都列在一个大列表中。

我希望以后能够添加一个 E : A 类，尽可能少地接触。在 A 上有一个虚拟静态工厂方法接受 P 的实例作为参数会很酷，这将多态地运行派生类中的所有静态重载，例如 C 中的重载将从 P 中提取 Cs 并将它们放入 List 中。当然，C# 中不存在虚拟静态方法之类的东西。

我无法立即看到如何实现它，以便可以添加类 D:A 和 E:A 而无需触及基类或一些持续更新的具有具体依赖性的“上帝方法”工厂方法每个派生类型。

这里有点晚了，所以我可能遗漏了一些明显的东西。你的想法？

编辑:

我的具体案例是我有一个由控制模块组成的过程工厂控制系统。我希望能够识别某些更高级别的构造，例如控制回路、反馈调整等。识别和管理这些构造的逻辑特定于所讨论的单个构造类型。简而言之，我想捆绑用于识别和处理结构的代码。

让我们考虑一个类比。我有一个文本文档。其中有单词的类型。字是“基”型“A”。文本文档是“P”项目。我可以实现单词类型“名词”和“动词”。在文本中识别“名词”的方式是特定于“名词”的，代码应该如此。随着越来越多的类型被实现并因此在文本中被识别，列表变得更长。

对我来说，在名词类中实现它是有意义的:

 static function IEnumerable<noun> IdentifyAll (P project)

然后做一个

CompleteWordList.AddRange(noun.IdentifyAll(p));

在初始化期间，但这会从中央初始化/工厂方法创建对特定“名词”类型的依赖。如果不触及它，就很难添加更多的词类。在撰写本文时，我觉得自己有点倾向于 MEF。

这是一个简单的例子。也许“短语”或其他东西对于基本类型来说是更合适的类比，但现在必须这样做。

尽管这些项目是由具有可检查属性的连接控制节点组成的网络(而不是文本文档)，但它非常像一个解析器。如果我有一些通用的解决方案，那就太好了。

Answer 1

好的，我想我现在明白了。如果我理解，您想获取一个从 A 派生的类型的对象并确定其实际类型(比如 B)，但工厂不知道如何对其进行分类作为 B。然后您应该能够在将来引入任意数量的 A 子类型，而无需为每个新类型修改工厂。

有人 知道如何从A 到B。如果它不是工厂，那么它一定是 B 本身。我看到您已经走上了这条路，并认为“我需要一个虚拟工厂方法，以便 A 的每个子类型都可以提供规范来标识自己。”

正如您所说，虚拟静态方法不存在，因此您无法按照您的想法进行操作。但是为什么不使用实例方法呢？

只要项目包含所有已知子类型的列表，它就可以简单地遍历这些类型，创建它们的实例并询问它们“这个对象是你们中的一员吗？”。如果它说"is"，那么您可以要求它“给我一个与此基本类型实例等效的您的实例”。 (这听起来效率低下；当然，在实践中，您可以只保留每种类型的一个“工厂实例”，这样您就不必继续重新创建它们。)

一个人为的例子，使用类似你的词类比的东西:

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Drawing;

interface IWord
{
    bool IsTypeOf(IWord word);
    string Text { get; set; }
    IWord MakeFrom(IWord word);
}

// the base type
class UntypedWord : IWord
{
    public virtual string Text { get; set; }
    public virtual bool IsTypeOf(IWord word)
    {
        throw new NotImplementedException();
    }
    public virtual IWord MakeFrom(IWord word)
    {
        throw new NotImplementedException();
    }
}

// one specific subtype
class ColorWord : UntypedWord
{
    public Color Color { get; private set; }

    public override bool IsTypeOf(IWord word)
    {
        return word.Text == "red" || word.Text == "green" || word.Text == "blue";
    }

    public override IWord MakeFrom(IWord word)
    {
        var newMe = new ColorWord();
        newMe.Text = word.Text;
        if (word.Text == "red") newMe.Color = Color.Red;
        else if (word.Text == "blue") newMe.Color = Color.Blue;
        else if (word.Text == "yellow") newMe.Color = Color.Yellow;
        return newMe;            
    }
}

// another specific type
class NumberWord : IWord // note: not an UntypedWord (see comments below)
{
    public int Number { get; set; }
    public string Text { get; set; }

    public bool IsTypeOf(IWord word)
    {
        return word.Text == "one" || word.Text == "two" || word.Text == "three";
    }

    public IWord MakeFrom(IWord word)
    {
        var newMe = new NumberWord();
        newMe.Text = word.Text;
        if (word.Text == "one") newMe.Number = 1;
        else if (word.Text == "two") newMe.Number = 2;
        else if (word.Text == "three") newMe.Number = 3;
        return newMe;
    }
}


class WordList
{
    Collection<Type> WordTypes = new Collection<Type>();
    Collection<IWord> UntypedWords = new Collection<IWord>();
    Dictionary<Type, Collection<IWord>> StronglyTypedWords = new Dictionary<Type, Collection<IWord>>();

    public void AddWordType<T>() where T : IWord
    {
        WordTypes.Add(typeof(T));

        if (!StronglyTypedWords.ContainsKey(typeof(T)))
            StronglyTypedWords[typeof(T)] = new Collection<IWord>();
    }

    public void Add(IWord word)
    {
        bool foundType = false;
        foreach (Type type in WordTypes)
        {
            // in practice you'd cache these factories for efficiency
            IWord instance = Activator.CreateInstance(type) as IWord;
            if (instance.IsTypeOf(word))
            {
                if (!StronglyTypedWords.ContainsKey(type))
                    StronglyTypedWords[type] = new Collection<IWord>();

                StronglyTypedWords[type].Add(instance.MakeFrom(word));
                foundType = true;
            }
        }
        if (!foundType)
            UntypedWords.Add(word);
    }

    public int HowManyWordsOfType<T>()
    {
        if (StronglyTypedWords.ContainsKey(typeof(T)))
            return StronglyTypedWords[typeof(T)].Count;
        return 0;
    }
}

class Program
{
    static void Main(string[] args)
    {
        var sentence = new WordList();
        sentence.AddWordType<ColorWord>();
        sentence.AddWordType<NumberWord>();

        sentence.Add(new UntypedWord { Text = "two" });
        sentence.Add(new UntypedWord { Text = "green" });
        sentence.Add(new UntypedWord { Text = "frogs" });
        sentence.Add(new UntypedWord { Text = "and" });
        sentence.Add(new UntypedWord { Text = "one" });
        sentence.Add(new UntypedWord { Text = "red" });
        sentence.Add(new UntypedWord { Text = "rose" });

        Console.WriteLine("color words: " + sentence.HowManyWordsOfType<ColorWord>());
        Console.WriteLine("number words: " + sentence.HowManyWordsOfType<NumberWord>());
    }
}    

输出:

color words: 2
number words: 2

现在当你想添加一个新的词类型时，你唯一需要添加的代码是:

sentence.AddWordType<NewWordType>();

您会注意到 ColorWord 是 UntypedWord 的子类型，但 NumberWord 不是。 Word 类型不必共享公共(public)基类型，只要它们实现了 IWord。

显然这是一个荒谬的例子，但它展示了每个子类型如何拥有根据公共(public)父类(super class)型(或公共(public)接口(interface))的给定对象的属性对自己进行分类的逻辑，并且它知道如何根据以下内容创建自己的实例给定的对象。

所以现在 WordList(您的 P)类永远不必更新以适应新的单词类型。您只需要在运行时告诉它所有类型。

并且您可以编写您的 IdentifyAll(WordList sentence) 方法，只是它是一个实例方法而不是静态方法。