博客园_JerryShi's blog

使用流模式传输大型数据

2011-12-14T10:20:00Z

WCF 支持两种消息处理模式：

缓冲模式：WCF处理消息的默认方式，在缓冲模式下，整个消息都会保存在内存中，知道发送或者接收完成。此模式作为默认方式，在某些情况下是必需的，如可靠消息传送和数字签名，但存在的缺陷是如果消息数据过大，缓冲占用大量系统内存，同时消耗其他系统资源。

流模式：使用System.IO.Stream 来发传送消息，流模式通常在绑定或传输信道上打开，在绑定的配置上设置transferMode属性来控制流模式的粒度。

transferMode的属性值包括：Buffer、Streamed、StreamedResponse、StreamedRequest；

Demo

Contract：

[ServiceContract]
public interface IFileDownload
{
[OperationContract]
Stream GetFileStream(string fileName);
}

Service:

public class FileDownloadService : IFileDownload, IDisposable
{
private FileStream fStream = null;

public Stream GetFileStream(string fileName)
{
string filePath = AppDomain.CurrentDomain.BaseDirectory + fileName;
if (!File.Exists(filePath))
{
throw new ArgumentException(string.Format("无法找到文件名为{0}的文件", fileName));
}

fStream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read);
return fStream;
}

public void Dispose()
{
Dispose(true);
}

protected virtual void Dispose(bool disposing)
{
//被客户直接调用的,那么托管的,和非托管的资源都可以释放 if (disposing)
{
// 释放托管资源 fStream.Dispose();
//垃圾回收器从Finalization队列中清除自己,从而阻止垃圾回收器调用Finalize方法. GC.SuppressFinalize(this);
}
}
}

Config

说明

运行过程中出现一次异常，异常如下：

此异常由于Client端配置与Server端配置不匹配导致的

本文链接

对象序列化之替换（Surrogate）

2011-11-18T16:28:00Z

有可能存在一种情况，实体类型无法进行序列化或需要在序列化的方式上进行更改，如第三方组件供应商提供的类型或者没有源代码的组件。对于这种情况，WCF提供IDataContractSurrogate 接口来实现一个替身类解决此类问题。

解决问题的步骤：

1. 定义数据契约来表示序列化的类型；

2. 定义实现序列化替身的操作类，实现IDataContractSurrogate接口，并至少实现其三个方法： GetDataContractType、GetDeserializedObject、GetObjectToSerialize ，其中GetDataContractType方法会向DataContractSerializer 返回需要序列化的类型，而GetObjectToSerialize和GetDeserializedObject会实际执行序列化和反序列化。

以下代码：

假设 Employee 无法实现序列化，以EmployeeSurrogated 作为其替身类，以EmpoyyeeSurrogate实现操作，代码如下：

EmployeeSurrogated 定义：

[DataContract]
internal class EmployeeSurrogated
{
public EmployeeSurrogated(int employeeID, string firstName, string lastName)
{
this.employeeID = employeeID;
this.firstName = firstName;
this.lastName = lastName;
}

[DataMember]
private int employeeID;

[DataMember]
private string firstName;

[DataMember]
private string lastName;

public int EmployeeID
{
get { return this.employeeID; }
}

public string FirstName
{
get { return this.firstName; }
}

public string LastName
{
get { return this.lastName; }
}

}

EmployeeSurrogate 操作类：

public class EmployeeSurrogate : IDataContractSurrogate
{
public object GetCustomDataToExport(Type clrType, Type dataContractType)
{
return null;
}

public object GetCustomDataToExport(System.Reflection.MemberInfo memberInfo, Type dataContractType)
{
return null;
}

/// <summary>
/// 向DataContractSerializer 返回需要序列化的类型
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public Type GetDataContractType(Type type)
{
if (typeof(Employee).IsAssignableFrom(type))
{
return typeof(EmployeeSurrogated);
}
return type;
}

/// <summary>
/// 执行反序列化后应返回的实际类型
/// </summary>
/// <param name="obj"></param>
/// <param name="targetType"></param>
/// <returns></returns>
public object GetDeserializedObject(object obj, Type targetType)
{
if (obj is EmployeeSurrogated)
{
EmployeeSurrogated oldEmployee = obj as EmployeeSurrogated;

Employee newEmployee = new Employee()
{
EmployeeID = oldEmployee.EmployeeID,
FirstName = oldEmployee.FirstName,
LastName = oldEmployee.LastName
};
return newEmployee;
}
return obj;
}

public void GetKnownCustomDataTypes(System.Collections.ObjectModel.Collection<Type> customDataTypes)
{
throw new NotImplementedException();
}

/// <summary>
/// 将无法序列化的对象转化会替身类性
/// </summary>
/// <param name="obj"></param>
/// <param name="targetType"></param>
/// <returns></returns>
public object GetObjectToSerialize(object obj, Type targetType)
{
if (obj is Employee)
{
Employee oldEmployee = obj as Employee;
EmployeeSurrogated newEmployee = new EmployeeSurrogated(oldEmployee.EmployeeID, oldEmployee.FirstName, oldEmployee.LastName);
return newEmployee;
}
return obj;
}

public Type GetReferencedTypeOnImport(string typeName, string typeNamespace, object customData)
{
if (typeNamespace.Equals(@"http://schemas.datacontract.org/2004/07/EmplyeeSurrogated"))
{
if (typeName.Equals("EmployeeSurrogated"))
{
return typeof(Employee);
}
}
return null;
}

public CodeTypeDeclaration ProcessImportedType(CodeTypeDeclaration typeDeclaration, CodeCompileUnit compileUnit)
{
return typeDeclaration;
}
}

