What is this line of code?

Often in code I see a line of code, I have an idea it do something about event but not clearly know what it does.

Is it possible that I can attach form A's load event in Form B with this, or what is it开发者_JAVA百科s benefit?

this.CGForm .Load +=new EventHandler(CGForm_Load);

Yes, it clearly has to do with events.

.Load in this case the the Form.Load event. The += operator adds one event handler to the event. An event can have many event handlers at the same time. Event handlers are just regular method that can be anywhere in your code base. When the event fires all subscribed methods will be called, one after the other.

I see no particular good reason to have FormA listen to the Load event of FormB, but other events might be more interesting, like the Form.Closed event. This is a way to have FormA react to changes in FormB.

Edit
Note that this causes FormA to hold a reference to FormB and FormB won't be garbage collected until FormA releases the reference to FormB (with
this.CGForm .Load -=new EventHandler(CGForm_Load);, note the -=) this is a common cause for memory leaks in .NET.

Subscribing to events from other forms is a "code smell" that can be a potential structure problem with your code. In some cases it is required, but if you have it all over the place your code will be hard to understand and maintain.

What this line means is that you subscribe the method CGForm_Load() to the this.CGForm.Load event. The method CGForm_Load() is the event handler or the callback.

After you run this line, every time the event is raised (in this case - every time the form is loaded), CGForm_Load() will be called automatically.

In order to unsubscribe a callback, use -= like this:

this.CGForm.Load -= new EventHandler(CGForm_Load)

Once an event callback is unsubscribed, the next time the event is raised (if the form is loaded again) the callback will no longer be called.

I find the following metaphor helpful: An event is like a power outlet, and callbacks are like power plugs. Subscribing is like connecting the plug to the outlet, and unsubscribing is like pulling it out. While there is a connection, all invocations of the event trigger the callback.

It simply adds the GCForm_Load method to the Load event on the CGForm. Under the hood when the CGForm is loaded code like the following will execute. Whenever this happens all event subscribers (in this case the method being subscribed here as CGForm_Load) will be invoked.

<pseudocode>
class CGForm
{
  public EventHandler<FormLoadedEventArgs> Load;

  private void SomeMethodThatLoadsTheForm()
  {
    LoadForm();
    var loadHandlers = Load;
    if (loadHandlers != null)
    {
       loadHandlers(new FormLoadedEventArgs(...));
    }
  }
}
</pseudocode>

this.CGForm .Load +=new EventHandler(CGForm_Load); subscribes the event handler delegate CGForm_Load to the Load event of the CGForm object.

Documentation about subscribing to events can be found at http://msdn.microsoft.com/en-us/library/ms366768(v=vs.80).aspx .

And index of information about how events work in .NET can be found at http://msdn.microsoft.com/en-US/library/awbftdfh(v=VS.80).aspx