Delegates

Prime b

14y6.5kVisual Basic .NET

Explain to me delegates please!!!!!!!!!!!!!!!!!!!!!!
To me it seems its just like method.

18 Replies

Know the answer? Post it — somebody with the same question will find it here.

Vulpes14y ago
Accepted answer
In effect, yes.

The way I tend to think of a delegate is as a list of methods with the same signature all of which can be invoked together by invoking the delegate itself.
0
jnmsy14y ago
Hello Prime,
The following videos may help you..
http://www.bestdotnettraining.com/Online/Training/CSharp/Delegates-Events/70
0
Sam Hobbs14y ago
I do not know how well Prime B understands the relevance of MulticastDelegate to delegates but I hope Prime B does understand, at least now. Also, to the extent that this thread might be useful for others in the future I hope it is sufficiently clear now.
0
Vulpes14y ago
Well, having explained (in a simple way) what I think a delegate actually is in my first post to this thread, I thought it might help Prime b to get a better intuitive grasp of them if I told him how I tend to think of them myself.

It seems to me that the essence of a multicast delegate is its invocation list without which it is just an empty shell.

If all I've succeeded in doing is confusing him even more, then I apologize.
0
jnmsy14y ago
Hello Prime,
The following videos may help you http://www.bestdotnettraining.com/Online/Training/SQL-Server/Stored-Procedures/155
0
Nitesh Kejriwal14y ago
In Simple words, delegates are function pointers that you declare in your code and it is bound to the function at run time.
0
Sam Hobbs14y ago
You said "a delegate is as a list of methods" and I think I am not taking that out of context. I believe you that you did not intend to say that a delegate is a list but that is what you said. I think what you said could be mis-interpreted.

Sure a MulticastDelegate provides a list of delegates but it is only one way of using delegates. It has nothing to do with the definition of what a delegate is except as an example of how delegates can be used.
0
Vulpes14y ago
I didn't say it was a list.

What I said was :

"The way I tend to think of a delegate is as a list of methods with the same signature all of which can be invoked together by invoking the delegate itself."

That's because of what it says in the MSDN documenation for the MulticastDelegate class:

"A MulticastDelegate has a linked list of delegates, called an invocation list, consisting of one or more elements. When a multicast delegate is invoked, the delegates in the invocation list are called synchronously in the order in which they appear. If an error occurs during execution of the list then an exception is thrown."
0
Sam Hobbs14y ago
What? A delegate is not a list!
0
Sam Hobbs14y ago
I would not say that a delegate is a point where you connect all the methods. A delegate is for refering to a method symbolically.

In programs, we could give a constant value for something. For example we could give the value 99. Then the program will always use 99. Or we could give a symbolic name and then assign a different value many times. The value might be the same during a single execution or the value could change many times during execution.

We use delegates to allow us to refer to methods symbolically. The actual instance of the method can change. We can have a class that has a delegate and each instance of the class can specify a different actual method. We can create the class and specify what method to use for the delegate and we can create another instance of the class and specify a totally different method. So each of the two instances might do two different things depending on what was specified for the delegate.

This question is asked at least once a month. There are many previous answers in other threads and there are articles in this web site.
0
Prime b14y ago
Got it, tyvm!
0
Prime b14y ago
So delegate is just a point where u connect all the methods ?
0
Vulpes14y ago
Suppose for a moment, you'd never heard of delegates but, when a button on a form was clicked, you wanted several methods to execute one after the other. Moreover, the list of methods to call could change at runtime and so you couldn't just code an 'omnibus' method which called several other methods.

To do this you'd need a mechanism to store pointers to all the methods to be called together with a reference to the associated objects on which to call them though, if it were a static method, there would be no object. The mechanism would need to be flexible enough to allow methods to be added or removed at runtime.

Does this sound familiar?

