CacheWrapperBuilder

Ich hatte mal wider lust auch etwas Gehirnsport (Programme schreiben, die Programmcode generieren gehört bei mir in diese Kategorie)
Rausgekommen ist folgendes:

Beschreibung:

Wenn man der Klasse ein interface und ein entsprechnedes Objekt übergibt, baut sie für deises Objekt einen Wrapper, der das interface implementiert. Dieser Wrapper speichert standardmäßig alle Eigenschaften des Interfaces und reicht Änderungen erste weiter, wenn man accept aufruft.

Damit kann man z.B. Einstellungen erst verzögert übernehmen lassen.
Man kann es auch zum Zurücksetzen des ORiginals verwenden, da der warpper bei seiner erstellung den aktuellen Zustand kopiert und später wieder zurückschreiben kann. Man kann mehrere Warpper gleichzeitig erstellen.

Man kann die Propertys des Interfaces mit einem Attribut versehen, um das Standardverhalten zu verändern:

[CacheType(CacheTypes.PassThrough)]
Wird verzögert durchgereicht, dies geschieht auch, wenn man das Attribut nicht angibt
[CacheType(CacheTypes.InstantPassTrough)]
Wird sofort durchgereicht
[CacheType(CacheTypes.ExchangeFlatCopy)]
Beim Erstellen wird eine Kopie mit memberwiseClone erstellt, die verzögert durchgereicht wird
[CacheType(CacheTypes.ExchangeClone)]
Beim Erstellen wird eine Kopie mit ICloneable.Clone erstellt, die verzögert durchgereicht wird
[CacheType(CacheTypes.AcceptFlatCopy)]
Beim Erstellen wird eine Kopie mit memberwiseClone erstellt, deren Propertys einzeln gesetzt werden. Bei Arrays wird Feld für Feld Kopiert.
[CacheType(CacheTypes.AcceptClone)]
Beim Erstellen wird eine Kopie mit ICloneable.Clone erstellt, deren Propertys einzeln gesetzt werden. Bei Arrays wird Feld für Feld Kopiert.
[CacheType(CacheTypes.Wrap)]
Für den Wert des Propertys wird automatisch ein Wrapper erstellt.
[CacheType(CacheTypes.Wrap, CustomWrapper = typeof(IListWrapper<int>))]
Für den Wert des Propertys wird ein Wrapper vom angegebenen Typ erstellt.

Wenn man kein Attribut angibt wird der Wert verzögert durchgereicht!

    TestClass original=new TestClass();
    original.Array = new int[3];
    original.SubObject.Text = "A";
    original.List.Add(1337);
    ITestObject wrapper=(ITestObject) CacheWrapperBuilder.Default._Wrap(typeof(ITestObject), original);
    wrapper.Array[0] = 1;
    wrapper.SubObject.Text="B";
    wrapper.List.Add(2);
    ((ICacheWrapper)wrapper).Accept();//Erst hier wird  das Original verändert

    public interface ITestSubObject
    {
        string Text { get; set; }
    }

    public class TestSubObject : ITestSubObject
    {
        public string Text{get;set;}
    }

    public interface ITestObject
    {
        [CacheType(CacheTypes.ExchangeFlatCopy)]
        int[] Array { get; set; }

        [CacheType(CacheTypes.Wrap)]
        ITestSubObject SubObject { get; }

        [CacheType(CacheTypes.Wrap,CustomWrapper=typeof(IListWrapper<int>))]
        IList<int> List { get;}
    }

    class TestClass:ITestObject
    {
        private int[] array;
        public int[] Array {
            get { return array; }
            set { array = value; } }

        ITestSubObject sub = new TestSubObject();
        public ITestSubObject SubObject { get { return sub; } }

        private IList<int> list=new List<int>();
        public IList<int> List { get { return list; } }
    }

    public class IListWrapper<T>:List<T>,ICacheWrapper
    {
        public IListWrapper(ICollection<T> inner)
        {
            this.inner = inner;
            Mirror();
        }

        public ICollection<T> inner;

        public void Accept()
        {
            inner.Clear();
            foreach (T v in this)
            {
                inner.Add(v);
            }
        }

        public void Mirror()
        {
            this.Clear();
            this.AddRange(inner);
        }
    }

siehe auch: Tiefes Kopieren belibiger Objektnetze

Schlagwörter: <Bitte Schlagwörter für Bullshit-Bingo ergänzen>