学习笔记 --- 工厂、单体、适配器、策略、观察者、MVC设计模式及ASP.NET MVC开发模式、关闭缓存的方法...-CSDN博客

关于工厂、单体、适配器、策略、观察者没啥好说的, 代码中有说明

//DesignPattern.cs

View Code

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

namespace DesignPattern
{
// ################################单体模式########################################
// 单体模式思路: 禁止外接任意调用 --> 1. 构造函数做成私有的, 且本类禁止继承(密封类)
// 本类又需要创建实例, 且只能有一份 --> 2. 类的静态成员(静态变量), 因此需要静态构造函数并在其中创建实例
// 需要对外界提供调用方法 --> 3. 静态属性或者静态方法为外界提供调用
public sealed class Singleton // 用sealed封闭类, 防止用其子类创建实例
{
private DateTime _createtime;

private Singleton() // 私有构造函数, 禁止外接调用
{
this ._createtime = DateTime.Now;
}

private static readonly Singleton inner; // 静态只读变量, 只能创建唯一的实例

static Singleton() // 通过静态构造函数, 返回本类的实例
{
inner = new Singleton();
}

public static Singleton GetSingleton // 提供静态属性供外接调用
{
get
{
return inner;
}
}

public static Singleton CreateSingleton() // 也可以提供静态方法供外接调用
{
return inner;
}

public override string ToString() // 重写ToString()方法, 返回
{
return " 该自定义对象的HashCode为: < " + inner.GetHashCode().ToString() + " > , 创建时间为: < " + this ._createtime.ToString() + " > , 当前时间为: < " + DateTime.Now.ToString() + " > ! " ;
}
}

// ################################工厂模式########################################
// 工厂模式的核心思想: 运行时绑定, 在运行时才创建对象. 工厂模式3大组成: 工厂、产品、抽象产品.
// 工厂模式思路: 通过工厂类创建不同类的实例 --> 1. 嵌套类, 且不同类需要有"共有的基类"或"实现相同接口"
// 工厂类通常做成单独的程序集 --> 2. 这里做成嵌套类了, 被嵌套类为internal
// 需要对外界提供可返回实例的方法 --> 3. 根据静态方法的参数(switch), 返回不同的实例
public class Factory
{
internal sealed class Laptop : Computer,IFunction
{
public Laptop( string type, string manufacturer, double price)
: base ( " 笔记本 " , type,manufacturer,price)
{

}

public override string ListFunction()
{
return " 我是笔记本, 价格贵, 携带方便! " ;
}
}

internal class Desktop : Computer,IFunction
{
public Desktop( string type, string manufacturer, double price)
: base ( " 台式机 " , type, manufacturer, price)
{

}

public override string ListFunction()
{
return " 我是台式机, 性能强悍, 易升级! " ;
}
}

internal sealed class NetBook : Computer,IFunction
{
public NetBook( string type, string manufacturer, double price)
: base ( " 上网本 " , type, manufacturer, price)
{

}

public override string ListFunction()
{
return " 我是上网本, 容易携带, 节能环保! " ;
}
}

// 静态方法为外界提供实例(抽象类做容器)
public static Computer getComputer( string name)
{
Computer result = null ;
switch (name)
{
case " 台式机 " :
result = new Desktop( " 随想T250 " , " 联想 " , 5888.88 );
break ;
case " 笔记本 " :
result = new Laptop( " ThinkPad-T500 " , " IBM " , 18888.0 );
break ;
case " 上网本 " :
result = new NetBook( " mini 9 " , " Dell " , 3000.00 );
break ;
default :
// nothing to do here
break ;
}
return result;
}

// 静态方法为外界提供实例(接口做容器)
public static IFunction getFunction( string name)
{
IFunction result = null ;
switch (name)
{
case " 台式机 " :
result = (IFunction) new Desktop( " 随想T250 " , " 联想 " , 5888.88 );
break ;
case " 笔记本 " :
result = (IFunction) new Laptop( " ThinkPad-T500 " , " IBM " , 18888.0 );
break ;
case " 上网本 " :
result = (IFunction) new NetBook( " mini 9 " , " Dell " , 3000.00 );
break ;
default :
// nothing to do here!
break ;
}
return result;
}

// 静态方法通过反射提供实例(需要配置文件), 由于是嵌套类, 反射有点问题, 如果是程序集肯定没问题
public static Computer getComputerByConfig()
{
string typestr = System.Configuration.ConfigurationManager.AppSettings[ " FactoryStrategy " ];
if (typestr == string .Empty)
{
throw new TypeLoadException( " 配置文件加载错误! " );
}
System.Type type = System.Type.GetType(typestr);
if (type == null )
{
throw new TypeLoadException( " 未知类型! " );
}
return System.Activator.CreateInstance(type) as Computer;
}
}

public abstract class Computer // 抽象类做容器
{
// 字段
private string _name;
private string _type;
private string _manufacturer;
private double _price;

// 构造函数
public Computer( string name, string type, string manufacturer, double price)
{
this ._name = name;
this ._type = type;
this ._manufacturer = manufacturer;
this ._price = price;
}

// 属性
public string Name
{
get
{
return this ._name;
}
}
public string Type
{
get
{
return this ._type;
}
}
public string Manufacturer
{
get
{
return this ._manufacturer;
}
}
public double Price
{
get
{
return this ._price;
}
}

public override string ToString()
{
return " 我是: < " + this .Name + " > , 型号为: < " + this .Type + " > , 制造商是: < " + this .Manufacturer + " > , 价格是: < " + this .Price.ToString() + " > ! " ;
}

public abstract string ListFunction();
}
public interface IFunction // 接口做容器
{
string ListFunction();
}

// ################################适配器模式#######################################
// 适配器模式思路: 通过接口的不同实现影响程序的执行效果(程序代码基本不做变化) --> 1. 定义接口(适配器模式注重的是功能), 及若干实现类.
public interface ICallAdapter
{
string MakeACall();
}

internal class Beeper : ICallAdapter
{
public string MakeACall()
{
return " 通过传呼台将信息< 新婚快乐, 百年好合! > 送给了他 " ;
}
}
internal class TelPhone : ICallAdapter
{
public string MakeACall()
{
return " 通过电话祝福他 < 新婚快乐, 百年好合! > " ;
}
}
internal class CellPhone : ICallAdapter
{
public string MakeACall()
{
return " 通过手机将亲手制作的视频-- < 新婚快乐, 百年好合! > 发送给了他 " ;
}
}

// 适配器模式的惯用法:
// 简单适配器(如上): 在业务逻辑比较简单且详细设计规范的情况下, 可以使用上边的方式, 在需要更换实现时直接修改源代码.
// 惯用适配器: 当我们在项目中需要更换某个功能模块的实现时, 新模块的方法名、参数名(方法签名)等均与旧模块不同, 此时可以通过引入专门的适配器来解决.
// 惯用适配器处理方式: 1. 新建类库项目并定义接口, 接口中规定需要实现的功能.
// 2. 创建新的适配器类, 该类继承自新模块中的实现类, 并实现定义的接口. 在新类的方法中, 通过base.方法名()调用新模块中的功能.
// 这样, 程序编码时使用IInterface ii = new NewClass();语句, 并调用接口ii上的方法即可. 当再发生改变时, 我们只需要在适配器中继承新模块的实现类, 并修改base后的方法即可. 之后把编译后的.dll文件拷贝到项目中去, 就可使用,源程序不做任何修改.
internal class MakeCall : Beeper, ICallAdapter // CellPhone
{
#region ICallAdapter Members

string ICallAdapter.MakeACall()
{
return base .MakeACall();
}

#endregion
}

// ################################策略模式#######################################
// 策略模式思路: 获得某个抽象类或接口的实现, 通过策略类(工具类)直接返回处理完成的结果.
// 与通过反射获得对象实例的工厂模式的区别: 工厂返回对象实例, 而策略强调完成任务、显示结果
// 1. 创建抽象基类或接口, 并创建若干实现类.
// 2. 创建策略类(工具类): 策略类利用反射从配置文件中获取对象实例后, 再调用对象上的方法, 返回结果
public abstract class Vehicle
{
public abstract string GetVehicleName();
}

internal class BoardingCar : Vehicle
{
public override string GetVehicleName()
{
return " 我是小轿车! " ;
}
}
internal class MotorBicycle : Vehicle
{
public override string GetVehicleName()
{
return " 我是摩托车! " ;
}
}
internal class Bike : Vehicle
{
public override string GetVehicleName()
{
return " 我是自行车! " ;
}
}

// 策略类(工具类), 用于返回处理结果, 用户不会看到连接字符串、new等操作
public class VehicleProvider
{
public static string OutputName()
{
string typestr = System.Configuration.ConfigurationManager.AppSettings[ " Strategy " ];
if (typestr == string .Empty)
{
throw new TypeLoadException( " 配置文件错误! " );
}
System.Type type = System.Type.GetType(typestr);
if (type == null )
{
throw new TypeLoadException( " 获取类型失败! " );
}
// 这里和通过反射获得对象的工厂的区别就是: 一个返回实例, 一个返回处理完成的结果
Vehicle v = System.Activator.CreateInstance(type) as Vehicle;
return v.GetVehicleName();
}
}
// 策略类(工具类)的另一种写法(适合项目文件多、业务逻辑较复杂的情况)
public class VehicleStrategy
{
private Vehicle _strategy;
public void SetStrategy(Vehicle strategy) // 设置策略
{
this ._strategy = strategy;
}
public string ExecuteStrategy() // 执行策略
{
return this ._strategy.GetVehicleName();
}
}

// ################################观察者模式#######################################
// 观察者模式思路: 观察者(被动方)根据被观察着(主动方)的行为, 做出不同的响应, 已实现联动效果.
// 1. 抽象出观察者的共有行为, 即接收被观察者发送的消息; 抽象出被观察着的行为, 即提添加观察者和发送信息给观察者(对行为的抽象, 适合接口)
// 2. 定义若干观察者的类, 实现观察者接口, 定义被观察者类, 实现被观察接口
// 3. 通过被观察者行为的变化影响所有的观察者
public interface IObserver // 观察者(被动方), 接收信息
{
void ReceiveInfo( object obj);
}

public interface IActive // 被观察着(主动方), 添加观察者和发送信息给观察者
{
void SendInfo( object obj); // 添加观察者
void RegObserver(IObserver io); // 发送信息
}

public class Car : IObserver
{
public void ReceiveInfo( object obj)
{
if (obj.ToString() == " 红灯 " )
{
Console.WriteLine( " 红灯停, 轿车踩刹车! " );
}
else if (obj.ToString() == " 绿灯 " )
{
Console.WriteLine( " 绿灯行, 轿车踩油门! " );
}
else
{
Console.WriteLine( " 黄灯将变灯, 轿车减速! " );
}
}
}

public class Bicycle : IObserver
{
public void ReceiveInfo( object obj)
{
if (obj.ToString() == " 红灯 " )
{
Console.WriteLine( " 红灯停, 自行车下车! " );
}
else if (obj.ToString() == " 绿灯 " )
{
Console.WriteLine( " 绿灯行, 自行车上车! " );
}
else
{
Console.WriteLine( " 黄灯将变灯, 自行车减速! " );
}
}
}

public class People : IObserver
{
public void ReceiveInfo( object obj)
{
if (obj.ToString() == " 红灯 " )
{
Console.WriteLine( " 红灯停, 人站住! " );
}
else if (obj.ToString() == " 绿灯 " )
{
Console.WriteLine( " 绿灯行, 人行走! " );
}
else
{
Console.WriteLine( " 黄灯将变灯, 人观察! " );
}
}
}

public class TrafficLight : IActive
{
// 内部需要有个集合记录所有观察者
List < IObserver > list = new List < IObserver > ();

public void SendInfo( object obj)
{
foreach (IObserver io in list)
{
io.ReceiveInfo(obj);
}
}

public void RegObserver(IObserver io)
{
list.Add(io);
}
}

// 观察者模式2(抽象类实现)：猫大叫, 主人醒, 老鼠跑
public abstract class Passive // 观察者
{
public abstract void Act();
}
public abstract class Active // 被观察者
{
public abstract void AddList(Passive pa);
public abstract void Shout();
}

public class Cat : Active
{
// 通知列表
List < Passive > list = new List < Passive > ();
public override void AddList(Passive pa)
{
list.Add(pa);
}

public override void Shout()
{
Console.WriteLine( " 猫大叫! " );
foreach (Passive p in list)
{
p.Act();
}
}
}
public class Mouse : Passive
{
public Mouse( string name)
{
this ._name = name;
}

private string _name;
public string Name
{
get
{
return this ._name;
}
set
{
this ._name = value;
}
}

public override void Act()
{
Console.WriteLine( string .Format( " 老鼠 < {0} > 四下逃窜! " , this .Name));
}
}
public class Man : Passive
{
public override void Act()
{
Console.WriteLine( string .Format( " 主人惊醒! " ));
}
}
}

