A18制造 » CShap http://a18zhizao.com 梦想的种子飞入了大地，所需要的只有时间。 Sun, 22 Apr 2012 13:46:47 +0000 en hourly 1 http://wordpress.org/?v=3.3.2 在Lambda表达式中进行递归调用 http://a18zhizao.com/y2010/1180_lambda-expressions-in-the-recursive-call.html http://a18zhizao.com/y2010/1180_lambda-expressions-in-the-recursive-call.html#comments Mon, 04 Jan 2010 03:59:37 +0000 a18ccms http://www.a18zhizao.cn/y2010/1180_lambda-expressions-in-the-recursive-call.html Lambda表达式是一个匿名的方法，在开发期我们是不知道其方法名是什么的，所以我们要怎么递归调用呢？

如果你看过我这文章《让您知道您的方法是被何“人”调用 》的话，你应该会“啊哈”的拍一下头脑，思路就出来了，没错!!就是直接用StackFrame获取当前执行的方法，然后直接Invoke即可。

示例代码：

    class Test
    {
        /**//// <summary>
        ///
        /// </summary>
        /// <param name="v1"></param>
        /// <param name="v2"></param>
        /// <param name="num"></param>
        /// <param name="total"></param>
        /// <returns></returns>
        public delegate long AddMethod(long v1, long v2, int num, int cout);

        /**//// <summary>
        ///
        /// </summary>
        /// <param name="addMethod"></param>
        /// <param name="cout"></param>
        static void Print(AddMethod method, int cout)
        {
            Console.WriteLine(method(0, 1, 2, cout));
        }

        static void Main()
        {
            //求0,1,1,2,3,5,8.类似的数据队列在第30个位置的数
            Print((v1, v2, num, cout) =>
                {
                    Console.Write(v1);
                    Console.Write(",");

                    num++;
                    if (num == cout)
                    {
                        Console.Write(v2);
                        Console.WriteLine();
                        return v1 + v2;
                    }
                    else
                    {
                        //取得当前方法
                        StackFrame frame = new StackFrame(0);
                        //递归调用
                        return (long)(frame.GetMethod().Invoke(num, new object[] { v2, (v1 + v2), num, cout }));
                    }
                }, 30);
            Console.Read();
        }
    }

我们的代码成功运行了，成功的求出在第30个位置的数值是：514229
其时，.NET里还有一个东东可以方便的得到当前调用方法的引用，这东东就是MethodBase，其有一个静态方法GetCurrentMethod 可直接获取当前执行的方法引用，所以我们可以将上面的StackFrame处的两句代码改为如下：

//递归调用
return (long)(MethodBase.GetCurrentMethod().Invoke(num, new object[] { v2, (v1 + v2), num, cout }));

执行后的结果都是一样的(不一样才怪了Orz）
原文地址

]]> http://a18zhizao.com/y2010/1180_lambda-expressions-in-the-recursive-call.html/feed 0 让您知道您的方法是被何“人”调用 http://a18zhizao.com/y2010/1179_let-you-know-that-your-way-is-what-people-call.html http://a18zhizao.com/y2010/1179_let-you-know-that-your-way-is-what-people-call.html#comments Mon, 04 Jan 2010 03:56:13 +0000 a18ccms http://www.a18zhizao.cn/y2010/1179_let-you-know-that-your-way-is-what-people-call.html 也许在某些场合下我们想知道自己的某个方法是被谁（哪个方法）调用的？比如下面的例子：

/**//// <summary>
        /// 正常方法
        /// </summary>
        static void Method1()
        {
            DisabledObsoleteMethod();
        }

        /**//// <summary>
        /// 过期方法
        /// </summary>
        [Obsolete]
        static void Method2()
        {
            DisabledObsoleteMethod();
        }

        /**//// <summary>
        /// 禁止过期方法调用此方法
        /// </summary>
        static void DisabledObsoleteMethod()
        {
            //如果调用此方法的方法中有"Obsolete"标记则不允许继续运行
        }

在上面代码中，我们要在DisabledObsoleteMethod函数里限制具有“Obsolete”属性的方法调用，我们如何去做呢？

在.Net中提供了一个"StackFrame"类用于表示当前线程上的函数调用堆栈中的某个具体函数，所以我们通过它就可继续编写我们的DisabledObsoleteMethod函数，代码如下：

        /**//// <summary>
        /// 禁止过期方法调用此方法
        /// </summary>
        static void DisabledObsoleteMethod()
        {
            StackFrame frame = new StackFrame(1);       //偏移一个函数位,也即是获取当前函数的前一个调用函数
            MethodBase method = frame.GetMethod();      //取得调用函数
            //反射获取其特性
            object[] attributes = method.GetCustomAttributes(typeof(ObsoleteAttribute), false);
            if (attributes.Length > 0)
            {
                //包含有"Obsolete"标记抛出错误或做其它处理
                throw new Exception(string.Format("方法{0}包括有Obsolete属性已被禁止调用",method.Name));
            }

            //继续做其它操作
        }

到此，当运行Method1时我们的DisabledObsoleteMethod函数就可以正常运作，而Method2就会被抛出异常警告了

因为StackFrame的构造函数可以指定偏移量，所以我们可以使用它获取调用我们的函数时函数调用堆栈里都有些什么函数，也即是可以了解到当前程序的一个流程是如何的，示例代码如下：

class Test
    {
        static void Main()
        {
            int offset = 0;
            do
            {
                StackFrame frame = new StackFrame(offset++);
                MethodBase method = frame.GetMethod();
                if (method == null) break;       //如果偏移位置没有函数时,则GetMethod方法返回null
                Console.WriteLine(method.Name);

            } while (true);
            Console.Read();
        }
    }

其实.NET已经为我们提供了一个StackTrace类，其可以获取函数调用堆栈里的所有函数的有序集合，通过它我们就能将上面的代码简化为下面的代码了，如下：

   class Test
    {
        static void Main()
        {
            StackTrace trace = new StackTrace();
            foreach (StackFrame frame in trace.GetFrames())
            {
                Console.WriteLine(frame.GetMethod().Name);
            }
            Console.Read();
        }
    }

两者输出的结果还是一样的,如下

Main
_nExecuteAssembly
ExecuteAssembly
RunUsersAssembly
ThreadStart_Context
Run
ThreadStart

看来在控制台程序中也是由某个线程委托开始运作的。

其时，.NET里还有一个东东可以方便的得到当前调用方法的引用，这东东就是MethodBase，其有一个静态方法GetCurrentMethod 可直接获取当前执行的方法引用，所以我们可以将上面的StackFrame处的两句代码改为如下：

return (long)(MethodBase.GetCurrentMethod().Invoke(num, new object[] { v2, (v1 + v2), num, cout }));

原文地址

]]> http://a18zhizao.com/y2010/1179_let-you-know-that-your-way-is-what-people-call.html/feed 1 位标志的判断和增减运算 http://a18zhizao.com/y2009/1170_flag-judgments-and-changes-in-the-computing.html http://a18zhizao.com/y2009/1170_flag-judgments-and-changes-in-the-computing.html#comments Thu, 31 Dec 2009 02:12:27 +0000 a18ccms http://www.a18zhizao.cn/y2009/1170_flag-judgments-and-changes-in-the-computing.html 由于有读者对《C#程序设计基础教程与实训》214页的那个例子无法理解，所以专门写一篇文章对位标志进行讲解，希望可以对初学者有一些帮助。要理解这篇文章，首先要知道什么是位运算，什么是二进制，这些是计算机一级的内容，我不打算在这里讲解。如果有不懂的请上网用Google了解或查找相关书籍了解，写这篇文章的目的在于让你知道为什么要使用位运算，使用它会带来什么好处。

