情人就是指针,用的时候一定要注意，要不然就带来巨大的灾难

     1.C#基础知识

     2.了解WCF基础知识

     在正常的c#开发中我们是允许用子类去替换基类的，这也是所谓的替换原则。但是我们在WCF中确不能用数据契约的子类来替换父类的，因为这中间存在一个序列化的问题。举个例子：

     我们有数据契约：

          [DataContract]

          class Employee{...}

     服务契约中：

          [ServiceContract]

          interface IEmployeeManager

          {

               [OperationContract]

               void AddEmployee(Employee employee);

          }

     然后我们在客户端的代理中就算有类：Intern继承于

          [DataContract]

          class Intern:Employee{...}

     然后再客户端调用时：

          proxy.AddEmployee(new Intern())是会出错的。因为在服务器端无法识别Intern对象，因为他无法去反序列化Intern成Employee对象(WCF序列化)。

     WCF提供给我们了一个解决的办法就是使用KnownTypeAttribute特性，在基类上标识对应的子类就可以了。KnownTypeAttribute特性可以使用在Struct跟Class上。示例：

          [DataContract]

          [KnownType(typeof(Customer))]

          class Employee{...}

          [DataContract]

          class Intern:Employee{...}

这样我们就在所有的契约跟操作上，能跨越所有的服务和终结点，允许服务接受子类。但是这样会遇到一个问题，我们不能去特定的指定某一个服务操作，所以KnownType的缺陷就是范围过于广泛。WCF提供了另外一个Attribute--ServiceKnownType.

ServiceKnownType 特性

     KnownType只能应用在数据契约的基类上，而ServiceKnownType可以在Interface、Method、Class上标识。看一个示例Employee.cs：

Code
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ServiceModel;
using System.Runtime.Serialization;

namespace HenllyeeDataContract
{
    [DataContract]
    public class Employee
    {
        #region Fields
        private string _name;
        private int _age;
        #endregion

        #region Properties
        /// <summary>
        /// The employee's name
        /// </summary>
        [DataMember(Order=0)]
        public string Name
        {
            get 
            {
                return this._name;
            }
            set
            {
                this._name = value;
            }
        }

        /// <summary>
        /// The employee's age
        /// </summary>
        [DataMember(Order=1)]
        public int Age
        {
            get
            {
                return this._age;
            }
            set
            {
                this._age = value;
            }
        }
        #endregion
    }

    [DataContract]
    public class Intern : Employee
    {
        private int _internship;

        /// <summary>
        /// The intern's working days
        /// </summary>
        [DataMember]
        public int Internship
        {
            get
            {
                return this._internship;
            }
            set
            {
                this._internship = value;
            }
        }
    }
}

在数据契约中我们并没有去指定KnownType，我们在服务契约的操作上去标识ServiceKnownType特性，EmployeeManage.cs:

Code
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ServiceModel;
using System.Runtime.Serialization;

namespace HenllyeeServiceContract
{
    [ServiceContract]
    public interface IEmployeeManage
    {
        [OperationContract]
        [ServiceKnownType(typeof(HenllyeeDataContract.Intern))]
        void AddEmployee(HenllyeeDataContract.Employee emlpoyee);

        [OperationContract]
        [ServiceKnownType(typeof(HenllyeeDataContract.Intern))]
        HenllyeeDataContract.Employee GetEmployee();
    }

    [ServiceBehavior(InstanceContextMode=InstanceContextMode.Single)]
    public class EmployeeManage : IEmployeeManage
    {
        private HenllyeeDataContract.Employee _employee;

        /// <summary>
        /// Set employee
        /// </summary>
        /// <param name="emlpoyee">the employee's object</param>
        public void AddEmployee(HenllyeeDataContract.Employee emlpoyee)
        {
            this._employee = emlpoyee;
        }

        /// <summary>
        /// Get a employee
        /// </summary>
        /// <returns></returns>
        public HenllyeeDataContract.Employee GetEmployee()
        {
            return this._employee;
        }
    }
}

在客户端我们调用：

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

namespace Client
{
    class Program
    {
        static void Main(string[] args)
        {
            EmployeeService.EmployeeManageClient proxy = new Client.EmployeeService.EmployeeManageClient();
            EmployeeService.Intern intern = new Client.EmployeeService.Intern();
            intern.Age = 22;
            intern.Name = "Henllyee Cui";
            intern.Internship = 120;
            proxy.AddEmployee(intern);

            EmployeeService.Employee internOut = proxy.GetEmployee();
            Console.Write("The Employee Name:{0}\nAge:{1}\n",
                internOut.Name,
                internOut.Age
                );
            Console.Read();
        }
    }
}

