工厂方法模式是一种类创建型模式.在工厂方法模式中,工厂父类负责定义创建产品对象的公共接口,工厂子类则负责生成具体的产品对象,这样做的目的是将产品类的实例化操作延迟到工厂子类中完成,即通过工厂子类来确定究竟应该实例化哪一个具体产品类.

工厂方法模式包含以下4个角色:

(1)抽象产品:它是定义产品的接口.

(2)具体产品:它是实现抽象产品的接口的类.

(3)抽象工厂:在抽象工厂类或接口中声明了工厂方法,用于返回一个产品.抽象工厂是工厂方法模式的核心,所有创建对象的工厂类都必须实现该接口.

(4)具体工厂:它是抽象工厂类的子类.

以下为一个实例的演示代码:

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

namespace ConsoleApplication2
{
 interface Logger//抽象产品接口
 {
 void WriteLog();
 }
 class DatabaseLogger : Logger//数据库日志记录类
 {
 public void WriteLog()
 {
 Console.WriteLine("数据库日志记录");

}

 }
 class FileLogger : Logger//文件日志记录类
 {
 public void WriteLog()
 {
 Console.WriteLine("文件日志记录");

}

}

interface LoggerFactory//抽象工厂接口
 {

Logger CreateLogger();//抽象工厂方法

}
 class DatabaseLoggerFactory : LoggerFactory//数据库日志记录工厂类
 {
 public Logger CreateLogger()
 {
 Logger logger = new DatabaseLogger();

return logger;

}

 }
 class FileLoggerFactory : LoggerFactory//文件日志记录工厂类
 {

public Logger CreateLogger()
 {
 Logger logger = new FileLogger();

return logger;
 }

}
 class Program
{

 static void Main(string[] args)
 {
 LoggerFactory factory;//定义抽象工厂类对象引用;
 Logger logger;//定义产品抽象类对象引用;
 factory = new FileLoggerFactory();//创建文件日志记录工厂对象;
 logger = factory.CreateLogger();//创建文件日志记录对象
 logger.WriteLog();
 factory = new DatabaseLoggerFactory();//创建数据库日志记录工厂对象;
 logger = factory.CreateLogger();//创建数据库日志记录对象
 logger.WriteLog();
 Console.ReadKey();

}

 }
}

运行结果如下:

• 之前一直不是很清楚IEnumerable和IEnumerator 具体区别 今天特地为此编写了一个自己 枚举类 继承自IEnumerable和IEnumerator 接口,我发现如果只继承IEnumerable而不继承IEnumerator 接口 是不可以实现foreach循环访问的因为使用foreach循环必须实现GetEumerator函数.IEnumerable是声明该类可以使用foreach循环访问,而IEnumerator是枚举器具体实现,也就是说 如果类继承了IEnumerable接口则表明此类对象是可以枚举的,具体怎么枚举则需要继承并实现IEnumerator接口.

public IEnumerator GetEnumerator()
{

return (IEnumerator)this;

}

另外我还发现,IEnumerator 接口的2个函数和一个属性 中 MoveNext()是自动调用执行的,Current是自动访问的,而且顺序是 使用foreach循环时首先执行MoveNext()函数把索引往后移一位,然后访问Current当前属性的值.所以当你继承这2个接口时索引定义要从 -1开始这样第一个访问的才能是数组索引为零的元素.

以下是我的实验代码和结果:

using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 using System.Collections;
 namespace test
 {
 struct point
 {
 public int x;
 public int y;
 public int z;
 }

class Myenum : IEnumerable, IEnumerator
 {
 private int index;
 private point[] points;

public Myenum(int numofpoint)
 {
 this.index = -1;
 points = new point[numofpoint];

for (int i = 0; i < points.Length; i++)
 {
 points[i].x = i;
 points[i].y = i * i;
 points[i].z = i * i * i;
 }
 }
 public IEnumerator GetEnumerator()
 {

return (IEnumerator)this;

}
 public object Current
 {
 get
 {
 Console.WriteLine("Current");
 return points[index];
 }
 }
 public bool MoveNext()
 {

index++;

if (index < points.Length&&index>=0)
 {
 Console.WriteLine("MoveNext()");
 return true;
 }
 else
 return false;

}
 public void Reset()
 {
 index = -1;
 Console.WriteLine("Reset()");
 }

}
 class Program
 {
 static void Main(string[] args)
 {

Myenum enum1 = new Myenum(5);

foreach (point p in enum1)
 {
 Console.WriteLine("(" + p.x.ToString() + "," + p.y.ToString() + "," + p.z.ToString() + ")");
 }

Console.Read();

}
 }
 }

1.readonly 保护的是变量的位置不会在构造函数之外被改变.

2.c#的参数类型有4种:值参数,引用参数,输出参数和参数数组.

3.输出参数声明的修饰符是out,out参数是用ref参数加上元数据里的一个特殊属性.

4.参数数组允许向方法传递不定长的参数,声明它的修饰符是params,只有方法的最后一个参数才可以是参数数组,并且参数数组的类型必须是一维的数组.

5.在声明抽象方法时要加上abstract修饰符,并且只允许在同样被声明为abstract的类中声明抽象方法,所有非抽象的继承类都必须重写抽象方法.

6.如果构造函数的声明包含了static 修饰符,它就变成了一个静态的构造函数.

7.属性是字段的一种自然延伸,属性不代表存储的位置,它只是提供了访问的机制.

8.结构体是值类型,一个构造类型的变量之间存储了结构的数据,而一个类类型保存的是指向动态分配对象的引用.