控制器介绍

新建立MVC3项目，名为12-1ControllersAndActions，使用空模板。

Global.asax中默认的路由定义为：

        public static void RegisterRoutes(RouteCollection routes)
        {
            routes.IgnoreRoute("{resource}.axd/{*pathInfo}");

            routes.MapRoute(
                "Default", // Route name
                "{controller}/{action}/{id}", // URL with parameters
                new { controller = "Home", action = "Index", id = UrlParameter.Optional } // Parameter defaults
            );

        }

一、两种方法实现自己的控制器

1、用IController创建控制器

在MVC框架中，控制器类必须实现System.Web.Mvc命名空间的IController接口。

System.Web.Mvc.IController接口如下所示：

public interface IController
{
    void Execute(RequestContext requestContext);
}

接口只有一个方法Execute，在请求目标控制器时将被调用。

通过实现IController，就可以创建控制器类，但这是一个相当低级的接口，要做大量工作才能让自己创建的控制器有效，下面只是一个简单的演示。

鼠标右击项目中的Controllers文件夹，选择 Add -> Class，创建新类，取名为BasicController，代码如下：

namespace _12_1ControllersAndActions.Controllers
{
    public class BasicController:IController
    {
        public void Execute(RequestContext requestContext)
        {
            string controller = (string)requestContext.RouteData.Values["controller"];
            string action = (string)requestContext.RouteData.Values["action"];
            requestContext.HttpContext.Response.Write(
                string.Format("Controller:{0}, Action:{1}", controller, action));
        }
    }
}

 如果运行程序，导航到"~/Basic/Index"，根据路由定义，也可以导航到"~/Basic"，产生的结果为：

Controller:Basic，Action:Index

2、一般的做法是创建派生于Controller类的控制器

鼠标右击项目中的Controllers文件夹，选择 Add -> Controller，新建控制器，命名为DerivedController，代码如下：

namespace _12_1ControllersAndActions.Controllers
{
    public class DerivedController : Controller
    {
        //
        // GET: /Derived/

        public ActionResult Index()
        {
            ViewBag.Message = "Hello from the DerivedController Index method.";
            return View("MyView");
        }

    }
}

在方法Index上鼠标右键，添加视图，视图取名为MyView

/Views/Derived/MyView.cshtml

@{
    ViewBag.Title = "MyView";
}

<h2>MyView</h2>
<h1>Message: @ViewBag.Message</h1>

 运行程序，导航到"~/Derived/Index"，或者根据路由定义，也可以导航到"~/Derived"，产生的结果为：

MyView

Message:Hello from the DerivedController Index method.

二、控制器接收输入

控制器常常需要访问输入数据，也就是在请求控制器的动作方法时传递进来的输入数据，如查询字符串值（指url尾部带问号?后面跟的部分，称为url的查询字符串）、表单值、以及路由系统根据输入url解析所得到的参数。

访问这些数据有三种方式：

通过上下文对象（Context Objects）获取数据。

通过参数传递给动作方法。

使用模型绑定（Model Binding）。

这里主要讨论前两种，模型绑定在后面讨论。

1、通过上下文对象获取数据

访问上下文对象，通过使用一组便利属性（Convenience Property）来进行访问。所谓上下文对象，实际上就是访问的与请求相关的信息。

如果要使用便利属性来访问与请求相关的信息，要注意一点，就是只能在派生于Controller的自定义控制器中才能使用。即，如果是通过实现IController接口来完成的自定义控制器里面不能使用这些便利属性。这些便利属性包括Request、Response、RouteData、HttpContext、Server等，每个属性都包含了请求不同方面的信息。见p305，表12-1。

（1）下面通过一个例子来表现这种通过上下文对象获取数据的方式。

在12-1ControllersAndActions项目中，HomeController控制器定义如下：

namespace _12_1ControllersAndActions.Controllers
{
    public class HomeController : Controller
    {
        public ActionResult Index()
        {
            //访问上下文对象的各个属性
            string userName = User.Identity.Name;
            string serverName = Server.MachineName;
            string clientIP = Request.UserHostAddress;
            DateTime dateStamp = HttpContext.Timestamp;
            ViewBag.userName = userName;
            ViewBag.serverName = serverName;
            ViewBag.clientIP = clientIP;
            ViewBag.dateStamp = dateStamp;
            //接收Request.Form所递交的数据
            //string oldProductName = Request.Form["OldName"];
            //string newProductName = Request.Form["NewName"];
            return View();
        }

    }
}

/Views/Home/Index.cshtml内容如下：

@{
    ViewBag.Title = "Index";
}

