wcf datetime json format

wcf 内置的json序列化工具，有时需要替换，或者特殊情况的处理，需要修改。

我也遇到了Dto属性类型是datetime，json的反序列化和序列号不友好。

这是国外网站的一个方案：Replacing WCF DataContractJsonSerializer with Newtonsoft JsonSerializer

不过时间格式还不是我想要的，他是发布在GitHub上，于是简单修改了时间格式，使更符合国情。

需要引用新写的库 WcfNewtonsoftJsonSerializer ，然后配置文件配置好。

关键配置部分：behaviorExtensions、endpointBehaviors、webHttpBinding

   <system.serviceModel>

     <extensions>

       <behaviorExtensions>

         <add name="newtonsoftJsonBehavior" type="WcfNewtonsoftJsonSerializer.NewtonsoftJsonBehaviorExtension, WcfNewtonsoftJsonSerializer" />

       </behaviorExtensions>

     </extensions>

     <behaviors>

       <endpointBehaviors>

         <behavior name="restEndPointBehavior">

           <webHttp helpEnabled="true" />

           <newtonsoftJsonBehavior />

         </behavior>

       </endpointBehaviors>

       <serviceBehaviors>

         <behavior name="restServiceBehavior">

           <serviceMetadata httpGetEnabled="true"/>

           <serviceDebug includeExceptionDetailInFaults="true"  httpHelpPageEnabled="true"/>

         </behavior>

       </serviceBehaviors>

     </behaviors>

     <bindings>

       <webHttpBinding>

         <binding name="restWebHttpBinding"

                  contentTypeMapper="WcfNewtonsoftJsonSerializer.NewtonsoftJsonContentTypeMapper, WcfNewtonsoftJsonSerializer"

                  allowCookies="false"

                  bypassProxyOnLocal="false"

                  hostNameComparisonMode="StrongWildcard"

                  maxBufferPoolSize="524288"

                  maxBufferSize="2147483647"

                  closeTimeout="00:01:00"

                  openTimeout="00:01:00"

                  receiveTimeout="00:02:00"

                  sendTimeout="00:02:00"

                  maxReceivedMessageSize="2147483647"

                  transferMode="Buffered">

           <security mode="None">

             <transport clientCredentialType="None" />

           </security>

           <readerQuotas maxArrayLength="2147483647"

                         maxBytesPerRead="2147483647"

                         maxDepth="2147483647"

                         maxNameTableCharCount="2147483647"

                         maxStringContentLength="2147483647" />

         </binding>

       </webHttpBinding>

     </bindings>

     <services>

       <service name="WcfService1.Service1" behaviorConfiguration="restServiceBehavior">

         <endpoint address=""

                   contract="WcfService1.IService1"

                   binding="webHttpBinding"

                   bindingConfiguration="restWebHttpBinding"

                   behaviorConfiguration="restEndPointBehavior" />

         <endpoint address="mex" binding="mexHttpBinding" contract="IMetadataExchange" />

       </service>

     </services>

   </system.serviceModel>