运行后： 

     ServiceKnownType特性也可以表示在数据契约的类上，那么就会应用到整个数据契约中操作上，如：

          [ServiceContract]

          [ServiceDataContract(typeof(HenllyeeDataContract.Intern))]

          public interface IEmployeeManage{...}

     那么IEmployeeManage服务契约跟其所有的操作都可以接受Intern这个子类.

已知类型与接口

     数据契约DataContract只能标识在class 或者struct上，但是数据契约的基类可以是接口,但是我们在服务契约的时候要去用ServiceKnownType特性去指定确切的数据类型。如:

     interface IEmployee{...}

     [DataContract]

     class Intern:IEmployee{...}

服务契约中：

     [ServiceContract]

     [ServiceKnownType(typeof(Intern))]

     interface IEmployeeManage

     {

          [OperationContract]

          void AdddEmployee(IEmployee employee);

     }

要注意的一点就是我们不能把KnownType特性应用到基接口上，因为客服端导出的元数据是不能包含接口本身的。

[代码下载]

     1.dotnet基本开发；

     2.WCF的数据契约跟服务契约的基本使用

内容：

     我们都知道数据契约其实也是服务器端到客户端序列化跟反序列化，这样的序列化跟asp.net ajax访问webservice是很像的.asp.net ajax 一般是将服务器端的数据序列化成jason字符串传递给前台脚本的但是我们在序列化或则反序列化的时候也许会要去控制一些数据契约里面的Filed或则Attributes,这就需要我们去监听数据契约在序列化及反序列化时触发的一些事件。

数据契约的事件

     数据契约在序列化跟反序列化分别有四个事件：

               1.serializing事件：发生在序列化之前；

               2.serialized事件：发生在序列化之后；

               3.deserializing事件：反序列化之前；

               4.deserialized事件：反序列化之后；

     四个事件我们一眼就能看得懂。但是我们如何去监听这几个事件呢，WCF提供了四个属性标识来标识我们定义的某个方法是来监听标识的特定的事件。但是我们在定义方法的时候必须要去符合这些事件的委托的类型，也就是说必须有相同的参数。我们看下定义的形式：

               1.监听serializing事件：

                    [OnSerializing]

                    void OnSerializing(StreamingContext context)

               2.监听serialized事件：

                    [OnSerialized]

                    void OnSerialized(StreamingContext context)

               3.监听deserializing事件：

                    [OnDeserializing]

                    void OnDeserializing(StreamingContext context)

               4.监听deserialized事件：

                    [OnDeserialized]

                    void OnDeserialized(StreamingContext context)

所以我们可以看出我们定义的方法一定要符合 void <methdName>(StringmingContext <Pram>)的形式，不然WCF就会抛出异常。要注意的一点就是：我们不能把相同的事件的标识应用到多个方法上面。

     因为在反序列化的时候是没有构造函数被调用的，所以我们可以通过OnDeserializing来实现反序列化的构造函数的功能。OnDeserialized事件允许初始化数据契约或则非数据契约的成员。下面我们就看一个例子通过监听OnDeserialized来设置非数据成员的值。

首先我们来定义一个数据契约：

Code
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ServiceModel;
using System.Runtime.Serialization;

namespace DataContract
{
    [DataContract(Name="Employee",Namespace="HenllyeeData")]
    public class EmployeeEntry
    {
        #region Fields
        private string _companyName;
        private string _name;
        private int _age;
        private decimal _salary;
        #endregion

        #region Attributes
        [DataMember(IsRequired=false,Order=0)]
        public string Name
        {
            get { return this._name; }
            set { this._name = value; }
        }

        [DataMember(IsRequired=false,Order=1)]
        public int Age
        {
            get { return this._age; }
            set { this._age = value; }
        }
        [DataMember(IsRequired=false,Order=2)]
        public decimal Salary
        {
            get { return this._salary; }
            set { this._salary = value; }
        }
        [DataMember(IsRequired=false,Order=3)]
        public string Info
        {
            get
            {
                return String.Format("Name:{0} \n Age:{1} \n; Salary:{2}\n CompanyName:{3}\n",
                    this._name,
                    this._age,
                    this._salary,
                    this._companyName);
            }
            set
            {
            }
        }

        [OnDeserialized]
        void OnDeserialized(StreamingContext context)
        {
            this._companyName = "ECI";
        }
        #endregion
    }
}

