private void SerializeNormalProperty(IDesignerSerializationManager manager, object value, PropertyDescriptor property, CodeStatementCollection statements) { using (CodeDomSerializerBase.TraceScope("CodeDomSerializer::SerializeProperty")) { CodeExpression targetObject = base.SerializeToExpression(manager, value); if (targetObject != null) { CodeExpression expression = new CodePropertyReferenceExpression(targetObject, property.Name); CodeExpression right = null; MemberRelationshipService service = manager.GetService(typeof(MemberRelationshipService)) as MemberRelationshipService; if (service != null) { MemberRelationship relationship = service[value, property]; if (relationship != MemberRelationship.Empty) { CodeExpression expression4 = base.SerializeToExpression(manager, relationship.Owner); if (expression4 != null) { right = new CodePropertyReferenceExpression(expression4, relationship.Member.Name); } } } if (right == null) { bool flag; object obj2 = this.GetPropertyValue(manager, property, value, out flag); if (flag) { ExpressionContext context = null; if (obj2 != value) { context = new ExpressionContext(expression, property.PropertyType, value); manager.Context.Push(context); } try { right = base.SerializeToExpression(manager, obj2); } finally { if (context != null) { manager.Context.Pop(); } } } } if (right != null) { CodeAssignStatement statement = new CodeAssignStatement(expression, right); statements.Add(statement); } } } }
private MemberRelationship GetRelationship(IDesignerSerializationManager manager, object value, MemberDescriptor descriptor) { MemberRelationshipService service = manager.GetService(typeof(MemberRelationshipService)) as MemberRelationshipService; if (service != null) { return(service[value, descriptor]); } else { return(MemberRelationship.Empty); } }
public override bool ShouldSerialize(IDesignerSerializationManager manager, object value, MemberDescriptor descriptor) { PropertyDescriptor member = descriptor as PropertyDescriptor; if (manager == null) { throw new ArgumentNullException("manager"); } if (value == null) { throw new ArgumentNullException("value"); } if (member == null) { throw new ArgumentNullException("descriptor"); } bool flag = member.ShouldSerializeValue(value); if (!flag) { SerializeAbsoluteContext context = (SerializeAbsoluteContext)manager.Context[typeof(SerializeAbsoluteContext)]; if ((context != null) && context.ShouldSerialize(member)) { if (!member.Attributes.Contains(DesignerSerializationVisibilityAttribute.Content)) { flag = false; } else { flag = true; } } } if (flag && !member.Attributes.Contains(DesignOnlyAttribute.Yes)) { return(true); } MemberRelationshipService service = manager.GetService(typeof(MemberRelationshipService)) as MemberRelationshipService; if (service != null) { MemberRelationship relationship = service[value, descriptor]; if (relationship != MemberRelationship.Empty) { return(true); } } return(false); }
/// <summary> /// This method returns true if the given member descriptor should be serialized, /// or false if there is no need to serialize the member. /// </summary> public override bool ShouldSerialize(IDesignerSerializationManager manager, object value, MemberDescriptor descriptor) { PropertyDescriptor propertyToSerialize = descriptor as PropertyDescriptor; if (manager == null) { throw new ArgumentNullException(nameof(manager)); } if (value == null) { throw new ArgumentNullException(nameof(value)); } if (propertyToSerialize == null) { throw new ArgumentNullException(nameof(descriptor)); } bool shouldSerializeProperty = propertyToSerialize.ShouldSerializeValue(value); if (!shouldSerializeProperty) { SerializeAbsoluteContext absolute = (SerializeAbsoluteContext)manager.Context[typeof(SerializeAbsoluteContext)]; if (absolute != null && absolute.ShouldSerialize(propertyToSerialize)) { // For ReadOnly properties, we only want to override the value returned from // ShouldSerializeValue() if the property is marked with DesignerSerializationVisibilityAttribute(Content). // Consider the case of a property with just a getter - we only want to serialize those // if they're marked in this way (see ReflectPropertyDescriptor::ShouldSerializeValue()) if (!propertyToSerialize.Attributes.Contains(DesignerSerializationVisibilityAttribute.Content)) { shouldSerializeProperty = false; // it's already false at this point, but this is clearer. } else { shouldSerializeProperty = true; // Always serialize difference properties } } } if (shouldSerializeProperty) { bool isDesignTime = propertyToSerialize.Attributes.Contains(DesignOnlyAttribute.Yes); if (!isDesignTime) { return(true); } } // If we don't have to serialize, we need to make sure there isn't a member // relationship with this property. If there is, we still need to serialize. MemberRelationshipService relationships = manager.GetService(typeof(MemberRelationshipService)) as MemberRelationshipService; if (relationships != null) { MemberRelationship relationship = relationships[value, descriptor]; if (relationship != MemberRelationship.Empty) { return(true); } } return(false); }
/// <summary> /// This serializes the given property on this object. /// </summary> private void SerializeNormalProperty(IDesignerSerializationManager manager, object value, PropertyDescriptor property, CodeStatementCollection statements) { using (CodeDomSerializer.TraceScope("CodeDomSerializer::" + nameof(SerializeProperty))) { CodeExpression target = SerializeToExpression(manager, value); CodeDomSerializer.TraceWarningIf(target == null, "Unable to serialize target for property {0}", property.Name); if (target != null) { CodeExpression propertyRef = new CodePropertyReferenceExpression(target, property.Name); CodeExpression serializedPropertyValue = null; // First check for a member relationship service to see if this property // is related to another member. If it is, then we will use that // relationship to construct the property assign statement. if // it isn't, then we're serialize ourselves. MemberRelationshipService relationships = manager.GetService(typeof(MemberRelationshipService)) as MemberRelationshipService; if (relationships != null) { MemberRelationship relationship = relationships[value, property]; if (relationship != MemberRelationship.Empty) { CodeExpression rhsTarget = SerializeToExpression(manager, relationship.Owner); if (rhsTarget != null) { serializedPropertyValue = new CodePropertyReferenceExpression(rhsTarget, relationship.Member.Name); } } } if (serializedPropertyValue == null) { // Serialize the value of this property into a code expression. If we can't get one, // then we won't serialize the property. // bool validValue; object propValue = GetPropertyValue(manager, property, value, out validValue); if (validValue) { ExpressionContext tree = null; if (propValue != value) { // make sure the value isn't the object or we'll end up printing // this property instead of the value. tree = new ExpressionContext(propertyRef, property.PropertyType, value); manager.Context.Push(tree); } try { serializedPropertyValue = SerializeToExpression(manager, propValue); } finally { if (tree != null) { Debug.Assert(manager.Context.Current == tree, "Context stack corrupted."); manager.Context.Pop(); } } } } if (serializedPropertyValue != null) { CodeAssignStatement assign = new CodeAssignStatement(propertyRef, serializedPropertyValue); statements.Add(assign); } } } }