c# - 如何在没有抽象基类的情况下强制覆盖后代中的方法？

Question

问题标题似乎有点困惑，但我会在这里尝试清除我的问题。

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

namespace ConsoleApplication1
{
    public abstract class Employee
    {
        private string name;
        private int empid;
        BenefitPackage _BenefitPackage = new BenefitPackage();
        public string Name
         {
             get { return this.name; }
             set { this.name = value; }
            }
        public int EmpId
        {
            get { return this.empid; }
            set
            {
                if (value == 1)
                    return;
                this.empid = value; }
        }
        public Employee(string Name, int EmpId)
        {
            this.Name = Name;
            this.EmpId = EmpId;
        }
        public Employee()
        { }

        public abstract void GiveBonus();

    }

    public class Manager : Employee
    {
        private int noofstockoptions;
        public override void GiveBonus()
        {
            Console.WriteLine("Manger GiveBonus Override");
        }
        public int NoOfStockOptions
        {
            get { return this.noofstockoptions; }
            set { this.noofstockoptions = value; }
        }

        public Manager(string Name,int EmpId, int NoOfStockOptions):base(Name,EmpId)
        {
            this.NoOfStockOptions=NoOfStockOptions;
        }

    }
    public class SalesPerson:Employee
    {
        private int noofsales;
        public int NoOfSales
        {
            get { return this.noofsales; }
            set { this.noofsales = value; }
        }

        public SalesPerson(string Name, int EmpId, int NoOfSales):base(Name,EmpId)
        {
            this.NoOfSales = NoOfSales;
        }
        public override void GiveBonus()
        {
            Console.WriteLine("Hi from salesperson");
        }
    }
    public sealed class PTSalesPerson : SalesPerson
    {
        private int noofhrworked;
        public int NoOfHrWorked
        {
            get { return this.noofhrworked; }
            set { this.noofhrworked = value; }

        }
        public PTSalesPerson(string Name, int EmpId, int NoOfSales,int NoOfHrWorked):base(Name,EmpId,NoOfSales)
        {
            this.NoOfHrWorked = NoOfHrWorked;

        }
        //public new void GiveBonus()
        //{
        //    Console.WriteLine("hi from ptsalesperson");
        //} 
    }

    class BenefitPackage
    {
        public int Bonus;
        public int GiveBonus()
        {
            int i = 200;
            return i;
        }

        private class innerPublic
        {
            public int innerBonus;

        }


    }

    class MainClass
    {
        public static void Main()
        { 
        Manager _Manager=new Manager("Vaibhav",1,50);
        PTSalesPerson _PTSalesPerson = new PTSalesPerson("Shantanu", 1, 4, 6);
        _Manager.GiveBonus();

        Employee _emp;
        //_emp = new Employee("new emp",4);
        //_emp.GiveBonus();
        _PTSalesPerson.GiveBonus();
        ((SalesPerson)_PTSalesPerson).GiveBonus();
        Console.ReadLine();    
        }

    }
}

请不要试图理解整个代码。我正在总结它。

1. Employee是一个抽象类，它有一个抽象方法GiveBonus
   
2. SalesPerson 派生自 Employee。 SalesPerson 必须定义抽象方法 GiveBonus。(SalesPerson 不能是抽象的)
   
3. PTSalesPerson 派生自 SalesPerson。

现在我的问题是，我如何强制 PTSalesPerson 有自己的 GiveBonus 实现。

Answer 1

我认为您以错误的方式思考这个问题。语言设计者并没有对自己说“我们真正需要的是一种将方法标记为必须被覆盖的方法，让我们发明这个叫做抽象的东西”。他们说“虚方法让我们表达了这样的想法，即该基类型的每个派生类型都应该能够执行该方法。但是如果没有合理的代码可以进入该方法的基类版本吗？我知道，让我们为这种情况发明一种称为抽象方法的东西。”

这就是抽象方法旨在解决的问题:您拥有所有派生类共有的方法，但没有合理的基类实现，而不是“我需要一种方法来强制我的派生类型提供实现”。派生类型被迫提供实现是解决方案的结果，但不是首先要解决的问题。

C# 语言没有解决“我必须强制我的子类型提供他们自己的此方法的实现”问题的机制，因为据我所知，这不是语言设计者曾经考虑过的问题我们的大多数客户。

所以我要问你的问题是:你为什么要这样做？当然，由派生类的开发人员来确定基类实现对于派生类是否正确。那不取决于你。即使您确实有办法做到这一点，开发人员也不会简单地说

override void M() { base.M(); }

?

您能解释一下您试图将这项工作强加给派生类开发人员的目的是什么吗？也许有更好的方法来实现您想要的。

但更一般地说:我不确定您的层次结构首先是否设计合理。当我在 Employee 上看到 GiveBonus 方法时，我认为这意味着“员工可以提供奖金”，而不是“员工可以收到奖金”。当然，经理 会发放奖金，而员工会收到 奖金。我认为您可能让员工层级做得太多了。