以下是WcfNewtonsoftJsonSerializer项目的关键代码：

     public class NewtonsoftJsonBehavior : WebHttpBehavior

     {

         public override void Validate( ServiceEndpoint endpoint )

         {

             base.Validate( endpoint );

             var elements = endpoint.Binding.CreateBindingElements();

             var webEncoder = elements.Find<WebMessageEncodingBindingElement>();

             if ( webEncoder == null )

             {

                 throw new InvalidOperationException( "This behavior must be used in an endpoint with the WebHttpBinding (or a custom binding with the WebMessageEncodingBindingElement)." );

             }

             foreach ( var operation in endpoint.Contract.Operations )

             {

                 ValidateOperation( operation );

             }

         }

         protected override IDispatchMessageFormatter GetRequestDispatchFormatter( OperationDescription operationDescription, ServiceEndpoint endpoint )

         {

             if ( IsGetOperation( operationDescription ) )

             {

                 // no change for GET operations

                 return base.GetRequestDispatchFormatter( operationDescription, endpoint );

             }

             if ( operationDescription.Messages[].Body.Parts.Count ==  )

             {

                 // nothing in the body, still use the default

                 return base.GetRequestDispatchFormatter( operationDescription, endpoint );

             }

             return new NewtonsoftJsonDispatchFormatter( operationDescription, true );

         }

         protected override IDispatchMessageFormatter GetReplyDispatchFormatter( OperationDescription operationDescription, ServiceEndpoint endpoint )

         {

             if ( operationDescription.Messages.Count ==  || operationDescription.Messages[].Body.ReturnValue.Type == typeof( void ) )

             {

                 return base.GetReplyDispatchFormatter( operationDescription, endpoint );

             }

             else

             {

                 return new NewtonsoftJsonDispatchFormatter( operationDescription, false );

             }

         }

         private void ValidateOperation( OperationDescription operation )

         {

             if ( operation.Messages.Count >  )

             {

                 if ( operation.Messages[].Body.Parts.Count >  )

                 {

                     throw new InvalidOperationException( "Operations cannot have out/ref parameters." );

                 }

             }

             var bodyStyle = GetBodyStyle( operation );

             var inputParameterCount = operation.Messages[].Body.Parts.Count;

             if ( !IsGetOperation( operation ) )

             {

                 var wrappedRequest = bodyStyle == WebMessageBodyStyle.Wrapped || bodyStyle == WebMessageBodyStyle.WrappedRequest;

                 if ( inputParameterCount ==  && wrappedRequest )

                 {

                     throw new InvalidOperationException( "Wrapped body style for single parameters not implemented in this behavior." );

                 }

             }

             var wrappedResponse = bodyStyle == WebMessageBodyStyle.Wrapped || bodyStyle == WebMessageBodyStyle.WrappedResponse;

             var isVoidReturn = operation.Messages.Count ==  || operation.Messages[].Body.ReturnValue.Type == typeof( void );

             if ( !isVoidReturn && wrappedResponse )

             {

                 throw new InvalidOperationException( "Wrapped response not implemented in this behavior." );

             }

         }

         private WebMessageBodyStyle GetBodyStyle( OperationDescription operation )

         {

             var wga = operation.Behaviors.Find<WebGetAttribute>();

             if ( wga != null )

             {

                 return wga.BodyStyle;

             }

             var wia = operation.Behaviors.Find<WebInvokeAttribute>();

             if ( wia != null )

             {

                 return wia.BodyStyle;

             }

             return DefaultBodyStyle;

         }

         private bool IsGetOperation( OperationDescription operation )

         {

             var wga = operation.Behaviors.Find<WebGetAttribute>();

             if ( wga != null )

             {

                 return true;

             }

             var wia = operation.Behaviors.Find<WebInvokeAttribute>();

             if ( wia != null )

             {

                 return wia.Method == "HEAD";

             }

             return false;

         }

     }

     public class NewtonsoftJsonBehaviorExtension : BehaviorExtensionElement

     {

         public override Type BehaviorType

         {

             get { return typeof ( NewtonsoftJsonBehavior ); }

         }

         protected override object CreateBehavior()

         {

             return new NewtonsoftJsonBehavior();

         }

     }

     public class NewtonsoftJsonContentTypeMapper : WebContentTypeMapper

     {

         public override WebContentFormat GetMessageFormatForContentType( string contentType )

         {

             return WebContentFormat.Raw;

         }

     }

     public class NewtonsoftJsonDispatchFormatter : IDispatchMessageFormatter

     {

         private readonly OperationDescription _operation;

         private readonly Dictionary<string, int> _parameterNames;

         public NewtonsoftJsonDispatchFormatter( OperationDescription operation, bool isRequest )

         {

             _operation = operation;

             if ( isRequest )

             {

                 var operationParameterCount = operation.Messages[].Body.Parts.Count;

                 if ( operationParameterCount >  )

                 {

                     _parameterNames = new Dictionary<string, int>();

                     for ( var i = ; i < operationParameterCount; i++ )

                     {

                         _parameterNames.Add( operation.Messages[].Body.Parts[i].Name, i );

                     }

                 }

             }

         }

         public void DeserializeRequest( Message message, object[] parameters )

         {

             object bodyFormatProperty;

             if ( !message.Properties.TryGetValue( WebBodyFormatMessageProperty.Name, out bodyFormatProperty ) ||

                  ( bodyFormatProperty as WebBodyFormatMessageProperty ).Format != WebContentFormat.Raw )

             {

                 throw new InvalidOperationException( "Incoming messages must have a body format of Raw. Is a ContentTypeMapper set on the WebHttpBinding?" );

             }

             var bodyReader = message.GetReaderAtBodyContents();

             bodyReader.ReadStartElement( "Binary" );

             var rawBody = bodyReader.ReadContentAsBase64();

             var ms = new MemoryStream( rawBody );

             var sr = new StreamReader( ms );

             var serializer = new Newtonsoft.Json.JsonSerializer();

             if ( parameters.Length ==  )

             {

                 // single parameter, assuming bare

                 parameters[] = serializer.Deserialize( sr, _operation.Messages[].Body.Parts[].Type );

             }

             else

             {

                 // multiple parameter, needs to be wrapped

                 Newtonsoft.Json.JsonReader reader = new Newtonsoft.Json.JsonTextReader( sr );

                 reader.Read();

                 if ( reader.TokenType != Newtonsoft.Json.JsonToken.StartObject )

                 {

                     throw new InvalidOperationException( "Input needs to be wrapped in an object" );

                 }

                 reader.Read();

                 while ( reader.TokenType == Newtonsoft.Json.JsonToken.PropertyName )

                 {

                     var parameterName = reader.Value as string;

                     reader.Read();

                     if ( _parameterNames.ContainsKey( parameterName ) )

                     {

                         var parameterIndex = _parameterNames[parameterName];

                         parameters[parameterIndex] = serializer.Deserialize( reader, _operation.Messages[].Body.Parts[parameterIndex].Type );

                     }

                     else

                     {

                         reader.Skip();

                     }

                     reader.Read();

                 }

                 reader.Close();

             }

             sr.Close();

             ms.Close();

         }

         public Message SerializeReply( MessageVersion messageVersion, object[] parameters, object result )

         {

             byte[] body;

             var serializer = new Newtonsoft.Json.JsonSerializer();

             serializer.Converters.Add( new IsoDateTimeConverter() {DateTimeFormat = "yyyy-MM-dd HH:mm:ss", DateTimeStyles = DateTimeStyles.None} );

             using ( var ms = new MemoryStream() )

             {

                 using ( var sw = new StreamWriter( ms, Encoding.UTF8 ) )

                 {

                     using ( Newtonsoft.Json.JsonWriter writer = new Newtonsoft.Json.JsonTextWriter( sw ) )

                     {

                         //writer.Formatting = Newtonsoft.Json.Formatting.Indented;

                         serializer.Serialize( writer, result );

                         sw.Flush();

                         body = ms.ToArray();

                     }

                 }

             }

             var replyMessage = Message.CreateMessage( messageVersion, _operation.Messages[].Action, new RawBodyWriter( body ) );

             replyMessage.Properties.Add( WebBodyFormatMessageProperty.Name, new WebBodyFormatMessageProperty( WebContentFormat.Raw ) );

             var respProp = new HttpResponseMessageProperty();

             respProp.Headers[HttpResponseHeader.ContentType] = "application/json";

             replyMessage.Properties.Add( HttpResponseMessageProperty.Name, respProp );

             return replyMessage;

         }

     }

     public class RawBodyWriter : BodyWriter

     {

         private readonly byte[] _content;

         public RawBodyWriter( byte[] content )

             : base( true )

         {

             _content = content;

         }

         protected override void OnWriteBodyContents( XmlDictionaryWriter writer )

         {

             writer.WriteStartElement( "Binary" );

             writer.WriteBase64( _content, , _content.Length );

             writer.WriteEndElement();

         }

     }

巴特西

wcf datetime json format

最新文章

热门文章