我们首先从一个问题着手：如果你正在编写一个课程管理系统，你会以什么样的形式来表示你今天哪些节有课哪些节没课呢？比如一天有12节课，如下图所示

 

可能大家会问，为什么只是记录哪些节有课，哪些节没课呢？这样的信息有什么作用呢？当然有用，比如你要查找某同学今天上午1、2节是否有课，又比如在排课系统中，把某门课排到星期二下午6、7节，首先就要确定这两节课是否已经分配给了其他课程。。。。。。

我想大部分人最初能想到的就是使用一个bool数组来表示它（这大部分人当中当然也包括我自己），使用代码来表示就是下面这个样子：

bool[] arrCourse = new bool[13];

arrCourse[5]=true;

arrCourse[6]=true;

好！恭喜你，有了一个很不错的开始，很好地完成了任务，以上代码执行完的结果如下图所示：

 

在数组中，当元素值为T时，表明这一节有课，为F时，表明这一节没课。现在感觉相当良好，现在可以开始排课了。比如我们现在需要在某天排入某门课，这一天现在的课程状态如下图所示：

 

如果我们要把这门课排到第1、2节，就需要做出如下判断

if(arrCourse[0]==false && arrCourse[1]==false)

如果我们需要把排到1、2、3节，就需要做出如下判断

if(arrCourse[0]==false && arrCourse[1]==false && arrCourse[2]==false)

如果需要把课排到1~5节或1~13节。。。！现在有点晕了，怎么这么麻烦啊！当然，你要是真的这么写程序那就是真的有点麻烦了，这样的判断应该借助循环。但无论怎么样，判断的次数是不能减少的，这样的数据结构也不能让人满意。是否有更好的解决方案呢？

好！我们尝试把F变为0，T变为1，看看效果怎么样：

 

这幅图表示的不是一个二进制数吗？用计算器来转换一下，它就是十进制的902。哈哈！真是天才的想法，用一个整数就可以表示这一天的上课状态了。现在我要把新课排在1、2节只需要把902跟二进制的（110000000000）也就是十进制的3072进行“与”运算（902 & 3072）就OK了，结果为0，表明可以排进去，结果不为0表明1、2节至少有一节已排入其他课了。

如果要排入的是下午6、7节，只需跟二进制（000001100000）也就是十进制的96进行“与”运算。现在不再需要进行多次判断，只需一次运算，判断结果是否为0就解决了所有问题。

现在大家应该明白位运算有多好了吧！Windows中存在着大量的位标志，如果曾经使用Windows API进行编程应该对此有很深的体会。举个例子：假设Windows字体存在以下几种样式：加粗，斜体，下划线。一个字体即可以同时拥有以上三种样式，也可以只拥有一种样式，或拥有其中任意两种样式，或者干脆一种都没有。如何表示字体的样式呢？当然最佳的方案就是使用位标志。如用第一个位表示字体是否加精，第二、三个位分别表示是否是斜体和下划线，如下图所示：

当位标志为：010------（十进制的2）时，表示这个字体只有斜体这种样式

当位标志为：011------（十进制的3）时，表示这个字体为粗体，同时又是斜体

。。。。。。。

所以当你要把某行字变为粗体时，只需让它跟二进制的（001）进行“或”运算就行了

把某行字变为斜体时，只需让它跟二进制的（010）进行“或”运算

把某行字变为带下划线时，只需让它跟二进制的（100）进行“或”运算

如果要把粗体去掉呢？只需把001求补变为110，然后跟位标志进行“与”运算就行了

把某行字的斜体去掉，只需把010求补变为101，然后跟位标志进行“与”运算就行了

把某行字的下划线去掉，只需把100求补变为011，然后跟位标志进行“与”运算就行了

好，现在你应该理解了课本216页的那些古怪代码了吧！当然，字体样式不止这些，加粗是否放在第一个位我也不知道，但道理就是这样的。如果还不明白，请先把位运算学好了再来看这篇文章。课本的第四章也对几个位运算符&，|，~做了详细的讲解。
原文地址

]]> http://a18zhizao.com/y2009/1170_flag-judgments-and-changes-in-the-computing.html/feed 0 C#里也可以用上Eval函数[即时运算] http://a18zhizao.com/y2009/1169_c-where-also-can-be-used-for-eval-function-immediate.html http://a18zhizao.com/y2009/1169_c-where-also-can-be-used-for-eval-function-immediate.html#comments Wed, 30 Dec 2009 13:28:09 +0000 a18ccms http://www.a18zhizao.cn/y2009/1169_c-where-also-can-be-used-for-eval-function-immediate.html 因为在我的某个工具包里需要能动态执行一段代码进行求值的功能，也就是类似于JAVA SCRIPT里的Eval函数和VB SCRIPT的Execute函数功能，但C#与VB.NET却没有类似的函数:( 只能手动编写。上网搜索了一下，幸运的从一个英文站点找到了：）代码量很少，它是通过调用JScript.NET里的Eval函数进行处理的，下面是代码(部分代码我修改与删减过，并非完整的原代码，在此感谢原作者scott）：

    using System;
    using System.CodeDom.Compiler;
    using System.Reflection;

    /**//// <summary>
    /// 动态求值
    /// </summary>
    public class Evaluator
    {
        /**//// <summary>
        /// 计算结果,如果表达式出错则抛出异常
        /// </summary>
        /// <param name="statement">表达式,如"1+2+3+4"</param>
        /// <returns>结果</returns>
        public static object Eval(string statement)
        {
            return _evaluatorType.InvokeMember(
                        "Eval",
                        BindingFlags.InvokeMethod,
                        null,
                        _evaluator,
                        new object[] { statement }
                     );
        }
        /**//// <summary>
        ///
        /// </summary>
        static Evaluator()
        {
            //构造JScript的编译驱动代码
            CodeDomProvider provider = CodeDomProvider.CreateProvider("JScript");

            CompilerParameters parameters;
            parameters = new CompilerParameters();
            parameters.GenerateInMemory = true;

            CompilerResults results;
            results = provider.CompileAssemblyFromSource(parameters, _jscriptSource);

            Assembly assembly = results.CompiledAssembly;
            _evaluatorType = assembly.GetType("Evaluator");

            _evaluator = Activator.CreateInstance(_evaluatorType);
        }

        private static object _evaluator = null;
        private static Type _evaluatorType = null;
        /**//// <summary>
        /// JScript代码
        /// </summary>
        private static readonly string _jscriptSource =

            @"class Evaluator
              {
                  public function Eval(expr : String) : String
                  {
                     return eval(expr);
                  }
              }";
    }

原文地址

]]> http://a18zhizao.com/y2009/1169_c-where-also-can-be-used-for-eval-function-immediate.html/feed 4 C#以不同算法写的迷宫算法 http://a18zhizao.com/y2009/1168_c-written-in-a-different-maze-algorithms-algorithms.html http://a18zhizao.com/y2009/1168_c-written-in-a-different-maze-algorithms-algorithms.html#comments Wed, 30 Dec 2009 01:17:55 +0000 a18ccms http://www.a18zhizao.cn/y2009/1168_c-written-in-a-different-maze-algorithms-algorithms.html 简单文字描述如下：

设定当前位置的初值为入口位置；

do｛

若当前位置可通，

则｛将当前位置插入栈顶； // 纳入路径

若该位置是出口位置，则结束；

// 求得路径存放在栈中

否则切换当前位置的东邻方块为新的当前位置；

｝

