C# 委托后果：不喜欢公共方法

Question

I'm learning C#. Now I'm fiddling with delegates and events. My question is regarding the delegate: it seems I must keep the method public virtual bool IsPromotable(Employee e, PromotionDelegate pd) public. Suppose I want it protected. What do I do now? Or is this example a bad use of the delegate? Or must I simply accept public methods when using delegates? Below is the fully compilable code:

using System;

namespace Delegate_Tutorial_1
{

    public class EmployeeEventArgs : EventArgs
    {
        public Employee Employee { get; set; }
    }

    //--

    public class Employee
    {
        public string Name { get; set; }
        public int YearsOfService { get; set; }

        public event EventHandler<EmployeeEventArgs> HourlyRateChanged;

        private double hourlyRate;
        public double HourlyRate
        {
            get { return hourlyRate; }
            set
            {
                if (hourlyRate != value)
                {
                    hourlyRate = value;
                    OnHourlyRateChanged();
                }
            }
        }

        protected virtual void OnHourlyRateChanged()
        {
            if (HourlyRateChanged != null)
                HourlyRateChanged(this, new EmployeeEventArgs() { Employee = this});
        }


        public virtual bool IsPromotable(Employee e, PromotionDelegate pd)
        {
            return pd(e);
        }
    }
}

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

namespace Delegate_Tutorial_1
{
    public delegate bool PromotionDelegate(Employee emp);

    class Program
    {
        static void Main(string[] args)
        {

            PromotionDelegate promoDelegate = PromotionCheck;

            List<Employee> EmployeeList = new List<Employee>();
            EmployeeList.Add(new Employee() { Name = "John", YearsOfService = 5, HourlyRate = 15 });
            EmployeeList.Add(new Employee() { Name = "Mary", YearsOfService = 4, HourlyRate = 17 });

            foreach (Employee emp in EmployeeList)
            {
                emp.HourlyRateChanged += OnHourlyRateChanged; //Subscribe to the event of the Employee

                if (emp.IsPromotable(emp, promoDelegate))
                {
                    emp.HourlyRate *= 1.1;
                    Console.WriteLine(emp.Name + " : eligable for promotion. Salary now is: " + emp.HourlyRate);
                }
            }
            Console.ReadLine();
        }


        //--

        public static bool PromotionCheck(Employee emp)
        {
            return emp.YearsOfService >= 5 ? true : false;
        }

        public static void OnHourlyRateChanged(object source, EmployeeEventArgs args)
        {
            Console.WriteLine("Hourly salary has been changed for: " + args.Employee.Name);
        }

    }
}

Answer 1

The fact that you need to call IsPromotable on your Employee class from your class Program is the reason that it needs to be public . It has nothing to do with whether or not you're using delegates.

Being public it has all of the virtues of being protected anyway. All of the Employee class descendants can see IsPromotable and override it (as it is also virtual ).

Now, just a couple of other hints for you.

With your OnHourlyRateChanged method in Employee you should structure the code like this:

protected virtual void OnHourlyRateChanged()
{
    var hrc = this.HourlyRateChanged;
    if (hrc != null)
    {
        hrc(this, new EmployeeEventArgs() { Employee = this });
    }
}

The reason is that in multi-threaded code the delegate may change from after the check but before the call. It doesn't happen often, but when it does it can cause your program to throw an exception and it becomes very hard to debug. Your code may not be multi-threaded, but you should always get into using this pattern as a habit.

Also, in Program you have called the event handler OnHourlyRateChanged . The normal convention is to use the On* naming for the method that raises the event, but not for the method that handles the event. It is more common for this method to be called something like Employee_HourlyRateChanged . Again this is a good habit to get into to avoid ambiguity in the future.