分类： C Sharp

起因：要上线一个内部的小系统，于是就动手实现，不过以前属于纯玩票，现在毕竟要实际用的东西，认证就要做了，后期要把认证绑到公司域的AD上，但是现在没有权限的情况下，内部测试只能用本地的认证系统了。

开始在完全搞不懂MVC这部分的情况下，想得蛮简单，小范围测试只需要几个人，手动创建完帐号字典，连数据库都不用，直接明文一验证就完了。结果发现框架里已经提供了比较完事的认证系统，就直接用吧，但是不会用……

经过一些时间的搜索，先记录一下。

首先依赖数据库，会使用LocalDB在App_data目录下生成一个mdf的LocalDB文件，一共5张表，用户的，用户组的，映射关系什么的，开始可以先不管。

在创建完框架直接调试，可以进入注册页面，先注册一个帐号，会要求用邮箱，密码也有复杂性要求，这部分如果要修改可以在App_Start\IdentityConfig.cs文件里修改PasswordValidator。

创建完，会发现本地数据库的表AspNetUsers里会多一个用户。当然密码不会用明文存……

然后我的需求1是帐号密码可以由我一个人创建，2是其他人可以登陆，但是不能创建新帐户。

尝试1：直接修改数据库，添加条目，发现AspNetUsers表里的ID是hash值，手动创建其实修改成数字应该也可以，不过显得不专业，放弃。

尝试2：注册、注销，循环注册多个帐户，太傻，放弃。

尝试3：登陆完注册导航按钮消失，直接输入url可以不？可以……这个办法已经可以了，偷懒的话可以把注册代码的注册成功后登陆注销，弄完帐户后再恢复。就下面这行

 await SignInManager.SignInAsync(user, isPersistent:false, rememberBrowser:false);

需求1解决，需求2搜了点文章，解决这个问题的同时让我对MVC三个层次的工作方式又理解了一些。

解决办法：

1. 让注册页必须由一定权限的人登陆，无权限的人会提示登陆，登陆完再验证权限。在AccountController.cs的Register部分注销匿名，添加Roles控制，即只允许Admins用户访问这个页面。

2.         //
           // POST: /Account/Register
           [HttpPost]
           //[AllowAnonymous]
           [Authorize(Roles = "Admins")]
           [ValidateAntiForgeryToken]
           public async Task<ActionResult> Register(RegisterViewModel model)

   这时候如果调试，会发现所有人都无法访问这个界面，会提示你登陆，然后就看不到了。查了下Account下的几个代码，好像没有集成用户组管理的页面和代码。于是在数据库里手动添加。
   在数据库的AspNetRoles表里添加ID为1，Name为Admins的条目，以及ID为2，Name为Users的条目。
   在数据库的AspNetUserRoles表里，将刚注册的用户的ID（Hash值）添加到这里的UserID，RoleID为1，就可以设定这个用户的Roles为Admin了。添加的其他用户可以手动分配为2（Users），或者像我一样没需求的，可以不分配。

通过这个问题的搜索学习，还了解到了一些MVC的设计思路，之前自己瞎玩的时候搞得一团糟，几乎把所有的代码都放到了View层，虽然也尝试把数据结构放到了Models，但是还是耦合到一团球。

我之前理解路由（当然是错误的理解），Control层只是起到转发Action的作用，并实现一些数据处理，而且这些数据处理都是手写的，但是在研究注册页的注册按钮如何工作时，我凌乱了，半天没理解怎么弄的，找到了一个stackoverflow的高分回答，解释了一下Model和Control的Binding关系，读了两遍，再回去看代码，果然就明白了。

模型基本上只提供了一个数据结构，而且基本只是数据的值，不包含函数（方法），View在提交Post的时候，调用的是同一个路由，所以开始看的时候莫名的觉得这个页面既显示注册界面，又完成了注册功能。然后找到Controller的时候，虽然明白了Controller如何完成功能，但是又不明白这些数据结构是如何传递的。相对的，也不明白Model是如何在这里面起作用的。

这些能活下来的框架和设计，都是相对简单且实用的，理解起来其实并不是太困难，但是需要一些点拨和经验。

需求是，根据坐标系的两个轴（向量），求出另外一个轴，由于我高数下（解析几何）不及格，所以一直没有想起来对应的定义。之前自己解决的办法是，求出这两个向量构造的平面，然后平面的法向就是解。

