覆盖列表属性

根据原始设计，只有糟糕的解决方案：

    public class Customer
    {
        protected List<CustomerAddress> _customerAddresList 
           = new List<CustomerAddress>();
    }
    public class Worker : Customer
    {
    }
    public class CustomerAddress
    {
        protected string _Address1;
        public virtual string Address1
        {
            get { return "customer address: " + _Address1; }
            set { _Address1 = value; }
        }
    }
    public class WorkerAddress: CustomerAddress
    {
        public override string Address1
        {
            get { return "Worker Address: " + _Address1; }
        }
    }

如果实体实例是继承的，我们有这个：

    // Inheriting instances
    public class CustomerBL : Customer
    {
        public void AddAdress(CustomerAddress address)
        {
            _customerAddresList.Add(address);
        }
    }
    public class WorkerBL: Worker
    {
        // Not inehritable, different signature
        public void AddAdress(WorkerAddress address)
        {
            _customerAddresList.Add(address);
        }
    }

如果我们继承 BL 类，我们有这个：

    // Inheriting BL
    public class CustomerBL2 : Customer
    {
        public virtual void AddAdress(CustomerAddress address)
        {
            _customerAddresList.Add(address);
        }
    }
    public class WorkerBL2 : CustomerBL2
    {
        public override void AddAdress(CustomerAddress address)
        {
            if (!(address is WorkerAddress))
                throw new Exception();
            base.AddAdress(address);
        }
    }

如果我们使用泛型，我们有这个

    // Using generics
    public class Generic<TAddress>
    {
        private List<TAddress> _addresList
            = new List<TAddress>();
        protected virtual List<TAddress> AddresList
        {
            get { return _addresList; }
        }
    }
    public class CustomerG : Generic<CustomerAddress>
    {
    }
    public class WorkerG : Generic<WorkerAddress>
    {
    }

毫无疑问，问题在于有两种不同的继承链：

• 实体之一
• 另一个 BL 类

好的决定，哪个是最重要的（事实上，我认为，通过这种设计，没有办法正确地做到这一点）。

最好让实体和 BL 类彼此独立，这样您就可以保持两个继承链的独立，并决定在其链中可以和应该继承的内容。

    public class Address
    {
    }

实体可以相互继承。好的，典型案例：

    public class Person
    {
        public List<Address> Adresses;
    }
    public class Worker: Person
    {
        // inherits adresses
    }

继承 BL 类（不喜欢它）：

    public class PersonBl
    {
        // Functionality which is common fot all the inheritance chain
        public void PrintAdresses(Person person)
        {
        }
        // Functionality that can be specialized for each inherited entity
        public virtual void SaveAdresses(Person person)
        {
            // they're are treated differently in each case
        }
        // Functionality specific of person
        public void DoSomethingWithPerson(Person person)
        {
            // TODO
        }
    }
    public class WorkerBl : PersonBl
    {
        // Uses PersonBl PrintAdresses
        public override void SaveAdresses(Person person)
        {
            // do it for worker
        }
        // Functionality specific of Worker
        public void DoSomethingWithWorker(Worker worker)
        {
            // TODO
        }
    }

"使用其他 BL 类的 BL 类"（这就是我喜欢的方式）：

    public class Person2Bl
    {
        // Functionality which is common for all the inheritance chain of entities
        public void PrintAdresses(Person person)
        {
        }
        public void SaveAdresses(Person person)
        {
           // specific for person
        }
        // Functionality specific of person
        public void DoSomethingWithPerson(Person person)
        {
        }
    }

    // doesn't inherit:
    public class Worker2Bl
    {
        // Use the logic in PersonBl2
        public void PrintAdresses(Worker worker)
        {
            // Really not necessary -> this could be done directly in the app code
            Person2Bl bl = new Person2Bl();
            bl.PrintAdresses(worker);
        }
        public void SaveAdresses(Worker worker)
        {
           // specific of Worker
        }
        public void DoSomethingWithWorker(Worker worker)
        {
            // specific of worker
        }
    }

事实上，最好有一个可以被WorkerBl2和PersonBl2使用的AddressBl

我认为您不应该从其他层的实体继承您的业务实体。请改用映射（手动或使用自动映射器等工具）。

即使不是很清楚你想实现什么，但考虑到你的评论：

所以我会创建另一个类公共类 Worker ： 客户 { public override CustomerAddress.TeleNumber {get; set; } }正在尝试 像这样覆盖它不起作用

我会这样做：

public class Customer 
{
    protected string telNumber =string.Empty; 
    public virtual string TelephoneNumber 
    {
      get { return telNumber ; }
      set {telNumber =value;}
    }
}
public class Worker : Customer 
{
   public override string TelephoneNumber 
   {
       get 
       {
          Console.WriteLine("Worker");
          return telNumber ; 
       }
       set {telNumber = value;}
   }
}

之后，如果你在代码中使用它，就像这样：

Customer curst = new Worker(); 
var telNumber = curst.TelephoneNumber ;

它将产生如下输出：

Worker

如果这不是您要要求的，请澄清。