//Progarm.cs

View Code

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

using System.Threading;

namespace DesignPattern
{
class Program
{
static System.Timers.Timer timer;
static string lightcolor = " 红灯 " ;
static TrafficLight tl;
static void Main( string [] args)
{
Console.WriteLine( " ------------单体模式(Singleton)------------- " );
// Singleton s1 = new Singleton(); // 无法直接创建Singleton的实例
Singleton s2 = Singleton.GetSingleton;
Console.WriteLine(s2.ToString());

Thread.Sleep( 3000 );

Singleton s3 = Singleton.GetSingleton;
Console.WriteLine(s3.ToString());

Thread.Sleep( 3000 );
Singleton s4 = Singleton.CreateSingleton();
Console.WriteLine(s4.ToString());

Console.WriteLine( " \n------------工厂模式(Factory)------------- " );
// 基类容器
Computer c1 = Factory.getComputer( " 笔记本 " );
Console.WriteLine(c1.ToString());
Computer c2 = Factory.getComputer( " 上网本 " );
Console.WriteLine(c2.ToString());
// 配置文件获取对象实例
// Computer c3 = Factory.getComputerByConfig();
// Console.WriteLine(c3.ToString());
// 使用接口容器
IFunction i1 = Factory.getFunction( " 台式机 " );
Console.WriteLine(i1.ListFunction());
IFunction i2 = Factory.getFunction( " 上网本 " );
Console.WriteLine(i2.ListFunction());

Console.WriteLine( " \n------------适配器模式(Adapter)------------- " );
ICallAdapter ica = null ; // 使用接口盛放不同实现
ica = new TelPhone();
Console.WriteLine(NoticeInfo( " 同事结婚 " , " 家里 " , ica));
ica = new CellPhone();
Console.WriteLine(NoticeInfo( " 好朋友结婚 " , " 厕所 " , ica));
ica = new Beeper();
Console.WriteLine(NoticeInfo( " 爷爷再婚 " , " 办公室 " , ica));
Console.WriteLine( " \n------------惯用的适配器模式------------- " );
ICallAdapter ica2 = new MakeCall();
Console.WriteLine(NoticeInfo( " 同事结婚 " , " 家里 " , ica2));

Console.WriteLine( " \n----------抽象类实现观察者模式1(Observer)----------- " );
Cat cat = new Cat();
Mouse m1 = new Mouse( " Jerry " );
Mouse m2 = new Mouse( " MickeyMouse " );
Man man = new Man();
cat.AddList(m1);
cat.AddList(m2);
cat.AddList(man);
cat.Shout();

Console.WriteLine( " \n------------接口观察者模式2(Observer)------------- " );
tl = new TrafficLight();
Car car1 = new Car();
Bicycle bike1 = new Bicycle();
People people1 = new People();
tl.RegObserver(car1);
tl.RegObserver(bike1);
tl.RegObserver(people1);

// tl.SendInfo("红灯"); // 测试
// tl.SendInfo("绿灯"); // 测试
timer = new System.Timers.Timer();
timer.Interval = 1000 * 10 ; // 推荐写法
timer.Elapsed += new System.Timers.ElapsedEventHandler(timer_Elapsed);
timer.Start();

Console.WriteLine( " \n------------策略模式(Strategy)------------- " );
Console.WriteLine(DesignPattern.VehicleProvider.OutputName()); // 通过反射从配置文件获得对象信息
Console.WriteLine( " \n------------策略模式另一种写法------------- " ); // 添加新策略时, 可以不修改源代码
System.Reflection.Assembly asm = System.Reflection.Assembly.LoadFrom(System.Configuration.ConfigurationManager.AppSettings[ " AssemblyPath " ]);
Vehicle vehicle = asm.CreateInstance(System.Configuration.ConfigurationManager.AppSettings[ " ClassName " ]) as Vehicle; // Vehicle为抽象类
VehicleStrategy vs = new VehicleStrategy(); // 策略管类类
vs.SetStrategy(vehicle); // 设置策略
Console.WriteLine(vs.ExecuteStrategy()); // 执行策略, 添加新策略时只要配置好app文件中程序集位置和类名即可

Console.ReadLine(); // 挂起程序
}

static void timer_Elapsed( object sender, System.Timers.ElapsedEventArgs e)
{
timer.Stop();
Console.WriteLine( " \n-----------观察者模式2的回调结果--------------\n " );
if (lightcolor == " 红灯 " )
{
lightcolor = " 绿灯 " ;
}
else if (lightcolor == " 绿灯 " )
{
lightcolor = " 红灯 " ;
}
tl.SendInfo(lightcolor);
Console.Write(Environment.NewLine);
timer.Start();
}

static string NoticeInfo( string content, string place, ICallAdapter mode) // 适配器模式中的主要代码部分
{
return " < " + content + " > , 小明正在 < " + place + " > , 于是用 < " + mode.MakeACall() + " > ! " ;
}
}
}