今天在写我的GDTGeometry库时又遇到这个问题，这次先去翻了翻新买的高数下教材，发现这就是向量叉积的定义，可惜当初并没有记牢。于是想直接在MathNet库里找，结果里面只有multiply（点积）和pointwise-multiply（逐点乘积），又特意找了下翻译叉积是Cross-Multiply，我觉得像基础课的很多定义，应该加上英文注释。

搜了下mathnet cross multiply，找到了stack overflow上的一篇问答，这个函数在Iridium子库里实现，不过这个库已经太监了，而且2012年就太监了，到现在还没有整合到numerics（主库里），简直是无语，我很想说这么个简单的功能我commit一个patch吧，不过仔细想了下，问题应该出在叉积通常只用在3维空间里，低维和高维的推广好像都有点问题。

overflow上的回答里已经有了我要的代码：

    using DLA = MathNet.Numerics.LinearAlgebra.Double;

    public static DLA.Vector Cross(DLA.Vector left, DLA.Vector right)
    {
        if ((left.Count != 3 || right.Count != 3))
        {
            string message = "Vectors must have a length of 3.";
            throw new Exception(message);
        }
        DLA.Vector result = new DLA.DenseVector(3);
        result[0] = left[1] * right[2] - left[2] * right[1];
        result[1] = -left[0] * right[2] + left[2] * right[0];
        result[2] = left[0] * right[1] - left[1] * right[0];

        return result;
    }

针对三维向量。

推导在高数下教材上有，和我一样数学差的可以去查。结论是

\[c=a\times b=\begin{vmatrix}i&j&k\\a_x&a_y&a_z\\b_x&b_y&b_z\end{vmatrix}\]

所以

\[i_c=\begin{vmatrix}a_y&a_z\\b_y&b_z\end{vmatrix}\]

\[j_c=-\begin{vmatrix}a_x&a_z\\b_x&b_z\end{vmatrix}\]

\[k_c=\begin{vmatrix}a_x&a_y\\b_x&b_y\end{vmatrix}\]

开始想把这部分写成DenseVector的扩展函数，后来想想既然只能用在3维向量上，就放到自己的Vector（三维）类里了。

从开始折腾到觉得自己可以小结一下了，一共三周。

开始是找库，OPENGL还是DirectX其实并不重要，甚至还考虑过Unity，不过最终发现像我这种非主流的需求，还是老老实实的从头学（搞）比较实际。

最终选了DirectX还是因为微软的文档。

SharpDX封装的很好，学习的过程中找到的有效资料基本都是C++的，用SharpDX实现既能对应上，又让我觉得方便了很多（和C++例子比）。

代码我是在一个项目上直接改的，我的目的不是教别人，所以堆在一起，未来看的时候能回忆一下当初的理解过程。

如果其他人看到了，抱歉，这文章是我自己纪录思路的，可能不太适合当作参考。

总的来说，DirectX入门需要一些数学知识储备，向量、矩阵的定义和运算，坐标变换的原理，齐次坐标变换，仿射矩阵，向量单位化（L2Norm），有一些立体的抽象思维能力，坐标系，光源，摄像机，而且绕不开的还有C++的知识，至少要能猜懂。

学习的顺序：

一、找本靠谱的参考书，例如Introduction to 3D Game Programming with Direct3D 11.0

二、测试开发环境，创建一个Device，我在网上找到几个靠谱的Tutorial代码却全在我Win7+VS2015 Community的环境下编译不能。所以测试环境很重要啊。

三、理解PipeLine，细节理解得越清楚越好，否则后面绝对会乱，尤其是C++。

四、针对PipeLine的每一部分，去用代码熟悉一下，总的来说，Directx每一步都有如下套路：描述一下这部分的属性，分配内存（当然分配前要定义结构和空间大小），绑定。C++原始API都是把创建的结果地址当作参数传入，返回结果是出错代码，对习惯了等号右赋左值的C#程序员很不习惯，所以SharpDX封装的好！而且还尽力省略了一些很不常用的参数。

五、别着急，这种底层的API由于灵活，所以每个人的玩法都不一样，没理解的情况下要把两个例子混一块玩会死得很惨，

<Introduction to 3D Game Programming with Direct3D 11.0>第15章Camera类的C#(SharpDX)实现。

