protected override void PerformFlush(IDesignerSerializationManager manager) { if (_rootSerializer != null) { CodeTypeDeclaration typeDecl = (CodeTypeDeclaration)_rootSerializer.Serialize(manager, base.LoaderHost.RootComponent); this.Write(MergeTypeDeclWithCompileUnit(typeDecl, this.Parse())); } }
private void SerializeComponent(IDesignerSerializationManager manager, IComponent component) { CodeDomSerializer serializer = base.GetSerializer(manager, component) as CodeDomSerializer; // ComponentCodeDomSerializer if (serializer != null) { this._codeMap.AddField(new CodeMemberField(component.GetType(), manager.GetName(component))); // statements can be a CodeExpression if the full serialization has been completed prior // to this serialization call (e.g when it is requested during the serialization of another // component. // CodeStatementCollection statements = serializer.Serialize(manager, component) as CodeStatementCollection; if (statements != null) { _codeMap.Add(statements); } CodeStatement statement = serializer.Serialize(manager, component) as CodeStatement; if (statement != null) { _codeMap.Add(statement); } } }
private void SerializeContentProperty(IDesignerSerializationManager manager, object instance, PropertyDescriptor descriptor, CodeStatementCollection statements) { CodePropertyReferenceExpression propRef = new CodePropertyReferenceExpression(); propRef.PropertyName = descriptor.Name; object propertyValue = descriptor.GetValue(instance); ExpressionContext expressionCtx = manager.Context[typeof(ExpressionContext)] as ExpressionContext; if (expressionCtx != null && expressionCtx.PresetValue == instance) { propRef.TargetObject = expressionCtx.Expression; } else { propRef.TargetObject = base.SerializeToExpression(manager, instance); } CodeDomSerializer serializer = manager.GetSerializer(propertyValue.GetType(), typeof(CodeDomSerializer)) as CodeDomSerializer; if (propRef.TargetObject != null && serializer != null) { manager.Context.Push(new ExpressionContext(propRef, propRef.GetType(), null, propertyValue)); object serialized = serializer.Serialize(manager, propertyValue); manager.Context.Pop(); CodeStatementCollection serializedStatements = serialized as CodeStatementCollection; if (serializedStatements != null) { statements.AddRange(serializedStatements); } CodeStatement serializedStatement = serialized as CodeStatement; if (serializedStatement != null) { statements.Add(serializedStatement); } CodeExpression serializedExpr = serialized as CodeExpression; if (serializedExpr != null) { statements.Add(new CodeAssignStatement(propRef, serializedExpr)); } } }
private void Serialize(IServiceProvider provider) { if (provider == null || _objects == null) { return; } // Use a new serialization manager to prevent from "deadlocking" the surface one // by trying to create new session when one currently exists // InstanceRedirectorDesignerSerializationManager manager = new InstanceRedirectorDesignerSerializationManager(provider, null, false); ((IDesignerSerializationManager)manager).AddSerializationProvider(CodeDomSerializationProvider.Instance); IDisposable session = manager.CreateSession(); foreach (ObjectEntry objectEntry in _objects.Values) { if (objectEntry.IsEntireObject) { CodeDomSerializer serializer = (CodeDomSerializer)((IDesignerSerializationManager)manager).GetSerializer(objectEntry.Type, typeof(CodeDomSerializer)); if (serializer != null) { object serialized = null; if (objectEntry.Absolute) { serialized = serializer.SerializeAbsolute(manager, objectEntry.Instance); } else { serialized = serializer.Serialize(manager, objectEntry.Instance); } objectEntry.Serialized = serialized; } } else { foreach (MemberEntry memberEntry in objectEntry.Members.Values) { CodeDomSerializer serializer = (CodeDomSerializer)((IDesignerSerializationManager)manager).GetSerializer( objectEntry.Type, typeof(CodeDomSerializer)); if (serializer != null) { object serialized = null; if (memberEntry.Absolute) { serialized = serializer.SerializeMemberAbsolute(manager, objectEntry.Instance, memberEntry.Descriptor); } else { serialized = serializer.SerializeMember(manager, objectEntry.Instance, memberEntry.Descriptor); } memberEntry.Serialized = serialized; } } } } _errors = manager.Errors; session.Dispose(); }
/// <summary> /// This serializes the given property on this object as a content property. /// </summary> private void SerializeContentProperty(IDesignerSerializationManager manager, object value, PropertyDescriptor property, bool isExtender, CodeStatementCollection statements) { CodeDomSerializer.Trace("Property is marked as Visibility.Content. Recursing."); object propertyValue = GetPropertyValue(manager, property, value, out bool validValue); // For persist contents objects, we don't just serialize the properties on the object; we // serialize everything. // CodeDomSerializer serializer = null; if (propertyValue is null) { CodeDomSerializer.TraceError("Property {0} is marked as Visibility.Content but it is returning null.", property.Name); string name = manager.GetName(value); if (name is null) { name = value.GetType().FullName; } manager.ReportError(new CodeDomSerializerException(string.Format(SR.SerializerNullNestedProperty, name, property.Name), manager)); } else { serializer = (CodeDomSerializer)manager.GetSerializer(propertyValue.GetType(), typeof(CodeDomSerializer)); if (serializer != null) { // Create a property reference expression and push it on the context stack. // This allows the serializer to gain some context as to what it should be // serializing. CodeExpression target = SerializeToExpression(manager, value); if (target is null) { CodeDomSerializer.TraceWarning("Unable to convert value to expression object"); } else { CodeExpression propertyRef = null; if (isExtender) { CodeDomSerializer.Trace("Content property is an extender."); ExtenderProvidedPropertyAttribute exAttr = (ExtenderProvidedPropertyAttribute)property.Attributes[typeof(ExtenderProvidedPropertyAttribute)]; // Extender properties are method invokes on a target "extender" object. // CodeExpression extender = SerializeToExpression(manager, exAttr.Provider); CodeExpression extended = SerializeToExpression(manager, value); CodeDomSerializer.TraceWarningIf(extender is null, "Extender object {0} could not be serialized.", manager.GetName(exAttr.Provider)); CodeDomSerializer.TraceWarningIf(extended is null, "Extended object {0} could not be serialized.", manager.GetName(value)); if (extender != null && extended != null) { CodeMethodReferenceExpression methodRef = new CodeMethodReferenceExpression(extender, "Get" + property.Name); CodeMethodInvokeExpression methodInvoke = new CodeMethodInvokeExpression { Method = methodRef }; methodInvoke.Parameters.Add(extended); propertyRef = methodInvoke; } } else { propertyRef = new CodePropertyReferenceExpression(target, property.Name); } if (propertyRef != null) { ExpressionContext tree = new ExpressionContext(propertyRef, property.PropertyType, value, propertyValue); manager.Context.Push(tree); object result = null; try { SerializeAbsoluteContext absolute = (SerializeAbsoluteContext)manager.Context[typeof(SerializeAbsoluteContext)]; if (IsSerialized(manager, propertyValue, absolute != null)) { result = GetExpression(manager, propertyValue); } else { result = serializer.Serialize(manager, propertyValue); } } finally { Debug.Assert(manager.Context.Current == tree, "Serializer added a context it didn't remove."); manager.Context.Pop(); } if (result is CodeStatementCollection csc) { foreach (CodeStatement statement in csc) { statements.Add(statement); } } else { if (result is CodeStatement cs) { statements.Add(cs); } } } } } else { CodeDomSerializer.TraceError("Property {0} is marked as Visibilty.Content but there is no serializer for it.", property.Name); manager.ReportError(new CodeDomSerializerException(string.Format(SR.SerializerNoSerializerForComponent, property.PropertyType.FullName), manager)); } } }
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 })); } } }