LazyValue<T>

public void ExtendFuncT()
        {
            //()：匿名无参方法。() =>方法名，指派匿名无参方法去执行另外一个方法。
            LazyValue<int> lazyOne = new LazyValue<int>(() => ExpensiveOne());//匿名无参方法被指派去执行ExpensiveOne
            LazyValue<long> lazyTwo = new LazyValue<long>(() => ExpensiveTwo("apple"));//匿名无参方法被指派去执行ExpensiveTwo

            Console.WriteLine("LazyValue objects have been created.");

            //泛型类别根据 关联的委托与方法 取值。
            Console.WriteLine(lazyOne.Value);//跳转到() => ExpensiveOne()，执行LazyValue<T>.Value的取值，然后显示结果。
            Console.WriteLine(lazyTwo.Value);//跳转到() => ExpensiveTwo("apple")，执行LazyValue<T>.Value的取值，然后显示结果。
        }
        //无参测试方法
        static int ExpensiveOne()
        {
            Console.WriteLine("\nExpensiveOne() is executing.");
            return 1;
        }
        //计算字串长度
        static long ExpensiveTwo(string input)
        {
            Console.WriteLine("\nExpensiveTwo() is executing.");
            return (long)input.Length;
        }
    }
    //扩展：自定义泛型类别LazyValue T，以Funct<T>为参数类型传递。
    class LazyValue<T> where T : struct
    {
        private T? val;//或 Nullable<T> val; //标记返回类型T，同时用于保存Func<T>委托的方法的返回值
        private Func<T> getValue;           //返回类型为T的委托

        // 构造。参数Funct<T>类型：传入的参数为返回类型为TResult(任何类型)的无参方法。
        public LazyValue(Func<T> func)
        {
            val = null;
            getValue = func;
        }

        public T Value
        {
            get
            {
                if (val == null)
                    val = getValue();//取得委托方法的返回值。
                return (T)val;      //强制抓换委托方法返回值类型。
            }
        }
    }