int ReadMembers(int index, ClassDataContract classContract, BitFlagsGenerator expectedElements, ref int memberIndex) { int memberCount = (classContract.BaseContract == null) ? 0 : ReadMembers(index, classContract.BaseContract, expectedElements, ref memberIndex); if (memberCount <= index && index < memberCount + classContract.Members.Count) { DataMember dataMember = classContract.Members [index - memberCount]; Type memberType = dataMember.MemberType; memberIndex = memberCount; if (!expectedElements.Load(index)) { XmlObjectSerializerReadContextComplexJson.ThrowDuplicateMemberException(objectLocal, memberNames, memberIndex); } if (dataMember.IsGetOnlyCollection) { var value = CodeInterpreter.GetMember(dataMember.MemberInfo, objectLocal); context.StoreCollectionMemberInfo(value); ReadValue(memberType, dataMember.Name); } else { var value = ReadValue(memberType, dataMember.Name); CodeInterpreter.SetMember(dataMember.MemberInfo, objectLocal, value); } memberIndex = index; ResetExpectedElements(expectedElements, index); } return(memberCount + classContract.Members.Count); }
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 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); try { collectionContract.AddMethod.Invoke(collection, new object [] { pkey, pvalue }); } catch (TargetInvocationException ex) { if (ex.InnerException != null) { throw ex.InnerException; } else { throw; } } } else { collectionContract.AddMethod.Invoke(collection, new object [] { value }); } }
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); } }
private void InitializeCompiler() { _compiler = new MetaCodeCompiler(); CompilerService = CompilerService.Instance; MacroInterpreter = new MacroInterpreter(CompilerService); CodeInterpreter = new CodeInterpreter(CompilerService); CodeGenerator = new CodeGenerator(); SemanticParser = new SemanticParser(CompilerService); InitializeFunctions(); WindowTitle = "MetaCode IDE"; }
bool TryWritePrimitive(Type type, Func <object> value, MemberInfo memberInfo, int?arrayItemIndex, 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 writer if (type.IsValueType) { callee = writer; } else { callee = context; 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(null); // call method to write primitive primitiveContract.XmlFormatWriterMethod.Invoke(callee, args.ToArray()); return(true); }
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)); } }
public FunctionContext(string name, FunctionDeclarationStatementNode function, InterpreterContext interpreterContext, CodeInterpreter codeInterpreter) : base(name) { if (function == null) ThrowHelper.ThrowArgumentNullException(() => function); if (interpreterContext == null) ThrowHelper.ThrowArgumentNullException(() => interpreterContext); if (codeInterpreter == null) ThrowHelper.ThrowArgumentNullException(() => codeInterpreter); Function = function; InterpreterContext = interpreterContext; CodeInterpreter = codeInterpreter; }
public bool TryInterpret(CodeInterpreter compiler, CodeReader reader, out IProcess process) { process = null; var backup = reader.Backup(); if (reader.ReadName(out var name)) { process = new GetFieldProcess(name); return(true); } backup.Restore(); return(false); }
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; } } }
public bool TryInterpret(CodeInterpreter compiler, CodeReader reader, out IProcess process) { var backup = reader.Backup(); process = null; if (reader.ReadName(out var name) && reader.ReadChar(out var bracketBegin) && bracketBegin == '(') { var parameters = new List <IProcess>(); Loop: if (reader.CurrentChar(out var bracketEnd) && bracketEnd == ')') { reader.Next(); process = new InvokeFunctionProcess(name, parameters.ToArray()); return(true); }
public bool TryInterpret(CodeInterpreter compiler, CodeReader reader, out IProcess process) { var backup = reader.Backup(); if (reader.ReadChar(out var bracketBegin) && bracketBegin == '(') { process = compiler.Interpret(reader, Priorities.None); if (reader.ReadChar(out var bracketEnd) && bracketEnd == ')') { return(true); } } process = null; backup.Restore(); return(false); }
public bool TryInterpret(CodeInterpreter compiler, CodeReader reader, out IProcess process) { var backup = reader.Backup(); process = null; if (reader.ReadName(out var _var) && _var == "var") { Loop: if (reader.ReadName(out var name)) { IProcess initValue = null; if (reader.CurrentChar(out var c) && c == '=') { reader.Next(); initValue = compiler.Interpret(reader, Priorities.AssignValueOperator); } if (reader.CurrentChar(out var c1) && c1 == ',') { reader.Next(); process = new VarProcess(name, initValue, process); goto Loop; } process = new VarProcess(name, initValue, process); return(true); } } backup.Restore(); return(false); }
public bool TryInterpret(CodeInterpreter compiler, CodeReader reader, out IProcess process) { var backup = reader.Backup(); process = null; if (compiler.TryInterpret(reader, Priority, out var before)) { if (reader.ReadOperator(out var operatorText) && OperatorText == operatorText) { if (compiler.TryInterpret(reader, Priority, out var after)) { process = CreateProcess(before, after); return(true); } } } backup.Restore(); return(false); }
public unsafe bool TryInterpret(CodeInterpreter compiler, CodeReader reader, out IProcess process) { var backup = reader.Backup(); process = null; if (reader.ReadNumber(out var text)) { fixed(char *pText = text) { var numberInfo = NumberHelper.GetNumberInfo(pText, text.Length, 10); if (numberInfo.IsNumber) { if (numberInfo.HaveExponent) { process = new ConstantProcess(new DoubleConstant(numberInfo.ToDouble())); } else if (numberInfo.IsFloat) { if (numberInfo.IsDecimal && numberInfo.IntegerCount + numberInfo.FractionalCount <= 28) { process = new ConstantProcess(new DecimalConstant(numberInfo.ToDecimal())); } else { process = new ConstantProcess(new DoubleConstant(numberInfo.ToDouble())); } } else if (numberInfo.IntegerCount <= 18) { process = new ConstantProcess(new Int64Constant(numberInfo.ToInt64())); } else if (numberInfo.IsDecimal && numberInfo.IntegerCount <= 28) { process = new ConstantProcess(new DecimalConstant(numberInfo.ToDecimal())); } else { process = new ConstantProcess(new DoubleConstant(numberInfo.ToDouble())); } return(true); } } if (long.TryParse(text, NumberStyles.Integer, NumberFormatInfo.CurrentInfo, out var int64Value)) { process = new ConstantProcess(new Int64Constant(int64Value)); return(true); } if (decimal.TryParse(text, NumberStyles.Float, NumberFormatInfo.CurrentInfo, out var decimalValue)) { process = new ConstantProcess(new DecimalConstant(decimalValue)); return(true); } if (double.TryParse(text, NumberStyles.Float, NumberFormatInfo.CurrentInfo, out var doubleValue)) { process = new ConstantProcess(new DoubleConstant(doubleValue)); return(true); } } backup.Restore(); return(false); }
public void InterpreterTest() { // GIVEN var source = @" var person: any = 0; person.name = 'John Doe'; person.age = 24; writeline(person.name); function max(a: number, b: number) : number do writeline('call function max'); if (a > b) result = a; else result = b; end; end; function min(a: number, b: number) : number do writeline('call function min'); if (a < b) result = a; else result = b; end; end; var j : number = 0; foreach (var i : number in [1,2,3,4,5,6]) do j = max(3 * i, min(4 * i, 5 * i)); writeline(j + '. Hello World!'); end; "; var compilerService = new CompilerService(); var analyzer = new CodeInterpreter(compilerService); // WHEN var node = ParseWithAbstractTreeVisitor(Compiler, source); analyzer.VisitChild(node as CompilationUnit); // THEN }
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); }
public InterpreterContext DeclareFunction(string name, FunctionDeclarationStatementNode function, CodeInterpreter codeInterpreter) { if (string.IsNullOrWhiteSpace(name)) ThrowHelper.ThrowException("The 'name' is blank!"); if (function == null) ThrowHelper.ThrowArgumentNullException(() => function); _functions.First() .Add(name, new FunctionContext(name, function, this, codeInterpreter)); return this; }
void WriteCollection(CollectionDataContract collectionContract) { XmlDictionaryString itemName = context.CollectionItemName; if (collectionContract.Kind == CollectionKind.Array) { Type itemType = collectionContract.ItemType; int i; // This check does not exist in the original dynamic code, // but there is no other way to check type mismatch. // CollectionSerialization.ArrayContract() shows that it is required. if (objLocal.GetType().GetElementType() != itemType) { throw new InvalidCastException(string.Format("Cannot cast array of {0} to array of {1}", objLocal.GetType().GetElementType(), itemType)); } context.IncrementArrayCount(writer, (Array)objLocal); if (!TryWritePrimitiveArray(collectionContract.UnderlyingType, itemType, () => objLocal, itemName)) { WriteArrayAttribute(); var arr = (Array)objLocal; var idx = new int [1]; for (i = 0; i < arr.Length; i++) { if (!TryWritePrimitive(itemType, null, null, i, itemName, 0)) { WriteStartElement(itemName, 0); idx [0] = i; var mbrVal = arr.GetValue(idx); WriteValue(itemType, mbrVal); WriteEndElement(); } } } } else { // This check does not exist in the original dynamic code, // but there is no other way to check type mismatch. // CollectionSerialization.ArrayContract() shows that it is required. if (!collectionContract.UnderlyingType.IsAssignableFrom(objLocal.GetType())) { throw new InvalidCastException(string.Format("Cannot cast {0} to {1}", objLocal.GetType(), collectionContract.UnderlyingType)); } MethodInfo incrementCollectionCountMethod = null; switch (collectionContract.Kind) { case CollectionKind.Collection: case CollectionKind.List: case CollectionKind.Dictionary: incrementCollectionCountMethod = XmlFormatGeneratorStatics.IncrementCollectionCountMethod; break; case CollectionKind.GenericCollection: case CollectionKind.GenericList: incrementCollectionCountMethod = XmlFormatGeneratorStatics.IncrementCollectionCountGenericMethod.MakeGenericMethod(collectionContract.ItemType); break; case CollectionKind.GenericDictionary: incrementCollectionCountMethod = XmlFormatGeneratorStatics.IncrementCollectionCountGenericMethod.MakeGenericMethod(Globals.TypeOfKeyValuePair.MakeGenericType(collectionContract.ItemType.GetGenericArguments())); break; } if (incrementCollectionCountMethod != null) { incrementCollectionCountMethod.Invoke(context, new object [] { writer, objLocal }); } bool isDictionary = false, isGenericDictionary = false; Type enumeratorType = null; Type [] keyValueTypes = null; if (collectionContract.Kind == CollectionKind.GenericDictionary) { isGenericDictionary = true; keyValueTypes = collectionContract.ItemType.GetGenericArguments(); enumeratorType = Globals.TypeOfGenericDictionaryEnumerator.MakeGenericType(keyValueTypes); } else if (collectionContract.Kind == CollectionKind.Dictionary) { isDictionary = true; keyValueTypes = new Type[] { Globals.TypeOfObject, Globals.TypeOfObject }; enumeratorType = Globals.TypeOfDictionaryEnumerator; } else { enumeratorType = collectionContract.GetEnumeratorMethod.ReturnType; } MethodInfo moveNextMethod = enumeratorType.GetMethod(Globals.MoveNextMethodName, BindingFlags.Instance | BindingFlags.Public, null, Globals.EmptyTypeArray, null); MethodInfo getCurrentMethod = enumeratorType.GetMethod(Globals.GetCurrentMethodName, BindingFlags.Instance | BindingFlags.Public, null, Globals.EmptyTypeArray, null); if (moveNextMethod == null || getCurrentMethod == null) { if (enumeratorType.IsInterface) { if (moveNextMethod == null) { moveNextMethod = JsonFormatGeneratorStatics.MoveNextMethod; } if (getCurrentMethod == null) { getCurrentMethod = JsonFormatGeneratorStatics.GetCurrentMethod; } } else { Type ienumeratorInterface = Globals.TypeOfIEnumerator; CollectionKind kind = collectionContract.Kind; if (kind == CollectionKind.GenericDictionary || kind == CollectionKind.GenericCollection || kind == CollectionKind.GenericEnumerable) { Type[] interfaceTypes = enumeratorType.GetInterfaces(); foreach (Type interfaceType in interfaceTypes) { if (interfaceType.IsGenericType && interfaceType.GetGenericTypeDefinition() == Globals.TypeOfIEnumeratorGeneric && interfaceType.GetGenericArguments()[0] == collectionContract.ItemType) { ienumeratorInterface = interfaceType; break; } } } if (moveNextMethod == null) { moveNextMethod = CollectionDataContract.GetTargetMethodWithName(Globals.MoveNextMethodName, enumeratorType, ienumeratorInterface); } if (getCurrentMethod == null) { getCurrentMethod = CollectionDataContract.GetTargetMethodWithName(Globals.GetCurrentMethodName, enumeratorType, ienumeratorInterface); } } } Type elementType = getCurrentMethod.ReturnType; object currentValue = null; // of elementType var enumerator = (IEnumerator)collectionContract.GetEnumeratorMethod.Invoke(objLocal, new object [0]); if (isDictionary) { ConstructorInfo dictEnumCtor = enumeratorType.GetConstructor(Globals.ScanAllMembers, null, new Type[] { Globals.TypeOfIDictionaryEnumerator }, null); enumerator = (IEnumerator)dictEnumCtor.Invoke(new object [] { enumerator }); } else if (isGenericDictionary) { Type ctorParam = Globals.TypeOfIEnumeratorGeneric.MakeGenericType(Globals.TypeOfKeyValuePair.MakeGenericType(keyValueTypes)); ConstructorInfo dictEnumCtor = enumeratorType.GetConstructor(Globals.ScanAllMembers, null, new Type[] { ctorParam }, null); enumerator = (IEnumerator)Activator.CreateInstance(enumeratorType, new object [] { enumerator }); } bool canWriteSimpleDictionary = isDictionary || isGenericDictionary; bool writeSimpleDictionary = canWriteSimpleDictionary && context.UseSimpleDictionaryFormat; PropertyInfo genericDictionaryKeyProperty = null, genericDictionaryValueProperty = null; if (canWriteSimpleDictionary) { Type genericDictionaryKeyValueType = Globals.TypeOfKeyValue.MakeGenericType(keyValueTypes); genericDictionaryKeyProperty = genericDictionaryKeyValueType.GetProperty(JsonGlobals.KeyString); genericDictionaryValueProperty = genericDictionaryKeyValueType.GetProperty(JsonGlobals.ValueString); } if (writeSimpleDictionary) { WriteObjectAttribute(); object key, value; var empty_args = new object [0]; while ((bool)moveNextMethod.Invoke(enumerator, empty_args)) { currentValue = getCurrentMethod.Invoke(enumerator, empty_args); key = CodeInterpreter.GetMember(genericDictionaryKeyProperty, currentValue); value = CodeInterpreter.GetMember(genericDictionaryValueProperty, currentValue); WriteStartElement(key, 0 /*nameIndex*/); WriteValue(genericDictionaryValueProperty.PropertyType, value); WriteEndElement(); } } else { WriteArrayAttribute(); var emptyArray = new object [0]; while (enumerator != null && enumerator.MoveNext()) { currentValue = getCurrentMethod.Invoke(enumerator, emptyArray); if (incrementCollectionCountMethod == null) { XmlFormatGeneratorStatics.IncrementItemCountMethod.Invoke(context, new object [] { 1 }); } if (!TryWritePrimitive(elementType, () => currentValue, null, null, itemName, 0)) { WriteStartElement(itemName, 0); if (isGenericDictionary || isDictionary) { var jc = JsonDataContract.GetJsonDataContract(XmlObjectSerializerWriteContextComplexJson.GetRevisedItemContract( collectionDataContract.ItemContract)); // FIXME: this TypeHandle might be wrong; there is no easy way to get Type for currentValue though. DataContractJsonSerializer.WriteJsonValue(jc, writer, currentValue, context, currentValue.GetType().TypeHandle); } else { WriteValue(elementType, currentValue); } WriteEndElement(); } } } } }
object LoadMemberValue(DataMember member) { return(CodeInterpreter.GetMember(member.MemberInfo, objLocal)); }
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); } } } } }