序列化方式：

序列化器：注意 DataContractSerializer 的实例化调用的构造方法，此关键操作导致可以实现替代的序列化；

public static string TryToSerialize(object obj)
{
DataContractSerializer serializer = new DataContractSerializer(obj.GetType());
using (StringWriter strWriter = new StringWriter())
{
using (XmlWriter xWriter = XmlWriter.Create(strWriter))
{
try
{
serializer.WriteObject(xWriter, obj);
xWriter.Flush();
return strWriter.ToString();
}
catch (Exception ex)
{
Console.WriteLine("Can not serialize without a surrogate : {0}", ex);
}
}
}
return string.Empty;
}

public static string SerializeUsingSurrogate(object obj, IDataContractSurrogate surrogateObj)
{
DataContractSerializer serializer = new DataContractSerializer(obj.GetType(), null, int.MaxValue, false, false, surrogateObj);

return SerializeUsingSurrogate(serializer, obj);
}

public static string SerializeUsingSurrogate(DataContractSerializer serializer, object obj)
{
using (StringWriter strWriter = new StringWriter())
{
using (XmlWriter xWriter = XmlWriter.Create(strWriter))
{
serializer.WriteObject(xWriter, obj);
xWriter.Flush();
return strWriter.ToString();
}
}
}

public static object DeserializeUsingSurrogate(Type sourceType, IDataContractSurrogate surrogateObj, string objXml)
{
DataContractSerializer serializer = new DataContractSerializer(sourceType, null, int.MaxValue, false, false, surrogateObj);

return DeserializeUsingSurrogate(serializer, objXml);
}

public static object DeserializeUsingSurrogate(DataContractSerializer serializer, string objXml)
{
using (StringReader strReader = new StringReader(objXml))
{
using (XmlReader xReader = XmlReader.Create(strReader))
{
return serializer.ReadObject(xReader);
}
}
}

最后执行：

static void SerializeSurrogate()
{
Employee e = new Employee()
{
EmployeeID = 1,
FirstName = "jerry",
LastName = "shi"
};

Console.WriteLine("{0},{1},{2}", e.EmployeeID, e.FirstName, e.LastName);

SerializeHelper.TryToSerialize(e);

string objXml = SerializeHelper.SerializeUsingSurrogate(e, new EmployeeSurrogate());

Console.WriteLine(objXml);

Employee newobj = (Employee)SerializeHelper.DeserializeUsingSurrogate(e.GetType(), new EmployeeSurrogate(), objXml);

Console.WriteLine("{0},{1},{2}", newobj.EmployeeID, newobj.FirstName, newobj.LastName);

Console.WriteLine("Press <Enter> to continute...");
Console.ReadLine();
}

结果说明：

本文链接

使用 IExtensibleDataObject 进行往返式序列化

2011-10-23T05:27:00Z

数据契约会随着时间的推移不断出现新的版本，结构相同但带有新增信息。与其将使用旧版本的数据契约的客户端与服务全部重新生成编译，不如让新版本向前兼容，使用共有部分的数据。

DataContractSerializer 正式这样处理的，如果消息中有多余的数据，DataContractSerializer会将其丢弃。不过这样做在有些情况下会出现问题，如果数据被接受之后还要返还给客户端，那么忽略任何多余的数据都有可能造成信息的丢失。这正IExtensibleDataObject 接口要解决的问题，其提供了对数据契约使用未知外部数据的能力，在进行反序列化时，将任何未知的数据都存储在一个ExtensibleDataObject类的实例中。

DataContractSerializer 默认会忽略任何未被使用或期望的数据，除非在契约上实现了IExtensibleDataObject接口。

可以通过添加程序集的方式不生成代理类就共享数据契约，在这种情况下要确保数据契约实现了IExtensibleDataObject，否则将无法支持往返序列化

示例：

[DataContract]
public class Employee : IExtensibleDataObject
{
[DataMember]
public int EmployeeID { get; set; }

[DataMember]
public string FirstName { get; set; }

[DataMember]
public string LastName { get; set; }

[DataMember]
public string SSN { get; set; }

private ExtensionDataObject extensionData;

public ExtensionDataObject ExtensionData
{
get
{
return this.extensionData;
}
set
{
this.extensionData = value;
}
}
}

若使用svcutil生成代码，则会自动为客户端生成对应的实体，自动会继承Object，并实现IExtensionDataObject 接口。如：

using System.Runtime.Serialization;

[System.Diagnostics.DebuggerStepThroughAttribute()]
[System.CodeDom.Compiler.GeneratedCodeAttribute("System.Runtime.Serialization", "4.0.0.0")]
[System.Runtime.Serialization.DataContractAttribute(Name="Employee", Namespace="http://schemas.datacontract.org/2004/07/JerryShi.EssentialWCF")]
public partial class Employee : object, System.Runtime.Serialization.IExtensibleDataObject
{

private System.Runtime.Serialization.ExtensionDataObject extensionDataField;

private int EmployeeIDField;

private string FirstNameField;

private string LastNameField;

public System.Runtime.Serialization.ExtensionDataObject ExtensionData
{
get
{
return this.extensionDataField;
}
set
{
this.extensionDataField = value;
}
}

[System.Runtime.Serialization.DataMemberAttribute()]
public int EmployeeID
{
get
{
return this.EmployeeIDField;
}
set
{
this.EmployeeIDField = value;
}
}

[System.Runtime.Serialization.DataMemberAttribute()]
public string FirstName
{
get
{
return this.FirstNameField;
}
set
{
this.FirstNameField = value;
}
}

[System.Runtime.Serialization.DataMemberAttribute()]
public string LastName
{
get
{
return this.LastNameField;
}
set
{
this.LastNameField = value;
}
}
}