在这里面我们定义了一个_companyName字段，并且不表示为DataMember,但是在Info属性中去获取了_companyName的值。我们在反序列化的时候完后通过OnDeserizlized方法中设计了其值。

下面是服务契约：

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

namespace ServiceContract
{

    [ServiceContract(Name="EmployeeManagerService")]
    public interface IEmployeeManager
    {
        /// <summary>
        /// Get a employee object
        /// </summary>
        /// <returns></returns>
        [OperationContract(Name="GetEmployee")]
        DataContract.EmployeeEntry GetEmployee();
        
        /// <summary>
        /// Save a employee object
        /// </summary>
        /// <param name="?"></param>
        [OperationContract(Name="SaveEmployee")]
        void SaveEmplyee(DataContract.EmployeeEntry employee);

    }
}

服务契约的实现：

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

namespace ServiceContract
{
    [ServiceBehavior(InstanceContextMode=InstanceContextMode.Single)]
    public class EmployeeManager:IEmployeeManager
    {
        #region Fields
        private DataContract.EmployeeEntry _employee;
        #endregion

        #region Methods
        public DataContract.EmployeeEntry GetEmployee()
        {
            return this._employee;
        }

        public void SaveEmplyee(DataContract.EmployeeEntry EmloyeeEntry)
        {
            this._employee = EmloyeeEntry;
        }
        #endregion
    }
}

宿主主机的代码比较简单就是暴露了一个终节点给客户端。

我们看下客户端的代码：

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

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            EmployeeServiceReference.Employee emloyee = new ConsoleApplication1.EmployeeServiceReference.Employee();
            emloyee.Name = "Henllyee";
            emloyee.Age = 22;
            emloyee.Salary = 3000;
            EmployeeServiceReference.EmployeeManagerServiceClient proxy = new ConsoleApplication1.EmployeeServiceReference.EmployeeManagerServiceClient();
            proxy.SaveEmployee(emloyee);

            EmployeeServiceReference.Employee emploOut= proxy.GetEmployee();
            Console.Write(emploOut.Info);
            Console.Read();
            
        }
    }
}

 运行主机跟客户端后我们看到了想要的效果：

[代码下载] 

     现在突然发现自己改变了不少，少了往日的几分轻狂，更多的了沉默，也许是没有了激情。想想以前在学校的时候能够借助老师给的机会，给全班讲授了两节课的自己研究的东西，而且底下的人听了感觉非常好；想想以前能有在课上站起来跟老师辩论asp.net的好处。以前那个充满激情、那个似乎研究出东西就要让全世界知道、那个莽撞的我也许就此消失了。可是当我第一次看到我们的系统的时候，我第一感觉就是，可以用进很多新技术啊，可以改进很多很多，后来还是沉默了，也许就是自己变了。去年的时候自己跟另外一个朋友做网站时，尽管我们经理说只要符合IE，可是我们还是坚决做到浏览器兼容、前台脚本符合w3c标准；做系统时尽量做到能用ajax取代一些不必要的刷新，做到多层结构；可是现在不知道为什么连这样的想法多没了，有的时候竟然自己也在复制些大写Tag。

     现在最多就是写点文章放在blog上，有的时候竟然连东西都懒得写了。前几天去跟同学去苏州乐园玩的，他问我多长时间没踢球了，我算了一下，好像好几个月了。自己真的变懒了，生活上是，工作上也是。自己晚上还在研究些东西、只是激情不再。

 1、什么是反射
        Reflection，中文翻译为反射。
        这是.Net中获取运行时类型信息的方式，.Net的应用程序由几个部分：‘程序集(Assembly)’、‘模块(Module)’、‘类型(class)’组成，而反射提供一种编程的方式，让程序员可以在程序运行期获得这几个组成部分的相关信息，例如：

        Assembly类可以获得正在运行的装配件信息，也可以动态的加载装配件，以及在装配件中查找类型信息，并创建该类型的实例。
Type类可以获得对象的类型信息，此信息包含对象的所有要素：方法、构造器、属性等等，通过Type类可以得到这些要素的信息，并且调用之。
MethodInfo包含方法的信息，通过这个类可以得到方法的名称、参数、返回值等，并且可以调用之。
诸如此类，还有FieldInfo、EventInfo等等，这些类都包含在System.Reflection命名空间下。

2、命名空间与装配件的关系
        很多人对这个概念可能还是很不清晰，对于合格的.Net程序员，有必要对这点进行澄清。
        命名空间类似与Java的包，但又不完全等同，因为Java的包必须按照目录结构来放置，命名空间则不需要。

        装配件是.Net应用程序执行的最小单位，编译出来的.dll、.exe都是装配件。

        装配件和命名空间的关系不是一一对应，也不互相包含，一个装配件里面可以有多个命名空间，一个命名空间也可以在多个装配件中存在，这样说可能有点模糊，举个例子：
