/// <summary>
/// Saves the object to the database.
/// </summary>
/// <remarks>
/// <para>
/// Calling this method starts the save operation, causing the object
/// to be inserted, updated or deleted within the database based on the
/// object's current state.
/// </para><para>
/// If <see cref="Core.BusinessBase.IsDeleted" /> is <see langword="true"/>
/// the object will be deleted. Otherwise, if <see cref="Core.BusinessBase.IsNew" />
/// is <see langword="true"/> the object will be inserted.
/// Otherwise the object's data will be updated in the database.
/// </para><para>
/// All this is contingent on <see cref="Core.BusinessBase.IsDirty" />. If
/// this value is <see langword="false"/>, no data operation occurs.
/// It is also contingent on <see cref="Core.BusinessBase.IsValid" />.
/// If this value is <see langword="false"/> an
/// exception will be thrown to indicate that the UI attempted to save an
/// invalid object.
/// </para><para>
/// It is important to note that this method returns a new version of the
/// business object that contains any data updated during the save operation.
/// You MUST update all object references to use this new version of the
/// business object in order to have access to the correct object data.
/// </para><para>
/// You can override this method to add your own custom behaviors to the save
/// operation. For instance, you may add some security checks to make sure
/// the user can save the object. If all security checks pass, you would then
/// invoke the base Save method via <c>base.Save()</c>.
/// </para>
/// </remarks>
/// <returns>A new object containing the saved values.</returns>
public virtual T Save()
{
T result;
if (this.IsChild)
{
throw new NotSupportedException(Resources.NoSaveChildException);
}
if (EditLevel > 0)
{
throw new Validation.ValidationException(Resources.NoSaveEditingException);
}
if (!IsValid)
{
throw new Validation.ValidationException(Resources.NoSaveInvalidException);
}
if (IsDirty)
{
result = (T)DataPortal.Update(this);
}
else
{
result = (T)this;
}
OnSaved(result);
return(result);
}
/// <summary>
/// Saves the object to the database.
/// </summary>
/// <param name="forceUpdate">
/// If true, triggers overriding IsNew and IsDirty.
/// If false then it is the same as calling Save().
/// </param>
/// <param name="userState">User state data.</param>
/// <param name="isSync">True if the save operation should be synchronous.</param>
protected async virtual Task <T> SaveAsync(bool forceUpdate, object userState, bool isSync)
{
if (forceUpdate && IsNew)
{
// mark the object as old - which makes it
// not dirty
MarkOld();
// now mark the object as dirty so it can save
MarkDirty(true);
}
T result;
if (this.IsChild)
{
throw new InvalidOperationException(Resources.NoSaveChildException);
}
if (EditLevel > 0)
{
throw new InvalidOperationException(Resources.NoSaveEditingException);
}
if (!IsValid && !IsDeleted)
{
throw new Rules.ValidationException(Resources.NoSaveInvalidException);
}
if (IsBusy)
{
throw new InvalidOperationException(Resources.BusyObjectsMayNotBeSaved);
}
if (IsDirty)
{
if (isSync)
{
result = DataPortal.Update <T>((T)this);
}
else
{
if (ApplicationContext.AutoCloneOnUpdate)
{
MarkBusy();
}
try
{
result = await DataPortal.UpdateAsync <T>((T)this);
}
finally
{
if (ApplicationContext.AutoCloneOnUpdate)
{
MarkIdle();
}
}
}
}
else
{
result = (T)this;
}
OnSaved(result, null, userState);
return(result);
}
/// <summary>
/// Saves the object to the database.
/// </summary>
/// <remarks>
/// <para>
/// Calling this method starts the save operation, causing the object
/// to be inserted, updated or deleted within the database based on the
/// object's current state.
/// </para><para>
/// If <see cref="Core.BusinessBase.IsDeleted" /> is <see langword="true"/>
/// the object will be deleted. Otherwise, if <see cref="Core.BusinessBase.IsNew" />
/// is <see langword="true"/> the object will be inserted.
/// Otherwise the object's data will be updated in the database.
/// </para><para>
/// All this is contingent on <see cref="Core.BusinessBase.IsDirty" />. If
/// this value is <see langword="false"/>, no data operation occurs.
/// It is also contingent on <see cref="Core.BusinessBase.IsValid" />.
/// If this value is <see langword="false"/> an
/// exception will be thrown to indicate that the UI attempted to save an
/// invalid object.
/// </para><para>
/// It is important to note that this method returns a new version of the
/// business object that contains any data updated during the save operation.
/// You MUST update all object references to use this new version of the
/// business object in order to have access to the correct object data.
/// </para><para>
/// You can override this method to add your own custom behaviors to the save
/// operation. For instance, you may add some security checks to make sure
/// the user can save the object. If all security checks pass, you would then
/// invoke the base Save method via <c>base.Save()</c>.
/// </para>
/// </remarks>
/// <returns>A new object containing the saved values.</returns>
public virtual T Save()
{
T result;
if (this.IsChild)
{
throw new InvalidOperationException(Resources.NoSaveChildException);
}
if (EditLevel > 0)
{
throw new InvalidOperationException(Resources.NoSaveEditingException);
}
if (!IsValid && !IsDeleted)
{
throw new Rules.ValidationException(Resources.NoSaveInvalidException);
}
if (IsBusy)
{
throw new InvalidOperationException(Resources.BusyObjectsMayNotBeSaved);
}
if (IsDirty)
{
result = (T)DataPortal.Update(this);
}
else
{
result = (T)this;
}
OnSaved(result, null, null);
return(result);
}
/// <summary>
/// Saves the object to the database.
/// </summary>
/// <param name="userState">User state data.</param>
/// <param name="isSync">True if the save operation should be synchronous.</param>
protected virtual async Task <T> SaveAsync(object userState, bool isSync)
{
T result;
if (this.IsChild)
{
throw new InvalidOperationException(Resources.NoSaveChildException);
}
if (_editLevel > 0)
{
throw new InvalidOperationException(Resources.NoSaveEditingException);
}
if (!IsValid)
{
throw new Rules.ValidationException(Resources.NoSaveInvalidException);
}
if (IsBusy)
{
throw new InvalidOperationException(Resources.BusyObjectsMayNotBeSaved);
}
if (IsDirty)
{
if (isSync)
{
result = DataPortal.Update <T>((T)this);
}
else
{
result = await DataPortal.UpdateAsync <T>((T)this);
}
}
else
{
result = (T)this;
}
OnSaved(result, null, userState);
return(result);
}
/// <summary>
/// Called by the business object's Save() method to
/// insert, update or delete an object in the database.
/// </summary>
/// <remarks>
/// Note that this method returns a reference to the updated business object.
/// If the server-side DataPortal is running remotely, this will be a new and
/// different object from the original, and all object references MUST be updated
/// to use this new object.
/// </remarks>
/// <typeparam name="T">Specific type of the business object.</typeparam>
/// <param name="obj">A reference to the business object to be updated.</param>
/// <returns>A reference to the updated business object.</returns>
public static T Update <T>(T obj)
{
var dp = new DataPortal <T>();
return(dp.Update(obj));
}