本文链接

使用 NetDataContractSerializer 共享类型

2011-10-23T03:56:00Z

在上一章节《WCF可序列化方式》提到了NetDataContractSerializer 适用于客户端与服务端共享类型信息，支持支持类型不变性。但并没有提供现成的特性，所以无法使用对数据契约进行标记的方式来达到使用NetDataContractSerializer的目的，必须通过自定制开发，才能对操作契约进行标注。

1. NetDataContractFormatAttribute特性；

public class NetDataContractFormatAttribute : Attribute, IOperationBehavior
{
public void AddBindingParameters(OperationDescription operationDescription, BindingParameterCollection bindingParameters)
{

}

public void ApplyClientBehavior(OperationDescription operationDescription, ClientOperation clientOperation)
{
ReplaceDataContractSerializerOperationBehavior(operationDescription);
}

public void ApplyDispatchBehavior(OperationDescription operationDescription, DispatchOperation dispatchOperation)
{
ReplaceDataContractSerializerOperationBehavior(operationDescription);
}

public void Validate(OperationDescription operationDescription)
{

}

public static void ReplaceDataContractSerializerOperationBehavior(OperationDescription description)
{
DataContractSerializerOperationBehavior dcs = description.Behaviors.Find<DataContractSerializerOperationBehavior>();

if (dcs != null)
{
description.Behaviors.Remove(dcs);
}
description.Behaviors.Add(new NetDataContractSerializerOperationBehavior(description));
}
}

2. NetDataContractSerializerOperationBehavior 行为；

public class NetDataContractSerializerOperationBehavior : DataContractSerializerOperationBehavior
{
private static NetDataContractSerializer serializer = new NetDataContractSerializer();

public NetDataContractSerializerOperationBehavior(OperationDescription operationDescription)
: base(operationDescription)
{

}

public override XmlObjectSerializer CreateSerializer(Type type, string name, string ns, IList<Type> knownTypes)
{
return NetDataContractSerializerOperationBehavior.serializer;
}

public override XmlObjectSerializer CreateSerializer(Type type, XmlDictionaryString name, XmlDictionaryString ns, IList<Type> knownTypes)
{
return NetDataContractSerializerOperationBehavior.serializer;
}
}

3. 将特性标记在契约中；

[ServiceContract(CallbackContract = typeof(IStockServiceCallback))]
public interface IStockService
{
[OperationContract]
double GetPrice(string ticker);

[OperationContract(IsOneWay = true)]
void RegisterForUpdate(string ticker);

[OperationContract]
[NetDataContractFormat]
StockPrice GetStockPrice(string ticker);
}

本文链接

WCF可序列化方式

2011-10-22T12:42:00Z

WCF支持多种序列化方式，决定使用何种取决于多种因素，包括是否希望共享类型或契约，是否支持现有.net类型，是否保留引用等等。

DataContractSerializer

WCF中的默认序列化方式，其目的是对基于XSD schema契约进行共享，将CLR类型映射成XSD中定义的类型，XSD是应用程序间数据交换的协议。

如：使用XSD在 .NET与Java应用程序之间交换数据，以字符串为例：

DataContractSerializer Demo：展示如何使用DataContract，并获取实体类的Schema信息，使用DataContractSerializer序列化输出

实体类：

[DataContract]
public class Employee
{
[DataMember]
public int EmployeeID { get; set; }

[DataMember]
public string FirstName { get; set; }

[DataMember]
public string LastName { get; set; }
}

获取Schema：

public static void WriteSchema(Type type)
{
XsdDataContractExporter exporter = new XsdDataContractExporter();
exporter.Options = new ExportOptions();
exporter.Export(type);

using (FileStream fs = new FileStream(string.Format("{0}/{1}.xsd", AppDomain.CurrentDomain.BaseDirectory, type.Name), FileMode.Create))
{
foreach (XmlSchema schema in exporter.Schemas.Schemas())
{
schema.Write(fs);
}
}
}

序列化输出：

public static void Serialize(object obj)
{
using (FileStream fs = new FileStream(string.Format("{0}/{1}.xml", AppDomain.CurrentDomain.BaseDirectory, obj.GetType().Name), FileMode.Create))
{
DataContractSerializer serializer = new DataContractSerializer(obj.GetType());
serializer.WriteObject(fs, obj);
}
}

Schema 数据：

<?xml version="1.0"?>
<xs:schema xmlns:tns="http://schemas.datacontract.org/2004/07/JerryShi.EssentialWCF" elementFormDefault="qualified" targetNamespace="http://schemas.datacontract.org/2004/07/JerryShi.EssentialWCF" xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:complexType name="Employee">
<xs:sequence>
<xs:element minOccurs="0" name="EmployeeID" type="xs:int" />
<xs:element minOccurs="0" name="FirstName" nillable="true" type="xs:string" />
<xs:element minOccurs="0" name="LastName" nillable="true" type="xs:string" />
</xs:sequence>
</xs:complexType>
<xs:element name="Employee" nillable="true" type="tns:Employee" />
</xs:schema>

序列化数据：

