// Write constructor
internal void InitSerialize(Object obj, ISurrogateSelector surrogateSelector, StreamingContext context, SerObjectInfoInit serObjectInfoInit, IFormatterConverter converter, ObjectWriter objectWriter)
{
SerTrace.Log(this, objectInfoId, " Constructor 1 ", obj);
this.context = context;
this.obj = obj;
this.serObjectInfoInit = serObjectInfoInit;
ISurrogateSelector surrogateSelectorTemp;
if (RemotingServices.IsTransparentProxy(obj))
{
objectType = Converter.typeofMarshalByRefObject;
}
else
{
objectType = obj.GetType();
}
if (objectType.IsArray)
{
isArray = true;
InitNoMembers();
return;
}
SerTrace.Log(this, objectInfoId, " Constructor 1 trace 2");
objectWriter.ObjectManager.RegisterObject(obj);
if (surrogateSelector != null && (serializationSurrogate = surrogateSelector.GetSurrogate(objectType, context, out surrogateSelectorTemp)) != null)
{
SerTrace.Log(this, objectInfoId, " Constructor 1 trace 3");
si = new SerializationInfo(objectType, converter);
if (!objectType.IsPrimitive)
{
serializationSurrogate.GetObjectData(obj, si, context);
}
InitSiWrite();
}
else if (obj is ISerializable)
{
if (!objectType.IsSerializable)
{
throw new SerializationException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_NonSerType"),
objectType.FullName, objectType.Assembly.FullName));
}
si = new SerializationInfo(objectType, converter);
((ISerializable)obj).GetObjectData(si, context);
SerTrace.Log(this, objectInfoId, " Constructor 1 trace 4 ISerializable " + objectType);
InitSiWrite();
}
else
{
SerTrace.Log(this, objectInfoId, " Constructor 1 trace 5");
InitMemberInfo();
}
}
internal void InitSerialize(object obj, ISurrogateSelector surrogateSelector, StreamingContext context, SerializationObjectInfo serObjectInfoInit, IFormatterConverter converter, ObjectWriter objectWriter, SerializationBinder binder)
{
_context = context;
_obj = obj;
_serObjectInfoInit = serObjectInfoInit;
_objectType = obj.GetType();
if (_objectType.IsArray)
{
_isArray = true;
InitNoMembers();
}
else if (_objectType.IsSerializable)
{
InvokeSerializationBinder(binder);
objectWriter.ObjectManager.RegisterObject(obj);
if (surrogateSelector != null && (_serializationSurrogate = surrogateSelector.GetSurrogate(_objectType, context, out _)) != null)
{
_si = new SerializationInfo(_objectType, converter);
if (!_objectType.IsPrimitive)
{
_serializationSurrogate.GetObjectData(obj, _si, context);
}
InitSiWrite();
}
else if (obj is ISerializable serializable)
{
if (!_objectType.IsSerializable)
{
throw new SerializationException(RemotingResources.NotMarkedForSerialization.Format(_objectType.FullName, _objectType.Assembly.FullName));
}
_si = new SerializationInfo(_objectType, converter);
serializable.GetObjectData(_si, context);
InitSiWrite();
//CheckTypeForwardedFrom(_cache, _objectType, _binderAssemblyString);
}
else
{
InitMemberInfo();
//CheckTypeForwardedFrom(_cache, _objectType, _binderAssemblyString);
}
}
else
{
throw new SerializationException(RemotingResources.NotMarkedForSerialization.Format(_objectType.FullName, _objectType.Assembly.FullName));
}
}
//Gets all the serializable members of an object and return an enumarable collection.
private IEnumerable <SerializationEntry> GetMemberInfo(object objectToSerialize, Type objectToSerializeType, FormatterConverter converter)
{
ISurrogateSelector selector1 = null;
ISerializationSurrogate serializationSurrogate = null;
SerializationInfo info = null;
Type objectType = objectToSerializeType;
//If the passed object is null, break the iteration.
if (objectToSerialize == null)
{
yield break;
}
//Get the serialization surrogate
if (SurrogateSelector == null)
{
throw new NullReferenceException("An error occurred serializing an object. The SurrogateSelector property may not be null.");
}
serializationSurrogate = SurrogateSelector.GetSurrogate(objectType, Context, out selector1);
if (serializationSurrogate == null)
{
throw new NullReferenceException(string.Format("An error occurred serializing an object. A surrogate was not found for type {0}", objectType.Name));
}
//Use the surrogate to get the members.
info = new SerializationInfo(objectType, converter);
//Get the data from the surrogate.
if (!objectType.IsPrimitive)
{
serializationSurrogate.GetObjectData(objectToSerialize, info, Context);
}
//Create the custom entries collection by copying all the members
foreach (System.Runtime.Serialization.SerializationEntry member in info)
{
//SerializationEntry entry = new SerializationEntry(member.Name, member.ObjectType, member.Value);
//yield return will return the entry now and return to this point when
//the enclosing loop (the one that contains the call to this method)
//request the next item.
//yield return entry;
yield return(member);
}
}
private SerializationInfo getSerializationInfo(object graph, IFormatterConverter converter)
{
System.Diagnostics.Debug.Assert(null != graph, "The 'graph' argument cannot be null.");
System.Diagnostics.Debug.Assert(null != converter, "The 'converter' argument cannot be null");
Type graphType = graph.GetType();
ISurrogateSelector selector = null;
ISerializationSurrogate surrogate = this.getSerializationSurrogate(graphType, out selector);
if (null == surrogate)
{
throw new SerializationException(String.Format("No SerializationSurrogate found for Type '{0}' in Assembly '{1}'", graph.GetType().FullName, graph.GetType().Assembly.FullName));
}
SerializationInfo graphInfo = new SerializationInfo(graphType, converter);
surrogate.GetObjectData(graph, graphInfo, this.context);
return(graphInfo);
}
private void SerializeISerializableObject(
object currentObject,
long currentObjectId,
ISerializationSurrogate surrogate)
{
Type currentType = currentObject.GetType();
SerializationInfo info = new SerializationInfo(currentType, new FormatterConverter());
ISerializable objISerializable = currentObject as ISerializable;
if (surrogate != null)
{
surrogate.GetObjectData(currentObject, info, _context);
}
else
{
objISerializable.GetObjectData(info, _context);
}
// Same as above
if (currentObjectId > 0L)
{
Element element = _mapper.GetXmlElement(info.FullTypeName, info.AssemblyName);
_xmlWriter.WriteStartElement(element.Prefix, element.LocalName, element.NamespaceURI);
Id(currentObjectId);
}
foreach (SerializationEntry entry in info)
{
_xmlWriter.WriteStartElement(XmlConvert.EncodeLocalName(entry.Name));
SerializeComponent(entry.Value, IsEncodingNeeded(entry.Value, null));
_xmlWriter.WriteEndElement();
}
if (currentObjectId > 0)
{
_xmlWriter.WriteFullEndElement();
}
}
/// <summary>
/// Populates the provided <see cref="SerializationInfo"/> with the data needed to
/// serialize the object and records that the object was unconditionally written.
/// </summary>
/// <param name="obj">The object to serialize.</param>
/// <param name="info">The <see cref="SerializationInfo"/> to populate with data.</param>
/// <param name="context">
/// The destination (see <see cref="StreamingContext"/>) for this serialization.
/// </param>
public void GetObjectData(Object obj, SerializationInfo info, StreamingContext context)
{
if (!unconditionallyWritten.Contains(obj))
{
// Record that the object was unconditionally written.
if (!obj.GetType().IsValueType)
{
unconditionallyWritten.Add(obj, true);
}
// If there is an actual surrogate for this type of object, use the surrogate
// to populate the SerializationInfo. Otherwise, if the object implements
// ISerializable, use the object's GetObjectData method to populate the
// SerializationInfo. Otherwise, get the serializable members of the object
// and write them directly to the SerializationInfo.
if (actualSurrogate != null)
{
actualSurrogate.GetObjectData(obj, info, context);
}
else if (obj is ISerializable)
{
((ISerializable)obj).GetObjectData(info, context);
}
else
{
// Serialize serializable members
Type objType = obj.GetType();
MemberInfo[] mi = FormatterServices.GetSerializableMembers(objType, context);
for (int i = 0; i < mi.Length; i++)
{
info.AddValue(mi[i].Name, ((FieldInfo)mi[i]).GetValue(obj));
}
}
}
}
// Write constructor
internal void InitSerialize(Object obj, ISurrogateSelector surrogateSelector, StreamingContext context, SerObjectInfoInit serObjectInfoInit, IFormatterConverter converter, ObjectWriter objectWriter)
{
SerTrace.Log( this, objectInfoId," Constructor 1 ",obj);
this.context = context;
this.obj = obj;
this.serObjectInfoInit = serObjectInfoInit;
ISurrogateSelector surrogateSelectorTemp;
if (RemotingServices.IsTransparentProxy(obj))
objectType = Converter.typeofMarshalByRefObject;
else
objectType = obj.GetType();
if (objectType.IsArray)
{
isArray = true;
InitNoMembers();
return;
}
SerTrace.Log( this, objectInfoId," Constructor 1 trace 2");
objectWriter.ObjectManager.RegisterObject(obj);
if (surrogateSelector != null && (serializationSurrogate = surrogateSelector.GetSurrogate(objectType, context, out surrogateSelectorTemp)) != null)
{
SerTrace.Log( this, objectInfoId," Constructor 1 trace 3");
si = new SerializationInfo(objectType, converter);
if (!objectType.IsPrimitive)
serializationSurrogate.GetObjectData(obj, si, context);
InitSiWrite();
}
else if (obj is ISerializable)
{
if (!objectType.IsSerializable) {
throw new SerializationException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_NonSerType"),
objectType.FullName, objectType.Assembly.FullName));
}
si = new SerializationInfo(objectType, converter);
((ISerializable)obj).GetObjectData(si, context);
SerTrace.Log( this, objectInfoId," Constructor 1 trace 4 ISerializable "+objectType);
InitSiWrite();
}
else
{
SerTrace.Log(this, objectInfoId," Constructor 1 trace 5");
InitMemberInfo();
}
}
/// <summary>
/// Write the specified value.
/// </summary>
/// <param name="value">Value.</param>
public override void Write(object value)
{
if (value == null)
{
m_Writer.Write("null");
}
else
{
Type type = value.GetType();
if (type == typeof(string) || type.IsEnum)
{
m_Writer.Write("\"{0}\"", value);
}
else if (type == typeof(short) || type == typeof(int) || type == typeof(long) ||
type == typeof(ushort) || type == typeof(uint) || type == typeof(ulong) ||
type == typeof(byte) || type == typeof(sbyte) || type == typeof(decimal) ||
type == typeof(double) || type == typeof(float))
{
m_Writer.Write(Convert.ChangeType(value, typeof(string)));
}
else if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(KeyValuePair <,>))
{
m_Writer.Write("{");
Write("Key");
m_Writer.Write(":");
Write(type.GetProperty("Key").GetValue(value, BindingFlags.Default, null, null, null));
m_Writer.Write(",");
Write("Value");
m_Writer.Write(":");
Write(type.GetProperty("Value").GetValue(value, BindingFlags.Default, null, null, null));
m_Writer.Write("}");
}
else if (value is IDictionary)
{
IDictionary dictionary = value as IDictionary;
bool isFirst = true;
m_Writer.Write("{");
foreach (var key in dictionary.Keys)
{
if (isFirst)
{
isFirst = false;
}
else
{
m_Writer.Write(",");
}
Write(key);
m_Writer.Write(":");
Write(dictionary[key]);
}
m_Writer.Write("}");
}
else if (value is IEnumerable)
{
IEnumerable enumerable = value as IEnumerable;
IEnumerator e = enumerable.GetEnumerator();
bool isFirst = true;
m_Writer.Write("[");
while (e.MoveNext())
{
if (isFirst)
{
isFirst = false;
}
else
{
m_Writer.Write(",");
}
Write(e.Current);
}
m_Writer.Write("]");
}
else if (value is ISerializable)
{
SerializationInfo info = new SerializationInfo(type, new FormatterConverter());
ISerializable serializable = value as ISerializable;
serializable.GetObjectData(info, m_Context);
WriteSerializationInfo(info);
}
else
{
if (m_SurrogateSelector != null)
{
ISurrogateSelector selector;
ISerializationSurrogate surrogate = m_SurrogateSelector.GetSurrogate(type, m_Context, out selector);
if (surrogate != null)
{
SerializationInfo info = new SerializationInfo(type, new FormatterConverter());
surrogate.GetObjectData(value, info, m_Context);
WriteSerializationInfo(info);
}
}
else
{
WriteObject(value, type);
}
}
}
}
// Write constructor
// [System.Security.SecurityCritical] // auto-generated
internal void InitSerialize(Object obj, ISurrogateSelector surrogateSelector, StreamingContext context, SerObjectInfoInit serObjectInfoInit, IFormatterConverter converter, ObjectWriter objectWriter, SerializationBinder binder)
{
SerTrace.Log(this, objectInfoId, " Constructor 1 ", obj);
this.context = context;
this.obj = obj;
this.serObjectInfoInit = serObjectInfoInit;
ISurrogateSelector surrogateSelectorTemp;
#if FEATURE_REMOTING
if (RemotingServices.IsTransparentProxy(obj))
{
objectType = Converter.typeofMarshalByRefObject;
}
else
#endif
objectType = obj.GetType();
if (objectType.IsArray)
{
isArray = true;
InitNoMembers();
return;
}
InvokeSerializationBinder(binder);
SerTrace.Log(this, objectInfoId, " Constructor 1 trace 2");
objectWriter.ObjectManager.RegisterObject(obj);
if (surrogateSelector != null && (serializationSurrogate = surrogateSelector.GetSurrogate(objectType, context, out surrogateSelectorTemp)) != null)
{
SerTrace.Log(this, objectInfoId, " Constructor 1 trace 3");
si = new SerializationInfo(objectType, converter);
if (!objectType.IsPrimitive)
{
serializationSurrogate.GetObjectData(obj, si, context);
}
InitSiWrite();
}
else if (obj is ISerializable)
{
if (!objectType.IsSerializable)
{
throw new SerializationException(Ssz.Runtime.Serialization.Environment.GetResourceString("Serialization_NonSerType",
objectType.FullName, objectType.Assembly.FullName));
}
si = new SerializationInfo(objectType, converter, !FormatterServices.UnsafeTypeForwardersIsEnabled());
#if FEATURE_SERIALIZATION
((ISerializable)obj).GetObjectData(si, context);
#endif
SerTrace.Log(this, objectInfoId, " Constructor 1 trace 4 ISerializable " + objectType);
InitSiWrite();
CheckTypeForwardedFrom(cache, objectType, binderAssemblyString);
}
else
{
SerTrace.Log(this, objectInfoId, " Constructor 1 trace 5");
InitMemberInfo();
CheckTypeForwardedFrom(cache, objectType, binderAssemblyString);
}
}
private void GetObjectData(object obj, out TypeMetadata metadata, out object data)
{
Type instanceType = obj.GetType();
// Check if the formatter has a surrogate selector, if it does,
// check if the surrogate selector handles objects of the given type.
if (_surrogateSelector != null)
{
ISurrogateSelector selector;
ISerializationSurrogate surrogate = _surrogateSelector.GetSurrogate(instanceType, _context, out selector);
if (surrogate != null)
{
SerializationInfo info = new SerializationInfo(instanceType, new FormatterConverter());
surrogate.GetObjectData(obj, info, _context);
metadata = new SerializableTypeMetadata(instanceType, info);
data = info;
return;
}
}
// Check if the object is marked with the Serializable attribute
BinaryCommon.CheckSerializable(instanceType, _surrogateSelector, _context);
#if NET_2_0
_manager.RegisterObject(obj);
#endif
ISerializable ser = obj as ISerializable;
if (ser != null)
{
SerializationInfo info = new SerializationInfo(instanceType, new FormatterConverter());
ser.GetObjectData(info, _context);
metadata = new SerializableTypeMetadata(instanceType, info);
data = info;
}
else
{
data = obj;
if (_context.Context != null)
{
// Don't cache metadata info when the Context property is not null sice
// we can't control the number of possible contexts in this case
metadata = new MemberTypeMetadata(instanceType, _context);
return;
}
Hashtable typesTable;
bool isNew = false;
lock (_cachedTypes) {
typesTable = (Hashtable)_cachedTypes [_context.State];
if (typesTable == null)
{
typesTable = new Hashtable();
_cachedTypes [_context.State] = typesTable;
isNew = true;
}
}
metadata = null;
lock (typesTable) {
if (!isNew)
{
metadata = (TypeMetadata)typesTable [instanceType];
}
if (metadata == null)
{
metadata = CreateMemberTypeMetadata(instanceType);
}
typesTable [instanceType] = metadata;
}
}
}
[System.Security.SecurityCritical] // auto-generated
internal void InitSerialize(Object obj, ISurrogateSelector surrogateSelector, StreamingContext context, SerObjectInfoInit serObjectInfoInit, IFormatterConverter converter, ObjectWriter objectWriter, SerializationBinder binder)
{
SerTrace.Log( this, objectInfoId," Constructor 1 ",obj);
this.context = context;
this.obj = obj;
this.serObjectInfoInit = serObjectInfoInit;
ISurrogateSelector surrogateSelectorTemp;
#if FEATURE_REMOTING
if (RemotingServices.IsTransparentProxy(obj))
objectType = Converter.typeofMarshalByRefObject;
else
#endif
objectType = obj.GetType();
if (objectType.IsArray)
{
isArray = true;
InitNoMembers();
return;
}
InvokeSerializationBinder(binder);
SerTrace.Log( this, objectInfoId," Constructor 1 trace 2");
objectWriter.ObjectManager.RegisterObject(obj);
if (surrogateSelector != null && (serializationSurrogate = surrogateSelector.GetSurrogate(objectType, context, out surrogateSelectorTemp)) != null)
{
SerTrace.Log( this, objectInfoId," Constructor 1 trace 3");
si = new SerializationInfo(objectType, converter);
if (!objectType.IsPrimitive)
serializationSurrogate.GetObjectData(obj, si, context);
InitSiWrite();
}
else if (obj is ISerializable)
{
if (!objectType.IsSerializable) {
throw new SerializationException(Environment.GetResourceString("Serialization_NonSerType",
objectType.FullName, objectType.Assembly.FullName));
}
si = new SerializationInfo(objectType, converter, !FormatterServices.UnsafeTypeForwardersIsEnabled());
#if FEATURE_SERIALIZATION
((ISerializable)obj).GetObjectData(si, context);
#endif
SerTrace.Log( this, objectInfoId," Constructor 1 trace 4 ISerializable "+objectType);
InitSiWrite();
CheckTypeForwardedFrom(cache, objectType, binderAssemblyString);
}
else
{
SerTrace.Log(this, objectInfoId," Constructor 1 trace 5");
InitMemberInfo();
CheckTypeForwardedFrom(cache, objectType, binderAssemblyString);
}
}
internal static object GetObjectData(object serObj, out string typeName, out string assemName, out string[] fieldNames, out object[] fieldValues)
{
Type type = null;
object obj2 = null;
if (RemotingServices.IsTransparentProxy(serObj))
{
type = typeof(MarshalByRefObject);
}
else
{
type = serObj.GetType();
}
SerializationInfo info = new SerializationInfo(type, s_converter);
if (serObj is ObjRef)
{
s_ObjRefRemotingSurrogate.GetObjectData(serObj, info, s_cloneContext);
}
else if (RemotingServices.IsTransparentProxy(serObj) || (serObj is MarshalByRefObject))
{
if (!RemotingServices.IsTransparentProxy(serObj) || (RemotingServices.GetRealProxy(serObj) is RemotingProxy))
{
ObjRef ref2 = RemotingServices.MarshalInternal((MarshalByRefObject)serObj, null, null);
if (ref2.CanSmuggle())
{
if (RemotingServices.IsTransparentProxy(serObj))
{
RealProxy realProxy = RemotingServices.GetRealProxy(serObj);
ref2.SetServerIdentity(realProxy._srvIdentity);
ref2.SetDomainID(realProxy._domainID);
}
else
{
ServerIdentity identity = (ServerIdentity)MarshalByRefObject.GetIdentity((MarshalByRefObject)serObj);
identity.SetHandle();
ref2.SetServerIdentity(identity.GetHandle());
ref2.SetDomainID(AppDomain.CurrentDomain.GetId());
}
ref2.SetMarshaledObject();
obj2 = ref2;
}
}
if (obj2 == null)
{
s_RemotingSurrogate.GetObjectData(serObj, info, s_cloneContext);
}
}
else
{
if (!(serObj is ISerializable))
{
throw new ArgumentException(Environment.GetResourceString("Arg_SerializationException"));
}
((ISerializable)serObj).GetObjectData(info, s_cloneContext);
}
if (obj2 == null)
{
typeName = info.FullTypeName;
assemName = info.AssemblyName;
fieldNames = info.MemberNames;
fieldValues = info.MemberValues;
return(obj2);
}
typeName = null;
assemName = null;
fieldNames = null;
fieldValues = null;
return(obj2);
}
internal void Serialize(object graph, Type expectedType)
{
Type graphType = graph == null ? null : graph.GetType();
TypeCode code = Type.GetTypeCode(graphType);
code = code == TypeCode.Object && graphType == SerializationStaticHelpers.RuntimeType ? (TypeCode)19 : code;
code = graph != null && graph is Enum ? TypeCode.Object : code;
this._writer.Write((byte)code);
if (code == TypeCode.Object)
{
ushort objId = 1;
bool first;
objId = (ushort)this._objIdGenerator.GetId(graph, out first);
this._writer.Write(objId);
if (first)
{
ISurrogateSelector selector = null;
ISerializationSurrogate surrogate = this._selector == null ? null : this._selector.GetSurrogate(graphType, this._context, out selector);
this._selector = selector == null ? this._selector : selector;
if (graphType.IsArray)
{
this.typeWriter(graphType, expectedType);
Array arrayGraph = (Array)graph;
for (int i = 0; i < arrayGraph.Rank; i++) //Rank değeri Type'ın içinde gidiyor.
{
this._writer.Write(arrayGraph.GetLength(i));
}
this.getArrayValues(arrayGraph, graphType);
}
else if (SerializationStaticHelpers.TypeOfISerializable.IsAssignableFrom(graphType))
{
SerializationInfo info = new SerializationInfo(graphType, SerializationStaticHelpers.FormatterConverter);
((ISerializable)graph).GetObjectData(info, this._context);
Type infoObjType = this._binder == null?Type.GetType(info.FullTypeName + ", " + info.AssemblyName) : this._binder.BindToType(info.AssemblyName, info.FullTypeName);
if (infoObjType != graphType)
{
graphType = infoObjType;
}
this.typeWriter(graphType, expectedType);
this.getISerializableValues(info, graphType);
}
else if (surrogate == null)
{
this.typeWriter(graphType, expectedType);
this.getObjectValues(graph, graphType);
}
else
{
SerializationInfo info = new SerializationInfo(graphType, SerializationStaticHelpers.FormatterConverter);
surrogate.GetObjectData(graph, info, this._context);
this.typeWriter(graphType, expectedType);
this.getISerializableValues(info, graphType);
}
}
}
else if (code == TypeCode.String)
{
string strGraph = (string)graph;
short index = (short)this._stringContents.IndexOf(strGraph);
this._writer.Write(index);
if (index == -1)
{
this._writer.Write(strGraph);
}
}
else
{
if (code == (TypeCode)19)
{
this.typeWriter(graph as Type, expectedType);
}
else
{
SerializationStaticHelpers.WritePrimitive(this._writer, graph, code);
}
}
}
/// <summary>
/// Gets all the serializable members of an object and return an enumarable collection.
/// </summary>
/// <param name="objectToSerialize">The object to get the members from.</param>
/// <param name="objectToSerializeType">The type of the object.</param>
/// <param name="converter">The converter to use when converting simple types.</param>
/// <returns>An IEnumerable list of <see cref="CustomSerializationEntry"/> entries.</returns>
private IEnumerable <CustomSerializationEntry> GetMemberInfo(object objectToSerialize, Type objectToSerializeType, FormatterConverter converter)
{
ISurrogateSelector selector1 = null;
ISerializationSurrogate serializationSurrogate = null;
SerializationInfo info = null;
Type objectType = objectToSerializeType;
// if the passed object is null, break the iteration.
if (objectToSerialize == null)
{
yield break;
}
if ((SurrogateSelector != null) && ((serializationSurrogate = SurrogateSelector.GetSurrogate(objectType, Context, out selector1)) != null))
{
// use a surrogate to get the members.
info = new SerializationInfo(objectType, converter);
if (!objectType.IsPrimitive)
{
// get the data from the surrogate.
serializationSurrogate.GetObjectData(objectToSerialize, info, Context);
}
}
else if (objectToSerialize is ISerializable)
{
// object implements ISerializable
if (!objectType.IsSerializable)
{
throw new SerializationException(string.Format("Type is not serializable : {0}.", objectType.FullName));
}
info = new SerializationInfo(objectType, converter);
// get the data using ISerializable.
((ISerializable)objectToSerialize).GetObjectData(info, Context);
}
if (info != null)
{
// either the surrogate provided the members, or the members were retrieved
// using ISerializable.
// create the custom entries collection by copying all the members
foreach (SerializationEntry member in info)
{
CustomSerializationEntry entry = new CustomSerializationEntry(member.Name, member.ObjectType, false, member.Value);
// yield return will return the entry now and return to this point when
// the enclosing loop (the one that contains the call to this method)
// request the next item.
yield return(entry);
}
}
else
{
// The item does not hava surrogate, not does it implement ISerializable.
// We use reflection to get the objects state.
if (!objectType.IsSerializable)
{
throw new SerializationException(string.Format("Type is not serializable : {0}.", objectType.FullName));
}
// Get all serializable members
MemberInfo[] members = FormatterServices.GetSerializableMembers(objectType, Context);
foreach (MemberInfo member in members)
{
if (CanSerialize(member))
{
// create the entry
CustomSerializationEntry entry = new CustomSerializationEntry(member.Name, member.ReflectedType, false);
if (typeof(IList).IsAssignableFrom(entry.ObjectType))
{
entry.IsList = true;
}
// get the value of the member
entry.Value = GetMemberValue(objectToSerialize, member);
// yield return will return the entry now and return to this point when
// the enclosing loop (the one that contains the call to this method)
// request the next item.
yield return(entry);
}
}
}
}
// Write constructor
internal void InitSerialize(object obj, ISurrogateSelector surrogateSelector, StreamingContext context, SerObjectInfoInit serObjectInfoInit, IFormatterConverter converter, ObjectWriter objectWriter, SerializationBinder binder)
{
_context = context;
_obj = obj;
_serObjectInfoInit = serObjectInfoInit;
_objectType = obj.GetType();
if (_objectType.IsArray)
{
_isArray = true;
InitNoMembers();
return;
}
InvokeSerializationBinder(binder);
objectWriter.ObjectManager.RegisterObject(obj);
ISurrogateSelector surrogateSelectorTemp;
if (surrogateSelector != null && (_serializationSurrogate = surrogateSelector.GetSurrogate(_objectType, context, out surrogateSelectorTemp)) != null)
{
_si = new SerializationInfo(_objectType, converter);
if (!_objectType.IsPrimitive)
{
_serializationSurrogate.GetObjectData(obj, _si, context);
}
InitSiWrite();
}
else if (obj is ISerializable)
{
if (!_objectType.IsSerializable)
{
throw new SerializationException(SR.Format(SR.Serialization_NonSerType, _objectType.FullName, _objectType.Assembly.FullName));
}
_si = new SerializationInfo(_objectType, converter);
((ISerializable)obj).GetObjectData(_si, context);
InitSiWrite();
CheckTypeForwardedFrom(_cache, _objectType, _binderAssemblyString);
}
else
{
InitMemberInfo();
CheckTypeForwardedFrom(_cache, _objectType, _binderAssemblyString);
}
}
public void GetObjectData(object obj, SerializationInfo info, StreamingContext context)
{
_innerSurrogate.GetObjectData(obj, info, context);
}
/// <summary>
/// Write the specified value.
/// </summary>
/// <param name="value">Value.</param>
public virtual void Write(object value)
{
if (value == null)
{
m_Writer.Write(0);
}
else
{
Type type = value.GetType();
if (type.IsPrimitive || type == typeof(string) || type == typeof(decimal))
{
if (type == typeof(string))
{
m_Writer.Write(( string )value);
}
else if (type == typeof(decimal))
{
m_Writer.Write(( decimal )value);
}
else if (type == typeof(short))
{
m_Writer.Write(( short )value);
}
else if (type == typeof(int))
{
m_Writer.Write(( int )value);
}
else if (type == typeof(long))
{
m_Writer.Write(( long )value);
}
else if (type == typeof(ushort))
{
m_Writer.Write(( ushort )value);
}
else if (type == typeof(uint))
{
m_Writer.Write(( uint )value);
}
else if (type == typeof(ulong))
{
m_Writer.Write(( ulong )value);
}
else if (type == typeof(double))
{
m_Writer.Write(( double )value);
}
else if (type == typeof(float))
{
m_Writer.Write(( float )value);
}
else if (type == typeof(byte))
{
m_Writer.Write(( byte )value);
}
else if (type == typeof(sbyte))
{
m_Writer.Write(( sbyte )value);
}
else if (type == typeof(char))
{
m_Writer.Write(( char )value);
}
else if (type == typeof(bool))
{
m_Writer.Write(( bool )value);
}
}
else if (type.IsEnum)
{
m_Writer.Write(value.ToString());
}
else if (type == typeof(DateTime))
{
m_Writer.Write((( DateTime )value).ToBinary());
}
else if (type == typeof(TimeSpan))
{
m_Writer.Write((( TimeSpan )value).ToString());
}
else if (value is ISerializable)
{
SerializationInfo info = new SerializationInfo(type, new FormatterConverter());
ISerializable serializable = value as ISerializable;
serializable.GetObjectData(info, m_Context);
WriteSerializationInfo(info);
}
else if (type.IsSerializable && !type.IsArray)
{
WriteObject(value, type);
}
else if (type.IsArray)
{
Array array = value as Array;
m_Writer.Write(array.Rank);
for (int i = 0; i < array.Rank; i++)
{
m_Writer.Write(array.GetLength(i));
}
int [] indices = new int[array.Rank];
for (int i = 0; i < array.Rank; i++)
{
for (int j = 0; j < array.GetLength(i); j++)
{
indices [i] = j;
Write(array.GetValue(indices));
}
}
}
else if (value is IEnumerable && value is ICollection)
{
IEnumerable enumerable = value as IEnumerable;
ICollection collection = value as ICollection;
IEnumerator e = enumerable.GetEnumerator();
m_Writer.Write(collection.Count);
while (e.MoveNext())
{
Write(e.Current);
}
}
else if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(KeyValuePair <,>))
{
Write(type.GetProperty("Key").GetValue(value, BindingFlags.Default, null, null, null));
Write(type.GetProperty("Value").GetValue(value, BindingFlags.Default, null, null, null));
}
else
{
ISerializationSurrogate surrogate = null;
if (m_SurrogateSelector != null)
{
ISurrogateSelector selector;
surrogate = m_SurrogateSelector.GetSurrogate(type, m_Context, out selector);
if (surrogate != null)
{
SerializationInfo info = new SerializationInfo(type, new FormatterConverter());
surrogate.GetObjectData(value, info, m_Context);
WriteSerializationInfo(info);
}
}
if (surrogate == null)
{
WriteObject(value, type);
}
}
}
}
private void SerializeISerializableObject(
object currentObject,
long currentObjectId,
ISerializationSurrogate surrogate)
{
Type currentType = currentObject.GetType();
SerializationInfo info = new SerializationInfo(currentType, new FormatterConverter());
ISerializable objISerializable = currentObject as ISerializable;
if(surrogate != null) surrogate.GetObjectData(currentObject, info, _context);
else
{
objISerializable.GetObjectData(info, _context);
}
// Same as above
if(currentObjectId > 0L)
{
Element element = _mapper. GetXmlElement (info.FullTypeName, info.AssemblyName);
_xmlWriter.WriteStartElement(element.Prefix, element.LocalName, element.NamespaceURI);
Id(currentObjectId);
}
foreach(SerializationEntry entry in info)
{
_xmlWriter.WriteStartElement(XmlConvert.EncodeLocalName (entry.Name));
SerializeComponent(entry.Value, IsEncodingNeeded(entry.Value, null));
_xmlWriter.WriteEndElement();
}
if(currentObjectId > 0)
_xmlWriter.WriteFullEndElement();
}
// Write constructor
internal void InitSerialize(Object obj, ISurrogateSelector surrogateSelector, StreamingContext context, SerObjectInfoInit serObjectInfoInit, IFormatterConverter converter, SoapAttributeInfo attributeInfo)
{
InternalST.Soap( this, objectInfoId," Constructor 1 ",obj);
this.context = context;
this.obj = obj;
this.serObjectInfoInit = serObjectInfoInit;
this.parentMemberAttributeInfo = attributeInfo;
this.surrogateSelector = surrogateSelector;
this.converter = converter;
ISurrogateSelector surrogateSelectorTemp;
if (RemotingServices.IsTransparentProxy(obj))
objectType = Converter.typeofMarshalByRefObject;
else
objectType = obj.GetType();
if (objectType.IsArray)
{
arrayElemObjectInfo = Serialize(objectType.GetElementType(), surrogateSelector, context, serObjectInfoInit, converter, null);
typeAttributeInfo = GetTypeAttributeInfo();
isArray = true;
InitNoMembers();
return;
}
InternalST.Soap( this, objectInfoId," Constructor 1 trace 2");
typeAttributeInfo = GetTypeAttributeInfo();
if (surrogateSelector != null && (serializationSurrogate = surrogateSelector.GetSurrogate(objectType, context, out surrogateSelectorTemp)) != null)
{
InternalST.Soap( this, objectInfoId," Constructor 1 trace 3");
si = new SerializationInfo(objectType, converter);
if (!objectType.IsPrimitive)
serializationSurrogate.GetObjectData(obj, si, context);
InitSiWrite();
}
else if (obj is ISerializable)
{
if (!objectType.IsSerializable)
{
throw new SerializationException(String.Format(SoapUtil.GetResourceString("Serialization_NonSerType"),
objectType.FullName, objectType.Module.Assembly.FullName));
}
si = new SerializationInfo(objectType, converter);
((ISerializable)obj).GetObjectData(si, context);
InternalST.Soap( this, objectInfoId," Constructor 1 trace 4 ISerializable "+objectType);
InitSiWrite();
}
else
{
InternalST.Soap(this, objectInfoId," Constructor 1 trace 5");
InitMemberInfo();
}
}
[System.Security.SecurityCritical] // auto-generated
internal void InitSerialize(Object obj, ISurrogateSelector surrogateSelector, StreamingContext context, SerObjectInfoInit serObjectInfoInit, IFormatterConverter converter, ObjectWriter objectWriter, SerializationBinder binder)
{
SerTrace.Log(this, objectInfoId, " Constructor 1 ", obj);
this.context = context;
this.obj = obj;
this.serObjectInfoInit = serObjectInfoInit;
ISurrogateSelector surrogateSelectorTemp;
#if FEATURE_REMOTING
if (RemotingServices.IsTransparentProxy(obj))
{
objectType = Converter.typeofMarshalByRefObject;
}
else
#endif
objectType = obj.GetType();
if (objectType.IsArray)
{
isArray = true;
InitNoMembers();
return;
}
InvokeSerializationBinder(binder);
SerTrace.Log(this, objectInfoId, " Constructor 1 trace 2");
objectWriter.ObjectManager.RegisterObject(obj);
if (surrogateSelector != null && (serializationSurrogate = surrogateSelector.GetSurrogate(objectType, context, out surrogateSelectorTemp)) != null)
{
SerTrace.Log(this, objectInfoId, " Constructor 1 trace 3");
si = new SerializationInfo(objectType, converter);
if (!objectType.IsPrimitive)
{
serializationSurrogate.GetObjectData(obj, si, context);
}
InitSiWrite();
}
else if (obj is ISerializable)
{
if (!objectType.IsSerializable)
{
throw new SerializationException(Environment.GetResourceString("Serialization_NonSerType",
objectType.FullName, objectType.Assembly.FullName));
}
Assembly mscorlibAsm = Assembly.Load("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089");
var FormatterServicesRef = mscorlibAsm.GetType("System.Runtime.Serialization.FormatterServices");
var unsafeTypeForwardersIsEnabled = FormatterServicesRef.GetMethod("UnsafeTypeForwardersIsEnabled", BindingFlags.Static | BindingFlags.NonPublic);
var unsafeTypeForwardersIsEnabledResult = (bool)unsafeTypeForwardersIsEnabled.Invoke(null, new object[] { });
si = new SerializationInfo(objectType, converter, !unsafeTypeForwardersIsEnabledResult);
//si = new SerializationInfo(objectType, converter, !FormatterServices.UnsafeTypeForwardersIsEnabled());
//#if FEATURE_SERIALIZATION
((ISerializable)obj).GetObjectData(si, context);
//#endif
SerTrace.Log(this, objectInfoId, " Constructor 1 trace 4 ISerializable " + objectType);
InitSiWrite();
CheckTypeForwardedFrom(cache, objectType, binderAssemblyString);
}
else
{
SerTrace.Log(this, objectInfoId, " Constructor 1 trace 5");
InitMemberInfo();
CheckTypeForwardedFrom(cache, objectType, binderAssemblyString);
}
}
[System.Security.SecurityCritical] // auto-generated
internal static object GetObjectData(object serObj, out string typeName, out string assemName, out string[] fieldNames, out object[] fieldValues)
{
Type objectType = null;
object retObj = null;
if (RemotingServices.IsTransparentProxy(serObj))
{
objectType = typeof(MarshalByRefObject);
}
else
{
objectType = serObj.GetType();
}
SerializationInfo si = new SerializationInfo(objectType, s_converter);
if (serObj is ObjRef)
{
s_ObjRefRemotingSurrogate.GetObjectData(serObj, si, s_cloneContext);
}
else if (RemotingServices.IsTransparentProxy(serObj) || serObj is MarshalByRefObject)
{
#if !MONO
// We can only try to smuggle objref's for actual CLR objects
// or for RemotingProxy's.
if (!RemotingServices.IsTransparentProxy(serObj) ||
RemotingServices.GetRealProxy(serObj) is RemotingProxy)
{
ObjRef objRef = RemotingServices.MarshalInternal((MarshalByRefObject)serObj, null, null);
if (objRef.CanSmuggle())
{
if (RemotingServices.IsTransparentProxy(serObj))
{
RealProxy rp = RemotingServices.GetRealProxy(serObj);
objRef.SetServerIdentity(rp._srvIdentity);
objRef.SetDomainID(rp._domainID);
}
else
{
ServerIdentity srvId = (ServerIdentity)MarshalByRefObject.GetIdentity((MarshalByRefObject)serObj);
srvId.SetHandle();
objRef.SetServerIdentity(srvId.GetHandle());
objRef.SetDomainID(AppDomain.CurrentDomain.GetId());
}
objRef.SetMarshaledObject();
retObj = objRef;
}
}
#endif
if (retObj == null)
{
// Deal with the non-smugglable remoting objects
s_RemotingSurrogate.GetObjectData(serObj, si, s_cloneContext);
}
}
else if (serObj is ISerializable)
{
((ISerializable)serObj).GetObjectData(si, s_cloneContext);
}
else
{
// Getting here means a bug in cloner
throw new ArgumentException(Environment.GetResourceString("Arg_SerializationException"));
}
if (retObj == null)
{
typeName = si.FullTypeName;
assemName = si.AssemblyName;
fieldNames = si.MemberNames;
fieldValues = si.MemberValues;
}
else
{
typeName = null;
assemName = null;
fieldNames = null;
fieldValues = null;
}
return(retObj);
}
private void GetObjectData(object obj, out TypeMetadata metadata, out object data)
{
Type type = obj.GetType();
if (this._surrogateSelector != null)
{
ISurrogateSelector surrogateSelector;
ISerializationSurrogate surrogate = this._surrogateSelector.GetSurrogate(type, this._context, out surrogateSelector);
if (surrogate != null)
{
SerializationInfo serializationInfo = new SerializationInfo(type, new FormatterConverter());
surrogate.GetObjectData(obj, serializationInfo, this._context);
metadata = new SerializableTypeMetadata(type, serializationInfo);
data = serializationInfo;
return;
}
}
BinaryCommon.CheckSerializable(type, this._surrogateSelector, this._context);
this._manager.RegisterObject(obj);
ISerializable serializable = obj as ISerializable;
if (serializable != null)
{
SerializationInfo serializationInfo2 = new SerializationInfo(type, new FormatterConverter());
serializable.GetObjectData(serializationInfo2, this._context);
metadata = new SerializableTypeMetadata(type, serializationInfo2);
data = serializationInfo2;
}
else
{
data = obj;
if (this._context.Context != null)
{
metadata = new MemberTypeMetadata(type, this._context);
return;
}
bool flag = false;
Hashtable cachedTypes = ObjectWriter._cachedTypes;
Hashtable hashtable;
lock (cachedTypes)
{
hashtable = (Hashtable)ObjectWriter._cachedTypes[this._context.State];
if (hashtable == null)
{
hashtable = new Hashtable();
ObjectWriter._cachedTypes[this._context.State] = hashtable;
flag = true;
}
}
metadata = null;
Hashtable obj2 = hashtable;
lock (obj2)
{
if (!flag)
{
metadata = (TypeMetadata)hashtable[type];
}
if (metadata == null)
{
metadata = this.CreateMemberTypeMetadata(type);
}
hashtable[type] = metadata;
}
}
}