否则
{

若栈不空且栈顶位置尚有其他方向未被探索，

则设定新的当前位置为: 沿顺时针方向旋转

找到的栈顶位置的下一相邻块；

若栈不空但栈顶位置的四周均不可通，

则｛ 删去栈顶位置； // 从路径中删去该通道块

若栈不空，则重新测试新的栈顶位置，

直至找到一个可通的相邻块或出栈至栈空；

｝

｝while (栈不空）

思路尝试(失败了，看下面的三种算法)

using System;
using System.Collections.Generic;
using System.Text;
using System.Collections;

namespace MazeSecond
{

    public struct StateItem
    {
        public int dir;
        public Point point;
        public int sex;
    }
    public struct Point
    {
        public int x;
        public int y;
    }
    class Program
    {
        static  Stack UptoDownStack = new Stack();
        static Stack DownToUpStack = new Stack();
        static void Main(string[] args)
        {
            //初始化迷宫
            int[,] MazeItem = new int[10, 10]
            {
                {1,1,1,1,1,1,1,1,1,1},
                {1,0,1,1,1,0,0,0,1,1},
                {1,0,0,1,1,0,1,0,1,1},
                {1,0,0,0,0,0,1,0,1,1},
                {1,1,0,1,0,1,1,0,1,1},
                {1,1,0,1,0,1,1,0,1,1},
                {1,0,0,0,1,1,1,0,1,1},
                {1,1,0,0,0,0,0,0,1,1},
                {1,1,1,1,1,1,0,0,0,1},
                {1,1,1,1,1,1,1,1,1,1}
            };
            //输出迷宫
            for (int i = 0; i <= MazeItem.GetUpperBound(0); i++)
            {
                for (int j = 0; j <= MazeItem.GetUpperBound(1); j++)
                {
                    Console.Write(MazeItem[i, j]);
                }
                Console.WriteLine();
            }
            //起点初始化
            StateItem UptoDownItem = new StateItem();
            UptoDownItem.dir = 1;
            UptoDownItem.point = new Point();
            UptoDownItem.point.x = 1;
            UptoDownItem.point.y = 1;
            UptoDownItem.sex = 0;
            //终点初始化
            StateItem DowntoUPItem = new StateItem();
            DowntoUPItem.dir = 1;
            DowntoUPItem.point = new Point();
            DowntoUPItem.point.x = 8;
            DowntoUPItem.point.y = 8;
            DowntoUPItem.sex = 1;

            UptoDownStack.Push(UptoDownItem);
            DownToUpStack.Push(DowntoUPItem);
            do
            {
               StateItem UptoDown=ReturnStatItem(UptoDownItem);
               StateItem DowntoUP = ReturnStatItem(DowntoUPItem);
                UptoDownStack.Push(UptoDown);
                DownToUpStack.Push(DowntoUP);
                if (UptoDown.point.x == DowntoUP.point.x && UptoDown.point.y == DowntoUP.point.y)
                {
                    break;
                }

            } while (UptoDownStack.Count > 0);

            while(DownToUpStack.Count > 0)
            {
                UptoDownStack.Push(DownToUpStack.Pop());
            }

            if (UptoDownStack.Count > 0)
            {
                while (UptoDownStack.Count > 0)
                {
                    StateItem st = (StateItem)UptoDownStack.Pop();
                    Console.WriteLine(st.point.x + "," + st.point.y);
                }
            }
            else
            {
                Console.WriteLine("无");
            }
        }
        public static StateItem ReturnStatItem(StateItem stateItem)
        {
            //初始化迷宫
              int[,] MazeItem = new int[10, 10]
            {
                {1,1,1,1,1,1,1,1,1,1},
                {1,0,1,1,1,0,0,0,1,1},
                {1,0,0,1,1,0,1,0,1,1},
                {1,0,0,0,0,0,1,0,1,1},
                {1,1,0,1,0,1,1,0,1,1},
                {1,1,0,1,0,1,1,0,1,1},
                {1,0,0,0,1,1,1,0,1,1},
                {1,1,0,0,0,0,0,0,1,1},
                {1,1,1,1,1,1,0,0,0,1},
                {1,1,1,1,1,1,1,1,1,1}
            };

            switch (stateItem.dir)
            {
                case 1:
                    stateItem.point.y = stateItem.point.y - 1;
                    break;
                case 2:
                    stateItem.point.x = stateItem.point.x + 1;
                    break;
                case 3:
                    stateItem.point.y = stateItem.point.y + 1;
                    break;
                case 4:
                    stateItem.point.x = stateItem.point.x - 1;
                    break;
                default :
                    break;
            }
            if (MazeItem[stateItem.point.x, stateItem.point.y] == 0)
            {
                return stateItem;
                MazeItem[stateItem.point.x, stateItem.point.y] = 2;
                stateItem.dir = 1;
            }
            else
            {
                if (stateItem.dir != 4)
                {
                    stateItem.dir++;
                    switch (stateItem.dir)
                    {
                        case 1:
                            stateItem.point.y = stateItem.point.y + 1;
                            break;
                        case 2:
                            stateItem.point.x = stateItem.point.x - 1;
                            break;
                        case 3:
                            stateItem.point.y = stateItem.point.y - 1;
                            break;
                        default:
                            break;
                    }
                    return stateItem;
                }
                else
                {
                    if (stateItem.sex == 0)
                    {
                        UptoDownStack.Pop();//第一次抛栈
                        stateItem = (StateItem)UptoDownStack.Pop();//第二次抛栈
                        if (stateItem.dir != 4)
                        {
                            stateItem.dir++;
                        }
                        return stateItem;
                    }
                    else
                    {
                        DownToUpStack.Pop();
                        stateItem = (StateItem)DownToUpStack.Pop();
                        if (stateItem.dir != 4)
                        {
                            stateItem.dir++;
                        }
                        return stateItem;
                    }
                }
            }
        }
    }
}

第一个算法：

/// <summary>
/// 走迷宫
/// </summary>
/// <param name="maze">迷宫矩阵</param>
/// <param name="curr">当前位置</param>
/// <param name="dest">目标位置</param>
/// <returns>返回是否走到终点</returns>
private bool SpyMaze(ref int[,] maze, Point curr, Point dest)
{
    if (!Rectangle.FromLTRB(0, 0, maze.GetLength(0),
        maze.GetLength(1)).Contains(curr)) return false; // 走到边界
    if (maze[curr.X, curr.Y] != 0) return false; // 墙或者是已经走过
    maze[curr.X, curr.Y] = 2; // 标记已经走过
    if (curr == dest) return true; // 走到目的地
    Point[] offset = {
        new Point(00, -1), new Point(+1, 00),
        new Point(00, +1), new Point(-1, 00)
    };
    bool result = false;
    for (int i = 0; !result && i < offset.Length; i++)
    {
        Point move = curr;
        move.Offset(offset[i]);
        result = SpyMaze(ref maze, move, dest);
    }
    if (!result) maze[curr.X, curr.Y] = 0; // 还原
    return result;
}

private void button1_Click(object sender,EventArgs e)
{
    int[,] maze = {
        {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
        {1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1},
        {1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0},
        {1,0,1,1,1,1,1,1,1,1,1,1,0,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,0,1,0,1,1,1,0},
        {1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,1,0,1,0},
        {1,0,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,0,1,0,1,0,1,0,1,0},
        {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,1,0,1,0,1,0},
        {1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,0,1,0,1,0,1,0,1,0,1,0},
        {1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,1,0,1,0},
        {1,0,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,0,1,1,1,0,1,0,1,0,1,0,1,0,1,0},
        {1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},
        {1,0,1,0,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},
        {1,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},
        {1,0,1,0,1,0,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},
        {1,0,1,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},
        {1,0,1,0,1,0,1,0,1,0,1,1,1,1,1,1,1,1,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},
        {1,0,1,0,1,0,1,0,1,0,1,0,0,0,0,0,0,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},
        {1,0,1,0,1,0,1,0,1,0,1,0,1,1,1,1,1,1,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},
        {1,0,1,0,1,0,1,0,1,0,1,0,1,0,0,0,0,0,0,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},
        {1,0,1,0,1,1,1,0,1,0,1,0,1,0,1,1,1,1,1,1,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},
        {1,0,1,0,0,0,0,0,1,0,1,0,1,0,1,0,0,0,0,0,0,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},
        {1,0,1,0,1,1,1,0,1,0,1,0,1,0,1,1,1,1,1,1,1,1,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},
        {1,0,1,0,1,0,1,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},
        {1,0,1,0,1,0,1,0,1,0,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},
        {1,0,1,0,1,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},
        {1,0,1,0,1,0,1,0,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,0,1,0,1,0,1,0,1,0,1,0},
        {1,0,1,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,1,0,1,0,1,0},
        {1,0,1,0,1,0,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,0,1,0,1,0,1,0,1,0,1,0},
        {1,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,1,0,1,0,1,0,1,0},
        {1,0,1,0,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,0,1,0,1,0,1,0,1,0,1,0},
        {1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,1,0,1,0,1,0},
        {1,0,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,0,1,0,1,0,1,0,1,0,1,0},
        {1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},
        {1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},
        {1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},
        {1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,0,1,1,1,1,1,1,1,0,1,0,1,0,1,1,1,0,1,0,1,0,1,0},
        {1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,1,0,1,0},
        {1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,0,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,0,1,0,1,0},
        {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0},
        {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,0},
        {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0},
    };
    SpyMaze(ref maze, new Point(0, 0),
        new Point(maze.GetLength(0) - 1, maze.GetLength(1) - 1));
    for (int i = 0; i < maze.GetLength(0); i++)
    {
        for (int j = 0; j < maze.GetLength(1); j++)
        {
            if (maze[i, j] == 2)
                Console.Write("[color=#FF0000]{0}[/color]", maze[i, j]);
            else Console.Write(maze[i, j]);
        }
        Console.WriteLine();
    }
}
结果：
2222222222222000000000000000000000000000
1111111111112111111111111111111110111111
1222222222222100000000000000000010122222
1211111111110101111111111111111010121112
1210000000000101000000000000001010121012
1211111111111101111111111111101010121012
1222222222222222222200000000101010121012
1011111111111111111211111111101010121012
1010000000000000001210000000001010121012
1010111111111111111211111011101010121012
1010100000000000000222221010101010121012
1010101111111111111111121010101010121012
1010101000000000000000121010101010121012
1010101011111111111110121010101010121012
1010101012222222222210121010101010121012
1010101012111111111210121010101010121012
1010101012100000001210121010101010121012
1010101012101111111210121010101010121012
1010101012101222222210121010101010121012
1010111012101211111110121010101010121012
1010000012101210000000121010101010121012
1010111012101211111111121010101010121012
1010101012101222222222221010101010121012
1010101012101111111111111010101010121012
1010101012100000000000000010101010121012
1010101012111111111111111110101010121012
1010101012222222222222222200101010121012
1010101011111111111111111211101010121012
1010101000000000000000001210001010121012
1010101111111111111111111211101010121012
1010100000000000000000000222101010121012
1010111111111111111111111112101010121012
1010000000000000000000000012101010121012
1011111111111110111111111012101010121012
1000000000000010100000000012101010121012
1011111111111110101111111012101110121012
1010000000000000101000000012100000121012
1011111111111111101011111112111111121012
1000000000000000001010000002222222221012
1111111111111111111011111111111111111012
0000000000000000000000000000000000000012

再来一种算法：

using System;
using System.Collections.Generic;
using System.Text;
namespace 迷宫问题_BFS
{
    class Program
    {
        struct Point
        {
            public int X;
            public int Y;
        }
        struct MapState
        {
            public int[,] Map;
            public Point Current;
            public bool Flag;
        }
        const int WIDTH=10;
        const int HEIGHT=10;
        static MapState[] list = new MapState[100000];
        static int[,] box = new int[WIDTH, HEIGHT]
            {
                {1,1,1,1,1,1,1,1,1,1},
                {1,0,1,1,1,0,0,0,1,1},
                {1,0,0,1,1,0,1,0,1,1},
                {1,0,0,0,0,0,1,0,1,1},
                {1,1,0,1,0,1,1,0,1,1},
                {1,1,0,1,0,1,1,0,1,1},
                {1,0,0,0,1,1,1,0,1,1},
                {1,1,0,0,0,0,0,0,1,1},
                {1,1,1,1,1,1,0,0,0,1},
                {1,1,1,1,1,1,1,1,1,1}
            };
        static void Main(string[] args)
        {
            Console.WriteLine("原来的样子：");
            for(int i=0;i<WIDTH;i++)
            {

                for (int y = 0; y < HEIGHT; y++)
                {
                    if (box[i, y] == 1)
                    {
                        Console.ForegroundColor = ConsoleColor.Green  ;
                        Console.Write(" "+ box[i, y].ToString ());

                    }
                    else if (box[i, y] == 0)
                    {
                        Console.ForegroundColor = ConsoleColor.White ;
                        Console.Write(" "+ box[i, y].ToString ());

                    }
                    else if (box[i, y] ==2)
                    {
                        Console.ForegroundColor = ConsoleColor.Red ;
                        Console.Write(" "+box[i, y].ToString());
                    }
                }
                Console.WriteLine();
            }
            Walk();
            Console.WriteLine("走出的样子：");
            for (int i = 0; i < WIDTH; i++)
            {
                for (int y = 0; y < HEIGHT; y++)
                {
                    if (list[Resualt1].Map[i, y] == 1 && list[Resualt2].Map[i, y] == 1)
                    {
                        Console.ForegroundColor = ConsoleColor.Green;
                        Console.Write(" 1");

                    }
                    else if (list[Resualt1].Map[i, y] == 0 && list[Resualt2].Map[i, y] ==0)
                    {
                        Console.ForegroundColor = ConsoleColor.White;
                        Console.Write(" 0");

                    }
                    else if (list[Resualt1].Map[i, y] == 2 || list[Resualt2].Map[i, y] == 2)
                    {
                        Console.ForegroundColor = ConsoleColor.Red;
                        if (list[Resualt1].Map[i, y] == 2)
                        {
                            Console.Write(" " + list[Resualt1].Map[i, y].ToString());
                            continue;
                        }
                        if (list[Resualt2].Map[i, y] == 2)
                        {
                            Console.Write(" " + list[Resualt2].Map[i, y].ToString());
                            continue;
                        }
                    }
                }
                Console.WriteLine();
            }
            Console.Read();
        }
        static void Print(int[,] box)
        {
            for (int i = 0; i < WIDTH; i++)
            {
                Console.WriteLine();
                for (int y = 0; y < HEIGHT; y++)
                {
                    if (box[i, y] == 1)
                    {
                        Console.ForegroundColor = ConsoleColor.Green;
                        Console.Write(" " + box[i, y].ToString());

                    }
                    else if (box[i, y] == 0)
                    {
                        Console.ForegroundColor = ConsoleColor.White;
                        Console.Write(" " + box[i, y].ToString());

                    }
                    else if (box[i, y] == 2)
                    {
                        Console.ForegroundColor = ConsoleColor.Red;
                        Console.Write(" "+box[i, y].ToString());
                    }
                }
            }
        }
        static int Resualt1 = 0;
        static int Resualt2 = 0;
        static int f = 0; static int l = 1;
        static void Walk()
        {
            list[f] = CreateMapState(1,1,box,true);
            list[f + 1] = CreateMapState(8, 8, box,false);
            do
            {
                Move(list[f], 0, 1,list[f].Flag );
                Move(list[f], 1, 0, list[f].Flag);
                Move(list[f], 0, -1, list[f].Flag);
                Move(list[f], -1, 0, list[f].Flag);
                f++;
            }
            while (CheckOut());
        }
        static bool CheckOut()
        {
            for (int i =0  ; i < l; i++)
            {
                for (int k = i+1; k < l-1; k++)
                {
                    if (list[i].Current.X == list[k].Current.X && list[i].Current.Y == list[k].Current.Y && list[i].Flag!=list[k].Flag )
                    {
                        Resualt1 = i;
                        Resualt2 = k;
                        return false;
                    }
                }
            }
            return true;
        }
        static void Move(MapState map,int x,int y,bool flag)
        {
            if (map.Map[map.Current.X + x, map.Current.Y + y] != 1 && map.Map[map.Current.X + x, map.Current.Y + y] != 2)
            {
                if (map.Current.X + x > 0 && map.Current.Y + y > 0)
                {
                    l++;
                    list[l] = CreateMapState(map.Current.X + x, map.Current.Y + y, map.Map, flag);
                }
            }

        }
        static MapState CreateMapState(int x,int y,int[,] tmp,bool flag)
        {
            MapState box;
            box.Flag = flag;
            box.Map = (int[,])tmp.Clone ();
            box.Map [x, y] = 2;
            box.Current.X = x;
            box.Current.Y = y;
            return box;
        }
    }
}

其实2头和1头开始都是一回事
你一开始就压个坐标进队列
一个是入口，一个是出口
然后宽度优先搜索·····
最后如果出口和入口的坐标推出的路线有点重叠就找到出路了···
但是每走都要记下当前地图的状态
CreateMapState干的就是这个
Walk是开始走迷宫
CheckOut是检查出口和入口推出的路线有无重叠点
如果没有就继续推 如果有就EXIT···打出路线
Print是我调试用的。。没用……

struct MapState
        {
            public int[,] Map;地图的位置状态
            public Point Current;但前走到哪个点
            public bool Flag;是入口推出点还是出口推出的点
        }
在WinForm下
System.Console.WriteLine("Debug日志");
和
System.Diagnostics.Debug.WriteLine("Debug日志");
相当

Console.Write("[color=#FF0000]{0}[/color]", maze[i, j]);
这类是细节输出的问题，自己动手改改就可以了。

再写个算法：

using System;

namespace ConsoleApplication1
{
    class Program
    {
        static int[,] MazeItem = new int[10, 10]   //初始化迷宫
            {
                {1,1,1,1,1,1,1,1,1,1},
                {1,0,1,1,1,0,0,0,1,1},
                {1,0,0,1,1,0,1,0,1,1},
                {1,0,0,0,0,0,1,0,1,1},
                {1,1,0,1,0,1,1,0,1,1},
                {1,1,0,1,0,1,1,0,1,1},
                {1,0,0,0,1,1,1,0,1,1},
                {1,1,0,0,0,0,0,0,1,1},
                {1,1,1,1,1,1,0,0,0,1},
                {1,1,1,1,1,1,1,1,1,1}
            };

        static void Main(string[] args)
        {
            if (!LetsGo(1, 1, 1, 5))
                Console.WriteLine("走不通。");
            else
                Console.WriteLine("    打印的是从出口到入口的路径。");
        }

        static bool LetsGo(int startX, int starY, int endX, int endY)
        {
            if (startX < 0 || startX >= 10 || endX < 0 || endX >= 10 || MazeItem[startX, starY] == 1)
                return false;

            MazeItem[startX, starY] = 1;    //避免重复
            if ((startX == endX && starY == endY) ||
                LetsGo(startX - 1, starY, endX, endY) || LetsGo(startX + 1, starY, endX, endY) ||
                LetsGo(startX, starY + 1, endX, endY) || LetsGo(startX, starY - 1, endX, endY))
            {
                print(startX, starY);
                return true;
            }
            else
                return false;
        }

        static void print(int x, int y)
        {
            Console.Write(string.Format("[{0},{1}]", x, y));
        }
    }
}

除非你多线程使用到多核，并且你合理地解决了数据重复问题，有可能快一点 --> 除非你多线程使用到多核，并且你合理地解决了数据并发冲突问题，有可能快一点
但这种快跟算法无关。
呵，我的程序跟上面的程序的逻辑是一样重复的。
其实，对于这类最简单的遍历，你知道“避免重复”就一切通吃了。至于搞什么树、栈结构，都是非常次要的。你的算法一样，只不过是经过每一个路径时“顺便留下的脚印”放在不同的结构中罢了。

树是最浪费资源的，而栈（不论函数栈还是显示自定义栈）对资源的使用主要跟深度有关。要想让“深度”最低，在每一次决定“向左、向右、向上、向下”这个次序的时候就不能无头苍蝇地机械决定，到达目的地距离最短的方向优先被选择则占用的栈最浅。但是，如果搜索过程中就知道哪条分支到达目的地最近，这就成了神仙了。所以一般的搜索策略都会开发不同的“启发函数”来决定搜索方向的排序，但是这个启发函数的好坏其实也往往是撞大运。

因此，不论你怎么搜，问题本身就是如此简单，没有什么真正管用的启发函数，那么就没有什么高明的策略。

这不像下棋。两个棋手的脑筋同样的“容量”，都是能够看到三步以外，但是一个棋手对形势判断的启发函数优于另一个，那么同样的算法下第一个人可以获胜。

]]> http://a18zhizao.com/y2009/1168_c-written-in-a-different-maze-algorithms-algorithms.html/feed 0 天草迷宫独特算法 http://a18zhizao.com/y2009/1163_amakusa-a-unique-algorithm-for-maze.html http://a18zhizao.com/y2009/1163_amakusa-a-unique-algorithm-for-maze.html#comments Tue, 29 Dec 2009 04:31:34 +0000 a18ccms http://www.a18zhizao.cn/y2009/1163_amakusa-a-unique-algorithm-for-maze.html 代码下载
原文地址

因为实验要求写迷宫算法的缘故，不得不研究一下这个看似没用的东西。实验要求上有提示算法思路，还有伪代码（本人灰常反感。。。代码都给了，当我白痴啊？）。老师上课也讲了思路，但是我一下子没听懂。然后就不听了。伪代码也懒得去看。自己想吧。书上给的算法是堆栈，递归，路过标记，死路回头，当然少不了几个结构。

下面说说我的算法，我的大思路是：把通路留住把死路消灭。可以想象一下，0代表通路，1代表墙。那既然通路都给我们了，我们只需将死路灭掉，当然，如果迷宫本来设计就走不通的话。那只会剩下出入口。

1、判断死路的方法

迷宫是个二维数组，周围有一圈墙。如，题目给的迷宫是10X10的话这里要定义一个12X12的二维数组，并且外围赋值1。节点可以向八个方向试探。

先定义节点结构，如图

紫色为零，可走通

代码：

class Node
        {
            public int[] D = new int[8];//方向数组
            public int x;//当前Node在迷宫数组的坐标
            public int y;
        }

死路即为只有一条后路的节点，有两种情况：

1、斜方向（1，3，5，7都是斜方向）

2、直方向（0，2，4，6都是直方向）

通过观察可以发现，当前节点周围有7堵墙，即7个1。也可以判断连续五个方向为1。

满足上述条件的当前节点置为1（迷宫数组置为1），如此循环死路就会一个个消失。

代码：

private void T_天草必杀()
        {
            int count = 0;//记录8方向通路的个数
            for (int i = 0; i < 10; i++)
                for (int j = 0; j < 10; j++)
                {
                    count = 0;
                    if ((i != P_入口.X && j != P_入口.Y) || (i != P_出口.X && j != P_出口.Y))//出入口不处理
                    {
                        F_赋值tmpNode(i, j);
                        for (int k = 0; k < 8; k++)
                        {
                            if (tmpNode.D[k] == 48)//48为"0"的数值，即通路。49为"1"，懒得处理了- -！

                                count++;

                        }
                        if (count < 2)
                        {
                            maze[i + 1, j + 1] = 49;
                        }
                    }
                }//遍历MAZE
        }

当然，这里显然没有考虑大路（当前节点有一条以上的通路）的情况。好，下面这循环搞定大路。经过下面这个循环，迷宫只会剩下上面那两种情况。

 

2、消灭大路（非大陆啊，看清楚，别说我反国家啊）

像这种情况叫大路，人眼观察为死路，要消灭的。

判断方法：当0，2（2，4）方向为墙，5（7）方向为通路 即置为死路。

0，2，5方向为一组。2，4，7方向为一组，4，6，1方向为一组，6，0，3方向为一组

代码：

private void Find_a_way()
        {
            for (int i = 0; i < 10; i++)
                for (int j = 0; j < 10; j++)
                {
                    if ((i != P_入口.X && j != P_入口.Y) || (i != P_出口.X && j != P_出口.Y))
                    {
                        F_赋值tmpNode(i, j);
                        if ((tmpNode.D[0] == 48 && tmpNode.D[2] == 48 && tmpNode.D[5] == 49) || (tmpNode.D[2] == 48 && tmpNode.D[4] == 48 && tmpNode.D[7] == 49) || (tmpNode.D[4] == 48 && tmpNode.D[6] == 48 && tmpNode.D[1] == 49) || (tmpNode.D[6] == 48 && tmpNode.D[0] == 48 && tmpNode.D[3] == 49))//精髓- -！
                        maze[i + 1, j + 1] = 49;
                    }
                }//遍历MAZE
        }

 

这里提醒一点，这个函数不要对出入口判断。因为出入口一大半是墙（参见定义的二维数组）

注意：

经过这个循环，迷宫就剩下前面所说的两种路了。写思路是先T_天草必杀()后Find_a_way()，实际是操作是先Find_a_way()后T_天草必杀()的。这个算法经过老师的检验的，没问题。

有些细节用不同的语言的童鞋改一下

]]> http://a18zhizao.com/y2009/1163_amakusa-a-unique-algorithm-for-maze.html/feed 0 一个C#的迷宫生成算法，采用深度优先遍历拆墙 http://a18zhizao.com/y2009/1162_ac-maze-generation-algorithm-using-depth-first-traversal-lift.html http://a18zhizao.com/y2009/1162_ac-maze-generation-algorithm-using-depth-first-traversal-lift.html#comments Tue, 29 Dec 2009 02:52:02 +0000 a18ccms http://www.a18zhizao.cn/y2009/1162_a-c-maze-generation-algorithm-using-depth-first-traversal-lift.html 因为最近要用C#开发一个走迷宫的小游戏，所以需要编写一个随机生成迷宫的组件，但是查阅了网上的很多相关资料，都不是很全。只知道最好的方法是采用图的遍历来做，但是依然不得要领。后来无意中看到了CodeZone上面的Generating Maze using C# and .NET（By Mike Gold September 25, 2002 ），才一下子明白过来，思路也清晰了。