<Employee xmlns="http://schemas.datacontract.org/2004/07/JerryShi.EssentialWCF" xmlns:i="http://www.w3.org/2001/XMLSchema-instance">
<EmployeeID>1</EmployeeID>
<FirstName>Jerry</FirstName>
<LastName>Shi</LastName>
</Employee>

NetDataContractSerializer

共享类型的序列化机制，如果在客户端与服务器之间，类型完全一致，则可以使用此序列化。 NetDatacontractSerializer 在序列化中保留了CLR类型和引用信息，支持类型不变性(type fidelity)。除此之外NetDataContractSerializer 与 DataContractSerializer 没有区别。

对类型信息的共享，违背了只共享契约的原则，因此NetDataContractSerializer不适用于跨应用的系统，而适用于单一应用程序内部开发。

序列化代码：

public static void NetDataContractSerialize(object obj)
{
using (FileStream fs = new FileStream(string.Format("{0}/{1}_NetDataContractSerialize.xml", AppDomain.CurrentDomain.BaseDirectory, obj.GetType().Name), FileMode.Create))
{
NetDataContractSerializer serializer = new NetDataContractSerializer();
serializer.WriteObject(fs, obj);
}
}

序列化数据：

<Employee z:Id="1" z:Type="JerryShi.EssentialWCF.Employee" z:Assembly="JerryShi.EssentialWCF, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" xmlns="http://schemas.datacontract.org/2004/07/JerryShi.EssentialWCF" xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns:z="http://schemas.microsoft.com/2003/10/Serialization/">
<EmployeeID>1</EmployeeID>
<FirstName z:Id="2">Jerry</FirstName>
<LastName z:Id="3">Shi</LastName>
</Employee>

NetDataContractSerializer 与 DataContractSerializer 比较：

1. 以自定义格式表示对象信息；

2. 包含对象Assmebly信息；

XmlSerializer

从.Net2.0起出现，支持现有.Net 类型，与ASP.NET Web Service兼容，能够控制XML输出结果

优势：向前兼容、对序列化后的XML可以进行控制；。

使用XmlSerializer的三种方式：

1. 默认序列化方式，要求构造方法必须为public，所有的public类型的字段及读写属性均会进行序列化；

2. 使用XmlElement和XmlAttribute特性，对public字段及读写属性进行标记，可以控制public字段和属性在xml中如何表示；

3. 使用IXmlSerializable接口来定制XmlSerializer的序列化，这种方法允许对序列化过程彻底的定制；

序列化数据：

<Employee xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<EmployeeID>1</EmployeeID>
<FirstName>Jerry</FirstName>
<LastName>Shi</LastName>
</Employee>

结果比较：与DataContractSerializer的结果很相似，最大的差异：XmlSerializer没有DataContractSerializer支持的类型多，但对Xml序列化数据有更多的控制能力。

特性：XmlSerializerFormat 可以用在服务契约、操作契约或服务上，用来指定WCF使用XmlSerializer 序列化方式。

在WCF契约中使用XmlSerializer 的方式，除了使用XmlSerializerFormat以外，也可以在使用svcutil.exe时使用参数： /serializer:xmlserializer 来生成以来XmlSerializer的代理代码。

DataContractJsonSerializer

从 .Net Framework 3.5 中出现，支持JavaScript对象序列化后的格式，适用于 Ajax、Silverlight 等应用。

当使用WebScriptEnablingBehavior行为或当WebHttpBehavior行为被配置成使用Json编码时，就会使用DataContractJsonSerializer。

DataContractJsonSerializer 遵循与DataContractSerializer一样的序列化规则，只是输出的格式是Json而不是Xml。

序列化数据：

{"EmployeeID":1,"FirstName":"Jerry","LastName":"Shi"}

选择序列化器

1. 如果需要支持现有类型或DataContractSerializer所不支持的序列化方式，应考虑XmlSerializer；

2. WCF 对NetDataContractSerializer没有直接支持，必须编写代码完成，不提倡使用；

3. DataContractJsonSerializer 主要用于Web 应用，Ajax或Silverlight

本文链接

序列化 VS 编码

2011-10-22T03:45:00Z

DataContract序列化机制，将CLR类型转换成符合标准的XML，在客户端与服务之间进行传输。然而有许多情况下DataContract序列化机制不足以完成工作。

WCF并没有遵循序列化的标准定义，而是将序列化定义为将对乡土转化为XML信息集（XML Infoset）的过程。XML Infoset 是一个数据模型，WCF用它在内部表示一个消息。

System.ServiceModel.Chnnels.Message是代表XML Infoset的类。

XML Infoset 是用来表示XML文档的数据类型，也是XML的基本抽象定义。

XML与XML Infoset之间的关键区别：XML Infoset未指定一种特定的格式，所以，尽管XML标准使用的是文本格式，XML Infoset却没有任何限制。

XML Infoset 与 XML相比的优势：只要消息是基于XML Infoset的，WCF就可以用不同的格式来表示它，其中包括了XML1.1规范制定的文本格式，也可以是其他格式如二进制。也可以使用XML，同时可以根据互通性和性能要求选择合适的消息格式。

编码描述将WCF消息转化成字节数组的过程，这样消息才能通过传输协议进行发送。

WCF提供5种编码方式：二进制、文本、消息传输优化机制（MTOM）、JSON、XML。

如果想在.NET 应用程序之间获得最佳性能，应选用BiaryMessageEncoder；

如果要基于WS-*的Web Service, 则应选用TextMessageEncoder和MtomMessageEncoder；

如果要基于Ajax应用通信，则应选用JsonMessageEncoder；

