有没有一种简单的方法可以在 C# 中模拟 Objective-C 类别？

Question

我有一个以前从未遇到过的奇怪的设计情况...如果我使用 Objective-C，我会用类别来解决它，但我必须使用 C# 2.0。

首先，一些背景知识。 我在这个类库中有两个抽象层。 底层为扫描内容的组件实现了一个插件架构（抱歉，不能比这更具体了）。 每个插件都会以某种独特的方式进行扫描，但插件也可能因它们接受的内容类型而异。 由于与本讨论无关的各种原因，我不想通过插件接口公开泛型。 因此，我最终为每种内容类型提供了一个 IScanner 接口和一个派生接口。

顶层是一个方便的包装器，它接受包含各个部分的复合内容格式。 不同的扫描仪将需要复合的不同部分，具体取决于它们感兴趣的内容类型。因此，我需要具有特定于每个 IScanner 派生接口的逻辑，用于解析复合内容，查找所需的相关部分。

解决这个问题的一种方法是简单地向 IScanner 添加另一个方法并在每个插件中实现它。 然而，两层设计的重点是插件本身不需要了解复合格式。 解决这个问题的强力方法是在上层进行类型测试和向下转换，但是随着将来添加对新内容类型的支持，这些需要仔细维护。 在这种情况下，访问者模式也会很尴尬，因为实际上只有一个访问者，但不同可访问类型的数量只会随着时间的推移而增加（即，这些是访问者适合的相反条件）。 另外，当我真正想要的只是劫持 IScanner 的单次调度时，双次调度感觉有点矫枉过正！

如果我使用 Objective-C，我只需在每个 IScanner 派生接口上定义一个类别，并在其中添加 parseContent 方法。 类别将在上层定义，因此插件不需要更改，同时避免了类型测试的需要。 不幸的是，C# 扩展方法不起作用，因为它们基本上是静态的（即，与调用站点使用的引用的编译时类型相关，而不是像 Obj-C 类别那样挂钩到动态调度）。 更不用说，我必须使用 C# 2.0，所以我什至无法使用扩展方法。 :-P

那么在 C# 中是否有一种干净、简单的方法来解决这个问题，类似于如何使用 Objective-C 类别来解决这个问题？

---

编辑：一些伪代码可以帮助使当前设计的结构清晰：

interface IScanner
{ // Nothing to see here...
}

interface IContentTypeAScanner : IScanner
{
    void ScanTypeA(TypeA content);
}

interface IContentTypeBScanner : IScanner
{
    void ScanTypeB(TypeB content);
}

class CompositeScanner
{
    private readonly IScanner realScanner;

    // C-tor omitted for brevity... It takes an IScanner that was created
    // from an assembly-qualified type name using dynamic type loading.

    // NOTE: Composite is defined outside my code and completely outside my control.
    public void ScanComposite(Composite c)
    {
        // Solution I would like (imaginary syntax borrowed from Obj-C):
        // [realScanner parseAndScanContentFrom: c];
        // where parseAndScanContentFrom: is defined in a category for each
        // interface derived from IScanner.

        // Solution I am stuck with for now:
        if (realScanner is IContentTypeAScanner)
        {
            (realScanner as IContentTypeAScanner).ScanTypeA(this.parseTypeA(c));
        }
        else if (realScanner is IContentTypeBScanner)
        {
            (realScanner as IContentTypeBScanner).ScanTypeB(this.parseTypeB(c));
        }
        else
        {
            throw new SomeKindOfException();
        }
    }

    // Private parsing methods omitted for brevity...
}

---

编辑：为了澄清，我已经对这个设计进行了很多思考。 我有很多理由，但其中大部分我无法分享，为什么会是这样。 我还没有接受任何答案，因为虽然很有趣，但他们回避了原来的问题。

事实是，在 Obj-C 中我可以简单而优雅地解决这个问题。 问题是，我可以在 C# 中使用相同的技术吗？如果可以，如何使用？ 我不介意寻找替代方案，但公平地说，这不是我问的问题。 :)

Answer 1

听起来你的意思是你的内容布局如下：

+--------+
| part 1 |
| type A |
+--------+
| part 2 |
| type C |
+--------+
| part 3 |
| type F |
+--------+
| part 4 |
| type D |
+--------+

并且每个部分类型都有读者。 也就是说，AScanner知道如何处理类型A的部分（如上面的部分1）中的数据，BScanner知道如何处理类型B的部分数据，等等。 到目前为止我是对的吗？

