Func, Action, Predicate delegates, events in C#

Noah Aas 240

Hello!

I am looking for a good short guide on when and how to take what.

Do you have any examples or do you know a good site?

Jiale Xue - MSFT 35,556 Reputation points Microsoft Vendor

2024-05-10T09:15:03.0733333+00:00
Hi @Noah Aas , Welcome to Microsoft Q&A, When you use Func, Action, Predicate delegates and events in C#, know their purpose and usage:

Func delegate:

Use: Represents a method that accepts zero or more input parameters and returns a value.

Syntax: Func<T1, T2, ..., TResult>

T1, T2, ...: input parameter type

TResult: return type

Action delegate:

Use: Represents a method that accepts zero or more input parameters and does not return a value.

Syntax: Action<T1, T2, ...>

T1, T2, ...: input parameter type

Predicate delegate:

Use: Represents a method that defines a set of conditions and determines whether the specified object meets these conditions.

Syntax: Predicate<T>

T: the object type to be compared

event:

Purpose: Allows a class to notify other classes or objects when something interesting happens.

grammar:
public event EventHandler<EventArgs> MyEvent;

You can find more information and examples about these delegates and events on Microsoft Docs.

Microsoft Docs - Delegates (C# Programming Guide)

Microsoft Docs - Events (C# Programming Guide)

Accepted answer

Bruce (SqlWork.com) 57,646

the ability to create a callback method is common. C# is a typed language, so in order to define typed callback (return and parameter types), you create a delegate. so the result of defining a delegate is new type of delegate.

delegate bool IsValid(string s); // define a new type of callback that 
                                 //   returns bool and take a string parameter
...

IsValid callback;   // define a variable of delegate type IsValid
callback = s => s?.Length > 1;   // using lambda, define a callback function

var result = callback("test");   // invoke the callback code

delegates are so handy, that when when generic were added, were created generic delegates where created so the delegate type need not be predefined:

Action<> a void delegate of parameter types
Func<> a delegate of parameters types and a return type
Predicate<> a delegate of parameters types and a return type of bool

Action<string> callback = s => Console.WriteLine(s); 
callback("test");

Func<string,bool> isvalid = s => s.Length > 10;
bool result = isvalid("test");

Predicate<string> isvalid2 = s => s.Length > 10;
bool result2 = isvalid2("test");

an event is a collection of delegates. generally they are defined as void, as you can not access the return value;

delegate void StringHandler (string s); // define delegate
event StringHandler callbacks;      // define event variable of type StringHandler
...

callbacks += s => Console.WriteLine(s);  // add a callback 
callbacks += s => Console.WriteLine(s);  // add another
callbacks.Invoke("test");  // writes "test" twice to console

Noah Aas 240

Hello! It's really good. Short and precise. Maybe you can add features to make the comparison easier to read. Perhaps I was already on the right way.

I have some problems with the spelling. I have checked it in a WinForm application.

delegate bool IsValid(string s); // define a new type of callback that 
								 //   returns bool and take a string parameter

delegate void StringHandler(string s); // define delegate
event StringHandler callbacks;      // define event variable of type StringHandler

private void btnCallbacks_Click(object sender, EventArgs e)
{
	IsValid callback;   // define a variable of delegate type IsValid
	callback = s => s?.Length > 1;   // using lambda, define a callback function

	var result = callback("test");   // invoke the callback code

	// --------------------
	Action<string> callback1 = s => Trace.WriteLine(s);
	callback1("test");

	Func<string, bool> isvalid = s => s.Length > 10;
	bool result1 = isvalid("test");

	Predicate<string> isvalid2 = s => s.Length > 10;
	bool result2 = isvalid2("test");

	// ----------------
	callbacks += s => Trace.WriteLine(s);  // add a callback 
	callbacks += s => Trace.WriteLine(s);  // add another
	callbacks.Invoke("test");  // writes "test" twice to console
}

//Output
//test
//test
//test
    // -> is OK
/////////////////////////////

A few small inconsistencies and questions. Hope you can help me.

Do you still have practical examples where Action, Func make sense? At the moment I have no advantage. Is the advantage that I have to pass a function? I could only call up the function. Same result. Like Variant2_WriteAction("Only call it")

I have checked your example to understand it better

Event I can notify one or more people. Isn't? Action and delegate Is the same. Isn't?

I think I've almost understood it, how do I use it, when will it be implemented. Maybe you can publish another example.

Current state.

delegate bool IsValid(string s); // define a new type of callback that 
								 //   returns bool and take a string parameter

delegate void StringHandler(string s); // define delegate
event StringHandler Callbacks;         // define event variable of type StringHandler

private void btnCallbacks_Click(object sender, EventArgs e)
{
	IsValid callback;   // define a variable of delegate type IsValid
	callback = s => s?.Length > 1;   // using lambda, define a callback function
	var result = callback("test");   // invoke the callback code

	IsValid callbackDelegateVariant2;
	callbackDelegateVariant2 = Variant2_WriteWithDelegate;
	var resultVariant2Delegate = callbackDelegateVariant2("test Variante2 withe delegate");   // invoke the callback code

	// --------------------
	Action<string> callback1 = s => Trace.WriteLine(s);
	callback1("test");   // If the notification is triggered, it could also be sent later. 


	Action<string> callback1Variant2 = Variant2_WriteAction;
	callback1Variant2("test callback1Variant2");
	// ------------------
	Func<string, bool> isvalid = s => s.Length > 10;
	bool result1 = isvalid("test");
	Func<string, bool> isvalidVariant2 = Variant2_WriteFunc;
	bool result1Variant2 = Variant2_WriteFunc("test Func 2");
	// ------------------
	Predicate<string> isvalid2 = s => s.Length > 10;
	bool result2 = isvalid2("test");

	Predicate<string> isvalid2Variant2 = Variant2_Predicate;
	bool result2Variant2 = Variant2_Predicate("test Predicate 2");

	// ----------------
	Callbacks += s => Trace.WriteLine(s);  // add a callback 
	Callbacks += s => Trace.WriteLine(s);  // add another
	Callbacks += AsFuncEvent1;
	Callbacks += AsFuncEvent2;
	Callbacks.Invoke("test  1:n relation notify");  // writes "test" twice to console
}


private bool Variant2_WriteWithDelegate(string s)
{
	Trace.WriteLine(s);
	return s.Length > 1;
}

private void Variant2_WriteAction(string s)
{
	Trace.WriteLine(s);
}

private bool Variant2_WriteFunc(string s)
{
	Trace.WriteLine(s);
	return s.Length > 10;
}

private bool Variant2_Predicate(string s)
{
	Trace.WriteLine(s);
	return s.Length > 10;
}


private void AsFuncEvent1(string s)
{
	Trace.WriteLine(s);
}

private void AsFuncEvent2(string s)
{
	Trace.WriteLine(s);
}

Lots of questions, hope you help. Thanks in advance.

Jiale Xue - MSFT 35,556 Microsoft Vendor

Hi @Noah Aas , Welcome to Microsoft Q&A,

Try to use this:

// Define delegate types
delegate bool IsValid(string s); 
delegate void StringHandler(string s); 

// Define event variable of type StringHandler
event StringHandler Callbacks;         

private void btnCallbacks_Click(object sender, EventArgs e)
{
    // Using delegate with lambda expression
	IsValid callback = s => s?.Length > 1;   
	var result = callback("test");   

	// Using delegate with a method
	IsValid callbackDelegateVariant2 = Variant2_WriteWithDelegate;
	var resultVariant2Delegate = callbackDelegateVariant2("test Variante2 with delegate");   

	// Using Action delegate
	Action<string> callback1 = s => Trace.WriteLine(s);
	callback1("test");   

	// Using Action delegate with a method
	Action<string> callback1Variant2 = Variant2_WriteAction;
	callback1Variant2("test callback1Variant2");

	// Using Func delegate
	Func<string, bool> isvalid = s => s.Length > 10;
	bool result1 = isvalid("test");

	// Using Func delegate with a method
	Func<string, bool> isvalidVariant2 = Variant2_WriteFunc;
	bool result1Variant2 = Variant2_WriteFunc("test Func 2");

	// Using Predicate delegate
	Predicate<string> isvalid2 = s => s.Length > 10;
	bool result2 = isvalid2("test");

	// Using Predicate delegate with a method
	Predicate<string> isvalid2Variant2 = Variant2_Predicate;
	bool result2Variant2 = Variant2_Predicate("test Predicate 2");

	// Adding methods to the event
	Callbacks += s => Trace.WriteLine(s);  
	Callbacks += s => Trace.WriteLine(s);  
	Callbacks += AsFuncEvent1;
	Callbacks += AsFuncEvent2;
	
	// Invoking the event
	Callbacks.Invoke("test  1:n relation notify");  
}

// Method to be used with delegate
private bool Variant2_WriteWithDelegate(string s)
{
	Trace.WriteLine(s);
	return s.Length > 1;
}

// Method to be used with Action delegate
private void Variant2_WriteAction(string s)
{
	Trace.WriteLine(s);
}

// Method to be used with Func delegate
private bool Variant2_WriteFunc(string s)
{
	Trace.WriteLine(s);
	return s.Length > 10;
}

// Method to be used with Predicate delegate
private bool Variant2_Predicate(string s)
{
	Trace.WriteLine(s);
	return s.Length > 10;
}

// Additional methods to be used with the event
private void AsFuncEvent1(string s)
{
	Trace.WriteLine(s);
}

private void AsFuncEvent2(string s)
{
	Trace.WriteLine(s);
}

Noah Aas 240 Reputation points

2024-05-14T12:02:49.1533333+00:00

What have you changed from my extensions?
Jiale Xue - MSFT 35,556 Reputation points Microsoft Vendor

2024-05-16T08:12:56.1466667+00:00
I haven't made significant changes to your code, just added comments and rearranged it slightly for clarity. Here's a summary of the changes:

Added comments to explain each section of the code.

Rearranged the order of the methods for better readability.

Added comments to explain the purpose of each delegate and event.

Adjusted indentation for better readability.
Noah Aas 240 Reputation points

2024-05-17T05:19:38.3966667+00:00

OK, thanks.

One question, the last and thanks in advance.

Do you still have practical examples where Action, Func make sense? At the moment I have no advantage. Is the advantage that I have to pass a function? I could only call up the function. Same result. Like Variant2_WriteAction("Only call it")
Jiale Xue - MSFT 35,556 Reputation points Microsoft Vendor

2024-05-17T09:26:50.8+00:00

Hi @Noah Aas , You can go to the website to refer to the following:

Microsoft Docs - Delegates (C# Programming Guide)

Microsoft Docs - Events (C# Programming Guide)

Don't keep pushing on new questions from one question to the next.

1 additional answer

P a u l 10,406 Reputation points

2024-05-09T19:38:07.7266667+00:00
This article seems reasonable:

https://medium.com/nerd-for-tech/c-delegates-actions-events-summary-please-8fab0244a40a

The TLDR is that Func<T>, Action & delegates declared via the delegate keyword are for most intents and purposes the same. The delegate format came first and Func and Action came in later .NET versions.

The main benefit of the delegate keyword variant is that you can apply keywords to them (as you would with a regular method signature) such as params, in, out & ref. E.g. you could express a "string-to-int" parsing function like this with a delegate:

delegate bool TryParseInt(string value, out int value);

But not with the equivalent Func<T>:

Func<string, out int, bool> Delegate; // <-- Won't compile!

An event is something that you subscribe to (i.e. you register your delegate, in which format of delegate above you prefer). When the event is invoked, your delegate will be called. The benefit of an using an event instead of straight delegate is that you can register/un-register as many delegates to a single event as you want.
Please sign in to rate this answer.
Noah Aas 240 Reputation points

2024-05-10T14:19:07.06+00:00

Thank you!
Sign in to comment

Share via

Func, Action, Predicate delegates, events in C#

1 additional answer