这是Mike的程序的UML图——

Mike的程序的UML图

public void Generate()
{
while (VisitedCells < TotalCells)
{
// get a list of the neighboring cells with all 4 walls intact
ArrayList AdjacentCells = GetNeighborsWithWalls(CurrentCell);
// test if a cell like this exists
if (AdjacentCells.Count > 0)
{
// yes, choose one of them, and knock down the wall between it and the current cell
int randomCell = Cell.TheRandom.Next(0, AdjacentCells.Count);
Cell theCell = ((Cell)AdjacentCells[randomCell]);
CurrentCell.KnockDownWall(theCell);
CellStack.Push(CurrentCell); // push the current cell onto the stack
CurrentCell = theCell; // make the random neighbor the new current cell
VisitedCells++; // increment the # of cells visited
}
else // No adjacent cells that haven't been visited, go back to the previous cell
{
CurrentCell = (Cell)CellStack.Pop();
}
}
}

程序的核心在于遍历所有迷宫格子。Mike是这样写的

我通过分析这个Generate()函数，再结合上方的UML，大致复原了Mike缩写程序的源代码。

简单的说，Mike这个程序的思路是这样的：

迷宫的格子当然是一个单独的类MazeCell，该对象除了拥有行、列两个坐标值外，还需要一个很重要的属性——墙，一个四个元素的INT型数组（private int[] wall = { 1, 1, 1, 1 };）。遍历迷宫的过程，就是拆墙的过程，数组的四个元素分别代表迷宫各自上、下、左、右四面墙的状态，拆哪面墙就将其置0以标志。相应的拆墙函数为KnockDownWall()。

