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

public interface IEmployee
{
    int VacationWeeks { get; }
    int YearsWithCompany { set; get; }
    double Salary { set; get; }
}
public class Employee : IEmployee
{
    private readonly int vacationWeeks;
    public Employee(int vacationWeeks)
    {
        this.vacationWeeks = vacationWeeks;
    }
    public int VacationWeeks
    {
        get { return vacationWeeks; }
    }
    public int YearsWithCompany { set; get; }
    public double Salary { set; get; }
}

public class EmployeeNew : IEmployee
{
    private Dictionary<int,int> vacationWeeksTable;
    public EmployeeNew(Dictionary<int, int> vacationWeeksTable)
    {
        this.vacationWeeksTable = vacationWeeksTable;
    }
    public int VacationWeeks
    {
        get { return vacationWeeksTable[YearsWithCompany]; }
    }
    public int YearsWithCompany { set; get; }
    public double Salary { set; get; }
}

// this class does two things, which I do not like
    public class EmployeeList : IEnumerable<IEmployee>, IEmployee
    {
        private Dictionary<int, int> vacationWeeksTable;
        private List<EmployeeSpecificData> employees;
        private int currentIndex;
        private EmployeeSpecificData CurrentEmployee
        {
            get { return employees[currentIndex]; }
        }
        public IEnumerator<IEmployee> GetEnumerator()
        {
            for (currentIndex = 0; currentIndex < employees.Count; currentIndex++)
            {
                yield return this;
            }
        }
        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }
        public int VacationWeeks
        {
            get { return vacationWeeksTable[YearsWithCompany]; }
        }
        // this is ugly repetitive code I don't like
        public int YearsWithCompany
        {
            get { return CurrentEmployee.YearsWithCompany; }
            set { CurrentEmployee.YearsWithCompany = value; }
        }
        // this is ugly repetitive code I don't like
        public double Salary
        {
            get { return CurrentEmployee.Salary; }
            set { CurrentEmployee.Salary = value; }
        }

    }

我使用以下内容来创建和初始化一些需要默认和共享行为的类。也许如果你能重构它会有所帮助：

它是Factory和FlyWeight模式组合的某种形式（在您的场景中可以删除FlyWeight部分），此外还具有类类型共享处理程序的概念。

我简化并删除了一些你不需要的东西，但还有更多需要删除的，我添加了评论。

用法为：（app init）

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

无论何时创建Employee类：

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

它只需要一个对类的WeakReference，所以您不必担心GC。

每个员工在创建时都会有共享的假期WeeksTable设置，如果不使用工厂类，则不可能在创建后从外部更改。

您可以在应用程序运行时的任何时刻更改Employee的所有运行实例的休假表，方法是：

// 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>>();
    }
}

代码模式实现：

IBaseClass：通过工厂创建的每个类实现的接口

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);
                }
            }
        } 
    }

创建一个包含Dictionary的类。创建或获取这个新类的实例将以一致的方式加载字典。然后，BO可以获取该类的一个实例，从而确保它们都使用相同的数据（因为包含列表的类知道如何用正确的数据集加载自己）。