现在，如果我理解您的意思，您遇到的问题是类型读取器（IScanner 实现）不知道如何在复合容器中找到它们识别的部分。

您的复合容器能否正确枚举各个单独的部分（即，它是否知道一个部分在哪里结束，另一个部分在哪里开始），如果是这样，每个部分是否具有扫描仪或容器可以区分的某种标识？

我的意思是，数据是这样排列的吗？

+-------------+
| part 1      |
| length: 100 |
| type: "A"   |
| data: ...   |
+-------------+
| part 2      |
| length: 460 |
| type: "C"   |
| data: ...   |
+-------------+
| part 3      |
| length: 26  |
| type: "F"   |
| data: ...   |
+-------------+
| part 4      |
| length: 790 |
| type: "D"   |
| data: ...   |
+-------------+

如果您的数据布局与此类似，扫描仪是否无法请求容器的所有部件具有与给定模式匹配的标识符？ 例如：

class Container : IContainer{
    IEnumerable IContainer.GetParts(string type){
        foreach(IPart part in internalPartsList)
            if(part.TypeID == type)
                yield return part;
    }
}

class AScanner : IScanner{
    void IScanner.ProcessContainer(IContainer c){
        foreach(IPart part in c.GetParts("A"))
            ProcessPart(part);
    }
}

或者，如果容器可能无法识别零件类型，但扫描仪能够识别其自己的零件类型，也许类似：

delegate void PartCallback(IPart part);

class Container : IContainer{
    void IContainer.GetParts(PartCallback callback){
        foreach(IPart part in internalPartsList)
            callback(part);
    }
}

class AScanner : IScanner{
    void IScanner.ProcessContainer(IContainer c){
        c.GetParts(delegate(IPart part){
            if(IsTypeA(part))
                ProcessPart(part);
        });
    }

    bool IsTypeA(IPart part){
        // determine if part is of type A
    }
}

也许我误解了您的内容和/或架构。 如果是这样，请澄清，我会更新。

---

来自OP的评论：

1. 扫描仪不应了解容器类型。
2. 容器类型没有内置智能。 它与您在 C# 中获得的普通旧数据非常接近。
3. 我无法更改容器类型； 它是现有架构的一部分。

我的回复太长，无法发表评论：

1. 扫描仪必须有某种方式来检索它们处理的部件。 如果您担心 IScanner 接口不应该识别 IContainer 接口，以便您可以自由地更改 IContainer 接口未来，那么您可以通过以下几种方式之一进行妥协：

   • 您可以向扫描仪传递一个由 IContainer 派生（或包含）的 IPartProvider 接口。 这个 IPartProvider 只会提供提供部件的功能，因此它应该非常稳定，并且可以在与 IScanner 相同的程序集中定义，以便您的插件ins 不需要引用定义了 IContainer 的程序集。
   • 您可以将委托传递给扫描仪，让他们用来检索零件。 这样，扫描器就不需要任何接口的知识（当然，IScanner 除外），只需要委托的知识。

2. 和

3. 也许您需要一个知道如何与容器和扫描仪通信的代理类。 上面提到的任何功能都可以在任何 ol' 类中实现，只要容器已经公开（或受保护地[这是一个词吗？]）公开足够的功能，外部/派生类将能够访问相关数据。

---

从您编辑的问题中的伪代码来看，您似乎并没有真正从界面中获得任何好处，而是将插件与主应用程序紧密耦合，因为每种扫描仪类型都有 IScanner 定义了唯一的“扫描”方法，而 CompositeScanner 类对每个部件类型都有唯一的“解析”方法。

我想说这是你的首要问题。 您需要将插件（我假设是 IScanner 接口的实现者）与主应用程序分离（我假设主应用程序是 CompositeScanner 类所在的位置）。 我之前的建议之一是我如何实现它，但具体细节取决于您的parseTypeX函数的工作方式。 这些可以抽象和概括吗？

据推测，您的 parseTypeX 函数与 Composite 类对象通信以获取所需的数据。 能否将这些内容移至通过 CompositeScanner 类代理的 IScanner 接口上的 Parse 方法，以从 Composite 获取此数据对象？ 像这样的事情：

delegate byte[] GetDataHandler(int offset, int length);

interface IScanner{
    void   Scan(byte[] data);
    byte[] Parse(GetDataHandler getData);
}

