How to simplify these delegate functions?

Question

I'm looking for a way to simplify this code, because I could develop more overloads for TryThis I made the string and int both of class Nullable so that in each overloaded function, the catch block could return the same value.

The problem is I need, if possible, no overloads of TryThis. The function overloads are both identical, except for the type of delegate they are passed. Is there some kind of variable that would encompass any delegate that can be executed?

class Program
{
    delegate int MyIntReturn();
    delegate string MyStringReturn();
    static private MyIntReturn ReadInt = () => {return int.Parse(Console.ReadLine()); };
    static private MyStringReturn ReadString = () => { return Console.ReadLine(); };

    static private Nullable<int> TryThis(MyIntReturn MyAction)
    {
        try
        {
            return MyAction();
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.ToString());
            return null;
        }
    }
    private static Nullable<string> TryThis(MyStringReturn MyAction)
    {
        try
        {
            return MyAction();
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.ToString());
            return null;
        }
    }

}

Answer 1

Generics and Delegates. Note that you can't return null in this modified version of TryThis, so we use the default(T) method to return whatever's most sensible.

class Program
{
    private delegate T TypeReturn<T>();
    static private TypeReturn<int> ReadInt = () => int.Parse(Console.ReadLine());
    static private TypeReturn<string> ReadString = () => Console.ReadLine(); 
    static private T TryThis<T>(TypeReturn<T> MyAction )
    {
        try
        {
            return  MyAction() ;
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.ToString());
            return default (T);
        }
    }
}

Answer 2

You can use the generic delegate Func<>:

static private T TryThis<T>(Func<T> MyAction) {
    try {
        return MyAction();
    } catch (Exception ex) {
        Console.WriteLine(ex.ToString());
        return default(T);
    }
}