using System;
using SharpDX;

namespace SharpDX_Study_001
{
    class Camera
    {
        public Camera()
        {
            mPosition = Vector3.Zero;
            mRight = Vector3.UnitX;
            mUp = Vector3.UnitY;
            mLook = Vector3.UnitZ;
            SetLens(0.2f * SharpDX.MathUtil.Pi, 1.0f, 1.0f, 1000.0f);
        }
        public Vector4 PositionXM
        {
            get
            {
                return new Vector4(mPosition, 0);
            }
        }
        public Vector3 Position
        {
            get
            {
                return mPosition;
            }
            set
            {
                mPosition = value;
            }
        }
        public Vector4 RightXM
        {
            get
            {
                return new Vector4(mRight, 0);
            }
        }
        public Vector4 UpXM
        {
            get
            {
                return new Vector4(mUp, 0);
            }
        }
        public Vector4 LookXM
        {
            get
            {
                return new Vector4(mLook, 0);
            }
        }
        public Vector3 Right
        {
            get
            {
                return mRight;
            }
        }
        public Vector3 Look
        {
            get
            {
                return mLook;
            }
        }
        public Vector3 Up
        {
            get
            {
                return mUp;
            }
        }
        public float NearZ
        {
            get
            {
                return mNearZ;
            }
        }
        public float FarZ
        {
            get
            {
                return mFarZ;
            }
        }
        public float Aspect
        {
            get
            {
                return mAspect;
            }
        }
        public float FovY
        {
            get
            {
                return mFovY;
            }
        }
        public float FovX
        {
            get
            {
                float halfWidth = 0.5f * NearWindowWidth;
                return 2.0f * Convert.ToSingle(Math.Atan(halfWidth / mNearZ));
            }
        }
        public float NearWindowWidth
        {
            get
            {
                return mAspect * mNearWindowHeight;
            }
        }
        public float NearWindowHeight
        {
            get
            {
                return mNearWindowHeight;
            }
        }
        public float FarWindowWidth
        {
            get
            {
                return mAspect * mFarWindowHeight;
            }
        }
        public float FarWindowHeight
        {
            get
            {
                return mFarWindowHeight;
            }
        }

        /// <summary>
        /// Set frustum.
        /// </summary>
        /// <param name="fovY"></param>
        /// <param name="aspect"></param>
        /// <param name="zn"></param>
        /// <param name="zf"></param>
        public void SetLens(float fovY, float aspect, float zn, float zf)
        {
            // cache properties
            mFovY = fovY;
            mAspect = aspect;
            mNearZ = zn;
            mFarZ = zf;

            mNearWindowHeight = 2.0f * mNearZ * Convert.ToSingle(Math.Tan(0.5f * mFovY));
            mFarWindowHeight = 2.0f * mFarZ * Convert.ToSingle(Math.Tan(0.5f * mFovY));

            mProj = Matrix.PerspectiveFovLH(mFovY, mAspect, mNearZ, mFarZ);
        }

        //       // Define camera space via LookAt parameters.
        public void LookAt(Vector4 pos, Vector4 target, Vector4 worldUp)
        {
            Vector3 L = new Vector3(pos.X, pos.Y, pos.Z);
            Vector3 T = new Vector3(target.X, target.Y, target.Z);
            Vector3 U = new Vector3(worldUp.X, worldUp.Y, worldUp.Z);
            LookAt(L, T, U);
        }
        public void LookAt(Vector3 pos, Vector3 target, Vector3 up)
        {
            mPosition = pos;
            mLook = Vector3.Normalize(target - pos);
            mRight = Vector3.Normalize(Vector3.Cross(up, mLook));
            mUp = Vector3.Cross(mLook, mRight);
        }
        public Matrix View
        {
            get
            {
                return mView;
            }
        }
        public Matrix Proj
        {
            get
            {
                return mProj;
            }
        }
        public Matrix ViewProj
        {
            get
            {
                return View * Proj;
            }
        }
        // Strafe/Walk the camera a distance d.
        public void Strafe(float d)
        {
            // mPosition += d*mRight
            Vector4 s = new Vector4(d);

            var nPos = (s * RightXM + PositionXM);
            mPosition = new Vector3(nPos.X, nPos.Y, nPos.Z);
        }
        public void Walk(float d)
        {
            // mPosition += d*mLook
            Vector4 s = new Vector4(d);
            var nPos = (s * LookXM + PositionXM);
            mPosition = new Vector3(nPos.X, nPos.Y, nPos.Z);
        }

