首页 文章

代表和活动之间有什么区别?

提问于
浏览
278

代表和活动之间有什么区别?两者都不能保存对可以执行的函数的引用吗?

10 回答

  • 6

    Event 声明在 delegate 实例上添加了一层抽象和保护 . 此保护可防止委托的客户端重置委托及其调用列表,并仅允许从调用列表中添加或删除目标 .

  • 91

    除了语法和操作属性之外,还存在语义差异 .

    从概念上讲,代表是功能模板;也就是说,它们表达了一个函数必须遵守的 Contract ,以便被认为是代表的“类型” .

    事件代表......好吧,事件 . 它们旨在在某些事情发生时提醒某人,是的,它们遵循代理定义,但它们不是一回事 .

    即使它们完全相同(语法和IL代码),仍然会保留语义差异 . 一般来说,我更喜欢为两个不同的概念设置两个不同的名称,即使它们以相同的方式实现(这并不意味着我喜欢两次使用相同的代码) .

  • 6

    要了解这些差异,您可以看看这2个示例

    代表示例(在本例中为Action - 这是一种不返回值的委托)

    public class Animal
    {
        public Action Run {get; set;}
    
        public void RaiseEvent()
        {
            if (Run != null)
            {
                Run();
            }
        }
    }
    

    要使用委托,您应该执行以下操作:

    Animal animal= new Animal();
    animal.Run += () => Console.WriteLine("I'm running");
    animal.Run += () => Console.WriteLine("I'm still running") ;
    animal.RaiseEvent();
    

    这段代码运作良好,但你可能会有一些弱点 .

    例如,如果我写这个:

    animal.Run += () => Console.WriteLine("I'm running");
    animal.Run += () => Console.WriteLine("I'm still running");
    animal.Run = () => Console.WriteLine("I'm sleeping") ;
    

    使用最后一行代码,我已经覆盖了以前的行为只是缺少一个 + (我使用 = 而不是 +=

    另一个弱点是每个使用你的 Animal 类的类都可以提升 RaiseEvent 只是称它为 animal.RaiseEvent() .

    要避免这些弱点,您可以在c#中使用 events .

    您的Animal类将以这种方式更改:

    public class ArgsSpecial : EventArgs
    {
        public ArgsSpecial (string val)
        {
            Operation=val;
        }
    
        public string Operation {get; set;}
    } 
    
    public class Animal
    {
        // Empty delegate. In this way you are sure that value is always != null 
        // because no one outside of the class can change it.
        public event EventHandler<ArgsSpecial> Run = delegate{} 
    
        public void RaiseEvent()
        {  
             Run(this, new ArgsSpecial("Run faster"));
        }
    }
    

    召唤事件

    Animal animal= new Animal();
     animal.Run += (sender, e) => Console.WriteLine("I'm running. My value is {0}", e.Operation);
     animal.RaiseEvent();
    

    区别:

    • 您没有使用公共属性,而是使用公共字段(使用事件,编译器保护您的字段免受不必要的访问)

    • 事件可能会导致我在覆盖行为时显示的上一个错误 .

    • 班上没有人可以举起活动 .

    • 事件可以包含在接口声明中,而字段则不能

    笔记:

    EventHandler被声明为以下委托:

    public delegate void EventHandler (object sender, EventArgs e)
    

    它需要一个发送者(对象类型)和事件参数 . 如果发件人来自静态方法,则它为null .

    此示例使用 EventHandler<ArgsSpecial> ,也可以使用 EventHandler 编写 .

    有关EventHandler的文档,请参阅here

  • 82

    这是一个老帖子,但如果有人发现它,就像我做的那样 - 这是另一个很好的链接来引用.. http://csharpindepth.com/Articles/Chapter2/Events.aspx

    简而言之,从文章中删除 - 事件是对代表的封装 . 从文章引用 -

    “假设事件在C#/ .NET中不存在作为概念 . 另一个类如何订阅事件?三个选项:由属性委托变量支持的公共委托变量委托变量与AddXXXHandler和RemoveXXXHandler方法选项1显然很可怕,由于所有正常原因,我们厌恶公共变量 . 选项2更好,但允许订阅者有效地互相覆盖 - 编写someInstance.MyEvent = eventHandler会很容易;这将替换任何现有的事件处理程序而不是添加新的另外,你仍然需要编写属性 . 选项3基本上是事件给你的,但有一个保证的约定(由编译器生成并由IL中的额外标志支持)和一个“免费”实现,如果你'对字段事件给你的语义感到满意 . 对事件进行订阅和取消订阅是封装的,不允许任意访问事件处理程序列表,语言可以使用通过为声明和订阅提供语法,简化了操作 . “

  • 6

    您还可以在接口声明中使用事件,而不是代理人使用事件 .

  • 250

    注意:如果您有权访问C# 5.0 Unleashed,请阅读 Headers 为"Events"的第18章中的"Limitations on Plain Use of Delegates",以更好地理解两者之间的差异 .


    有一个简单,具体的例子总能帮助我 . 所以这是社区的一个 . 首先,我将展示如何单独使用代表来完成事件为我们所做的事情 . 然后我展示了同样的解决方案如何使用 EventHandler 的实例 . 然后我解释为什么我们不想做我在第一个例子中解释的内容 . 这篇文章的灵感来自John Skeet的an article .

    示例1:使用公共委托

    假设我有一个带有单个下拉框的WinForms应用程序 . 下拉列表绑定到 List<Person> . Person具有Id,Name,NickName,HairColor的属性 . 在主窗体上是一个自定义用户控件,显示该人员的属性 . 当有人在下拉列表中选择某个人时,用户控件中的标签会更新以显示所选人员的属性 .

    enter image description here

    这是如何工作的 . 我们有三个文件可以帮助我们将它们放在一起:

    • Mediator.cs - 静态类保存委托

    • Form1.cs - 主要表格

    • DetailView.cs - 用户控件显示所有细节

    以下是每个类的相关代码:

    class Mediator
    {
        public delegate void PersonChangedDelegate(Person p); //delegate type definition
        public static PersonChangedDelegate PersonChangedDel; //delegate instance. Detail view will "subscribe" to this.
        public static void OnPersonChanged(Person p) //Form1 will call this when the drop-down changes.
        {
            if (PersonChangedDel != null)
            {
                PersonChangedDel(p);
            }
        }
    }
    

    这是我们的用户控件:

    public partial class DetailView : UserControl
    {
        public DetailView()
        {
            InitializeComponent();
            Mediator.PersonChangedDel += DetailView_PersonChanged;
        }
    
        void DetailView_PersonChanged(Person p)
        {
            BindData(p);
        }
    
        public void BindData(Person p)
        {
            lblPersonHairColor.Text = p.HairColor;
            lblPersonId.Text = p.IdPerson.ToString();
            lblPersonName.Text = p.Name;
            lblPersonNickName.Text = p.NickName;
    
        }
    }
    

    最后,我们在Form1.cs中有以下代码 . 这里我们调用OnPersonChanged,它调用订阅该委托的任何代码 .

    private void comboBox1_SelectedIndexChanged(object sender, EventArgs e)
    {
        Mediator.OnPersonChanged((Person)comboBox1.SelectedItem); //Call the mediator's OnPersonChanged method. This will in turn call all the methods assigned (i.e. subscribed to) to the delegate -- in this case `DetailView_PersonChanged`.
    }
    

    好 . 这就是如何在不使用事件和仅使用委托的情况下使其工作 . 我们只是将一个公共委托放入一个类 - 你可以使它成为静态或单个,或者其他什么 . 大 .

    但是,但是,我们不想做我刚才描述的事情 . 因为public fields are bad很多很多原因 . 那么我们有什么选择呢?正如John Skeet所描述的,以下是我们的选择:

    • 一个公共委托变量(这就是我们上面刚才所做的 . 不要't do this. i just told you above why it'不好)

    • 将委托放入带有get / set的属性中(这里的问题是订阅者可以互相覆盖 - 所以我们可以向委托订阅一堆方法然后我们可能会意外地说 PersonChangedDel = null ,消除所有其他订阅这里剩下的另一个问题是,由于用户可以访问委托,他们可以调用调用列表中的目标 - 我们不希望外部用户有权访问何时提出我们的事件 .

    • 具有AddXXXHandler和RemoveXXXHandler方法的委托变量

    第三种选择基本上是一个事件给我们的东西 . 当我们声明一个EventHandler时,它允许我们访问一个委托 - 不是公开的,不是作为属性,但是我们称之为只添加/删除访问者的事件 .

    让我们看看相同的程序是什么样的,但现在使用Event代替公共委托(我还将我们的Mediator更改为单例):

    示例2:使用EventHandler而不是公共委托

    中保

    class Mediator
    {
    
        private static readonly Mediator _Instance = new Mediator();
    
        private Mediator() { }
    
        public static Mediator GetInstance()
        {
            return _Instance;
        }
    
        public event EventHandler<PersonChangedEventArgs> PersonChanged; //this is just a property we expose to add items to the delegate.
    
        public void OnPersonChanged(object sender, Person p)
        {
            var personChangedDelegate = PersonChanged as EventHandler<PersonChangedEventArgs>;
            if (personChangedDelegate != null)
            {
                personChangedDelegate(sender, new PersonChangedEventArgs() { Person = p });
            }
        }
    }
    

    请注意,如果您在EventHandler上使用F12,它将向您显示定义只是一个带有额外“sender”对象的通用ified委托:

    public delegate void EventHandler<TEventArgs>(object sender, TEventArgs e);
    

    用户控制:

    public partial class DetailView : UserControl
    {
        public DetailView()
        {
            InitializeComponent();
            Mediator.GetInstance().PersonChanged += DetailView_PersonChanged;
        }
    
        void DetailView_PersonChanged(object sender, PersonChangedEventArgs e)
        {
            BindData(e.Person);
        }
    
        public void BindData(Person p)
        {
            lblPersonHairColor.Text = p.HairColor;
            lblPersonId.Text = p.IdPerson.ToString();
            lblPersonName.Text = p.Name;
            lblPersonNickName.Text = p.NickName;
    
        }
    }
    

    最后,这是Form1.cs代码:

    private void comboBox1_SelectedIndexChanged(object sender, EventArgs e)
    {
            Mediator.GetInstance().OnPersonChanged(this, (Person)comboBox1.SelectedItem);
    }
    

    因为EventHandler想要和EventArgs作为参数,所以我创建了这个类,其中只有一个属性:

    class PersonChangedEventArgs
    {
        public Person Person { get; set; }
    }
    

    希望这能告诉你为什么我们有事件以及它们如何不同 - 但在功能上与代表一样 .

  • 4

    事件和代表之间的误会真是太棒了!委托指定TYPE(例如 classinterface ),而事件只是一种成员(例如字段,属性等) . 并且,就像任何其他类型的成员一样,事件也有类型 . 但是,在事件的情况下,事件的类型必须由委托指定 . 例如,您不能声明由接口定义的类型的事件 .

    最后,我们可以进行以下 Observation: the type of an event MUST be defined by a delegate . 这是事件和委托之间的主要关系,并在ECMA-335 (CLI) Partitions I to VIII.18 Defining events 部分中进行了描述:

    在典型用法中,TypeSpec(如果存在)标识一个委托,其签名与传递给事件的fire方法的参数匹配 .

    但是, this fact does NOT imply that an event uses a backing delegate field . 实际上,事件可能使用您选择的任何不同数据结构类型的支持字段 . 如果你在C#中显式地实现了一个事件,你可以自由选择存储 event handlers 的方式(注意 event handlerstype of the event 的实例,而这反过来强制地是 delegate type ---来自之前的 Observation ) . 但是,您可以将这些事件处理程序(它们是委托实例)存储在数据结构中,例如 ListDictionary 或任何其他内容,甚至是支持委托字段 . 但不要忘记,您不必使用委托字段 .

  • 34

    .net中的事件是Add方法和Remove的指定组合方法,两者都期望某些特定类型的委托 . C#和vb.net都可以为添加和删除方法自动生成代码,这些方法将定义用于保存事件订阅的委托,并在该订阅委托中添加/删除传入的委托 . 当且仅当它非空时,VB.net还将自动生成代码(使用RaiseEvent语句)来调用订阅列表;由于某种原因,C#不会产生后者 .

    请注意,尽管使用多播委托管理事件订阅是很常见的,但这并不是这样做的唯一方法 . 从公众的角度来看,潜在事件订阅者需要知道如何让对象知道它想要接收事件,但是不需要知道发布者将使用什么机制来引发事件 . 还要注意,虽然在.net中定义事件数据结构的人显然认为应该有一种提升它们的公共方法,但C#和vb.net都不会使用该功能 .

  • 3

    To define about event in simple way:

    对于有两个限制的委托,事件是 REFERENCE

    • 无法直接调用

    • 无法直接赋值(例如eventObj = delegateMethod)

    以上两个是代表们的弱点,并在事件中得到解决 . 完整的代码示例显示fiddler的区别在于https://dotnetfiddle.net/5iR3fB .

    切换Event和Delegate之间的注释以及调用/赋值给委托的客户端代码以理解差异

    这是内联代码 .

    /*
    This is working program in Visual Studio.  It is not running in fiddler because of infinite loop in code.
    This code demonstrates the difference between event and delegate
            Event is an delegate reference with two restrictions for increased protection
    
                1. Cannot be invoked directly
                2. Cannot assign value to delegate reference directly
    
    Toggle between Event vs Delegate in the code by commenting/un commenting the relevant lines
    */
    
    public class RoomTemperatureController
    {
        private int _roomTemperature = 25;//Default/Starting room Temperature
        private bool _isAirConditionTurnedOn = false;//Default AC is Off
        private bool _isHeatTurnedOn = false;//Default Heat is Off
        private bool _tempSimulator = false;
        public  delegate void OnRoomTemperatureChange(int roomTemperature); //OnRoomTemperatureChange is a type of Delegate (Check next line for proof)
        // public  OnRoomTemperatureChange WhenRoomTemperatureChange;// { get; set; }//Exposing the delegate to outside world, cannot directly expose the delegate (line above), 
        public  event OnRoomTemperatureChange WhenRoomTemperatureChange;// { get; set; }//Exposing the delegate to outside world, cannot directly expose the delegate (line above), 
    
        public RoomTemperatureController()
        {
            WhenRoomTemperatureChange += InternalRoomTemperatuerHandler;
        }
        private void InternalRoomTemperatuerHandler(int roomTemp)
        {
            System.Console.WriteLine("Internal Room Temperature Handler - Mandatory to handle/ Should not be removed by external consumer of ths class: Note, if it is delegate this can be removed, if event cannot be removed");
        }
    
        //User cannot directly asign values to delegate (e.g. roomTempControllerObj.OnRoomTemperatureChange = delegateMethod (System will throw error)
        public bool TurnRoomTeperatureSimulator
        {
            set
            {
                _tempSimulator = value;
                if (value)
                {
                    SimulateRoomTemperature(); //Turn on Simulator              
                }
            }
            get { return _tempSimulator; }
        }
        public void TurnAirCondition(bool val)
        {
            _isAirConditionTurnedOn = val;
            _isHeatTurnedOn = !val;//Binary switch If Heat is ON - AC will turned off automatically (binary)
            System.Console.WriteLine("Aircondition :" + _isAirConditionTurnedOn);
            System.Console.WriteLine("Heat :" + _isHeatTurnedOn);
    
        }
        public void TurnHeat(bool val)
        {
            _isHeatTurnedOn = val;
            _isAirConditionTurnedOn = !val;//Binary switch If Heat is ON - AC will turned off automatically (binary)
            System.Console.WriteLine("Aircondition :" + _isAirConditionTurnedOn);
            System.Console.WriteLine("Heat :" + _isHeatTurnedOn);
    
        }
    
        public async void SimulateRoomTemperature()
        {
            while (_tempSimulator)
            {
                if (_isAirConditionTurnedOn)
                    _roomTemperature--;//Decrease Room Temperature if AC is turned On
                if (_isHeatTurnedOn)
                    _roomTemperature++;//Decrease Room Temperature if AC is turned On
                System.Console.WriteLine("Temperature :" + _roomTemperature);
                if (WhenRoomTemperatureChange != null)
                    WhenRoomTemperatureChange(_roomTemperature);
                System.Threading.Thread.Sleep(500);//Every second Temperature changes based on AC/Heat Status
            }
        }
    
    }
    
    public class MySweetHome
    {
        RoomTemperatureController roomController = null;
        public MySweetHome()
        {
            roomController = new RoomTemperatureController();
            roomController.WhenRoomTemperatureChange += TurnHeatOrACBasedOnTemp;
            //roomController.WhenRoomTemperatureChange = null; //Setting NULL to delegate reference is possible where as for Event it is not possible.
            //roomController.WhenRoomTemperatureChange.DynamicInvoke();//Dynamic Invoke is possible for Delgate and not possible with Event
            roomController.SimulateRoomTemperature();
            System.Threading.Thread.Sleep(5000);
            roomController.TurnAirCondition (true);
            roomController.TurnRoomTeperatureSimulator = true;
    
        }
        public void TurnHeatOrACBasedOnTemp(int temp)
        {
            if (temp >= 30)
                roomController.TurnAirCondition(true);
            if (temp <= 15)
                roomController.TurnHeat(true);
    
        }
        public static void Main(string []args)
        {
            MySweetHome home = new MySweetHome();
        }
    
    
    }
    
  • 0

    CovarianceContravariance 为委托对象提供了额外的灵活性 . 另一方面,事件没有这样的概念 .

    • Covariance 允许您为委托分配一个方法,其中方法的返回类型是一个类,该类派生自指定委托的返回类型的类 .

    • Contravariance 允许您为委托分配方法,其中方法的参数类型是指定为委托参数的类的基类 .

相关问题