private void WriteObject(object graph)
{
_writer.WriteStartObject();
_writer.WritePropertyName(ID_TYPE);
_writer.WriteValue(graph.GetType().FullName);
var members = FormatterServices.GetSerializableMembers(graph.GetType(), Context);
var objs = FormatterServices.GetObjectData(graph, members);
for (int i = 0; i < objs.Length; i++)
{
_writer.WritePropertyName(members[i].Name);
if (objs[i] == null)
{
_writer.WriteValue(null);
continue;
}
else
{
this.WriteValue(objs[i]);
}
}
_writer.WriteEndObject();
}
// used by the server when an exception is thrown
// by the called function
internal ServerFault CreateServerFault(Exception e)
{
// it's really strange here
// a ServerFault object has a private System.Exception member called *exception*
// (have a look at a MS Soap message when an exception occurs on the server)
// but there is not public .ctor with an Exception as parameter...????....
// (maybe an internal one). So I searched another way...
ServerFault sf = (ServerFault)FormatterServices.GetUninitializedObject(typeof(ServerFault));
MemberInfo[] mi = FormatterServices.GetSerializableMembers(typeof(ServerFault), new StreamingContext(StreamingContextStates.All));
FieldInfo fi;
object[] mv = new object[mi.Length];
for (int i = 0; i < mi.Length; i++)
{
fi = mi[i] as FieldInfo;
if (fi != null && fi.FieldType == typeof(Exception))
{
mv[i] = e;
}
}
sf = (ServerFault)FormatterServices.PopulateObjectMembers(sf, mi, mv);
return(sf);
}
public object Deserialize(Stream serializationStream)
{
IList list;
using (var sr = new StreamReader(serializationStream))
{
// Optional if reading headers! Example: UserId, FirstName, Title
if (_firstLineIsHeaders)
{
string[] headers = GetHeader(sr);
}
var listType = typeof(List <>);
var constructedListType = listType.MakeGenericType(typeof(T));
list = (IList)Activator.CreateInstance(constructedListType);
while (sr.Peek() >= 0)
{
var line = sr.ReadLine();
var fieldData = line.Split(_delimiter);
var obj = FormatterServices.GetUninitializedObject(typeof(T));
var members = FormatterServices.GetSerializableMembers(obj.GetType(), Context);
object[] data = new object[members.Length];
for (int i = 0; i < members.Length; ++i)
{
FieldInfo fi = ((FieldInfo)members[i]);
data[i] = Convert.ChangeType(fieldData.ElementAt(i), fi.FieldType, CultureInfo.InvariantCulture);
}
list.Add((T)FormatterServices.PopulateObjectMembers(obj, members, data));
}
}
return(list);
}
void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
{
info.AddValue("text", _text);
info.AddValue("alignment", _alignment);
info.AddValue("lineAlignment", _lineAlignment);
info.AddValue("trimming", _trimming);
info.AddValue("wrap", _wrap);
info.AddValue("vertical", _vertical);
info.AddValue("readOnly", _readOnly);
info.AddValue("autoSize", _autoSize);
var fontConverter = new FontConverter();
info.AddValue("_font", fontConverter.ConvertToString(_font));
var thisType = typeof(LabelElement);
var members = FormatterServices.GetSerializableMembers(thisType, context);
foreach (var member in members)
{
if (member.DeclaringType == thisType)
{
continue;
}
info.AddValue(member.Name, ((FieldInfo)member).GetValue(this));
}
}
private static int CalcFieldCount(System.Type type)
{
MemberInfo[] members = FormatterServices.GetSerializableMembers(type);
if (members.Length == 0)
{
return(1);
}
int fieldCount = 0;
foreach (MemberInfo member in members)
{
FieldInfo fi = (FieldInfo)member;
if (fi.FieldType.IsArray)
{
var seq = (Sequence)System.Attribute.GetCustomAttribute(member, typeof(Sequence), true);
var elementType = fi.FieldType.GetElementType();
int elementFieldCount = CalcFieldCount(elementType);
fieldCount += seq.length * elementFieldCount;
}
else
{
fieldCount += 1;
}
}
return(fieldCount);
}
/// <summary>
/// Gets settings class members to serialize
/// </summary>
/// <param name="in_type"></param>
/// <returns></returns>
protected MemberInfo[] GetSerializableMembers(Type in_type)
{
MemberInfo[] member_info;
if (in_type.IsSerializable)
{
// if 'Serializable' attribute is defined -> select all 'serializable' members
member_info = FormatterServices.GetSerializableMembers(in_type);
}
else
{
// if 'DataContract' attribute is specified -> select all members which has 'DataMember' attribute
DataContractAttribute[] attributes = (DataContractAttribute[])in_type.GetCustomAttributes(typeof(DataContractAttribute), true);
if (attributes != null && attributes.Length > 0)
{
// get members with 'DataMember' attribute
MemberInfo[] field_info = in_type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.SetField | BindingFlags.GetField).Where(p => p.GetCustomAttributes(typeof(DataMemberAttribute), true).Count() != 0).ToArray();
MemberInfo[] property_info = in_type.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.SetProperty | BindingFlags.GetProperty).Where(p => p.GetCustomAttributes(typeof(DataMemberAttribute), true).Count() != 0).ToArray();
member_info = field_info.Concat(property_info).ToArray();
}
else
{
// no attribute specified -> select public members
member_info = in_type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.SetField | BindingFlags.GetField).Where(p => p.GetCustomAttributes(typeof(NonSerializedAttribute), true).Count() == 0).ToArray();
member_info = member_info.Concat(in_type.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.SetProperty | BindingFlags.GetProperty)).ToArray().Where(p => p.GetCustomAttributes(typeof(IgnoreDataMemberAttribute), true).Count() == 0).ToArray();
}
}
// retrun member info
return(member_info);
}
int ReadObject(BinaryReader reader, Type type, ref object obj, SerializeAsAttribute attr)
{
int size = 0;
if (type.BaseType != _TypeOfObject)
{
size += ReadObject(reader, type.BaseType, ref obj, attr);
}
MemberInfo[] membersInfo = FormatterServices.GetSerializableMembers(type, _Contex);
object[] membersData = new object[membersInfo.Length];
for (int i = 0; i < membersInfo.Length; i++)
{
MemberInfo memberInfo = membersInfo[i];
Debug.Assert(memberInfo is FieldInfo);
SerializeAsAttribute memberAttr = GetSerializeAsAttribute(type, obj, memberInfo);
object memberData;
Type memberType = memberAttr.FieldType == null ? ((FieldInfo)memberInfo).FieldType : memberAttr.FieldType;
size += ReadMember(reader, memberType, out memberData, memberAttr);
membersData[i] = memberData;
obj = FormatterServices.PopulateObjectMembers(obj, membersInfo, membersData);
}
return(size);
}
private void WorkOnInstanceAndLocal_2()
{
MemberInfo[] ms = FormatterServices.GetSerializableMembers(typeof(int), new StreamingContext(StreamingContextStates.All));
foreach (MemberInfo m in ms)
{
if (!m.DeclaringType.Equals(typeof(Int32)))
{
throw new Exception("Err_23947tsg! error");
}
}
int i = 5;
Object[] os = FormatterServices.GetObjectData(i, ms);
if ((int)os[0] != 5)
{
throw new Exception("Err_32497g! error");
}
Object o = FormatterServices.GetUninitializedObject(typeof(int));
Object o1 = FormatterServices.PopulateObjectMembers(o, ms, os);
if ((Int32)o1 != 5)
{
throw new Exception("Err_23947tsg! 2347sg");
}
Int32[] iS = { 1, 2, 3 };
if (Buffer.ByteLength(iS) != 12)
{
throw new Exception("Err_10974! wrong result");
}
if (Buffer.GetByte(iS, 4) != 2)
{
throw new Exception("Err_23408! wrong result");
}
}
private void InitMemberInfo()
{
if (!_serObjectInfoInit.SeenBeforeTable.TryGetValue(_objectType, out _cache))
{
_cache = new SerializationObjectInfoCache(_objectType)
{
MemberInfos = FormatterServices.GetSerializableMembers(_objectType, _context)
};
int length = _cache.MemberInfos.Length;
_cache.MemberNames = new string[length];
_cache.MemberTypes = new Type[length];
int index = 0;
while (true)
{
if (index >= length)
{
_serObjectInfoInit.SeenBeforeTable.Add(_objectType, _cache);
break;
}
_cache.MemberNames[index] = _cache.MemberInfos[index].Name;
_cache.MemberTypes[index] = ((FieldInfo)_cache.MemberInfos[index]).FieldType;
index++;
}
}
if (_obj != null)
{
_memberData = FormatterServices.GetObjectData(_obj, _cache.MemberInfos);
}
_isNamed = true;
}
private void InitMemberInfo()
{
this.cache = (SerObjectInfoCache)this.serObjectInfoInit.seenBeforeTable[this.objectType];
if (this.cache == null)
{
this.cache = new SerObjectInfoCache();
this.cache.memberInfos = FormatterServices.GetSerializableMembers(this.objectType, this.context);
this.count = this.cache.memberInfos.Length;
this.cache.memberNames = new string[this.count];
this.cache.memberTypes = new Type[this.count];
this.cache.memberAttributeInfos = new SoapAttributeInfo[this.count];
for (int i = 0; i < this.count; i++)
{
this.cache.memberNames[i] = this.cache.memberInfos[i].Name;
this.cache.memberTypes[i] = this.GetMemberType(this.cache.memberInfos[i]);
this.cache.memberAttributeInfos[i] = Attr.GetMemberAttributeInfo(this.cache.memberInfos[i], this.cache.memberNames[i], this.cache.memberTypes[i]);
}
this.cache.fullTypeName = this.objectType.FullName;
this.cache.assemblyString = this.objectType.Module.Assembly.FullName;
this.serObjectInfoInit.seenBeforeTable.Add(this.objectType, this.cache);
}
this.memberData = new object[this.cache.memberNames.Length];
this.memberNames = new string[this.cache.memberNames.Length];
this.isTyped = true;
this.isNamed = true;
}
private void DeserializeProxyMembers()
{
var proxyType = proxy.GetType();
var members = FormatterServices.GetSerializableMembers(proxyType);
var deserializedMembers = new List <MemberInfo>();
var deserializedValues = new List <object>();
for (var i = 0; i < members.Length; i++)
{
var member = members[i] as FieldInfo;
// we get some inherited members...
if (member.DeclaringType != proxyType)
{
continue;
}
Debug.Assert(member != null);
var value = info.GetValue(member.Name, member.FieldType);
deserializedMembers.Add(member);
deserializedValues.Add(value);
}
FormatterServices.PopulateObjectMembers(
proxy,
deserializedMembers.ToArray(),
deserializedValues.ToArray()
);
}
void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
{
Helpers.ThrowIfNull(info, "info");
bool flag = context.State == StreamingContextStates.CrossAppDomain;
if (!flag)
{
foreach (RecognizedPhrase alternate in Alternates)
{
try
{
string smlContent = alternate.SmlContent;
RecognizedAudio audio = Audio;
if (alternate.Text == null || alternate.Homophones == null || alternate.Semantics == null || (smlContent == null && smlContent != null) || (audio == null && audio != null))
{
throw new SerializationException();
}
}
catch (NotSupportedException)
{
}
}
}
Type type = GetType();
MemberInfo[] serializableMembers = FormatterServices.GetSerializableMembers(type, context);
MemberInfo[] array = serializableMembers;
foreach (MemberInfo memberInfo in array)
{
if (!flag || (memberInfo.Name != "_recognizer" && memberInfo.Name != "_grammar" && memberInfo.Name != "_ruleList" && memberInfo.Name != "_audio" && memberInfo.Name != "_audio"))
{
info.AddValue(memberInfo.Name, ((FieldInfo)memberInfo).GetValue(this));
}
}
}
public void GetObjectData(SerializationInfo info, StreamingContext context)
{
// Serialize the desired values for this class.
info.AddValue("title", title);
// Get the set of serializable members for the class and base classes.
Type thisType = this.GetType();
MemberInfo[] mi = FormatterServices.GetSerializableMembers(thisType, context);
// Serialize the base class's fields to the info object.
for (Int32 i = 0; i < mi.Length; i++)
{
// Do not serialize fields for this class.
if (mi[i].DeclaringType == thisType)
{
continue;
}
// Skip this field if it is marked NonSerialized.
if (Attribute.IsDefined(mi[i], typeof(NonSerializedAttribute)))
{
continue;
}
// Get the value of this field and add it to the SerializationInfo object.
info.AddValue(mi[i].Name, ((FieldInfo)mi[i]).GetValue(this));
}
// Call the method below to see the contents of the SerializationInfo object.
DisplaySerializationInfo(info);
}
protected Manager(SerializationInfo info, StreamingContext context) : base(null)
{
// Get the set of serializable members for the class and base classes.
Type thisType = this.GetType();
MemberInfo[] mi = FormatterServices.GetSerializableMembers(thisType, context);
// Deserialize the base class's fields from the info object.
for (Int32 i = 0; i < mi.Length; i++)
{
// Do not deserialize fields for this class.
if (mi[i].DeclaringType == thisType)
{
continue;
}
// For easier coding, treat the member as a FieldInfo object
FieldInfo fi = (FieldInfo)mi[i];
// Skip this field if it is marked NonSerialized.
if (Attribute.IsDefined(mi[i], typeof(NonSerializedAttribute)))
{
continue;
}
// Get the value of this field from the SerializationInfo object.
fi.SetValue(this, info.GetValue(fi.Name, fi.FieldType));
}
// Deserialize the values that were serialized for this class.
title = info.GetString("title");
}
static void Run()
{
// Create an instance of a Book class
// with a title and author.
Book Book1 = new Book("Book Title 1",
"Masato Kawai");
// Store data about the serializable members in a
// MemberInfo array. The MemberInfo type holds
// only type data, not instance data.
MemberInfo[] members =
FormatterServices.GetSerializableMembers
(typeof(Book));
// Copy the data from the first book into an
// array of objects.
object[] data =
FormatterServices.GetObjectData(Book1, members);
// Create an uninitialized instance of the Book class.
Book Book1Copy =
(Book)FormatterServices.GetSafeUninitializedObject
(typeof(Book));
// Call the PopuluateObjectMembers to copy the
// data into the new Book instance.
FormatterServices.PopulateObjectMembers
(Book1Copy, members, data);
// Print the data from the copy.
Console.WriteLine("Title: {0}", Book1Copy.Title);
Console.WriteLine("Author: {0}", Book1Copy.Author);
}
private void InitMemberInfo()
{
InternalST.Soap(this, objectInfoId, " ", objectType, " InitMemberInfo Entry");
cache = (SerObjectInfoCache)serObjectInfoInit.seenBeforeTable[objectType];
if (cache == null)
{
InternalST.Soap(this, objectInfoId, " ", objectType, " InitMemberInfo new cache");
cache = new SerObjectInfoCache();
cache.memberInfos = FormatterServices.GetSerializableMembers(objectType, context);
count = cache.memberInfos.Length;
cache.memberNames = new String[count];
cache.memberTypes = new Type[count];
cache.memberAttributeInfos = new SoapAttributeInfo[count];
// Calculate new arrays
for (int i = 0; i < count; i++)
{
cache.memberNames[i] = cache.memberInfos[i].Name;
cache.memberTypes[i] = GetMemberType(cache.memberInfos[i]);
cache.memberAttributeInfos[i] = Attr.GetMemberAttributeInfo(cache.memberInfos[i], cache.memberNames[i], cache.memberTypes[i]);
InternalST.Soap(this, objectInfoId, " InitMemberInfo name ", cache.memberNames[i], ", type ", cache.memberTypes[i], ", memberInfoType ", cache.memberInfos[i].GetType());
}
cache.fullTypeName = objectType.FullName;
cache.assemblyString = objectType.Module.Assembly.FullName;
serObjectInfoInit.seenBeforeTable.Add(objectType, cache);
}
memberData = new Object[cache.memberNames.Length];
memberNames = new String[cache.memberNames.Length];
isTyped = true;
isNamed = true;
InternalST.Soap(this, objectInfoId, " ", objectType, " InitMemberInfo Exit");
}
private static bool Bug()
{
ObjectManager objmgr1;
StreamingContext sc1;
ObjectIDGenerator objid1;
TestFixup tstfxp1;
Int64 iRootID;
Int64 iChildID;
String strValue;
MemberInfo[] members;
Boolean fFirstTime;
sc1 = new StreamingContext(StreamingContextStates.All);
tstfxp1 = new TestFixup();
strValue = "Hello World";
objid1 = new ObjectIDGenerator();
iRootID = objid1.GetId(tstfxp1, out fFirstTime);
iChildID = objid1.GetId(strValue, out fFirstTime);
members = FormatterServices.GetSerializableMembers(tstfxp1.GetType());
objmgr1 = new ObjectManager(null, sc1);
objmgr1.RecordFixup(iRootID, members[0], iChildID);
try {
objmgr1.RegisterObject(strValue, iChildID);
return(true);
} catch (Exception ex) {
Console.WriteLine("Bug:Exception thrown, " + ex);
return(false);
}
}
// Always remember: the whole configuration must be serialized as one single, flat object (or SerializationInfo), we cannot rely on any
// nested objects to be deserialized in the right order
public static void GetObjectDataForGeneratedTypes(
SerializationInfo info,
StreamingContext context,
object mixin,
ConcreteMixinTypeIdentifier identifier,
bool serializeBaseMembers,
string pipelineIdentifier)
{
ArgumentUtility.CheckNotNull("info", info);
ArgumentUtility.CheckNotNull("mixin", mixin);
ArgumentUtility.CheckNotNull("identifier", identifier);
info.SetType(typeof(MixinSerializationHelper));
var identifierSerializer = new SerializationInfoConcreteMixinTypeIdentifierSerializer(info, "__identifier");
identifier.Serialize(identifierSerializer);
object[] baseMemberValues;
if (serializeBaseMembers)
{
var baseType = mixin.GetType().BaseType;
Assertion.IsNotNull(baseType, "Generated mixin types always have a base type.");
MemberInfo[] baseMembers = FormatterServices.GetSerializableMembers(baseType);
baseMemberValues = FormatterServices.GetObjectData(mixin, baseMembers);
}
else
{
baseMemberValues = null;
}
info.AddValue("__baseMemberValues", baseMemberValues);
info.AddValue("__participantConfigurationID", pipelineIdentifier);
}
int WriteObject(BinaryWriter writer, Type type, object obj, SerializeAsAttribute attr)
{
int size = 0;
if (type.BaseType != _TypeOfObject)
{
size += WriteObject(writer, type.BaseType, obj, attr);
}
MemberInfo[] membersInfo = FormatterServices.GetSerializableMembers(type, _Contex);
object[] membersData = FormatterServices.GetObjectData(obj, membersInfo);
Debug.Assert(membersInfo.Length == membersData.Length);
for (int i = 0; i < membersInfo.Length; i++)
{
MemberInfo memberInfo = membersInfo[i];
Debug.Assert(memberInfo is FieldInfo);
object memberData = membersData[i];
Type memberType = memberData != null?memberData.GetType() : ((FieldInfo)memberInfo).FieldType;
SerializeAsAttribute memberAttr = GetSerializeAsAttribute(type, obj, memberInfo);
size += WriteMember(writer, memberType, memberData, memberAttr);
}
return(size);
}
private DerivedSerialize(SerializationInfo info, StreamingContext context)
{
if (info == null)
{
return;
}
//为本类设置反序列化好的值
m_name = info.GetDateTime("date");
//base.m_name = info.GetString(String.Format("{0}.{1}", this.GetType().BaseType.FullName, "m_Name"));
//查找基类的可序列化字段集合
Type baseType = this.GetType().BaseType;
MemberInfo[] members = FormatterServices.GetSerializableMembers(baseType, context);
foreach (MemberInfo mi in members)
{
if ((mi.MemberType & MemberTypes.Field) != 0)
{
//为基类设置反序列化好的值
FieldInfo fi = (FieldInfo)mi;
fi.SetValue(this, info.GetValue(baseType.FullName + "+" + mi.Name, fi.FieldType));
}
}
}
protected LabelElement(SerializationInfo info, StreamingContext context)
{
var thisType = typeof(LabelElement);
var members = FormatterServices.GetSerializableMembers(thisType, context);
foreach (var member in members)
{
if (member.DeclaringType == thisType)
{
continue;
}
var fieldInfo = (FieldInfo)member;
fieldInfo.SetValue(this, info.GetValue(fieldInfo.Name, fieldInfo.FieldType));
}
Text = info.GetString("text");
Alignment = (StringAlignment)info.GetValue("alignment", typeof(StringAlignment));
LineAlignment = (StringAlignment)info.GetValue("lineAlignment", typeof(StringAlignment));
Trimming = (StringTrimming)info.GetValue("trimming", typeof(StringTrimming));
Wrap = info.GetBoolean("wrap");
Vertical = info.GetBoolean("vertical");
ReadOnly = info.GetBoolean("readOnly");
AutoSize = info.GetBoolean("autoSize");
var fontConverter = new FontConverter();
Font = (Font)fontConverter.ConvertFromString(info.GetString("_font"));
}
/// <summary>
/// Shallow copy |instance| to |copy|. Use with care.
///
/// (This covers the case where we want to shallow copy into an existing object,
/// which is not handled by Object.MemberwiseCopy).
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="copy"></param>
/// <param name="instance"></param>
/// <returns></returns>
public static void Copy <T>(T copy, T instance)
{
var type = instance.GetType();
var fields = new List <MemberInfo>();
if (type.GetCustomAttributes(typeof(SerializableAttribute), false).Length == 0)
{
var t = type;
while (t != typeof(Object))
{
Debug.Assert(t != null, "t != null");
fields.AddRange(
t.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance |
BindingFlags.DeclaredOnly));
t = t.BaseType;
}
}
else
{
fields.AddRange(FormatterServices.GetSerializableMembers(instance.GetType()));
}
var values = FormatterServices.GetObjectData(instance, fields.ToArray());
FormatterServices.PopulateObjectMembers(copy, fields.ToArray(), values);
}
static int ReadMember(object obj, MemberInfo member, string[] fields, int fieldIndex)
{
FieldInfo fi = (FieldInfo)member;
if (fi.FieldType.IsArray)
{
var elementType = fi.FieldType.GetElementType();
var seq = (Sequence)System.Attribute.GetCustomAttribute(fi, typeof(Sequence), true);
var array = (IList)System.Array.CreateInstance(elementType, seq.length);
fi.SetValue(obj, array);
var elementMembers = FormatterServices.GetSerializableMembers(elementType);
for (int i = 0; i < array.Count; ++i)
{
if (elementMembers.Length == 0)
{
array[i] = CastValue(fields[fieldIndex], elementType, array[i]);
++fieldIndex;
}
else
{
object element = System.Activator.CreateInstance(elementType);
fieldIndex = ReadObject(element, elementMembers, fields, fieldIndex);
array[i] = element;
}
}
}
else
{
var value = CastValue(fields[fieldIndex], fi.FieldType, fi.GetValue(obj));
fi.SetValue(obj, value);
++fieldIndex;
}
return(fieldIndex);
}
public void GetBaseData(SerializationInfo info, StreamingContext context, object proxy, System.Type proxyBaseType)
{
if (proxyBaseType == null)
{
throw new ArgumentNullException(nameof(proxyBaseType));
}
info.AddValue(HasAdditionalDataName, true);
var members = FormatterServices.GetSerializableMembers(proxyBaseType, context);
foreach (var member in members)
{
switch (member)
{
case FieldInfo field:
info.AddValue(GetAdditionalMemberName(field), field.GetValue(proxy));
break;
case PropertyInfo property:
info.AddValue(GetAdditionalMemberName(property), property.GetValue(proxy));
break;
default:
throw new NotSupportedException($"Serializing a member of type {member.GetType()} is not supported.");
}
}
}
private void InitMemberInfo()
{
SerTrace.Log(this, objectInfoId, " ", objectType, " InitMemberInfo Entry");
SerTrace.Log(this, objectInfoId, " ", objectType, " InitMemberInfo new cache");
cache = new SerObjectInfoCache();
cache.memberInfos = FormatterServices.GetSerializableMembers(objectType, context);
count = cache.memberInfos.Length;
cache.memberNames = new String[count];
cache.memberTypes = new Type[count];
// Calculate new arrays
for (int i = 0; i < count; i++)
{
cache.memberNames[i] = cache.memberInfos[i].Name;
cache.memberTypes[i] = GetMemberType(cache.memberInfos[i]);
SerTrace.Log(this, objectInfoId, " InitMemberInfo name ", cache.memberNames[i], ", type ", cache.memberTypes[i], ", memberInfoType ", cache.memberInfos[i].GetType());
}
cache.fullTypeName = objectType.FullName;
cache.assemblyString = objectType.Module.Assembly.FullName;
isTyped = true;
isNamed = true;
SerTrace.Log(this, objectInfoId, " ", objectType, " InitMemberInfo Exit");
}
private SerializationStatus DeserializeSerializable(SerializationInstance instance, Type t, SerializationInfo info, StreamingContext context)
{
object obj = FormatterServices.GetUninitializedObject(t);
InvokeOnSerialize(obj, context, false, false);
if (typeof(ISerializable).IsAssignableFrom(t) && TryDeserializeISerializable(obj, info, context))
{
InvokeOnSerialize(obj, context, false, true);
return(SerializationStatus.Deserialized(obj));
}
Dictionary <string, MemberInfo> map = FormatterServices.GetSerializableMembers(t, context).ToDictionary(m => m.Name);
List <MemberInfo> found = new List <MemberInfo>();
List <object> values = new List <object>();
foreach (SerializationEntry entry in info)
{
if (!map.TryGetValue(entry.Name, out MemberInfo mi))
{
continue;
}
found.Add(mi);
values.Add(info.GetValue(entry.Name, GetMemberType(mi)));
}
obj = FormatterServices.PopulateObjectMembers(obj, found.ToArray(), values.ToArray());
InvokeOnSerialize(obj, context, false, true);
return(SerializationStatus.Deserialized(obj));
}
private void InitMemberInfo()
{
if (!_serObjectInfoInit._seenBeforeTable.TryGetValue(_objectType, out _cache))
{
_cache = new SerObjectInfoCache(_objectType);
_cache._memberInfos = FormatterServices.GetSerializableMembers(_objectType, _context);
int count = _cache._memberInfos.Length;
_cache._memberNames = new string[count];
_cache._memberTypes = new Type[count];
// Calculate new arrays
for (int i = 0; i < count; i++)
{
_cache._memberNames[i] = _cache._memberInfos[i].Name;
_cache._memberTypes[i] = ((FieldInfo)_cache._memberInfos[i]).FieldType;
}
_serObjectInfoInit._seenBeforeTable.Add(_objectType, _cache);
}
if (_obj != null)
{
_memberData = FormatterServices.GetObjectData(_obj, _cache._memberInfos);
}
_isNamed = true;
}
// X:\jsc.svn\core\ScriptCoreLib\JavaScript\BCLImplementation\System\Runtime\Serialization\FormatterServices.cs
/// <summary>
/// This is a javascript application.
/// </summary>
/// <param name="page">HTML document rendered by the web server which can now be enhanced.</param>
public Application(IApp page)
{
var o = new xFoo();
Console.WriteLine(new { o });
//var x = typeof(o);
var x = o.GetType();
Console.WriteLine("GetUninitializedObject");
// sometime later
var oo = FormatterServices.GetUninitializedObject(x);
//var isFoo = oo as xFoo;
var isFoo = oo is xFoo;
// Uncaught TypeError: Cannot read property 'LgEABvEJMzKFrGX3QxjvzA' of null
var om = FormatterServices.GetSerializableMembers(x);
var ov = FormatterServices.GetObjectData(o, om);
FormatterServices.PopulateObjectMembers(oo, om, ov);
// 0:34ms {{ isFoo = true, oo = xFoo: {{ xField1 = field1 {{ Counter = 1 }} }} }}
// 0:80ms {{ isFoo = true, oo = xFoo: {{ xField1 = null }} }}
// do we still see ToString?
Console.WriteLine(new { isFoo, oo });
}
public void Serialize(Stream serializationStream, object graph)
{
if (!(graph is IEnumerable))
{
throw new Exception("This serialize will only work on IEnumerable.");
}
var headings = typeof(T).GetProperties();
var headerNames = headings.Select(e => e.Name.ToString()).ToArray();
var headers = String.Join(new String(_delimiter, 1), headerNames);
using (var stream = new StreamWriter(serializationStream))
{
if (_firstLineIsHeaders)
{
stream.WriteLine(headers);
stream.Flush();
}
var members = FormatterServices.GetSerializableMembers(typeof(T), Context);
foreach (var item in (IEnumerable)graph)
{
var objs = FormatterServices.GetObjectData(item, members);
var valueList = objs.Select(e => e.ToString()).ToArray();
var values = String.Join(new String(_delimiter, 1), valueList);
stream.WriteLine(values);
}
stream.Flush();
}
}
public void TestClass1()
{
DerivedClass1 derived = new DerivedClass1();
derived.anotherInt = 69;
MemberInfo [] members = FormatterServices.GetSerializableMembers(derived.GetType());
Assert.IsTrue(members != null, "#01");
Assert.AreEqual(3, members.Length, "#02");
object [] data = FormatterServices.GetObjectData(derived, members);
Assert.IsTrue(data != null, "#03");
Assert.AreEqual(3, data.Length, "#04");
DerivedClass1 o = (DerivedClass1)FormatterServices.GetUninitializedObject(derived.GetType());
Assert.IsTrue(o != null, "#05");
o = (DerivedClass1)FormatterServices.PopulateObjectMembers(o, members, data);
Assert.IsTrue(o != null, "#06");
Assert.AreEqual("hola", o.Hello, "#07");
Assert.AreEqual(21, o.IntBase, "#08");
Assert.AreEqual(1, o.IntDerived, "#09");
Assert.AreEqual(69, o.anotherInt, "#10");
Assert.AreEqual("hey", DerivedClass1.hey, "#11");
}