        // Rotate the camera.
        public void Pitch(float angle)
        {
            // Rotate up and look vector about the right vector.

            Matrix R = Matrix.RotationAxis(mRight, angle);
            mUp = Vector3.TransformNormal(mUp, R);
            mLook = Vector3.TransformNormal(mLook, R);
        }
        public void RotateY(float angle)
        {
            // Rotate the basis vectors about the world y-axis.

            Matrix R = Matrix.RotationY(angle);
            mRight = Vector3.TransformNormal(mRight, R);
            mUp = Vector3.TransformNormal(mUp, R);
            mLook = Vector3.TransformNormal(mLook, R);
        }

        // After modifying camera position/orientation, call to rebuild the view matrix.
        public void UpdateViewMatrix()
        {
            var R = mRight;
            var U = mUp;
            var L = mLook;
            var P = mPosition;

            // Keep camera's axes orthogonal to each other and of unit length.
            L = Vector3.Normalize(L);
            U = Vector3.Normalize(Vector3.Cross(mLook, mRight));

            // U, L already ortho-normal, so no need to normalize cross product.
            R = Vector3.Cross(U, L);

            // Fill in the view matrix entries.
            float x = -Vector3.Dot(P, R);
            float y = -Vector3.Dot(P, U);
            float z = -Vector3.Dot(P, L);

            mRight = R;
            mUp = U;
            mLook = L;

            mView.Column1 = new Vector4(mRight, x);
            mView.Column2 = new Vector4(mUp, y);
            mView.Column3 = new Vector4(mLook, z);
            mView.Column4 = Vector4.UnitW;
        }


        private Vector3 mPosition;

        private Vector3 mRight;

        private Vector3 mUp;

        private Vector3 mLook;


        // Cache frustum properties.
        float mNearZ;
        float mFarZ;
        float mAspect;
        float mFovY;
        float mNearWindowHeight;
        float mFarWindowHeight;

        Matrix mView;
        Matrix mProj;

    }
}

想要了解一个开源项目，可以直接读代码，想了解别的，就得反编译了。

其实.NET的反编译算是方便的，毕竟是IL中间语言而不是机器码或者汇编，不过当我需要这个功能并开始找的时候发现选择并不多，其实就两个：Reflector和ILSpy。

Reflector更有名，不过2011年开始转向了收费，ILSpy则是?Development started after Red Gate?announced?that the free version of .NET Reflector would cease to exist by end of February 2011.

但是2012年开始ILSpy也停止了更新，按理说一个开源软件停止更新基本两个原因：1.社区人跑光了；2.一些法律或者其他公司的干预。ILSpy和SharpDevelop是一个社区，一直非常活跃，所以开始我觉得是M$又动手脚了。

实际情况是ILSpy的项目整合到了SharpDevelop里面，不过没有任何明确的公告，我想原因可能是遭到了M$的压力或者核心成员有争论。

ILSpy1.0开始就支持直接反编译DLL然后直接attach调试，设断点什么的，但是2.0开始变成了插件需要自己编译（二进制包里这个被删了，源码包里有）。2.1的时候连源码里也没有了而且最新的一个发布里面有冲突。ILSpy的Debug功能消失几乎是和ILSpy停止开发同时，再同时，SharpDevelop出了类似的功能，可以在调试的同时反编译第三方库。

本质上这其实是一个功能，但是实际上ILSpy原来的用法更方便，因为不需要构造Solution敲任何代码，直接可以用。

我想原因可能是：

1.过于简单的反编译操作使得门槛降低，可能受到了一些压力。

2.开发这个项目的社区目的是方便开发人员调试自己的程序，而不是去剽窃他人的劳动，所以人为地加了一些限制。

不管怎么样，现在的确不方便了，虽然可以用2.0版，不过2.0不支持64位的环境= =。

包含之前几篇文章提到的算法的C#实现。

界面很简单，点按钮选择数据文件，一行一个点的xyz坐标。选择类型，然后计算。

可执行文件同目录下有两个测试用数据文件。

二进制包下载LSQ_Feature_binary

源码及二进制包下载（VS2012 Express）