迷宫格子的类写完了，相当于是基础已经搭建了起来。接下来就是核心的迷宫类，首先该对象必须用一个二维数组MazeCell[,] cells来装迷宫格子，然后需要一个堆栈Stack<MazeCell> mazeStack来装遍历过程中临时存储用的格子。

在最核心的遍历循环中，首先要从当前格子周围找一个四面墙都在的相邻格子（相邻是指的位于当前格子的上下左右），也就是未曾被访问的格子。这时可能得到以下几种结果：

1、有不止一个相邻的格子都未被访问过：这时需要生成一个随机数，挑选其中一个出来拆掉它与当前格子之间的墙并且压入堆栈，同时将其作为新的当前格子。

2、只有一个相邻的各自未被访问，这更方便，随机数都不用生成了，直接拿来拆墙，之后同上。

3、周围的格子都被访问过了，这说明当前格子已经走到了一条死路的尽头，所以需要把堆栈中的前一个格子Pop出来当作当前格子，再看看周围是否有路，如果还是没有就继续Pop直到能找到另外一条路。

该循环在访问完所有的格子后结束。此时，所有的格子都被拆掉了一面墙，迷宫也就生成了。

（数字表示程序遍历该迷宫的顺序）
遍历迷宫图
原文地址

]]> http://a18zhizao.com/y2009/1162_ac-maze-generation-algorithm-using-depth-first-traversal-lift.html/feed 0 新Orcas语言特性：Lambda表达式 http://a18zhizao.com/y2009/1161_new-orcas-language-features-lambda-expressions.html http://a18zhizao.com/y2009/1161_new-orcas-language-features-lambda-expressions.html#comments Tue, 29 Dec 2009 00:53:10 +0000 a18ccms http://www.a18zhizao.cn/y2009/1161_new-orcas-language-features-lambda-expressions.html 【原文地址】New "Orcas" Language Feature: Lambda Expressions
【原文发表日期】 Sunday, April 08, 2007 4:21 PM
【译文地址】 这里