//App.config

<? xml version="1.0" encoding="utf-8" ?>
< configuration >
< appSettings >

< add key ="Strategy" value ="DesignPattern.Bike,DesignPattern" />


< add key ="ClassName" value ="DesignPattern.MotorBicycle" />
< add key ="AssemblyPath" value ="D:\重要未完成\DesignPattern\DesignPattern\bin\Debug\DesignPattern.exe" />
</ appSettings >
</ configuration >

关于MVC设计模式的控制台Demo

//Model/Model.cs

View Code

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

using System.Diagnostics;

namespace MVCModel
{
// MVC模式的思想: 将界面设计和功能设计分开, 且同时进行设计, 最后通过Controller综合工作成果. 程序运行时, 按View-Controller-Model的流程执行
// 功能开发人员可以向Controller提交dll文件, 也可以将dll注册到本机的全局程序集缓存(GAC)中(c:\windows\assembly).
// 添加到GAC中的方法:
// 1. 添加完整的文档注释, 类型及成员均需添加且不可遗漏(类: 描述... ; 方法: 根据...; 属性: 获取或设置... ; 参数: System.xx类型, 表示...)
//
// 2. 添加完整程序集信息(通过创建空类库项目, 获得AssemblyInfo文件并修改)
// 主版本号: 软件版本重大变化, 如: 单机版到网络版
// 次要版本号: 软件功能变化, 如: 添加辅助挂机功能
// 内部版本号: 如: beta,final, 或同时做出几个不同方案, 最终选一个
// 修订号: 修改bug的次数
//
// 3. 通过类库中的强名称工具获得签名密钥(需在环境变量的Path中, 添加VS2008的SDK目录c:\program files\Microsoft SDKs\Windows\v6.0A\bin)
// cmd中生成强名称(注意大小写): sn -k strongname.snk 查看强名称: sn -T xxx.dll
// 备注: VS2005的SDK目录为c:\program files\Microsoft Visual Studio 8\SDK\v2.0\Bin
//
// 4. 将有完整文档注释的cs文件、AssemblyInfo文件及强名称文件编译成一个dll文件和XML文档
// cmd中键入命令: csc /target:library /doc:xxx.xml /keyfile:strongname.snk /out:xxx.dll AssemblyInfo.cs aaa.cs bbb.cs
//
// 5. 将xxx.dll和xxx.xml拷贝到稳定的目录(如框架类库目录: c:\windows\Microsoft.Net\Framework\v3.5\)下
// cmd中使用命令gacutil /i xxx.dll注册到GAC中使用gacutil /u xxx.dll可以反注册; 若不需要xxx.xml, 可以简单的讲xxx.dll拖到c:\windows\Assemly文件夹中

/// <summary>
/// 描述定时关机操作及其相关信息
/// </summary>
public class Model
{
/// <summary>
/// 根据参数选择执行的操作及延时
/// </summary>
/// <param name="action"> System.String类型, 表示操作的类型, "r"代表重启, "s"代表关机 </param>
/// <param name="seconds"> System.Int32类型, 以整数表示的操作延时, 单位为秒 </param>
public void RunCommand( string action, int seconds)
{
string param = " - " + action + " -t " + seconds;
Process.Start( " shutdown " , param);
}

/// <summary>
/// 根据参数返回执行命令的字符串表示
/// </summary>
/// <param name="action"> System.String类型, 表示操作额类型, "r"代表重启, "s"代表关机 </param>
/// <param name="seconds"> System.Int32类型, 以整数表示的操作延迟, 单位为秒 </param>
/// <returns> System.String类型, 执行命令的字符串表示, 默认返回空字符串"" </returns>
public string GetCommand( string action, int seconds)
{
string result = "" ;

result = " shutdown - " + action + " -t " + seconds;

return result;
}
}
}

//Model/AssemblyInfo.cs

View Code

using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;

// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle( " PowerOffComponent " )]
[assembly: AssemblyDescription( " 全局程序集, 完成计算机定时关机操作 " )]
[assembly: AssemblyConfiguration( "" )]
[assembly: AssemblyCompany( " China America IT Technology Inc. " )]
[assembly: AssemblyProduct( " CaitProduct-PowerOff " )]
[assembly: AssemblyCopyright( " Copyright © China America IT Technology Inc. 2010 " )]
[assembly: AssemblyTrademark( " CAIT " )]
[assembly: AssemblyCulture( "" )]

// Setting ComVisible to false makes the types in this assembly not visible
// to COM components. If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible( false )]

// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid( " 43c452bd-72d8-421c-b2ec-4e8a9b749418 " )]

// Version information for an assembly consists of the following four values:
//
// Major Version: 主版本号, 软件版本重大变化, 如: 单机版到网络版
// Minor Version: 次要版本号, 软件功能变化, 如: 添加辅助挂机功能
// Build Number: 内部版本号, 如: beta,final, 或同时做出几个不同方案, 最终选一个
// Revision: 修订号: 修改bug的次数
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion( " 1.0.1.5 " )]
[assembly: AssemblyFileVersion( " 1.0.1.5 " )]

//Controller/Controller.cs

View Code

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

namespace MVCController
{
public class Controller
{
public static string KillPower( string choise, string time)
{
string result = null ;

string param = (choise == " 1 " ) ? " s " : " r " ;
int inttime = Convert.ToInt32(time);

MVCModel.Model m = new MVCModel.Model();
result = m.GetCommand(param, inttime);

// 这里可以采用异步通信, 开辟子线程执行RunCommand命令
m.RunCommand(param, inttime); // 两种异步通信: 1. Async方法+事件 2.委托实例+回调函数(callback)

return result;
}
}
}

//View/View.cs

View Code

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

namespace MVCView
{
class View
{
static void Main( string [] args)
{
Console.WriteLine( " ************************************** " );
Console.WriteLine( " * * " );
Console.WriteLine( " * MVC模式练习---关机重启小程序 * " );
Console.WriteLine( " * * " );
Console.WriteLine( " ************************************** " );

string input = "" ;
string time = " 5 " ;
string result = null ;
while ( true )
{
Console.WriteLine( " 请选择操作: \t1.关机 \t2.重启 " );
Console.WriteLine( " \t\t0.退出 " );
input = Console.ReadLine();
if (input != " 0 " )
{
if ((input == " 1 " ) != (input == " 2 " ))
{
Console.Write( " 请输入延迟时间(含0): " );
time = Console.ReadLine();

// 执行方法
result = MVCController.Controller.KillPower(input,time);
if (result != null )
{
Console.WriteLine( " \n操作已执行, 执行的完整命令为: " + result + " \n " );
}
else
{
Console.WriteLine( " \n程序执行异常, 请通知管理员! \n " );
}

}
else
{
Console.WriteLine( " 输入了不合适的选项! " );
}
}
else
{
Console.WriteLine( " 感谢使用, 再见! " );
break ;
}
}
}
}
}

ASP.NET-MVC

最早是在王老师的课上听到MVC这个东西, 当时是讲设计模式. MVC设计模式从本质上讲就是种分工的方式, 人为的把一个项目分成Model(模型)、View(试图)、Controller(控制器). 这样呢, 首先由Controller来协调View和Model之间的衔接, 按王老师的话讲就是”和稀泥的家伙”, 在Controller中预先规定好需要提供给View开发人员的方法及方法名, 这样, View开发人员在开发时, 便可以忽略具体的实现, 只要根据需要调用Controller中的方法并显示结果即可; 那么Model开发人员关注的则是具体的业务对象, 针对每个业务对象制作不同的类以及与该业务对象相关的各种方法; 最后Controller通常有较有经验的工程师担当, 他负责调用Model中业务对象的各种方法来完成相关的业务逻辑. 如此, 一个项目就被分成了3个阶段, View和Controller、Controller和Model之间可以通过接口来现隔离(术语叫解耦合), 最终3个部分可以并行开发, 大大提高了开发效率.

之后在郝老师的课上, 又一次听到MVC, 这里的MVC是指ASP.NET的MVC开发方式(说开发模式容易混淆). 反正当时我是弄混了.

MVC设计模式: 何谓设计模式? 设计模式是一种设计思想, 是高于开发的一种抽象层面的想法. 而MVC开发模式或者说开发方式, 就是在你实际开发过程中, 采取的一种手段或某种流程. 前面也提过, MVC设计模式的思想就是分工, 各层用接口隔离; MVC开发模式是微软在ASP.NET技术中提出的一种开发手段, 就如同我们熟悉的WebForm开发, ASP.NET MVC也是一种开发手段与WebForm是平行的, 它代表.NET Web开发领域中, 除WebForm外的另一种开发方向. 你可以理解为ASP.NET MVC就是将MVC设计模式的思想用到了Web网站开发中的UI层, 所有ASP.NET MVC的工作都是针对UI层的, 底下的业务逻辑、数据库访问、实体等层依然和WebForm开发是一样的.

那么微软大费周章的搞出个ASP.NET MVC有什么好处呢? ----最大的好处就是可测试.

在传统的Web开发中, 如果想测试开发的网站, 你需要的启动网站, 用非正常用户的角度去尝试各种边界值和以外情况, 而在ASP.NET MVC中, 页面View中显示的内容都是从Model中来的, 而Model又是在Controller中由Action返回的, 这里先不用管Action是什么, 你可以把它当作是个Controller中的处理请求的方法. 此时, 整个Controller看起来就是类而已, 而实际上它就是个类, 这时候关于网站的测试工作的关键就看这个类了, 这时候你想到了什么? NUnitTest, 对啊, 我们只要写测试用例, 用事先写好的测试用例来测试不就好了, 开发过程中, 我们可以随时跑下测试用例, 就知道当前有没有错误. 因此, 可测试是ASP.NET MVC的最大优点.

ASP.NET MVC 请求过程:

说了一大堆, 其实就是两点: 1. ASP.NET MVC开发模式(方式)是MVC设计模式(思想)在UI层的体现. 2. ASP.NET MVC最大的优点是便于测试. Okey, 接下来开始ASP.NET MVC, 以下无特殊说明, MVC均指ASP.NET MVC. 看下图, ASP.NET MVC的请求回应过程.

客户端浏览器首先发送GET或POST请求, 当请求到达IIS后, 由aspnet_iisapi.dll转交asp.net组件, 然后由w3wp创建应用程序域, 再应用程序域中创建HttpRuntime执行环境, 并在环境中创建HttpContext对象(该对象包含HttpRequest、HttpResponse、Cache、Server等对象)和HttpApplication应用程序管道, 在HttpApplication应用程序管道中会根据请求的URL形式将会进行一个称为Routing的过程(可以参见Global.asax.cs中的代码). 什么是Routing(路由)呢? 在计算机网络中, 路由定义为: 在不同的网段间转发数据的过程. 而在此处的Routing可以理解为一个转发数据的过程, 它把GET请求头或POST请求体中的数据转发给了Controller. 上图中有个请求地址的示例, Routing的工作实际上就是通过正则表达式把Controller、Action和Parameter分别取出来. 这样, 便得到了Controller的名称、Action的名称、以及参数, 这时asp.net mvc将会到网站根目录下的Controllers文件夹中找到相应名称的Controller类, 并在Controller类中找到Action. 在Controller类中可以看到, 一个Action其实就是返回值为ActionResult的方法. 之后, 在Action方法中完成调用业务逻辑层、数据库访问层等完成工作之后, 将取到的结果封装到一个Model类中, 在返回给前台的View. 在View中通过该Model类的对象获得值并显示在View中, 最后在把View发送给客户端浏览器.

以上就是ASP.NET MVC的整个请求相应过程, 值得注意的, Model是用来封装返回结果的, 也可以在Model中添加用于验证(配合jQuery)的标注属性. 当然我们也可以不用Model, 而直接使用ViewData字典或者自定义实体类都可以返回结果. 不论是Model、ViewData还是实体类都需要在View的页面指令的Inherits属性中声明一下, 声明格式如下: Inherits =” System.Web.Mvc.ViewPage<mvc_1.Models.VenderModel>”, 其中mvc_1.Models.VenderModel就是用来封装结果的Model类.

如此说来, 我们有三种方式从Controller中传递数据岛View中: ViewData、自定义实体类、Model(常用).

开发ASP.NET MVC网站的开发工具需要是VS2008 + SP1以上, 并且需要安装ASP.NET MVC2_VS2008. 在写View的时候, 会用到Lambda表达式(Parameter => Method)和嵌入程序块(<%...%>)及嵌入表达式(<%= %>). 详见示例:

1. 为简便, 这里不再分BLL、DAL及实体层, 我们通过一个接口和一个实现类来完成对xml中数据的操作、通过Manufacturer实体类表示制造商信息.

注意: 在返回集合数据时, 可以用IEnumerable<T>泛型接口作返回类型.

Model类似于实体类, 但Model真的不是实体类:

实体类是与数据库中某张或某几张表相关的类型, 该类型可以使程序员在程序中方便的表示和使用表中的数据, 是O/R Mapping(Object-Relation Mapping, 对象关系映射)思想的体现. 实体类中几乎涉及数据表中的每个字段, 是用来在整个项目中表示数据对象的. 而Model中虽然也是一大堆封装字段的属性, 而且可以添加用于验证(配合jQuery)的标签属性, 但是Model的重点在于Controller和View之间. Model提供了一种介于Controller和View之间传递的数据的强类型表示, Model中的数据可能只是与View中需要显示的那部分数据相关. 一句话说, 实体类是数据库中的表和程序中的数据表示之间的一层映射, 而Model是UI层的Controller和View之间传递的数据或参数的映射. 例如: 你可能在数据中有表(包含: 序号、姓名、密码、生日、家庭住址), 那么你的实体类中往往是对表中所有字段的封装. 但是在UI中, 你的更改密码的页面(View)传递给Controller的参数往往是个Model类(包含: 旧密码、新密码)的对象, 这时区别很容易看出来. Model就是一种对传递的数据的强类型的封装, 而实体类是对数据库中表中字段进行的封装, 是用来在程序中表示表中的数据的. 根据具体的情况, Model类中字段的内容可能和实体类字段的内容相差很大, 更多的时候Model类中的字段就是View中用来接收用户输入的字段.

2. 由上图可知, 客户端请求的第一站是Controller中. 为实现低耦合, 我们在Controller中调用接口上的方法, 因为我们可以先定义接口类型的属性, 然后重写Controller的Initialize()方法, 在Initialize()方法中进行接口的赋值工作.

注意: 我们通常将业务逻辑处理完的结果用Model封装后返回给View, 但是当返回的是集合类型的元素时, 我们必须通过ViewData字典返回.

3. 接下来, 我们继续看Controller中的每个方法即Action, 每个Action应该对应一个View, 而Controller中往往有多个Action, 所以我们在View文件夹中创建Manufacturer文件夹, 并且针对每个Action都创建一个View页面, 如: Index、Detail、Delete等.

注意: 我们也可以自定义Action, 其实就是写个方法. 例如: public JsonResult CheckName(){…}, 其中JsonResult用来返回Json对象, 通过JsonResult对象的JsonRequestBehavior属性设置允许的请求类型, 通过JsonResult对象的Data属性返回结果.

在MVC中, 针对同一个View页面的两次请求会由于缓存看不到结果, 这是需要用页面指令关闭缓存. 如:<@OutputCache Duration=”1” VaryByParam=”*”%>

4. 最后, 在View中呈现我们的结果, 如果是集合数据, 我们可以采用嵌入代码块的方式(<%......%>)拼程序块, 而用<%=……%>来绑定结果中的字段; 如果返回的只是单个Model, 可以通过lambda表达式绑定结果数据, 只是不要忘了需要在页面指令的Inherits属性中, 申明Model.

以上便是Asp.Net MVC的一次请求过程, 开发网站的UI时, 只要按照Controller ---> Action ---> BLL(业务处理逻辑) ---> View的次序迭代即可.

关于MVC中的验证:

Model类中的标注属性实际上就是用来完成验证工作的, 因为Model类中的字段均是View页面中需要用户输入的字段, 凡是涉及到用户输入的地方, 肯定补课缺少的就是验证.

在MVC有两种验证方式: 服务器端的验证方式和客户端的验证方式.

1. 服务器端验证: 包含Model中的标注属性、View中的Html.ValidationMessageFor()、Controller中的Action方法中的ModelState.IsValid属性. MVC中的服务器端验证和jQuery的Validate配合工作的. 使用时, 只要在Model中添加验证标签(引用System.ComponentModel和System.ComponentModel.DataAnnotations命名空间), 在Controller的Action方法中用ModelState.IsValid判断下, 最后再View中添加验证信息的显示位置即可. 具体事例, 参见View文件夹中的Create.aspx.

2. 客户端验证: 客户端验证才是我们开发中常用的验证手段, 同样MVC的客户端的验证手段仍然是通过jQuery的Validate实现的. 客户端的验证, 我们不需要该Model、也不需要改Controller, 所有的验证工作都是在View中的Javascript脚本中完成的. 我们把jQuery和jQuery.Validate引用到View页面中, 并且我们可以通过Html.TextBoxFor()的重载方法, 为TextBox元素添加ID等属性(通过匿名对象new {}进行). 具体事例见Edit.aspx

注意: 我们可以通过<%= Url.Action(“ActionName”) %>计算出这个Action的全路径. 并且因为IE浏览器会对同一个请求做缓存处理, 所以这里应该用<%= Url.Action(“ActionName”) + “?” + DateTime.ToLongTimeString() %>做地址.

关于input中的name属性, 例如: <input type=”hidden” name=”abc” value=”123”>的标签, 只有添加了name属性, 在表达提交时才会将input的值发送到服务器. 发送时, 会在get请求后变成?abc=123，在post请求体中变成是…&abc=123, …表示装他的内容.

关于缓存, 我们有5中关闭缓存的方式:

1. 更改Url: 在Url后边人为添加不会重复的内容.

2. 在*.ashx, *.cs文件中用context.Response.Cache.SetCacheability(HttpCacheability.NoCache);

3. 在*.aspx或*.ascx文件中, 用页面指令<%@Outputcache Duration=”1” VaryByParam=”*”%>

4. jQuery的Ajax中, 使用$.ajax({cache: false}); 关闭ajax时的缓存

5. 在*.html中的head标签中, 添加如下内容:

//实例代码如下:

//数据文件, App_Data/ManufacturerData.xml

View Code

<? xml version="1.0" encoding="utf-8" ?>
< Data >
< Manufacturer >
< ManufacturerID > fa33da90-d145-4122-85a9-b3f99f99ebfd </ ManufacturerID >
< ManufacturerName > Mercedes.Benz </ ManufacturerName >
< MandarinName > 梅赛德斯.奔驰 </ MandarinName >
< CreateTime > 2011-01-12 18:53:20 </ CreateTime >
</ Manufacturer >
< Manufacturer >
< ManufacturerID > 8f7f6a78-b991-493e-bbe7-4ba5af00fa63 </ ManufacturerID >
< ManufacturerName > Bayerische Motoren-Werke AG </ ManufacturerName >
< MandarinName > 宝马 </ MandarinName >
< CreateTime > 2011-03-02 08:33:00 </ CreateTime >
</ Manufacturer >
< Manufacturer >
< ManufacturerID > c3aa600a-26df-4a27-be06-4b4329f2998a </ ManufacturerID >
< ManufacturerName > Ferrari </ ManufacturerName >
< MandarinName > 法拉利 </ MandarinName >
< CreateTime > 2010-06-07 23:13:15 </ CreateTime >
</ Manufacturer >
< Manufacturer >
< ManufacturerID > 45d73ca9-96ad-4884-b56b-2b6b673d9843 </ ManufacturerID >
< ManufacturerName > cbg </ ManufacturerName >
< MandarinName > Test1 </ MandarinName >
< CreateTime > 2011-2-18 0:40:30 </ CreateTime >
</ Manufacturer >
< Manufacturer >
< ManufacturerID > 4c35a974-ecb4-489d-878b-0008f1735ba3 </ ManufacturerID >
< ManufacturerName > abc </ ManufacturerName >
< MandarinName > vvvb </ MandarinName >
< CreateTime > 2011-2-18 1:45:06 </ CreateTime >
</ Manufacturer >
</ Data >