<h2>Index</h2>
<h2>userName=@ViewBag.userName</h2>
<h2>serverName=@ViewBag.serverName</h2>
<h2>clientIP=@ViewBag.clientIP</h2>
<h2>dataStamp=@ViewBag.dateStamp</h2>

这里可以注意，如果希望显示出一些上下文数据，而又不想有对应的cshtml文件，那么可以用response.write，例如：

namespace _12_1ControllersAndActions.Controllers
{
    public class HomeController : Controller
    {
        public ActionResult Index()
        {
            //访问上下文对象的各个属性
            string userName = User.Identity.Name;
            string serverName = Server.MachineName;
            string clientIP = Request.UserHostAddress;
            DateTime dateStamp = HttpContext.Timestamp;
            ViewBag.userName = userName;
            ViewBag.serverName = serverName;
            ViewBag.clientIP = clientIP;
            ViewBag.dateStamp = dateStamp;
            //接收Request.Form所递交的数据
            //string oldProductName = Request.Form["OldName"];
            //string newProductName = Request.Form["NewName"];
            return View();
        }

        public void Index2()
        {
            //访问上下文对象的各个属性
            string userName = User.Identity.Name;
            string serverName = Server.MachineName;
            string clientIP = Request.UserHostAddress;
            DateTime dateStamp = HttpContext.Timestamp;
            Response.Write(string.Format("userName:{0}<br>serverName:{1}<br>clientIP:{2}<br>dataStamp:{3}", 
                userName, serverName, clientIP, dateStamp));
        }

    }
}

这里的Index2就没有对应的cshtml文件对应。程序运行后，输入地址："~/Home/Index2"就可以查看到用Response.Write写出的内容。

 上下文对象常用的有Request.QueryString、Request.Form和RouteData.Values

（2）通过上下文对象访问RouteData.Values的例子

上面例子中的项目12-1ControllersAndActions，在HomeController控制器中添加了一个TestInput动作方法，如下：

namespace _12_1ControllersAndActions.Controllers
{
    public class HomeController : Controller
    {
        public ActionResult Index()
        {
            //访问上下文对象的各个属性
            string userName = User.Identity.Name;
            string serverName = Server.MachineName;
            string clientIP = Request.UserHostAddress;
            DateTime dateStamp = HttpContext.Timestamp;
            ViewBag.userName = userName;
            ViewBag.serverName = serverName;
            ViewBag.clientIP = clientIP;
            ViewBag.dateStamp = dateStamp;
            //接收Request.Form所递交的数据
            //string oldProductName = Request.Form["OldName"];
            //string newProductName = Request.Form["NewName"];
            return View();
        }

        public void Index2()
        {
            //访问上下文对象的各个属性
            string userName = User.Identity.Name;
            string serverName = Server.MachineName;
            string clientIP = Request.UserHostAddress;
            DateTime dateStamp = HttpContext.Timestamp;
            Response.Write(string.Format("userName:{0}<br>serverName:{1}<br>clientIP:{2}<br>dataStamp:{3}", 
                userName, serverName, clientIP, dateStamp));
        }

        public void TestInput()
        {
            string inputController = (string)RouteData.Values["controller"];
            string inputAction = (string)RouteData.Values["action"];
            int inputId = Convert.ToInt32(RouteData.Values["id"]);
            Response.Write(string.Format("inputController={0}<br>inputAction={1}<br>inputId={2}",
                inputController, inputAction, inputId));
        }

    }
}

在TestInput动作方法中，通过RouteData.Values["controller"]读取到当前请求的控制器名字，通过RouteData.Values["action"]读取到当前请求的动作方法的名字，通过RouteData.Values["id"]访问到当前请求中的URL里对应到路由中的自定义变量id的值读取出来。那么这里RouteData.Values中的controller、action、id属性来自于哪里，RouteData.Values中还有哪些属性可用，就取决于在Global.asax中的路由定义。

先看一下为当前这个例子设计的路由定义：

public static void RegisterRoutes(RouteCollection routes)
        {
            routes.IgnoreRoute("{resource}.axd/{*pathInfo}");

            //这是本身的默认路由，现在需要如果有id要限定它只能是数字，用正则表达式
            //routes.MapRoute(
            //    "Default", // Route name
            //    "{controller}/{action}/{id}", // URL with parameters
            //    new { controller = "Home", action = "Index", id = UrlParameter.Optional } // Parameter defaults
            //);

            routes.MapRoute(
                "Default", // Route name
                "{controller}/{action}", // URL with parameters
                new { controller = "Home", action = "Index" } // Parameter defaults
            );

            routes.MapRoute(
                "Default2", // Route name
                "{controller}/{action}/{id}", // URL with parameters
                new { controller = "Home", action = "Index" }, // Parameter defaults
                new { id=@"d+"}
            );
        }

现在这个例子，希望路由在原来的默认路由的基础上增加一个约束，就是如果url中输入了id，那么希望将id的值约束在数字上，如果id输入的是非数字的值，比如字母之类就不能匹配路由。

用正则表达式加约束条件，生成匿名对象new { id=@"d+" }，但是这个约束不能直接加在原来的默认路由上，原来的默认路由为：

            routes.MapRoute(
                "Default", // Route name
                "{controller}/{action}/{id}", // URL with parameters
                new { controller = "Home", action = "Index", id = UrlParameter.Optional } // Parameter defaults
            );

在这个默认路由中，定义了url模式里的变量有3个，分别是controller、action和id，并用new设置了这三个变量的默认参数值，其中id设置的是UrlParameter.Optional，设置为这个值，表示在匹配url时，id可以有也可以没有，如果没有id，那么就没有id这个变量。如果希望有id的时候把它的值限定在数字上，不能直接在参数默认值的后面添加约束，比如：

            routes.MapRoute(
                "Default", // Route name
                "{controller}/{action}/{id}", // URL with parameters
                new { controller = "Home", action = "Index", id = UrlParameter.Optional }, // Parameter defaults
                new { id=@"d+"}
            );

加上这个约束，就表示id必须要有值，而且要是数字，否则就不匹配。这样一来，下面的url都不能再匹配了：

"~/"

"~/Home/Index"

"~/Home/TestInput"

也就是说id=UrlParameter.Optional就失去了意义。

解决方法就是把路由定义成两个：

        routes.MapRoute(
                "Default", // Route name
                "{controller}/{action}", // URL with parameters
                new { controller = "Home", action = "Index" } // Parameter defaults
            );

            routes.MapRoute(
                "Default2", // Route name
                "{controller}/{action}/{id}", // URL with parameters
                new { controller = "Home", action = "Index" }, // Parameter defaults
                new { id=@"d+"}
            );

按照顺序依次匹配，没有写id的匹配第一个路由定义，写了id的匹配第二个路由定义。

那么没有写id的时候，匹配第一个路由定义，就是{controller}/{action}，就只有controller和action两个变量，这个时候在动作方法中访问RouteData.Values["id"]得到的结果就为null，但是这里的类型转换用的是Convert.ToInt32()，当括号内的对象为null时，得到的结果就为0。如果用的是int.Parse()遇到这种情况就会抛出异常。

int inputId = Convert.ToInt32(RouteData.Values["id"]);

当然，如果取到id的值，如果只想要字符类型，那就不用这么复杂， 可以直接用

string inputId = (string)RouteData.Values["id"];

对于本例，如果在url中输入的是"~/Home/TestInput/325"，那么显示的结果为：

inputController=Home
inputAction=TestInput
inputId=325

（3）通过上下文对象访问Request.QueryString的例子

Request.QueryString查询字符串就是跟在url后面带问号之后的内容。例如：

http://localhost:1943/Home/TestInput2?var1=abc&var2=123

问号后面的var1=abc&var2=123就是QueryString。

例，假设跟上一个例题同样的路由定义：

public static void RegisterRoutes(RouteCollection routes)
        {
            routes.IgnoreRoute("{resource}.axd/{*pathInfo}");

            //这是本身的默认路由，现在需要如果有id要限定它只能是数字，用正则表达式
            //routes.MapRoute(
            //    "Default", // Route name
            //    "{controller}/{action}/{id}", // URL with parameters
            //    new { controller = "Home", action = "Index", id = UrlParameter.Optional } // Parameter defaults
            //);

            routes.MapRoute(
                "Default", // Route name
                "{controller}/{action}", // URL with parameters
                new { controller = "Home", action = "Index" } // Parameter defaults
            );

            routes.MapRoute(
                "Default2", // Route name
                "{controller}/{action}/{id}", // URL with parameters
                new { controller = "Home", action = "Index" }, // Parameter defaults
                new { id=@"d+"}
            );
        }

在HomeController中新增了名为TestInput2的动作方法：

        public void TestInput2()
        {
            string inputController = (string)RouteData.Values["controller"];
            string inputAction = (string)RouteData.Values["action"];
            int inputId = Convert.ToInt32(RouteData.Values["id"]);
            string queryVar1 = Request.QueryString["var1"];
            string queryVar2 = Request.QueryString["var2"];
            Response.Write(string.Format("inputController={0}<br>inputAction={1}<br>" + 
                "inputId={2}<br>queryVar1={3}<br>queryVar2={4}",
                inputController, inputAction, inputId, queryVar1, queryVar2));
        }

