重构对象列表以实现业务规则

Dictionary<int,int> vacationWeeksTable = new Dictionary<int,int>();
// fill the table
Factory<Employee>.Init(vacationWeeksTable);

// remove grouping in the factory class to remove this null
Employee em = Factory<Employee>.Create(null);

// this will call the method registered for SetInitialdata on all instances of Employee classes.
// again remove grouping to remove that null
Factory<Employee>.Call(EventHandlerTypes.SetInitialData, null, vacTable);

class Employee : IBaseClass
{
    private Dictionary<int, int> vacationWeeksTable;

    public virtual void RegisterSharedHandlers(int? group, Action<IKey, int?, EventHandlerTypes, Action<object, SharedEventArgs>> register)
    {
        group = 0; // disable different groups
        register(new Key<Employee, int>(0), group, EventHandlerTypes.SetInitialData, SetVacationWeeksTable);
    }

    public virtual void RegisterSharedData(Action<IKey, object> regData)
    {
        // remove this from factory and interface, you probably dont need it
        // I have been using it as a FlyWeight data store for classes.            
    }

    private void SetVacationWeeksTable(object sender, SharedEventArgs e)
    {
        vacationWeeksTable = e.GetData<Dictionary<int, int>>();
    }

}

public enum EventHandlerTypes
{
    SetInitialData // you can add additional shared handlers here and Factory<C>.Call - it.
}

public class SharedEventArgs : EventArgs
{
    private object data;

    public SharedEventArgs(object data)
    {
        this.data = data;
    }

    public T GetData<T>()
    {
        return (T)data;
    }
}

public interface IBaseClass
{
    void RegisterSharedHandlers(int? group, Action<IKey, int?, EventHandlerTypes, Action<object, SharedEventArgs>> regEvent);
    void RegisterSharedData(Action<IKey, object> regData);
}

public interface IKey
{
    Type GetKeyType();
    V GetValue<V>();
}

public class Key<T, V> : IKey
{
    public V ID { get; set; }
    public Key(V id)
    {
        ID = id;
    }

    public Type GetKeyType()
    {
        return typeof(T);
    }

    public Tp GetValue<Tp>()
    {
        return (Tp)(object)ID;
    }
}

public class Triple<T, V, Z>
{
    public T First { get; set; }
    public V Second { get; set; }
    public Z Third { get; set; }
    public Triple(T first, V second, Z third)
    {
        First = first;
        Second = second;
        Third = third;
    }
}

   public static class Factory<C> where C : IBaseClass, new()
    {
        private static object initialData;
        private static Dictionary<IKey, Triple<EventHandlerTypes, int, WeakReference>> handlers = new Dictionary<IKey, Triple<EventHandlerTypes, int, WeakReference>>();
        private static Dictionary<IKey, object> data = new Dictionary<IKey, object>();

        static Factory()
        {
            C newClass = new C();
            newClass.RegisterSharedData(registerSharedData);
        }

        public static void Init<IT>(IT initData)
        {
            initialData = initData;
        }

        public static Dt[] GetData<Dt>()
        {
            var dataList = from d in data where d.Key.GetKeyType() == typeof(Dt) select d.Value;

            return dataList.Cast<Dt>().ToArray();
        }

        private static void registerSharedData(IKey key, object value)
        {
            data.Add(key, value);
        }

        public static C Create(int? group)
        {
            C newClass = new C();
            newClass.RegisterSharedHandlers(group, registerSharedHandlers);
            // this is a bit bad here since it will call it on all instances
            // it would be better if you can call this from outside after creating all the classes
            Factory<C>.Call(EventHandlerTypes.SetInitialData, null, initialData);
            return newClass;
        }

        private static void registerSharedHandlers(IKey subscriber, int? group, EventHandlerTypes type, Action<object, SharedEventArgs> handler)
        {
            handlers.Add(subscriber, new Triple<EventHandlerTypes, int, WeakReference>(type, group ?? -1, new WeakReference(handler)));
        }

        public static void Call<N>(EventHandlerTypes type, int? group, N data)
        {
            Call<N>(null, type, group, data);
        }

        public static void Call<N>(object sender, EventHandlerTypes type, int? group, N data)
        {
            lock (handlers)
            {
                var invalid = from h in handlers where h.Value.Third.Target == null select h.Key;

                // delete expired references
                foreach (var inv in invalid.ToList()) handlers.Remove(inv);

                var events = from h in handlers where h.Value.First == type && (!@group.HasValue || h.Value.Second == (int)@group) select h.Value.Third;

                foreach (var ev in events.ToList())
                {
                    // call the handler
                    ((Action<object, SharedEventArgs>)ev.Target)(sender, arg);
                }
            }
        } 
    }