上个月我开始了一个贴子系列，讨论作为Visual Studio和.NET框架Orcas版本一部分发布的一些新的VB和C#语言特性。下面是这个系列的前2篇贴子：

今天的贴子讨论另一个基础性的新语言特性：Lambda表达式。

什么是Lambda表达式？

随VS 2005发布的C#2.0引进了匿名方法的概念，允许在预期代理(delegate)值的地方用“行内(in-line)”代码块(code blocks)来做替代。

Lambda表达式为编写匿名方法提供了更简明的函数式的句法，但结果却在编写LINQ查询表达式时变得极其有用，因为它们提供了一个非常紧凑的而且类安全的方式来编写可以当作参数来传递，在以后作运算的函数。

Lambda表达式的例子：

在我以前的扩展方法博客贴子里，我演示了你如何可以象下面这样声明一个简单的Person类：

然后，我示范了你可以如何使用一些值来生成一个List<Person>集合的实例，然后使用由LINQ提供的新的Where和Average扩展方法来返回集合中的人的一个子集，以及计算这个集合中的人的平均年龄：

上面高亮标记的红色 p => 表达式就是Lambda表达式。在上面的例子里，我用第一个lambda来指定获取特定人时所用的过滤条件，用第二个lambda来指定在计算平均年龄时该用Person对象的哪个值。

