. NET brief introduction to component programming (relationship between delegate and event)

I have been learning about the. NET Component Programming Technology for some time recently. There are many good things to share with you during the learning process. [Wang qingpei has all rights reserved. For more information, please sign it.]

What is component programming? In fact, it is to use. NET to develop programs based on component models. It is a high level and has not been studied and honed for a long time.

I cannot feel this feeling. Our current development philosophy should be object-oriented, but how to improve this level is only a matter of learning.

In fact, component-Oriented Programming involves the idea of object-oriented programming, which encapsulates a set of functions for reuse in the future. However, in the process of component development, the idea of object-oriented should be used to construct

The two concepts of component creation are not contradictory. The object-oriented thinking is concrete implementation, while the component-oriented thinking should be described at a macro level at the height of a product or framework.

We will not discuss these technical philosophies. learning practical things is more realistic. We only need to know That object-oriented programming is code reuse, while component-oriented programming is implementation reuse. Regardless of the surface

Objects or components-oriented components must be implemented with good code in the final analysis. As long as we start coding, we can inject these ideas into our minds.

In this article, we will first remove some technical questions about delegation and events that are frequently used in component programming. Before learning component programming, I cannot understand the relationship between delegate and event and

What is the intention between the users. However, I had a rough understanding in the recent learning process and decided to write the learned technology and share it with you. [Wang qingpei has all rights reserved. For more information, please sign it.]

In C #, delegate represents the concept of delegation, while event represents the concept of event. But why do they need to be used together? You can implement object-oriented events without event.

All subscribers can be called through multicast delegation.

In fact, I want to explain why we need to use the event mechanism in one sentence, but I will not talk about it here, so it will be meaningless. Please continue.

Let's first look at the Code:

1:

 
 

  
  
Using System;
  
  
Using System. Collections. Generic;
  
  
Using System. Text;
  
  
 
  
  
Namespace EventDemo
  
  
{
  
  
/// <Summary>
  
  
/// Handle remove delegate
  
  
/// </Summary>
  
  
/// <Param name = "handle"> message </param>
  
  
Public delegate void MoveHandler (string handle );
  
  
/// <Summary>
  
  
/// Handle object
  
  
/// </Summary>
  
  
Public class ObjectHandler
  
  
{
  
  
/// <Summary>
  
  
/// Handle event
  
  
/// </Summary>
  
  
Public MoveHandler hand;
  
  
/// <Summary>
  
  
/// Trigger the handle event to notify all subscribers
  
  
/// </Summary>
  
  
Public void Onhand ()
  
  
{
  
  
Hand ("handle event ");
  
  
}
  
  
}
  
  
}
 
 

2:

 
 

  
  
using System;  
  
  
using System.Collections.Generic;  
  
  
using System.Text;  
  
  
 
  
  
namespace EventDemo  
  
  
{  
  
  
    class Program  
  
  
    {  
  
  
        static void Main(string[] args)  
  
  
        {  
  
  
            ObjectHandler handermanager = new ObjectHandler();  
  
  
            handermanager.hand += handmethod;  
  
  
            handermanager.Onhand();  
  
  
        }  
  
  
        public static void handmethod(string eventstring)  
  
  
        {  
  
  
            Console.WriteLine(eventstring);  
  
  
            Console.ReadLine();  
  
  
        }  
  
  
    }  
  
  
}  
 
 

To demonstrate the effect, I randomly named an object, which has no special significance.

I defined an ObjectHandler object and used MoveHandler internally to delegate the instance to represent the event object. When the Onhand method is called, I delegate the instance to call subscribers one by one to achieve the event effect. However, the method for triggering an event is generally not defined as public, but only for display.

[Wang qingpei has all rights reserved. For more information, please sign it.]
We introduce the problem that an event is private within an object. It can only be triggered by an object to comply with the object-oriented rules, but it cannot be achieved by using delegation alone. The delegated instance must be subscribed by the subscriber, so the delegated instance must be public. At this time, the delegated instance cannot guarantee who triggered the event.
See the Code:

3:

 
 

  
  
Using System;
  
  
Using System. Collections. Generic;
  
  
Using System. Text;
  
  
 
  
  
Namespace EventDemo
  
  
{
  
  
Class Program
  
  
{
  
  
Static void Main (string [] args)
  
  
{
  
  
ObjectHandler handermanager = new ObjectHandler ();
  
  
Handermanager. hand + = handmethod;
  
  
Handermanager. Onhand ();
  
  
 
  
  
/* I cheat all subscribers by triggering internal delegation of the object.
  
  
All subscribers think that the events sent by ObjectHandler are actually simulated by someone secretly. */
  
  
Handermanager. hand ("killing with a knife ");
  
  
}
  
  
Public static void handmethod (string eventstring)
  
  
{
  
  
Console. WriteLine (eventstring );
  
  
Console. ReadLine ();
  
  
}
  
  
}
  
  
}
 
 

The subscriber has no reason to take responsibility for this unexpected event. The ObjectHandler object must take responsibility for this.

So how to avoid events from being triggered by malicious users? This requires the event keyword. If the delegated instance after the event is modified, it cannot be triggered outside the object. See the Code:

4:

 
 

  
  
Using System;
  
  
Using System. Collections. Generic;
  
  
Using System. Text;
  
  
 
  
  
Namespace EventDemo
  
  
{
  
  
/// <Summary>
  
  
/// Handle remove delegate
  
  
/// </Summary>
  
  
/// <Param name = "handle"> message </param>
  
  
Public delegate void MoveHandler (string handle );
  
  
/// <Summary>
  
  
/// Handle object
  
  
/// </Summary>
  
  
Public class ObjectHandler
  
  
{
  
  
/// <Summary>
  
  
/// Handle event
  
  
/// </Summary>
  
  
Public event MoveHandler hand;
  
  
/// <Summary>
  
  
/// Trigger the handle event to notify all subscribers
  
  
/// </Summary>
  
  
Public void Onhand ()
  
  
{
  
  
Hand ("handle event ");
  
  
}
  
  
}
  
  
}
 
 

In this way, the object closure principle is well maintained.

In the next article, we will learn the deeper application of delegation "Asynchronous delegation"

This article is from the pattern driven the world blog, please be sure to keep this source http://wangqingpei557.blog.51cto.com/1009349/639337