/// <summary>
/// Returns a collection of business objects that are connected to
/// this object through the specified relationship (eg. would return
/// a father and a mother if the relationship was "parents"). This
/// method is to be used in the case of multiple relationships.
/// </summary>
/// <param name="relationshipName">The name of the relationship</param>
/// <returns>Returns a business object collection</returns>
/// <exception cref="InvalidRelationshipAccessException">Thrown if
/// the relationship specified is a single relationship, when a
/// multiple one was expected</exception>
public virtual IBusinessObjectCollection GetRelatedCollection(string relationshipName)
{
ArgumentValidationHelper.CheckStringArgumentNotEmpty(relationshipName, "relationshipName");
IMultipleRelationship multipleRelationship = GetMultiple(relationshipName);
return(multipleRelationship.BusinessObjectCollection);
}
///<summary>
/// Returns a multiple relationship for with the specified relationship name.
///</summary>
///<param name="relationshipName">The specified relationship name</param>
///<returns>The multiple relationship</returns>
public IMultipleRelationship GetMultiple(string relationshipName)
{
ArgumentValidationHelper.CheckStringArgumentNotEmpty(relationshipName, "relationshipName");
IMultipleRelationship relationship = GetRelationshipAsMultiple(relationshipName);
return(relationship);
}
///<summary>
/// Returns a single relationship for with the specified relationship name.
///</summary>
///<param name="relationshipName">The specified relationship name</param>
///<returns>THe single relationship</returns>
public ISingleRelationship GetSingle(string relationshipName)
{
ArgumentValidationHelper.CheckStringArgumentNotEmpty(relationshipName, "relationshipName");
IRelationship relationship = GetRelationshipAsSingle(relationshipName);
return((ISingleRelationship)relationship);
}
/// <summary>
/// Returns the business object that is related to this object
/// through the specified relationship (eg. would return a father
/// if the relationship was called "father"). This method is to be
/// used in the case of single relationships.
/// </summary>
/// <param name="relationshipName">The name of the relationship</param>
/// <returns>Returns a business object</returns>
/// <exception cref="InvalidRelationshipAccessException">Thrown if
/// the relationship specified is a multiple relationship, when a
/// single one was expected</exception>
public T GetRelatedObject <T>(string relationshipName) where T : class, IBusinessObject, new()
{
ArgumentValidationHelper.CheckStringArgumentNotEmpty(relationshipName, "relationshipName");
SingleRelationship <T> relationship = GetSingle <T>(relationshipName);
return(relationship.GetRelatedObject());
}
/// <summary>
/// Returns the business object that is related to this object
/// through the specified relationship (eg. would return a father
/// if the relationship was called "father"). This method is to be
/// used in the case of single relationships.
/// </summary>
/// <param name="relationshipName">The name of the relationship</param>
/// <returns>Returns a business object</returns>
/// <exception cref="InvalidRelationshipAccessException">Thrown if
/// the relationship specified is a multiple relationship, when a
/// single one was expected</exception>
public IBusinessObject GetRelatedObject(string relationshipName)
{
ArgumentValidationHelper.CheckStringArgumentNotEmpty(relationshipName, "relationshipName");
ISingleRelationship relationship = GetSingle(relationshipName);
return(relationship.GetRelatedObject());
}
///<summary>
/// Returns a strongly typed multiple relationship for with the specified relationship name.
///</summary>
///<param name="relationshipName">The specified relationship name</param>
///<returns>The multiple relationship</returns>
public MultipleRelationship <T> GetMultiple <T>(string relationshipName)
where T : BusinessObject, new()
{
ArgumentValidationHelper.CheckStringArgumentNotEmpty(relationshipName, "relationshipName");
IMultipleRelationship relationship = GetRelationshipAsMultiple(relationshipName);
return((MultipleRelationship <T>)relationship);
}
/// <summary>
/// Returns a collection of business objects that are connected to
/// this object through the specified relationship (eg. would return
/// a father and a mother if the relationship was "parents"). This
/// method is to be used in the case of multiple relationships.
/// </summary>
/// <param name="relationshipName">The name of the relationship</param>
/// <returns>Returns a business object collection</returns>
/// <exception cref="InvalidRelationshipAccessException">Thrown if
/// the relationship specified is a single relationship, when a
/// multiple one was expected</exception>
public BusinessObjectCollection <TBusinessObject> GetRelatedCollection <TBusinessObject>(string relationshipName)
where TBusinessObject : BusinessObject, new()
{
ArgumentValidationHelper.CheckStringArgumentNotEmpty(relationshipName, "relationshipName");
MultipleRelationship <TBusinessObject> multipleRelationship = GetMultiple <TBusinessObject>(relationshipName);
return(multipleRelationship.BusinessObjectCollection);
}
///<summary>
/// Returns a strongly typed single relationship for with the specified relationship name.
///</summary>
///<param name="relationshipName">The specified relationship name</param>
///<returns>THe single relationship</returns>
public SingleRelationship <T> GetSingle <T>(string relationshipName)
where T : class, IBusinessObject, new()
{
ArgumentValidationHelper.CheckStringArgumentNotEmpty(relationshipName, "relationshipName");
IRelationship relationship = GetRelationshipAsSingle(relationshipName);
return((SingleRelationship <T>)relationship);
}
private IMultipleRelationship GetRelationshipAsMultiple(string relationshipName)
{
ArgumentValidationHelper.CheckStringArgumentNotEmpty(relationshipName, "relationshipName");
IRelationship relationship = this[relationshipName];
if (relationship is ISingleRelationship)
{
throw new InvalidRelationshipAccessException("The 'single' relationship " + relationshipName +
" was accessed as a 'multiple' relationship (using GetRelatedCollection()).");
}
return((IMultipleRelationship)relationship);
}
/// <summary>
/// Sets the related business object of a <b>single</b> relationship.
/// This includes setting the RelKey properties of the relationship owner
/// to the value of the related object's properties.
/// </summary>
/// <param name="relationshipName">The name of a single relationship</param>
/// <param name="relatedObject">The new related object</param>
/// <exception cref="InvalidRelationshipAccessException">Thrown if
/// the relationship named is a multiple relationship instead of a
/// single one</exception>
public void SetRelatedObject(string relationshipName, IBusinessObject relatedObject)
{
ArgumentValidationHelper.CheckStringArgumentNotEmpty(relationshipName, "relationshipName");
IRelationship relationship = this[relationshipName];
if (relationship is IMultipleRelationship)
{
throw new InvalidRelationshipAccessException("SetRelatedObject() was passed a relationship (" +
relationshipName +
") that is of type 'multiple' when it expects a 'single' relationship");
}
((ISingleRelationship)relationship).SetRelatedObject(relatedObject);
}
// ReSharper disable DoNotCallOverridableMethodsInConstructor
private RelationshipDef(string relationshipName, Type relatedObjectClassType, string relatedObjectAssemblyName, string relatedObjectClassName, IRelKeyDef relKeyDef, bool keepReferenceToRelatedObject, DeleteParentAction deleteParentAction, InsertParentAction insertParentAction, RelationshipType relationshipType)
{
ArgumentValidationHelper.CheckArgumentNotNull(relKeyDef, "relKeyDef");
ArgumentValidationHelper.CheckStringArgumentNotEmpty(relationshipName, "relationshipName");
if (relatedObjectClassType != null)
{
MyRelatedObjectClassType = relatedObjectClassType;
}
else
{
_relatedObjectAssemblyName = relatedObjectAssemblyName;
_relatedObjectClassName = relatedObjectClassName;
_relatedObjectClassType = null;
}
RelKeyDef = relKeyDef;
RelationshipName = relationshipName;
KeepReferenceToRelatedObject = keepReferenceToRelatedObject;
this.DeleteParentAction = deleteParentAction;
this.InsertParentAction = insertParentAction;
RelationshipType = relationshipType;
}
/// <summary>
/// Returns true if a property with this name is part of this key
/// </summary>
/// <param name="propName">The property name</param>
/// <returns>Returns true if it is contained</returns>
public bool Contains(string propName)
{
ArgumentValidationHelper.CheckStringArgumentNotEmpty(propName, "propName");
return(_props.ContainsKey(propName));
}
