c#3.0實現(xiàn)延遲賦值示例

更新時間：2014年01月22日 15:11:25 作者：

這篇文章主要介紹了c#3.0實現(xiàn)延遲賦值示例,大家參考使用吧

延遲賦值主要有兩點:

1.一個參數(shù)可能或可能沒被賦值．

2.一個參數(shù)在一個函數(shù)中每次使用時可能被賦值．

如下面的這種情況：

int Add(int x, int y)
{
    return (2 + 1) + (1);
}

使用Func<T>，我們輕松實現(xiàn)，看代碼：

復(fù)制代碼代碼如下:

/// <summary>
/// LazyExpression
/// </summary>
/// <typeparam name="T">T</typeparam>
public class LazyExpression<T>
{
    Func<T> thunk;
    public LazyExpression(Func<T> Thunk)
    {
        thunk = Thunk;
    }
    public T Evaluate()
    {
        return thunk();
    }
}

/// <summary>
/// LazyBoolExpression
/// </summary>
public static class LazyBoolExpression
{
    public static bool And(LazyExpression<bool> LHS, LazyExpression<bool> RHS)
    {
        return LHS.Evaluate() && RHS.Evaluate();
    }
    public static bool Or(LazyExpression<bool> LHS, LazyExpression<bool> RHS)
    {
        return LHS.Evaluate() == true ? true : RHS.Evaluate();
    }
}

/// <summary>
/// LazyMemoizedExpression
/// </summary>
/// <typeparam name="T"></typeparam>
public class LazyMemoizedExpression<T>
{
    bool thunked;
    T value;
    Func<T> thunk;
    public LazyMemoizedExpression(Func<T> Thunk)
    {
        thunked = false;
        thunk = Thunk;
    }
    public T Evaluate()
    {
        if (!thunked)
        {
            value = thunk();
            thunked = true;
        }
        return value;
    }
}

LazyExpression<T>類實現(xiàn)了基本的延遲賦值，LazyMemoizedExpression<T>類實現(xiàn)了一次賦值，多次使用．
LazyBoolExpression實現(xiàn)邏輯表達式．

看UnitTest，一切就明白了

復(fù)制代碼代碼如下:

///<summary>
///Laziestheexpressiontest.
///</summary>
[TestCase]
publicvoidLazyExpressionTest()
{
varlme1=newLazyExpression<int>(()=>2+1);
varlme2=newLazyExpression<int>(()=>1);
Assert.AreEqual(4,Add(lme1,lme2));
}

///<summary>
///Addsthespecifiedx.
///</summary>
///<paramname="x">Thex.</param>
///<paramname="y">They.</param>
///<returns>result</returns>
privateintAdd(LazyExpression<int>x,LazyExpression<int>y)
{
returnx.Evaluate()+y.Evaluate();
}

///<summary>
///Laziestheexpressionwithlogic.
///</summary>
[TestCase]
publicvoidLazyExpressionWithLogic()
{
varexp1=newLazyExpression<bool>(()=>true);
varexp2=newLazyExpression<bool>(()=>true||false);
if(LazyBoolExpression.And(exp1,exp2))
{
Console.WriteLine("lazyand");
}
if(LazyBoolExpression.Or(exp1,exp2))
{
Console.WriteLine("lazyor");
}
}

///<summary>
///Laziesthememoizedexpressiontest.
///</summary>
[TestCase]
publicvoidLazyMemoizedExpressionTest()
{
varlme1=newLazyMemoizedExpression<int>(()=>GetIntResult());
Assert.AreEqual(943,lme1.Evaluate());
Assert.AreEqual(943,lme1.Evaluate());
//output:
//1passed,0failed,0skipped,took2.80seconds(NUnit2.5).
}

///<summary>
///Comparestolazyexpressiontest.
///</summary>
[TestCase]
publicvoidCompareToLazyExpressionTest()
{
varlme1=newLazyExpression<int>(()=>GetIntResult());
Assert.AreEqual(943,lme1.Evaluate());
Assert.AreEqual(943,lme1.Evaluate());
//output:
//1passed,0failed,0skipped,took4.80seconds(NUnit2.5).
}

///<summary>
///Getstheintresult.
///</summary>
///<returns></returns>
privateintGetIntResult()
{
//currentthreadsleeptwosecond.
System.Threading.Thread.Sleep(2000);
return943;
}

您可能感興趣的文章: