object SerializeCell(IDesignerSerializationManager manager, CodeExpression target, Cell cell) { object codeObject = null; ExpressionContext context = null; ExpressionContext context2 = manager.Context[typeof(ExpressionContext)] as ExpressionContext; if (context2 != null) { CodeMethodInvokeExpression codeIndexer = new CodeMethodInvokeExpression(target, "GetAt", new CodePrimitiveExpression(cell.Column.Index)); context = new ExpressionContext(codeIndexer, typeof(RowCollection), context2.PresetValue, cell); manager.Context.Push(context); } try { CodeDomSerializer rowSerialzier = (CodeDomSerializer)manager.GetSerializer(cell.GetType(), typeof(CodeDomSerializer)); //codeObject = rowSerialzier.Serialize(manager, row); codeObject = rowSerialzier.SerializeAbsolute(manager, cell); } finally { if (context != null) { manager.Context.Pop(); } } return codeObject; }
private void SerializeContentProperty(IDesignerSerializationManager manager, object value, PropertyDescriptor property, bool isExtender, CodeStatementCollection statements) { bool flag; object presetValue = this.GetPropertyValue(manager, property, value, out flag); CodeDomSerializer serializer = null; if (presetValue == null) { string name = manager.GetName(value); if (name == null) { name = value.GetType().FullName; } manager.ReportError(System.Design.SR.GetString("SerializerNullNestedProperty", new object[] { name, property.Name })); } else { serializer = (CodeDomSerializer) manager.GetSerializer(presetValue.GetType(), typeof(CodeDomSerializer)); if (serializer != null) { CodeExpression targetObject = base.SerializeToExpression(manager, value); if (targetObject != null) { CodeExpression expression = null; if (isExtender) { ExtenderProvidedPropertyAttribute attribute = (ExtenderProvidedPropertyAttribute) property.Attributes[typeof(ExtenderProvidedPropertyAttribute)]; CodeExpression expression3 = base.SerializeToExpression(manager, attribute.Provider); CodeExpression expression4 = base.SerializeToExpression(manager, value); if ((expression3 != null) && (expression4 != null)) { CodeMethodReferenceExpression expression5 = new CodeMethodReferenceExpression(expression3, "Get" + property.Name); CodeMethodInvokeExpression expression6 = new CodeMethodInvokeExpression { Method = expression5 }; expression6.Parameters.Add(expression4); expression = expression6; } } else { expression = new CodePropertyReferenceExpression(targetObject, property.Name); } if (expression != null) { ExpressionContext context = new ExpressionContext(expression, property.PropertyType, value, presetValue); manager.Context.Push(context); object obj3 = null; try { SerializeAbsoluteContext context2 = (SerializeAbsoluteContext) manager.Context[typeof(SerializeAbsoluteContext)]; if (base.IsSerialized(manager, presetValue, context2 != null)) { obj3 = base.GetExpression(manager, presetValue); } else { obj3 = serializer.Serialize(manager, presetValue); } } finally { manager.Context.Pop(); } CodeStatementCollection statements2 = obj3 as CodeStatementCollection; if (statements2 == null) { CodeStatement statement2 = obj3 as CodeStatement; if (statement2 != null) { statements.Add(statement2); } } else { foreach (CodeStatement statement in statements2) { statements.Add(statement); } } } } } else { manager.ReportError(System.Design.SR.GetString("SerializerNoSerializerForComponent", new object[] { property.PropertyType.FullName })); } } }
object SerializeRow(IDesignerSerializationManager manager, CodeExpression target, Row row) { object codeObject = null; ExpressionContext context = null; ExpressionContext context2 = manager.Context[typeof(ExpressionContext)] as ExpressionContext; CodeMethodInvokeExpression codeIndexer = new CodeMethodInvokeExpression(target, "GetAt", new CodePrimitiveExpression(row.Index)); if (context2 != null) { //CodeIndexerExpression codeIndexer = new CodeIndexerExpression(target, new CodePrimitiveExpression(row.Index)); context = new ExpressionContext(codeIndexer, typeof(RowCollection), context2.PresetValue, row); manager.Context.Push(context); } try { CodeDomSerializer rowSerialzier = (CodeDomSerializer)manager.GetSerializer(row.GetType(), typeof(CodeDomSerializer)); //codeObject = rowSerialzier.Serialize(manager, row); codeObject = rowSerialzier.SerializeAbsolute(manager, row); } finally { foreach (Cell item in row.Cells) { object cellCodeObject = SerializeCell(manager, codeIndexer, item); if(cellCodeObject is CodeStatementCollection && codeObject is CodeStatementCollection) { (codeObject as CodeStatementCollection).AddRange(cellCodeObject as CodeStatementCollection); } } if (context != null) { manager.Context.Pop(); } } return codeObject; }
private void SerializeExtenderProperty(IDesignerSerializationManager manager, object value, PropertyDescriptor property, CodeStatementCollection statements) { AttributeCollection attributes = property.Attributes; using (CodeDomSerializerBase.TraceScope("PropertyMemberCodeDomSerializer::SerializeExtenderProperty")) { ExtenderProvidedPropertyAttribute attribute = (ExtenderProvidedPropertyAttribute) attributes[typeof(ExtenderProvidedPropertyAttribute)]; CodeExpression targetObject = base.SerializeToExpression(manager, attribute.Provider); CodeExpression expression2 = base.SerializeToExpression(manager, value); if ((targetObject != null) && (expression2 != null)) { bool flag; CodeMethodReferenceExpression expression = new CodeMethodReferenceExpression(targetObject, "Set" + property.Name); object obj2 = this.GetPropertyValue(manager, property, value, out flag); CodeExpression expression4 = null; if (flag) { ExpressionContext context = null; if (obj2 != value) { context = new ExpressionContext(expression, property.PropertyType, value); manager.Context.Push(context); } try { expression4 = base.SerializeToExpression(manager, obj2); } finally { if (context != null) { manager.Context.Pop(); } } } if (expression4 != null) { CodeMethodInvokeExpression expression5 = new CodeMethodInvokeExpression { Method = expression }; expression5.Parameters.Add(expression2); expression5.Parameters.Add(expression4); statements.Add(expression5); } } } }
private void SerializeNormalProperty(IDesignerSerializationManager manager, object value, PropertyDescriptor property, CodeStatementCollection statements) { using (CodeDomSerializerBase.TraceScope("CodeDomSerializer::SerializeProperty")) { CodeExpression targetObject = base.SerializeToExpression(manager, value); if (targetObject != null) { CodeExpression expression = new CodePropertyReferenceExpression(targetObject, property.Name); CodeExpression right = null; MemberRelationshipService service = manager.GetService(typeof(MemberRelationshipService)) as MemberRelationshipService; if (service != null) { MemberRelationship relationship = service[value, property]; if (relationship != MemberRelationship.Empty) { CodeExpression expression4 = base.SerializeToExpression(manager, relationship.Owner); if (expression4 != null) { right = new CodePropertyReferenceExpression(expression4, relationship.Member.Name); } } } if (right == null) { bool flag; object obj2 = this.GetPropertyValue(manager, property, value, out flag); if (flag) { ExpressionContext context = null; if (obj2 != value) { context = new ExpressionContext(expression, property.PropertyType, value); manager.Context.Push(context); } try { right = base.SerializeToExpression(manager, obj2); } finally { if (context != null) { manager.Context.Pop(); } } } } if (right != null) { CodeAssignStatement statement = new CodeAssignStatement(expression, right); statements.Add(statement); } } } }
public string SetValue(IDesignerSerializationManager manager, ExpressionContext tree, object value, bool forceInvariant, bool shouldSerializeInvariant, bool ensureInvariant, bool applyingCachedResources) { string name = null; bool flag = false; if (tree != null) { string propertyName; if (tree.Owner == this.RootComponent) { name = "$this"; } else { name = manager.GetName(tree.Owner); if (name == null) { IReferenceService service = (IReferenceService) manager.GetService(typeof(IReferenceService)); if (service != null) { name = service.GetName(tree.Owner); } } } CodeExpression expression = tree.Expression; if (expression is CodePropertyReferenceExpression) { propertyName = ((CodePropertyReferenceExpression) expression).PropertyName; } else if (expression is CodeFieldReferenceExpression) { propertyName = ((CodeFieldReferenceExpression) expression).FieldName; } else if (expression is CodeMethodReferenceExpression) { propertyName = ((CodeMethodReferenceExpression) expression).MethodName; if (propertyName.StartsWith("Set")) { propertyName = propertyName.Substring(3); } } else { propertyName = null; } if (name == null) { name = "resource"; } if (propertyName != null) { name = name + "." + propertyName; } } else { name = "resource"; flag = true; } string key = name; int num = 1; do { if (flag) { key = name + num.ToString(CultureInfo.InvariantCulture); num++; } else { flag = true; } } while (this.nameTable.ContainsKey(key)); this.SetValue(manager, key, value, forceInvariant, shouldSerializeInvariant, ensureInvariant, applyingCachedResources); this.nameTable[key] = key; return key; }
public override object Serialize(IDesignerSerializationManager manager, object value) { if (manager == null) throw new ArgumentNullException("manager"); object result = null; if (value == null) return result; CodeStatementCollection statements = null; ExpressionContext cxt = manager.Context[typeof(ExpressionContext)] as ExpressionContext; if (value.GetType().GetConstructor(new Type[0]) != null) { if (value is ICollection) { ExpressionContext varExct = null; if (cxt != null) { if (cxt.PresetValue != value) { try { statements = new CodeStatementCollection(); CodeVariableReferenceExpression varExpression = AddVariableExpression(manager, statements, value); varExct = new ExpressionContext(varExpression, value.GetType(), cxt.Owner, value); manager.Context.Push(varExct); result = this.originalSerializer.Serialize(manager, value); if (result is CodeStatementCollection) statements.AddRange(result as CodeStatementCollection); else if (result is CodeStatement) statements.Add(result as CodeStatement); else if (result is CodeExpression) // If the returned result is an expression, it mostly likely means the collection // can not be serialized using statements, instead it has been serialized as resources. // In this case, we just over-write the variable init expression with the "GetObject" // expression for resource objects. statements.Add(new CodeAssignStatement(varExpression, result as CodeExpression)); result = statements; } finally { if (varExct != null) manager.Context.Pop(); } } else { result = this.originalSerializer.Serialize(manager, value); } } } else { statements = new CodeStatementCollection(); CodeVariableReferenceExpression varExpression = AddVariableExpression(manager, statements, value); SerializeProperties(manager, statements, value, new Attribute[] { DesignOnlyAttribute.No }); SerializeEvents(manager, statements, value, new Attribute[] { DesignOnlyAttribute.No }); result = statements; } } else if (cxt != null) { result = this.originalSerializer.Serialize(manager, value); } return result; }
private CodeExpression SerializeInstanceDescriptor(IDesignerSerializationManager manager, object value, InstanceDescriptor descriptor) { CodeExpression expression = null; using (TraceScope("CodeDomSerializerBase::SerializeInstanceDescriptor")) { CodeExpression[] parameters = new CodeExpression[descriptor.Arguments.Count]; object[] array = new object[parameters.Length]; ParameterInfo[] infoArray = null; if (parameters.Length > 0) { descriptor.Arguments.CopyTo(array, 0); MethodBase memberInfo = descriptor.MemberInfo as MethodBase; if (memberInfo != null) { infoArray = memberInfo.GetParameters(); } } bool flag = true; for (int i = 0; i < parameters.Length; i++) { object obj2 = array[i]; CodeExpression expression2 = null; ExpressionContext context = null; ExpressionContext context2 = manager.Context[typeof(ExpressionContext)] as ExpressionContext; if (context2 != null) { context = new ExpressionContext(context2.Expression, infoArray[i].ParameterType, context2.Owner); manager.Context.Push(context); } try { expression2 = this.SerializeToExpression(manager, obj2); } finally { if (context != null) { manager.Context.Pop(); } } if (expression2 != null) { if ((obj2 != null) && !infoArray[i].ParameterType.IsAssignableFrom(obj2.GetType())) { expression2 = new CodeCastExpression(infoArray[i].ParameterType, expression2); } parameters[i] = expression2; } else { flag = false; break; } } if (!flag) { return expression; } Type declaringType = descriptor.MemberInfo.DeclaringType; CodeTypeReference createType = new CodeTypeReference(declaringType); if (descriptor.MemberInfo is ConstructorInfo) { expression = new CodeObjectCreateExpression(createType, parameters); } else if (descriptor.MemberInfo is MethodInfo) { CodeTypeReferenceExpression targetObject = new CodeTypeReferenceExpression(createType); CodeMethodReferenceExpression method = new CodeMethodReferenceExpression(targetObject, descriptor.MemberInfo.Name); expression = new CodeMethodInvokeExpression(method, parameters); declaringType = ((MethodInfo) descriptor.MemberInfo).ReturnType; } else if (descriptor.MemberInfo is PropertyInfo) { CodeTypeReferenceExpression expression5 = new CodeTypeReferenceExpression(createType); CodePropertyReferenceExpression expression6 = new CodePropertyReferenceExpression(expression5, descriptor.MemberInfo.Name); expression = expression6; declaringType = ((PropertyInfo) descriptor.MemberInfo).PropertyType; } else if (descriptor.MemberInfo is FieldInfo) { CodeTypeReferenceExpression expression7 = new CodeTypeReferenceExpression(createType); expression = new CodeFieldReferenceExpression(expression7, descriptor.MemberInfo.Name); declaringType = ((FieldInfo) descriptor.MemberInfo).FieldType; } Type type = value.GetType(); while (!type.IsPublic) { type = type.BaseType; } if (!type.IsAssignableFrom(declaringType)) { expression = new CodeCastExpression(type, expression); } } return expression; }
protected void SerializePropertiesToResources(IDesignerSerializationManager manager, CodeStatementCollection statements, object value, Attribute[] filter) { using (TraceScope("ComponentCodeDomSerializerBase::SerializePropertiesToResources")) { PropertyDescriptorCollection descriptors = GetPropertiesHelper(manager, value, filter); manager.Context.Push(statements); try { CodeExpression targetObject = this.SerializeToExpression(manager, value); if (targetObject != null) { CodePropertyReferenceExpression expression = new CodePropertyReferenceExpression(targetObject, string.Empty); foreach (PropertyDescriptor descriptor in descriptors) { ExpressionContext context = new ExpressionContext(expression, descriptor.PropertyType, value); manager.Context.Push(context); try { if (descriptor.Attributes.Contains(DesignerSerializationVisibilityAttribute.Visible)) { string name; expression.PropertyName = descriptor.Name; if (targetObject is CodeThisReferenceExpression) { name = "$this"; } else { name = manager.GetName(value); } name = string.Format(CultureInfo.CurrentCulture, "{0}.{1}", new object[] { name, descriptor.Name }); ResourceCodeDomSerializer.Default.SerializeMetadata(manager, name, descriptor.GetValue(value), descriptor.ShouldSerializeValue(value)); } } finally { manager.Context.Pop(); } } } } finally { manager.Context.Pop(); } } }
private object SerializeViaAddRange(IDesignerSerializationManager manager, CodeExpression targetExpression, Type targetType, Type elementType, ICollection valuesToSerialize) { CodeStatementCollection statements = new CodeStatementCollection(); using (CodeDomSerializerBase.TraceScope("CollectionCodeDomSerializer::SerializeViaAddRange")) { if (valuesToSerialize.Count <= 0) { return statements; } ArrayList list = new ArrayList(valuesToSerialize.Count); ExpressionContext context = manager.Context[typeof(ExpressionContext)] as ExpressionContext; foreach (object obj2 in valuesToSerialize) { bool flag = !(obj2 is IComponent); if (!flag) { InheritanceAttribute attribute = (InheritanceAttribute) TypeDescriptor.GetAttributes(obj2)[typeof(InheritanceAttribute)]; if (attribute != null) { if (attribute.InheritanceLevel == InheritanceLevel.InheritedReadOnly) { flag = false; } else { flag = true; } } else { flag = true; } } if (flag) { CodeExpression expression = null; ExpressionContext context2 = null; if (context != null) { context2 = new ExpressionContext(context.Expression, elementType, context.Owner); manager.Context.Push(context2); } try { expression = base.SerializeToExpression(manager, obj2); } finally { if (context2 != null) { manager.Context.Pop(); } } if (expression != null) { if ((obj2 != null) && !elementType.IsAssignableFrom(obj2.GetType())) { expression = new CodeCastExpression(elementType, expression); } list.Add(expression); } } } if (list.Count <= 0) { return statements; } CodeTypeReference reference = new CodeTypeReference(elementType); CodeArrayCreateExpression expression2 = new CodeArrayCreateExpression { CreateType = reference }; foreach (CodeExpression expression3 in list) { expression2.Initializers.Add(expression3); } CodeMethodReferenceExpression expression4 = new CodeMethodReferenceExpression(targetExpression, "AddRange"); CodeMethodInvokeExpression expression5 = new CodeMethodInvokeExpression { Method = expression4 }; expression5.Parameters.Add(expression2); statements.Add(new CodeExpressionStatement(expression5)); } return statements; }
private CodeArrayCreateExpression SerializeArray(IDesignerSerializationManager manager, Type targetType, ICollection array, ICollection valuesToSerialize) { CodeArrayCreateExpression expression = null; using (CodeDomSerializerBase.TraceScope("CollectionCodeDomSerializer::SerializeArray")) { if (((Array) array).Rank != 1) { manager.ReportError(System.Design.SR.GetString("SerializerInvalidArrayRank", new object[] { ((Array) array).Rank.ToString(CultureInfo.InvariantCulture) })); return expression; } Type elementType = targetType.GetElementType(); CodeTypeReference reference = new CodeTypeReference(elementType); CodeArrayCreateExpression expression2 = new CodeArrayCreateExpression { CreateType = reference }; bool flag = true; foreach (object obj2 in valuesToSerialize) { if ((obj2 is IComponent) && TypeDescriptor.GetAttributes(obj2).Contains(InheritanceAttribute.InheritedReadOnly)) { flag = false; break; } CodeExpression expression3 = null; ExpressionContext context = null; ExpressionContext context2 = manager.Context[typeof(ExpressionContext)] as ExpressionContext; if (context2 != null) { context = new ExpressionContext(context2.Expression, elementType, context2.Owner); manager.Context.Push(context); } try { expression3 = base.SerializeToExpression(manager, obj2); } finally { if (context != null) { manager.Context.Pop(); } } if (expression3 != null) { if ((obj2 != null) && (obj2.GetType() != elementType)) { expression3 = new CodeCastExpression(elementType, expression3); } expression2.Initializers.Add(expression3); } else { flag = false; break; } } if (flag) { expression = expression2; } } return expression; }
private void SerializeContentProperty(IDesignerSerializationManager manager, object value, PropertyDescriptor property, bool isExtender, CodeStatementCollection statements) { bool flag; object presetValue = this.GetPropertyValue(manager, property, value, out flag); CodeDomSerializer serializer = null; if (presetValue == null) { string name = manager.GetName(value); if (name == null) { name = value.GetType().FullName; } manager.ReportError(System.Design.SR.GetString("SerializerNullNestedProperty", new object[] { name, property.Name })); } else { serializer = (CodeDomSerializer)manager.GetSerializer(presetValue.GetType(), typeof(CodeDomSerializer)); if (serializer != null) { CodeExpression targetObject = base.SerializeToExpression(manager, value); if (targetObject != null) { CodeExpression expression = null; if (isExtender) { ExtenderProvidedPropertyAttribute attribute = (ExtenderProvidedPropertyAttribute)property.Attributes[typeof(ExtenderProvidedPropertyAttribute)]; CodeExpression expression3 = base.SerializeToExpression(manager, attribute.Provider); CodeExpression expression4 = base.SerializeToExpression(manager, value); if ((expression3 != null) && (expression4 != null)) { CodeMethodReferenceExpression expression5 = new CodeMethodReferenceExpression(expression3, "Get" + property.Name); CodeMethodInvokeExpression expression6 = new CodeMethodInvokeExpression { Method = expression5 }; expression6.Parameters.Add(expression4); expression = expression6; } } else { expression = new CodePropertyReferenceExpression(targetObject, property.Name); } if (expression != null) { ExpressionContext context = new ExpressionContext(expression, property.PropertyType, value, presetValue); manager.Context.Push(context); object obj3 = null; try { SerializeAbsoluteContext context2 = (SerializeAbsoluteContext)manager.Context[typeof(SerializeAbsoluteContext)]; if (base.IsSerialized(manager, presetValue, context2 != null)) { obj3 = base.GetExpression(manager, presetValue); } else { obj3 = serializer.Serialize(manager, presetValue); } } finally { manager.Context.Pop(); } CodeStatementCollection statements2 = obj3 as CodeStatementCollection; if (statements2 == null) { CodeStatement statement2 = obj3 as CodeStatement; if (statement2 != null) { statements.Add(statement2); } } else { foreach (CodeStatement statement in statements2) { statements.Add(statement); } } } } } else { manager.ReportError(System.Design.SR.GetString("SerializerNoSerializerForComponent", new object[] { property.PropertyType.FullName })); } } }