It should do because the mechanism I'm describing is an event which is just a special kind of delegate :)
0
Prime b14y ago
I honestly don't see the advantage of using them
0
Satyapriya Nayak14y ago
Hi Prime,

Please refer Our recommended articles

http://www.c-sharpcorner.com/UploadFile/72d20e/concept-of-delegate-in-C-Sharp2/

http://www.c-sharpcorner.com/uploadfile/6897bc/delegates-part-i/default.aspx

http://www.c-sharpcorner.com/uploadfile/6897bc/delegates-part-2/default.aspx

http://www.c-sharpcorner.com/UploadFile/Ashush/delegates-in-C-Sharp/

http://www.c-sharpcorner.com/UploadFile/fbulovic/ExploringDelegates11092005000646AM/ExploringDelegates.aspx

http://www.c-sharpcorner.com/UploadFile/pathumfer/learn-basics-of-delegates-in-C-Sharp/

http://www.c-sharpcorner.com/UploadFile/rmcochran/delegateStrategy06142007210551PM/delegateStrategy.aspx

Thanks
0
Vulpes14y ago
Delegates are just a special kind of object which can represent an instance or static method which has a particular signature. In the case of an instance method, the delegate also stores a reference to the object on which the method will be invoked.

Delegates can be 'multicast' which means that they can represent not just one but several such methods and invoke them all simultaneously with one invocation of the delegate itself.

Delegates wouldn't be a very useful if they weren't the basis for events in .NET. An event is just a special kind of delegate to which (outside the class in which it's declared) you can only apply the += and -= operators to add an eventhandler to, or remove an eventhandler from, the delegate's invocation list. This ensures that outside code can't view or manipulate the delegate's invocation list which might lead to security problems.
0
Senthilkumar14y ago
Hi Prime,

A delegate is a type that references a method. Once a delegate is assigned a method, it behaves exactly like that method. The delegate method can be used like any other method, with parameters and a return value.

Delegates have the following properties:

Delegates are similar to C++ function pointers, but are type safe.

Delegates allow methods to be passed as parameters.

Delegates can be used to define callback methods.

Delegates can be chained together; for example, multiple methods can be called on a single event.

Methods don't need to match the delegate signature exactly. For more information, see Covariance and Contravariance

C# version 2.0 introduces the concept of Anonymous Methods, which permit code blocks to be passed as parameters in place of a separately defined method.

For example,

public delegate double Delegate_Prod(int a,int b);
class Class1
{
static double fn_Prodvalues(int val1,int val2)
{
return val1*val2;
}
static void Main(string[] args)
{
//Creating the Delegate Instance
Delegate_Prod delObj = new Delegate_Prod(fn_Prodvalues);
Console.Write("Please Enter Values");
int v1 = Int32.Parse(Console.ReadLine());
int v2 = Int32.Parse(Console.ReadLine());
//use a delegate for processing
double res = delObj(v1,v2);
Console.WriteLine ("Result :"+res);
Console.ReadLine();
}
}

Here I have used a small program which demonstrates the use of delegate.

The delegate "Delegate_Prod" is declared with double return type and accepts only two integer parameters.

Inside the class, the method named fn_Prodvalues is defined with double return type and two integer parameters. (The delegate and method have the same signature and parameter type.)

Inside the Main method, the delegate instance is created and the function name is passed to the delegate instance as follows:

Delegate_Prod delObj = new Delegate_Prod(fn_Prodvalues);
After this, we are accepting the two values from the user and passing those values to the delegate as we do using method:

delObj(v1,v2);
Here delegate object encapsulates the method functionalities and returns the result as we specified in the method.

For more info:
http://www.c-sharpcorner.com/Forums/Thread/169396/
http://geekswithblogs.net/joycsharp/archive/2008/02/15/simple-c-delegate-sample.aspx
http://www.codeproject.com/Articles/11657/Understanding-Delegates-in-C

0
Kunal Vaishya14y ago
Refer this link
http://www.dotnetperls.com/delegate
0