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);
}
}
public MemberRelationship this[MemberRelationship source]
{
get
{
if (source.Owner == null)
{
throw new ArgumentNullException("Owner");
}
if (source.Member == null)
{
throw new ArgumentNullException("Member");
}
return this.GetRelationship(source);
}
set
{
if (source.Owner == null)
{
throw new ArgumentNullException("Owner");
}
if (source.Member == null)
{
throw new ArgumentNullException("Member");
}
this.SetRelationship(source, value);
}
}
private static void ThrowRelationshipNotSupported(MemberRelationship source, MemberRelationship relationship)
{
string?sourceName = TypeDescriptor.GetComponentName(source.Owner !) ?? source.Owner !.ToString();
string?relName = TypeDescriptor.GetComponentName(relationship.Owner !) ?? relationship.Owner !.ToString();
throw new ArgumentException(SR.Format(SR.MemberRelationshipService_RelationshipNotSupported, sourceName, source.Member.Name, relName, relationship.Member.Name));
}
protected override MemberRelationship GetRelationship(MemberRelationship source)
{
LoggingService.Debug("MemberRelationshipService: GetRelationship called, source=" + ToString(source));
var mrs = base.GetRelationship(source);
LoggingService.Debug("MemberRelationshipService: -> returning " + ToString(mrs));
return mrs;
}
/// <summary>
/// Returns the current relationship associated with the source, or MemberRelationship.Empty if
/// there is no relationship. Also sets a relationship between two objects. Empty
/// can also be passed as the property value, in which case the relationship will
/// be cleared.
/// </summary>
public MemberRelationship this[MemberRelationship source]
{
get
{
// The Owner and Member properties can be null if the MemberRelationship is constructed
// using the default constructor. However there is no situation in which one is null
// and not the other as the main constructor performs argument validation.
if (source.Owner == null)
{
throw new ArgumentException(SR.Format(SR.InvalidNullArgument, "source.Owner"), nameof(source));
}
Debug.Assert(source.Member != null);
return(GetRelationship(source));
}
set
{
// The Owner and Member properties can be null if the MemberRelationship is constructed
// using the default constructor. However there is no situation in which one is null
// and not the other as the main constructor performs argument validation.
if (source.Owner == null)
{
throw new ArgumentException(SR.Format(SR.InvalidNullArgument, "source.Owner"), nameof(source));
}
Debug.Assert(source.Member != null);
SetRelationship(source, value);
}
}
public override bool SupportsRelationship(MemberRelationship source, MemberRelationship relationship)
{
#if WFDESIGN_LOG_MEMBERRELATIONSHIPSERVICE
LoggingService.Debug("MemberRelationshipService: SupportsRelationship called, source=" + ToString(source) + ", relationship=" + ToString(relationship));
#endif
return true;
}
/// <summary>
/// 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.
/// </summary>
protected virtual void SetRelationship(MemberRelationship source, MemberRelationship relationship)
{
if (!relationship.IsEmpty && !SupportsRelationship(source, relationship))
{
ThrowRelationshipNotSupported(source, relationship);
}
_relationships[new RelationshipEntry(source)] = new RelationshipEntry(relationship);
}
/// <summary>
/// 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.
/// </summary>
protected virtual MemberRelationship GetRelationship(MemberRelationship source)
{
if (_relationships.TryGetValue(new RelationshipEntry(source), out RelationshipEntry retVal) && retVal._owner.IsAlive)
{
return(new MemberRelationship(retVal._owner.Target !, retVal._member));
}
return(MemberRelationship.Empty);
}
/// <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)
{
ArgumentNullException.ThrowIfNull(manager);
ArgumentNullException.ThrowIfNull(value);
if (!(descriptor is PropertyDescriptor propertyToSerialize))
{
throw new ArgumentNullException(nameof(descriptor));
}
bool shouldSerializeProperty = propertyToSerialize.ShouldSerializeValue(value);
if (!shouldSerializeProperty)
{
SerializeAbsoluteContext absolute = (SerializeAbsoluteContext)manager.Context[typeof(SerializeAbsoluteContext)];
if (absolute is not 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.
if (manager.GetService(typeof(MemberRelationshipService)) is MemberRelationshipService relationships)
{
MemberRelationship relationship = relationships[value, descriptor];
if (relationship != MemberRelationship.Empty)
{
return(true);
}
}
return(false);
}
/// <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;
}
protected virtual MemberRelationship GetRelationship(MemberRelationship source)
{
RelationshipEntry entry;
if (((this._relationships != null) && this._relationships.TryGetValue(new RelationshipEntry(source), out entry)) && entry.Owner.IsAlive)
{
return new MemberRelationship(entry.Owner.Target, entry.Member);
}
return MemberRelationship.Empty;
}
protected virtual MemberRelationship GetRelationship(MemberRelationship source)
{
RelationshipEntry entry;
if (((this._relationships != null) && this._relationships.TryGetValue(new RelationshipEntry(source), out entry)) && entry.Owner.IsAlive)
{
return(new MemberRelationship(entry.Owner.Target, entry.Member));
}
return(MemberRelationship.Empty);
}
public MemberRelationship this [MemberRelationship source]
{
get
{
return(default(MemberRelationship));
}
set
{
}
}
public MemberRelationship this [MemberRelationship source]
{
get
{
return default(MemberRelationship);
}
set
{
}
}
public override bool Equals(object obj)
{
if (!(obj is MemberRelationship))
{
return(false);
}
MemberRelationship relationship = (MemberRelationship)obj;
return((relationship.Owner == this.Owner) && (relationship.Member == this.Member));
}
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 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);
}
}
/// <summary>
/// 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.
/// </summary>
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);
}
/// <summary>
/// Infrastructure support to make this a first class struct
/// </summary>
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);
}
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);
}
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);
}
/// <summary>
/// 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.
/// </summary>
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.Format(SR.MemberRelationshipService_RelationshipNotSupported, sourceName, source.Member.Name, relName, relationship.Member.Name));
}
_relationships[new RelationshipEntry(source)] = new RelationshipEntry(relationship);
}
protected virtual void SetRelationship(MemberRelationship source, MemberRelationship relationship)
{
if (!relationship.IsEmpty && !this.SupportsRelationship(source, relationship))
{
string componentName = TypeDescriptor.GetComponentName(source.Owner);
string str2 = TypeDescriptor.GetComponentName(relationship.Owner);
if (componentName == null)
{
componentName = source.Owner.ToString();
}
if (str2 == null)
{
str2 = relationship.Owner.ToString();
}
throw new ArgumentException(SR.GetString("MemberRelationshipService_RelationshipNotSupported", new object[] { componentName, source.Member.Name, str2, relationship.Member.Name }));
}
if (this._relationships == null)
{
this._relationships = new Dictionary<RelationshipEntry, RelationshipEntry>();
}
this._relationships[new RelationshipEntry(source)] = new RelationshipEntry(relationship);
}
protected virtual void SetRelationship(MemberRelationship source, MemberRelationship relationship)
{
if (!relationship.IsEmpty && !this.SupportsRelationship(source, relationship))
{
string componentName = TypeDescriptor.GetComponentName(source.Owner);
string str2 = TypeDescriptor.GetComponentName(relationship.Owner);
if (componentName == null)
{
componentName = source.Owner.ToString();
}
if (str2 == null)
{
str2 = relationship.Owner.ToString();
}
throw new ArgumentException(SR.GetString("MemberRelationshipService_RelationshipNotSupported", new object[] { componentName, source.Member.Name, str2, relationship.Member.Name }));
}
if (this._relationships == null)
{
this._relationships = new Dictionary <RelationshipEntry, RelationshipEntry>();
}
this._relationships[new RelationshipEntry(source)] = new RelationshipEntry(relationship);
}
public MemberRelationshipWeakEntry (MemberRelationship relation)
{
_ownerWeakRef = new WeakReference (relation.Owner);
_member = relation.Member;
}
/// <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 is 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.
if (manager.GetService(typeof(MemberRelationshipService)) is MemberRelationshipService relationships)
{
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 is null)
{
// Serialize the value of this property into a code expression. If we can't get one,
// then we won't serialize the property.
//
object propValue = GetPropertyValue(manager, property, value, out bool 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);
}
}
}
}
public MemberRelationship this[MemberRelationship source]
{
get { throw new NotImplementedException(); }
set { throw new NotImplementedException(); }
}
static MemberRelationship()
{
Empty = new MemberRelationship();
}
internal RelationshipEntry(MemberRelationship rel) {
Owner = new WeakReference(rel.Owner);
Member = rel.Member;
hashCode = rel.Owner == null ? 0 : rel.Owner.GetHashCode();
}
/// <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 MemberRelationship this [MemberRelationship source] {
get { return(GetRelationship(source)); }
set { SetRelationship(source, value); }
}
protected virtual new void SetRelationship(MemberRelationship source, MemberRelationship relationship)
{
}
private bool DeserializePropertyAssignStatement(IDesignerSerializationManager manager, CodeAssignStatement statement, CodePropertyReferenceExpression propertyReferenceEx, bool reportError)
{
object instance = this.DeserializeExpression(manager, null, propertyReferenceEx.TargetObject);
if ((instance != null) && !(instance is CodeExpression))
{
PropertyDescriptor member = GetPropertiesHelper(manager, instance, runTimeProperties)[propertyReferenceEx.PropertyName];
if (member != null)
{
object underlyingSystemType = this.DeserializeExpression(manager, null, statement.Right);
if (underlyingSystemType is CodeExpression)
{
return false;
}
IConvertible convertible = underlyingSystemType as IConvertible;
if ((convertible != null) && (member.PropertyType != underlyingSystemType.GetType()))
{
try
{
underlyingSystemType = convertible.ToType(member.PropertyType, null);
}
catch
{
}
}
Type type = underlyingSystemType as Type;
if ((type != null) && (type.UnderlyingSystemType != null))
{
underlyingSystemType = type.UnderlyingSystemType;
}
MemberRelationship empty = MemberRelationship.Empty;
MemberRelationshipService service = null;
if (statement.Right is CodePropertyReferenceExpression)
{
service = manager.GetService(typeof(MemberRelationshipService)) as MemberRelationshipService;
if (service != null)
{
CodePropertyReferenceExpression right = (CodePropertyReferenceExpression) statement.Right;
object obj4 = this.DeserializeExpression(manager, null, right.TargetObject);
PropertyDescriptor descriptor2 = GetPropertiesHelper(manager, obj4, null)[right.PropertyName];
if (descriptor2 != null)
{
MemberRelationship source = new MemberRelationship(instance, member);
MemberRelationship relationship = new MemberRelationship(obj4, descriptor2);
empty = service[source];
if (service.SupportsRelationship(source, relationship))
{
service[source] = relationship;
}
}
}
}
else
{
service = manager.GetService(typeof(MemberRelationshipService)) as MemberRelationshipService;
if (service != null)
{
empty = service[instance, member];
service[instance, member] = MemberRelationship.Empty;
}
}
try
{
member.SetValue(instance, underlyingSystemType);
}
catch
{
if (service != null)
{
service[instance, member] = empty;
}
throw;
}
return true;
}
if (reportError)
{
Error(manager, System.Design.SR.GetString("SerializerNoSuchProperty", new object[] { instance.GetType().FullName, propertyReferenceEx.PropertyName }), "SerializerNoSuchProperty");
}
}
return false;
}
protected virtual new MemberRelationship GetRelationship(MemberRelationship source)
{
return default(MemberRelationship);
}
public abstract bool SupportsRelationship(MemberRelationship source, MemberRelationship relationship);
static MemberRelationship()
{
Empty = new MemberRelationship();
}
protected virtual void SetRelationship(MemberRelationship source, MemberRelationship relationship)
{
throw new NotImplementedException();
}
protected virtual new void SetRelationship(MemberRelationship source, MemberRelationship relationship)
{
}
public abstract bool SupportsRelationship(MemberRelationship source, MemberRelationship relationship);
internal RelationshipEntry(MemberRelationship rel)
{
this.Owner = new WeakReference(rel.Owner);
this.Member = rel.Member;
this.hashCode = (rel.Owner == null) ? 0 : rel.Owner.GetHashCode();
}
public override bool SupportsRelationship(MemberRelationship source, MemberRelationship relationship)
{
return true;
}
static string ToString(MemberRelationship mrs)
{
return "[MR: IsEmpty=" + mrs.IsEmpty + ", Owner=[" + (mrs.Owner == null ? "<null>" : mrs.Owner.ToString()) + "], Member=[" + (mrs.Member == null ? "<null>" : mrs.Member.Name) + "]]";
}
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;
}
protected virtual new MemberRelationship GetRelationship(MemberRelationship source)
{
return(default(MemberRelationship));
}
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);
}
internal RelationshipEntry(MemberRelationship rel)
{
this.Owner = new WeakReference(rel.Owner);
this.Member = rel.Member;
this.hashCode = (rel.Owner == null) ? 0 : rel.Owner.GetHashCode();
}
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();
}
protected virtual MemberRelationship GetRelationship(MemberRelationship source)
{
throw new NotImplementedException();
}
protected override MemberRelationship GetRelationship(MemberRelationship source)
{
return base.GetRelationship(source);
}