class Composite{
    public byte[] GetData(int offset, int length){/*...*/}
}

class CompositeScanner{}
    IScanner realScanner;

    public void ScanComposite(Composite c){
        realScanner.Scan(realScanner.Parse(delegate(int offset, int length){
            return c.GetData(offset, length);
        });
    }
}

当然，可以通过删除 IScanner 上单独的 Parse 方法并将 GetDataHandler 委托直接传递给 Scan（如果需要，其实现可以调用私有Parse）。 该代码看起来与我之前的示例非常相似。

这种设计提供了我能想到的尽可能多的关注点分离和解耦。

---

我只是想到了其他一些你可能会觉得更容易接受的东西，而且确实可以提供更好的关注点分离。

如果您可以让每个插件向应用程序“注册”，那么您可以将解析保留在应用程序中，只要插件可以告诉应用程序如何检索其数据即可。 示例如下，但由于我不知道如何识别您的部件，因此我实现了两种可能性 - 一种用于索引部件，一种用于命名部件：

// parts identified by their offset within the file
class MainApp{
    struct BlockBounds{
        public int offset;
        public int length;

        public BlockBounds(int offset, int length){
            this.offset = offset;
            this.length = length;
        }
    }

    Dictionary<Type, BlockBounds> plugins = new Dictionary<Type, BlockBounds>();

    public void RegisterPlugin(Type type, int offset, int length){
        plugins[type] = new BlockBounds(offset, length);
    }

    public void ScanContent(Container c){
        foreach(KeyValuePair<Type, int> pair in plugins)
            ((IScanner)Activator.CreateInstance(pair.Key)).Scan(
                c.GetData(pair.Value.offset, pair.Value.length);
    }
}

或者

// parts identified by name, block length stored within content (as in diagram above)
class MainApp{
    Dictionary<string, Type> plugins = new Dictionary<string, Type>();

    public void RegisterPlugin(Type type, string partID){
        plugins[partID] = type;
    }

    public void ScanContent(Container c){
        foreach(IPart part in c.GetParts()){
            Type type;
            if(plugins.TryGetValue(part.ID, out type))
                ((IScanner)Activator.CreateInstance(type)).Scan(part.Data);
        }
    }
}

显然，我已经极大地简化了这些示例，但希望您得到这个想法。 此外，如果您可以将工厂（或工厂委托）传递给 RegisterPlugin 方法，而不是使用 Activator.CreateInstance，那就太好了。

Answer 2

我要尝试...;-)
如果在您的系统中存在一个填充 IScanner 对象“目录”的阶段，您可以考虑用一个属性来装饰您的 IScanner ，该属性说明了哪个 Part< /code> 他们感兴趣。然后您可以映射此信息并使用地图驱动您的 Composite 的扫描。
这不是一个完整的答案：如果我有一点时间，我会尝试详细说明...

编辑：一些伪代码来支持我的混乱解释

public interface IScanner
{
    void Scan(IPart part);
}

public interface IPart
{
    string ID { get; }
}

[ScannedPart("your-id-for-A")]
public class AlphaScanner : IScanner
{
    public void Scan(IPart part)
    {
        throw new NotImplementedException();
    }
}

[ScannedPart("your-id-for-B")]
public class BetaScanner : IScanner
{
    public void Scan(IPart part)
    {
        throw new NotImplementedException();
    }
}

public interface IComposite
{
    List<IPart> Parts { get; }
}

public class ScannerDriver
{
    public Dictionary<string, IScanner> Scanners { get; private set; }

    public void DoScan(IComposite composite)
    {
        foreach (IPart part in composite.Parts)
        {
            IScanner scanner = Scanners[part.ID];
            scanner.Scan(part);
        }
    }
}

不要按原样接受：它是为了解释目的。

编辑：回答内核上校的评论。
我很高兴你觉得这很有趣。 :-)
在这个简单的代码草图中，应该仅在字典初始化期间（或需要时）涉及反射，并且在此阶段您可以“强制”属性的存在（甚至使用映射扫描仪和部件的其他方式）。 我说“强制”是因为，即使它不是编译时约束，我认为您在将代码投入生产之前至少会运行一次代码；-) 所以它可能是一次运行- 如果需要的话，时间限制。 我想说，灵感是类似于 MEF 或其他类似框架的东西（非常非常简单）。
只是我的2分钱。