具有许多属性的类的装饰器模式

Question

我有这样一个简单的类:

public class DataBag
{
    public string UserControl { get; set; }
    public string LoadMethod { get; set; }
    public dynamic Params { get; set; }
    public int Height { get; set; }
    public DataBag(string Control, 
        object vars, string lm)
    {
        UserControl = Control;
        LoadMethod = lm;
        Params = vars;
        Height = 0;
    }
}

然后我想为它创建一个装饰器，它会添加一堆自己的属性。问题是什么是最简洁和优雅的方式来提供对装饰属性的访问?

到目前为止，我有两个选择:要么我为装饰器中的四个装饰属性中的每一个提供一个get-set对(这看起来乏味而拗口，基本上这是我想避免的)，要么我从DynamicObject继承DataBag，然后以某种方式设法使用TryGetMember方法获得装饰属性(这是动态的，似乎不是在c#中做事的正确方法)。

任何建议吗?

Answer 1

在实现装饰器时，我通常这样做。首先，提取被装饰对象的接口，并使被装饰对象实现该接口:

public interface IDataBag
{
    string UserControl { get; set; }
    string LoadMethod { get; set; }
    dynamic Params { get; set; }
    int Height { get; set; }
}

下一步-创建一个装饰器，它将所有的调用委托给被装饰对象(所有的装饰器都将继承这个装饰器):

public class DataBagDecorator : IDataBag
{
    private IDataBag _dataBag;
    public DataBagDecorator(IDataBag dataBag)
    {
        _dataBag = dataBag;
    }
    public virtual string UserControl
    {
        get { return _dataBag.UserControl; }
        set { _dataBag.UserControl = value; }
    }
    // other members
}

最后-创建装饰器:

public class FooDataBag : DataBagDecorator
{
    public FooDataBag(IDataBag dataBag) 
        : base(dataBag) { }
    public override string UserControl
    {
        // added behavior
        get { return "Foo" + base.UserControl; }
        set { base.UserControl = value; }
    }
    // you don't need to override other members
}

用法:

IDataBag dataBag = new FooDataBag(new DataBag());

Answer 2

这是最简单的装饰:

public class PrettyBag : DataBag
{
    public int Decoration1 { get; set; }
    public int Decoration2 { get; set; }
}

如果你想创建一个facade并隐藏一些DataBag属性，而不是仅仅添加属性，那么你可以将DataBag的成员设置为protected。

对于接口，你可以这样做:

    public interface IDataBag
    {
       ...
    }
    public class DataBag : IDataBag
    {
       ...
    }
    public interface IPrettyBag : IDataBag
    {
        int Decoration1 { get; set; }
        int Decoration2 { get; set; }
    }
    public class BigBag : IPrettyBag
    {
        public int Decoration1 { get; set; }
        public int Decoration2 { get; set; }
    }
    public interface SmallBag : IPrettyBag
    {
        public int Decoration1 { get; set; }
        public int Decoration2 { get; set; }
    }

Answer 3

更新:@JeremyDWill正确地指出，你不能从它的一个参数派生出泛型类型…

如果你认为装饰器是一个"添加新属性的子类"，你可以这样做:

public class MyDecorator<T> : T
{
    public int MyDecoratorProperty1 { get; set; }
    public int MyDecoratorProperty2 { get; set; }
}

然后可以创建MyDecorator<DataBag>和MyDecorator<OtherClass>的实例，等等。现有的属性是可访问的，因为MyDecorator<>特定于泛型参数的类型，并且派生自该类。

你可以创建一个包含装饰对象的包装器:

public class MyDecorator<T>
{
    public MyDecorator(T decoratedObject)
    {
        this.DecoratedObject = decoratedObject;
    }
    public T DecoratedObject { get; private set; }
    public int MyDecoratorProperty1 { get; set; }
    public int MyDecoratorProperty2 { get; set; }
}

的优点是，获得装饰属性很容易:myObj.MyDecoratorProperty1。缺点是您现在必须通过DecoratedObject成员来访问基本对象:

DataBag bag = new DataBag("", null, null);
MyDecorator<DataBag> deco = new MyDecorator<DataBag>(bag);
deco.DecoratedObject.Height = 2;

如果你不能从装饰子类化(你需要一次支持多个装饰器)，你将不得不做一些像"附加属性"…您的decorator类必须保存原始对象和修饰属性的字典。使用一些扩展方法，只要事先知道要装饰的类型(或者愿意装饰任何对象)，就可以使这些属性"看起来"像被装饰类的本地成员:

public static class AttachedDecorator
{
    private class Properties
    {
        public int MyDecoratorProperty1 { get; set; }
        public int MyDecoratorProperty2 { get; set; }
    }
    private static Dictionary<object, Properties> map = new Dictionary<object, Properties>();
    public static int GetMyDecoratorProperty1(object obj)
    {
        Properties props;
        if (map.TryGetValue(obj, out props))
        {
            return props.MyDecoratorProperty1;
        }
        return -1; // or some value that makes sense if the object has no decorated property set
    }
    public static int GetMyDecoratorProperty2(object obj) { /* ... */ }
    public static void SetMyDecoratorProperty1(object obj, int value)
    {
        Properties props;
        if (!map.TryGetValue(obj, out props))
        {
            props = new Properties();
            map.Add(obj, props);
        }
        props.MyDecoratorProperty1 = value;
    }
    public static void SetMyDecoratorProperty2(object obj, int value) { /* ... */ }
}
public static class DecoratorExtensions
{
    private static int GetMyDecoratorProperty1(this object obj)
    {
        return AttachedDecorator.GetMyDecoratorProperty1(obj);
    }
    private static void SetMyDecoratorProperty1(this object obj, int value)
    {
        return AttachedDecorator.GetMyDecoratorProperty1(obj, value);
    }
    // ...
}

你的代码可能看起来像:

DataBag myData = new DataBag();
myData.SetMyDecoratorProperty1(7);
Console.WriteLine("prop1: {0}", myData.GetMyDecoratorProperty1());