How to Pass a Method as a Parameter in C# Using Delegates

By the end of this page, you will understand how C# allows methods to be passed as parameters using delegates. You will learn the modern Func<...> syntax, see how it matches method signatures, and understand how to call the passed method inside another method. You will also see practical examples, common mistakes, and how this pattern is used in real C# codebases.

In C#, you cannot pass a method by writing a parameter type like "method name". Instead, you pass a delegate.

A delegate is a type that represents a reference to a method with a specific signature.

A method signature includes:

• the parameter types
• the return type

If two methods have the same signature, they can both be assigned to the same delegate type.

For the example in this question, both methods match this signature:

• input: string
• output: int

That means RunTheMethod should accept something that represents "any method that takes a string and returns an int".

In modern C#, the most common way to do this is with Func<string, int>.

• Func<string, int> means:
  • takes a string
  • returns an int

So instead of trying to pass a method name directly, you define the parameter like this:

public bool ()

Think of a delegate like a remote control button.

The RunTheMethod function does not need to know the actual method's name in advance. It only needs a button it can press.

If the button is wired to Method1, pressing it runs Method1. If the button is wired to Method2, pressing it runs Method2.

What matters is that every button works the same way:

• it accepts one string
• it gives back one int

So RunTheMethod is not asking for a specific method name. It is asking for anything callable with that shape.

The simplest modern solution uses Func<TInput, TResult>.

using System;

public class Example
{
    public int Method1(string input)
    {
        return input.Length;
    }

    public int Method2(string input)
    {
        return input.IndexOf(' ');
    }

    public bool RunTheMethod(Func<string, int> myMethod)
    {
        int result = myMethod("My String");
        Console.WriteLine(result);
        return true;
    }

    public bool Test()
    {
        return RunTheMethod(Method1);
    }
}

What this means

• Func<string, int> defines a method type.
• Method1 matches that type because it takes a and returns an .

Consider this small example:

using System;

public class Example
{
    public int Method1(string input)
    {
        return input.Length;
    }

    public bool RunTheMethod(Func<string, int> myMethod)
    {
        int i = myMethod("My String");
        Console.WriteLine(i);
        return true;
    }

    public bool Test()
    {
        return RunTheMethod(Method1);
    }
}

Step-by-step

1. Test() is called.

2. Test() calls RunTheMethod(Method1).

3. The method Method1 is passed into RunTheMethod as a delegate.

Passing methods as parameters is very common in C#.

1. Reusable processing pipelines

You may have a method that handles logging, timing, or validation, and then runs one of several operations.

public int ExecuteWithLogging(Func<string, int> operation, string input)
{
    Console.WriteLine("Starting...");
    int result = operation(input);
    Console.WriteLine("Done.");
    return result;
}

2. Sorting and filtering

LINQ uses this idea heavily. You pass logic into methods like Where, Select, and OrderBy.

var shortNames = names.Where(name => name.Length < 5);

The lambda is a function passed as a parameter.

3. Event handling

In UI apps and desktop apps, methods are passed as handlers for clicks, changes, or other events.

4. Retry and error-handling wrappers

You can pass an operation into a generic method that retries on failure.

5. Business rules

An application may pass different calculation methods depending on customer type, pricing mode, or feature flags.

In real projects, this pattern is often used to separate shared workflow from custom behavior.

Common patterns

• Guard clauses before invoking the method
• Validation of input
• Logging around execution
• Error handling with try/catch
• Configuration-based behavior where one of several methods is chosen dynamically

Example with a guard clause

public bool RunTheMethod(Func<string, int> myMethod)
{
    if (myMethod == null)
    {
        throw new ArgumentNullException(nameof(myMethod));
    }

    int result = myMethod("My String");
    Console.WriteLine(result);
    return true;
}

Example with shared workflow

public int RunWithAudit(Func<string, int> operation, string input)
{
    Console.WriteLine();

     result = operation(input);

    Console.WriteLine();
     result;
}

1. Passing the result instead of the method

Broken code:

RunTheMethod(Method1("Hello"));

Why it is wrong:

• Method1("Hello") executes immediately.
• It returns an int.
• But RunTheMethod expects a delegate, not an int.

Correct:

RunTheMethod(Method1);

2. Using the wrong delegate type

Broken code:

public bool RunTheMethod(Action<string> myMethod)

Why it is wrong:

• Action<string> means the method takes a string and returns void.
• Your methods return int, so this does not match.

Correct:

// Method signature to match
int SomeMethod(string input)

// Receive a method as a parameter
public bool RunTheMethod(Func<string, int> myMethod)
{
    int result = myMethod("My String");
    return true;
}

// Pass a method
RunTheMethod(Method1);

// Pass a lambda instead
RunTheMethod(s => s.Length);

// Custom delegate alternative
public delegate int StringOperation(string input);

Rules

• The method signature must match exactly.
• Use Func<...> for methods that return a value.

How do you pass a method as a parameter in C#?

Use a delegate type such as Func or Action. For a method that takes a string and returns an int, use Func<string, int>.

What is a delegate in C#?

A delegate is a type that can store a reference to a method with a specific signature.

When should I use Func instead of Action?

Use Func when the method returns a value. Use Action when the method returns void.

Can I pass a lambda instead of a named method?

Yes. For example:

RunTheMethod(s => s.Length);

Does the method signature need to match exactly?

Yes. The parameter types and return type must match the delegate type.

Can instance methods be passed as parameters?

Yes, as long as you pass them from an object instance when needed.

Is Func better than creating a custom delegate?

Usually yes for simple cases. A custom delegate is useful when a named delegate makes the code clearer.

• Delegates — The core C# feature that allows methods to be treated like values.
• Func and Action — Built-in delegate types used for returning values or returning void.
• Lambda expressions — A concise way to create inline functions.
• Anonymous methods — An older way to define functions inline.
• Method signatures — Important because delegate compatibility depends on matching parameters and return types.
• Events — Built on delegates and commonly used in UI and event-driven programming.
• LINQ — Uses delegates and lambdas heavily for querying and transforming data.