//Reads data from xml file and creates a dictionary based off of that.
static IDictionary<XName, InstanceValue> LoadInstanceDataFromFile(Stream inputStream)
{
IDictionary<XName, InstanceValue> data = new Dictionary<XName, InstanceValue>();
var serializer = new NetDataContractSerializer();
using (var xmlReader = XmlReader.Create(inputStream))
{
var doc = new XmlDocument();
doc.Load(xmlReader);
var instances = doc.GetElementsByTagName("InstanceValue");
foreach (XmlElement instanceElement in instances)
{
var keyElement = (XmlElement)instanceElement.SelectSingleNode("descendant::key");
var key = (XName)DeserializeObject(serializer, keyElement);
var valueElement = (XmlElement)instanceElement.SelectSingleNode("descendant::value");
var value = DeserializeObject(serializer, valueElement);
var instVal = new InstanceValue(value);
data.Add(key, instVal);
}
}
return data;
}
internal XmlObjectSerializerContext(NetDataContractSerializer serializer)
: this(serializer,
serializer.MaxItemsInObjectGraph,
serializer.Context,
serializer.IgnoreExtensionDataObject)
{
}
protected override object DeserializeObject(ArraySegment<byte> value)
{
var ds = new NetDataContractSerializer();
using (var ms = new MemoryStream(value.Array, value.Offset, value.Count))
return ds.Deserialize(ms);
}
/// <summary>
/// Saves all instance data.
/// </summary>
/// <param name="instanceId">The instance id.</param>
/// <param name="command">The command.</param>
/// <returns></returns>
/// <exception cref="System.Runtime.DurableInstancing.InstancePersistenceException"></exception>
public Boolean SaveAllInstanceData(Guid instanceId, SaveWorkflowCommand command)
{
Boolean isExistingInstance;
try
{
String fileName = String.Format("{0}.xml", instanceId);
String fullPath = Path.Combine(_dataDirectory, fileName);
isExistingInstance = File.Exists(fullPath);
XElement root = new XElement("Instance");
root.Add(new XAttribute("WorkflowInstanceId", instanceId));
XDocument xml = new XDocument(root);
NetDataContractSerializer serializer = new NetDataContractSerializer();
XElement section = new XElement("InstanceData");
root.Add(section);
foreach(var entry in command.InstanceData)
{
SaveSingleEntry(serializer, section, entry);
}
SaveInstanceDocument(fullPath, xml);
}
catch(Exception exception)
{
Dev2Logger.Log.Error(exception);
throw new InstancePersistenceException(exception.Message, exception);
}
return isExistingInstance;
}
/// <summary>
/// Writes the job (which implements ISerializable) to the provided
/// file stream.
/// </summary>
/// <param name="job">ScheduledJob job to save</param>
/// <param name="fs">FileStream</param>
private static void SaveResultsToFile(ScheduledJob job, FileStream fs)
{
XmlObjectSerializer serializer = new System.Runtime.Serialization.NetDataContractSerializer();
serializer.WriteObject(fs, job);
fs.Flush();
}
internal XmlObjectSerializerReadContextComplex(NetDataContractSerializer serializer) : base(serializer)
{
this.mode = SerializationMode.SharedType;
this.preserveObjectReferences = true;
this.binder = serializer.Binder;
this.surrogateSelector = serializer.SurrogateSelector;
this.assemblyFormat = serializer.AssemblyFormat;
}
// Deserializes a stream to a graph using the NetDataContractSerializer (binary mode)
private static object DeserializeGraph(Stream rawBytes)
{
using (XmlDictionaryReader dr = XmlDictionaryReader.CreateBinaryReader(rawBytes, XmlDictionaryReaderQuotas.Max))
{
object deserialized = new NetDataContractSerializer().ReadObject(dr);
return deserialized;
}
}
public override object Deserialize(Type type, byte[] data)
{
var formatter = new NetDataContractSerializer();
using (var ms = new MemoryStream(data))
{
return formatter.Deserialize(ms);
}
}
internal XmlObjectSerializerReadContextComplex(NetDataContractSerializer serializer)
: base(serializer)
{
this.mode = SerializationMode.SharedType;
this.preserveObjectReferences = true;
this.binder = serializer.Binder;
this.surrogateSelector = serializer.SurrogateSelector;
this.assemblyFormat = serializer.AssemblyFormat;
}
public override byte[] Serialize(object obj)
{
var formatter = new NetDataContractSerializer();
using (var ms = new MemoryStream())
{
formatter.Serialize(ms, obj);
return ms.ToArray();
}
}
internal override bool WriteClrTypeInfo(XmlWriterDelegator xmlWriter, Type dataContractType, SerializationInfo serInfo)
{
if (this.mode == SerializationMode.SharedType)
{
NetDataContractSerializer.WriteClrTypeInfo(xmlWriter, dataContractType, this.binder, serInfo);
return(true);
}
return(false);
}
internal XmlObjectSerializerWriteContextComplex(NetDataContractSerializer serializer, Hashtable surrogateDataContracts) : base(serializer)
{
this.mode = SerializationMode.SharedType;
base.preserveObjectReferences = true;
this.streamingContext = serializer.Context;
this.binder = serializer.Binder;
this.surrogateSelector = serializer.SurrogateSelector;
this.surrogateDataContracts = surrogateDataContracts;
}
public BinaryStateSerializer(ILogger logger)
{
if (logger == null)
throw new ArgumentNullException("logger");
this.logger = logger;
netDataContractSerializer = new NetDataContractSerializer();
load();
}
public static object Deserialize(byte[] buffer)
{
using (MemoryStream memStream = new MemoryStream(buffer))
using (GZipStream zipStream = new GZipStream(memStream, CompressionMode.Decompress))
using (XmlDictionaryReader xmlDictionaryReader = XmlDictionaryReader.CreateBinaryReader(zipStream, XmlDictionaryReaderQuotas.Max))
{
NetDataContractSerializer serializer = new NetDataContractSerializer();
return serializer.ReadObject(xmlDictionaryReader);
}
}
public XElement ToElement(object val, Func<Type, XNamespace> getNamespace)
{
var serializer = new NetDataContractSerializer();
using (var ms = new MemoryStream())
{
serializer.WriteObject(ms, val);
ms.Seek(0, SeekOrigin.Begin);
return XElement.Load(new XmlTextReader(ms));
}
}
internal XmlObjectSerializerWriteContextComplex(NetDataContractSerializer serializer, Hashtable surrogateDataContracts)
: base(serializer)
{
this.mode = SerializationMode.SharedType;
this.preserveObjectReferences = true;
this.streamingContext = serializer.Context;
this.binder = serializer.Binder;
this.surrogateSelector = serializer.SurrogateSelector;
this.surrogateDataContracts = surrogateDataContracts;
}
/// <summary>
/// Creates a new instance of the class with the same value as instance.
/// </summary>
/// <returns>Returns cloned object.</returns>
public virtual object Clone()
{
IFormatter formatter = new NetDataContractSerializer();
using(Stream stream = new MemoryStream())
{
formatter.Serialize(stream, this);
stream.Seek(0, SeekOrigin.Begin);
return formatter.Deserialize(stream);
}
}
private object Deserialize(string value, Type type)
{
using (var m = new MemoryStream(Encoding.Unicode.GetBytes(value)))
{
var r = XmlDictionaryReader.CreateTextReader(m, Encoding.Unicode, XmlDictionaryReaderQuotas.Max, null);
//var s = new DataContractSerializer(type, null, Int32.MaxValue, false, false, null, new PluginDataContractResolver());
var s = new NetDataContractSerializer();
return s.ReadObject(r);
}
}
static void Main(string[] args)
{
var ns = new NetDataContractSerializer();
// NetDataContractSerializer is otherwise the same to use
// as DataContractSerializer.
Person p = new Person { Name = "Stacey", Age = 30 };
var ds = new DataContractSerializer(typeof(Person));
XmlWriterSettings settings = new XmlWriterSettings() { Indent = true };
using (XmlWriter w = XmlWriter.Create("person.xml", settings))
ds.WriteObject(w, p);
System.Diagnostics.Process.Start("person.xml");
}
static KeyValuePair<string, MethodBase> DeserializeMethodBase(XmlReader reader)
{
var sb = new StringBuilder();
sb.Append(reader.ReadOuterXml());
var s = sb.ToString();
var ndcs = new NetDataContractSerializer();
using (var sr = new StringReader(s))
using (var xr = new XmlTextReader(sr))
{
return new KeyValuePair<string, MethodBase>(s, (MethodBase)ndcs.ReadObject(xr));
}
}
public void SholdSerializeOperator()
{
// Given
var entity = new FilterTestEntity { StringField = "Abc", IntField = 5 };
// Какое-то сложное логическое выражение
var specification = new FilterSpecification<FilterTestEntity>(
b => b.Or(
c => c
.And(a => a.Or(o => o
.Null(i => i.StringField)
.Equal(i => i.StringField, string.Empty))
.Equal(i => i.IntField, 0))
.And(a => a
.NotNull(i => i.StringField)
.NotEqual(i => i.StringField, string.Empty)
.Or(o => o
.In(i => i.StringField.ToLower(), new[] { "a", "b", "c" })
.Contains(i => i.StringField.ToLower(), "abc")
.StartsWith(i => i.StringField, "1")
.EndsWith(i => i.StringField, "5"))
.Or(o => o
.And(a2 => a2
.GreaterOrEqual(i => i.IntField, 0)
.LessOrEqual(i => i.IntField, 10))
.And(a2 => a2
.Greater(i => i.IntField, 10)
.Less(i => i.IntField, 20))
.Between(i => i.IntField, 20, 30)))));
IFilterOperator operatorFromStream;
IFilterOperator operatorToStream = specification.Operator;
// When
using (var stream = new MemoryStream())
{
// Сериализация
var serializer = new NetDataContractSerializer();
serializer.Serialize(stream, operatorToStream);
stream.Position = 0;
// Десериализация
operatorFromStream = (IFilterOperator)serializer.ReadObject(stream);
}
// Then
Assert.IsNotNull(operatorFromStream);
Assert.AreEqual(operatorToStream.IsSatisfiedBy(entity), operatorFromStream.IsSatisfiedBy(entity));
}
public static byte[] Serialize(object graph)
{
using (MemoryStream memStream = new MemoryStream())
using (GZipStream zipStream = new GZipStream(memStream, CompressionMode.Compress))
{
using (XmlDictionaryWriter xmlDictionaryWriter = XmlDictionaryWriter.CreateBinaryWriter(zipStream))
{
NetDataContractSerializer serializer = new NetDataContractSerializer();
serializer.WriteObject(xmlDictionaryWriter, graph);
xmlDictionaryWriter.Close();
}
zipStream.Close();
return memStream.ToArray();
}
}
public async Task SerializingTaskTest()
{
var count = 10;
var action = new Action(() => count=count+5);
Assert.AreEqual(count, 10);
var sr = new NetDataContractSerializer();
//v//ar actionString = sr.S
//var actionString = JsonConvert.SerializeObject(action);
//var newAction = JsonConvert.DeserializeObject<Action>(actionString);
//newAction.Invoke();
Assert.AreEqual(count, 15);
}
private static WorkflowCompilerResults DeserializeWrapperOutput(string fileName)
{
WorkflowCompilerResults results;
using (Stream stream = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read))
{
using (XmlReader reader = XmlReader.Create(stream))
{
NetDataContractSerializer serializer = new NetDataContractSerializer();
SurrogateSelector selector = new SurrogateSelector();
selector.AddSurrogate(typeof(MemberAttributes), serializer.Context, new CompilerResultsSurrogate());
serializer.SurrogateSelector = selector;
results = (WorkflowCompilerResults) serializer.ReadObject(reader);
}
}
return results;
}
private string Serialize(object value, Type type)
{
using (var m = new MemoryStream())
{
var w = XmlDictionaryWriter.CreateTextWriter(m, Encoding.Unicode);
//var s = new DataContractSerializer(type, null, Int32.MaxValue, false, false, null, new PluginDataContractResolver());
var s = new NetDataContractSerializer();
s.WriteObject(w, value);
w.Flush();
w.Close();
return System.Text.Encoding.Unicode.GetString(m.ToArray());
}
}
private static Response GetSerializedVersion(object response)
{
try
{
using (var stream = new MemoryStream())
{
var serializer = new NetDataContractSerializer();
serializer.WriteObject(stream, response);
stream.Position = 0;
return (Response)serializer.ReadObject(stream);
}
}
catch (Exception ex)
{
throw new ColomboSerializationException(string.Format("{0} could not be serialized.", response), ex);
}
}
private static void WriteCompilerOutput(string path, WorkflowCompilerResults results)
{
using (Stream stream = new FileStream(path, FileMode.Create, FileAccess.Write, FileShare.None))
{
XmlWriterSettings settings = new XmlWriterSettings {
Indent = true
};
using (XmlWriter writer = XmlWriter.Create(stream, settings))
{
NetDataContractSerializer serializer = new NetDataContractSerializer();
SurrogateSelector selector = new SurrogateSelector();
selector.AddSurrogate(typeof(MemberAttributes), serializer.Context, new CompilerResultsSurrogate());
serializer.SurrogateSelector = selector;
serializer.WriteObject(writer, results);
}
}
}
private static object ReadFaultDetail(Message reply)
{
const string DetailElementName = "Detail";
using (XmlDictionaryReader reader = reply.GetReaderAtBodyContents())
{
// Find <soap:Detail>
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element && reader.LocalName == DetailElementName)
{
break;
}
}
// Did we find it?
if (reader.NodeType != XmlNodeType.Element || reader.LocalName != DetailElementName)
{
return null;
}
// Move to the contents of <soap:Detail>
if (!reader.Read())
{
return null;
}
// Deserialize the fault
NetDataContractSerializer serializer = new NetDataContractSerializer();
try
{
return serializer.ReadObject(reader);
}
catch (FileNotFoundException)
{
// Serializer was unable to find assembly where exception is defined
return null;
}
catch (SerializationException)
{
// Error during deserialization
return null;
}
}
}
internal override DataContract GetDataContract(int id, RuntimeTypeHandle typeHandle)
{
DataContract contract = null;
if ((this.mode == SerializationMode.SharedType) && (this.surrogateSelector != null))
{
contract = NetDataContractSerializer.GetDataContractFromSurrogateSelector(this.surrogateSelector, base.GetStreamingContext(), typeHandle, null, ref this.surrogateDataContracts);
}
if (contract == null)
{
return(base.GetDataContract(id, typeHandle));
}
if (this.IsGetOnlyCollection && (contract is SurrogateDataContract))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidDataContractException(System.Runtime.Serialization.SR.GetString("SurrogatesWithGetOnlyCollectionsNotSupportedSerDeser", new object[] { DataContract.GetClrTypeFullName(contract.UnderlyingType) })));
}
return(contract);
}
public override void Commit(IDictionary savedState)
{
this.PrintStartText(System.Configuration.Install.Res.GetString("InstallActivityCommitting"));
if (!this.initialized)
{
this.InitializeFromAssembly();
}
string installStatePath = this.GetInstallStatePath(this.Path);
FileStream input = new FileStream(installStatePath, FileMode.Open, FileAccess.Read);
XmlReaderSettings settings = new XmlReaderSettings {
CheckCharacters = false,
CloseInput = false
};
XmlReader reader = null;
if (input != null)
{
reader = XmlReader.Create(input, settings);
}
try
{
if (reader != null)
{
NetDataContractSerializer serializer = new NetDataContractSerializer();
savedState = (Hashtable) serializer.ReadObject(reader);
}
}
finally
{
if (reader != null)
{
reader.Close();
}
if (input != null)
{
input.Close();
}
if (base.Installers.Count == 0)
{
base.Context.LogMessage(System.Configuration.Install.Res.GetString("RemovingInstallState"));
File.Delete(installStatePath);
}
}
base.Commit(savedState);
}
/// <summary>
/// Writes the job status information to the provided
/// file stream.
/// </summary>
/// <param name="job">ScheduledJob job to save</param>
/// <param name="fs">FileStream</param>
private static void SaveStatusToFile(ScheduledJob job, FileStream fs)
{
StatusInfo statusInfo = new StatusInfo(
job.InstanceId,
job.Name,
job.Location,
job.Command,
job.StatusMessage,
job.JobStateInfo.State,
job.HasMoreData,
job.PSBeginTime,
job.PSEndTime,
job.Definition);
XmlObjectSerializer serializer = new System.Runtime.Serialization.NetDataContractSerializer();
serializer.WriteObject(fs, statusInfo);
fs.Flush();
}
public static object DeserializeUsingNetDataContract(string filename)
{
object theObject = null;
int maxDepth = 10000;
bool maxDepthExceeded = true;
while (maxDepthExceeded)
{
try
{
using (FileStream fs = new FileStream(filename, FileMode.Open))
{
XmlDictionaryReaderQuotas quotas = new XmlDictionaryReaderQuotas();
quotas.MaxDepth = maxDepth;
using (XmlDictionaryReader reader = XmlDictionaryReader.CreateTextReader(fs, quotas))
{
NetDataContractSerializer ser = new NetDataContractSerializer();
//ser.Binder = new Version2SerializationBinder();
theObject = (List<ArchAngel.Providers.Database.Model.Database>)ser.ReadObject(reader, true);
}
fs.Close();
maxDepthExceeded = false;
}
}
catch (SerializationException ex)
{
if (ex.Message.IndexOf("more levels of nesting than is allowed by the quota") >= 0)
{
// We need to increase the maxDepth
maxDepth += 1000;
maxDepthExceeded = true;
}
else
{
// We have another kind of error
throw;
}
}
}
return theObject;
}
internal override DataContract GetDataContract(RuntimeTypeHandle typeHandle, Type type)
{
DataContract dataContract = null;
if (mode == SerializationMode.SharedType && surrogateSelector != null)
{
dataContract = NetDataContractSerializer.GetDataContractFromSurrogateSelector(surrogateSelector, GetStreamingContext(), typeHandle, type, ref surrogateDataContracts);
}
if (dataContract != null)
{
if (this.IsGetOnlyCollection && dataContract is SurrogateDataContract)
{
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidDataContractException(SR.GetString(SR.SurrogatesWithGetOnlyCollectionsNotSupportedSerDeser,
DataContract.GetClrTypeFullName(dataContract.UnderlyingType))));
}
return(dataContract);
}
return(base.GetDataContract(typeHandle, type));
}
// Update the overloads whenever you are changing this method
internal static void WriteClrTypeInfo(XmlWriterDelegator writer, Type dataContractType, SerializationBinder binder, SerializationInfo serInfo)
{
TypeInformation typeInformation = null;
string clrTypeName = null;
string clrAssemblyName = null;
if (binder != null)
{
binder.BindToName(dataContractType, out clrAssemblyName, out clrTypeName);
}
if (clrTypeName == null)
{
if (serInfo.IsFullTypeNameSetExplicit)
{
clrTypeName = serInfo.FullTypeName;
}
else
{
typeInformation = NetDataContractSerializer.GetTypeInformation(serInfo.ObjectType);
clrTypeName = typeInformation.FullTypeName;
}
}
if (clrAssemblyName == null)
{
if (serInfo.IsAssemblyNameSetExplicit)
{
clrAssemblyName = serInfo.AssemblyName;
}
else
{
clrAssemblyName = (typeInformation == null) ?
NetDataContractSerializer.GetTypeInformation(serInfo.ObjectType).AssemblyString :
typeInformation.AssemblyString;
}
}
WriteClrTypeInfo(writer, clrTypeName, clrAssemblyName);
}
public void Net_data_contract_serialization_will_not_change_the_type_of_a_collection()
{
using (var session = DataAccess.OpenSession())
{
var forum = session.Get<ForumModel>(1);
//company.EmployeesList made public for the purpose of
//this demo
Assert.AreEqual(typeof(NHibernate.Collection.Generic.PersistentGenericBag<TopicModel>), forum.Topics.GetType());
var serializer = new NetDataContractSerializer();
//serialize company to a memory stream
Stream stream = new MemoryStream();
serializer.WriteObject(stream, forum);
Console.WriteLine();
//deserialize the memory stream back to a company
stream.Position = 0;
forum = (ForumModel)serializer.ReadObject(stream);
Assert.AreEqual(typeof(NHibernate.Collection.Generic.PersistentGenericBag<TopicModel>), forum.Topics.GetType());
}
}
/// <summary>
/// Deserialize data.
/// </summary>
/// <param name="data">Data to deserialize.</param>
/// <param name="encoding">The encoding to use.</param>
/// <returns>The deserialized data.</returns>
public object Deserialize( string data, Encoding encoding = null )
{
if ( encoding == null )
{
encoding = DefaultEncoding;
}
if ( data == null )
{
return null;
}
var bytes = encoding.GetBytes( data );
if ( bytes == null || bytes.Length == 0 )
{
return null;
}
object result;
using ( var memoryStream = new MemoryStream( bytes ) )
{
using ( var xmlDictionaryReader = XmlDictionaryReader.CreateTextReader( memoryStream, encoding, XmlDictionaryReaderQuotas.Max, null ) )
{
var netDataContractSerializer = new NetDataContractSerializer();
result = netDataContractSerializer.ReadObject( xmlDictionaryReader, true );
}
}
if ( result != null && result.GetType() == typeof( NullObject ) )
{
return null;
}
return result;
}
// Update the overloads whenever you are changing this method
internal static void WriteClrTypeInfo(XmlWriterDelegator writer, DataContract dataContract, SerializationBinder binder)
{
if (!dataContract.IsISerializable && !(dataContract is SurrogateDataContract))
{
TypeInformation typeInformation = null;
Type clrType = dataContract.OriginalUnderlyingType;
string clrTypeName = null;
string clrAssemblyName = null;
if (binder != null)
{
binder.BindToName(clrType, out clrAssemblyName, out clrTypeName);
}
if (clrTypeName == null)
{
typeInformation = NetDataContractSerializer.GetTypeInformation(clrType);
clrTypeName = typeInformation.FullTypeName;
}
if (clrAssemblyName == null)
{
clrAssemblyName = (typeInformation == null) ?
NetDataContractSerializer.GetTypeInformation(clrType).AssemblyString :
typeInformation.AssemblyString;
// Throw in the [TypeForwardedFrom] case to prevent a partially trusted assembly from forwarding itself to an assembly with higher privileges
if (!UnsafeTypeForwardingEnabled && !clrType.Assembly.IsFullyTrusted && !IsAssemblyNameForwardingSafe(clrType.Assembly.FullName, clrAssemblyName))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.GetString(SR.TypeCannotBeForwardedFrom, DataContract.GetClrTypeFullName(clrType), clrType.Assembly.FullName, clrAssemblyName)));
}
}
WriteClrTypeInfo(writer, clrTypeName, clrAssemblyName);
}
}
private static void SaveStatusToFile(ScheduledJob job, FileStream fs)
{
StatusInfo statusInfo = new StatusInfo(job.InstanceId, job.Name, job.Location, job.Command, job.StatusMessage, job.JobStateInfo.State, job.HasMoreData, job.PSBeginTime, job.PSEndTime, job.Definition);
XmlObjectSerializer netDataContractSerializer = new NetDataContractSerializer();
netDataContractSerializer.WriteObject(fs, statusInfo);
fs.Flush();
}
private static void SaveResultsToFile(ScheduledJob job, FileStream fs)
{
XmlObjectSerializer netDataContractSerializer = new NetDataContractSerializer();
netDataContractSerializer.WriteObject(fs, job);
fs.Flush();
}
/// <summary>
/// Loads the Job2 object from provided files stream.
/// </summary>
/// <param name="fs">FileStream from which to read job object</param>
/// <returns>Created Job2 from file stream</returns>
private static Job2 LoadResultsFromFile(FileStream fs)
{
XmlObjectSerializer serializer = new System.Runtime.Serialization.NetDataContractSerializer();
return((Job2)serializer.ReadObject(fs));
}
internal XmlObjectSerializerContext(NetDataContractSerializer serializer) : this(serializer, serializer.MaxItemsInObjectGraph, serializer.Context, serializer.IgnoreExtensionDataObject)
{
}
protected XmlObjectSerializerWriteContext(NetDataContractSerializer serializer)
: base(serializer)
{
this.unsafeTypeForwardingEnabled = NetDataContractSerializer.UnsafeTypeForwardingEnabled;
}
protected XmlObjectSerializerReadContext(NetDataContractSerializer serializer) : base(serializer)
{
this.attributes = new Attributes();
}
internal static XmlObjectSerializerReadContext CreateContext(NetDataContractSerializer serializer)
{
return(new XmlObjectSerializerReadContextComplex(serializer));
}
protected XmlObjectSerializerWriteContext(NetDataContractSerializer serializer) : base(serializer)
{
this.byValObjectsInScope = new ObjectReferenceStack();
}
internal static XmlObjectSerializerWriteContext CreateContext(NetDataContractSerializer serializer, Hashtable surrogateDataContracts)
{
return(new XmlObjectSerializerWriteContextComplex(serializer, surrogateDataContracts));
}