如果已有的编码器不能满足要求，则可以扩展WCF来支持新的编码器；

本文链接

自定义 Behavior

2011-10-21T14:31:00Z

自定义Behavior 允许在WCF 构建运行时环境和消息处理管道的关键点上插入代码。

实现自定义行为的步骤：

1. 创建一个实现了 Inspector、Selector、Formatter、或Invoker 接口的类；

2. 创建一个实现了下列行为接口之一的类：IServiceBehavior、IEndpointBehavior、IOperationBehavior或IContractBehavior；

3. 配置客户端或服务来使用行为，可由代码、配置文件、属性来完成；

服务端行为实现消息检验器

该Demo实现一个日志行为，输出端点发送和接收的每条消息，代码实现了从端点行为调用的一个消息检验器，以及在一个自定义扩管服务中手工的向服务描述添加端点行为。

public class MyEndpointBehavior : IEndpointBehavior
{
#region IEndpointBehavior Members

public void AddBindingParameters(ServiceEndpoint endpoint, BindingParameterCollection bindingParameters)
{

}

public void ApplyClientBehavior(ServiceEndpoint endpoint, ClientRuntime clientRuntime)
{

}

public void ApplyDispatchBehavior(ServiceEndpoint endpoint, EndpointDispatcher endpointDispatcher)
{
endpointDispatcher.DispatchRuntime.MessageInspectors.Add(new MyMessageInspector());
}

public void Validate(ServiceEndpoint endpoint)
{

}

#endregion
}

public class MyMessageInspector : IDispatchMessageInspector
{

#region IDispatchMessageInspector Members

public object AfterReceiveRequest(ref Message request, IClientChannel channel, InstanceContext instanceContext)
{
Console.WriteLine(request.ToString());
return request;
}

public void BeforeSendReply(ref Message reply, object correlationState)
{

}

#endregion
}

执行结果：

结果分析：

服务端输出每次接收到的Message数据；

通过属性暴露服务操作行为的参数检验器

Demo功能说明：使用正则表达式对参数进行校验，当参数无效时返回错误消息；从操作行为调用参数检验器，实现属性的操作行为，在服务定义中通过属性引用将操作行为添加到服务描述中；

[AttributeUsage(AttributeTargets.Method)]
public class MyOperationBehavior : Attribute, IOperationBehavior
{
public string Pattern;
public string Message;

#region IOperationBehavior Members

public void AddBindingParameters(OperationDescription operationDescription, BindingParameterCollection bindingParameters)
{

}

public void ApplyClientBehavior(OperationDescription operationDescription, ClientOperation clientOperation)
{

}

public void ApplyDispatchBehavior(OperationDescription operationDescription, DispatchOperation dispatchOperation)
{
dispatchOperation.ParameterInspectors.Add(new MyParameterInspector(Pattern, Message));
}

public void Validate(OperationDescription operationDescription)
{

}

#endregion
}

