# Simple Func<T> and Func<T1, T2, TResult> Examples

Full source code available here.

About a month ago I wrote a post with a simple explanation of how to use methods that take `Action` or `Action<T>` as parameters. Actions themselves take 0 to 16 parameters, and return nothing.

This is a follow up with some examples of how to call methods that take `Func<TResult>` or `Func<T1, T2, TResult>` as parameters. Funcs return a value and take 0 to 16 parameters.

As with Actions, there are a variety of ways to call methods that take Funcs.

#### Example 1

It’s not easy to come up with a non contrived examples for this post, and especially difficult for `Func`, a function that takes no parameters and returns something.

```public static string DateCalculator(Func<double> daysSinceSomeDate)
{
return \$"{daysSinceSomeDate()} days in your date calculation";
}
```

This method expects a `Func<double>`, that is, a `Func<TResult>` that returns a `double` and takes no parameters.

Here are two examples calling this –

```Console.WriteLine(DateCalculator(() => Math.Round(DateTime.Now.Subtract(new DateTime(2000,1,1)).TotalDays, 2)));

Console.WriteLine(DateCalculator(() => Math.Round(new DateTime(2020,12,31).Subtract(DateTime.Now).TotalDays , 2)));
```

The calls pass in a `Func` that performs a calculation with date subtraction, not very useful, as I said, it’s not easy to come up with a simple and useful example of using a `Func<TResult>`.

#### Example 2

This method expects a `Func<int, int, int>`, that is, a Func<T1, T2, TResult>. It takes two `int`s and returns an `int`.

```public static void SomeMath(Func<int, int, int> mathFunction)
{
int result = mathFunction(7, 5);
Console.WriteLine(\$"The mathFunction returned {result}");
}
```

There are a variety of ways to call this. Here are some examples.

Create a method that takes two `int`s and returns an `int`.

```public static int Subtraction(int number1, int number2)
{
return number1 - number2;
}
```

You can now call `SomeMath(..)` like this –

```SomeMath(Subtraction);
```

Or this –

```Func<int, int, int> myFuncAsMethod = Subtraction;
SomeMath(myFuncAsMethod);
```

I like showing how you to pass a method into a method that takes a `Func`, because if you are ever struggling writing a lambda to satisfy a `Func` parameter, stop, and write a simple method instead to work out what you need to do. It can be easier to read, and is usually easier to debug.

Speaking of lambdas, here’s how to call the `SomeMath(..)` method with lambdas.

This is the simplest approach –

```SomeMath((a, b) => a + b);
```

This lambda will take two parameters, named a and b, then performs addition on them. You can think of `(a, b)` as parameters to the “method body” to the right of `=>`. That “method body” adds a and b. There is also an implied “return” statement, but it can be left out of single line lambdas like that. For multi-line lambdas it is necessary.

Here is such an example –

```SomeMath((x, y) =>
{
int temp = x * y; // you can make your lambdas multi-line
int calculatedNumber = temp * temp;
return calculatedNumber;
});
```

You can also assign a lambda to a declared `Func`, but I don’t see that done very often. You might do this if you are going to use the same lambda logic in multiple places.

```Func<int, int, int> myFuncAsLambda = (a, b) => a * b;
SomeMath(myFuncAsLambda);
```

There are other ways to satisfy the method `SomeMath(..)`, but these should be enough for most scenarios you will come across.

Full source code available here.