C# 集合作为装饰器：伪代码实现方案

在等待答案的同时，我想讨论可能的实施计划/细节，或者总体上回答实施以下内容有多困难，以及需要哪些工具/技术：

（摘自所提问题）：

假设您需要实现许多 （子）集合类型。其中一个 特性与存储相关：列表， 数组等，而另一个是 行为相关：已排序，删除 唯一的，可观察的（开火的那一个） 每一次变化后的事件）等

显然（再一次），要求 直接映射到著名的 Decorator设计模式，其中存储相关 特性（列表、阵列）将由多个 行为（有序、可观察等）

到目前为止，我想用（类似Java的）伪代码提出一些合理的简短实现，同时询问是否有可能用Java或C#实现以下内容，或者，如果没有，则用任何其他现代编程语言实现：

每个集合必须支持的基本接口：

interface Collection {
    [mutator]
    public void add(object o);

    [mutator]
    public void remove(object o);

    [accessor]
    public object get(int i);
}

存储方面：

清单执行情况：

class List : Collection {
    [mutator]
    public void add(object o) { ... }

    [mutator]
    public void remove(object o) { ... }

    [accessor]
    public object get(int i) { ... }
}

class Array : Collection {
    [mutator]
    public void add(object o) { ... }

    [mutator]
    public void remove(object o) { ... }

    [accessor]
    public object get(int i) { ... }
}

阵列实现：

class List : Collection {
    [mutator]
    public void add(object o) { ... }

    [mutator]
    public void remove(object o) { ... }

    [accessor]
    public object get(int i) { ... }
}

class Array : Collection {
    [mutator]
    public void add(object o) { ... }

    [mutator]
    public void remove(object o) { ... }

    [accessor]
    public object get(int i) { ... }
}

行为方面方面：

线程安全装饰器：

typename<T> : where T is Collection
class ThreadSafe : Collection {
    private T m_source;
    private object m_lock = new object();

    [mutator]
    public void add(object o) { 
        using (m_lock) {
            m_source.add();
        }
    }

    [mutator]
    public void remove(object o) { ... }

    [accessor]
    public object get(int i) { ... }
}

class ChangeEvent {
    public Collection Source { get; private set; }
    public Method UpdateType { get; private set; }
}

interface Observer {
    public notifyChange(ChangeEvent e);
}

typename<T> : where T is Collection
class Observable : Collection {
    public Observer Observer { get; set; } // additional property
    private T m_source;

    [mutator]
    public void add(object o) {
        if (Observer != null) {
            var event = new ChangeEvent() { Source = this, UpdateType = GetCurrentMethod() };
            Observer.notifyChange(event);
        }
        m_source.add(o);
    }

    [mutator]
    public void remove(object o) { ... }

    [accessor]
    public object get(int i) { ... }
}

typename<T> : where T is Collection
class Ordered : Collection {
    private T m_source;

    [mutator]
    public void add(object o) {
        int idx = findProperPosition(); // assumed possible using the base Collection interface
        ...
        m_source.add(o);
    }

    [mutator]
    public void remove(object o) { ... }

    [accessor]
    public object get(int i) { ... }
}

typename<T> : where T is Collection
class ReadOnly : Collection {
    private T m_source;

    [mutator]       
    public void add(object o) { throw IllegalOperationException(...); }

    [mutator]
    public void remove(object o) { throw IllegalOperationException(...); }

    [accessor]
    public object get(int i) { return m_source.get(i); }
}

typename：其中T是集合
类线程安全：集合{
私人T m_来源；
私有对象m_lock=新对象（）；
[变异体]
公共无效添加（对象o）{
使用（m_锁）{
m_source.add（）；
}
}
[变异体]
公共无效删除（对象o）{…}
[访问者]
公共对象get（int i）{…}
}

可见装饰物：

typename<T> : where T is Collection
class ThreadSafe : Collection {
    private T m_source;
    private object m_lock = new object();

    [mutator]
    public void add(object o) { 
        using (m_lock) {
            m_source.add();
        }
    }

    [mutator]
    public void remove(object o) { ... }

    [accessor]
    public object get(int i) { ... }
}

class ChangeEvent {
    public Collection Source { get; private set; }
    public Method UpdateType { get; private set; }
}

interface Observer {
    public notifyChange(ChangeEvent e);
}

typename<T> : where T is Collection
class Observable : Collection {
    public Observer Observer { get; set; } // additional property
    private T m_source;

    [mutator]
    public void add(object o) {
        if (Observer != null) {
            var event = new ChangeEvent() { Source = this, UpdateType = GetCurrentMethod() };
            Observer.notifyChange(event);
        }
        m_source.add(o);
    }

    [mutator]
    public void remove(object o) { ... }

    [accessor]
    public object get(int i) { ... }
}

typename<T> : where T is Collection
class Ordered : Collection {
    private T m_source;

    [mutator]
    public void add(object o) {
        int idx = findProperPosition(); // assumed possible using the base Collection interface
        ...
        m_source.add(o);
    }

    [mutator]
    public void remove(object o) { ... }

    [accessor]
    public object get(int i) { ... }
}

typename<T> : where T is Collection
class ReadOnly : Collection {
    private T m_source;

    [mutator]       
    public void add(object o) { throw IllegalOperationException(...); }

    [mutator]
    public void remove(object o) { throw IllegalOperationException(...); }

    [accessor]
    public object get(int i) { return m_source.get(i); }
}

