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);
}
}
}
}
