Assigning methods to object at run-time - Design Pattern

I have created an architecture in my C# code which does exactly what I want, but seems it would be very difficult to maintain in the long-run and am hoping there's a design pattern / better architecture I could be pointed towards.

I have created an object Test which, again, does exactly what I need perfectly which has the following structure:

class Test
{
    public static Dictionary<string, Func<Test, object>> MethodDictionary;

    public double Var1;
    public double Var2;

    private Lazy<object> _test1;
    public object Test1 { get { return _test1.Value; } }

    private Lazy<object> _test2;
    public object Test2 { get { return _test2.Value; } }

    public Test()
    {
        _test1 = new Lazy<object>(() => MethodDictionary["Test1"](this), true);
        _test2 = new Lazy<object>(() => MethodDictionary["Test2"](this), true);
    }
}

What this allows me to do is, at run-time to assign a dictionary of functions to my Test object and the 2 properties Test1 & Test2 will use the functions loaded into it to return values.

The implementation looking somewhat as follows:

class Program
{
    static void Main(string[] args)
    {
        Dictionary<string, Func<Test, object>> MethodDictionary = new Dictionary<string,Func<Test,object>>();
        MethodDictionary.Add("Test1", TestMethod1);
        MethodDictionary.Add("Test2", TestMethod2);

        Test.MethodDictionary = MethodDictionary;

        var x = new Test() { Var1 = 20, Var2 = 30 };
        Console.WriteLine(x.Test1.ToString());
        Console.WriteLine(x.Test2.ToString());
        Console.ReadKey();
    }

    private static object TestMethod1(Test t)
    { return t.Var1 + t.Var2; }

    private static object TestMethod2(Test t)
    { return t.Var1 - t.Var2; }

}

And it works great and has proven very efficient for large sets of Test objects.

My challenge is that if I ever want to add in a new method to my Test class, I need to add in the:

1. private Lazy<object> _myNewMethod;
2. public object MyNewMethod { get { return _myNewMethod.Value; } }
3. Update the constuctor with the key to look for in the dictionary

And, although that is pretty simple, I'd love to have a 1-line add-in (maybe some form of custom object) or have the properties read directly form the dictionary without any need for defining them at all.

Any ideas? ANY help would be great!!!

Thanks!!!