Is there anything that you can do with 'delegate' but cannot do with either 'Action' or 'Func'?

Question

Apologizing in advance for the newbie kinda question (as I am one in C#):

While studying delegates, it seems to me that the combination of Action and Func covers the entire "functionality" of the delegate keyword.

In other words, there is nothing that you can do with the delegate keyword but cannot do with either Action or Func.

I've tried the following examples (which work fine):

Func<int,int,int,int> func = (x,y,z) => (x<<9)|(y<<6)|(z<<3);
Action<int,int,int> action = (x,y,z) => Console.WriteLine(x|y|z);

Am I wrong? If yes, then can you please provide a counterexample?

I would define Action and Func als Wrapper/helper classes that allow programmes Easy to use, and standardized delegates. — Venson, Jun 04 '14 at 16:50
Thanks @Tarec. I'd expect my question to be a duplicate of some previous post, but haven't been quite able to find one. Your link provides a partial answer to my question, but it kind of explains something that I already know. So basically I'm just trying to figure out whether once you have `Action` and `Func` it "covers the whole thing", or am I missing something here? Thanks again. — barak manos, Jun 04 '14 at 16:55
@barakmanos you are right, that answer doesn't explain the difference in purposes of using both. Please check this explanation, I hope it helps ;) http://stackoverflow.com/a/18741018/1284902 — Tarec, Jun 04 '14 at 17:04

Servy · Accepted Answer · 2015-01-19T15:08:59.407

7

You will need to use a delegate other than Action or Func if you want to have:

More than 16 parameters to your method.
Any parameters be ref or out parameters.
A params parameter.
Optional arguments for any of your parameters.
Constraints on any of the generic arguments. (Ensuring a parameter is any type that extends a type, that it has a parameterless constructor, that it is a value/reference type, etc.)
unsafe types used in the signature of the method, such as pointers as parameters.
Have a parameter that isn't contravariant, or a return type that's not covariant. Func and Action both apply variance wherever possible, so if its important that your delegate not be variant, you would need your own.

edited Jan 19 '15 at 15:08

answered Jun 04 '14 at 17:01

Servy

`out`, `params` and optional arguments are actually three results of one common and more general impossibility with `Action`/`Func`: the ability to specify custom attributes. – Jun 04 '14 at 17:04
You could add the case of `unsafe` types, i.e. a delegate type where some parameters, or the return value, are of pointer types. For example `public unsafe delegate string GetString(char* value);`. – Jeppe Stig Nielsen Jan 19 '15 at 14:32
Yet another use if you do not want the type parameters to be marked as co- or contravariant. Note that `System.EventHandler` is not contravariant (not "`in`") in `TEventArgs` because it can lead to problem with multicast delegates. So it is different from `Action – Jeppe Stig Nielsen Jan 19 '15 at 14:40

score 2 · Answer 2 · answered Jun 04 '14 at 17:01

2

You can create delegates that take ref or out parameters. You cannot define a Func or an Action that has ref or out parameters.

For example:

delegate void MyDelegate(ref string val);

Cannot be expressed as an Action.

answered Jun 04 '14 at 17:01

Jim Mischel

score 1 · Answer 3 · answered Jun 04 '14 at 17:09

My two cents: With your own generic delegates you can apply generic constraints which is not provided by Func or Action

delegate void MyDelegate<T>(T input) where T : struct;

Compiler will make sure MyDelegate<T> will always have value types as T, reference types are not allowed.

3 Answers3