-3

在下面的代码中，在派生类中，ArrayList我们使用了 as 方法OnChanged()。

这个类被声明为： protected virtual void OnChanged(EventArgs e)

问题：受保护和虚拟关键字背后的目的是什么？

无论如何它会起作用，但我需要知道使用受保护的访问修饰符和虚拟的目的。这段代码的最后一件事是来自 MSDN 页面，该页面教授如何让用户代表启动一个事件。

using System;

namespace DelegateForEvents
{
    using System.Collections;

    // A delegate type of hooking up change notificatins.
    public delegate void ChangedEventHandler(object sender, EventArgs e);

    // A class that works just like ArrayList, but sends notifications whevern the list changes.
    public class ListWithChangedEvent : ArrayList
    {
        // An event that clients can use to be notified whenever the elements of the list change
        public event ChangedEventHandler Changed;

        // Invoke the Changed event; called whenever list changes 
        protected virtual void OnChanged(EventArgs e)
        {
            if (Changed != null)
                Changed(this, e);
        }


        // Override some of the methods that can change the list;
        // Invoke event after each
        public override int Add(object value)
        {
            int i = base.Add(value);
            OnChanged(EventArgs.Empty);

            return i;
        }

        public override void Clear()
        {
            base.Clear();
            OnChanged(EventArgs.Empty);
        }

        public override object this[int index]
        {
            //get
            //{
            //    return base[index];
            //}
            set
            {
                base[index] = value;
                OnChanged(EventArgs.Empty);
            }
        }
    }
}


namespace TestEvents
{
    using DelegateForEvents;

    class EventListener
    {
        private ListWithChangedEvent List;

        public EventListener(ListWithChangedEvent list)
        {
            List = list;
            // Add "ListChanged" to the Changed event on "List"
            List.Changed += new ChangedEventHandler(ListChanged);
        }

        // This will be called whenever the list changes.
        private void ListChanged(object sender, EventArgs e)
        {
            Console.WriteLine("This is called when the event fires");
        }

        public void Detach()
        {
            // Death the event and delete the list
            List.Changed -= new ChangedEventHandler(ListChanged);
            List = null;
        }
    }

    class Test
    {

        // Test the ListWithChangedEvent class
        static void Main()
        {
            // Create a new list
            ListWithChangedEvent list = new ListWithChangedEvent();

            // Create a class that listens to list's change event
            EventListener listener = new EventListener(list);

            // Add and remove items from the list.
            list.Add("item 1");
            list.Clear();
            listener.Detach();
            Console.ReadLine();

        }
    }
}
4

4 回答 4

2

虚拟：此方法旨在被覆盖。调用此方法时，在 IL 中生成 'callvirt' 而不是 'call'。

受保护：此方法对继承自该方法的类可见，但不可公开调用。

于 2012-10-10T22:26:21.923 回答
1

protected意味着该方法可以在派生类中使用，但对外人不可见。有点像private派生类的例外。

virtual意味着无论调用方法的变量类型如何，它总是被调用的实际对象实例的方法。

于 2012-10-10T22:26:21.110 回答
1

虚方法意味着子类可以覆盖基类的实现。virtual 关键字基本上“开启”多态性。

受保护意味着该方法只能由基类和派生类访问。

于 2012-10-10T22:26:45.137 回答
1

protected是一个访问修饰符，它将成员定义为可从声明它的类中访问，以及从声明该成员的类派生的任何类中访问。

virtual表示函数可以被派生类覆盖。这意味着，如果您有另一个继承自ListWithChangedEvent它的类，则可能会改变所做的事情OnChanged。

于 2012-10-10T22:27:35.513 回答