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();
         }
     }