//IManufacturerManager.cs

View Code

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

namespace MvcApplicationDemo
{
public interface IManufacturerManager
{
// 当返回集合数据时, 可以用IEnumerable<T>泛型接口作返回类型
IEnumerable < Manufacturer > GetAllManufacturers();
Manufacturer GetManufacturerByID(Guid id);
void CreateManufacturer(Manufacturer manufacturer);
void DeleteManufacturer(Guid id);
bool CheckManufacturerName( string manufacturername);
void UpdateManufacturer(Manufacturer manufacturer);
}
}

//ManufacturerManager.cs

View Code

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

using System.Web.Mvc;

namespace MvcApplicationDemo
{
public class ManufacturerManager : IManufacturerManager
{
string DataPath = AppDomain.CurrentDomain.BaseDirectory + " App_Data/ManufacturerData.xml " ;
#region IManufacturerManager Members

public IEnumerable < Manufacturer > GetAllManufacturers()
{
// 一次性全部读取, 适合采用XML流, 但XML流不支持结构化查询
List < Manufacturer > manufacturers = new List < Manufacturer > (); // 用于返回数据
System.IO.StreamReader sw = new System.IO.StreamReader(DataPath, System.Text.Encoding.UTF8);
using (System.Xml.XmlReader xmlrd = System.Xml.XmlReader.Create(sw))
{
Manufacturer manufacturer;
while (xmlrd.Read())
{
if (xmlrd.NodeType == System.Xml.XmlNodeType.Element)
{
if (xmlrd.Name == " Manufacturer " )
{
manufacturer = new Manufacturer();
if (xmlrd.ReadToFollowing( " ManufacturerID " ))
{
manufacturer.Uid = new Guid(xmlrd.ReadElementString( " ManufacturerID " ));
}
if (xmlrd.ReadToFollowing( " ManufacturerName " ))
{
manufacturer.ManufacturerName = xmlrd.ReadElementString( " ManufacturerName " );
}
if (xmlrd.ReadToFollowing( " MandarinName " ))
{
manufacturer.MandarinName = xmlrd.ReadElementString( " MandarinName " );
}
if (xmlrd.ReadToFollowing( " CreateTime " ))
{
manufacturer.CreateTime = DateTime.Parse(xmlrd.ReadElementString( " CreateTime " ));
}
manufacturers.Add(manufacturer);
}
}
}
}
sw.Close();
return manufacturers;
}

public Manufacturer GetManufacturerByID(Guid id)
{
Manufacturer manufacturer = null ;

// 只是查询, 适合XPathDocument, 优化过的XPath, 优点: 结构化查询、速度快; 缺点: 只能读不能写
System.Xml.XPath.XPathDocument xpdoc = new System.Xml.XPath.XPathDocument(DataPath); // 创建XPathDocument
System.Xml.XPath.XPathNavigator xpnav = xpdoc.CreateNavigator(); // 创建查找用的导航器

// 定制XPathExpression表达式
string xpathstr = " Data/Manufacturer " ;
System.Xml.XPath.XPathExpression xpath = System.Xml.XPath.XPathExpression.Compile(xpathstr);

// 使用导航器获得结果, 单个结果用XPathNavigator导航器, 多个结果用XPathNodeIterator迭代器
System.Xml.XPath.XPathNavigator resultnav = xpnav.SelectSingleNode(xpathstr);
while (resultnav.HasChildren)
{
resultnav.MoveToFirstChild();
if (resultnav.Value == id.ToString())
{
manufacturer = new Manufacturer();
manufacturer.Uid = id;
if (resultnav.MoveToNext() && resultnav.Name == " ManufacturerName " )
{
manufacturer.ManufacturerName = resultnav.Value;
}
if (resultnav.MoveToNext() && resultnav.Name == " MandarinName " )
{
manufacturer.MandarinName = resultnav.Value;
}
if (resultnav.MoveToNext() && resultnav.Name == " CreateTime " && ! string .IsNullOrEmpty(resultnav.Value))
{
manufacturer.CreateTime = DateTime.Parse(resultnav.Value);
}
break ;
}
else
{
resultnav.MoveToParent(); ; // 移动父节点
resultnav.MoveToNext(); // 父节点的兄弟
}
}
return manufacturer;
}

public void CreateManufacturer(Manufacturer manufacturer)
{
// 修改操作, 适合采用XPath进行操作
System.Xml.XmlDocument xdoc = new System.Xml.XmlDocument();
xdoc.Load(DataPath);

string xpath = " /Data " ;
System.Xml.XmlNode nodes = xdoc.SelectSingleNode(xpath);
System.Xml.XmlNode newnode = xdoc.CreateNode(System.Xml.XmlNodeType.Element, " Manufacturer " , string .Empty);

System.Xml.XmlElement elemid = xdoc.CreateElement( " ManufacturerID " );
System.Xml.XmlText textid = xdoc.CreateTextNode(manufacturer.Uid.ToString());
elemid.AppendChild(textid);
newnode.AppendChild(elemid);

System.Xml.XmlElement elemname = xdoc.CreateElement( " ManufacturerName " );
System.Xml.XmlText textname = xdoc.CreateTextNode(manufacturer.ManufacturerName);
elemname.AppendChild(textname);
newnode.AppendChild(elemname);

System.Xml.XmlElement elemcnname = xdoc.CreateElement( " MandarinName " );
System.Xml.XmlText textcnname = xdoc.CreateTextNode(manufacturer.MandarinName);
elemcnname.AppendChild(textcnname);
newnode.AppendChild(elemcnname);

System.Xml.XmlElement elemtime = xdoc.CreateElement( " CreateTime " );
System.Xml.XmlText texttime = xdoc.CreateTextNode(manufacturer.CreateTime.ToString());
elemtime.AppendChild(texttime);
newnode.AppendChild(elemtime);

nodes.AppendChild(newnode);

using (System.IO.StreamWriter sw = new System.IO.StreamWriter(DataPath, false , System.Text.Encoding.UTF8))
{
xdoc.Save(sw);
}
}

public void DeleteManufacturer(Guid id)
{
// 修改操作, 适合采用XPath进行操作
System.Xml.XmlDocument xdoc = new System.Xml.XmlDocument();
xdoc.Load(DataPath);

string xpath = " /Data/Manufacturer/ManufacturerID [text()=\" " + id.ToString() + " \"] " ;
System.Xml.XmlNode node = xdoc.SelectSingleNode(xpath);
if (node != null )
{
node.ParentNode.ParentNode.RemoveChild(node.ParentNode);
}
using (System.IO.StreamWriter sw = new System.IO.StreamWriter(DataPath, false , System.Text.Encoding.UTF8))
{
xdoc.Save(sw);
}
}

public void UpdateManufacturer(Manufacturer manufacturer)
{
// 修改操作, 适合采用XPath进行操作
System.Xml.XmlDocument xdoc = new System.Xml.XmlDocument();
xdoc.Load(DataPath);

string xpath = " /Data/Manufacturer/ManufacturerID [text()=\" " + manufacturer.Uid.ToString() + " \"] " ;
System.Xml.XmlNode node = xdoc.SelectSingleNode(xpath);
if (node != null )
{
node.NextSibling.FirstChild.Value = manufacturer.ManufacturerName;
node.NextSibling.NextSibling.FirstChild.Value = manufacturer.MandarinName;
}
using (System.IO.StreamWriter sw = new System.IO.StreamWriter(DataPath, false , System.Text.Encoding.UTF8))
{
xdoc.Save(sw);
}
}

public bool CheckManufacturerName( string manufacturername)
{
// 仅查找, 适合XPathDocument
System.Xml.XPath.XPathDocument xpd = new System.Xml.XPath.XPathDocument(DataPath);
System.Xml.XPath.XPathNavigator xnav = xpd.CreateNavigator();

// 定义XPath
string xpathstr = " /Data/Manufacturer/ManufacturerName [text()=\" " + manufacturername + " \"] " ;
System.Xml.XPath.XPathExpression xpath = System.Xml.XPath.XPathExpression.Compile(xpathstr);

System.Xml.XPath.XPathNavigator result = xnav.SelectSingleNode(xpath);
if (result == null )
{
return true ;
}
else
{
return false ;
}
}

#endregion
}
}

