优化.NET Remoting的传输的DataSet的序列化以提供性能
首先大家可以先看一下这篇文章：
Improving DataSet Serialization and Remoting Performance
这篇文章使用了一个DataSetSurrogate 代理类来包装DataSet，在序列化的时候，就可以被序列化成完全的Binary。关于这个DataSetSurrogate的用法，我这里就不多说了，大家可以看文章和其中包含的使用帮助。
但是，使用这个代理类有一个问题，就是需要写多余的代码来使用它，尤其对于已经编写好的代码，要每个往返数据的地方都加上它，肯定是不现实的。于是，我就想到了使用ChannelSink的方式，来统一处理往返中的DataSet。
基本原理是：在ClientSink中截获方法调用，检查传入参数是否是数据集或者其子类，如果是，就把这些参数包装成DataSetSurrogate，以CallContext来传递，且把原始的参数值设置为null；在ServerSink接受到这个被修改过的方法调用，把CallContext的参数DataSetSurrogate恢复成DataSet，同时也要把ReturnValue包装成DataSetSurrogate，以同样的方式传递给客户端；在客户端接受到方法的ReturnValue后，也要把ReturnValue恢复成DataSet。
相应的代码如下：
【ClientSink】
public class UAPClientSink:BaseChannelObjectWithProperties, IMessageSink,IClientChannelSink
{
//接收链中，在Formatter之上，在配置文件中，在Formatter上面
private IClientChannelSink m_NextChnlSink;
private IMessageSink m_NextMsgSink;
//private IDictionary m_Prop;
public UAPClientSink(object next)
{
m_NextChnlSink=next as IClientChannelSink;
m_NextMsgSink=next as IMessageSink;
}
#region IMessageSink 成员
public IMessage SyncProcessMessage(IMessage msg)
{
IMessage myReturnMsg;
//用于设置是否要使用DataSetSurrogate来包装DataSet
if (CallContext.GetData("NotSurrogate")!=null && (bool)CallContext.GetData("NotSurrogate"))
{
CallContext.SetData("NotSurrogate_Server",new LogicalCallContextData("true"));
IMessage retmsg= m_NextMsgSink.SyncProcessMessage(msg);
CallContext.SetData("NotSurrogate",null);
return retmsg;
}
else
{
CallContext.SetData("NotSurrogate_Server",new LogicalCallContextData("false"));
}
LogicalCallContext lcc = (LogicalCallContext) msg.Properties["__CallContext"];
if (msg is IMethodCallMessage) //处理调用
{
//包装DataSet为DataSetSurrogate
Type[] ts=(Type[])msg.Properties["__MethodSignature"];
Object[] vs=(Object[])msg.Properties["__Args"];
if (ts!=null)
{
for (int i=0;i<=ts.Length-1;i++)
{
System.Diagnostics.Debug.WriteLine(vs[i].ToString());
if ((vs[i] is System.Data.DataSet) && vs[i]!=null)
{
System.Data.DataSet ds=(System.Data.DataSet)vs[i];
DataSetSurrogate dss=new DataSetSurrogate(ds);
lcc.SetData("DataSetSurrogate_" + i.ToString(),dss);
vs[i]=null;
}
}
}
}
//执行下一个Sink的操作，直到执行到真实的Endpoint的方法，并得到访问值
myReturnMsg=m_NextMsgSink.SyncProcessMessage(msg);
if (myReturnMsg is IMethodReturnMessage)//处理返回
{
//恢复ReturnValue中DataSet
System.Diagnostics.Debug.WriteLine("==========处理返回的DataSet=========");
IMethodReturnMessage returnMsg=(IMethodReturnMessage)myReturnMsg;
System.Data.DataSet ds=returnMsg.ReturnValue as System.Data.DataSet;
if (ds!=null)
{
try
{
System.Diagnostics.Debug.WriteLine("处理前 ReturnValue中的DataSet的数据：" + ds.GetXml());
//再获得returnMsg的__CallContext
lcc = (LogicalCallContext)returnMsg.Properties["__CallContext"];
DataSetSurrogate returnDSS=(DataSetSurrogate)lcc.GetData("DataSetSurrogate_Return");
System.Diagnostics.Debug.WriteLine("=== 有DataSetSurrogate_Return ===");
Object nds;
if (returnMsg.ReturnValue.GetType()==typeof(System.Data.DataSet))
{
nds=returnDSS.ConvertToDataSet();
}
else
{
nds=Activator.CreateInstance(returnMsg.ReturnValue.GetType());
//ReadDataIntoDataSetEx是我扩展了DataSetSurrogate的方法，以支持类型数据集包含额外列的模式
returnDSS.ReadDataIntoDataSetEx(nds as System.Data.DataSet);
}
Debug.WriteLine("处理后 ReturnValue中的DataSet的数据（行的数目）：" +((System.Data.DataSet)nds).Tables[0].Rows.Count);
MethodReturnWrapper mrw=new MethodReturnWrapper(myReturnMsg as IMethodReturnMessage);
mrw.SetReturnValue(nds);
myReturnMsg=mrw;
lcc.SetData("DataSetSurrogate_Return",null);
}
catch(Exception ex)
{
Debug.WriteLine(ex.ToString());
}
}
CallContext.SetData("NotSurrogate",null);
return myReturnMsg;
}
else
{
Debug.WriteLine(myReturnMsg.GetType().FullName);
CallContext.SetData("NotSurrogate",null);
return myReturnMsg;
}
}
public IMessageSink NextSink
{
get
{
return m_NextMsgSink;
}
}
public IMessageCtrl AsyncProcessMessage(IMessage msg, IMessageSink replySink)
{
return m_NextMsgSink.AsyncProcessMessage(msg,replySink);
}
#endregion
#region IClientChannelSink 成员
public void AsyncProcessRequest(IClientChannelSinkStack sinkStack, IMessage msg, ITransportHeaders headers, Stream stream)
{
throw new Exception("在配置文件中的顺序不对");
}
public void ProcessMessage(IMessage msg, ITransportHeaders requestHeaders, Stream requestStream, out ITransportHeaders responseHeaders, out Stream responseStream)
{
throw new Exception("在配置文件中的顺序不对");
}
public void AsyncProcessResponse(IClientResponseChannelSinkStack sinkStack, object state, ITransportHeaders headers, Stream stream)
{
throw new Exception("在配置文件中的顺序不对");
}
public Stream GetRequestStream(IMessage msg, ITransportHeaders headers)
{
throw new Exception("在配置文件中的顺序不对");
}
public IClientChannelSink NextChannelSink
{
get
{
return m_NextChnlSink;
}
}
#endregion
public override IDictionary Properties
{
get
{
return base.Properties;
}
}
}
【ServerSink】
public class UAPServerSink:BaseChannelObjectWithProperties,IServerChannelSink, IChannelSinkBase
{
//接收链中，在Formatter之上，在配置文件中，在Formatter下面
IServerChannelSink m_Next;
public UAPServerSink(IServerChannelSink nextSink)
{
m_Next=nextSink;
}
#region IChannelSinkBase 成员
public override IDictionary Properties
{
get
{
// TODO: 添加 UAPServerSink.Properties getter 实现
return base.Properties;
}
}
#endregion
#region IServerChannelSink 成员
public Stream GetResponseStream(IServerResponseChannelSinkStack sinkStack, object state, IMessage msg, ITransportHeaders headers)
{
return null;
}
public ServerProcessing ProcessMessage(IServerChannelSinkStack sinkStack, IMessage requestMsg, ITransportHeaders requestHeaders, Stream requestStream, out IMessage responseMsg, out ITransportHeaders responseHeaders, out Stream responseStream)
{
LogicalCallContext lcc = (LogicalCallContext) requestMsg.Properties["__CallContext"];
if (lcc!=null)
{
//不需要包装
if (lcc.GetData("NotSurrogate_Server")!=null &&
((LogicalCallContextData)lcc.GetData("NotSurrogate_Server")).Data=="true")
{
sinkStack.Push(this,null);
return m_Next.ProcessMessage(sinkStack,requestMsg,requestHeaders,requestStream,out responseMsg,out responseHeaders,out responseStream);
}
if (requestMsg!=null && requestMsg is IMethodCallMessage)
{
//恢复传入DataSet的参数值
Type[] ts=(Type[])requestMsg.Properties["__MethodSignature"];
Object[] vs=(Object[])requestMsg.Properties["__Args"];
if (ts!=null)
{
for (int i=0;i<=ts.Length-1;i++)
{
if (ts[i]==typeof(System.Data.DataSet) || ts[i].BaseType==typeof(System.Data.DataSet))
{
Object v=lcc.GetData("DataSetSurrogate_" + i.ToString());
DataSetSurrogate dss=(DataSetSurrogate)v;
Object ds;
if (ts[i]==typeof(System.Data.DataSet))
{
ds=dss.ConvertToDataSet();
}
else
{
ds=Activator.CreateInstance(ts[i]);
dss.ReadDataIntoDataSetEx(ds as System.Data.DataSet);
}
vs[i]=ds;
lcc.SetData("DataSetSurrogate_" + i.ToString(),null);
}
}
}
}
sinkStack.Push(this,null);
ServerProcessing spres=m_Next.ProcessMessage(sinkStack,requestMsg,requestHeaders,requestStream,out responseMsg,out responseHeaders,out responseStream);
if (responseMsg is IMethodReturnMessage)
{
IMethodReturnMessage returnMsg=responseMsg as IMethodReturnMessage;
if (returnMsg!=null)
{
//包装ReturnValue中DataSet为DataSetSurrogate
lcc= (LogicalCallContext) returnMsg.Properties["__CallContext"];
Object retval=returnMsg.ReturnValue;
if (retval!=null && retval is System.Data.DataSet)
{
System.Data.DataSet ds=(System.Data.DataSet)retval;
DataSetSurrogate dss=new DataSetSurrogate(ds);
lcc.SetData("DataSetSurrogate_Return",dss);
MethodReturnWrapper mrw=new MethodReturnWrapper(returnMsg);
Object nds=Activator.CreateInstance(retval.GetType());
mrw.SetReturnValue(nds);
responseMsg=mrw;
}
}
}
return spres;
}
else
{
sinkStack.Push(this,null);
return m_Next.ProcessMessage(sinkStack,requestMsg,requestHeaders,requestStream,out responseMsg,out responseHeaders,out responseStream);
}
}
public void AsyncProcessResponse(IServerResponseChannelSinkStack sinkStack, object state, IMessage msg, ITransportHeaders headers, Stream stream)
{
m_Next.AsyncProcessResponse(sinkStack,state,msg,headers,stream);
}
public IServerChannelSink NextChannelSink
{
get
{
return m_Next;
}
}
#endregion
}
【ReadDataIntoDataSetEx】
/// <summary>
/// 以支持在Typed DataSet的动态列的添加（而不是异常）,添加到末尾
/// </summary>
/// <param name="ds"></param>
public void ReadDataIntoDataSetEx(System.Data.DataSet ds)
{
if (ds == null)
{
throw new ArgumentNullException("The dataset parameter cannot be null");
}
if (IsMissTableOrColumn(ds))
{
System.Data.DataSet nds=new System.Data.DataSet();
ReadSchemaIntoDataSet(nds);
ReadDataIntoDataSet(nds);
ds.Merge(nds);
}
else
{
ReadDataIntoDataSet(ds);
}
}
以上的代码并没有考虑到异步调用，也没有考虑方法调用的参数的ref out 属性。
