C# Dynamic EventArgs

EventParams.cs

// Copyright (c) 2015 David Ruhmann

using System;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Collections.Generic;

namespace ChartedCode
{
    public class EventArgs<T> : EventArgs
    {
        public T value { get; set; }
        public EventArgs(T value) { this.value = value; }
    }

    public class EventArgs<T1, T2> : EventArgs<T1>
    {
        public T2 value2 { get; set; }
        public EventArgs(T1 v1, T2 v2) : base(v1) { this.value2 = v2; }
    }

    public class EventArgs<T1, T2, T3> : EventArgs<T1, T2>
    {
        public T3 value3 { get; set; }
        public EventArgs(T1 v1, T2 v2, T3 v3) : base(v1, v2) { this.value3 = v3; }
    }

    public class EventArgs<T1, T2, T3, T4> : EventArgs<T1, T2, T3>
    {
        public T4 value4 { get; set; }
        public EventArgs(T1 v1, T2 v2, T3 v3, T4 v4) : base(v1, v2, v3) { this.value4 = v4; }
    }

    public class EventArgs<T1, T2, T3, T4, T5> : EventArgs<T1, T2, T3, T4>
    {
        public T5 value5 { get; set; }
        public EventArgs(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5) : base(v1, v2, v3, v4) { this.value5 = v5; }
    }

    public class EventArgs<T1, T2, T3, T4, T5, T6> : EventArgs<T1, T2, T3, T4, T5>
    {
        public T6 value6 { get; set; }
        public EventArgs(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6) : base(v1, v2, v3, v4, v5) { this.value6 = v6; }
    }

    public class EventArgs<T1, T2, T3, T4, T5, T6, T7> : EventArgs<T1, T2, T3, T4, T5, T6>
    {
        public T7 value7 { get; set; }
        public EventArgs(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7) : base(v1, v2, v3, v4, v5, v6) { this.value7 = v7; }
    }

    public class EventArgs<T1, T2, T3, T4, T5, T6, T7, T8> : EventArgs<T1, T2, T3, T4, T5, T6, T7>
    {
        public T8 value8 { get; set; }
        public EventArgs(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8) : base(v1, v2, v3, v4, v5, v6, v7) { this.value8 = v8; }
    }

    public class EventDictionary<TKey, TValue> : EventArgs
    {
        protected Dictionary<TKey, TValue> args { get; set; }

        public EventDictionary() : this(default(object[][])) { }
        public EventDictionary(TKey key, TValue value) : this(new object[]{key, value}) { }
        public EventDictionary(params object[][] args)
        {
            foreach (object[] a in args)
            {
                Add((TKey)a[0], (TValue)a[1]);
            }
        }

        public virtual EventDictionary<TKey, TValue> Add(TKey key, TValue value)
        {
            this.args.Add(key, value);
            return this;
        }

        public virtual T Get<T>(TKey key)// where T : class
        {
            //return this?[key] as T;
            return (T)(object)this[key];
        }

        public TValue this[TKey i]
        {
            get { return args[i]; }
            set { args[i] = value; }
        }
    }

    public class EventDict<T> : EventDictionary<string, T>
    {
        public EventDict() : base() { }
        public EventDict(string key, T value) : base(key, value) { }
        public EventDict(params object[][] args) : base(args) { }
        public virtual EventDict<T> Add(string key, T value) { return (EventDict<T>)base.Add(key, value); }
        public virtual TValue Get<TValue>(string key)
        {
            try
            {
                return base.Get<TValue>(key);
            }
            catch
            {
                return default(TValue);
            }
        }
        public T this[string i]
        {
            get
            {
                try
                {
                    return base[i];
                }
                catch
                {
                    return default(T);
                }
            }

            set { base[i] = value; }
        }
    }

    public class EventDict : EventDict<object>
    {
        public EventDict() : base() { }
        public EventDict(string key, object value) : base(key, value) { }
        public EventDict(params object[][] args) : base(args) { }
        public virtual EventDict Add(string key, object value) { return (EventDict)base.Add(key, value); }
        public virtual object Get(string key) { return base.Get<object>(key); }
        //public object this[string i]
        //{
        //    get { return base[i]; }
        //    set { base[i] = value; }
        //}
    }

    public class EventParams<T> : EventArgs
    {
        protected T[] args { get; set; }

        public EventParams() : this(default(T[])) { }
        public EventParams(params T[] args)
        {
            this.args = args;
        }

        public virtual EventParams<T> Add(T value)
        {
            args[args.Length] = value;
            return this;
        }

        public virtual TValue Get<TValue>(int i)
        {
            try
            {
                return (TValue)(object)this[i];
            }
            catch
            {
                return default(TValue);
            }
        }

        public T this[int i]
        {
            get
            {
                try
                {
                    return args[i];
                }
                catch
                {
                    return default(T);
                }
            }
            set
            {
                try
                {
                    args[i] = value;
                }
                catch
                {
                    T[] arr = new T[i+10];
                    args.CopyTo(arr, 0);
                    args = arr;
                    args[i] = value;
                }
            }
        }
    }

    public class EventParams : EventParams<object>
    {
        public EventParams() : base() { }
        public EventParams(params object[] args) : base(args) { }
        public virtual EventParams Add(object value) { return (EventParams)base.Add(value); }
    }

    //public class TestEventParams<T1, T2> : EventParams
    //{
    //    T1 first { get; set; }
    //    T2 second
    //    public TestEventParams(T1 a, T2 b) : base(a, b) { }
    //    protected void Set(int i) { base[i] }
    //}

    public class ReadOnlyEventParams<T> : EventParams<T>
    {
        public ReadOnlyEventParams() : base() { }
        public ReadOnlyEventParams(params T[] args) : base(args) { }
        public new T this[int i]
        {
            get { return base[i]; }
            private set { base[i] = value; }
        }
    }

    public class ReadOnlyEventParams : ReadOnlyEventParams<object>
    {
        public ReadOnlyEventParams() : base() { }
        public ReadOnlyEventParams(params object[] args) : base(args) { }
    }
}