private void SerializeNormalProperty(IDesignerSerializationManager manager,
object component, PropertyDescriptor descriptor, CodeStatementCollection statements)
{
CodeAssignStatement assignment = new CodeAssignStatement();
CodeExpression leftSide = null;
CodePropertyReferenceExpression propRef = null;
ExpressionContext expression = manager.Context[typeof(ExpressionContext)] as ExpressionContext;
RootContext root = manager.Context[typeof(RootContext)] as RootContext;
if (expression != null && expression.PresetValue == component && expression.Expression != null)
{
leftSide = new CodePropertyReferenceExpression(expression.Expression, descriptor.Name);
}
else if (root != null && root.Value == component)
{
leftSide = new CodePropertyReferenceExpression(root.Expression, descriptor.Name);
}
else
{
propRef = new CodePropertyReferenceExpression();
propRef.PropertyName = descriptor.Name;
propRef.TargetObject = TryGetCachedExpression(manager, component, propRef);
leftSide = propRef;
}
CodeExpression rightSide = null;
MemberRelationship relationship = GetRelationship(manager, component, descriptor);
if (!relationship.IsEmpty)
{
propRef = new CodePropertyReferenceExpression();
propRef.PropertyName = relationship.Member.Name;
propRef.TargetObject = TryGetCachedExpression(manager, relationship.Owner, propRef);
rightSide = propRef;
}
else
{
object rightSideValue = descriptor.GetValue(component);
rightSide = TryGetCachedExpression(manager, rightSideValue, null, component);
}
if (rightSide == null)
{
Console.WriteLine("SerializeNormalProperty: <" + component.GetType().Name + "." +
descriptor.Name + "> - unable to serialize the right side of the assignment to expression");
}
else if (leftSide == null)
{
Console.WriteLine("SerializeNormalProperty: <" + component.GetType().Name + "." +
descriptor.Name + "> - unable to serialize the left side of the assignment to expression");
}
else
{
assignment.Left = leftSide;
assignment.Right = rightSide;
statements.Add(assignment);
}
}
public MemberRelationship this[MemberRelationship source] {
get {
if (source.Owner == null)
{
throw new ArgumentNullException("Owner");
}
if (source.Member == null)
{
throw new ArgumentNullException("Member");
}
return(GetRelationship(source));
}
set {
if (source.Owner == null)
{
throw new ArgumentNullException("Owner");
}
if (source.Member == null)
{
throw new ArgumentNullException("Member");
}
SetRelationship(source, value);
}
}
private void SerializeNormalProperty(IDesignerSerializationManager manager,
object instance, PropertyDescriptor descriptor, CodeStatementCollection statements)
{
CodeAssignStatement assignment = new CodeAssignStatement();
CodeExpression leftSide = null;
CodePropertyReferenceExpression propRef = null;
ExpressionContext expression = manager.Context[typeof(ExpressionContext)] as ExpressionContext;
RootContext root = manager.Context[typeof(RootContext)] as RootContext;
if (expression != null && expression.PresetValue == instance && expression.Expression != null)
{
leftSide = new CodePropertyReferenceExpression(expression.Expression, descriptor.Name);
}
else if (root != null && root.Value == instance)
{
leftSide = new CodePropertyReferenceExpression(root.Expression, descriptor.Name);
}
else
{
propRef = new CodePropertyReferenceExpression();
propRef.PropertyName = descriptor.Name;
propRef.TargetObject = base.SerializeToExpression(manager, instance);
leftSide = propRef;
}
CodeExpression rightSide = null;
MemberRelationship relationship = GetRelationship(manager, instance, descriptor);
if (!relationship.IsEmpty)
{
propRef = new CodePropertyReferenceExpression();
propRef.PropertyName = relationship.Member.Name;
propRef.TargetObject = base.SerializeToExpression(manager, relationship.Owner);
rightSide = propRef;
}
else
{
rightSide = base.SerializeToExpression(manager, descriptor.GetValue(instance));
}
if (rightSide == null || leftSide == null)
{
base.ReportError(manager, "Cannot serialize " + ((IComponent)instance).Site.Name + "." + descriptor.Name,
"Property Name: " + descriptor.Name + System.Environment.NewLine +
"Property Type: " + descriptor.PropertyType.Name + System.Environment.NewLine);
}
else
{
assignment.Left = leftSide;
assignment.Right = rightSide;
statements.Add(assignment);
}
}
/// <devdoc>
/// This is the implementation API for returning relationships. The default implementation stores the
/// relationship in a table. Relationships are stored weakly, so they do not keep an object alive.
/// </devdoc>
protected virtual MemberRelationship GetRelationship(MemberRelationship source)
{
RelationshipEntry retVal;
if (_relationships != null && _relationships.TryGetValue(new RelationshipEntry(source), out retVal) && retVal.Owner.IsAlive)
{
return(new MemberRelationship(retVal.Owner.Target, retVal.Member));
}
return(MemberRelationship.Empty);
}
/// <devdoc>
/// Infrastructure support to make this a first class struct
/// </devdoc>
public override bool Equals(object obj)
{
if (!(obj is MemberRelationship))
{
return(false);
}
MemberRelationship rel = (MemberRelationship)obj;
return(rel.Owner == Owner && rel.Member == Member);
}
protected virtual void SetRelationship(MemberRelationship source, MemberRelationship relationship)
{
if (source.IsEmpty)
{
throw new ArgumentNullException("source");
}
if (!relationship.IsEmpty && !this.SupportsRelationship(source, relationship))
{
throw new ArgumentException("Relationship not supported.");
}
_relations[new MemberRelationshipWeakEntry(source)] = new MemberRelationshipWeakEntry(relationship);
}
protected virtual MemberRelationship GetRelationship(MemberRelationship source)
{
if (source.IsEmpty)
{
throw new ArgumentNullException("source");
}
MemberRelationshipWeakEntry entry = _relations[new MemberRelationshipWeakEntry(source)] as MemberRelationshipWeakEntry;
if (entry != null)
{
return(new MemberRelationship(entry.Owner, entry.Member));
}
return(MemberRelationship.Empty);
}
private void SerializeNormalProperty(IDesignerSerializationManager manager,
object value, PropertyDescriptor descriptor, CodeStatementCollection statements)
{
CodeExpression leftSide = base.SerializeToExpression(manager, value);
CodeExpression rightSide = null;
MemberRelationship relationship = GetRelationship(manager, value, descriptor);
if (!relationship.IsEmpty)
{
rightSide = new CodePropertyReferenceExpression(base.SerializeToExpression(manager, relationship.Owner),
relationship.Member.Name);
}
else
{
rightSide = base.SerializeToExpression(manager, descriptor.GetValue(value));
}
statements.Add(new CodeAssignStatement(leftSide, rightSide));
}
/// <devdoc>
/// This is the implementation API for returning relationships. The default implementation stores the
/// relationship in a table. Relationships are stored weakly, so they do not keep an object alive. Empty can be
/// passed in for relationship to remove the relationship.
/// </devdoc>
protected virtual void SetRelationship(MemberRelationship source, MemberRelationship relationship)
{
if (!relationship.IsEmpty && !SupportsRelationship(source, relationship))
{
string sourceName = TypeDescriptor.GetComponentName(source.Owner);
string relName = TypeDescriptor.GetComponentName(relationship.Owner);
if (sourceName == null)
{
sourceName = source.Owner.ToString();
}
if (relName == null)
{
relName = relationship.Owner.ToString();
}
throw new ArgumentException(SR.GetString(SR.MemberRelationshipService_RelationshipNotSupported, sourceName, source.Member.Name, relName, relationship.Member.Name));
}
if (_relationships == null)
{
_relationships = new Dictionary <RelationshipEntry, RelationshipEntry>();
}
_relationships[new RelationshipEntry(source)] = new RelationshipEntry(relationship);
}
public MemberRelationshipWeakEntry (MemberRelationship relation)
{
_ownerWeakRef = new WeakReference (relation.Owner);
_member = relation.Member;
}
public MemberRelationship this [MemberRelationship source] {
get { return(GetRelationship(source)); }
set { SetRelationship(source, value); }
}
public MemberRelationshipWeakEntry(MemberRelationship relation)
{
_ownerWeakRef = new WeakReference(relation.Owner);
_member = relation.Member;
}
internal RelationshipEntry(MemberRelationship rel)
{
Owner = new WeakReference(rel.Owner);
Member = rel.Member;
hashCode = rel.Owner == null ? 0 : rel.Owner.GetHashCode();
}
/// <devdoc> /// Returns true if the provided relatinoship is supported. /// </devdoc> public abstract bool SupportsRelationship(MemberRelationship source, MemberRelationship relationship);
public abstract bool SupportsRelationship (MemberRelationship source, MemberRelationship relationship);
protected virtual MemberRelationship GetRelationship (MemberRelationship source)
{
if (source.IsEmpty)
throw new ArgumentNullException ("source");
MemberRelationshipWeakEntry entry = _relations[new MemberRelationshipWeakEntry (source)] as MemberRelationshipWeakEntry;
if (entry != null)
return new MemberRelationship (entry.Owner, entry.Member);
return MemberRelationship.Empty;
}
public MemberRelationship this [MemberRelationship source] {
get { return GetRelationship (source); }
set { SetRelationship (source, value); }
}
protected virtual void SetRelationship (MemberRelationship source, MemberRelationship relationship)
{
if (source.IsEmpty)
throw new ArgumentNullException ("source");
if (!relationship.IsEmpty && !this.SupportsRelationship (source, relationship))
throw new ArgumentException ("Relationship not supported.");
_relations[new MemberRelationshipWeakEntry (source)] = new MemberRelationshipWeakEntry (relationship);
}
