void CreateObject(ClassDataContract classContract)
{
Type type = objectType = classContract.UnderlyingType;
if (type.IsValueType && !classContract.IsNonAttributedType)
{
type = Globals.TypeOfValueType;
}
if (classContract.UnderlyingType == Globals.TypeOfDBNull)
{
objectLocal = DBNull.Value;
}
else if (classContract.IsNonAttributedType)
{
if (type.IsValueType)
{
objectLocal = FormatterServices.GetUninitializedObject(type);
}
else
{
objectLocal = classContract.GetNonAttributedTypeConstructor().Invoke(new object [0]);
}
}
else
{
objectLocal = CodeInterpreter.ConvertValue(XmlFormatReaderGenerator.UnsafeGetUninitializedObject(DataContract.GetIdForInitialization(classContract)), Globals.TypeOfObject, type);
}
}
void InternalSerialize(MethodInfo methodInfo, Func <object> memberValue, Type memberType, bool writeXsiType)
{
var v = memberValue();
var typeHandleValue = Type.GetTypeHandle(v);
var isDeclaredType = typeHandleValue.Equals(CodeInterpreter.ConvertValue(v, memberType, Globals.TypeOfObject));
methodInfo.Invoke(ctx, new object [] { writer, memberValue != null ? v : null, isDeclaredType, writeXsiType, DataContract.GetId(memberType.TypeHandle), memberType.TypeHandle });
}
bool InvokeFactoryMethod(ClassDataContract classContract, string objectId)
{
if (HasFactoryMethod(classContract))
{
objectLocal = CodeInterpreter.ConvertValue(context.GetRealObject((IObjectReference)objectLocal, objectId), Globals.TypeOfObject, classContract.UnderlyingType);
return(true);
}
return(false);
}
void InitArgs(Type objType)
{
if (objType == Globals.TypeOfDateTimeOffsetAdapter)
{
objLocal = DateTimeOffsetAdapter.GetDateTimeOffsetAdapter((DateTimeOffset)obj);
}
else
{
objLocal = CodeInterpreter.ConvertValue(obj, typeof(object), objType);
}
}
object ReadCollectionItem(CollectionDataContract collectionContract, Type itemType, string itemName, string itemNs)
{
if (collectionContract.Kind == CollectionKind.Dictionary || collectionContract.Kind == CollectionKind.GenericDictionary)
{
context.ResetAttributes();
return(CodeInterpreter.ConvertValue(collectionContract.ItemContract.ReadXmlValue(xmlReader, context), Globals.TypeOfObject, itemType));
}
else
{
return(ReadValue(itemType, itemName, itemNs));
}
}
bool TryWritePrimitive(Type type, Func <object> value, MemberInfo memberInfo, int?arrayItemIndex, XmlDictionaryString ns, XmlDictionaryString name, int nameIndex)
{
PrimitiveDataContract primitiveContract = PrimitiveDataContract.GetPrimitiveDataContract(type);
if (primitiveContract == null || primitiveContract.UnderlyingType == Globals.TypeOfObject)
{
return(false);
}
object callee = null;
var args = new List <object> ();
// load xmlwriter
if (type.IsValueType)
{
callee = writer;
}
else
{
callee = ctx;
args.Add(writer);
}
// load primitive value
if (value != null)
{
args.Add(value());
}
else if (memberInfo != null)
{
args.Add(CodeInterpreter.GetMember(memberInfo, objLocal));
}
else
{
args.Add(((Array)objLocal).GetValue(new int [] { (int)arrayItemIndex }));
}
// load name
if (name != null)
{
args.Add(name);
}
else
{
args.Add(memberNames [nameIndex]);
}
// load namespace
args.Add(ns);
// call method to write primitive
primitiveContract.XmlFormatWriterMethod.Invoke(callee, args.ToArray());
return(true);
}
object InternalDeserialize(Type type, string name, string ns)
{
Type declaredType = type.IsPointer ? Globals.TypeOfReflectionPointer : type;
var obj = context.InternalDeserialize(xmlReader, DataContract.GetId(declaredType.TypeHandle), declaredType.TypeHandle, name, ns);
if (type.IsPointer)
{
// wow, there is no way to convert void* to object in strongly typed way...
return(XmlFormatGeneratorStatics.UnboxPointer.Invoke(null, new object [] { obj }));
}
else
{
return(CodeInterpreter.ConvertValue(obj, Globals.TypeOfObject, type));
}
}
void StoreCollectionValue(object collection, Type valueType, object value, CollectionDataContract collectionContract)
{
if (collectionContract.Kind == CollectionKind.GenericDictionary || collectionContract.Kind == CollectionKind.Dictionary)
{
ClassDataContract keyValuePairContract = DataContract.GetDataContract(valueType) as ClassDataContract;
if (keyValuePairContract == null)
{
Fx.Assert("Failed to create contract for KeyValuePair type");
}
DataMember keyMember = keyValuePairContract.Members [0];
DataMember valueMember = keyValuePairContract.Members [1];
object pkey = CodeInterpreter.GetMember(keyMember.MemberInfo, value);
object pvalue = CodeInterpreter.GetMember(valueMember.MemberInfo, value);
collectionContract.AddMethod.Invoke(collection, new object [] { pkey, pvalue });
}
else
{
collectionContract.AddMethod.Invoke(collection, new object [] { value });
}
}
int ReadMembers(int index, ClassDataContract classContract, bool [] requiredMembers, ref int memberIndex, ref int requiredIndex)
{
int memberCount = (classContract.BaseContract == null) ? 0 : ReadMembers(index, classContract.BaseContract, requiredMembers,
ref memberIndex, ref requiredIndex);
if (memberCount <= index && index < memberCount + classContract.Members.Count)
{
DataMember dataMember = classContract.Members [index - memberCount];
Type memberType = dataMember.MemberType;
if (dataMember.IsRequired)
{
int nextRequiredIndex = index + 1;
for (; nextRequiredIndex < requiredMembers.Length; nextRequiredIndex++)
{
if (requiredMembers [nextRequiredIndex])
{
break;
}
}
requiredIndex = nextRequiredIndex;
}
if (dataMember.IsGetOnlyCollection)
{
var value = CodeInterpreter.GetMember(dataMember.MemberInfo, objectLocal);
context.StoreCollectionMemberInfo(value);
ReadValue(memberType, dataMember.Name, classContract.StableName.Namespace);
}
else
{
var value = ReadValue(memberType, dataMember.Name, classContract.StableName.Namespace);
CodeInterpreter.SetMember(dataMember.MemberInfo, objectLocal, value);
}
memberIndex = index;
}
return(memberCount + classContract.Members.Count);
}
object LoadMemberValue(DataMember member)
{
return(CodeInterpreter.GetMember(member.MemberInfo, objLocal));
}
void WriteValue(Type memberType, object memberValue, bool writeXsiType)
{
Pointer memberValueRefPointer = null;
if (memberType.IsPointer)
{
memberValueRefPointer = (Pointer)XmlFormatGeneratorStatics.BoxPointer.Invoke(null, new object [] { memberValue, memberType });
}
bool isNullableOfT = (memberType.IsGenericType &&
memberType.GetGenericTypeDefinition() == Globals.TypeOfNullable);
if (memberType.IsValueType && !isNullableOfT)
{
PrimitiveDataContract primitiveContract = PrimitiveDataContract.GetPrimitiveDataContract(memberType);
if (primitiveContract != null && !writeXsiType)
{
primitiveContract.XmlFormatContentWriterMethod.Invoke(writer, new object [] { memberValue });
}
else
{
// InternalSerialize(XmlFormatGeneratorStatics.InternalSerializeMethod, () => memberValue, memberType, writeXsiType);
var typeHandleValue = Type.GetTypeHandle(memberValue);
var isDeclaredType = typeHandleValue.Equals(CodeInterpreter.ConvertValue(memberValue, memberType, Globals.TypeOfObject));
ctx.InternalSerialize(writer, memberValue, isDeclaredType, writeXsiType, DataContract.GetId(memberType.TypeHandle), memberType.TypeHandle);
}
}
else
{
bool isNull;
if (isNullableOfT)
{
memberValue = UnwrapNullableObject(() => memberValue, ref memberType, out isNull); //Leaves !HasValue on stack
}
else
{
isNull = memberValue == null;
}
if (isNull)
{
XmlFormatGeneratorStatics.WriteNullMethod.Invoke(ctx, new object [] { writer, memberType, DataContract.IsTypeSerializable(memberType) });
}
else
{
PrimitiveDataContract primitiveContract = PrimitiveDataContract.GetPrimitiveDataContract(memberType);
if (primitiveContract != null && primitiveContract.UnderlyingType != Globals.TypeOfObject && !writeXsiType)
{
if (isNullableOfT)
{
primitiveContract.XmlFormatContentWriterMethod.Invoke(writer, new object [] { memberValue });
}
else
{
primitiveContract.XmlFormatContentWriterMethod.Invoke(ctx, new object [] { writer, memberValue });
}
}
else
{
bool isNull2 = false;
if (memberType == Globals.TypeOfObject || //boxed Nullable<T>
memberType == Globals.TypeOfValueType ||
((IList)Globals.TypeOfNullable.GetInterfaces()).Contains(memberType))
{
var unwrappedMemberValue = CodeInterpreter.ConvertValue(memberValue, memberType.GetType(), Globals.TypeOfObject);
memberValue = unwrappedMemberValue;
isNull2 = memberValue == null;
}
if (isNull2)
{
XmlFormatGeneratorStatics.WriteNullMethod.Invoke(ctx, new object [] { writer, memberType, DataContract.IsTypeSerializable(memberType) });
}
else
{
var typeHandleValue = Type.GetTypeHandle(memberValue);
var isDeclaredType = typeHandleValue.Equals(CodeInterpreter.ConvertValue(memberValue, memberType, Globals.TypeOfObject));
if (isNullableOfT)
{
ctx.InternalSerialize(writer, memberValue, isDeclaredType, writeXsiType, DataContract.GetId(memberType.TypeHandle), memberType.TypeHandle);
}
else
{
ctx.InternalSerializeReference(writer, memberValue, isDeclaredType, writeXsiType, DataContract.GetId(memberType.TypeHandle), memberType.TypeHandle);
}
//InternalSerialize((isNullableOfT ? XmlFormatGeneratorStatics.InternalSerializeMethod : XmlFormatGeneratorStatics.InternalSerializeReferenceMethod), () => memberValue, memberType, writeXsiType);
}
}
}
}
}
object ReadValue(Type type, string name, string ns)
{
var valueType = type;
object value = null;
bool shouldAssignNullableValue = false;
int nullables = 0;
while (type.IsGenericType && type.GetGenericTypeDefinition() == Globals.TypeOfNullable)
{
nullables++;
type = type.GetGenericArguments() [0];
}
PrimitiveDataContract primitiveContract = PrimitiveDataContract.GetPrimitiveDataContract(type);
if ((primitiveContract != null && primitiveContract.UnderlyingType != Globals.TypeOfObject) || nullables != 0 || type.IsValueType)
{
context.ReadAttributes(xmlReader);
string objectId = context.ReadIfNullOrRef(xmlReader, type, DataContract.IsTypeSerializable(type));
// Deserialize null
if (objectId == Globals.NullObjectId)
{
if (nullables != 0)
{
value = Activator.CreateInstance(valueType);
}
else if (type.IsValueType)
{
throw new SerializationException(SR.GetString(SR.ValueTypeCannotBeNull, DataContract.GetClrTypeFullName(type)));
}
else
{
value = null;
}
}
else if (objectId == string.Empty)
{
// Deserialize value
// Compare against Globals.NewObjectId, which is set to string.Empty
objectId = context.GetObjectId();
if (type.IsValueType)
{
if (!string.IsNullOrEmpty(objectId))
{
throw new SerializationException(SR.GetString(SR.ValueTypeCannotHaveId, DataContract.GetClrTypeFullName(type)));
}
}
object innerValueRead = null;
if (nullables != 0)
{
shouldAssignNullableValue = true;
}
if (primitiveContract != null && primitiveContract.UnderlyingType != Globals.TypeOfObject)
{
value = primitiveContract.XmlFormatReaderMethod.Invoke(xmlReader, new object [0]);
if (!type.IsValueType)
{
context.AddNewObject(value);
}
}
else
{
value = InternalDeserialize(type, name, ns);
}
}
else
{
// Deserialize ref
if (type.IsValueType)
{
throw new SerializationException(SR.GetString(SR.ValueTypeCannotHaveRef, DataContract.GetClrTypeFullName(type)));
}
else
{
value = CodeInterpreter.ConvertValue(context.GetExistingObject(objectId, type, name, ns), Globals.TypeOfObject, type);
}
}
if (shouldAssignNullableValue)
{
if (objectId != Globals.NullObjectId)
{
value = WrapNullableObject(type, value, valueType, nullables);
}
}
}
else
{
value = InternalDeserialize(type, name, ns);
}
return(value);
}