这里用了两句话

string queryVar1 = Request.QueryString["var1"];
string queryVar2 = Request.QueryString["var2"];

来读取查询字符串中变量的值。

如果输入的url是"~/Home/TestInput2?var1=abc&var2=123"则显示的结果为：

inputController=Home
inputAction=TestInput2
inputId=0
queryVar1=abc
queryVar2=123

这个输入的url，没有匹配id，所以RouteData.Values["id"]为空，经过Convert.ToInt32()转换后值为0。QueryString里如果有多个变量，之间用符号&间隔。

扩充下这个例题，现在假设在/Views/Home/Index.cshtml，也就是HomeController中Index产生的视图上添加：

@Html.ActionLink("Navigate", "TestInput2", new { id="123" })

这时，如果路由定义为：

            routes.MapRoute(
                "Default", // Route name
                "{controller}/{action}/{id}", // URL with parameters
                new { controller = "Home", action = "Index", id = UrlParameter.Optional } // Parameter defaults
            );

那么ActionLink产生的html为：

<a href="/Home/TestInput2/123">Navigate</a>

点击该超链接后显示的结果为：

inputController=Home
inputAction=TestInput2
inputId=123
queryVar1=
queryVar2=

但是，如果路由定义为：

            routes.MapRoute(
                "Default", // Route name
                "{controller}/{action}", // URL with parameters
                new { controller = "Home", action = "Index" } // Parameter defaults
            );

            routes.MapRoute(
                "Default2", // Route name
                "{controller}/{action}/{id}", // URL with parameters
                new { controller = "Home", action = "Index" }, // Parameter defaults
                new { id = @"d+" }
            );

那么@Html.ActionLink("Navigate", "TestInput2", new { id="123" })产生的html为：

<a href="/Home/TestInput2?id=123">Navigate</a>

这是因为按定义顺序，会首先去匹配第一个路由定义，那么反推回url。第一个路由定义中没有id，那就认为new { id="123" }产生的就是查询字符串。点击这个超链接后，产生的显示结果为：

inputController=Home
inputAction=TestInput2
inputId=0
queryVar1=
queryVar2=

这样一来，如果是第二种路由定义，既想生成的url中产生id，又有查询字符串，那就需要使用：

@Html.ActionLink("Navigate", "TestInput2/123", new { var1="ABC", var2="325" })

产生的html为：

<a href="/Home/TestInput2/123?var1=ABC&amp;var2=325">Navigate</a>

注意html中的&amp;就是&，最后产生的url就是"~/Home/TestInput2/123?var1=ABC&var2=325"

点击该超链接后，产生的显示结果为：

inputController=Home
inputAction=TestInput2
inputId=123
queryVar1=ABC
queryVar2=325

（4）通过上下文对象访问Request.Form中数据的例子

利用Request.Form可以读取提交过来的表单中的数据，通过Name的属性值来进行识别访问。下面构造一个例子来说明用Request.Form来读取表单数据的情况。

假设使用的路由定义为：

public static void RegisterRoutes(RouteCollection routes)
        {
            routes.IgnoreRoute("{resource}.axd/{*pathInfo}");
            routes.MapRoute(
                "Default", // Route name
                "{controller}/{action}", // URL with parameters
                new { controller = "Home", action = "Index" } // Parameter defaults
            );

            routes.MapRoute(
                "Default2", // Route name
                "{controller}/{action}/{id}", // URL with parameters
                new { controller = "Home", action = "Index" }, // Parameter defaults
                new { id = @"d+" }
            );
        }

在HomeController中添加了TestInput3()动作方法的两个重载版本：

        [HttpGet]
        public ViewResult TestInput3()
        {
            return View();
        }

        [HttpPost]
        public ViewResult TestInput3(string dummy)
        {
            string inputController = (string)RouteData.Values["controller"];
            string inputAction = (string)RouteData.Values["action"];
            int inputId = Convert.ToInt32(RouteData.Values["id"]);
            string city = Request.Form["City"];
            DateTime forDate = DateTime.Parse(Request.Form["forDate"]);
            ViewBag.inputController = inputController;
            ViewBag.inputAction = inputAction;
            ViewBag.inputId = inputId;
            ViewBag.city = city;
            ViewBag.forDate = forDate;
            return View("TI3Result");
        }

