关于工厂、单体、适配器、策略、观察者没啥好说的, 代码中有说明
//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="FactoryStrategy" value="DesignPattern.Factory.Desktop,DesignPattern"/>
-->
< add
key
="Strategy"
value
="DesignPattern.Bike,DesignPattern"
/>
<!-- 可选MoterBicycle,car
-->
<!-- 策略模式配置文件
-->
< 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标签中, 添加如下内容:
<META HTTP-EQUIV="pragma" CONTENT="no-cache">
<META HTTP-EQUIV="Cache-Control" CONTENT="no-cache, must-revalidate">
<META HTTP-EQUIV="expires" CONTENT="Wed, 26 Feb 1997 08:21:57 GMT">
//实例代码如下:
//数据文件, App_Data/ManufacturerData.xml
View Code
<? xml versinotallow="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 ="" 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 ="" type ="text/javascript" ></ script >
< script src ="" 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);
}
}
}本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
