分类： 嵌入式
2012-12-08 16:15:22
几种模式的代码如下：
简单工厂模式：
namespace FactoryMethod1
{
class Program
{
static void Main(string[] args)
{
LightSimpleFactory lsf = new LightSimpleFactory();
Light l = lsf.Create("绿灯");
l.TurnOn();
l.TurnOff();
Console .WriteLine ("____________");
l = lsf.Create("红灯");
l.TurnOn();
l.TurnOff();
Console.ReadLine();
}
//定义抽象类light
public abstract class Light
{
public abstract void TurnOn();
public abstract void TurnOff();
}
//定义RedLight，继承抽象类Light,然后实现TurnOn和TurnOff方法，代码如下：
public class RedLight:Light
{
public override void TurnOn()
{
Console .WriteLine ("开始生产红灯");
}
public override void TurnOff()
{
Console.WriteLine ("生产红灯结束！");
}
}
//定义GreenLight,继承抽象类Light，然后实现TurnOn 和TurnOff方法，代码如下：
public class GreenLight : Light
{
public override void TurnOn()
{
Console.WriteLine ("开始生产绿灯！");
}
public override void TurnOff()
{
Console.WriteLine("生产绿灯结束！");
}
}
//定义LightSimpleFactory类，该类实现工厂生产工作，故通过Create生产红灯和绿灯，代码如下：
public class LightSimpleFactory
{
public Light Create(string LightColor)
{
if (LightColor == "绿灯")
{
return new GreenLight();
}
else if (LightColor == "红灯")
{
return new RedLight();
}
else
{
return null;
}
}
}
}
工厂模式：
class Program
{
static void Main(string[] args)
{
Creator c1 = new RedLightCreator();
Creator c2 = new GreenLightCreator();
Light r1 = c1.factory();
Light g2 = c2.factory();
r1.TurnOn();
r1.TurnOff();
Console.WriteLine("------------------");
g2.TurnOn();
g2.TurnOff();
Console.ReadLine();
}
//定义抽象类，在抽象类中定义抽象方法
public abstract class Light
{
public abstract void TurnOn();
public abstract void TurnOff();
}
//在子类中实现父类的所有抽象方法，重写
public class RedLight : Light
{
public override void TurnOn()
{
Console .WriteLine ("开始生产红色灯泡！");
}
public override void TurnOff()
{
Console.WriteLine("生产红色灯泡结束！");
}
}
//在子类中实现父类的所以抽象方法，重写
public class GreenLight : Light
{
public override void TurnOn()
{
Console .WriteLine ("开始生产绿色灯泡！");
}
public override void TurnOff()
{
Console .WriteLine ("生产绿色灯泡结束！");
}
}
//定义抽象工厂
public abstract class Creator
{
public abstract Light factory();
}
public class RedLightCreator : Creator
{
public override Light factory()
{
return new RedLight ();
}
}
public class GreenLightCreator : Creator
{
public override Light factory()
{
return new GreenLight ();
}
}
}
抽象工厂模式：
namespace FactoryMethod1
{
class Program
{
static void Main(string[] args)
{
//创建并运行非洲动物世界
ContinentFactory africa = new AfricaFactory();
AnimalWorld world = new AnimalWorld(africa);
world.RunFoodChain();
//创建并运行美洲动物世界
ContinentFactory america = new AmericaFactory();
world = new AnimalWorld(america);
world.RunFoodChain();
Console.ReadLine();
}
}
abstract class ContinentFactory //抽象工厂（大陆）
{
abstract public Herbivore CreateHerbivore();//创建草食动物
abstract public Carnivore CreateCarnivore();//创建食肉动物
}
class AfricaFactory:ContinentFactory //具体工厂（非洲）
{
override public Herbivore CreateHerbivore()
{
return new Wildebeest();//羚羊
}
override public Carnivore CreateCarnivore()
{
return new Lion();//狮子
}
}
class AmericaFactory : ContinentFactory //具体工厂（美洲）
{
override public Herbivore CreateHerbivore()
{
return new Bison();//野牛
}
override public Carnivore CreateCarnivore()
{
return new Wolf();//狼
}
}
abstract class Herbivore //抽象产品（食草动物）
{
}
abstract class Carnivore //抽象产品（食肉动物）
{
abstract public void Eat(Herbivore h);
}
class Wildebeest : Herbivore //产品（羚羊）
{
}
class Lion : Carnivore //产品（狮子）
{
override public void Eat(Herbivore h)
{
//吃肉食
Console .WriteLine ("狮子吃：" + h);
}
}
class Bison : Herbivore //产品（野牛）
{
}
class Wolf : Carnivore //产品（狼）
{
//Methods
override public void Eat(Herbivore h)
{
//吃肉食
Console.WriteLine("狼吃 " + h);
}
}
class AnimalWorld //程序客户端
{
private Herbivore herbivore;//抽象产品--食草动物
private Carnivore carnivore;//抽象产品--食肉动物
public AnimalWorld(ContinentFactory factory)
{
carnivore = factory.CreateCarnivore();
herbivore = factory.CreateHerbivore();
}
public void RunFoodChain()
{
carnivore.Eat(herbivore);
}
}
}
1.为什么使用设计模式？
优点：设计模式是为了使设计适应变化。设计模式是重构的工具。设计一开始就要保持流畅、简单，并具有持续性。
缺点：不能过度使用设计模式。
使用设计模式的目的是为了适应未来的变化，变化之所以存在是因为一切的事务都具有不可预见性，如果具有可预见性，则不能称之为变化。如何判断哪种需求可能变化，哪些需求可能不变，并且最大程度上保持设计的流畅、简单，这些是工艺问题，而不是工程问题。既然是工艺问题，那么就只能给出原则，不能给出标准。使用设计模式的原则是：对未来既有可能发生的问题进行简单的修改、降低成本。
易维护的程序首先要易理解，这很重要。易理解的大吗才易于维护。过度的使用设计模式会增加程序的复杂性，让程序不易理解，从而降低程序的易维护性。
2.为什么使用架构？
可靠性。软件系统对于用户的商业经营和管理来说非常重要，因此软件系统必须非常可靠。
安全性。软件系统所承担的交易的商业价值极高，系统的安全性非常重要。
可扩展性。软件必须能够在用户的使用率、用户的数目增加很快的情况下，保持合理的性能。只有这样，才能适应用户市场扩展的可能性。
可定制性。同样的一套软件，可以根据用户群的不同和市场需求的变化进行调整。
可扩展性。在新技术出现的时候，一个软件系统应当允许导入新技术，从而对现有系统进行功能和性能的扩展。
可维护性。软件系统的维护包括两方面，一是排除现有的错误，二十将新的软件需求反映到现有系统中去。一个易于维护的系统可以有效的减低技术支持的花费。
客户体验。软件必须易于使用。
市场时机。软件用户要面临竞争，软件提供商也要面临竞争。以最快的速度争夺市场先机非常重要。
摘自《ASP.NET技术方案宝典》