这里用了两个注解属性[HttpGet]和[HttpPost]来指定一个TestInput3用于Get请求，另一个TestInput3动作方法用于Post请求。在本例中，希望在Post请求的TestInput3动作方法中利用上下文对象Request.Form来访问表单数据，本部需要指定参数。但是同名的两个动作方法TestInput3看来是通过重载来实现的，如果名字相同，返回类型相同，参数又完全一致的话，程序就不能通过编译。所以，为了演示这个例子，就在Post请求的动作方法TestInput3上加了一个哑元参数dummy，目的就是为了完成同名的TestInput3函数的重载。

接下来，在由Get请求TestInput3时，返回的视图是默认视图/Views/Home/TestInput3.cshtml，在里面构造了表单：

@{
    ViewBag.Title = "TestInput3";
}

<h2>TestInput3</h2>
@using (Html.BeginForm())
{
    <p>city:<input type="text" name="City" /></p>
    <p>forDate:<input type="text" name="forDate" /></p>
    <input type="submit" value="提交" />   
}

表单由

@using (Html.BeginForm())

{

    ...

}

指定。里面有是三个元素，第一个是文本框，name为City，第二个也是文本框，name属性为forDate。Request.Form就依赖这些元素的name来识别和访问指定的元素值。第三个元素是按钮，类型为submit，按钮显示的文字为“提交”。点击该按钮后，默认将表单Post到与产生当前视图同名的动作方法上，本例子中，产生这个视图的动作方法是TestInput3，那么Post回去的时候，也就是传递给同名的TestInput3动作方法。

在响应Post的TestInput3动作方法通过：

string city = Request.Form["City"];
DateTime forDate = DateTime.Parse(Request.Form["forDate"]);

读取到表单中元素的值后，再利用ViewBag传递给显示结果的视图，该动作方法返回时指定了视图名return View("TI3Result").

那么，就在/Views/Home/TI3Result.cshtml中产生输出显示的结果。添加视图文件/Views/Home/TI3Result.cshtml如下：

@{
    ViewBag.Title = "TI3Result";
}

<h2>TI3Result</h2>
<p>inputController=@ViewBag.inputController</p>
<p>inputAction=@ViewBag.inputAction</p>
<p>inpuId=@ViewBag.inputId</p>
<p>city=@ViewBag.city</p>
<p>forDate=@ViewBag.forDate</p>

执行程序后，在url上输入"~/Home/TestInput3，显示为：

 在文本框中输入数据如下：

点击提交按钮后，显示结果为：

2、为动作方法设定参数传递数据

上下文对象常用的Request.QueryString、Request.Form和RouteData.Values等数据也可以通过动作方法的参数来设定。这里有个约定，就是参数名跟要访问的属性名或元素名同名，系统是根据名字自动去匹配。

（1）先看一个常规的例子，假设路由定义为：

        public static void RegisterRoutes(RouteCollection routes)
        {
            routes.IgnoreRoute("{resource}.axd/{*pathInfo}");
            routes.MapRoute(
                "Default", // Route name
                "{controller}/{action}/{id}", // URL with parameters
                new { controller = "Home", action = "Index", id = UrlParameter.Optional } // Parameter defaults
            );
        }

在HomeController中新加了名为TestInput4()的动作方法：

        public void TestInput4(int id)
        {
            Response.Write(string.Format("id={0}", id));
        }

在动作方法TestInput()上设定了参数，整型的名为id的参数。动作方法的参数会用名字自动去匹配Request.QueryString、Request.Form和RouteData.Values中的属性和元素的值，依赖的就是名字。

接下来，在/Views/Home/Index.cshtml中添加ActionLink来生成超链接，指向HomeController中的TestInput4()动作方法。添加的代码为：

@Html.ActionLink("NavTestInput4", "TestInput4", new{ id=325 })

请注意ActionLink是怎么根据路由定义来生成html的。

第一个参数"NavTestInput4"是超链接文本，第二个参数是要访问的动作方法名字。没有给出控制器名字，则默认为产生当前视图页面的控制器，在本例子中就是Home控制器。第三个参数用new生成匿名对象，其中有id=325，根据路由定义，id匹配路由模式中的id变量。倒退回url，生成的超链接为：

<a href="/Home/TestInput4/325">NavTestInput4</a>

点击该超链接后，根据路由定义，匹配路由模式"{controller}/{action}/{id}"，访问到Home控制器中的TestInput4动作方法，动作方法的参数id匹配路由模式中的{id}，也就是RouteData.Values["id"]就通过匹配的动作方法参数id被传递到了动作方法中。而且可以看到，类型也自动匹配，参数中的int id，不需要做任何类型那个转换。显示结果为：

id=325

（2）跟上一个例题一样的路由定义，现在将HomeController中的TestInput4修改为：

        public void TestInput4(int id, string var1)
        {
            Response.Write(string.Format("id={0}<br>var1={1}", id, var1));
        }