装配件A：
namespace   N1
{
      public   class   AC1   {…}
      public   class   AC2   {…}
}
namespace   N2
{
      public   class   AC3   {…}
      public   class   AC4{…}
}
装配件B：
namespace   N1
{
      public   class   BC1   {…}
      public   class   BC2   {…}
}
namespace   N2
{
      public   class   BC3   {…}
      public   class   BC4{…}
}

        这两个装配件中都有N1和N2两个命名空间，而且各声明了两个类，这样是完全可以的，然后我们在一个应用程序中引用装配件A，那么在这个应用程序中，我们能看到N1下面的类为AC1和AC2，N2下面的类为AC3和AC4。
        接着我们去掉对A的引用，加上对B的引用，那么我们在这个应用程序下能看到的N1下面的类变成了BC1和BC2，N2下面也一样。
        如果我们同时引用这两个装配件，那么N1下面我们就能看到四个类：AC1、AC2、BC1和BC2。

        到这里，我们可以清楚一个概念了，命名空间只是说明一个类型是那个族的，比如有人是汉族、有人是回族；而装配件表明一个类型住在哪里，比如有人住在北京、有人住在上海；那么北京有汉族人，也有回族人，上海有汉族人，也有回族人，这是不矛盾的。

        上面我们说了，装配件是一个类型居住的地方，那么在一个程序中要使用一个类，就必须告诉编译器这个类住在哪儿，编译器才能找到它，也就是说必须引用该装配件。
        那么如果在编写程序的时候，也许不确定这个类在哪里，仅仅只是知道它的名称，就不能使用了吗？答案是可以，这就是反射了，就是在程序运行的时候提供该类型的地址，而去找到它。
有兴趣的话，接着往下看吧。

3、运行期得到类型信息有什么用
        有人也许疑问，既然在开发时就能够写好代码，干嘛还放到运行期去做，不光繁琐，而且效率也受影响。
这就是个见仁见智的问题了，就跟早绑定和晚绑定一样，应用到不同的场合。有的人反对晚绑定，理由是损耗效率，但是很多人在享受虚函数带来的好处的时侯还没有意识到他已经用上了晚绑定。这个问题说开去，不是三言两语能讲清楚的，所以就点到为止了。
        我的看法是，晚绑定能够带来很多设计上的便利，合适的使用能够大大提高程序的复用性和灵活性，但是任何东西都有两面性，使用的时侯，需要再三衡量。

接着说，运行期得到类型信息到底有什么用呢？
还是举个例子来说明，很多软件开发者喜欢在自己的软件中留下一些接口，其他人可以编写一些插件来扩充软件的功能，比如我有一个媒体播放器，我希望以后可以很方便的扩展识别的格式，那么我声明一个接口：
public   interface   IMediaFormat
{
string   Extension   {get;}
Decoder   GetDecoder();
}
这个接口中包含一个Extension属性，这个属性返回支持的扩展名，另一个方法返回一个解码器的对象（这里我假设了一个Decoder的类，这个类提供把文件流解码的功能，扩展插件可以派生之），通过解码器对象我就可以解释文件流。
那么我规定所有的解码插件都必须派生一个解码器，并且实现这个接口，在GetDecoder方法中返回解码器对象，并且将其类型的名称配置到我的配置文件里面。
这样的话，我就不需要在开发播放器的时侯知道将来扩展的格式的类型，只需要从配置文件中获取现在所有解码器的类型名称，而动态的创建媒体格式的对象，将其转换为IMediaFormat接口来使用。

这就是一个反射的典型应用。

4、如何使用反射获取类型
        首先我们来看如何获得类型信息。
        获得类型信息有两种方法，一种是得到实例对象
        这个时侯我仅仅是得到这个实例对象，得到的方式也许是一个object的引用，也许是一个接口的引用，但是我并不知道它的确切类型，我需要了解，那么就可以通过调用System.Object上声明的方法GetType来获取实例对象的类型对象，比如在某个方法内，我需要判断传递进来的参数是否实现了某个接口，如果实现了，则调用该接口的一个方法：
