< ⇒⇒⇒ <
> ⇒⇒⇒ >
<html>
<body>
<p>You can give this a try below:</p>
<form action="http://google.com/complete/search" method="get"><div>
<input type="text" size="20" name="q" />
<input type="submit" value="Submit" />
<input type="hidden" name="output" value="toolbar" />
</div>
</form>
</body>
</html>
...
; Windows: "\path1;\path2"
include_path = ".;c:\php\includes;D:\ZendFramework-1.9.4\library\"
...
...
LoadModule rewrite_module modules/mod_rewrite.so
...
<Directory "C:\Program Files\Apache Software Foundation\Apache2.2\htdocs">
AllowOverride All
</Directory>
RewriteEngine on
RewriteBase /
RewriteRule !\.(js|ico|gif|jpg|png|css)$ index.php
<?php
require_once 'Zend/Version.php'; //库文件读入
echo Zend_Version::VERSION; //表示Zend Framework的版本信息
?>
+----------+
| Database |
+----------+
| mysql |
| test |
| user_db |
+----------+
+-------+------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+-------+------+------+-----+---------+-------+
| id | text | NO | | NULL | |
| model | text | YES | | NULL | |
| year | text | YES | | NULL | |
+-------+------+------+-----+---------+-------+
①「;extension=php_mysql.dll」将这句的注释放开。
②extension_dir设置为php目录下php_mysql.dll文件所在的路径。
例：extension_dir = "D:/php-5.2.11-Win32/ext/"
③重启Apache.
下面的网页访问刚才建立的car表并显示所有表内数据。
<htm>
<head>
<title> PHP Connect to MySql Test </title>
</head>
<body>
<?php
$username = "db_user";
$password = "123456";
$hostname = "localhost";
//connection to the database
$dbhandle = mysql_connect($hostname, $username, $password)
or die("Unable to connect to MySQL");
echo "Connected to MySQL<br>";
//select a database to work with
$selected = mysql_select_db("user_db",$dbhandle)
or die("Could not select user_db");
//execute the SQL query and return records
$result = mysql_query("SELECT id, model,year FROM cars");
//fetch tha data from the database
while ($row = mysql_fetch_array($result)) {
echo "ID:".$row{'id'}." Name:".$row{'model'}."Year: ". //display the results
$row{'year'}."<br>";
}
//close the connection
mysql_close($dbhandle);
?>
</body>
</html>
#
# Dynamic Shared Object (DSO) Support
#
# To be able to use the functionality of a module which was built as a DSO you
# have to place corresponding `LoadModule' lines at this location so the
# directives contained in it are actually available _before_ they are used.
# Statically compiled modules (those listed by `httpd -l') do not need
# to be loaded here.
#
# Example:
# LoadModule foo_module modules/mod_foo.so
#
LoadModule actions_module modules/mod_actions.so
LoadModule alias_module modules/mod_alias.so
LoadModule asis_module modules/mod_asis.so
LoadModule php5_module d:/php-5.2.11-Win32/php5apache2_2.dll
LoadModule php5_module d:/php-5.2.11-Win32/php5apache2.dll
#
# AddType allows you to add to or override the MIME configuration
# file specified in TypesConfig for specific file types.
#
#AddType application/x-gzip .tgz
#
# AddEncoding allows you to have certain browsers uncompress
# information on the fly. Note: Not all browsers support this.
#
#AddEncoding x-compress .Z
#AddEncoding x-gzip .gz .tgz
#
# If the AddEncoding directives above are commented-out, then you
# probably should define those extensions to indicate media types:
#
AddType application/x-compress .Z
AddType application/x-gzip .gz .tgz
AddType application/x-httpd-php .php
AddType application/x-httpd-php-source .phps
PHPIniDir "D:/php-5.2.11-Win32/"
//Singleton设计模式
class MainApp
{
static void Main()
{
//生成负荷均衡器对象
LoadBalancer b1 = LoadBalancer.GetLoadBalancer();
//取得负荷均衡器对象
LoadBalancer b2 = LoadBalancer.GetLoadBalancer();
//取得负荷均衡器对象
LoadBalancer b3 = LoadBalancer.GetLoadBalancer();
//取得负荷均衡器对象
LoadBalancer b4 = LoadBalancer.GetLoadBalancer();
// 判断是否是相同的负荷均衡器
if (b1 == b2 && b2 == b3 && b3 == b4)
{
Console.WriteLine("Same instance\n");
}
// 演示15次客户端的请求，每次请求，负荷均衡器随机提供一个服务进程Server。
LoadBalancer balancer = LoadBalancer.GetLoadBalancer();
for (int i = 0; i < 15; i++)
{
string server = balancer.Server;
Console.WriteLine("Dispatch Request to: " + server);
}
// Wait for user
Console.ReadKey();
}
}
/// 'Singleton'类：负荷均衡器类
class LoadBalancer
{
//静态成员变量，保存负荷均衡器类的实例对象。
private static LoadBalancer _instance;
//服务器进程队列。
private List_servers = new List ();
//随机数产生器，用来随机提供一个服务器进程
private Random _random = new Random();
// 同步对象
private static object syncLock = new object();
// 保护的构造函数，添加5个服务进程。
protected LoadBalancer()
{
//构建可用的服务
_servers.Add("ServerI");
_servers.Add("ServerII");
_servers.Add("ServerIII");
_servers.Add("ServerIV");
_servers.Add("ServerV");
}
//负荷均衡器的创建只能通过该函数生成。
public static LoadBalancer GetLoadBalancer()
{
//保证类的实例只有一个
if (_instance == null)
{
//保证类的生成和检测能一次执行完毕不受其他线程影响（支持多线程）
lock(syncLock)
{
//如果没有创建该实例则创建
if (_instance == null)
{
_instance = new LoadBalancer();
}
}
}
//返回类的实例。
return _instance;
}
// 随机取得一个服务进程。
public string Server
{
get
{
int r = _random.Next(_servers.Count);
return _servers[r].ToString();
}
}
}
/// Visitor 设计模式.
class MainApp
{
///
/// Entry point into console application.
///
static void Main()
{
//生成Tom的房子，初始化修理，家务，装修次数。
House h1 = new House("Tom's House", 0, 0, 0);
//Tom的房子接受修理工访问者。
h1.Accept(new FixerVisitor());
//Tom的房子接受家务工访问者。
h1.Accept(new HouseworkVisitor());
//Tom的房子接受装修工访问者。
h1.Accept(new DecorateVisitor());
//生成Marry的房子，初始化修理，家务，装修次数。
House h2 = new House("Mary's House", 1, 1, 1);
//Marry的房子接受修理工访问者。
h2.Accept(new FixerVisitor());
//Marry的房子接受家务工访问者。
h2.Accept(new HouseworkVisitor());
//Marry的房子接受装修工访问者。
h2.Accept(new DecorateVisitor());
Console.ReadKey();
}
}
//访问者(装修工，修理工，家务工等)的接口
interface IVisitor
{
void Visit(Element element);
}
//访问者：修理工
class FixerVisitor : IVisitor
{
//访问房子一次，将房子的修理次数加1并打印输出修理后的修理次数。
public void Visit(Element element)
{
House house = element as House;
house.FixCnt++;
Console.WriteLine("{0} 修理下水道的次数是：{1}", house.Name, house.FixCnt);
}
}
//访问者：家务工。
class HouseworkVisitor : IVisitor
{
//访问房子一次，将房子的做家务次数加1并打印输出做家务后的次数。
public void Visit(Element element)
{
House house = element as House;
house.HouseworkCnt++;
Console.WriteLine("{0} 做家务的次数是：{1}", house.Name, house.HouseworkCnt);
}
}
//访问者：装修工
class DecorateVisitor : IVisitor
{
//访问房子一次，将房子装修次数加1并输出装修后的装修次数。
public void Visit(Element element)
{
House house = element as House;
house.DecorateCnt++;
Console.WriteLine("{0} 装修的次数是：{1}", house.Name, house.DecorateCnt);
}
}
//访问元素(房子)的抽象基类
abstract class Element
{
public abstract void Accept(IVisitor visitor);
}
//具体的房子类: Accept接受访问者，并让访问者访问自己Visit(this)。
class House : Element
{
private string _name;
private int _fixCnt; //修下水道次数;
private int _houseworkCnt;//做家务次数;
private int _decorateCnt;//装修次数;
public House(string name, int fixCnt, int houseworkCnt, int decorateCnt)
{
this._name = name;
this._fixCnt = fixCnt;
this._houseworkCnt = houseworkCnt;
this._decorateCnt = decorateCnt;
}
public string Name
{
get { return _name; }
set { _name = value; }
}
public int FixCnt
{
get { return _fixCnt; }
set { _fixCnt = value; }
}
public int HouseworkCnt
{
get { return _houseworkCnt; }
set { _houseworkCnt = value; }
}
public int DecorateCnt
{
get { return _decorateCnt; }
set { _decorateCnt = value; }
}
//接受访问者
public override void Accept(IVisitor visitor)
{
visitor.Visit(this);
}
}
/// Chain of Responsibility 设计模式.
class MainApp
{
static void Main()
{
//建立责任者链
Approver larry = new Director();//主管
Approver sam = new VicePresident();//副总裁
Approver tammy = new President();//总裁
larry.SetSuccessor(sam);//设置主管的上级：副总裁
sam.SetSuccessor(tammy);//设置副总裁的上级总裁。
// 创建购买对象
Purchase p = new Purchase(2034, 350.00, "Supplies");
//将购买对象递交责任链上的主管
larry.ProcessRequest(p);
p = new Purchase(2035, 32590.10, "Project X");
larry.ProcessRequest(p);
p = new Purchase(2036, 122100.00, "Project Y");
larry.ProcessRequest(p);
Console.ReadKey();
}
}
//责任者(Handler)的抽象基类。
abstract class Approver
{
protected Approver successor;
//设置自己的上级
public void SetSuccessor(Approver successor)
{
this.successor = successor;
}
//批准的处理
public abstract void ProcessRequest(Purchase purchase);
}
//主管类。
class Director : Approver
{
public override void ProcessRequest(Purchase purchase)
{
//购买对象小于10000时，可批准。
if (purchase.Amount < 10000.0)
{
Console.WriteLine("{0} approved request# {1}",
this.GetType().Name, purchase.Number);
}
else if (successor != null)//超过1万让上级处理
{
successor.ProcessRequest(purchase);
}
}
}
//副总裁类
class VicePresident : Approver
{
public override void ProcessRequest(Purchase purchase)
{
//购买对象小于25000时，可批准。
if (purchase.Amount < 25000.0)
{
Console.WriteLine("{0} approved request# {1}",
this.GetType().Name, purchase.Number);
}
else if (successor != null)//超过25000时让上级处理。
{
successor.ProcessRequest(purchase);
}
}
}
//总裁类
class President : Approver
{
public override void ProcessRequest(Purchase purchase)
{
//购买对象小于10万时可批准。
if (purchase.Amount < 100000.0)
{
Console.WriteLine("{0} approved request# {1}",
this.GetType().Name, purchase.Number);
}
else//超过10万的购买对象须开会研究决定。
{
Console.WriteLine(
"Request# {0} requires an executive meeting!", purchase.Number);
}
}
}
//购买对象类。
class Purchase
{
private int _number;
private double _amount;
private string _purpose;
// Constructor
public Purchase(int number, double amount, string purpose)
{
this._number = number;
this._amount = amount;
this._purpose = purpose;
}
// Gets or sets purchase number
public int Number
{
get { return _number; }
set { _number = value; }
}
// Gets or sets purchase amount
public double Amount
{
get { return _amount; }
set { _amount = value; }
}
// Gets or sets purchase purpose
public string Purpose
{
get { return _purpose; }
set { _purpose = value; }
}
}
class MainApp
{
static void Main()
{
//用腰果装饰苹果味的冰激凌
DecoratorIcecream ice1 = new CashewNutsDecoratorIcecream(new AppleIcecream());
Console.Write(ice1.getName() + ice1.getSweet());
//用杏仁装饰桔子味的冰激凌
DecoratorIcecream ice2 = new AlmondDecoratorIcecream(new OrangeIcecream());
Console.Write("\n");
Console.Write(ice2.getName() + ice2.getSweet());
}
}
//冰激凌的抽象类。getName返回冰激凌的名字，getSweet返回冰激凌的冰的味道。
abstract class Icecream
{
public abstract string getName();
public abstract string getSweet();
}
//苹果味的冰激凌
class AppleIcecream : Icecream
{
public override string getName()
{
return "苹果冰激凌。";
}
public override string getSweet()
{
return "苹果味。";
}
}
//桔子味的冰激凌
class OrangeIcecream : Icecream
{
public override string getName()
{
return "桔子冰激凌。";
}
public override string getSweet()
{
return "桔子味。";
}
}
//装饰类的抽象类
abstract class DecoratorIcecream
{
public abstract string getName();
public abstract string getSweet();
}
//用腰果装饰的类
class CashewNutsDecoratorIcecream : DecoratorIcecream
{
protected Icecream ice;
public CashewNutsDecoratorIcecream(Icecream ice)
{
this.ice = ice;
}
public override string getName()
{
return "腰果" + ice.getName();
}
public override string getSweet()
{
return ice.getSweet();
}
}
//用杏仁装饰的类
class AlmondDecoratorIcecream : DecoratorIcecream
{
protected Icecream ice;
public AlmondDecoratorIcecream(Icecream ice)
{
this.ice = ice;
}
public override string getName()
{
return "杏仁" + ice.getName();
}
public override string getSweet()
{
return ice.getSweet();
}
}
static void Main()
{
/*构建一个下图所示的目录结构，-的长短代表目录的层次。
* -root
* ---File A
* ---File B
* ---Directory
* -----File XA
* -----File XB
* ---File C
*/
Directory root = new Directory("root");
root.Add(new File("File A"));
root.Add(new File("File B"));
Directory comp = new Directory("Directory X");
comp.Add(new File("File XA"));
comp.Add(new File("File XB"));
root.Add(comp);
root.Add(new File("File C"));
// Add and remove a File
File file = new File("File D");
root.Add(file);
root.Remove(file);
// Recursively display tree
root.Display(1);
// Wait for user
Console.ReadKey();
}
}
//文件和目录的共同抽象类-->将文件和目录看作同一个事物的基础
//定义了 添加 删除 显示接口
abstract class Component
{
protected string name;
// Constructor
public Component(string name)
{
this.name = name;
}
public abstract void Add(Component c);
public abstract void Remove(Component c);
public abstract void Display(int depth);
}
//实现目录类
class Directory : Component
{
//定义了一个序列，用来放Componet(文件/目录)。
private List_children = new List ();
// Constructor
public Directory(string name)
: base(name)
{
}
//向目录中添加文件或目录
public override void Add(Component component)
{
_children.Add(component);
}
//从目录中移除文件或目录
public override void Remove(Component component)
{
_children.Remove(component);
}
//递归显示该目录下的所有文件或目录。
public override void Display(int depth)
{
Console.WriteLine(new String('-', depth) + name);
// Recursively display child nodes
foreach (Component component in _children)
{
component.Display(depth + 2);
}
}
}
//实现文件类
class File : Component
{
// Constructor
public File(string name)
: base(name)
{
}
//文件中不能添加文件。
public override void Add(Component c)
{
Console.WriteLine("Cannot add to a file");
}
//文件只能从目录中移除。
public override void Remove(Component c)
{
Console.WriteLine("Cannot remove from a File");
}
//显示文件路径
public override void Display(int depth)
{
Console.WriteLine(new String('-', depth) + name);
}
}
class Human
{
private string _name;
public string Name { get;set;}
private int _age = -1;
public int Age { get;set;}
private int _hight = -1;
public int Hight { get;set;}
private int _weight = -1;
public int Weight { get;set;}
public Human(string name, int age, int hight, int weight)
{
_name = name;
_age = age;
_hight = hight;
_weight = weight;
}
}
class MyClass
{
int _comparetype = -1;
public void SetCompareType(int type)
{
_comparetype = type;
}
public int Compare(Human h1, Human h2)
{
if (_comparetype == 1)//年龄par
{
if (h1.Age > h2.Age)
{
return 1;
}
else if (h1.Age < h2.Age)
{
return -1;
}
else
return 0;
}
if (_comparetype == 2) //体重
{
//・・・・
}
}
}
public class Human
{
private string _name;
public string Name { get { return _name; } set { _name = value; } }
private int _age = -1;
public int Age { get { return _age; } set { _age = value; } }
private int _height = -1;
public int Height { get { return _height; } set { _height = value; } }
private int _weight = -1;
public int Weight { get { return _weight; } set { _weight = value; } }
public Human(string name, int age, int hight, int weight)
{
_name = name;
_age = age;
_height = hight;
_weight = weight;
}
}
//战略部接口
public interface Comparator
{
int compare(Human h1, Human h2);
}
public class AgeComparator : Comparator
{
public int compare(Human h1, Human h2)
{
if (h1.Age > h2.Age)
{
return 1;
}
else if (h1.Age == h2.Age)
{
return 0;
}
else
{
return -1;
}
}
}
public class HeightComparator : Comparator
{
public int compare(Human h1, Human h2)
{
if (h1.Height > h2.Height)
{
return 1;
}
else if (h1.Height == h2.Height)
{
return 0;
}
else
{
return -1;
}
}
public class MyClass
{
private Comparator comparator = null;
public MyClass(Comparator comparator)
{
this.comparator = comparator;
}
public int compare(Human h1, Human h2)
{
return comparator.compare(h1, h2);
}
}
class ProgramTest
{
static void Main(string[] args)
{
Human h1 = new Human("Tom", 21, 178, 60);
Human h2 = new Human("Jack", 22, 268, 56);
AgeComparator a = new AgeComparator();
MyClass m = new MyClass(a);
int i = m.compare(h1, h2);
Console.WriteLine("比较结果：" + i);
}
}
}
abstract class Sorter{
public void sort(Object obj[]);
}
public class QuickSorter: Sorter{
public void sort(Object obj[]){
// 用快速排序排列 obj[]
・・・・
}
}
public class BubbleSorter : Sorter{
public void sort(Object obj[]){
// 用冒泡排序排列obj[]
・・・・
}
}
abstract class TimerSorter:Sorter{
public void timerSorter(Object obj[]){
long start = System.currentTimeMillis();
sort(obj);
long end = System.currentTimeMillis();
System.out.println("time:"+(end - start));
}
abstract class Sorter{
private SortImple sortImple;
public Sorter(SortImple sortImple){
this.sortImple = sortImple;
}
public void sort(Object obj[]){
sortImple.sort(obj);
}
}
Abstract SortImple {
Public void sort(Object obj[]);
}
public class QuickSortImple: SortImple{
pubic void sort(Object obj[]){
// 用快速排序排列 obj[]
・・・・
}
}
public class BubbleSortImple: SortImple {
pubic void sort(Object obj[]){
// 用冒泡排序排列obj[]
・・・・
}
}
public class TimerSorter : Sorter{
public TimerSorter(SortImple sortImple){
super(sortImple);
}
public void timerSort(Object obj[]){
long start = System.currentTimeMillis();
sort(obj);
long end = System.currentTimeMillis();
System.out.println("time:"+(end - start));
}
}
//类：食盐水，有两个属性：salt，water；构造函数决定食盐和水的量。
public class SaltWater
{
public SaltWater(double water, double salt)
{
this._salt = salt;
this._water = water;
}
public double salt
{
get { return _salt; }
set { _salt = value; }
}
public double water
{
get { return _water; }
set { _water = value; }
}
private double _salt;
private double _water;
}
//接口Builder，决定表现形式。有个接口
public interface Builder
{
void addSolute(int soluteAmount);//添加溶剂
void addSoluvent(int solventAmount);//添加溶质
void abandonSolution(int solutionAmount);//倒掉一部分溶液
SaltWater getResult();//取得配置溶液。
}
//类Director，决定生成过程。
public class Director
{
private Builder builder;
public Director(Builder builder)//构造函数：生成表现形式。
{
this.builder = builder;
}
public void constract()//配置本例食盐水的过程。
{
builder.addSoluvent(100);
builder.addSolute(40);
builder.abandonSolution(70);
builder.addSoluvent(100);
builder.addSolute(15);
}
}
//实现接口Builder，食盐水。
public class SaltWaterBuilder: Builder
{
private SaltWater saltWater;
public SaltWaterBuilder(){
this.saltWater = new SaltWater(0,0);
}
public void addSolute(int saltAmount){
saltWater.salt += saltAmount;
}
public void addSoluvent(int waterAmount){
saltWater.water += waterAmount;
}
public void abandonSolution(int saltWaterAmount){
saltWater.salt *= 1 - saltWaterAmount / (saltWater.salt + saltWater.water);
saltWater.water *= 1 - saltWaterAmount / (saltWater.salt + saltWater.water);
}
public SaltWater getResult(){
return this.saltWater;
}
}
//Test
public static void Main()
{ //创建表现形式
Builder builder = new SaltWaterBuilder();
//创建生产过程。
Director dir = new Director(builder);
//生产
dir.constract();
//取得生产结果，配置好的食盐水。
SaltWater saltWater = (SaltWater)builder.getResult();
Console.Write(saltWater.salt/saltWater.water * 100 +"%");
}
using System;
namespace Structural
{
// MainApp test application
class MainApp
{
static void Main()
{
// Create two instances and clone each
ConcretePrototype1 p1 = new ConcretePrototype1("I");
ConcretePrototype1 c1 = (ConcretePrototype1)p1.Clone();
Console.Write(p1.Id + "\n");
Console.Write(c1.Id + "\n");
// Wait for user
Console.Read();
}
}
// "Prototype"
abstract class Prototype
{
private string id;
// Constructor
public Prototype(string id)
{
this.id = id;
readXML();
}
// Property
public string Id
{
get { return id; }
}
public abstract Prototype Clone();
protected abstract void readXML();
}
// "ConcretePrototype1"
class ConcretePrototype1 : Prototype
{
// Constructor
public ConcretePrototype1(string id)
: base(id)
{
}
public override Prototype Clone()
{
// Shallow copy
return (Prototype)this.MemberwiseClone();
}
protected override void readXML()
{
Console.Write("read xml \n" );
}
}
}
public interface IGateway
{
string GetCSVCustomers();
}
public class MoolahGateway
{
public ListGetCustomers()
{
ListlistCustomers = new List ();
listCustomers.Add("Bob Smith");
listCustomers.Add("Chris Thomas");
listCustomers.Add("Dave Mathews");
return listCustomers;
}
}
public class MoolahGatewayAdapter : IGateway
{
private MoolahGateway _moolahGateway = new MoolahGateway();
string IGateway.GetCSVCustomers()
{
ListlistCustomers = _moolahGateway.GetCustomers();
StringBuilder csvCustomers = new StringBuilder();
foreach (string item in listCustomers)
{
csvCustomers.Append(item);
csvCustomers.Append(",");
}
return csvCustomers.ToString().TrimEnd(',');
}
}
class Program
{
static void Main(string[] args)
{
IGateway gateway = new MoolahGatewayAdapter();
Console.WriteLine(gateway.GetCSVCustomers());
}
}
///
/// Entry point into console application.
///
static void Main()
{
ConcreteAggregate a = new ConcreteAggregate();
a[0] = "Item A";
a[1] = "Item B";
a[2] = "Item C";
a[3] = "Item D";
// Create Iterator and provide aggregate
//ConcreteIterator i = new ConcreteIterator(a);
Iterator i = a.CreateIterator();
Console.WriteLine("Iterating over collection:");
object item = i.First();
while (item != null)
{
Console.WriteLine(item);
item = i.Next();
}
// Wait for user
Console.ReadKey();
}
}
///
/// The 'Aggregate' abstract class
///
abstract class Aggregate
{
public abstract Iterator CreateIterator();
}
///
/// The 'ConcreteAggregate' class
///
class ConcreteAggregate : Aggregate
{
private ArrayList _items = new ArrayList();
public override Iterator CreateIterator()
{
return new ConcreteIterator(this);
}
// Gets item count
public int Count
{
get { return _items.Count; }
}
// Indexer
public object this[int index]
{
get { return _items[index]; }
set { _items.Insert(index, value); }
}
}
///
/// The 'Iterator' abstract class
///
abstract class Iterator
{
public abstract object First();
public abstract object Next();
public abstract bool IsDone();
public abstract object CurrentItem();
}
///
/// The 'ConcreteIterator' class
///
class ConcreteIterator : Iterator
{
private ConcreteAggregate _aggregate;
private int _current = 0;
// Constructor
public ConcreteIterator(ConcreteAggregate aggregate)
{
this._aggregate = aggregate;
}
// Gets first iteration item
public override object First()
{
return _aggregate[0];
}
// Gets next iteration item
public override object Next()
{
object ret = null;
if (_current < _aggregate.Count - 1)
{
ret = _aggregate[++_current];
}
return ret;
}
// Gets current iteration item
public override object CurrentItem()
{
return _aggregate[_current];
}
// Gets whether iterations are complete
public override bool IsDone()
{
return _current >= _aggregate.Count;
}
}
public static void Main()
{
//白色套装工厂
AbstractSuiteFactory whiteFactory = new ConcreteWhiteSuiteFactory();
Client client1 = new Client(whiteFactory);
client1.Run();
//黑色套装工厂
AbstractSuiteFactory blackFactory = new ConcreteBlackSuiteFactory();
Client client2 = new Client(blackFactory);
client2.Run();
Console.ReadKey();
}
}
//抽象套装工厂
abstract class AbstractSuiteFactory
{
//上衣
public abstract AbstractCoat CreateCoat();
//裤子
public abstract AbstractTrouses CreateTrouses();
}
//具体的，白色套装工厂
class ConcreteWhiteSuiteFactory : AbstractSuiteFactory
{
//制作白色上衣
public override AbstractCoat CreateCoat()
{
return new WhiteCoat();
}
//制作白色裤子
public override AbstractTrouses CreateTrouses()
{
return new WhiteTrouses();
}
}
//黑色套装工厂
class ConcreteBlackSuiteFactory : AbstractSuiteFactory
{
//制作黑色上衣
public override AbstractCoat CreateCoat()
{
return new BlackCoat();
}
//制作黑色裤子
public override AbstractTrouses CreateTrouses()
{
return new BlackTrouses();
}
}
//抽象上衣
abstract class AbstractCoat
{
}
//抽象裤子
abstract class AbstractTrouses
{ //将上衣和裤子搭配成一套
public abstract void Interact(AbstractCoat a);
}
//具体的白色上衣
class WhiteCoat : AbstractCoat
{
}
//具体的白色裤子
class WhiteTrouses : AbstractTrouses
//搭配上衣和裤子
{ public override void Interact(AbstractCoat a)
{
Console.WriteLine(this.GetType().Name +" interacts with " + a.GetType().Name);
}
}
//具体的黑色上衣
class BlackCoat : AbstractCoat
{
}
//具体的黑色裤子
class BlackTrouses : AbstractTrouses
{
//搭配上衣和裤子
public override void Interact(AbstractCoat a)
{
Console.WriteLine(this.GetType().Name + " interacts with " + a.GetType().Name);
}
}
class Client //在这个类中，其实又用到了工厂方法。
{
//客户类：构造抽象工厂，生产抽象产品。实例化在具体应用时。
private AbstractCoat _abstractCoat;
private AbstractTrouses _abstractTrouses;
// Constructor
public Client(AbstractSuiteFactory factory)
{
_abstractTrouses = factory.CreateTrouses();
_abstractCoat = factory.CreateCoat();
}
public void Run()
{
_abstractTrouses.Interact(_abstractCoat);
}
abstract class Dishes
{
public abstract string getDishes();
}
class ChineseDishes : Dishes
{
public override string getDishes()
{
return "Step1 -> Step2 -> Step3 --> Chinese Dishes.\n";
}
}
class FranceDishes : Dishes
{
public override string getDishes()
{
return "StepA -> StepB -> StepC --> France Dishes.\n";
}
}
abstract class DishFactory
{
public abstract Dishes factoryMethod();
public void makeDishes()
{
Dishes dishes = this.factoryMethod();
Console.Write(dishes.getDishes());
}
}
class ChineseDishFactory : DishFactory
{
public override Dishes factoryMethod()
{
return new ChineseDishes();
}
}
class FranceDishFactory : DishFactory
{
public override Dishes factoryMethod()
{
return new FranceDishes();
}
}
public static void Main()
{
DishFactory cdf = new ChineseDishFactory();
cdf.makeDishes();
DishFactory fdf = new FranceDishFactory();
fdf.makeDishes();
}
abstract class TemplateCooking
{
public virtual void AddOil() //虚拟函数，如果想放花生油以外的油，可以改写。否则可以不写。
{ Console.Write("放入花生油\n"); }
public abstract void AddCondiments(); //放佐料，抽象函数，必须重写。
public abstract void AddBase(); //放入主料，抽象函数，必须重写。
public virtual void HeatUp() //加热，虚拟函数，如果用其他方式加热可以改写。
{ Console.Write("用煤气灶加热\n"); }
public virtual void OutPut() ////出锅，如果不是放到盘子里，可以改写。
{ Console.Write("盛到盘子中\n"); }
public void Cook() //保证正确的顺序。
{
AddOil(); AddCondiments(); AddBase(); HeatUp(); OutPut();
}
}
//下面制作一个炒青椒肉丝的类。
class CookPepper: TemplateCooking
{
public override void AddOil() { Console.Write("放色拉油\n"); } //改用色拉油。
public override void AddCondiments() { Console.Write("放入花椒\n"); } //这个是必须实现的接口
public override void AddBase() { Console.Write("放入肉丝，青椒\n"); } //这个是必须实现的接口
//其他的加热，出锅 不改变。
}
public static void Main()
{
CookPepper cookPepper = new CookPepper();
cookPepper.Cook(); //保证按部就班准确的做好菜。
}
class PcMakerA //电脑厂家
{
repairMainBoard();{}//修理主板
repairMonitor();{}//修理显示器
}
class ServiceCenterB //售后服务代理
{
repairMouse();{} //修鼠标
repariKeyboard();{}//修键盘
repairMainBoard(){}//修主板(自己修不了，让厂家去修：我只是代理)
{
pcMakerA = New PcMakerA();
pcMakerA.repairMainBoard();
}
repairMonitor()//修显示器(自己修不了，让厂家去修：我只是代理)
{
pcMakerA = New PcMakerA();
pcMakerA.repairMonitor();
}
}
class Client //顾客
{
serviceCenter = new ServiceCenterB();
serviceCenter.repairMainBoard();//给我修主板
serviceCenter.repariKeyboard();//给我修键盘
}
public class Girl
{
//代表心情好
private static int STATE_ORDINARY = 0;
//代表心情坏
private static int STATE_IN_BAD_MOOD = 1;
//心情状态，初期为-1
private int state = -1;
//改变心情状态
public void changeState(int state)
{
this.state = state;
}
//对邀请看电影的后的反应动作。
public string invite()
{
if (state == STATE_ORDINARY)
{
return "好呀";
} else if (state == STATE_IN_BAD_MOOD)
{
return "讨厌";
} else
{
return "...";
}
}
public class StatePatternGirl
{
private State state = null;
private void changeState(State state)
{
this.state = state;
}
public string invite()
{
return this.state.invite();
}
}
//状态的接口，动作在具体状态类中实现。
interface State
{
public string invite();
}
class BadMoodState : State
{
public string invite()
{
return "去喝咖啡吧";
}
}
class OrdinaryState : State
{
public string morningGreet()
{
return "好高兴呀";
}
}
///pure C DLL
#include "windows.h"
#define DLLEXPORT __declspec(dllexport)
extern "C"
{
DLLEXPORT int __stdcall timeChange(void (*onTimeChange)())
{
return onTimeChange();
}
}
///C#
class DLL
{
[DllImport"ctimechange.dll", CallingConvention = CallingConvention.StdCall)]
public static extern int timeChange(DOnTimeChange cb);
public delegate int DOnTimeChange();
public static void main()
{
DOnTimeChange cb = new DOnTimeChange(OnTimeChange);
timeChange(cb);
}
public static void OnTimeChange()
{
console.write("time changed");
}
}