也就是说TestInput4的参数可以去匹配Request.QueryString、Request.Form和RouteData.Values等数据中的id和var1的值。将/Views/Home/Index.cshtml中ActionLink修改为：

@Html.ActionLink("NavTestInput4", "TestInput4", new{ id=325, var1="ABC" })

根据路由定义，在ActionLink中的第三个参数new{ id=325, var1="ABC" }，id匹配路由模式"{controller}/{action}/{id}"中的{id}，而var1在路由模式中没有变量叫这个名字，那就以问号?跟在url的最后面作为QueryString。本例子中的ActionLink产生的html为：

<a href="/Home/TestInput4/325?var1=ABC">NavTestInput4</a>

点击该超链接后，访问到Home控制器中的TestInput4动作方法。TestInput4动作方法中的参数id，接收RouteData.Values["id"]的值，参数var1接收Request.QueryString["var1"]的值。显示的结果为：

id=325
var1=ABC

（3）注意路由变化，如果将路由定义改为：

        public static void RegisterRoutes(RouteCollection routes)
        {
            routes.IgnoreRoute("{resource}.axd/{*pathInfo}");
            routes.MapRoute(
                "Default", // Route name
                "{controller}/{action}", // URL with parameters
                new { controller = "Home", action = "Index" } // Parameter defaults
            );

            routes.MapRoute(
                "Default2", // Route name
                "{controller}/{action}/{id}", // URL with parameters
                new { controller = "Home", action = "Index" }, // Parameter defaults
                new { id = @"d+" }
            );
        }

假设HomeController中的动作方法TestInput4()与第（1）个例子中一样：

        public void TestInput4(int id)
        {
            Response.Write(string.Format("id={0}", id));
        }

在/Views/Home/Index.cshtml中的ActionLink也与第（1）个例子一样，代码为：

@Html.ActionLink("NavTestInput4", "TestInput4", new{ id=325 })

注意，由于路由的不同，这个例子中ActionLink生成html就与第（1）个例子不一样了。根据本例子中的路由定义，按照顺序，匹配第一个路由。在第一个路由中，路由的url模式为"{controller}/{action}"，路由模式中没有id变量。那么ActionLink的第三个参数new{ id=325 }中的id就没有路由模式中的变量与其对应，就只能跟在问号后面，放在url的最后作为QueryString。所以，本例中生成的html为：

<a href="/Home/TestInput4?id=325">NavTestInput4</a>

需要注意的是，虽然产生的url不一样，但是在访问Home控制器里的TestInput4动作方法时，仍然可以让TestInput4的参数id正确读取到url中的id的值。这就是与前面直接通过上下文对象RouteData.Values["id"]，或Request.QueryString["id"]来访问id值不一样的地方。动作方法TestInput4中的参数id，会自动去匹配Request.QueryString、Request.Form和RouteData.Values中与参数同名的数据。所以本例子中TestInput4的参数id，接收的是Request.QueryString["id"]的值，显示的结果为：

id=325

RouteData.Values和Request.QueryString中如果都有与动作方法的参数相同的变量，优先匹配的是RouteData.Values。例如，假设在Index.cshtml中的ActionLink代码为：

@Html.ActionLink("NavTestInput4", "TestInput4/123", new{ id=325 })

路由匹配本例子中的第二个路由定义，路由模式为"{controller}/{action}/{id}"，产生的html为：

<a href="/Home/TestInput4/123?id=325">NavTestInput4</a>

根据匹配的第二个路由，这里既有RouteData.Values["id"]值为123，又有Request.QueryString["id"]值为325，传递给Home控制器的动作方法TestInput4的时候，TestInput4的参数id优先接收RouteData.Values["id"]，显示结果为：

id=123

（4）提交的表单，Request.Form中各元素的值也可以通过动作方法的参数传递。

例如，前面TestInput3的例子，其他不变，将HomeController中接收Post请求的TestInput3动作方法修改为：

        [HttpPost]
        public ViewResult TestInput3(string controller, string action,
            string city, DateTime forDate, int id = 0)
        {
            string inputController = controller;
            string inputAction = action;
            int inputId = id;
            
            ViewBag.inputController = inputController;
            ViewBag.inputAction = inputAction;
            ViewBag.inputId = inputId;
            ViewBag.city = city;
            ViewBag.forDate = forDate;
            return View("TI3Result");
        }

效果跟上一个TestInput3的例子一样。而且forDate的类型自动就给转换为DateTime类型。

三、从控制器产生输出

1、不要视图，直接用Response.Write输出

只要是派生于Controller的类里面的动作方法，就可以直接用Response.Write().

