public DataContractJsonSerializerOperationBehavior(OperationDescription description, int maxItemsInObjectGraph, bool ignoreExtensionDataObject, IDataContractSurrogate dataContractSurrogate, bool alwaysEmitTypeInformation)
     : base(description)
 {
     this.MaxItemsInObjectGraph = maxItemsInObjectGraph;
     this.IgnoreExtensionDataObject = ignoreExtensionDataObject;
     this.DataContractSurrogate = dataContractSurrogate;
     this.alwaysEmitTypeInformation = alwaysEmitTypeInformation;
 }

 internal static object GetCustomDataToExport(IDataContractSurrogate surrogate, Type clrType, Type dataContractType)
 {
     if (DataContract.GetBuiltInDataContract(clrType) != null)
     {
         return null;
     }
     return surrogate.GetCustomDataToExport(clrType, dataContractType);
 }

 internal static object GetDeserializedObject(IDataContractSurrogate surrogate, object obj, Type objType, Type memberType)
 {
     if (obj == null)
         return null;
     if (DataContract.GetBuiltInDataContract(objType) != null)
         return obj;
     return surrogate.GetDeserializedObject(obj, memberType);
 }

 internal static Type GetReferencedTypeOnImport(IDataContractSurrogate surrogate, string typeName, string typeNamespace, object customData)
 {
     if (DataContract.GetBuiltInDataContract(typeName, typeNamespace) != null)
     {
         return null;
     }
     return surrogate.GetReferencedTypeOnImport(typeName, typeNamespace, customData);
 }

 internal static Type GetDataContractType(IDataContractSurrogate surrogate, Type type)
 {
     if (DataContract.GetBuiltInDataContract(type) != null)
         return type;
     Type dcType = surrogate.GetDataContractType(type);
     if (dcType == null)
         return type;
     return dcType;
 }

 public DataContractSerializer(Type type, string rootName, string rootNamespace,
     IEnumerable<Type> knownTypes,
     int maxItemsInObjectGraph,
     bool ignoreExtensionDataObject,
     bool preserveObjectReferences,
     IDataContractSurrogate dataContractSurrogate)
     : this(type, rootName, rootNamespace, knownTypes, maxItemsInObjectGraph, ignoreExtensionDataObject, preserveObjectReferences, dataContractSurrogate, null)
 {
 }

 public DataContractJsonSerializer(Type type,
     IEnumerable<Type> knownTypes,
     int maxItemsInObjectGraph,
     bool ignoreExtensionDataObject,
     IDataContractSurrogate dataContractSurrogate,
     bool alwaysEmitTypeInformation)
 {
     EmitTypeInformation emitTypeInformation = alwaysEmitTypeInformation ? EmitTypeInformation.Always : EmitTypeInformation.AsNeeded;
     Initialize(type, knownTypes, maxItemsInObjectGraph, ignoreExtensionDataObject, dataContractSurrogate, emitTypeInformation, false, null, false);
 }

 internal static object GetObjectToSerialize(IDataContractSurrogate surrogate, object obj, Type objType, Type membertype)
 {
     if (obj == null)
     {
         return null;
     }
     if (DataContract.GetBuiltInDataContract(objType) != null)
     {
         return obj;
     }
     return surrogate.GetObjectToSerialize(obj, membertype);
 }

		public static object Deserialize (XmlReader reader, Type declaredType,
			KnownTypeCollection knownTypes, IDataContractSurrogate surrogate, DataContractResolver resolver, DataContractResolver defaultResolver,
			string name, string ns, bool verifyObjectName)
		{
			reader.MoveToContent ();
			if (verifyObjectName)
				if (reader.NodeType != XmlNodeType.Element ||
				    reader.LocalName != name ||
				    reader.NamespaceURI != ns)
					throw new SerializationException (String.Format ("Expected element '{0}' in namespace '{1}', but found {2} node '{3}' in namespace '{4}'", name, ns, reader.NodeType, reader.LocalName, reader.NamespaceURI));
//				Verify (knownTypes, declaredType, name, ns, reader);
			return new XmlFormatterDeserializer (knownTypes, surrogate, resolver, defaultResolver).Deserialize (declaredType, reader);
		}

 public static void AddDataContractSurrogate(this ServiceHostBase host, IDataContractSurrogate surrogate)
 {
     foreach (var endpoint in host.Description.Endpoints)
     {
         foreach (var operation in endpoint.Contract.Operations)
         {
             var dc = operation.Behaviors.Find<DataContractSerializerOperationBehavior>();
             if (dc != null)
             {
                 dc.DataContractSurrogate = surrogate;
             }
         }
     }
     var exporter = host.GetXsdDataContractExporter();
     if (exporter != null)
     {
         exporter.Options.DataContractSurrogate = surrogate;
     }
 }

 private void ConfigureOperationDescriptionBehaviors(OperationDescription operation, IDataContractSurrogate contractSurrogate)
 {
     DataContractSerializerOperationBehavior item = new DataContractSerializerOperationBehavior(operation, TypeLoader.DefaultDataContractFormatAttribute);
     if (contractSurrogate != null)
     {
         item.DataContractSurrogate = contractSurrogate;
     }
     operation.Behaviors.Add(item);
     operation.Behaviors.Add(new OperationInvokerBehavior());
     if ((this.info.TransactionOption == TransactionOption.Supported) || (this.info.TransactionOption == TransactionOption.Required))
     {
         operation.Behaviors.Add(new TransactionFlowAttribute(TransactionFlowOption.Allowed));
     }
     OperationBehaviorAttribute attribute = new OperationBehaviorAttribute {
         TransactionAutoComplete = true,
         TransactionScopeRequired = false
     };
     operation.Behaviors.Add(attribute);
 }

		public DataContractSurrogateBehavior(Type surrogateType)
		{
			if (typeof(IDataContractSurrogate).IsAssignableFrom(surrogateType) == false)
			{
				throw new ArgumentException(string.Format(
					"The data contract surrogate {0} does not implement {1}.",
					surrogateType.FullName,
					typeof(IDataContractSurrogate).FullName),
					"surrogateType");
			}

			var surrogateCtor = surrogateType.GetConstructor(Type.EmptyTypes);
			if (surrogateCtor == null)
			{
				throw new ArgumentException(string.Format(
					"The data contract surrogate {0} does not have an empty public constructor.",
					surrogateType.FullName));
			}

			surrogate = (IDataContractSurrogate)surrogateCtor.Invoke(new object[0]);
		}

		public DataContractSerializer (Type type,
			IEnumerable<Type> knownTypes,
			int maxObjectsInGraph,
			bool ignoreExtensionDataObject,
			bool preserveObjectReferences,
			IDataContractSurrogate dataContractSurrogate)
			: this (type, knownTypes)
		{
			Initialize (maxObjectsInGraph,
				ignoreExtensionDataObject,
				preserveObjectReferences,
				dataContractSurrogate);
		}

 internal static Type GetSurrogatedType(IDataContractSurrogate dataContractSurrogate, Type type)
 {
     return DataContractSurrogateCaller.GetDataContractType(dataContractSurrogate, DataContract.UnwrapNullableType(type));
 }

 private void Initialize(Type type, IEnumerable<Type> knownTypes, int maxItemsInObjectGraph, bool ignoreExtensionDataObject, IDataContractSurrogate dataContractSurrogate, bool alwaysEmitTypeInformation)
 {
     XmlObjectSerializer.CheckNull(type, "type");
     this.rootType = type;
     if (knownTypes != null)
     {
         this.knownTypeList = new List<Type>();
         foreach (Type type2 in knownTypes)
         {
             this.knownTypeList.Add(type2);
             if (type2 != null)
             {
                 this.AddCollectionItemTypeToKnownTypes(type2);
             }
         }
     }
     if (maxItemsInObjectGraph < 0)
     {
         throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("maxItemsInObjectGraph", System.Runtime.Serialization.SR.GetString("ValueMustBeNonNegative")));
     }
     this.maxItemsInObjectGraph = maxItemsInObjectGraph;
     this.ignoreExtensionDataObject = ignoreExtensionDataObject;
     this.dataContractSurrogate = dataContractSurrogate;
     this.alwaysEmitTypeInformation = alwaysEmitTypeInformation;
 }

 internal static object SurrogateToDataContractType(IDataContractSurrogate dataContractSurrogate, object oldObj, Type surrogatedDeclaredType, ref Type objType)
 {
     object obj = DataContractSurrogateCaller.GetObjectToSerialize(dataContractSurrogate, oldObj, objType, surrogatedDeclaredType);
     if (obj != oldObj)
     {
         if (obj == null)
             objType = Globals.TypeOfObject;
         else
             objType = obj.GetType();
     }
     return obj;
 }

 void Initialize(Type type, XmlDictionaryString rootName, XmlDictionaryString rootNamespace,
     IEnumerable<Type> knownTypes,
     int maxItemsInObjectGraph,
     bool ignoreExtensionDataObject,
     bool preserveObjectReferences,
     IDataContractSurrogate dataContractSurrogate,
     DataContractResolver dataContractResolver,
     bool serializeReadOnlyTypes)
 {
     Initialize(type, knownTypes, maxItemsInObjectGraph, ignoreExtensionDataObject, preserveObjectReferences, dataContractSurrogate, dataContractResolver, serializeReadOnlyTypes);
     // validate root name and namespace are both non-null
     this.rootName = rootName;
     this.rootNamespace = rootNamespace;
 }

 public DataContractJsonSerializer(Type type, XmlDictionaryString rootName, IEnumerable<Type> knownTypes, int maxItemsInObjectGraph, bool ignoreExtensionDataObject, IDataContractSurrogate dataContractSurrogate, bool alwaysEmitTypeInformation)
 {
     this.Initialize(type, rootName, knownTypes, maxItemsInObjectGraph, ignoreExtensionDataObject, dataContractSurrogate, alwaysEmitTypeInformation);
 }

		void Initialize (
			int maxObjectsInGraph,
			bool ignoreExtensionDataObject,
			bool preserveObjectReferences,
			IDataContractSurrogate dataContractSurrogate)
		{
			if (maxObjectsInGraph < 0)
				throw new ArgumentOutOfRangeException ("maxObjectsInGraph must not be negative.");
			max_items = maxObjectsInGraph;
			ignore_ext = ignoreExtensionDataObject;
			preserve_refs = preserveObjectReferences;
			surrogate = dataContractSurrogate;
		}

		public DataContractJsonSerializer (Type type, string rootName, IEnumerable<Type> knownTypes, int maxItemsInObjectGraph, bool ignoreExtensionDataObject, IDataContractSurrogate dataContractSurrogate, bool alwaysEmitTypeInformation)
			: this (type, rootName, knownTypes, maxItemsInObjectGraph, ignoreExtensionDataObject, alwaysEmitTypeInformation)
		{
			surrogate = dataContractSurrogate;
		}