private object GetPropertyValue(IDesignerSerializationManager manager, PropertyDescriptor property, object value, out bool validValue) { object obj2 = null; validValue = true; try { if (!property.ShouldSerializeValue(value)) { AmbientValueAttribute attribute = (AmbientValueAttribute) property.Attributes[typeof(AmbientValueAttribute)]; if (attribute != null) { return attribute.Value; } DefaultValueAttribute attribute2 = (DefaultValueAttribute) property.Attributes[typeof(DefaultValueAttribute)]; if (attribute2 != null) { return attribute2.Value; } validValue = false; } obj2 = property.GetValue(value); } catch (Exception exception) { validValue = false; manager.ReportError(System.Design.SR.GetString("SerializerPropertyGenFailed", new object[] { property.Name, exception.Message })); } return obj2; }
private object GetPropertyValue(IDesignerSerializationManager manager, PropertyDescriptor property, object value, out bool validValue) { object obj2 = null; validValue = true; try { if (!property.ShouldSerializeValue(value)) { AmbientValueAttribute attribute = (AmbientValueAttribute)property.Attributes[typeof(AmbientValueAttribute)]; if (attribute != null) { return(attribute.Value); } DefaultValueAttribute attribute2 = (DefaultValueAttribute)property.Attributes[typeof(DefaultValueAttribute)]; if (attribute2 != null) { return(attribute2.Value); } validValue = false; } obj2 = property.GetValue(value); } catch (Exception exception) { validValue = false; manager.ReportError(System.Design.SR.GetString("SerializerPropertyGenFailed", new object[] { property.Name, exception.Message })); } return(obj2); }
/// <summary> /// This method actually performs the serialization. When the member is serialized /// the necessary statements will be added to the statements collection. /// </summary> public override void Serialize(IDesignerSerializationManager manager, object value, MemberDescriptor descriptor, CodeStatementCollection statements) { if (manager is null) { throw new ArgumentNullException(nameof(manager)); } if (value is null) { throw new ArgumentNullException(nameof(value)); } if (!(descriptor is EventDescriptor eventToSerialize)) { throw new ArgumentNullException(nameof(descriptor)); } if (statements is null) { throw new ArgumentNullException(nameof(statements)); } try { // If the IEventBindingService is not available, we don't throw - we just don't do anything. if (manager.GetService(typeof(IEventBindingService)) is IEventBindingService eventBindings) { PropertyDescriptor prop = eventBindings.GetEventProperty(eventToSerialize); string methodName = (string)prop.GetValue(value); if (methodName != null) { CodeDomSerializer.Trace("Event {0} bound to {1}", eventToSerialize.Name, methodName); CodeExpression eventTarget = SerializeToExpression(manager, value); CodeDomSerializer.TraceWarningIf(eventTarget is null, "Object has no name and no propery ref in context so we cannot serialize events: {0}", value); if (eventTarget != null) { CodeTypeReference delegateTypeRef = new CodeTypeReference(eventToSerialize.EventType); CodeDelegateCreateExpression delegateCreate = new CodeDelegateCreateExpression(delegateTypeRef, _thisRef, methodName); CodeEventReferenceExpression eventRef = new CodeEventReferenceExpression(eventTarget, eventToSerialize.Name); CodeAttachEventStatement attach = new CodeAttachEventStatement(eventRef, delegateCreate); attach.UserData[typeof(Delegate)] = eventToSerialize.EventType; statements.Add(attach); } } } } catch (Exception e) { // Since we usually go through reflection, don't // show what our engine does, show what caused // the problem. // if (e is TargetInvocationException) { e = e.InnerException; } manager.ReportError(new CodeDomSerializerException(string.Format(SR.SerializerPropertyGenFailed, eventToSerialize.Name, e.Message), manager)); } }
/// <summary> /// This method actually performs the serialization. When the member is serialized /// the necessary statements will be added to the statements collection. /// </summary> public override void Serialize(IDesignerSerializationManager manager, object value, MemberDescriptor descriptor, CodeStatementCollection statements) { if (manager is null) { throw new ArgumentNullException(nameof(manager)); } if (value is null) { throw new ArgumentNullException(nameof(value)); } if (!(descriptor is PropertyDescriptor propertyToSerialize)) { throw new ArgumentNullException(nameof(descriptor)); } if (statements is null) { throw new ArgumentNullException(nameof(statements)); } try { ExtenderProvidedPropertyAttribute exAttr = (ExtenderProvidedPropertyAttribute)propertyToSerialize.Attributes[typeof(ExtenderProvidedPropertyAttribute)]; bool isExtender = (exAttr != null && exAttr.Provider != null); bool serializeContents = propertyToSerialize.Attributes.Contains(DesignerSerializationVisibilityAttribute.Content); CodeDomSerializer.Trace("Serializing property {0}", propertyToSerialize.Name); if (serializeContents) { SerializeContentProperty(manager, value, propertyToSerialize, isExtender, statements); } else if (isExtender) { SerializeExtenderProperty(manager, value, propertyToSerialize, statements); } else { SerializeNormalProperty(manager, value, propertyToSerialize, statements); } } catch (Exception e) { // Since we usually go through reflection, don't // show what our engine does, show what caused // the problem. if (e is TargetInvocationException) { e = e.InnerException; } manager.ReportError(new CodeDomSerializerException(string.Format(SR.SerializerPropertyGenFailed, propertyToSerialize.Name, e.Message), manager)); } }
public override void Serialize(IDesignerSerializationManager manager, object value, MemberDescriptor descriptor, CodeStatementCollection statements) { EventDescriptor e = descriptor as EventDescriptor; if (manager == null) { throw new ArgumentNullException("manager"); } if (value == null) { throw new ArgumentNullException("value"); } if (e == null) { throw new ArgumentNullException("descriptor"); } if (statements == null) { throw new ArgumentNullException("statements"); } try { IEventBindingService service = (IEventBindingService)manager.GetService(typeof(IEventBindingService)); if (service != null) { string methodName = (string)service.GetEventProperty(e).GetValue(value); if (methodName != null) { CodeExpression targetObject = base.SerializeToExpression(manager, value); if (targetObject != null) { CodeTypeReference delegateType = new CodeTypeReference(e.EventType); CodeDelegateCreateExpression listener = new CodeDelegateCreateExpression(delegateType, _thisRef, methodName); CodeEventReferenceExpression eventRef = new CodeEventReferenceExpression(targetObject, e.Name); CodeAttachEventStatement statement = new CodeAttachEventStatement(eventRef, listener); statement.UserData[typeof(Delegate)] = e.EventType; statements.Add(statement); } } } } catch (Exception innerException) { if (innerException is TargetInvocationException) { innerException = innerException.InnerException; } manager.ReportError(System.Design.SR.GetString("SerializerPropertyGenFailed", new object[] { e.Name, innerException.Message })); } }
public override void Serialize(IDesignerSerializationManager manager, object value, MemberDescriptor descriptor, CodeStatementCollection statements) { EventDescriptor e = descriptor as EventDescriptor; if (manager == null) { throw new ArgumentNullException("manager"); } if (value == null) { throw new ArgumentNullException("value"); } if (e == null) { throw new ArgumentNullException("descriptor"); } if (statements == null) { throw new ArgumentNullException("statements"); } try { IEventBindingService service = (IEventBindingService) manager.GetService(typeof(IEventBindingService)); if (service != null) { string methodName = (string) service.GetEventProperty(e).GetValue(value); if (methodName != null) { CodeExpression targetObject = base.SerializeToExpression(manager, value); if (targetObject != null) { CodeTypeReference delegateType = new CodeTypeReference(e.EventType); CodeDelegateCreateExpression listener = new CodeDelegateCreateExpression(delegateType, _thisRef, methodName); CodeEventReferenceExpression eventRef = new CodeEventReferenceExpression(targetObject, e.Name); CodeAttachEventStatement statement = new CodeAttachEventStatement(eventRef, listener); statement.UserData[typeof(Delegate)] = e.EventType; statements.Add(statement); } } } } catch (Exception innerException) { if (innerException is TargetInvocationException) { innerException = innerException.InnerException; } manager.ReportError(System.Design.SR.GetString("SerializerPropertyGenFailed", new object[] { e.Name, innerException.Message })); } }
public override void Serialize(IDesignerSerializationManager manager, object value, MemberDescriptor descriptor, CodeStatementCollection statements) { PropertyDescriptor property = descriptor as PropertyDescriptor; if (manager == null) { throw new ArgumentNullException("manager"); } if (value == null) { throw new ArgumentNullException("value"); } if (property == null) { throw new ArgumentNullException("descriptor"); } if (statements == null) { throw new ArgumentNullException("statements"); } try { ExtenderProvidedPropertyAttribute attribute = (ExtenderProvidedPropertyAttribute)property.Attributes[typeof(ExtenderProvidedPropertyAttribute)]; bool isExtender = (attribute != null) && (attribute.Provider != null); if (property.Attributes.Contains(DesignerSerializationVisibilityAttribute.Content)) { this.SerializeContentProperty(manager, value, property, isExtender, statements); } else if (isExtender) { this.SerializeExtenderProperty(manager, value, property, statements); } else { this.SerializeNormalProperty(manager, value, property, statements); } } catch (Exception innerException) { if (innerException is TargetInvocationException) { innerException = innerException.InnerException; } manager.ReportError(System.Design.SR.GetString("SerializerPropertyGenFailed", new object[] { property.Name, innerException.Message })); } }
public override void Serialize(IDesignerSerializationManager manager, object value, MemberDescriptor descriptor, CodeStatementCollection statements) { PropertyDescriptor property = descriptor as PropertyDescriptor; if (manager == null) { throw new ArgumentNullException("manager"); } if (value == null) { throw new ArgumentNullException("value"); } if (property == null) { throw new ArgumentNullException("descriptor"); } if (statements == null) { throw new ArgumentNullException("statements"); } try { ExtenderProvidedPropertyAttribute attribute = (ExtenderProvidedPropertyAttribute) property.Attributes[typeof(ExtenderProvidedPropertyAttribute)]; bool isExtender = (attribute != null) && (attribute.Provider != null); if (property.Attributes.Contains(DesignerSerializationVisibilityAttribute.Content)) { this.SerializeContentProperty(manager, value, property, isExtender, statements); } else if (isExtender) { this.SerializeExtenderProperty(manager, value, property, statements); } else { this.SerializeNormalProperty(manager, value, property, statements); } } catch (Exception innerException) { if (innerException is TargetInvocationException) { innerException = innerException.InnerException; } manager.ReportError(System.Design.SR.GetString("SerializerPropertyGenFailed", new object[] { property.Name, innerException.Message })); } }
private object DeserializeName(IDesignerSerializationManager manager, string name) { string typeName = null; Type objectType = null; object obj2 = this.nameTable[name]; using (CodeDomSerializerBase.TraceScope("RootCodeDomSerializer::DeserializeName")) { CodeMemberField field = null; CodeObject obj3 = obj2 as CodeObject; if (obj3 != null) { obj2 = null; this.nameTable[name] = null; if (obj3 is CodeVariableDeclarationStatement) { CodeVariableDeclarationStatement statement = (CodeVariableDeclarationStatement) obj3; typeName = CodeDomSerializerBase.GetTypeNameFromCodeTypeReference(manager, statement.Type); } else if (obj3 is CodeMemberField) { field = (CodeMemberField) obj3; typeName = CodeDomSerializerBase.GetTypeNameFromCodeTypeReference(manager, field.Type); } } else { if (obj2 != null) { return obj2; } IContainer service = (IContainer) manager.GetService(typeof(IContainer)); if (service != null) { IComponent component = service.Components[name]; if (component != null) { typeName = component.GetType().FullName; this.nameTable[name] = component; } } } if (name.Equals(this.ContainerName)) { IContainer container2 = (IContainer) manager.GetService(typeof(IContainer)); if (container2 != null) { obj2 = container2; } } else if (typeName != null) { objectType = manager.GetType(typeName); if (objectType == null) { manager.ReportError(new SerializationException(System.Design.SR.GetString("SerializerTypeNotFound", new object[] { typeName }))); } else { CodeStatementCollection codeObject = (CodeStatementCollection) this.statementTable[name]; if ((codeObject != null) && (codeObject.Count > 0)) { CodeDomSerializer serializer = (CodeDomSerializer) manager.GetSerializer(objectType, typeof(CodeDomSerializer)); if (serializer == null) { manager.ReportError(System.Design.SR.GetString("SerializerNoSerializerForComponent", new object[] { objectType.FullName })); } else { try { obj2 = serializer.Deserialize(manager, codeObject); if ((obj2 != null) && (field != null)) { PropertyDescriptor descriptor = TypeDescriptor.GetProperties(obj2)["Modifiers"]; if ((descriptor != null) && (descriptor.PropertyType == typeof(MemberAttributes))) { MemberAttributes attributes = field.Attributes & MemberAttributes.AccessMask; descriptor.SetValue(obj2, attributes); } } } catch (Exception exception) { manager.ReportError(exception); } } } } } this.nameTable[name] = obj2; } return obj2; }
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 })); } } }
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); }
public override object Serialize(IDesignerSerializationManager manager, object value) { CodeStatementCollection statements = null; PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(value); using (CodeDomSerializerBase.TraceScope("ComponentCodeDomSerializer::Serialize")) { if ((manager == null) || (value == null)) { throw new ArgumentNullException((manager == null) ? "manager" : "value"); } if (base.IsSerialized(manager, value)) { return base.GetExpression(manager, value); } InheritanceLevel notInherited = InheritanceLevel.NotInherited; InheritanceAttribute attribute = (InheritanceAttribute) TypeDescriptor.GetAttributes(value)[typeof(InheritanceAttribute)]; if (attribute != null) { notInherited = attribute.InheritanceLevel; } if (notInherited == InheritanceLevel.InheritedReadOnly) { return statements; } statements = new CodeStatementCollection(); CodeTypeDeclaration declaration = manager.Context[typeof(CodeTypeDeclaration)] as CodeTypeDeclaration; RootContext context = manager.Context[typeof(RootContext)] as RootContext; CodeExpression left = null; bool flag = false; bool flag2 = true; bool flag3 = true; bool flag4 = false; left = base.GetExpression(manager, value); if (left != null) { flag = false; flag2 = false; flag3 = false; IComponent component = value as IComponent; if ((component != null) && (component.Site == null)) { ExpressionContext context2 = manager.Context[typeof(ExpressionContext)] as ExpressionContext; if ((context2 == null) || (context2.PresetValue != value)) { flag4 = true; } } } else { if (notInherited == InheritanceLevel.NotInherited) { PropertyDescriptor descriptor = properties["GenerateMember"]; if (((descriptor != null) && (descriptor.PropertyType == typeof(bool))) && !((bool) descriptor.GetValue(value))) { flag = true; flag2 = false; } } else { flag3 = false; } if (context == null) { flag = true; flag2 = false; } } manager.Context.Push(value); manager.Context.Push(statements); try { try { string name = manager.GetName(value); string className = TypeDescriptor.GetClassName(value); if ((flag2 || flag) && (name != null)) { if (flag2) { if (notInherited == InheritanceLevel.NotInherited) { MemberAttributes @private; CodeMemberField field = new CodeMemberField(className, name); PropertyDescriptor descriptor2 = properties["Modifiers"]; if (descriptor2 == null) { descriptor2 = properties["DefaultModifiers"]; } if ((descriptor2 != null) && (descriptor2.PropertyType == typeof(MemberAttributes))) { @private = (MemberAttributes) descriptor2.GetValue(value); } else { @private = MemberAttributes.Private; } field.Attributes = @private; declaration.Members.Add(field); } left = new CodeFieldReferenceExpression(context.Expression, name); } else { if (notInherited == InheritanceLevel.NotInherited) { CodeVariableDeclarationStatement statement = new CodeVariableDeclarationStatement(className, name); statements.Add(statement); } left = new CodeVariableReferenceExpression(name); } } if (flag3) { CodeExpression expression2; IContainer service = manager.GetService(typeof(IContainer)) as IContainer; ConstructorInfo info = null; if (service != null) { info = CodeDomSerializerBase.GetReflectionTypeHelper(manager, value).GetConstructor(BindingFlags.ExactBinding | BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly, null, this.GetContainerConstructor(manager), null); } if (info != null) { expression2 = new CodeObjectCreateExpression(className, new CodeExpression[] { base.SerializeToExpression(manager, service) }); } else { bool flag5; expression2 = base.SerializeCreationExpression(manager, value, out flag5); } if (expression2 != null) { if (left == null) { if (flag4) { left = expression2; } } else { CodeAssignStatement statement2 = new CodeAssignStatement(left, expression2); statements.Add(statement2); } } } if (left != null) { base.SetExpression(manager, value, left); } if ((left != null) && !flag4) { bool flag6 = value is ISupportInitialize; if (flag6) { string fullName = typeof(ISupportInitialize).FullName; flag6 = manager.GetType(fullName) != null; } Type c = null; if (flag6) { c = CodeDomSerializerBase.GetReflectionTypeHelper(manager, value); flag6 = CodeDomSerializerBase.GetReflectionTypeFromTypeHelper(manager, typeof(ISupportInitialize)).IsAssignableFrom(c); } bool flag7 = (value is IPersistComponentSettings) && ((IPersistComponentSettings) value).SaveSettings; if (flag7) { string typeName = typeof(IPersistComponentSettings).FullName; flag7 = manager.GetType(typeName) != null; } if (flag7) { c = c ?? CodeDomSerializerBase.GetReflectionTypeHelper(manager, value); flag7 = CodeDomSerializerBase.GetReflectionTypeFromTypeHelper(manager, typeof(IPersistComponentSettings)).IsAssignableFrom(c); } IDesignerSerializationManager manager2 = (IDesignerSerializationManager) manager.GetService(typeof(IDesignerSerializationManager)); if (flag6) { this.SerializeSupportInitialize(manager, statements, left, value, "BeginInit"); } base.SerializePropertiesToResources(manager, statements, value, _designTimeFilter); ComponentCache serviceInstance = (ComponentCache) manager.GetService(typeof(ComponentCache)); ComponentCache.Entry entry = null; if (serviceInstance == null) { IServiceContainer container2 = (IServiceContainer) manager.GetService(typeof(IServiceContainer)); if (container2 != null) { serviceInstance = new ComponentCache(manager); container2.AddService(typeof(ComponentCache), serviceInstance); } } else if (((manager == manager2) && (serviceInstance != null)) && serviceInstance.Enabled) { entry = serviceInstance[value]; } if ((entry == null) || entry.Tracking) { if (entry == null) { entry = new ComponentCache.Entry(serviceInstance); ComponentCache.Entry entryAll = null; entryAll = serviceInstance.GetEntryAll(value); if (((entryAll != null) && (entryAll.Dependencies != null)) && (entryAll.Dependencies.Count > 0)) { foreach (object obj2 in entryAll.Dependencies) { entry.AddDependency(obj2); } } } entry.Component = value; bool flag8 = manager == manager2; entry.Valid = flag8 && this.CanCacheComponent(manager, value, properties); if ((flag8 && (serviceInstance != null)) && serviceInstance.Enabled) { manager.Context.Push(serviceInstance); manager.Context.Push(entry); } try { entry.Statements = new CodeStatementCollection(); base.SerializeProperties(manager, entry.Statements, value, _runTimeFilter); base.SerializeEvents(manager, entry.Statements, value, null); foreach (CodeStatement statement3 in entry.Statements) { if (statement3 is CodeVariableDeclarationStatement) { entry.Tracking = true; break; } } if (entry.Statements.Count > 0) { entry.Statements.Insert(0, new CodeCommentStatement(string.Empty)); entry.Statements.Insert(0, new CodeCommentStatement(name)); entry.Statements.Insert(0, new CodeCommentStatement(string.Empty)); if ((flag8 && (serviceInstance != null)) && serviceInstance.Enabled) { serviceInstance[value] = entry; } } } finally { if ((flag8 && (serviceInstance != null)) && serviceInstance.Enabled) { manager.Context.Pop(); manager.Context.Pop(); } } } else if (((entry.Resources != null) || (entry.Metadata != null)) && ((serviceInstance != null) && serviceInstance.Enabled)) { ResourceCodeDomSerializer.Default.ApplyCacheEntry(manager, entry); } statements.AddRange(entry.Statements); if (flag7) { this.SerializeLoadComponentSettings(manager, statements, left, value); } if (flag6) { this.SerializeSupportInitialize(manager, statements, left, value, "EndInit"); } } return statements; } catch (CheckoutException) { throw; } catch (Exception exception) { manager.ReportError(exception); } return statements; } finally { manager.Context.Pop(); manager.Context.Pop(); } } return statements; }
/// <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)); } } }
public override object Serialize(IDesignerSerializationManager manager, object value) { CodeStatementCollection statements = null; PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(value); using (CodeDomSerializerBase.TraceScope("ComponentCodeDomSerializer::Serialize")) { if ((manager == null) || (value == null)) { throw new ArgumentNullException((manager == null) ? "manager" : "value"); } if (base.IsSerialized(manager, value)) { return(base.GetExpression(manager, value)); } InheritanceLevel notInherited = InheritanceLevel.NotInherited; InheritanceAttribute attribute = (InheritanceAttribute)TypeDescriptor.GetAttributes(value)[typeof(InheritanceAttribute)]; if (attribute != null) { notInherited = attribute.InheritanceLevel; } if (notInherited == InheritanceLevel.InheritedReadOnly) { return(statements); } statements = new CodeStatementCollection(); CodeTypeDeclaration declaration = manager.Context[typeof(CodeTypeDeclaration)] as CodeTypeDeclaration; RootContext context = manager.Context[typeof(RootContext)] as RootContext; CodeExpression left = null; bool flag = false; bool flag2 = true; bool flag3 = true; bool flag4 = false; left = base.GetExpression(manager, value); if (left != null) { flag = false; flag2 = false; flag3 = false; IComponent component = value as IComponent; if ((component != null) && (component.Site == null)) { ExpressionContext context2 = manager.Context[typeof(ExpressionContext)] as ExpressionContext; if ((context2 == null) || (context2.PresetValue != value)) { flag4 = true; } } } else { if (notInherited == InheritanceLevel.NotInherited) { PropertyDescriptor descriptor = properties["GenerateMember"]; if (((descriptor != null) && (descriptor.PropertyType == typeof(bool))) && !((bool)descriptor.GetValue(value))) { flag = true; flag2 = false; } } else { flag3 = false; } if (context == null) { flag = true; flag2 = false; } } manager.Context.Push(value); manager.Context.Push(statements); try { try { string name = manager.GetName(value); string className = TypeDescriptor.GetClassName(value); if ((flag2 || flag) && (name != null)) { if (flag2) { if (notInherited == InheritanceLevel.NotInherited) { MemberAttributes @private; CodeMemberField field = new CodeMemberField(className, name); PropertyDescriptor descriptor2 = properties["Modifiers"]; if (descriptor2 == null) { descriptor2 = properties["DefaultModifiers"]; } if ((descriptor2 != null) && (descriptor2.PropertyType == typeof(MemberAttributes))) { @private = (MemberAttributes)descriptor2.GetValue(value); } else { @private = MemberAttributes.Private; } field.Attributes = @private; declaration.Members.Add(field); } left = new CodeFieldReferenceExpression(context.Expression, name); } else { if (notInherited == InheritanceLevel.NotInherited) { CodeVariableDeclarationStatement statement = new CodeVariableDeclarationStatement(className, name); statements.Add(statement); } left = new CodeVariableReferenceExpression(name); } } if (flag3) { CodeExpression expression2; IContainer service = manager.GetService(typeof(IContainer)) as IContainer; ConstructorInfo info = null; if (service != null) { info = CodeDomSerializerBase.GetReflectionTypeHelper(manager, value).GetConstructor(BindingFlags.ExactBinding | BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly, null, this.GetContainerConstructor(manager), null); } if (info != null) { expression2 = new CodeObjectCreateExpression(className, new CodeExpression[] { base.SerializeToExpression(manager, service) }); } else { bool flag5; expression2 = base.SerializeCreationExpression(manager, value, out flag5); } if (expression2 != null) { if (left == null) { if (flag4) { left = expression2; } } else { CodeAssignStatement statement2 = new CodeAssignStatement(left, expression2); statements.Add(statement2); } } } if (left != null) { base.SetExpression(manager, value, left); } if ((left != null) && !flag4) { bool flag6 = value is ISupportInitialize; if (flag6) { string fullName = typeof(ISupportInitialize).FullName; flag6 = manager.GetType(fullName) != null; } Type c = null; if (flag6) { c = CodeDomSerializerBase.GetReflectionTypeHelper(manager, value); flag6 = CodeDomSerializerBase.GetReflectionTypeFromTypeHelper(manager, typeof(ISupportInitialize)).IsAssignableFrom(c); } bool flag7 = (value is IPersistComponentSettings) && ((IPersistComponentSettings)value).SaveSettings; if (flag7) { string typeName = typeof(IPersistComponentSettings).FullName; flag7 = manager.GetType(typeName) != null; } if (flag7) { c = c ?? CodeDomSerializerBase.GetReflectionTypeHelper(manager, value); flag7 = CodeDomSerializerBase.GetReflectionTypeFromTypeHelper(manager, typeof(IPersistComponentSettings)).IsAssignableFrom(c); } IDesignerSerializationManager manager2 = (IDesignerSerializationManager)manager.GetService(typeof(IDesignerSerializationManager)); if (flag6) { this.SerializeSupportInitialize(manager, statements, left, value, "BeginInit"); } base.SerializePropertiesToResources(manager, statements, value, _designTimeFilter); ComponentCache serviceInstance = (ComponentCache)manager.GetService(typeof(ComponentCache)); ComponentCache.Entry entry = null; if (serviceInstance == null) { IServiceContainer container2 = (IServiceContainer)manager.GetService(typeof(IServiceContainer)); if (container2 != null) { serviceInstance = new ComponentCache(manager); container2.AddService(typeof(ComponentCache), serviceInstance); } } else if (((manager == manager2) && (serviceInstance != null)) && serviceInstance.Enabled) { entry = serviceInstance[value]; } if ((entry == null) || entry.Tracking) { if (entry == null) { entry = new ComponentCache.Entry(serviceInstance); ComponentCache.Entry entryAll = null; entryAll = serviceInstance.GetEntryAll(value); if (((entryAll != null) && (entryAll.Dependencies != null)) && (entryAll.Dependencies.Count > 0)) { foreach (object obj2 in entryAll.Dependencies) { entry.AddDependency(obj2); } } } entry.Component = value; bool flag8 = manager == manager2; entry.Valid = flag8 && this.CanCacheComponent(manager, value, properties); if ((flag8 && (serviceInstance != null)) && serviceInstance.Enabled) { manager.Context.Push(serviceInstance); manager.Context.Push(entry); } try { entry.Statements = new CodeStatementCollection(); base.SerializeProperties(manager, entry.Statements, value, _runTimeFilter); base.SerializeEvents(manager, entry.Statements, value, null); foreach (CodeStatement statement3 in entry.Statements) { if (statement3 is CodeVariableDeclarationStatement) { entry.Tracking = true; break; } } if (entry.Statements.Count > 0) { entry.Statements.Insert(0, new CodeCommentStatement(string.Empty)); entry.Statements.Insert(0, new CodeCommentStatement(name)); entry.Statements.Insert(0, new CodeCommentStatement(string.Empty)); if ((flag8 && (serviceInstance != null)) && serviceInstance.Enabled) { serviceInstance[value] = entry; } } } finally { if ((flag8 && (serviceInstance != null)) && serviceInstance.Enabled) { manager.Context.Pop(); manager.Context.Pop(); } } } else if (((entry.Resources != null) || (entry.Metadata != null)) && ((serviceInstance != null) && serviceInstance.Enabled)) { ResourceCodeDomSerializer.Default.ApplyCacheEntry(manager, entry); } statements.AddRange(entry.Statements); if (flag7) { this.SerializeLoadComponentSettings(manager, statements, left, value); } if (flag6) { this.SerializeSupportInitialize(manager, statements, left, value, "EndInit"); } } return(statements); } catch (CheckoutException) { throw; } catch (Exception exception) { manager.ReportError(exception); } return(statements); } finally { manager.Context.Pop(); manager.Context.Pop(); } } return(statements); }
private bool ResolveName(IDesignerSerializationManager manager, string name, bool canInvokeManager) { bool flag = false; CodeDomSerializerBase.OrderedCodeStatementCollection codeObject = this._statementsTable[name] as CodeDomSerializerBase.OrderedCodeStatementCollection; object[] objArray = (object[]) this._objectState[name]; if (name.IndexOf('.') > 0) { string outerComponent = null; IComponent instance = this.ResolveNestedName(manager, name, ref outerComponent); if ((instance != null) && (outerComponent != null)) { manager.SetName(instance, name); this.ResolveName(manager, outerComponent, canInvokeManager); } } if (codeObject == null) { flag = this._statementsTable[name] != null; if (!flag) { if (this._expressions.ContainsKey(name)) { ArrayList list2 = this._expressions[name]; foreach (CodeExpression expression2 in list2) { object obj3 = base.DeserializeExpression(manager, name, expression2); if (((obj3 != null) && !flag) && (canInvokeManager && (manager.GetInstance(name) == null))) { manager.SetName(obj3, name); flag = true; } } } if (!flag && canInvokeManager) { flag = manager.GetInstance(name) != null; } if ((flag && (objArray != null)) && (objArray[2] != null)) { this.DeserializeDefaultProperties(manager, name, objArray[2]); } if ((flag && (objArray != null)) && (objArray[3] != null)) { this.DeserializeDesignTimeProperties(manager, name, objArray[3]); } if ((flag && (objArray != null)) && (objArray[4] != null)) { this.DeserializeEventResets(manager, name, objArray[4]); } if ((flag && (objArray != null)) && (objArray[5] != null)) { DeserializeModifier(manager, name, objArray[5]); } } if (!flag && (flag || canInvokeManager)) { manager.ReportError(new CodeDomSerializerException(System.Design.SR.GetString("CodeDomComponentSerializationServiceDeserializationError", new object[] { name }), manager)); } return flag; } this._objectState[name] = null; this._statementsTable[name] = null; string typeName = null; foreach (CodeStatement statement in codeObject) { CodeVariableDeclarationStatement statement2 = statement as CodeVariableDeclarationStatement; if (statement2 != null) { typeName = statement2.Type.BaseType; break; } } if (typeName != null) { Type valueType = manager.GetType(typeName); if (valueType == null) { manager.ReportError(new CodeDomSerializerException(System.Design.SR.GetString("SerializerTypeNotFound", new object[] { typeName }), manager)); goto Label_01DA; } if ((codeObject == null) || (codeObject.Count <= 0)) { goto Label_01DA; } CodeDomSerializer serializer = base.GetSerializer(manager, valueType); if (serializer == null) { manager.ReportError(new CodeDomSerializerException(System.Design.SR.GetString("SerializerNoSerializerForComponent", new object[] { valueType.FullName }), manager)); goto Label_01DA; } try { object obj2 = serializer.Deserialize(manager, codeObject); flag = obj2 != null; if (flag) { this._statementsTable[name] = obj2; } goto Label_01DA; } catch (Exception exception) { manager.ReportError(exception); goto Label_01DA; } } foreach (CodeStatement statement3 in codeObject) { base.DeserializeStatement(manager, statement3); } flag = true; Label_01DA: if ((objArray != null) && (objArray[2] != null)) { this.DeserializeDefaultProperties(manager, name, objArray[2]); } if ((objArray != null) && (objArray[3] != null)) { this.DeserializeDesignTimeProperties(manager, name, objArray[3]); } if ((objArray != null) && (objArray[4] != null)) { this.DeserializeEventResets(manager, name, objArray[4]); } if ((objArray != null) && (objArray[5] != null)) { DeserializeModifier(manager, name, objArray[5]); } if (!this._expressions.ContainsKey(name)) { return flag; } ArrayList list = this._expressions[name]; foreach (CodeExpression expression in list) { base.DeserializeExpression(manager, name, expression); } this._expressions.Remove(name); return true; }
/// <include file='doc\CollectionCodeDomSerializer.uex' path='docs/doc[@for="CollectionCodeDomSerializer.SerializeArray"]/*' /> /// <devdoc> /// Serializes the given array. /// </devdoc> private object SerializeArray(IDesignerSerializationManager manager, CodePropertyReferenceExpression propRef, Type asType, Array array, object targetObject) { object result = null; Debug.WriteLineIf(traceSerialization.TraceVerbose, "CollectionCodeDomSerializer::SerializeArray"); Debug.Indent(); if (array.Rank != 1) { Debug.WriteLineIf(traceSerialization.TraceError, "*** Cannot serialize arrays with rank > 1. ***"); manager.ReportError(SR.GetString(SR.SerializerInvalidArrayRank, array.Rank.ToString())); } else { // For an array, we need an array create expression. First, get the array type // Type elementType = null; if (asType != null) { elementType = asType; } else { elementType = array.GetType().GetElementType(); } CodeTypeReference elementTypeRef = new CodeTypeReference(elementType); Debug.WriteLineIf(traceSerialization.TraceVerbose, "Array type: " + elementType.Name); Debug.WriteLineIf(traceSerialization.TraceVerbose, "Length:" + array.Length.ToString()); // Now create an ArrayCreateExpression, and fill its initializers. // CodeArrayCreateExpression arrayCreate = new CodeArrayCreateExpression(); arrayCreate.CreateType = elementTypeRef; bool arrayOk = true; ICollection collection = array; bool isTargetInherited = false; IComponent comp = targetObject as IComponent; if (comp != null) { InheritanceAttribute ia = (InheritanceAttribute)TypeDescriptor.GetAttributes(comp)[typeof(InheritanceAttribute)]; isTargetInherited = (ia != null && ia.InheritanceLevel == InheritanceLevel.Inherited); } if (isTargetInherited) { InheritedPropertyDescriptor inheritedDesc = manager.Context[typeof(PropertyDescriptor)] as InheritedPropertyDescriptor; if (inheritedDesc != null) { collection = GetCollectionDelta(inheritedDesc.OriginalValue as ICollection, array); } } CodeValueExpression codeValue = new CodeValueExpression(null, collection, elementType); manager.Context.Push(codeValue); try { foreach (object o in collection) { // If this object is being privately inherited, it cannot be inside // this collection. Since we're writing an entire array here, we // cannot write any of it. // if (o is IComponent && TypeDescriptor.GetAttributes(o).Contains(InheritanceAttribute.InheritedReadOnly)) { arrayOk = false; break; } object expression = SerializeToExpression(manager, o); if (expression is CodeExpression) { arrayCreate.Initializers.Add((CodeExpression)expression); } else { arrayOk = false; break; } } } finally { manager.Context.Pop(); } // if we weren't given a property, we're done. Otherwise, we must create an assign statement for // the property. // if (arrayOk) { if (propRef != null) { result = new CodeAssignStatement(propRef, arrayCreate); } else { result = arrayCreate; } } } Debug.Unindent(); return(result); }
protected object DeserializeExpression(IDesignerSerializationManager manager, string name, CodeExpression expression) { object instance = expression; using (TraceScope("CodeDomSerializerBase::DeserializeExpression")) { while (instance != null) { CodePrimitiveExpression expression2 = instance as CodePrimitiveExpression; if (expression2 != null) { return expression2.Value; } CodePropertyReferenceExpression propertyReferenceEx = instance as CodePropertyReferenceExpression; if (propertyReferenceEx != null) { return this.DeserializePropertyReferenceExpression(manager, propertyReferenceEx, true); } if (instance is CodeThisReferenceExpression) { RootContext context = (RootContext) manager.Context[typeof(RootContext)]; if (context != null) { instance = context.Value; } else { IDesignerHost host = manager.GetService(typeof(IDesignerHost)) as IDesignerHost; if (host != null) { instance = host.RootComponent; } } if (instance == null) { Error(manager, System.Design.SR.GetString("SerializerNoRootExpression"), "SerializerNoRootExpression"); } return instance; } CodeTypeReferenceExpression expression4 = instance as CodeTypeReferenceExpression; if (expression4 != null) { return manager.GetType(GetTypeNameFromCodeTypeReference(manager, expression4.Type)); } CodeObjectCreateExpression expression5 = instance as CodeObjectCreateExpression; if (expression5 != null) { instance = null; Type c = manager.GetType(GetTypeNameFromCodeTypeReference(manager, expression5.CreateType)); if (c != null) { object[] parameters = new object[expression5.Parameters.Count]; bool flag = true; for (int i = 0; i < parameters.Length; i++) { parameters[i] = this.DeserializeExpression(manager, null, expression5.Parameters[i]); if (parameters[i] is CodeExpression) { if ((typeof(Delegate).IsAssignableFrom(c) && (parameters.Length == 1)) && (parameters[i] is CodeMethodReferenceExpression)) { CodeMethodReferenceExpression expression19 = (CodeMethodReferenceExpression) parameters[i]; if (!(expression19.TargetObject is CodeThisReferenceExpression)) { object obj3 = this.DeserializeExpression(manager, null, expression19.TargetObject); if (!(obj3 is CodeExpression)) { MethodInfo method = c.GetMethod("Invoke"); if (method != null) { ParameterInfo[] infoArray = method.GetParameters(); Type[] types = new Type[infoArray.Length]; for (int j = 0; j < types.Length; j++) { types[j] = infoArray[i].ParameterType; } if (GetReflectionTypeHelper(manager, obj3).GetMethod(expression19.MethodName, types) != null) { MethodInfo info2 = obj3.GetType().GetMethod(expression19.MethodName, types); instance = Activator.CreateInstance(c, new object[] { obj3, info2.MethodHandle.GetFunctionPointer() }); } } } } } flag = false; break; } } if (flag) { instance = this.DeserializeInstance(manager, c, parameters, name, name != null); } return instance; } Error(manager, System.Design.SR.GetString("SerializerTypeNotFound", new object[] { expression5.CreateType.BaseType }), "SerializerTypeNotFound"); return instance; } CodeArgumentReferenceExpression expression6 = instance as CodeArgumentReferenceExpression; if (expression6 != null) { instance = manager.GetInstance(expression6.ParameterName); if (instance == null) { Error(manager, System.Design.SR.GetString("SerializerUndeclaredName", new object[] { expression6.ParameterName }), "SerializerUndeclaredName"); } return instance; } CodeFieldReferenceExpression expression7 = instance as CodeFieldReferenceExpression; if (expression7 != null) { object obj4 = this.DeserializeExpression(manager, null, expression7.TargetObject); if ((obj4 != null) && !(obj4 is CodeExpression)) { FieldInfo field; object obj6; RootContext context2 = (RootContext) manager.Context[typeof(RootContext)]; if ((context2 != null) && (context2.Value == obj4)) { object obj5 = manager.GetInstance(expression7.FieldName); if (obj5 != null) { return obj5; } Error(manager, System.Design.SR.GetString("SerializerUndeclaredName", new object[] { expression7.FieldName }), "SerializerUndeclaredName"); return instance; } Type type = obj4 as Type; if (type != null) { obj6 = null; field = GetReflectionTypeFromTypeHelper(manager, type).GetField(expression7.FieldName, BindingFlags.GetField | BindingFlags.Public | BindingFlags.Static); } else { obj6 = obj4; field = GetReflectionTypeHelper(manager, obj4).GetField(expression7.FieldName, BindingFlags.GetField | BindingFlags.Public | BindingFlags.Instance); } if (field != null) { return field.GetValue(obj6); } CodePropertyReferenceExpression expression20 = new CodePropertyReferenceExpression { TargetObject = expression7.TargetObject, PropertyName = expression7.FieldName }; instance = this.DeserializePropertyReferenceExpression(manager, expression20, false); if (instance == expression7) { Error(manager, System.Design.SR.GetString("SerializerUndeclaredName", new object[] { expression7.FieldName }), "SerializerUndeclaredName"); } return instance; } Error(manager, System.Design.SR.GetString("SerializerFieldTargetEvalFailed", new object[] { expression7.FieldName }), "SerializerFieldTargetEvalFailed"); return instance; } CodeMethodInvokeExpression expression8 = instance as CodeMethodInvokeExpression; if (expression8 != null) { object component = this.DeserializeExpression(manager, null, expression8.Method.TargetObject); if (component != null) { object[] args = new object[expression8.Parameters.Count]; bool flag2 = true; for (int k = 0; k < args.Length; k++) { args[k] = this.DeserializeExpression(manager, null, expression8.Parameters[k]); if (args[k] is CodeExpression) { flag2 = false; break; } } if (flag2) { IComponentChangeService service = (IComponentChangeService) manager.GetService(typeof(IComponentChangeService)); Type type3 = component as Type; if (type3 != null) { return GetReflectionTypeFromTypeHelper(manager, type3).InvokeMember(expression8.Method.MethodName, BindingFlags.InvokeMethod | BindingFlags.Public | BindingFlags.Static, null, null, args, null, null, null); } if (service != null) { service.OnComponentChanging(component, null); } try { instance = GetReflectionTypeHelper(manager, component).InvokeMember(expression8.Method.MethodName, BindingFlags.InvokeMethod | BindingFlags.Public | BindingFlags.Instance, null, component, args, null, null, null); } catch (MissingMethodException) { CodeCastExpression targetObject = expression8.Method.TargetObject as CodeCastExpression; if (targetObject == null) { throw; } Type type4 = manager.GetType(GetTypeNameFromCodeTypeReference(manager, targetObject.TargetType)); if ((type4 == null) || !type4.IsInterface) { throw; } instance = GetReflectionTypeFromTypeHelper(manager, type4).InvokeMember(expression8.Method.MethodName, BindingFlags.InvokeMethod | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance, null, component, args, null, null, null); } if (service != null) { service.OnComponentChanged(component, null, null, null); } return instance; } if ((args.Length == 1) && (args[0] is CodeDelegateCreateExpression)) { string methodName = expression8.Method.MethodName; if (methodName.StartsWith("add_")) { methodName = methodName.Substring(4); this.DeserializeAttachEventStatement(manager, new CodeAttachEventStatement(expression8.Method.TargetObject, methodName, (CodeExpression) args[0])); instance = null; } } } return instance; } CodeVariableReferenceExpression expression9 = instance as CodeVariableReferenceExpression; if (expression9 != null) { instance = manager.GetInstance(expression9.VariableName); if (instance == null) { Error(manager, System.Design.SR.GetString("SerializerUndeclaredName", new object[] { expression9.VariableName }), "SerializerUndeclaredName"); } return instance; } CodeCastExpression expression10 = instance as CodeCastExpression; if (expression10 != null) { instance = this.DeserializeExpression(manager, name, expression10.Expression); IConvertible convertible = instance as IConvertible; if (convertible != null) { Type conversionType = manager.GetType(GetTypeNameFromCodeTypeReference(manager, expression10.TargetType)); if (conversionType != null) { instance = convertible.ToType(conversionType, null); } } return instance; } if (instance is CodeBaseReferenceExpression) { RootContext context3 = (RootContext) manager.Context[typeof(RootContext)]; if (context3 != null) { return context3.Value; } return null; } CodeArrayCreateExpression expression11 = instance as CodeArrayCreateExpression; if (expression11 != null) { Type type6 = manager.GetType(GetTypeNameFromCodeTypeReference(manager, expression11.CreateType)); Array array = null; if (type6 != null) { if (expression11.Initializers.Count > 0) { ArrayList list = new ArrayList(expression11.Initializers.Count); foreach (CodeExpression expression22 in expression11.Initializers) { try { object o = this.DeserializeExpression(manager, null, expression22); if (!(o is CodeExpression)) { if (!type6.IsInstanceOfType(o)) { o = Convert.ChangeType(o, type6, CultureInfo.InvariantCulture); } list.Add(o); } } catch (Exception exception) { manager.ReportError(exception); } } array = Array.CreateInstance(type6, list.Count); list.CopyTo(array, 0); } else if (expression11.SizeExpression != null) { IConvertible convertible2 = this.DeserializeExpression(manager, name, expression11.SizeExpression) as IConvertible; if (convertible2 != null) { int length = convertible2.ToInt32(null); array = Array.CreateInstance(type6, length); } } else { array = Array.CreateInstance(type6, expression11.Size); } } else { Error(manager, System.Design.SR.GetString("SerializerTypeNotFound", new object[] { expression11.CreateType.BaseType }), "SerializerTypeNotFound"); } instance = array; if ((instance != null) && (name != null)) { manager.SetName(instance, name); } return instance; } CodeArrayIndexerExpression expression12 = instance as CodeArrayIndexerExpression; if (expression12 != null) { instance = null; Array array2 = this.DeserializeExpression(manager, name, expression12.TargetObject) as Array; if (array2 != null) { int[] indices = new int[expression12.Indices.Count]; bool flag3 = true; for (int m = 0; m < indices.Length; m++) { IConvertible convertible3 = this.DeserializeExpression(manager, name, expression12.Indices[m]) as IConvertible; if (convertible3 != null) { indices[m] = convertible3.ToInt32(null); } else { flag3 = false; break; } } if (flag3) { instance = array2.GetValue(indices); } } return instance; } CodeBinaryOperatorExpression expression13 = instance as CodeBinaryOperatorExpression; if (expression13 != null) { object obj10 = this.DeserializeExpression(manager, null, expression13.Left); object obj11 = this.DeserializeExpression(manager, null, expression13.Right); instance = obj10; IConvertible left = obj10 as IConvertible; IConvertible right = obj11 as IConvertible; if ((left != null) && (right != null)) { instance = this.ExecuteBinaryExpression(left, right, expression13.Operator); } return instance; } CodeDelegateInvokeExpression expression14 = instance as CodeDelegateInvokeExpression; if (expression14 != null) { Delegate delegate2 = this.DeserializeExpression(manager, null, expression14.TargetObject) as Delegate; if (delegate2 != null) { object[] objArray3 = new object[expression14.Parameters.Count]; bool flag4 = true; for (int n = 0; n < objArray3.Length; n++) { objArray3[n] = this.DeserializeExpression(manager, null, expression14.Parameters[n]); if (objArray3[n] is CodeExpression) { flag4 = false; break; } } if (flag4) { delegate2.DynamicInvoke(objArray3); } } return instance; } CodeDirectionExpression expression15 = instance as CodeDirectionExpression; if (expression15 != null) { return this.DeserializeExpression(manager, name, expression15.Expression); } CodeIndexerExpression expression16 = instance as CodeIndexerExpression; if (expression16 != null) { instance = null; object target = this.DeserializeExpression(manager, null, expression16.TargetObject); if (target != null) { object[] objArray4 = new object[expression16.Indices.Count]; bool flag5 = true; for (int num7 = 0; num7 < objArray4.Length; num7++) { objArray4[num7] = this.DeserializeExpression(manager, null, expression16.Indices[num7]); if (objArray4[num7] is CodeExpression) { flag5 = false; break; } } if (flag5) { instance = GetReflectionTypeHelper(manager, target).InvokeMember("Item", BindingFlags.GetProperty | BindingFlags.Public | BindingFlags.Instance, null, target, objArray4, null, null, null); } } return instance; } if (instance is CodeSnippetExpression) { return null; } CodeParameterDeclarationExpression expression17 = instance as CodeParameterDeclarationExpression; if (expression17 != null) { return manager.GetType(GetTypeNameFromCodeTypeReference(manager, expression17.Type)); } CodeTypeOfExpression expression18 = instance as CodeTypeOfExpression; if (expression18 != null) { string typeNameFromCodeTypeReference = GetTypeNameFromCodeTypeReference(manager, expression18.Type); for (int num8 = 0; num8 < expression18.Type.ArrayRank; num8++) { typeNameFromCodeTypeReference = typeNameFromCodeTypeReference + "[]"; } instance = manager.GetType(typeNameFromCodeTypeReference); if (instance == null) { Error(manager, System.Design.SR.GetString("SerializerTypeNotFound", new object[] { typeNameFromCodeTypeReference }), "SerializerTypeNotFound"); } return instance; } if (((instance is CodeEventReferenceExpression) || (instance is CodeMethodReferenceExpression)) || !(instance is CodeDelegateCreateExpression)) { } return instance; } } return instance; }
internal static void FillStatementTable(IDesignerSerializationManager manager, IDictionary table, Dictionary<string, string> names, CodeStatementCollection statements, string className) { using (TraceScope("CodeDomSerializerBase::FillStatementTable")) { CodeExpressionStatement statement4 = null; foreach (CodeStatement statement6 in statements) { CodeCastExpression expression2; CodeExpression left = null; CodeAssignStatement statement = statement6 as CodeAssignStatement; if (statement != null) { left = statement.Left; } else { CodeAttachEventStatement statement2 = statement6 as CodeAttachEventStatement; if (statement2 != null) { left = statement2.Event; } else { CodeRemoveEventStatement statement3 = statement6 as CodeRemoveEventStatement; if (statement3 != null) { left = statement3.Event; } else { statement4 = statement6 as CodeExpressionStatement; if (statement4 != null) { left = statement4.Expression; } else { CodeVariableDeclarationStatement statement5 = statement6 as CodeVariableDeclarationStatement; if (statement5 != null) { AddStatement(table, statement5.Name, statement5); if (((names != null) && (statement5.Type != null)) && !string.IsNullOrEmpty(statement5.Type.BaseType)) { names[statement5.Name] = GetTypeNameFromCodeTypeReference(manager, statement5.Type); } left = null; } } } } } if (left == null) { continue; } Label_00E4: while ((expression2 = left as CodeCastExpression) != null) { left = expression2.Expression; } CodeDelegateCreateExpression expression3 = left as CodeDelegateCreateExpression; if (expression3 != null) { left = expression3.TargetObject; goto Label_00E4; } CodeDelegateInvokeExpression expression4 = left as CodeDelegateInvokeExpression; if (expression4 != null) { left = expression4.TargetObject; goto Label_00E4; } CodeDirectionExpression expression5 = left as CodeDirectionExpression; if (expression5 != null) { left = expression5.Expression; goto Label_00E4; } CodeEventReferenceExpression expression6 = left as CodeEventReferenceExpression; if (expression6 != null) { left = expression6.TargetObject; goto Label_00E4; } CodeMethodInvokeExpression expression7 = left as CodeMethodInvokeExpression; if (expression7 != null) { left = expression7.Method; goto Label_00E4; } CodeMethodReferenceExpression expression8 = left as CodeMethodReferenceExpression; if (expression8 != null) { left = expression8.TargetObject; goto Label_00E4; } CodeArrayIndexerExpression expression9 = left as CodeArrayIndexerExpression; if (expression9 != null) { left = expression9.TargetObject; goto Label_00E4; } CodeFieldReferenceExpression expression10 = left as CodeFieldReferenceExpression; if (expression10 != null) { bool flag = false; if (expression10.TargetObject is CodeThisReferenceExpression) { Type objectType = GetType(manager, expression10.FieldName, names); if (objectType != null) { CodeDomSerializer serializer = manager.GetSerializer(objectType, typeof(CodeDomSerializer)) as CodeDomSerializer; if (serializer != null) { string str = serializer.GetTargetComponentName(statement6, left, objectType); if (!string.IsNullOrEmpty(str)) { AddStatement(table, str, statement6); flag = true; } } } if (!flag) { AddStatement(table, expression10.FieldName, statement6); } continue; } left = expression10.TargetObject; goto Label_00E4; } CodePropertyReferenceExpression expression11 = left as CodePropertyReferenceExpression; if (expression11 != null) { if ((expression11.TargetObject is CodeThisReferenceExpression) && ((names == null) || names.ContainsKey(expression11.PropertyName))) { AddStatement(table, expression11.PropertyName, statement6); continue; } left = expression11.TargetObject; goto Label_00E4; } CodeVariableReferenceExpression expression12 = left as CodeVariableReferenceExpression; if (expression12 != null) { bool flag2 = false; if (names != null) { Type type2 = GetType(manager, expression12.VariableName, names); if (type2 != null) { CodeDomSerializer serializer2 = manager.GetSerializer(type2, typeof(CodeDomSerializer)) as CodeDomSerializer; if (serializer2 != null) { string str2 = serializer2.GetTargetComponentName(statement6, left, type2); if (!string.IsNullOrEmpty(str2)) { AddStatement(table, str2, statement6); flag2 = true; } } } } else { AddStatement(table, expression12.VariableName, statement6); flag2 = true; } if (!flag2) { manager.ReportError(new CodeDomSerializerException(System.Design.SR.GetString("SerializerUndeclaredName", new object[] { expression12.VariableName }), manager)); } } else if (((left is CodeThisReferenceExpression) || (left is CodeBaseReferenceExpression)) && (className != null)) { AddStatement(table, className, statement6); } } } }
protected CodeExpression SerializeToExpression(IDesignerSerializationManager manager, object value) { CodeExpression legacyExpression = null; using (TraceScope("SerializeToExpression")) { if (value != null) { if (this.IsSerialized(manager, value)) { legacyExpression = this.GetExpression(manager, value); } else { legacyExpression = this.GetLegacyExpression(manager, value); if (legacyExpression != null) { this.SetExpression(manager, value, legacyExpression); } } } if (legacyExpression != null) { return legacyExpression; } CodeDomSerializer serializer = this.GetSerializer(manager, value); if (serializer != null) { CodeStatementCollection statements = null; if (value != null) { this.SetLegacyExpression(manager, value); StatementContext context = manager.Context[typeof(StatementContext)] as StatementContext; if (context != null) { statements = context.StatementCollection[value]; } if (statements != null) { manager.Context.Push(statements); } } object obj2 = null; try { obj2 = serializer.Serialize(manager, value); } finally { if (statements != null) { manager.Context.Pop(); } } legacyExpression = obj2 as CodeExpression; if ((legacyExpression == null) && (value != null)) { legacyExpression = this.GetExpression(manager, value); } CodeStatementCollection statements2 = obj2 as CodeStatementCollection; if (statements2 == null) { CodeStatement statement = obj2 as CodeStatement; if (statement != null) { statements2 = new CodeStatementCollection(); statements2.Add(statement); } } if (statements2 != null) { if (statements == null) { statements = manager.Context[typeof(CodeStatementCollection)] as CodeStatementCollection; } if (statements != null) { statements.AddRange(statements2); return legacyExpression; } string name = "(null)"; if (value != null) { name = manager.GetName(value); if (name == null) { name = value.GetType().Name; } } manager.ReportError(System.Design.SR.GetString("SerializerLostStatements", new object[] { name })); } return legacyExpression; } manager.ReportError(System.Design.SR.GetString("SerializerNoSerializerForComponent", new object[] { value.GetType().FullName })); } return legacyExpression; }
protected void DeserializeStatement(IDesignerSerializationManager manager, CodeStatement statement) { using (TraceScope("CodeDomSerializerBase::DeserializeStatement")) { manager.Context.Push(statement); try { CodeAssignStatement statement2 = statement as CodeAssignStatement; if (statement2 != null) { this.DeserializeAssignStatement(manager, statement2); } else { CodeVariableDeclarationStatement statement3 = statement as CodeVariableDeclarationStatement; if (statement3 != null) { this.DeserializeVariableDeclarationStatement(manager, statement3); } else if (!(statement is CodeCommentStatement)) { CodeExpressionStatement statement4 = statement as CodeExpressionStatement; if (statement4 != null) { this.DeserializeExpression(manager, null, statement4.Expression); } else if (statement is CodeMethodReturnStatement) { this.DeserializeExpression(manager, null, statement4.Expression); } else { CodeAttachEventStatement statement6 = statement as CodeAttachEventStatement; if (statement6 != null) { this.DeserializeAttachEventStatement(manager, statement6); } else { CodeRemoveEventStatement statement7 = statement as CodeRemoveEventStatement; if (statement7 != null) { this.DeserializeDetachEventStatement(manager, statement7); } else { CodeLabeledStatement statement8 = statement as CodeLabeledStatement; if (statement8 != null) { this.DeserializeStatement(manager, statement8.Statement); } } } } } } } catch (CheckoutException) { throw; } catch (Exception innerException) { if (innerException is TargetInvocationException) { innerException = innerException.InnerException; } if (!(innerException is CodeDomSerializerException) && (statement.LinePragma != null)) { innerException = new CodeDomSerializerException(innerException, statement.LinePragma); } manager.ReportError(innerException); } finally { manager.Context.Pop(); } } }
protected void DeserializePropertiesFromResources(IDesignerSerializationManager manager, object value, Attribute[] filter) { using (TraceScope("ComponentCodeDomSerializerBase::DeserializePropertiesFromResources")) { IDictionaryEnumerator metadataEnumerator = ResourceCodeDomSerializer.Default.GetMetadataEnumerator(manager); if (metadataEnumerator == null) { metadataEnumerator = ResourceCodeDomSerializer.Default.GetEnumerator(manager, CultureInfo.InvariantCulture); } if (metadataEnumerator != null) { string name; RootContext context = manager.Context[typeof(RootContext)] as RootContext; if ((context != null) && (context.Value == value)) { name = "$this"; } else { name = manager.GetName(value); } PropertyDescriptorCollection descriptors = GetPropertiesHelper(manager, value, null); while (metadataEnumerator.MoveNext()) { string key = metadataEnumerator.Key as string; int index = key.IndexOf('.'); if ((index != -1) && key.Substring(0, index).Equals(name)) { string str4 = key.Substring(index + 1); PropertyDescriptor descriptor = descriptors[str4]; if (descriptor != null) { bool flag = true; if (filter != null) { AttributeCollection attributes = descriptor.Attributes; foreach (Attribute attribute in filter) { if (!attributes.Contains(attribute)) { flag = false; break; } } } if (flag) { object obj2 = metadataEnumerator.Value; try { descriptor.SetValue(value, obj2); continue; } catch (Exception exception) { manager.ReportError(exception); continue; } } } } } } } }
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 })); } } }
internal void ReportError (IDesignerSerializationManager manager, string message, string details) { try { throw new Exception (message); } catch (Exception e) { e.Data["Details"] = message + Environment.NewLine + Environment.NewLine + details; manager.ReportError (e); } }
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 object DeserializeName(IDesignerSerializationManager manager, string name) { string typeName = null; Type objectType = null; object obj2 = this.nameTable[name]; using (CodeDomSerializerBase.TraceScope("RootCodeDomSerializer::DeserializeName")) { CodeMemberField field = null; CodeObject obj3 = obj2 as CodeObject; if (obj3 != null) { obj2 = null; this.nameTable[name] = null; if (obj3 is CodeVariableDeclarationStatement) { CodeVariableDeclarationStatement statement = (CodeVariableDeclarationStatement)obj3; typeName = CodeDomSerializerBase.GetTypeNameFromCodeTypeReference(manager, statement.Type); } else if (obj3 is CodeMemberField) { field = (CodeMemberField)obj3; typeName = CodeDomSerializerBase.GetTypeNameFromCodeTypeReference(manager, field.Type); } } else { if (obj2 != null) { return(obj2); } IContainer service = (IContainer)manager.GetService(typeof(IContainer)); if (service != null) { IComponent component = service.Components[name]; if (component != null) { typeName = component.GetType().FullName; this.nameTable[name] = component; } } } if (name.Equals(this.ContainerName)) { IContainer container2 = (IContainer)manager.GetService(typeof(IContainer)); if (container2 != null) { obj2 = container2; } } else if (typeName != null) { objectType = manager.GetType(typeName); if (objectType == null) { manager.ReportError(new SerializationException(System.Design.SR.GetString("SerializerTypeNotFound", new object[] { typeName }))); } else { CodeStatementCollection codeObject = (CodeStatementCollection)this.statementTable[name]; if ((codeObject != null) && (codeObject.Count > 0)) { CodeDomSerializer serializer = (CodeDomSerializer)manager.GetSerializer(objectType, typeof(CodeDomSerializer)); if (serializer == null) { manager.ReportError(System.Design.SR.GetString("SerializerNoSerializerForComponent", new object[] { objectType.FullName })); } else { try { obj2 = serializer.Deserialize(manager, codeObject); if ((obj2 != null) && (field != null)) { PropertyDescriptor descriptor = TypeDescriptor.GetProperties(obj2)["Modifiers"]; if ((descriptor != null) && (descriptor.PropertyType == typeof(MemberAttributes))) { MemberAttributes attributes = field.Attributes & MemberAttributes.AccessMask; descriptor.SetValue(obj2, attributes); } } } catch (Exception exception) { manager.ReportError(exception); } } } } } this.nameTable[name] = obj2; } return(obj2); }
/// <summary> /// This retrieves the value of this property. If the property returns false /// from ShouldSerializeValue (indicating the ambient value for this property) /// This will look for an AmbientValueAttribute and use it if it can. /// </summary> private object GetPropertyValue(IDesignerSerializationManager manager, PropertyDescriptor property, object value, out bool validValue) { object propertyValue = null; validValue = true; try { if (!property.ShouldSerializeValue(value)) { // We aren't supposed to be serializing this property, but we decided to do // it anyway. Check the property for an AmbientValue attribute and if we // find one, use it's value to serialize. AmbientValueAttribute attr = (AmbientValueAttribute)property.Attributes[typeof(AmbientValueAttribute)]; if (attr != null) { return(attr.Value); } else { DefaultValueAttribute defAttr = (DefaultValueAttribute)property.Attributes[typeof(DefaultValueAttribute)]; if (defAttr != null) { return(defAttr.Value); } else { // nope, we're not valid... // validValue = false; } } } propertyValue = property.GetValue(value); } catch (Exception e) { // something failed -- we don't have a valid value validValue = false; manager.ReportError(new CodeDomSerializerException(string.Format(SR.SerializerPropertyGenFailed, property.Name, e.Message), manager)); } if ((propertyValue != null) && (!propertyValue.GetType().IsValueType) && !(propertyValue is Type)) { // DevDiv2 (Dev11) bug 187766 : property whose type implements ISupportInitialize is not // serialized with Begin/EndInit. Type type = TypeDescriptor.GetProvider(propertyValue).GetReflectionType(typeof(object)); if (!type.IsDefined(typeof(ProjectTargetFrameworkAttribute), false)) { // TargetFrameworkProvider is not attached TypeDescriptionProvider typeProvider = CodeDomSerializerBase.GetTargetFrameworkProvider(manager, propertyValue); if (typeProvider != null) { TypeDescriptor.AddProvider(typeProvider, propertyValue); } } } return(propertyValue); }
/// <include file='doc\ComponentCodeDomSerializer.uex' path='docs/doc[@for="ComponentCodeDomSerializer.Serialize"]/*' /> /// <devdoc> /// Serializes the given object into a CodeDom object. /// </devdoc> public override object Serialize(IDesignerSerializationManager manager, object value) { Debug.WriteLineIf(traceSerialization.TraceVerbose, "ComponentCodeDomSerializer::Serialize"); Debug.Indent(); try { Debug.WriteLineIf(traceSerialization.TraceVerbose, "Value: " + value.ToString()); } catch { // in case the ToString throws... } if (manager == null || value == null) { throw new ArgumentNullException(manager == null ? "manager" : "value"); } CodeStatementCollection statements = new CodeStatementCollection(); CodeExpression instanceDescrExpr = null; InheritanceAttribute inheritanceAttribute = (InheritanceAttribute)TypeDescriptor.GetAttributes(value)[typeof(InheritanceAttribute)]; InheritanceLevel inheritanceLevel = InheritanceLevel.NotInherited; if (inheritanceAttribute != null) { inheritanceLevel = inheritanceAttribute.InheritanceLevel; } // Get the name for this object. Components can only be serialized if they have // a name. // string name = manager.GetName(value); bool generateDeclaration = (name != null); if (name == null) { IReferenceService referenceService = (IReferenceService)manager.GetService(typeof(IReferenceService)); if (referenceService != null) { name = referenceService.GetName(value); } } Debug.WriteLineIf(traceSerialization.TraceWarning && name == null, "WARNING: object has no name so we cannot serialize."); if (name != null) { Debug.WriteLineIf(traceSerialization.TraceVerbose, "Name: " + name); // Push the component being serialized onto the stack. It may be handy to // be able to discover this. // manager.Context.Push(value); try { try { // If the object is not inherited ensure that is has a component declaration. // if (generateDeclaration && inheritanceLevel == InheritanceLevel.NotInherited) { // Check to make sure this isn't our base component. If it is, there is // no need to serialize its declaration. // IDesignerHost host = (IDesignerHost)manager.GetService(typeof(IDesignerHost)); if ((host == null || host.RootComponent != value)) { SerializeDeclaration(manager, statements, value); } } else { Debug.WriteLineIf(traceSerialization.TraceVerbose, "Skipping declaration of inherited or namespace component."); } // Next, if the object is not being privately inherited, serialize the // rest of its state. // if (inheritanceLevel != InheritanceLevel.InheritedReadOnly) { bool supportInitialize = (value is ISupportInitialize); if (supportInitialize) { Debug.WriteLineIf(traceSerialization.TraceVerbose, "Object implements ISupportInitialize."); SerializeSupportInitialize(manager, statements, value, "BeginInit"); } // Add a nice comment that declares we're about to serialize this component // int insertLoc = statements.Count; SerializePropertiesToResources(manager, statements, value, designTimeProperties); SerializeProperties(manager, statements, value, runTimeProperties); SerializeEvents(manager, statements, value, null); // if we added some statements, insert the comments // if (statements.Count > insertLoc) { statements.Insert(insertLoc, new CodeCommentStatement(string.Empty)); statements.Insert(insertLoc, new CodeCommentStatement(name)); statements.Insert(insertLoc, new CodeCommentStatement(string.Empty)); } if (supportInitialize) { SerializeSupportInitialize(manager, statements, value, "EndInit"); } } else { Debug.WriteLineIf(traceSerialization.TraceVerbose, "Skipping serialization of read-only inherited component"); } } catch (Exception ex) { manager.ReportError(ex); } } finally { Debug.Assert(manager.Context.Current == value, "Context stack corrupted"); manager.Context.Pop(); } } else { Debug.WriteLineIf(traceSerialization.TraceWarning, "Attempting instance descriptor serialization."); Debug.Indent(); // Last resort, lets see if if can serialize itself to an instance descriptor. // if (TypeDescriptor.GetConverter(value).CanConvertTo(typeof(InstanceDescriptor))) { Debug.WriteLineIf(traceSerialization.TraceWarning, "Type supports instance descriptor."); // Got an instance descriptor. Ask it to serialize // object o = InstanceDescriptorCodeDomSerializer.Default.Serialize(manager, value); if (o is CodeExpression) { Debug.WriteLineIf(traceSerialization.TraceWarning, "Serialized successfully."); instanceDescrExpr = (CodeExpression)o; } } Debug.Unindent(); } if (instanceDescrExpr != null) { Debug.WriteLineIf(traceSerialization.TraceVerbose, "Object serialized into a single InstanceDescriptor expression."); Debug.Unindent(); return(instanceDescrExpr); } else { Debug.WriteLineIf(traceSerialization.TraceVerbose, "Object serialized into " + statements.Count.ToString() + " statements."); Debug.Unindent(); return(statements); } }
private object DeserializeName(IDesignerSerializationManager manager, string name, CodeStatementCollection statements) { object obj2 = null; using (CodeDomSerializerBase.TraceScope("RootCodeDomSerializer::DeserializeName")) { obj2 = this._nameTable[name]; CodeObject obj3 = obj2 as CodeObject; string typeName = null; CodeMemberField field = null; if (obj3 != null) { obj2 = null; this._nameTable[name] = null; CodeVariableDeclarationStatement statement = obj3 as CodeVariableDeclarationStatement; if (statement != null) { typeName = CodeDomSerializerBase.GetTypeNameFromCodeTypeReference(manager, statement.Type); } else { field = obj3 as CodeMemberField; if (field != null) { typeName = CodeDomSerializerBase.GetTypeNameFromCodeTypeReference(manager, field.Type); } else { CodeExpression expression = obj3 as CodeExpression; RootContext context = manager.Context[typeof(RootContext)] as RootContext; if (((context != null) && (expression != null)) && (context.Expression == expression)) { obj2 = context.Value; typeName = TypeDescriptor.GetClassName(obj2); } } } } else if (obj2 == null) { IContainer service = (IContainer)manager.GetService(typeof(IContainer)); if (service != null) { IComponent component = service.Components[name]; if (component != null) { typeName = component.GetType().FullName; this._nameTable[name] = component; } } } if (typeName == null) { return(obj2); } Type valueType = manager.GetType(typeName); if (valueType == null) { manager.ReportError(new CodeDomSerializerException(System.Design.SR.GetString("SerializerTypeNotFound", new object[] { typeName }), manager)); return(obj2); } if ((statements == null) && this._statementTable.ContainsKey(name)) { statements = this._statementTable[name]; } if ((statements == null) || (statements.Count <= 0)) { return(obj2); } CodeDomSerializer serializer = base.GetSerializer(manager, valueType); if (serializer == null) { manager.ReportError(new CodeDomSerializerException(System.Design.SR.GetString("SerializerNoSerializerForComponent", new object[] { valueType.FullName }), manager)); return(obj2); } try { obj2 = serializer.Deserialize(manager, statements); if ((obj2 != null) && (field != null)) { PropertyDescriptor descriptor = TypeDescriptor.GetProperties(obj2)["Modifiers"]; if ((descriptor != null) && (descriptor.PropertyType == typeof(MemberAttributes))) { MemberAttributes attributes = field.Attributes & MemberAttributes.AccessMask; descriptor.SetValue(obj2, attributes); } } this._nameTable[name] = obj2; } catch (Exception exception) { manager.ReportError(exception); } } return(obj2); }
public override object Serialize(IDesignerSerializationManager manager, object value) { if ((manager == null) || (value == null)) { throw new ArgumentNullException((manager == null) ? "manager" : "value"); } CodeTypeDeclaration declaration = new CodeTypeDeclaration(manager.GetName(value)); RootContext context = new RootContext(new CodeThisReferenceExpression(), value); using (CodeDomSerializerBase.TraceScope("RootCodeDomSerializer::Serialize")) { declaration.BaseTypes.Add(value.GetType()); this.containerRequired = false; manager.Context.Push(context); manager.Context.Push(this); manager.Context.Push(declaration); if (!(manager is DesignerSerializationManager)) { manager.AddSerializationProvider(new CodeDomSerializationProvider()); } try { if (value is IComponent) { ISite site = ((IComponent) value).Site; if (site == null) { return declaration; } ICollection components = site.Container.Components; StatementContext context2 = new StatementContext(); context2.StatementCollection.Populate(components); manager.Context.Push(context2); try { foreach (IComponent component in components) { if ((component != value) && !base.IsSerialized(manager, component)) { if (base.GetSerializer(manager, component) != null) { base.SerializeToExpression(manager, component); } else { manager.ReportError(System.Design.SR.GetString("SerializerNoSerializerForComponent", new object[] { component.GetType().FullName })); } } } manager.Context.Push(value); try { if ((base.GetSerializer(manager, value) != null) && !base.IsSerialized(manager, value)) { base.SerializeToExpression(manager, value); } else { manager.ReportError(System.Design.SR.GetString("SerializerNoSerializerForComponent", new object[] { value.GetType().FullName })); } } finally { manager.Context.Pop(); } } finally { manager.Context.Pop(); } CodeMemberMethod method = new CodeMemberMethod { Name = this.InitMethodName, Attributes = MemberAttributes.Private }; declaration.Members.Add(method); ArrayList elements = new ArrayList(); foreach (object obj2 in components) { if (obj2 != value) { elements.Add(context2.StatementCollection[obj2]); } } if (context2.StatementCollection[value] != null) { elements.Add(context2.StatementCollection[value]); } if (this.ContainerRequired) { this.SerializeContainerDeclaration(manager, method.Statements); } this.SerializeElementsToStatements(elements, method.Statements); } return declaration; } finally { manager.Context.Pop(); manager.Context.Pop(); manager.Context.Pop(); } } return declaration; }
protected CodeExpression SerializeToExpression (IDesignerSerializationManager manager, object instance) { if (manager == null) throw new ArgumentNullException ("manager"); if (instance == null) throw new ArgumentNullException ("instance"); CodeExpression expression = this.GetExpression (manager, instance); // 1 - IDesignerSerializationManager.GetExpression if (expression == null) { CodeDomSerializer serializer = this.GetSerializer (manager, instance); // 2 - manager.GetSerializer().Serialize() if (serializer != null) { object serialized = serializer.Serialize (manager, instance); expression = serialized as CodeExpression; // 3 - CodeStatement or CodeStatementCollection if (expression == null) { CodeStatement statement = serialized as CodeStatement; CodeStatementCollection statements = serialized as CodeStatementCollection; if (statement != null || statements != null) { CodeStatementCollection contextStatements = null; StatementContext context = manager.Context[typeof (StatementContext)] as StatementContext; if (context != null) contextStatements = context.StatementCollection[instance]; if (contextStatements == null) contextStatements = manager.Context[typeof (CodeStatementCollection)] as CodeStatementCollection; if (contextStatements != null) { if (statements != null) contextStatements.AddRange (statements); else contextStatements.Add (statement); } } } if (expression == null) expression = this.GetExpression (manager, instance); // 4 if (expression == null) manager.ReportError ("SerializeToExpression: " + instance.GetType ().AssemblyQualifiedName + " failed."); } } return expression; }
private object GetPropertyValue(IDesignerSerializationManager manager, PropertyDescriptor property, object value, out bool validValue) { object instance = null; validValue = true; try { if (!property.ShouldSerializeValue(value)) { AmbientValueAttribute attribute = (AmbientValueAttribute) property.Attributes[typeof(AmbientValueAttribute)]; if (attribute != null) { return attribute.Value; } DefaultValueAttribute attribute2 = (DefaultValueAttribute) property.Attributes[typeof(DefaultValueAttribute)]; if (attribute2 != null) { return attribute2.Value; } validValue = false; } instance = property.GetValue(value); } catch (Exception exception) { validValue = false; manager.ReportError(System.Design.SR.GetString("SerializerPropertyGenFailed", new object[] { property.Name, exception.Message })); } if (((instance != null) && !instance.GetType().IsValueType) && !TypeDescriptor.GetProvider(instance).GetReflectionType(typeof(object)).IsDefined(typeof(ProjectTargetFrameworkAttribute), false)) { TypeDescriptionProvider targetFrameworkProvider = CodeDomSerializerBase.GetTargetFrameworkProvider(manager, instance); if (targetFrameworkProvider != null) { TypeDescriptor.AddProvider(targetFrameworkProvider, instance); } } return instance; }
public override object Serialize(IDesignerSerializationManager manager, object value) { if ((manager == null) || (value == null)) { throw new ArgumentNullException((manager == null) ? "manager" : "value"); } CodeTypeDeclaration declaration = new CodeTypeDeclaration(manager.GetName(value)); RootContext context = new RootContext(new CodeThisReferenceExpression(), value); using (CodeDomSerializerBase.TraceScope("RootCodeDomSerializer::Serialize")) { declaration.BaseTypes.Add(value.GetType()); this.containerRequired = false; manager.Context.Push(context); manager.Context.Push(this); manager.Context.Push(declaration); if (!(manager is DesignerSerializationManager)) { manager.AddSerializationProvider(new CodeDomSerializationProvider()); } try { if (value is IComponent) { ISite site = ((IComponent)value).Site; if (site == null) { return(declaration); } ICollection components = site.Container.Components; StatementContext context2 = new StatementContext(); context2.StatementCollection.Populate(components); manager.Context.Push(context2); try { foreach (IComponent component in components) { if ((component != value) && !base.IsSerialized(manager, component)) { if (base.GetSerializer(manager, component) != null) { base.SerializeToExpression(manager, component); } else { manager.ReportError(System.Design.SR.GetString("SerializerNoSerializerForComponent", new object[] { component.GetType().FullName })); } } } manager.Context.Push(value); try { if ((base.GetSerializer(manager, value) != null) && !base.IsSerialized(manager, value)) { base.SerializeToExpression(manager, value); } else { manager.ReportError(System.Design.SR.GetString("SerializerNoSerializerForComponent", new object[] { value.GetType().FullName })); } } finally { manager.Context.Pop(); } } finally { manager.Context.Pop(); } CodeMemberMethod method = new CodeMemberMethod { Name = this.InitMethodName, Attributes = MemberAttributes.Private }; declaration.Members.Add(method); ArrayList elements = new ArrayList(); foreach (object obj2 in components) { if (obj2 != value) { elements.Add(context2.StatementCollection[obj2]); } } if (context2.StatementCollection[value] != null) { elements.Add(context2.StatementCollection[value]); } if (this.ContainerRequired) { this.SerializeContainerDeclaration(manager, method.Statements); } this.SerializeElementsToStatements(elements, method.Statements); } return(declaration); } finally { manager.Context.Pop(); manager.Context.Pop(); manager.Context.Pop(); } } return(declaration); }
public override object Serialize(IDesignerSerializationManager manager, object value) { CodeDomSerializer serial = GetBaseComponentSerializer(manager); if (serial == null) { return(null); } CodeStatementCollection statements = (CodeStatementCollection)serial.Serialize(manager, value); //serializer for web controls. if (!(manager.GetSerializer(typeof(System.Web.UI.Control), typeof(CodeDomSerializer)) is WebControlSerializer)) { manager.AddSerializationProvider(new WebControlSerializationProvider()); } IDesignerHost host = (IDesignerHost)manager.GetService(typeof(IDesignerHost)); if (host.RootComponent == value) { return(statements); } statements.AddRange(GetCommentHeader("Mapper code")); DataUIMapper cn = (DataUIMapper)value; CodeExpression cnref = SerializeToExpression(manager, value); #region Mapping property serialization CodePropertyReferenceExpression propref = new CodePropertyReferenceExpression(cnref, "Mappings"); foreach (MapperInfo mi in cn.Mappings) { MapperInfo info = mi; if (info.ControlID != String.Empty && info.ControlProperty != null && info.DataProperty != String.Empty) { object ctl = manager.GetInstance(info.ControlID); //if (ctl == null) //{ // manager.ReportError(String.Format("Control '{0}' associated with the view mapping in controller '{1}' doesn't exist in the page.", info.ControlID, manager.GetName(value))); // continue; //} if (ctl.GetType().GetProperty(info.ControlProperty) == null) { manager.ReportError(String.Format("Control property '{0}' in control '{1}' associated with the view mapping in datauimapper '{2}' doesn't exist.", info.ControlProperty, info.ControlID, manager.GetName(value))); continue; } statements.Add( new CodeMethodInvokeExpression( propref, "Add", new CodeExpression[] { new CodeObjectCreateExpression( typeof(MapperInfo), new CodeExpression[] { new CodePrimitiveExpression(info.ControlID), new CodePrimitiveExpression(info.ControlProperty), new CodePrimitiveExpression(info.DataProperty), new CodePrimitiveExpression((int)info.Format) } ) } )); } } #endregion statements.Add( new CodeCommentStatement("Connect the host environment.")); if (host.RootComponent as System.Windows.Forms.Form != null) { CodeObjectCreateExpression adapter = new CodeObjectCreateExpression(typeof(Adapter.WindowsFormsAdapter), new CodeExpression[0]); CodeExpression connect = new CodeMethodInvokeExpression(adapter, "Connect", new CodeExpression[] { cnref, new CodeThisReferenceExpression(), }); statements.Add(connect); } else if (host.RootComponent as System.Web.UI.Page != null) { CodeObjectCreateExpression adapter = new CodeObjectCreateExpression(typeof(Adapter.WebFormsAdapter), new CodeExpression[0]); CodeExpression connect = new CodeMethodInvokeExpression(adapter, "Connect", new CodeExpression[] { cnref, new CodeThisReferenceExpression(), }); statements.Add(connect); } return(statements); }
private object DeserializeName(IDesignerSerializationManager manager, string name, CodeStatementCollection statements) { object obj2 = null; using (CodeDomSerializerBase.TraceScope("RootCodeDomSerializer::DeserializeName")) { obj2 = this._nameTable[name]; CodeObject obj3 = obj2 as CodeObject; string typeName = null; CodeMemberField field = null; if (obj3 != null) { obj2 = null; this._nameTable[name] = null; CodeVariableDeclarationStatement statement = obj3 as CodeVariableDeclarationStatement; if (statement != null) { typeName = CodeDomSerializerBase.GetTypeNameFromCodeTypeReference(manager, statement.Type); } else { field = obj3 as CodeMemberField; if (field != null) { typeName = CodeDomSerializerBase.GetTypeNameFromCodeTypeReference(manager, field.Type); } else { CodeExpression expression = obj3 as CodeExpression; RootContext context = manager.Context[typeof(RootContext)] as RootContext; if (((context != null) && (expression != null)) && (context.Expression == expression)) { obj2 = context.Value; typeName = TypeDescriptor.GetClassName(obj2); } } } } else if (obj2 == null) { IContainer service = (IContainer) manager.GetService(typeof(IContainer)); if (service != null) { IComponent component = service.Components[name]; if (component != null) { typeName = component.GetType().FullName; this._nameTable[name] = component; } } } if (typeName == null) { return obj2; } Type valueType = manager.GetType(typeName); if (valueType == null) { manager.ReportError(new CodeDomSerializerException(System.Design.SR.GetString("SerializerTypeNotFound", new object[] { typeName }), manager)); return obj2; } if ((statements == null) && this._statementTable.ContainsKey(name)) { statements = this._statementTable[name]; } if ((statements == null) || (statements.Count <= 0)) { return obj2; } CodeDomSerializer serializer = base.GetSerializer(manager, valueType); if (serializer == null) { manager.ReportError(new CodeDomSerializerException(System.Design.SR.GetString("SerializerNoSerializerForComponent", new object[] { valueType.FullName }), manager)); return obj2; } try { obj2 = serializer.Deserialize(manager, statements); if ((obj2 != null) && (field != null)) { PropertyDescriptor descriptor = TypeDescriptor.GetProperties(obj2)["Modifiers"]; if ((descriptor != null) && (descriptor.PropertyType == typeof(MemberAttributes))) { MemberAttributes attributes = field.Attributes & MemberAttributes.AccessMask; descriptor.SetValue(obj2, attributes); } } this._nameTable[name] = obj2; } catch (Exception exception) { manager.ReportError(exception); } } return obj2; }
/// <summary> /// Serializes the given object into a CodeDom object. /// </summary> public override object Serialize(IDesignerSerializationManager manager, object value) { CodeStatementCollection statements = null; PropertyDescriptorCollection props = TypeDescriptor.GetProperties(value); using (TraceScope("ComponentCodeDomSerializer::Serialize")) { if (manager == null || value == null) { throw new ArgumentNullException(manager == null ? "manager" : "value"); } if (IsSerialized(manager, value)) { Debug.Fail("Serialize is being called twice for the same component"); return(GetExpression(manager, value)); } // If the object is being inherited, we will will not emit a variable declaration. Also, we won't // do any serialization at all if the object is privately inherited. InheritanceLevel inheritanceLevel = InheritanceLevel.NotInherited; InheritanceAttribute inheritanceAttribute = (InheritanceAttribute)TypeDescriptor.GetAttributes(value)[typeof(InheritanceAttribute)]; if (inheritanceAttribute != null) { inheritanceLevel = inheritanceAttribute.InheritanceLevel; } // First, skip everything if we're privately inherited. We cannot write any code that would affect this // component. TraceIf(inheritanceLevel == InheritanceLevel.InheritedReadOnly, "Skipping read only inherited component"); if (inheritanceLevel != InheritanceLevel.InheritedReadOnly) { // Things we need to know: // // 1. What expression should we use for the left hand side // a) already given to us via GetExpression? // b) a local variable? // c) a member variable? // // 2. Should we generate an init expression for this // object? // a) Inherited or existing expression: no // b) otherwise, yes. statements = new CodeStatementCollection(); CodeTypeDeclaration typeDecl = manager.Context[typeof(CodeTypeDeclaration)] as CodeTypeDeclaration; RootContext rootCxt = manager.Context[typeof(RootContext)] as RootContext; CodeExpression assignLhs = null; CodeExpression assignRhs; // Defaults for components bool generateLocal = false; bool generateField = true; bool generateObject = true; bool isComplete = false; assignLhs = GetExpression(manager, value); if (assignLhs != null) { Trace("Existing expression for LHS of value"); generateLocal = false; generateField = false; generateObject = false; // if we have an existing expression and this is not // a sited component, do not serialize it. We need this for Everett / 1.0 // backwards compat (even though it's wrong). if (value is IComponent comp && comp.Site == null) { // We were in a serialize content // property and would still serialize it. This code reverses what the // outer if block does for this specific case. We also need this // for Everett / 1.0 backwards compat. if (!(manager.Context[typeof(ExpressionContext)] is ExpressionContext expCxt) || expCxt.PresetValue != value) { isComplete = true; } } } else { Trace("Creating LHS expression"); if (inheritanceLevel == InheritanceLevel.NotInherited) { // See if there is a "GenerateMember" property. If so, // we might want to generate a local variable. Otherwise, // we want to generate a field. PropertyDescriptor generateProp = props["GenerateMember"]; if (generateProp != null && generateProp.PropertyType == typeof(bool) && !(bool)generateProp.GetValue(value)) { Trace("Object GenerateMember property wants a local variable"); generateLocal = true; generateField = false; } } else { generateObject = false; } if (rootCxt == null) { generateLocal = true; generateField = false; } } // Push the component being serialized onto the stack. It may be handy to // be able to discover this. manager.Context.Push(value); manager.Context.Push(statements); try { string name = manager.GetName(value); string typeName = TypeDescriptor.GetClassName(value); // Output variable / field declarations if we need to if ((generateField || generateLocal) && name != null) { if (generateField) { if (inheritanceLevel == InheritanceLevel.NotInherited) { // We need to generate the field declaration. See if there is a modifiers property on // the object. If not, look for a DefaultModifies, and finally assume it's private. CodeMemberField field = new CodeMemberField(typeName, name); PropertyDescriptor modifersProp = props["Modifiers"]; MemberAttributes fieldAttrs; if (modifersProp == null) { modifersProp = props["DefaultModifiers"]; } if (modifersProp != null && modifersProp.PropertyType == typeof(MemberAttributes)) { fieldAttrs = (MemberAttributes)modifersProp.GetValue(value); } else { TraceWarning("No Modifiers or DefaultModifiers property on component {0}. We must assume private.", name); fieldAttrs = MemberAttributes.Private; } field.Attributes = fieldAttrs; typeDecl.Members.Add(field); Trace("Field {0} {1} {2} created.", fieldAttrs, typeName, name); } // Next, create a nice LHS for our pending assign statement, when we hook up the variable. assignLhs = new CodeFieldReferenceExpression(rootCxt.Expression, name); } else { if (inheritanceLevel == InheritanceLevel.NotInherited) { CodeVariableDeclarationStatement local = new CodeVariableDeclarationStatement(typeName, name); statements.Add(local); Trace("Local {0} {1} created.", typeName, name); } assignLhs = new CodeVariableReferenceExpression(name); } } // Now output an object create if we need to. We always see if there is a // type converter that can provide us guidance if (generateObject) { // Ok, now that we've decided if we have a local or a member variable, its now time to serialize the rest of the code. // The first step is to create an assign statement to "new" the object. For that, we need to know if // the component wants a special IContainer constructor or not. For that to be valid we must also know // that we can get to an actual IContainer. IContainer container = manager.GetService(typeof(IContainer)) as IContainer; ConstructorInfo ctor = null; if (container != null) { ctor = GetReflectionTypeHelper(manager, value).GetConstructor(BindingFlags.ExactBinding | BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly, null, GetContainerConstructor(manager), null); } if (ctor != null) { Trace("Component has IContainer constructor."); assignRhs = new CodeObjectCreateExpression(typeName, new CodeExpression[] { SerializeToExpression(manager, container) }); } else { // For compat reasons we ignore the isCompleteOld value here. assignRhs = SerializeCreationExpression(manager, value, out bool isCompleteOld); Debug.Assert(isCompleteOld == isComplete, "CCDS Differing"); } TraceErrorIf(assignRhs == null, "No RHS code assign for object {0}", value); if (assignRhs != null) { if (assignLhs == null) { // We cannot do much more for this object. If isComplete is true, // then the RHS now becomes our LHS. Otherwise, I'm afraid we have // just failed to serialize this object. if (isComplete) { assignLhs = assignRhs; } else { TraceError("Incomplete serialization of object, abandoning serialization."); } } else { CodeAssignStatement assign = new CodeAssignStatement(assignLhs, assignRhs); statements.Add(assign); } } } if (assignLhs != null) { SetExpression(manager, value, assignLhs); } // It should practically be an assert that isComplete is false, but someone may // have an unusual component. if (assignLhs != null && !isComplete) { // .NET CF needs us to verify that the ISupportInitialize interface exists // (they do not support this interface and will modify their DSM to resolve the type to null). bool supportInitialize = (value is ISupportInitialize); if (supportInitialize) { string fullName = typeof(ISupportInitialize).FullName; supportInitialize = manager.GetType(fullName) != null; } Type reflectionType = null; if (supportInitialize) { // Now verify that this control implements ISupportInitialize in the project target framework // Don't use operator "is" but rather use IsAssignableFrom on the reflection types. // We have other places where we use operator "is", for example "is IComponent" to generate // specific CodeDOM objects, however we don't have cases of objects which were not an IComponent // in a downlevel framework and became an IComponent in a newer framework, so I'm not replacing // all instances of operator "is" by IsAssignableFrom. reflectionType = GetReflectionTypeHelper(manager, value); supportInitialize = GetReflectionTypeFromTypeHelper(manager, typeof(ISupportInitialize)).IsAssignableFrom(reflectionType); } bool persistSettings = (value is IPersistComponentSettings) && ((IPersistComponentSettings)value).SaveSettings; if (persistSettings) { string fullName = typeof(IPersistComponentSettings).FullName; persistSettings = manager.GetType(fullName) != null; } if (persistSettings) { reflectionType = reflectionType ?? GetReflectionTypeHelper(manager, value); persistSettings = GetReflectionTypeFromTypeHelper(manager, typeof(IPersistComponentSettings)).IsAssignableFrom(reflectionType); } // We implement statement caching only for the main code generation phase. We don't implement it for other // serialization managers. How do we tell the difference? The main serialization manager exists as a service. IDesignerSerializationManager mainManager = manager.GetService(typeof(IDesignerSerializationManager)) as IDesignerSerializationManager; if (supportInitialize) { Trace("Object implements ISupportInitialize."); SerializeSupportInitialize(manager, statements, assignLhs, value, "BeginInit"); } SerializePropertiesToResources(manager, statements, value, _designTimeFilter); // Writing out properties is expensive. But, we're very smart and we cache the results // in ComponentCache. See if we have cached results. If so, use 'em. If not, generate // code and then see if we can cache the results for later. ComponentCache cache = manager.GetService(typeof(ComponentCache)) as ComponentCache; ComponentCache.Entry entry = null; if (cache == null) { if (manager.GetService(typeof(IServiceContainer)) is ServiceContainer sc) { cache = new ComponentCache(manager); sc.AddService(typeof(ComponentCache), cache); } } else { if (manager == mainManager && cache.Enabled) { entry = cache[value]; } } if (entry == null || entry.Tracking) { // Pushing the entry here allows it to be found by the resource code dom serializer, // which will add data to the ResourceBlob property on the entry. if (entry == null) { entry = new ComponentCache.Entry(cache); // We cache components even if they're not valid so dependencies are // still tracked correctly (see comment below). The problem is, we will create a // new entry object even if there is still an existing one that is just invalid, and it // might have dependencies that will be lost. // we need to make sure we copy over any dependencies that are also tracked. ComponentCache.Entry oldEntry = cache?.GetEntryAll(value); if (oldEntry != null && oldEntry.Dependencies != null && oldEntry.Dependencies.Count > 0) { foreach (object dependency in oldEntry.Dependencies) { entry.AddDependency(dependency); } } } entry.Component = value; // we need to link the cached entry with its corresponding component right away, before it's put in the context // see CodeDomSerializerBase.cs::GetExpression for usage // This entry will only be used if the valid bit is set. // This is useful because we still need to setup depedency relationships // between components even if they are not cached. See VSWhidbey 263053. bool correctManager = manager == mainManager; entry.Valid = correctManager && CanCacheComponent(manager, value, props); if (correctManager && cache != null && cache.Enabled) { manager.Context.Push(cache); manager.Context.Push(entry); } try { entry.Statements = new CodeStatementCollection(); SerializeProperties(manager, entry.Statements, value, _runTimeFilter); SerializeEvents(manager, entry.Statements, value, null); foreach (CodeStatement statement in entry.Statements) { if (statement is CodeVariableDeclarationStatement local) { entry.Tracking = true; break; } } if (entry.Statements.Count > 0) { // if we added some statements, insert the comments // entry.Statements.Insert(0, new CodeCommentStatement(string.Empty)); entry.Statements.Insert(0, new CodeCommentStatement(name)); entry.Statements.Insert(0, new CodeCommentStatement(string.Empty)); // // cache the statements for future usage if possible. We only do this for the main serialization manager, not // for any other seriallization managers that may be calling us for undo or clipboard functions. if (correctManager && cache != null && cache.Enabled) { cache[value] = entry; } } } finally { if (correctManager && cache != null && cache.Enabled) { Debug.Assert(manager.Context.Current == entry, "Context stack corrupted"); manager.Context.Pop(); manager.Context.Pop(); } } } else { // If we got a cache entry, we will need to take all the resources out of // it and apply them too. if ((entry.Resources != null || entry.Metadata != null) && cache != null && cache.Enabled) { ResourceCodeDomSerializer res = ResourceCodeDomSerializer.Default; res.ApplyCacheEntry(manager, entry); } } // Regarless, apply statements. Either we created them or we got them // out of the cache. statements.AddRange(entry.Statements); if (persistSettings) { SerializeLoadComponentSettings(manager, statements, assignLhs, value); } if (supportInitialize) { SerializeSupportInitialize(manager, statements, assignLhs, value, "EndInit"); } } } catch (CheckoutException) { throw; } catch (Exception ex) { manager.ReportError(ex); } finally { Debug.Assert(manager.Context.Current == statements, "Context stack corrupted"); manager.Context.Pop(); manager.Context.Pop(); } } } return(statements); }