例如，前面的例子Index2()

namespace _12_1ControllersAndActions.Controllers
{
    public class HomeController : Controller
    {public void Index2()
        {
            //访问上下文对象的各个属性
            string userName = User.Identity.Name;
            string serverName = Server.MachineName;
            string clientIP = Request.UserHostAddress;
            DateTime dateStamp = HttpContext.Timestamp;
            Response.Write(string.Format("userName:{0}<br>serverName:{1}<br>clientIP:{2}<br>dataStamp:{3}", 
                userName, serverName, clientIP, dateStamp));
        }
    }
}

以及直接用Response.Redirect("/Some/Other/Url")也是属于这一种。

例如，在HomeController中添加动作方法TestRe

        public void TestRe()
        {
            Response.Redirect("/Home/Index");
        }

执行后，若输入"~/Home/TestRe"，则会自动转移到"~/Home/Index"

2、理解Action Result

在动作方法中不直接使用Response对象，而是返回一个派生于ActionResult类的对象，它描述控制器要完成的操作，例如产生一个视图、重定向到另一个url或动作方法等。

不同的操作用不同的派生类，它们都是ActionResult的派生类。例如，重定向：

        public ActionResult TestRe()
        {
            return new RedirectResult("/Home/Index");
        }

结果就返回RedirectResult的一个对象，因为RedirectResult派生于ActionResult，所以动作方法的返回类型可以用ActionResult，当然也可以明确使用RedirectResult作为该动作方法的返回类型。另外，各派生类也有一些控制器辅助器方法，可以简化调用，例如RedirectResult类有辅助器方法Redirect

        public ActionResult TestRe()
        {
            return Redirect("/Home/Index");
        }

跟上面直接使用return new RedirectResult("/Home/Index");产生的效果是一样的。

各个常用的派生类和用到的控制器辅助方法见p313。

3、从动作方法中产生视图作为输出

    public class HomeController : Controller
    {
        public ViewResult Index()
        {
            return View();
        }
    }

产生视图 /Views/Home/Index.cshtml

再如

    public class HomeController : Controller
    {
        public ViewResult Index()
        {
            return View("HomePage");
        }
    }

产生的视图为 /Views/Home/HomePage.cshtml

return View("HomePage")参数里加上双引号，表示给出指定的视图名。就不是默认跟动作方法同名的视图了。

另外，这里动作方法的返回类型用的是ViewResult，因为在知道方法返回的类型时，倾向于使用具体的类型，当然直接使用ActionResult也可以的。MVC框架在搜索视图时，先搜索Areas再搜索Views。仅以cshtml为例，下面是搜索顺序：

/Areas/<AreaName>/Views/<ControllerName>/视图名.cshtml

/Areas/<AreaName>/Views/Shared/视图名.cshtml

/Views/<ControllerName>/视图名.cshtml

/Views/Shared/视图名.cshtml

视图文件在生成html时会用到/Views/Shared/_Layout.cshtml布局文件作为默认布局文件，如果要用另一个布局文件可以用 

