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);
}
}
bool InvokeFactoryMethod(ClassDataContract classContract)
{
if (HasFactoryMethod(classContract))
{
objectLocal = CodeInterpreter.ConvertValue(context.GetRealObject((IObjectReference)objectLocal, Globals.NewObjectId), 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)
{
if (collectionContract.Kind == CollectionKind.Dictionary || collectionContract.Kind == CollectionKind.GenericDictionary)
{
context.ResetAttributes();
var revisedContract = XmlObjectSerializerWriteContextComplexJson.GetRevisedItemContract(collectionContract.ItemContract);
var v = DataContractJsonSerializer.ReadJsonValue(revisedContract, xmlReader, context);
return(CodeInterpreter.ConvertValue(v, Globals.TypeOfObject, itemType));
}
else
{
return(ReadValue(itemType, JsonGlobals.itemString));
}
}
object InternalDeserialize(Type type, string name)
{
Type declaredType = type.IsPointer ? Globals.TypeOfReflectionPointer : type;
var obj = context.InternalDeserialize(xmlReader, DataContract.GetId(declaredType.TypeHandle), declaredType.TypeHandle, name, string.Empty);
if (type.IsPointer)
{
// wow, there is no way to convert void* to object in strongly typed way...
return(JsonFormatGeneratorStatics.UnboxPointer.Invoke(null, new object [] { obj }));
}
else
{
return(CodeInterpreter.ConvertValue(obj, 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));
try {
methodInfo.Invoke(context, new object [] { writer, memberValue != null ? v : null, isDeclaredType, writeXsiType, DataContract.GetId(memberType.TypeHandle), memberType.TypeHandle });
} catch (TargetInvocationException ex) {
if (ex.InnerException != null)
{
throw ex.InnerException;
}
else
{
throw;
}
}
}
object ReadValue(Type type, string name)
{
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);
}
}
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, string.Empty), Globals.TypeOfObject, type);
}
}
if (shouldAssignNullableValue)
{
if (objectId != Globals.NullObjectId)
{
value = WrapNullableObject(type, value, valueType, nullables);
}
}
}
else
{
value = InternalDeserialize(type, name);
}
return(value);
}
void WriteValue(Type memberType, object memberValue)
{
Pointer memberValueRefPointer = null;
if (memberType.IsPointer)
{
memberValueRefPointer = (Pointer)JsonFormatGeneratorStatics.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)
{
primitiveContract.XmlFormatContentWriterMethod.Invoke(writer, new object [] { memberValue });
}
else
{
InternalSerialize(XmlFormatGeneratorStatics.InternalSerializeMethod, () => memberValue, memberType, false);
}
}
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(context, new object [] { writer, memberType, DataContract.IsTypeSerializable(memberType) });
}
else
{
PrimitiveDataContract primitiveContract = PrimitiveDataContract.GetPrimitiveDataContract(memberType);
if (primitiveContract != null && primitiveContract.UnderlyingType != Globals.TypeOfObject)
{
if (isNullableOfT)
{
primitiveContract.XmlFormatContentWriterMethod.Invoke(writer, new object [] { memberValue });
}
else
{
primitiveContract.XmlFormatContentWriterMethod.Invoke(context, 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(context, new object [] { writer, memberType, DataContract.IsTypeSerializable(memberType) });
}
else
{
InternalSerialize((isNullableOfT ? XmlFormatGeneratorStatics.InternalSerializeMethod : XmlFormatGeneratorStatics.InternalSerializeReferenceMethod),
() => memberValue, memberType, false);
}
}
}
}
}