//实体类, Manufacturer.cs

View Code

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace MvcApplicationDemo
{
public class Manufacturer
{
public Guid Uid { get ; set ; }
public string ManufacturerName { get ; set ; }
public string MandarinName { get ; set ; }
public DateTime CreateTime { get ; set ; }

public Manufacturer()
{ }

public Manufacturer(Guid id, string manufacturername, string mandarinname, DateTime createtime)
{
this .Uid = id;
this .ManufacturerName = manufacturername;
this .MandarinName = mandarinname;
this .CreateTime = createtime;
}

public Manufacturer(Guid id, string manufacturername, DateTime createtime)
{
this .Uid = id;
this .ManufacturerName = manufacturername;
this .MandarinName = string .Empty;
this .CreateTime = createtime;
}
}
}

//Controllers/ManufacturerController.cs

View Code

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;

namespace MvcApplicationDemo.Controllers
{
public class ManufacturerController : Controller
{
// 通过接口来调用方法, 在初始化方法中用接口承载实现类
public IManufacturerManager ManufacturerService { get ; set ; }
protected override void Initialize(System.Web.Routing.RequestContext requestContext)
{
if ( this .ManufacturerService == null )
{
this .ManufacturerService = new ManufacturerManager();
}
base .Initialize(requestContext);
}

//
// GET: /Manufacturer/

public ActionResult Index()
{
IEnumerable < Manufacturer > manufacturers = this .ManufacturerService.GetAllManufacturers();
// 由于ManufacturerModel无法传递集合, 这里用ViewData传递集合数据
ViewData[ " manufacturers " ] = manufacturers;
return View();
}

//
// GET: /Manufacturer/Details/5

public ActionResult Details(Guid id) // 修改int类型为GUID
{
Manufacturer manufacturer = this .ManufacturerService.GetManufacturerByID(id);
return View(manufacturer); // 显示全部信息, 这里用实体类返回数据给View, 注意在View中注册Manufacturer类型
}

//
// GET: /Manufacturer/Create

public ActionResult Create() // Get方式
{
return View();
}

//
// POST: /Manufacturer/Create

[HttpPost]
public ActionResult Create(MvcApplicationDemo.Models.ManufacturerModel model) // 使用Model传递数据
{
if (ModelState.IsValid) // Model是否通过验证, 验证工作通过Model类的标注属性完成(服务器端验证)
{
try
{
// TODO: Add insert logic here
Manufacturer manufacturer = new Manufacturer(Guid.NewGuid(), model.ManufacturerName, model.MandarinName, DateTime.Now);
this .ManufacturerService.CreateManufacturer(manufacturer);
return RedirectToAction( " Index " );
}
catch
{
return View();
}
}
return View(model);
}

//
// GET: /Manufacturer/Edit/5

public ActionResult Edit(Guid id)
{
if (id != Guid.Empty)
{
Manufacturer manufacturer = this .ManufacturerService.GetManufacturerByID(id);
MvcApplicationDemo.Models.ManufacturerModel model = new MvcApplicationDemo.Models.ManufacturerModel();
model.ManufacturerName = manufacturer.ManufacturerName;
model.MandarinName = manufacturer.MandarinName;
return View(model); // 用Model返回数据
}
else
{
return View();
}
}

//
// POST: /Manufacturer/Edit/5

[HttpPost]
public ActionResult Edit(Guid id, MvcApplicationDemo.Models.ManufacturerModel model)
{
try
{
// TODO: Add update logic here
Manufacturer manufacturer = new Manufacturer();
manufacturer.Uid = id;
manufacturer.ManufacturerName = model.ManufacturerName;
manufacturer.MandarinName = model.MandarinName;
this .ManufacturerService.UpdateManufacturer(manufacturer);
return RedirectToAction( " Index " );
}
catch
{
return View();
}
}

//
// GET: /Manufacturer/Delete/5

public ActionResult Delete(Guid id)
{
if (id != Guid.Empty)
{
this .ManufacturerService.DeleteManufacturer(id);
}
return RedirectToAction( " Index " );
}

//
// POST: /Manufacturer/Delete/5

// [HttpPost] // 删除不需要Post方式
// public ActionResult Delete(Guid id, FormCollection collection)
// {
// try
// {
// // TODO: Add delete logic here
// if (id != null)
// {
// this.ManufacturerService.DeleteManufacturer(id);
// }
// return RedirectToAction("Index");
// }
// catch
// {
// return View();
// }
// }

// 添加自定义的Action
public ActionResult CheckManufacturerName( string manufacturername)
{
if ( ! string .IsNullOrEmpty(manufacturername))
{
// JsonResult专门用来返回Json对象
JsonResult jresult = new JsonResult();
jresult.JsonRequestBehavior = JsonRequestBehavior.AllowGet;
jresult.Data = this .ManufacturerService.CheckManufacturerName(manufacturername);
return jresult;
}
return View();
}
}
}

//Models/ManufacturerModel.cs

View Code

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace MvcApplicationDemo.Models
{
public class ManufacturerModel
{
[System.ComponentModel.DataAnnotations.Required]
[System.ComponentModel.DisplayName( " 制造商名称 " )] // 文本框前的文本信息, 需要配合LabelFor()
public string ManufacturerName { get ; set ; }

[System.ComponentModel.DataAnnotations.Required]
[System.ComponentModel.DisplayName( " 中文名称 " )]
public string MandarinName { get ; set ; }
}
}

//Views/Shared/Site.Master

View Code

<% @ Master Language = " C# " Inherits = " System.Web.Mvc.ViewMasterPage " %>

<! DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd" >
< html xmlns ="http://www.w3.org/1999/xhtml" >
< head runat ="server" >
< title >< asp:ContentPlaceHolder ID ="TitleContent" runat ="server" /></ title >
< link href ="http://www.cnblogs.com/Content/Site.css" rel ="stylesheet" type ="text/css" />

</ head >

< body >
< div class ="page" >

< div id ="header" >
< div id ="title" >
< h1 > My MVC Application </ h1 >
</ div >

< div id ="logindisplay" >
<% Html.RenderPartial( " LogOnUserControl " ); %>
</ div >

< div id ="menucontainer" >