…
public   void   Process(   object   processObj   )
{
Type   t   =   processsObj.GetType();
if(   t.GetInterface(“ITest”)   !=null   )
                    …
}
…
        另外一种获取类型的方法是通过Type.GetType以及Assembly.GetType方法，如：
              Type   t   =   Type.GetType(“System.String”);
        需要注意的是，前面我们讲到了命名空间和装配件的关系，要查找一个类，必须指定它所在的装配件，或者在已经获得的Assembly实例上面调用GetType。
        本装配件中类型可以只写类型名称，另一个例外是mscorlib.dll，这个装配件中声明的类型也可以省略装配件名称（.Net装配件编译的时候，默认都引用了mscorlib.dll，除非在编译的时候明确指定不引用它），比如：
          System.String是在mscorlib.dll中声明的，上面的Type   t   =   Type.GetType(“System.String”)是正确的
          System.Data.DataTable是在System.Data.dll中声明的，那么：
Type.GetType(“System.Data.DataTable”)就只能得到空引用。
          必须：
Type   t   =   Type.GetType("System.Data.DataTable,System.Data,Version=1.0.3300.0,   Culture=neutral,   PublicKeyToken=b77a5c561934e089");
          这样才可以，大家可以看下面这个帖子：
                http://expert.csdn.net/Expert/topic/2210/2210762.xml?temp=.1919977
          qqchen的回答很精彩

5、如何根据类型来动态创建对象
        System.Activator提供了方法来根据类型动态创建对象，比如创建一个DataTable：

Type   t   =   Type.GetType("System.Data.DataTable,System.Data,Version=1.0.3300.0,   Culture=neutral,   PublicKeyToken=b77a5c561934e089");

DataTable   table   =   (DataTable)Activator.CreateInstance(t);

    例二：根据有参数的构造器创建对象
namespace   TestSpace 
 {
  public   class   TestClass
      {
      private   string   _value;
       public   TestClass(string   value)  
     {
       _value=value;
       }
  }
}
…
Type   t   =   Type.GetType(“TestSpace.TestClass”);
Object[]   constructParms   =   new   object[]   {“hello”};   //构造器参数
TestClass   obj   =   (TestClass)Activator.CreateInstance(t,constructParms);
…
把参数按照顺序放入一个Object数组中即可

6、如何获取方法以及动态调用方法
namespace   TestSpace
{
      public   class   TestClass   {
          private   string   _value;
          public   TestClass()   {
          }
          public   TestClass(string   value)   {
                _value   =   value;
          }

          public   string   GetValue(   string   prefix   )   {
           if(   _value==null   )
           return   "NULL";
           else
             return   prefix+"   :   "+_value;
            }

            public   string   Value   {
set   {
_value=value;
}
get   {
if(   _value==null   )
return   "NULL";
else
return   _value;
}
            }
      }
}

        上面是一个简单的类，包含一个有参数的构造器，一个GetValue的方法，一个Value属性，我们可以通过方法的名称来得到方法并且调用之，如：

//获取类型信息
Type   t   =   Type.GetType("TestSpace.TestClass");
//构造器的参数
object[]   constuctParms   =   new   object[]{"timmy"};
//根据类型创建对象
object   dObj   =   Activator.CreateInstance(t,constuctParms);
//获取方法的信息
MethodInfo   method   =   t.GetMethod("GetValue");
//调用方法的一些标志位，这里的含义是Public并且是实例方法，这也是默认的值
BindingFlags   flag   =   BindingFlags.Public   |   BindingFlags.Instance;
//GetValue方法的参数
object[]   parameters   =   new   object[]{"Hello"};
//调用方法，用一个object接收返回值
object   returnValue   =   method.Invoke(dObj,flag,Type.DefaultBinder,parameters,null);

        属性与方法的调用大同小异，大家也可以参考MSDN

7、动态创建委托
        委托是C#中实现事件的基础，有时候不可避免的要动态的创建委托，实际上委托也是一种类型：System.Delegate，所有的委托都是从这个类派生的
        System.Delegate提供了一些静态方法来动态创建一个委托，比如一个委托：

namespace   TestSpace   {
      delegate   string   TestDelegate(string   value);
      public   class   TestClass   {
public   TestClass()   {
                  }
                  public   void   GetValue(string   value)   {
                          return   value;
                  }
        }
}

使用示例：
TestClass   obj   =   new   TestClass();

//获取类型，实际上这里也可以直接用typeof来获取类型
Type   t   =   Type.GetType(“TestSpace.TestClass”);
//创建代理，传入类型、创建代理的对象以及方法名称
TestDelegate   method   =   (TestDelegate)Delegate.CreateDelegate(t,obj,”GetValue”);

String   returnValue   =   method(“hello”);