public class MyParameterInspector : IParameterInspector
{
string pattern;
string message;

public MyParameterInspector(string pattern, string message)
{
this.pattern = pattern;
this.message = message;
}

#region IParameterInspector Members

public void AfterCall(string operationName, object[] outputs, object returnValue, object correlationState)
{

}

public object BeforeCall(string operationName, object[] inputs)
{
foreach (object input in inputs)
{
if (input != null && input.GetType().Equals(typeof(string)))
{
Regex regex = new Regex(pattern);
if (regex.IsMatch(input.ToString()))
{
throw new FaultException(string.Format("Parameter out of range : {0} , {1}", input.ToString(), message));
}
}
}
return null;
}

#endregion
}
[ServiceBehavior(InstanceContextMode = InstanceContextMode.PerSession, ConcurrencyMode = ConcurrencyMode.Multiple)]
public class StockService : IStockService
{
public StockService()
{
Console.WriteLine("{0}:Created new instance of StockService on thread", DateTime.Now);
}

public class Worker
{
public string ticker;
public Update workProcess;
}

public static Hashtable workers = new Hashtable();
public static object locker = new object();
private int callsCounter = 0;

#region IStockService Members

[MyOperationBehavior(Pattern="[^a-zA-Z]",Message="Only alpha characters allowed")]
public double GetPrice(string ticker)
{
Console.WriteLine("{0}: GetPrice called on thread {1}", DateTime.Now, Thread.CurrentThread.ManagedThreadId);
Thread.Sleep(5000);
return 94.85;
}

public void RegisterForUpdate(string ticker)
{
Worker worker = null;

if (!workers.ContainsKey(ticker))
{
worker = new Worker();
worker.ticker = ticker;
worker.workProcess = new Update();
worker.workProcess.ticker = ticker;
workers.Add(ticker, worker);
}

worker = (Worker)workers[ticker];
IStockServiceCallback c = OperationContext.Current.GetCallbackChannel(); lock (worker.workProcess.callbacks) { worker.workProcess.callbacks.Add(c); } Thread t = new Thread(new ThreadStart(worker.workProcess.SendUpdateToClient)); t.IsBackground = true; t.Start(); } public StockPrice GetStockPrice(string ticker) { StockPrice p = new StockPrice(); Console.WriteLine("{0}: GetPrice called on thread {1}", DateTime.Now, Thread.CurrentThread.ManagedThreadId); p.Price = 94.85; lock (locker) { p.CallsCounter = ++callsCounter; } Thread.Sleep(1000); return p; } #endregion } public class Update { public string ticker; public List callbacks = new List(); public void SendUpdateToClient() { Random w = new Random(); Random p = new Random(); for (int i = 0; i < 10; i++) { Thread.Sleep(w.Next(5000)); lock (callbacks) { foreach (IStockServiceCallback callback in callbacks) { try { callback.PriceUpdate("msft", 100.00 + p.NextDouble()); } catch (Exception ex) { Console.WriteLine("Error sending cache to client:{0}", ex.Message); } } } } } }

执行结果

调试状态下直接报出错误信息

通过配置文件暴露服务行为

实现IServiceBehavior，代码：

public class MyServiceBehavior : IServiceBehavior
{
string evaluationKey;
string evaluationType;

public MyServiceBehavior(string evaluationKey, string evaluationType)
{
this.evaluationKey = evaluationKey;
this.evaluationType = evaluationType;
}

#region IServiceBehavior Members

public void AddBindingParameters(ServiceDescription serviceDescription, ServiceHostBase serviceHostBase, Collection endpoints, BindingParameterCollection bindingParameters) { } public void ApplyDispatchBehavior(ServiceDescription serviceDescription, ServiceHostBase serviceHostBase) { } public void Validate(ServiceDescription serviceDescription, ServiceHostBase serviceHostBase) { if (evaluationType.Equals("Enterprise", StringComparison.OrdinalIgnoreCase) & !evaluationKey.Equals("SuperSecretEvaluationKey", StringComparison.OrdinalIgnoreCase)) { throw new Exception(string.Format("Invalid evaluation key. Type:{0}", evaluationType)); } } #endregion }

配置：

本文链接

操作行为之事务

2011-10-17T13:53:00Z

事务场景：

1. 长期事务：多步骤业务处理，时间跨度长，如几分钟、几天、上月，涉及多个组织或工作流；

2. 短期事务：简单业务处理，时间段，几秒内完成，外部以来很少；

短期事务ACID特性：原子性、一致性、隔离性、持久性

WCF支持短期事务，利用两种架构来实现：

1. .Net Framewok 和 Windows Infrastructure 支持 Microsoft环境中运行的事务；

2. 利用跨平台的WS-* 标准。

事务化操作

声明操作行为： [OperationBehavior(TransactionScopeRequired=true)]，表示将服务操作标识为事务化操作。

操作说明：

1. WCF在将控制权转换为服务方法前创建一个新事务；

2. 将执行线程纳入第一步创建的事务中；

可以显式或隐式的指定当操作完成时的提交事务的操作。声明操作行为：[OperationBehavior(TransactionAutoComplete=true)]

TransactionAutoCompleted=true 表示若没有抛出任何错误，操作会隐式的认定执行完成；若抛出错误，操作会认定为未完成，针对事务资源的部分更新会被回滚。

TransactionAutoCompleted=false 表示必须在方法返回前显示的调用 OperationContext.Current.SetTransactionCompleted() ，若使用了显式方法，则必须在通信信道中使用基于会话的绑定，并使用[ServiceContract(SessionMode=SessionMode.Allowed)]使用服务契约支持会话。

代码示例：BankService 实现两个方法，GetBalance 不需要事务，Transfer 指定了事务，并隐式提交事务。通过输出事务的 LocalIdentifier和DistributedIdentifier来判断事务执行情况

public class BankService: IBankService
{
#region IBankService Members

[OperationBehavior(TransactionScopeRequired = false)]
public double GetBalance(string AccountName)
{
DBAccess dbAccess = new DBAccess();
double amount = dbAccess.GetBalance(AccountName);
dbAccess.Audit(AccountName, "Query", amount);
return amount;
}

[OperationBehavior(TransactionScopeRequired = true, TransactionAutoComplete = true)]
public void Transfer(string From, string To, double amount)
{
try
{
Withdraw(From, amount);
Deposit(To, amount);
}
catch (Exception ex)
{
throw ex;
}
}

#endregion

private void Withdraw(string accountName, double amount)
{
DBAccess dbAccess = new DBAccess();
dbAccess.Withdraw(accountName, amount);
dbAccess.Audit(accountName, "Withdraw", amount);
}

private void Deposit(string accountName, double amount)
{
DBAccess dbAccess = new DBAccess();
dbAccess.Deposit(accountName, amount);
dbAccess.Audit(accountName, "Deposit", amount);
}
}

执行结果：

在执行过程中若本机没有打开MSDTC服务，则会出现错误，必须要进行配置。

结果分析：

1. Withdraw 执行中打开第一个数据库连接，当前存在一个上下文事务，并且属于本地事务；

2. Deposit 执行中打开第二个数据库连接，导致事务从本地事务升级到分布式事务；

导致事务升级的代码：

private void Withdraw(string accountName, double amount)
{
DBAccess dbAccess = new DBAccess();//创建SqlConnection
dbAccess.Withdraw(accountName, amount);
dbAccess.Audit(accountName, "Withdraw", amount);
}

private void Deposit(string accountName, double amount)
{
DBAccess dbAccess = new DBAccess();//创建SqlConnection
dbAccess.Deposit(accountName, amount);
dbAccess.Audit(accountName, "Deposit", amount);
}

由于创建两个SqlConnection实例，导致分布式事务出现，可以对此进行优化，将dbAccess 实例作为全局变量，共用同一个SqlConnection实例。优化后结果如下：

操作之间的事务流转

背景：跨越服务边界的事务，如：用户下订单需要同时调用订单服务及客户信息服务，增加订单的同时增加客户信息。

在WCF中，服务边界之间的事务流转信息统称为事务流（transaction flow），要在服务边界之间定义事务流，需要以下5个操作：

1. （服务契约）SessionMode.Required，服务契约必须使用Session，只有这样客户端才能在参与事务的各个服务之间共享信息；

2. （操作行为）TransactionScopeRequired=true，操作行为必须在事务上下文内，若不存在上下文，则创建一个新事物；

3. （操作契约）TransactionFlowOption.Allowed，操作契约必须允许消息头中包含用于流转的事务信息；

4. （绑定）TransactionFlow=true，允许事务跨越多个服务调用，绑定必须激活事务流，使得信道能在SOAP头中放置事务信息，绑定必须支持会话；

5. （客户端）TransactionScope，初始化事务的角色（通常是客户端）必须在调用服务操作时使用一个事务作用域，必须调用TransactionScope.Close()来提交修改；

暂无Demo

本文链接

服务行为之元数据

2011-09-28T13:38:00Z

元数据：将服务的ABC（地址、绑定、契约）以服务提供者与服务消费者共同认可的XML 描述的形式描述出来。

要使元数据对客户端可用，需要两个步骤：

1. 按某种可读的格式导出元数据；

2. 发布到一个可用的位置；

默认的导出格式是WSDL，WCF使用WS-MetadataExchange协议发布元数据，或者将元数据发布为HTTP GET的

Response。导出与发布的操作都由 ServiceMetadataBehavior 实现

服务通过Mex端点交换数据，Mex端点类似于我们开发的端点，同样有自己的 ABC，同样可以通过配置文件进行添加。

Mex端点的ABC及示例

契约： System.ServiceModel.Description.IMetadataExchange 接口，其服务实现了检查服务并以WSDL格式提供和发布元数据的方法；

绑定： CLR提供的绑定：mexHttpBinding、mexHttpsBinding、mexNamedPipeBinding、mexTcpBinding；

地址：地址可以是相对地址，也可以是绝对地址，通常配置文件中相对地址为mex

Mex端点自托管代码

using (ServiceHost servcieHost = new ServiceHost(typeof(StockService), new Uri(url)))
{
servcieHost.AddServiceEndpoint(typeof(IStockService), binding, "");

ServiceMetadataBehavior behavior = new ServiceMetadataBehavior();
behavior.HttpGetEnabled = true;
servcieHost.Description.Behaviors.Add(behavior);
servcieHost.AddServiceEndpoint(typeof(IMetadataExchange), MetadataExchangeBindings.CreateMexHttpBinding(), "mex");

servcieHost.Open();

Console.WriteLine("Press to terminate service...");
Console.ReadLine();
servcieHost.Close();
}

本文链接

服务行为之并发与实例化

2011-09-27T14:26:00Z

本章节介绍服务行为中的并发与实例化行为，服务行为的介绍可以参考《 WCF Behaviors（行为）》

并发与实例化的引入，相关的名词解释

并发（Concurrency）：对同时执行的任务数量，度量单位为任务（如请求、作业、事务等）；

执行时间（Execution Time）：完成任务所用的时间，度量单位为时间（如秒、毫秒等）；

吞吐量（Throughput）：固定时间内完成的任务数量，度量单位为任务/时间如：请求/秒、事务/分钟；

提高吞吐量的办法：

减少执行时间

通过修改任务内部算法或增加硬件资源来完成，WCF在此方面作用有限。

提高并发

通过提高单位时间内的并发数量， WCF中控制另发的两个行为：InstanceContextMode 和 ConcurrencyMode

ServiceBehavior 属性不定义在接口上，而是服务类上，因为ServiceBehavior属性针对的是服务的行为，而不是服务的契约。

InstanceContextMode 服务行为用于控制实例化，取值说明：

Single ：所有入站请求均共用同一个服务类的实例；
PerCall ：为每一个入站请求创建一个服务类的实例；
PerSession：为每一个会话创建一个服务类的实例，默认值；

InstanceContextMode 的默认值为PerSession，但当使用无会话的信道（通道）或者无会话绑定时，会变化为PerCall行为。

ConcurrencyMode 服务行为用于控制服务实例内的线程并发，取值说明：

Single：同一时刻仅能有一个线程访问服务类，默认值；

Reentrant：同一个是仅能有一个线程访问服务类，但该线程可以暂时离开服务类进入等待状态，而后又激活继续访问；

Multiple：多线程并发访问服务类。

Single 是最安全的设置，服务操作不需要担心线程安全问题，Multiple 需要类具有内置的线程安全能力。

同时使用 InstanceContextMode 与 ConcurrencyMode 这两个设置，可以配置服务的实例化和并发来满足特定的性能需求。

会话实例 - 单线程 - 默认-示例

定义服务接口

[ServiceContract]
public interface IStockService
{
[OperationContract]
double GetPrice(string ticker);
}

实现服务，输出线程ID

public class StockService : IStockService
{
public StockService()
{
Console.WriteLine("{0}:Created new instance of StockService on thread", DateTime.Now);
}

#region IStockService Members

public double GetPrice(string ticker)
{
Console.WriteLine("{0}: GetPrice called on thread {1}", DateTime.Now, Thread.CurrentThread.ManagedThreadId);

return 94.95;
}

#endregion
}

客户端异步调用代码

public static void GetPriceWithAsync(string address, Binding binding)
{
//IStockService proxy = CreateStockServiceProxy(address, binding);
StockServiceClient proxy = new StockServiceClient(stockContext, binding, new EndpointAddress(address));

IAsyncResult arGetPrice;
for (int i = 0; i < 3; i++)
{
Console.WriteLine("{0} : Calling GetPrice", DateTime.Now);
arGetPrice = proxy.BeginGetPrice("msft", GetPriceCallback, proxy);
Thread.Sleep(100);//为了让输出更清晰
Interlocked.Increment(ref c);
}
while (c > 0)
{
Thread.Sleep(1000);
}
stockProxy.Close();
}

static void GetPriceCallback(IAsyncResult ar)
{
double price = ((StockServiceClient)ar.AsyncState).EndGetPrice(ar);
Console.WriteLine("{0}: GetPrice result:{1}", DateTime.Now, price);
Interlocked.Decrement(ref c);
}

执行结果

结果分析：

1. 对每个客户端的请求，服务端仅生成了一个服务实例

2. 每个请求都在各自的线程中被执行。

以上代码采用net.tcp方式进行绑定，net.tcp支持会话，因此InstanceContextMode取值为PerSession；

ConcurrencyMode.Single 设置使得每个WCF对于每个服务实例只允许一个线程。

多实例 - 单线程 - 示例

服务类代码：

[ServiceBehavior(InstanceContextMode = InstanceContextMode.PerCall, ConcurrencyMode = ConcurrencyMode.Multiple)]
public class StockService : IStockService

执行结果

结果分析：

1. 为每个请求创建了一个实例；

2. 每个请求在各自的线程中处理请求。

InstanceContextMode.PerSession 在绑定不支持会话的情况下会演变为 InstanceContextMode.PerCall ，故如果采用BasicHttpBinding方式，则无须进行设置。

单实例-多线程-示例

适用情况：

服务初始化代价高昂，如：构造方法需要从数据库中加载大量数据，或者构建一个大的数据结构；

服务代码中存在锁机制，可以保护线程局部安全，提高伸缩性；

服务类代码：

[ServiceBehavior(InstanceContextMode = InstanceContextMode.Single, ConcurrencyMode = ConcurrencyMode.Multiple)]
public class StockService : IStockService

执行结果：

结果分析：

1. 服务端仅创建了一次实例；

2. 每次请求是在不同的线程中执行的；

单实例 - 单线程 - 单例模式

适用情况：没有锁机制，要求先进先出处理方式，调用者存在共享情况

服务端代码：

[ServiceBehavior(InstanceContextMode = InstanceContextMode.Single, ConcurrencyMode = ConcurrencyMode.Single)]
public class StockService : IStockService

执行结果：

结果分析：

1. 与会话实例 - 单线程 - 示例中不同的是，显式声明 InstanceContextMode = InstanceContextMode.Single 后，一旦host成功，自动会创建服务实例;

2. 多个请求重用一个线程，

ConcurrencyMode.Single 设置使得WCF在同一时刻只允许运行一个服务类的一个实例，并不控制创建线程的总量

会话级实例

要实现基于会话的服务实例，必须要实现两点：

1. 在契约级打开会话功能：SessionMode ： Allowed|NotAllowed|Requied；

2. 在服务级设置按会话创建服务实例；

虽然会话是在契约级别设置是否允许，但其真正实现是在绑定元素指定的信道，因此服务第一次启动时会校验契约行为与信道的兼容性，如果信道需要会话，而绑定不支持会话(如：basicHttpBinding)，则会抛出异常

会话实例 - 多线程 - 示例

代码：

[DataContract]
public class StockPrice
{
[DataMember]
public double Price;

[DataMember]
public int CallsCounter;
}

[ServiceBehavior(InstanceContextMode = InstanceContextMode.PerSession, ConcurrencyMode = ConcurrencyMode.Multiple)]
public class StockService : IStockService
{
public StockService()
{
Console.WriteLine("{0}:Created new instance of StockService on thread", DateTime.Now);
}

public StockPrice GetStockPrice(string ticker)
{
StockPrice p = new StockPrice();
Console.WriteLine("{0}: GetPrice called on thread {1}", DateTime.Now, Thread.CurrentThread.ManagedThreadId);

p.Price = 94.85;
lock (locker)
{
p.CallsCounter = ++callsCounter;
}
Thread.Sleep(1000);
return p;
}
}

执行结果：启动两个客户端，同时调用

结果分析：

1. 创建了两个实例，分别针对两个客户端；

2. 计数器针对两个客户端是独立的，分别计数；

3. 服务端处理请求在3个线程中进行，属于多线程。

如果将InstanceContextMode改为Single，则计数器将从1增长到6

使用配置控制实例、线程

通过配置对程序中的多实例、多线程、会话数进行控制

maxConcurrentInstances ：最大并发实例数，当InstanceContextMode取值为 PerSession或PerCall 时此配置会起作用，Single表示只存在一个实例；

maxConcurrentCalls：最大并发调用数量，当 ConcurrencyMode 为 Mutiple时起作用；

maxConcurrentSeesions：最大会话数量，当InstanceContextMode取值为PerSession时起作用，当达到最大数量时，会等待其他会话关闭。

本文链接

博客园_JerryShi's blog

使用流模式传输大型数据

对象序列化之 替换（Surrogate）

使用 IExtensibleDataObject 进行往返式序列化

使用 NetDataContractSerializer 共享类型

WCF可序列化方式

序列化 VS 编码

自定义 Behavior

操作行为 之 事务

服务行为 之 元数据

服务行为 之 并发与实例化

对象序列化之替换（Surrogate）

操作行为之事务

服务行为之元数据

服务行为之并发与实例化