详解Lambda表达式

理解Lambda表达式最容易的方法是把它们设想成编写简明的行内方法的方式。譬如，我上面编写的例子可以使用C#2.0的匿名方法来编写，象这样：

上面两个匿名方法都接受一个Person类型的参数。第一个匿名方法返回一个布尔值，表示Person的LastName是否是Guthrie，第二个匿名方法返回一个整数值（返回那个人的年龄）。我们前面使用的lambda表达式的作用是一样的，两个表达式都接受一个Person类型的参数。第一个lambda表达式返回一个布尔值，第二个返回一个整数。

在C#里，一个lambda表达式在句法上是写成一个参数列表，随后是 => 符号，随后是表达式在调用时要运算的表达式或者语句块：

params => expression

所以，当我们编写这样的lambda表达式时：

p => p.LastName == "Guthrie" 

我们是想表示，我们在定义的Lambda接受一个参数p，要运行的代码表达式返回p.LastName的值是否等于“Guthrie”。 我们将参数命名为p是不相干的，我也可以很容易地将其命名为o，x，foo，或者我想要的任何名字。

不象匿名方法要求参数类型是明确地指明的，Lambda表达式允许省略参数类型，而允许它们根据用法来推断出类型。譬如，当我编写 p=>p.LastName == "Guthrie" 这个lambda表达式时，编译器推断出p参数属于Person类型，因为当前的Where扩展方法的对象是个范型的List<Person>集合。

Lambda参数的类型可以在编译时和被Visual Studio的intellisense引擎推断出来，这意味着在编写lambda时你将获得完全的intellisense 和编译时检查。譬如，注意当我在下面健入 p.  时，Visual Studio Orcas是如何提供intellisense完成的，因为它知道 p 是 Person类型：

注: 假如你要给一个Lambda表达式明确地声明参数的类型的话，你可以在Lambda参数表里的参数名字前声明参数类型，象这样：

针对框架开发人员的高级内容：Lambda表达式树 (Lambda Expression Trees)

从一个框架开发人员(framework developer)的角度来看，使得Lambda表达式特别强有力的事情之一是，它们既可以以基于IL的方法的形式被编译成代码代理（code delegate），或者也可以编译成一个表达式树(expression tree)对象，然后在运行时用来分析，转换或者优化表达式。

能将Lambda表达式编译成一个表达式树对象是个强大无比的机制，将促成许多使用场景，包括使用能提供编译时句法检查和VS intellisense的统一的查询语言来建立支持丰富数据查询的高性能对象映射器（无论是关系数据库，活动目录，还是web服务）之能力。

从Lambda表达式到代码代理 (Code Delegates)

上面的Where扩展方法是个将Lambda表达式编译成代码代理(code delegate)的例子（意即它是编译成IL的，可以以代理的形式调用）。支持象上面那样过滤任何IEnumerable集合的Where()扩展方法可以使用下面这样的扩展方法代码来实现：

上面的Where()扩展方法接受一个 Func<T, bool> 类型的过滤参数，该参数是个接受一个类型为T的参数，返回一个布尔值表示条件是否满足的方法之代理。当我们把Lambda表达式作为一个参数传递给这个Where() 扩展方法时，C#编译器会将我们的Lambda表达式编译成IL方法代理（这里，<T> 将是Person），然后我们的Where()方法可以调用来计算某个给定条件是否被满足了。

从Lambda表达式到表达式树

当我们要想针对类似我们的列表集合一样的内存中的数据做运算时，把lambda表达式编译成代码代理是恰如其分的。但考虑一下你想要查询数据库里的数据的情形(下面的代码是使用Orcas中内置的LINQ到SQL对象关系映射器写成的) :

这里，我要从数据库里取出一串强类型的Product对象，我向Where()扩展方法表示，要通过一个Lambda表达式来做过滤。

我绝对不想要看到发生的是，从数据库里取回所有的产品记录，将它们放在一个局部的集合里，然后在内存里对它运行Where()扩展方法来进行过滤。这么做效率极其不高，对大数据库的扩缩性将是极差的。而我希望的是，LINQ到SQL的ORM将我上面的Lambda过滤条件翻译成SQL表达式，然后在远程的数据库里进行过滤性查询。那样的话，我只返回那些符合查询条件的记录，这样的数据库查询效率是非常高的。

框架开发人员可以通过声明他们的Lambda表达式参数是个Expression<T>类型，而不是Func<T>类型来取得这样的结果。这会导致Lambda表达式参数被编译成一个我们可以在运行时拆开和分析的表达式树：

注意上面我是怎么把我们在先前用过的同样的 p=>p.LastName == "Guthrie" Lambda表达式，但这次将其赋值给一个 Expression<Func<Person, bool>> 变量，而不是Func<Person,bool> 变量。编译器不会产生IL，而是会指派一个表达式树对象，然后我作为一个框架开发人员就可以用它来对相应的Lambda表达式进行分析，按我想要的方式对其进行运算(譬如，我可以挑出表达式中的类型，名字和值等)。

在LINQ到SQL的情形下，它会将这个Lambda过滤语句翻译成标准的关系SQL语句，来对数据库进行操作(从逻辑上来说，一个“SELECT * from Products where UnitPrice < 55”语句)。

IQueryable<T> 接口

为帮助框架开发人员建立可查询的数据提供器，LINQ提供了 IQueryable<T> 接口。这个接口实现了标准的LINQ扩展方法查询运算符，提供了一个更便利的方式来实现对一个复杂的表达式树的处理(譬如，象下面这样，我用了3个不同的扩展方法，2个lambda来从数据库取回10个产品的情形)：

想阅读一些关于如何使用 IQueryable<T> 来建立自定义的LINQ数据提供器的精彩博客系列的话，请看一下下面这些别人写的精彩博客贴子：

结语

希望上面的贴子内容对如何考虑和使用Lambda表达式提供了基本的理解。当与Orcas中System.Linq命名空间下提供的内置标准查询扩展方法结合使用时，它们提供了一个非常好的方式来对任何类型的数据进行查询和交互，同时还保持了对完整的编译时检查和intellisense的支持。

通过利用由Lambda提供的对表达式树的支持，以及 IQueryable<T> 接口，构建数据提供器的框架开发人员可以确保开发人员编写的干净的编码，对任何数据源(无论是数据库，XML文件，内存中的对象，web服务，LDAP系统等)运行起来速度快而且效率高。

在下几个星期里，我将完成这个从理论的层次上讨论新核心语言概念的语言系列，然后转到讨论一些极其实用的实战例子(特别是针对数据库和XML文件使用LINQ的场景)。

希望本文对你有所帮助，

Scott

]]> http://a18zhizao.com/y2009/1161_new-orcas-language-features-lambda-expressions.html/feed 0 反编译工具Reflector下载(集成两个常用.net插件,FileGenerator和FileDisassembler) http://a18zhizao.com/y2009/1158_download-reflector-decompiler-tools-integrated-two-commonly-used-net-plug-ins-filegenerator-and-filedisassembler.html http://a18zhizao.com/y2009/1158_download-reflector-decompiler-tools-integrated-two-commonly-used-net-plug-ins-filegenerator-and-filedisassembler.html#comments Fri, 25 Dec 2009 01:36:25 +0000 a18ccms http://www.a18zhizao.cn/y2009/1158_download-reflector-decompiler-tools-integrated-two-commonly-used-net-plug-ins-filegenerator-and-filedisassembler.html Reflector是一款比较强大的反编译工具,相信很多朋友都用过它,但reflector本身有很多局限性,比如只能一个一个的查看方法等,但幸好reflector支持插件功能目前网上有很多reflector的插件,本人找取了两个应用范围很广,并且广受好评的插件:Reflector.FileDisassembler和Reflector.FileGenerator和Reflector进行了整合,放在了一个压缩包中,大家可以直接解压缩后就开始使用,其中FileGenerator在网上没有现成dll,本人编译后将其取出,放在了压缩包中,一直在苦苦找寻的朋友这次可以拿来直接用了:)