类更改事件{
公共集合源{get；private set；}
公共方法UpdateType{get；private set；}
}
界面观察者{
公共变更通知（变更事件e）；
}
typename：其中T是集合
可观测类：集合{
公共观察者{get；set；}//附加属性
私人T m_来源；
[变异者]
公共无效添加（对象o）{
如果（观察者！=null）{
var event=new changevent（）{Source=this，UpdateType=GetCurrentMethod（）}；
观察员。通知变更（事件）；
}
m_来源。添加（o）；
}
[变异体]
公共无效删除（对象o）{…}
[访问者]
公共对象get（int i）{…}
}

订购装饰师：

typename<T> : where T is Collection
class ThreadSafe : Collection {
    private T m_source;
    private object m_lock = new object();

    [mutator]
    public void add(object o) { 
        using (m_lock) {
            m_source.add();
        }
    }

    [mutator]
    public void remove(object o) { ... }

    [accessor]
    public object get(int i) { ... }
}

class ChangeEvent {
    public Collection Source { get; private set; }
    public Method UpdateType { get; private set; }
}

interface Observer {
    public notifyChange(ChangeEvent e);
}

typename<T> : where T is Collection
class Observable : Collection {
    public Observer Observer { get; set; } // additional property
    private T m_source;

    [mutator]
    public void add(object o) {
        if (Observer != null) {
            var event = new ChangeEvent() { Source = this, UpdateType = GetCurrentMethod() };
            Observer.notifyChange(event);
        }
        m_source.add(o);
    }

    [mutator]
    public void remove(object o) { ... }

    [accessor]
    public object get(int i) { ... }
}

typename<T> : where T is Collection
class Ordered : Collection {
    private T m_source;

    [mutator]
    public void add(object o) {
        int idx = findProperPosition(); // assumed possible using the base Collection interface
        ...
        m_source.add(o);
    }

    [mutator]
    public void remove(object o) { ... }

    [accessor]
    public object get(int i) { ... }
}

typename<T> : where T is Collection
class ReadOnly : Collection {
    private T m_source;

    [mutator]       
    public void add(object o) { throw IllegalOperationException(...); }

    [mutator]
    public void remove(object o) { throw IllegalOperationException(...); }

    [accessor]
    public object get(int i) { return m_source.get(i); }
}

typename：其中T是集合
已订购类别：集合{
私人T m_来源；
[变异体]
公共无效添加（对象o）{
int idx=findpropertosition（）；//假定可以使用基本集合接口
...
m_来源。添加（o）；
}
[变异体]
公共无效删除（对象o）{…}
[访问者]
公共对象get（int i）{…}
}

只读装饰器：

typename<T> : where T is Collection
class ThreadSafe : Collection {
    private T m_source;
    private object m_lock = new object();

    [mutator]
    public void add(object o) { 
        using (m_lock) {
            m_source.add();
        }
    }

    [mutator]
    public void remove(object o) { ... }

    [accessor]
    public object get(int i) { ... }
}

class ChangeEvent {
    public Collection Source { get; private set; }
    public Method UpdateType { get; private set; }
}

interface Observer {
    public notifyChange(ChangeEvent e);
}

typename<T> : where T is Collection
class Observable : Collection {
    public Observer Observer { get; set; } // additional property
    private T m_source;

    [mutator]
    public void add(object o) {
        if (Observer != null) {
            var event = new ChangeEvent() { Source = this, UpdateType = GetCurrentMethod() };
            Observer.notifyChange(event);
        }
        m_source.add(o);
    }

    [mutator]
    public void remove(object o) { ... }

    [accessor]
    public object get(int i) { ... }
}

typename<T> : where T is Collection
class Ordered : Collection {
    private T m_source;

    [mutator]
    public void add(object o) {
        int idx = findProperPosition(); // assumed possible using the base Collection interface
        ...
        m_source.add(o);
    }

    [mutator]
    public void remove(object o) { ... }

    [accessor]
    public object get(int i) { ... }
}

typename<T> : where T is Collection
class ReadOnly : Collection {
    private T m_source;

    [mutator]       
    public void add(object o) { throw IllegalOperationException(...); }

    [mutator]
    public void remove(object o) { throw IllegalOperationException(...); }

    [accessor]
    public object get(int i) { return m_source.get(i); }
}

typename：其中T是集合
类只读：集合{
私人T m_来源；
[变异体]
public void add（object o）{throw IllegalOperationException（…）；}
[变异体]
public void remove（对象o）{抛出非法操作异常（…）；}
[访问者]
公共对象get（int i）{返回m_source.get（i）；}
}

到目前为止，以上只是伪代码，但目标是使客户机代码能够构建多种集合，以便每种集合都可以仅结合一个存储方面任何数量的行为相关方面。如果能够在编译时构造这些复合类型，并且即使在运行时也能非常方便地生成这些类型，那就太好了

---

问题是（任何现代编程语言）如何计算？

我不明白你不明白的是哪方面。Java集合已经有了这一点，并且源代码是公共的。具有线程安全和不可修改的装饰器。此外，许多类型都有fascade方法，如“asList（）”

既然如此，你的问题还剩下什么

---

如何制作未定做的东西？比如，如何创建一个装饰器，将HashMap转换为LinkedHaskMap？这样的装饰器可以通过内部数据结构来维护秩序。

好吧，让我们看看这是怎么回事。FAQ“我不应该在这里问什么样的问题？”的前两句话很好地描述了这个主题。首先，对不起。重新表述了主要（实际）问题。