< ul id ="menu" >
< li > <% = Html.ActionLink( " Home " , " Index " , " Home " ) %> </ li >
< li > <% = Html.ActionLink( " About " , " About " , " Home " ) %> </ li >
< li > <% = Html.ActionLink( " Manufacturer " , " Index " , " Manufacturer " ) %> </ li >
</ ul >

</ div >
</ div >

< div id ="main" >
< asp:ContentPlaceHolder ID ="MainContent" runat ="server" />

< div id ="footer" >
</ div >
</ div >
</ div >
</ body >
</ html >

//Views/Manufacturer/Index.aspx

View Code

<% @ Page Title = "" Language = " C# " MasterPageFile = " ~/Views/Shared/Site.Master " Inherits = " System.Web.Mvc.ViewPage " %>

<% @OutputCache Duration = " 1 " VaryByParam = " * " %>

< asp:Content ID ="Content1" ContentPlaceHolderID ="TitleContent" runat ="server" >
制造商
</ asp:Content >

< asp:Content ID ="Content2" ContentPlaceHolderID ="MainContent" runat ="server" >

< h2 > 制造商 </ h2 >
<% = Html.ActionLink( " 添加 " , " Create " ) %>
< hr />
<% var manufacturers = ViewData[ " manufacturers " ] as IEnumerable < MvcApplicationDemo.Manufacturer > ; %>
< table >
< tr >
< td > 制造商ID </ td >
< td > 制造商名称 </ td >
</ tr >
<%
foreach (var m in manufacturers)
{
%>
< tr >
< td > <% = Html.Encode(m.Uid) %> </ td > <% -- Encode用来防止用户直接输入Html元素 -- %>
< td > <% = Html.Encode(m.ManufacturerName) %> </ td >
< td > <% = Html.ActionLink( " 详细 " , " Details " , new { id = m.Uid } ) %> </ td >
< td > <% = Html.ActionLink( " 修改 " , " Edit " , new { id = m.Uid } ) %> </ td >
< td > <% = Html.ActionLink( " 删除 " , " Delete " , new { id = m.Uid } ) %> </ td >
</ tr >
<% } %>
</ table >
</ asp:Content >

//Views/Manufacturer/Details.aspx

View Code

<% @ Page Title = "" Language = " C# " MasterPageFile = " ~/Views/Shared/Site.Master " Inherits = " System.Web.Mvc.ViewPage<MvcApplicationDemo.Manufacturer> " %>

<% @OutputCache Duration = " 1 " VaryByParam = " * " %>

< asp:Content ID ="Content1" ContentPlaceHolderID ="TitleContent" runat ="server" >
制造商详情
</ asp:Content >

< asp:Content ID ="Content2" ContentPlaceHolderID ="MainContent" runat ="server" >

< h2 > 制造商详情 </ h2 >
<% = Html.ActionLink( " 修改 " , " Edit " , new { id = ViewData.Model.Uid} ) %>
<% = Html.ActionLink( " 返回 " , " Index " ) %>
< hr />
< ul >
< li > <% = Html.Encode(ViewData.Model.Uid) %> </ li >
< li > <% = Html.Encode(ViewData.Model.ManufacturerName) %> </ li >
< li > <% = Html.Encode(ViewData.Model.MandarinName) %> </ li >
< li > <% = Html.Encode(ViewData.Model.CreateTime) %> </ li >
<% --< li >< % = Html.Encode(ViewData.Eval( " CreateTime " )) %> </ li > --%>
</ ul >
</ asp:Content >

//Views/Manufacturer/Create.aspx

View Code

<% @ Page Title = "" Language = " C# " MasterPageFile = " ~/Views/Shared/Site.Master " Inherits = " System.Web.Mvc.ViewPage<MvcApplicationDemo.Models.ManufacturerModel> " %>

< asp:Content ID ="Content1" ContentPlaceHolderID ="TitleContent" runat ="server" >
添加制造商
</ asp:Content >

< asp:Content ID ="Content2" ContentPlaceHolderID ="MainContent" runat ="server" >

< h2 > 添加制造商 </ h2 >
<% Html.BeginForm(); %>
< fieldset >
< legend > 制造商信息 </ legend >
制造商名称: <% = Html.TextBoxFor(m => m.ManufacturerName) %>
<% = Html.ValidationMessageFor(m => m.ManufacturerName) %> < br />
中文名称: <% = Html.TextBoxFor(m => m.MandarinName) %>
<% = Html.ValidationMessageFor(m => m.MandarinName) %> < br />
< br />
< input type ="submit" value ="保存" />
</ fieldset >
<% Html.EndForm(); %>

</ asp:Content >

//Views/Manufacturer/Edit.aspx

View Code

<% @ Page Title = "" Language = " C# " MasterPageFile = " ~/Views/Shared/Site.Master " Inherits = " System.Web.Mvc.ViewPage<MvcApplicationDemo.Models.ManufacturerModel> " %>

<% @ OutputCache Duration = " 1 " VaryByParam = " * " %>
< asp:Content ID ="Content1" ContentPlaceHolderID ="TitleContent" runat ="server" >
Edit
</ asp:Content >
< asp:Content ID ="Content2" ContentPlaceHolderID ="MainContent" runat ="server" >
< h2 >
修改制造商信息 </ h2 >
<% = Html.ActionLink( " 返回 " , " Index " ) %>
<% Html.BeginForm(); %>
< fieldset >
< legend > 制造商信息 </ legend > 制造商名称:
<% = Html.TextBoxFor(m => m.ManufacturerName, new { id = " ManuName " }) %>
< span ></ span >
< br />
中文名称:
<% = Html.TextBoxFor(m => m.MandarinName) %>
< span ></ span >
< br />
< input type ="submit" value ="保存" />
</ fieldset >
<% Html.EndForm(); %>

< script src ="http://www.cnblogs.com/Scripts/jquery-1.4.1-vsdoc.js" type ="text/javascript" ></ script >

< script src ="http://www.cnblogs.com/Scripts/jquery.validate-vsdoc.js" type ="text/javascript" ></ script >

< script type ="text/javascript" >
// 关闭缓存的做法: 1.修改Url 2.设置Ajax关闭缓存 3.<OutputCache> 4.<META HTTP-EQUIV="Pragma" CONTENT="no-cache"><META HTTP-EQUIV="Expires" CONTENT="-1">
// $.ajax({
// cache: false
// });
$( function () {
// alert("hello");
$( " form " ).validate(
// 通过一个参数对象描述验证信息
{
rules: {
ManufacturerName: {
required: true ,
minlength: 2 ,
remote: ' <%=Url.Action("CheckManufacturerName") + "?" + DateTime.Now.ToLongTimeString() %> '
},
MandarinName: {
minlength: 2
}
},
messages: {
ManufacturerName: {
required: " 必须输入供应商名称 " ,
minlength: jQuery.format( " 供应商名称至少包含 {0} 个字符 " ),
remote: " 供应商已经存在，请检查名称。 "
},
MandarinName: {
minlength: jQuery.format( " 中文名称至少包含 {0} 个字符 " )
}
},
errorPlacement: function (error, element) {
error.appendTo(element.next( " span " ));
},
success: function (label) {
// set   as text for IE
label.html( "   " ).addClass( " checked " );
}
});
})
</ script >

</ asp:Content >

//Global.asax.cs

View Code

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using System.Web.Routing;

namespace MvcApplicationDemo
{
// Note: For instructions on enabling IIS6 or IIS7 classic mode,
// visit http://go.microsoft.com/?LinkId=9394801

public class MvcApplication : System.Web.HttpApplication
{
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
);

}

protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();

// 注册路由
RegisterRoutes(RouteTable.Routes);
}
}
}