/// <summary> Sets the related entity property to the entity specified. If the property is a collection, it will add the entity specified to that collection.</summary>
		/// <param name="propertyName">Name of the property.</param>
		/// <param name="entity">Entity to set as an related entity</param>
		/// <remarks>Used by prefetch path logic.</remarks>
		protected override void SetRelatedEntityProperty(string propertyName, IEntityCore entity)
		{
			switch(propertyName)
			{
				case "Address":
					this.Address = (AddressEntity)entity;
					break;
				case "AddressType":
					this.AddressType = (AddressTypeEntity)entity;
					break;
				case "BusinessEntity":
					this.BusinessEntity = (BusinessEntityEntity)entity;
					break;
				default:
					this.OnSetRelatedEntityProperty(propertyName, entity);
					break;
			}
		}

 /// <summary> Sets the internal parameter related to the fieldname passed to the instance relatedEntity. </summary>
 /// <param name="relatedEntity">Instance to set as the related entity of type entityType</param>
 /// <param name="fieldName">Name of field mapped onto the relation which resolves in the instance relatedEntity</param>
 protected override void SetRelatedEntity(IEntityCore relatedEntity, string fieldName)
 {
     switch(fieldName)
     {
         case "Products":
             this.Products.Add((ProductEntity)relatedEntity);
             break;
         default:
             break;
     }
 }

 /// <summary> Unsets the internal parameter related to the fieldname passed to the instance relatedEntity. Reverses the actions taken by SetRelatedEntity() </summary>
 /// <param name="relatedEntity">Instance to unset as the related entity of type entityType</param>
 /// <param name="fieldName">Name of field mapped onto the relation which resolves in the instance relatedEntity</param>
 /// <param name="signalRelatedEntityManyToOne">if set to true it will notify the manytoone side, if applicable.</param>
 protected override void UnsetRelatedEntity(IEntityCore relatedEntity, string fieldName, bool signalRelatedEntityManyToOne)
 {
     switch(fieldName)
     {
         case "Products":
             this.PerformRelatedEntityRemoval(this.Products, relatedEntity, signalRelatedEntityManyToOne);
             break;
         default:
             break;
     }
 }

 /// <summary> Sets the internal parameter related to the fieldname passed to the instance relatedEntity. </summary>
 /// <param name="relatedEntity">Instance to set as the related entity of type entityType</param>
 /// <param name="fieldName">Name of field mapped onto the relation which resolves in the instance relatedEntity</param>
 protected override void SetRelatedEntity(IEntityCore relatedEntity, string fieldName)
 {
     switch(fieldName)
     {
         case "AspnetUser":
             SetupSyncAspnetUser(relatedEntity);
             break;
         default:
             break;
     }
 }

 /// <summary> Unsets the internal parameter related to the fieldname passed to the instance relatedEntity. Reverses the actions taken by SetRelatedEntity() </summary>
 /// <param name="relatedEntity">Instance to unset as the related entity of type entityType</param>
 /// <param name="fieldName">Name of field mapped onto the relation which resolves in the instance relatedEntity</param>
 /// <param name="signalRelatedEntityManyToOne">if set to true it will notify the manytoone side, if applicable.</param>
 protected override void UnsetRelatedEntity(IEntityCore relatedEntity, string fieldName, bool signalRelatedEntityManyToOne)
 {
     switch(fieldName)
     {
         case "AspnetUser":
             DesetupSyncAspnetUser(false, true);
             break;
         default:
             break;
     }
 }

 /// <summary> Sets the internal parameter related to the fieldname passed to the instance relatedEntity. </summary>
 /// <param name="relatedEntity">Instance to set as the related entity of type entityType</param>
 /// <param name="fieldName">Name of field mapped onto the relation which resolves in the instance relatedEntity</param>
 protected override void SetRelatedEntity(IEntityCore relatedEntity, string fieldName)
 {
     switch(fieldName)
     {
         case "AspnetUser":
             SetupSyncAspnetUser(relatedEntity);
             break;
         case "SnFriendListMembers":
             this.SnFriendListMembers.Add((SnFriendListMemberEntity)relatedEntity);
             break;
         default:
             break;
     }
 }

		/// <summary> Sets the internal parameter related to the fieldname passed to the instance relatedEntity. </summary>
		/// <param name="relatedEntity">Instance to set as the related entity of type entityType</param>
		/// <param name="fieldName">Name of field mapped onto the relation which resolves in the instance relatedEntity</param>
		protected override void SetRelatedEntity(IEntityCore relatedEntity, string fieldName)
		{
			switch(fieldName)
			{
				case "Product":
					SetupSyncProduct(relatedEntity);
					break;
				default:
					break;
			}
		}

 /// <summary> Sets the related entity property to the entity specified. If the property is a collection, it will add the entity specified to that collection.</summary>
 /// <param name="propertyName">Name of the property.</param>
 /// <param name="entity">Entity to set as an related entity</param>
 /// <remarks>Used by prefetch path logic.</remarks>
 protected override void SetRelatedEntityProperty(string propertyName, IEntityCore entity)
 {
     switch(propertyName)
     {
         case "Customer":
             this.Customer = (CustomerEntity)entity;
             break;
         case "CustomerDemographic":
             this.CustomerDemographic = (CustomerDemographicEntity)entity;
             break;
         default:
             this.OnSetRelatedEntityProperty(propertyName, entity);
             break;
     }
 }

 /// <summary> Unsets the internal parameter related to the fieldname passed to the instance relatedEntity. Reverses the actions taken by SetRelatedEntity() </summary>
 /// <param name="relatedEntity">Instance to unset as the related entity of type entityType</param>
 /// <param name="fieldName">Name of field mapped onto the relation which resolves in the instance relatedEntity</param>
 /// <param name="signalRelatedEntityManyToOne">if set to true it will notify the manytoone side, if applicable.</param>
 protected override void UnsetRelatedEntity(IEntityCore relatedEntity, string fieldName, bool signalRelatedEntityManyToOne)
 {
     switch(fieldName)
     {
         case "Customer":
             DesetupSyncCustomer(false, true);
             break;
         case "CustomerDemographic":
             DesetupSyncCustomerDemographic(false, true);
             break;
         default:
             break;
     }
 }

		/// <summary> setups the sync logic for member _businessEntity</summary>
		/// <param name="relatedEntity">Instance to set as the related entity of type entityType</param>
		private void SetupSyncBusinessEntity(IEntityCore relatedEntity)
		{
			if(_businessEntity!=relatedEntity)
			{
				DesetupSyncBusinessEntity(true, true);
				_businessEntity = (BusinessEntityEntity)relatedEntity;
				this.PerformSetupSyncRelatedEntity( _businessEntity, new PropertyChangedEventHandler( OnBusinessEntityPropertyChanged ), "BusinessEntity", AdventureWorks.Dal.Adapter.v41.RelationClasses.StaticBusinessEntityAddressRelations.BusinessEntityEntityUsingBusinessEntityIdStatic, true, new string[] {  } );
			}
		}

 /// <summary> Sets the internal parameter related to the fieldname passed to the instance relatedEntity. </summary>
 /// <param name="relatedEntity">Instance to set as the related entity of type entityType</param>
 /// <param name="fieldName">Name of field mapped onto the relation which resolves in the instance relatedEntity</param>
 protected override void SetRelatedEntity(IEntityCore relatedEntity, string fieldName)
 {
     switch(fieldName)
     {
         case "Customer":
             SetupSyncCustomer(relatedEntity);
             break;
         case "CustomerDemographic":
             SetupSyncCustomerDemographic(relatedEntity);
             break;
         default:
             break;
     }
 }

		/// <summary> setups the sync logic for member _addressType</summary>
		/// <param name="relatedEntity">Instance to set as the related entity of type entityType</param>
		private void SetupSyncAddressType(IEntityCore relatedEntity)
		{
			if(_addressType!=relatedEntity)
			{
				DesetupSyncAddressType(true, true);
				_addressType = (AddressTypeEntity)relatedEntity;
				this.PerformSetupSyncRelatedEntity( _addressType, new PropertyChangedEventHandler( OnAddressTypePropertyChanged ), "AddressType", AdventureWorks.Dal.Adapter.v41.RelationClasses.StaticBusinessEntityAddressRelations.AddressTypeEntityUsingAddressTypeIdStatic, true, new string[] {  } );
			}
		}

		/// <summary> Unsets the internal parameter related to the fieldname passed to the instance relatedEntity. Reverses the actions taken by SetRelatedEntity() </summary>
		/// <param name="relatedEntity">Instance to unset as the related entity of type entityType</param>
		/// <param name="fieldName">Name of field mapped onto the relation which resolves in the instance relatedEntity</param>
		/// <param name="signalRelatedEntityManyToOne">if set to true it will notify the manytoone side, if applicable.</param>
		protected override void UnsetRelatedEntity(IEntityCore relatedEntity, string fieldName, bool signalRelatedEntityManyToOne)
		{
			switch(fieldName)
			{
				case "Address":
					DesetupSyncAddress(false, true);
					break;
				case "AddressType":
					DesetupSyncAddressType(false, true);
					break;
				case "BusinessEntity":
					DesetupSyncBusinessEntity(false, true);
					break;
				default:
					break;
			}
		}

		/// <summary> Sets the internal parameter related to the fieldname passed to the instance relatedEntity. </summary>
		/// <param name="relatedEntity">Instance to set as the related entity of type entityType</param>
		/// <param name="fieldName">Name of field mapped onto the relation which resolves in the instance relatedEntity</param>
		protected override void SetRelatedEntity(IEntityCore relatedEntity, string fieldName)
		{
			switch(fieldName)
			{
				case "Address":
					SetupSyncAddress(relatedEntity);
					break;
				case "AddressType":
					SetupSyncAddressType(relatedEntity);
					break;
				case "BusinessEntity":
					SetupSyncBusinessEntity(relatedEntity);
					break;
				default:
					break;
			}
		}

 /// <summary> setups the sync logic for member _artwork</summary>
 /// <param name="relatedEntity">Instance to set as the related entity of type entityType</param>
 private void SetupSyncArtwork(IEntityCore relatedEntity)
 {
     if(_artwork!=relatedEntity)
     {
         DesetupSyncArtwork(true, true);
         _artwork = (ArtworkEntity)relatedEntity;
         this.PerformSetupSyncRelatedEntity( _artwork, new PropertyChangedEventHandler( OnArtworkPropertyChanged ), "Artwork", TVJunkie.DatabaseAccessLayer.RelationClasses.StaticArtworkToRoleRelations.ArtworkEntityUsingArtworkIdStatic, true, new string[] {  } );
     }
 }

 /// <summary> setups the sync logic for member _customerDemographic</summary>
 /// <param name="relatedEntity">Instance to set as the related entity of type entityType</param>
 private void SetupSyncCustomerDemographic(IEntityCore relatedEntity)
 {
     if(_customerDemographic!=relatedEntity)
     {
         DesetupSyncCustomerDemographic(true, true);
         _customerDemographic = (CustomerDemographicEntity)relatedEntity;
         this.PerformSetupSyncRelatedEntity( _customerDemographic, new PropertyChangedEventHandler( OnCustomerDemographicPropertyChanged ), "CustomerDemographic", Northwind.Data.RelationClasses.StaticCustomerCustomerDemoRelations.CustomerDemographicEntityUsingCustomerTypeIdStatic, true, new string[] {  } );
     }
 }

 /// <summary> setups the sync logic for member _role</summary>
 /// <param name="relatedEntity">Instance to set as the related entity of type entityType</param>
 private void SetupSyncRole(IEntityCore relatedEntity)
 {
     if(_role!=relatedEntity)
     {
         DesetupSyncRole(true, true);
         _role = (RoleEntity)relatedEntity;
         this.PerformSetupSyncRelatedEntity( _role, new PropertyChangedEventHandler( OnRolePropertyChanged ), "Role", TVJunkie.DatabaseAccessLayer.RelationClasses.StaticArtworkToRoleRelations.RoleEntityUsingRoleIdStatic, true, new string[] {  } );
     }
 }

		/// <summary> Sets the related entity property to the entity specified. If the property is a collection, it will add the entity specified to that collection.</summary>
		/// <param name="propertyName">Name of the property.</param>
		/// <param name="entity">Entity to set as an related entity</param>
		/// <remarks>Used by prefetch path logic.</remarks>
		protected override void SetRelatedEntityProperty(string propertyName, IEntityCore entity)
		{
			switch(propertyName)
			{
				case "SalesPerson":
					this.SalesPerson = (SalesPersonEntity)entity;
					break;
				default:
					this.OnSetRelatedEntityProperty(propertyName, entity);
					break;
			}
		}

 /// <summary> Unsets the internal parameter related to the fieldname passed to the instance relatedEntity. Reverses the actions taken by SetRelatedEntity() </summary>
 /// <param name="relatedEntity">Instance to unset as the related entity of type entityType</param>
 /// <param name="fieldName">Name of field mapped onto the relation which resolves in the instance relatedEntity</param>
 /// <param name="signalRelatedEntityManyToOne">if set to true it will notify the manytoone side, if applicable.</param>
 protected override void UnsetRelatedEntity(IEntityCore relatedEntity, string fieldName, bool signalRelatedEntityManyToOne)
 {
     switch(fieldName)
     {
         case "AspnetUser":
             DesetupSyncAspnetUser(false, true);
             break;
         case "SnFriendListMembers":
             this.PerformRelatedEntityRemoval(this.SnFriendListMembers, relatedEntity, signalRelatedEntityManyToOne);
             break;
         default:
             break;
     }
 }

		/// <summary> Sets the internal parameter related to the fieldname passed to the instance relatedEntity. </summary>
		/// <param name="relatedEntity">Instance to set as the related entity of type entityType</param>
		/// <param name="fieldName">Name of field mapped onto the relation which resolves in the instance relatedEntity</param>
		protected override void SetRelatedEntity(IEntityCore relatedEntity, string fieldName)
		{
			switch(fieldName)
			{
				case "SalesPerson":
					SetupSyncSalesPerson(relatedEntity);
					break;
				default:
					break;
			}
		}