The concept of delegates (references to methods) per se is new to me (although I used function pointers in C years ago), and although the literature acknowledges that there are significant differences between delegates and the use of pointers to objects, I'm nonetheless a little confused by how similar the syntax used for references to methods is to that used for references to objects.
Recently at a few different forums I posted a brief outline of my understanding of the instantiation of objects, and got corroboration and helpful feedback from several developers. Let me very briefly summarize my current understanding, for comparison to the way delegates work:
Steps to create and prepare to use an object:
1 Define a class: create a "blueprint" for objects of this class.
2 Declare an object: create a reference variable to hold a reference (address) of an object. The reference variable must be of the same class as the object.
3 Instantiate an object: allocate space for the object in the heap.
4 Assign an object to an object reference variable: place an object's address in an object reference variable.
Syntax used to implement these steps (numerals refer to the steps given immediately above):
1 Define a class: class
2 Declare an object:
3 Instantiate an object: new
This is usually done within the same statement as assigning the object to an object reference variable (see immediately below), unless the object's reference (address) is being returned to some calling method.
3 & 4 Instantiate an object and assign it to an object variable within a single statement:
2, 3 & 4 Declare an object, instantiate it and assign it to an object variable within a single statement:
This seems very similar to how I understand delegates to work, which I've summarized below.
Steps to create and prepare to use a delegate reference:
1 Define a delegate type: specify the signature (including return type) of methods that delegates of this type can point to. This is called "declaring" the delegate; which I think is kind of confusing, since "declaring an object" means to create a reference variable to hold the reference (address) of an object (see step #2 above for objects), but in my opinion "declaring" the delegate is really much more analogous to defining a class (see step #1 above for objects).
2 Declare a delegate reference variable: create a delegate reference variable to hold the reference (address) of some methods. The delegate reference variable must be of the delegate type with the same method signature as the methods it will point to.
3 Instantiate a delegate: allocate space for a delegate in the heap. [BTW, what actually goes in the heap here - the reference (address) of a method, or a copy of the method?]
4 Assign the delegate to a delegate reference variable: place a method's address in a delegate reference variable.
Syntax used to implement these steps (numerals refer to the steps given immediately above):
1 "Declare" a delegate: delegate
2 Declare a delegate reference variable:
3 Instantiate a delegate: new
3 & 4 Instantiate a delegate and assign it to a delegate reference variable within a single statement:
2, 3 & 4 Declare a delegate, instantiate it and assign it to a delegate reference variable within a single statement:
Any feedback on my thoughts would be appreciated.
Posted Feb 2, 2009, 11:52 PM
private delegate bool IsEmptyDelegate(string[] arr); // Create the delegate signature
private IsEmptyDelegate isEmpty; // Create an instance of type IsEmptyDelegate
// In the constructor or elsewhere
isEmpty = new IsEmptyDelegate(IsEmpty); // Instantiate the delegate if not static
// call the delegate instead of the method
bool arrIsEmpty = isEmpty(myStrArr); // You can use a delegate just like a method call
Like Ive said before, delegates are simply function pointers that are type safe. The EventHandler class is a good example of this, it is nothing more than a delegate with a signature of:
public delegate void EventHandler(object sender, EventArgs e);
If you plan on updating the interface from a seperate thread, using a delegate to do so is a MUST. A very generic example is:
// Consider all of this code running in a Form
private delegate void UpdateLabel();
private void Process() // Runs on a different thread...
{
this.Invoke(new UpdateLabel(()=> // lamda expression, new in C# 3.0, tasty stuff
{
this.label1.Text = "Hello World!";
}));
}
If you have any questions about what Ive written here, feel free to ask :)