return View("HomePage", "_OtherLayout);

 当然，先要保证这个布局文件在/Views/Shared/目录中，也就是/Views/Shared/_OtherLayout.cshtml

四、把数据从动作方法传递给视图

1、使用视图模型对象

@model 类型

在HomeController中添加动作方法VMO()，如下：

        public ViewResult VMO()
        {
            DateTime date = DateTime.Now;
            return View(date);
        }

注意，这里的return View(date);参数里的date没有加双引号，这表示要传递给视图的数据，而不是指定要渲染的视图名，这里如果将date加上双引号，含义就变了，就表示该动作方法要产生一个名为date.cshtml的视图来进行显示。

这里使用return View(date);就表示把对象date传递到与当前动作方法同名的视图上，也就是/Views/Home/VMO.cshtml

@model DateTime
@{
    ViewBag.Title = "VMO";
}

<h2>VMO</h2>
the day is:@Model.DayOfWeek

在开头指定模型类型时，要用小写的m，这里是@model DateTime。而在文中读取模型值时，要用大写的M，如这里的@Model.DayOfWeek.

刚才强调，在动作方法中，返回View带参数时，不要加双引号，才表示返回的数据对象。如果要直接返回字符串对象，就需要在前面加上(object)指明这是模型对象。

        public ViewResult VMO()
        {
            DateTime date = DateTime.Now;
            return View((object)"hello, world.");
        }

在VMO.cshtml中，就使用string来指定模型类型。

@model string
@{
    ViewBag.Title = "VMO";
}

<h2>VMO</h2>
the day is:@Model

2、使用ViewBag传递数据

ViewBag允许你在这个动态对象上定义任意属性，并在视图中访问它们 ，就相当于键/值对。

只是vs对它不提供智能感应支持。

3、执行重定向

（1）重定向到字面url

假设在HomeController中有动作方法TestRe

        public RedirectResult TestRe()
        {
            return Redirect("/Home/Index");
        }

当访问"~/Home/TestRe"时，就会重定向到"~/Home/Index"

（2）重定向到路由系统的url

在HomeController中，假设有前面例子中的动作方法TestInput2()

        public void TestInput2()
        {
            string inputController = (string)RouteData.Values["controller"];
            string inputAction = (string)RouteData.Values["action"];
            int inputId = Convert.ToInt32(RouteData.Values["id"]);
            string queryVar1 = Request.QueryString["var1"];
            string queryVar2 = Request.QueryString["var2"];
            Response.Write(string.Format("inputController={0}<br>inputAction={1}<br>" + 
                "inputId={2}<br>queryVar1={3}<br>queryVar2={4}",
                inputController, inputAction, inputId, queryVar1, queryVar2));
        }

下面定义动作方法TestRe()来重定向到TestInput2()

        public RedirectToRouteResult TestRe()
        {
            return RedirectToRoute(new
            {
                Controller = "Home",
                Action = "TestInput2",
                id = "123",
                var1 = "ABC",
                var2 = "999"
            });
        }

执行程序后，当输入"~/Home/TestTe"，将产生重定向。注意，产生的url取决于所使用的路由定义。如果路由定义为

            routes.MapRoute(
                "Default", // Route name
                "{controller}/{action}/{id}", // URL with parameters
                new { controller = "Home", action = "Index", id = UrlParameter.Optional } // Parameter defaults
            );

则重定向产生的url为

"~/Home/TestInput2/123?var1=ABC&var2=999"

但这个路由定义，如果没有加以处理，在id处如果输入的不是数字，那么将会抛出异常。

如果路由定义用的是下面的定义

            routes.MapRoute(
                "Default", // Route name
                "{controller}/{action}", // URL with parameters
                new { controller = "Home", action = "Index" } // Parameter defaults
            );

            routes.MapRoute(
                "Default2", // Route name
                "{controller}/{action}/{id}", // URL with parameters
                new { controller = "Home", action = "Index" }, // Parameter defaults
                new { id = @"d+" }
            );

那么产生的重定向url为

"~/Home/TestInput2?id=123&var1=ABC&var2=999"

（3）重定向到一个动作方法

public RedirectToRouteResult TestRe()
{
    return RedirectToAction("TestInput2");
}

public RedirectToRouteResult TestRe()
{
    return RedirectToAction("TestInput2", new { id="123", var1="ABC", var2="999"});
}

public RedirectToRouteResult TestRe()
{
    return RedirectToAction("TestInput2", "Home");
}

public RedirectToRouteResult TestRe()
{
  return RedirectToAction("TestInput2", "Home", new { id="123", var1="ABC", var2="999"});
}

 4、返回文件及二进制数据

（1）返回文件

文件下载

        public FileResult TestFile()
        {
            string fPath = AppDomain.CurrentDomain.BaseDirectory + "DownloadTest/";
            //string fileName = @"c:log.txt";
            string fileName = fPath + "log.txt";
            string contentType = "text/plain";
            string downloadName = "Test.txt";
            return File(fileName, contentType, downloadName);     
        }

这里的AppDomain.CurrentDomain.BaseDirectory表示读取到当前项目的根物理路径，末尾带反斜杠。要下载的文件log.txt放在根目录下的DownloadTest文件夹中。在出现另存为对话框的时候，下载名被改为Test.txt。

（2）发送字节数组

        public FileContentResult TestFile()
        {
            byte[] data = ... //二进制内容
            return File(data, "text/plain", "Test.txt");
        }

（3）发送流内容

如果所处理的数据可以通过一个打开的System.IO.Stream进行操作，可以把这个流传递给File方法的一个重载版本。这个流得内容将被读取并发送给浏览器。

        public FileStreamResult TestFile()
        {
            Stream stream = ... //打开某种流
            return File(stream, "text/html");
        }

5、返回错误及http错误代码

（1）指定错误码

        public HttpStatusCodeResult StatusCode()
        {
            return new HttpStatusCodeResult(404, "url cannot be serviced.");
        }

（2）发送404错误

        public HttpStatusCodeResult StatusCode()
        {
            return HttpNotFound();
        }

（3）发送401错误

        public HttpStatusCodeResult StatusCode()
        {
            return new HttpUnauthorizedResult();
        }

-lyj