点击下载Reflector集成压缩包

本压缩包中Reflector.exe已经升级为最新的5.0版本,具体的使用方法不多说了,只简单介绍一下本压缩包的使用步骤:
先下载本压缩包并解压缩,运行其中的Reflector.exe(主程序),初次运行会弹出错误提示对话框,因为引用的两个插件DLL是按照我本地实际情况配置的,所以你还需要根据你的实际情况来从新配置一下,方法很简单,我们拿引用FileGenerator.dll来做一个范例,
首先介绍一下Filegenerator,FileGenerator插件的作用是：根据dll文件，把里面的源文件导出成文件，导出来的文件除了没有注释，变量名也变了，其它的可谓是没有差别。对于一些比较好的控件，如果不是开源的，完全可以导出成文件，然后自己加上注释，少许修改，很好的利用起来。（不开源的dll，用起来也不放心啊）

具体的初始化设置方法:点击View->Add-Ins...,弹出一个窗口，然后点击Add->选择文件夹里面的："FileGenerator.dll",点击close.
然后回到Reflector窗口，Tool->Generator File(s)... 右边就出现了插件的窗口，选中左边的dll文件，点击右边的导出文件，源代码就全部导出来了！
另一个插件Reflector.FileDisassembler.dll设置方法也和这个一样,另外再提供一些Reflector的相关插件下载，

Reflector.FileDisassembler
This add-in can be used to dump the disassembler output to files for any Reflector supported language.
Website Download   
Reflector.CodeMetrics
Analyses .NET assemblies and shows design quality metrics. The menu item is registered under the "Tools" menu.
Website Download   
Reflector.SQL2005Browser
This add-in allows to browse .NET assemblies stored in SQL Server 2005 (Yukon) databases.
Website Download   
Reflector.DelphiLanguage
The Delphi view that is used inside .NET Reflector provided as a language add-in.
Website Download   
Reflector.McppLanguage
This add-in extends Reflector with a Managed C++ language rendering module.
Website Download   
Reflector.ChromeLanguage
This add-in extends Reflector with a Chrome language rendering module.
Website Download   
Reflector.Diff
This add-in shows differences between two versions of the same assembly.
Website Download   
Reflector.VisualStudio
This program is hosting .NET Reflector inside the Visual Studio 2003 IDE. Run Reflector.VisualStudio.exe to register the add-in with Visual Studio.
Website Download   
Reflector.ClassView
Shows class definitions as plain text with color coding. The menu item is registered under the "Tools" menu.
Website Download   
Reflector.CodeModelView
This add-in shows the underlying code model objects for a selected node in .NET Reflector. The menu item is registered under the "Tools" menu.
Website Download   
Reflector.FileGenerator
This add-in can be used to dump the disassembler output to files for any Reflector supported language.
Download   
Reflector.Graph
This add-in draws assembly dependency graphs and IL graphs.
Website Download   
Reflector.OpenRunningAssembly
Opens an assembly or dependency from a process running on the system. The menu item is registered under the "Tools" menu.
Website Download

出处：小柯Atlas

]]> http://a18zhizao.com/y2009/1158_download-reflector-decompiler-tools-integrated-two-commonly-used-net-plug-ins-filegenerator-and-filedisassembler.html/feed 0 ZMR掌门人挤房间工具[更新V1.2] http://a18zhizao.com/y2009/1056_head-of-the-crowded-room-simulation-tool.html http://a18zhizao.com/y2009/1056_head-of-the-crowded-room-simulation-tool.html#comments Fri, 30 Oct 2009 06:00:48 +0000 a18ccms http://www.a18zhizao.cn/?p=1056 100的情况也可以正常使用 增加网友 无 关于间隔时间的事情，现在调整成15S。不知道行不行。欢迎大家反馈。 V1.1 挤房间工具 版本历史: V1.2 本来1.1里面关于PING大于100这个问题我一直知道。不过我一直没有去理会。我觉得大于100，也就不适合再玩DOTA了。卡队友也卡自己。不过今天黄同学给我发邮件咨询我这个问题。我回复他上面的理由，他也把他的实际情况和我说了一下（具体学校用X代表） 我是X工的，而他的教育网服务器不知在武汉还是哪里，当时显示的ping是100+，而我在游戏里面由于都是X工的网络，所以各自的ping都在10ms左右，所以看服务器的ping是不准确的。 所以新版本就这样诞生了。也解决我发现的偶尔会清除不掉广告的毛病。呵呵 V1.1 12.20 [...]]]> 具体功能标题就明白了，说下使用方法吧：
（1）打开程序和掌门人
（2）用鼠标指向要挤的房间
（3）按F11
（4）忙其他的事情去吧。

（*）如有出错情况：按Ctrl+F11 终止程序运行后点击右下角图标选退出 重新再运行程序

请注意。这个是微软DotNet程序。需要下载微软DotNet支持
Microsoft .NET Framework 2.0 SP1 点击这里下载
Microsoft .NET Framework 3.0.4506.30 点击这里下载
Microsoft .NET Framework 3.5 SP1 多语言版 点击这里下载
以上任选一个下载都可以使用，不过版本越高，下载包越大，不过支持的功能越多。以后越不用下载新的。

版本更新：

2010/03/04 V1.2 (寻找BUG 欢迎反馈)
下载地址 点击这里
2009/12/21 V1.1 (稳定)
下载地址 点击这里

版本内容：
V1.2 修改挤房间过程中的清理过程，保证PING>100的情况也可以正常使用
增加网友 无 关于间隔时间的事情，现在调整成15S。不知道行不行。欢迎大家反馈。
V1.1 挤房间工具

版本历史:
V1.2

本来1.1里面关于PING大于100这个问题我一直知道。不过我一直没有去理会。我觉得大于100，也就不适合再玩DOTA了。卡队友也卡自己。不过今天黄同学给我发邮件咨询我这个问题。我回复他上面的理由，他也把他的实际情况和我说了一下（具体学校用X代表）

我是X工的，而他的教育网服务器不知在武汉还是哪里，当时显示的ping是100+，而我在游戏里面由于都是X工的网络，所以各自的ping都在10ms左右，所以看服务器的ping是不准确的。

所以新版本就这样诞生了。也解决我发现的偶尔会清除不掉广告的毛病。呵呵

V1.1

12.20 ZMR今天改版了。貌似不能用了。周一上班去写新的。呵呵~~~~
12.21 中午没啥事情，想把工具更新下，一更新发现不是我工具的毛病。查看了下新版的掌门人的主程序，原来我的程序很不幸，被掌门人列为黑名单了。。
http://farm3.static.flickr.com/2629/4202875804_ba02050d98.jpg (Flickr被封，我的截图也没法看了，能访问的自己看地址吧。)
yopoo
狂汗，就我这个一天才100流量的小站，它咋发现我的。而且我觉得都没啥必要，用这个的全国估计都不超过10人。。。

V0.0

最近想写个东西回忆回忆C#，正好我看VS，HF都有挤房间工具 就掌门人没有。思索着就自己写了一个。呵呵

]]> http://a18zhizao.com/y2009/1056_head-of-the-crowded-room-simulation-tool.html/feed 41