Паттерн наблюдателя ( Observer )

        public class IObserver 
        {
            public virtual void Update(CShape a){}
        }
        
        public class Observer: IObserver
        {
            public Observer(){}
            
            public override void Update(CShape a)
            {
                //TreeNode tn = new TreeNode();
                // tn.Name = a.Name;
                // Update(a);
                /* if(a is CGroup)
                    foreach( CShape f in CGroup)
                        Update(f,tn);*/
            }
        }
        
        public class IObservable
        {
            public virtual void AddObserver(IObserver o){}
            public virtual void RemoveObserver(IObserver o){}
            public virtual void Notify(){}
        }
 
        public class Subject: IObservable 
        {
            public List<IObserver> _obs;
            
            public Subject()
            {
                _obs = new List<IObserver>();
            }
            
            public override void AddObserver(IObserver o)
            {
                _obs.Add(o);
            }
            
            public override void RemoveObserver(IObserver o)
            {
                _obs.Remove(o);
            }
            
            public override void Notify()
            {
                TreeNode f = new TreeNode();
                for(int i=0; i<_obs.Count;++i)
                    _obs[i].Update(this);
            }
        }
          public class CShape: Subject{}

Storage<CShape> storage = new Storage<CShape>();
   
public class Storage<T>
        {
            private int top;
            public T [] s;
         
            public Storage()
            {
                top = 0;
                s = new T[top];
            }
         
            public void Add(T var)
            {
                T [] a = new T[top+1];
                for (int i=0; i<top; i++) a[i] = s[i];
                a[top]= var;
                top++;
                s = a;
            }
         
            public void Remove(int index)
            {
                if (top == 0) return;
                T[] a = new T[top-1];
                for(int i=0, j=0; i<top; i++)
                {
                    if(i != index)
                    {
                        a[j]=s[i];
                        j++;
                    }
                }
                s = a;
                top--;
            }
         
            public T this[int index]
            {
                get { return s[index]; }
            }
         
            public int getCount
            {
                get {return top;}
            }
}

public interface IMyObserver
    {
        void UpdateCreate(IMyObservable a);
        void UpdateDelete(IMyObservable a);
    }

 public interface IMyObservable
    {
        void AddObserver(IMyObserver o);
        void RemoveObserver(IMyObserver o);
        void NotifyCreate();
        void NotifyDelete();
    }

 public class CShape : IMyObservable
    {
        public List<IMyObserver> _obs;
 
        public CShape()
        {
            _obs = new List<IMyObserver>();
        }
 
        public void AddObserver(IMyObserver o)
        {
            _obs.Add(o);
        }
 
        public void RemoveObserver(IMyObserver o)
        {
            _obs.Remove(o);
        }
 
        public void NotifyCreate()
        {
            for (int i = 0; i < _obs.Count; ++i)
                _obs[i].UpdateCreate(this);
        }
 
        public void NotifyDelete()
        {
            for (int i = 0; i < _obs.Count; ++i)
                _obs[i].UpdateDelete(this);
        }
    }

    public class Storage<T> where T : IMyObservable
    {
        private int top;
        public T[] s;
 
        public Storage()
        {
            top = 0;
            s = new T[top];
        }
 
        public void Add(T var)
        {
            T[] a = new T[top + 1];
            for (int i = 0; i < top; i++) a[i] = s[i];
            a[top] = var;
            a[top].NotifyCreate();
            top++;
            s = a;
        }
 
        public void Remove(int index)
        {
            if (top == 0) return;
            s[index].NotifyDelete();
            T[] a = new T[top - 1];
            for (int i = 0, j = 0; i < top; i++)
            {
                if (i != index)
                {
                    a[j] = s[i];
                    j++;
                }
            }
            s = a;
            top--;
        }
 
        public T this[int index]
        {
            get { return s[index]; }
        }
 
        public int getCount
        {
            get { return top; }
        }
    }

    public partial class Form1 : Form, IMyObserver
    {
 
        public Form1()
        {
            InitializeComponent();
        }
   
        Storage<CShape> storage = new Storage<CShape>();
 
        private void button1_Click(object sender, EventArgs e)
        {
            var shape = new CShape();
            shape.AddObserver(this); // добавляем подписчика
            storage.Add(shape);
        }
 
        private void button2_Click(object sender, EventArgs e)
        {
            storage.Remove(0);
        }
 
        public void UpdateCreate(IMyObservable a)
        {
            TreeNode node = new TreeNode(a.GetType().Name);
            node.Name = a.GetType().Name;
            treeView1.Nodes.Add(node);
        }
 
        public void UpdateDelete(IMyObservable a)
        {
            TreeNode[] nodes = treeView1.Nodes.Find(a.GetType().Name, true);
            if (nodes.Length > 0)
                treeView1.Nodes.Remove(nodes[0]);
        }
    }