/// <summary>
/// Removes specified data object.
/// </summary>
/// <param name="context">ObjectContext object</param>
/// <param name="obj">Data object to remove</param>
/// <returns>
/// entity set name
/// </returns>
public static void RemoveObject(ObjectContext context,
DataObject obj)
{
Debug.Assert(context != null);
context.DeleteObject(DataObjectHelper.GetEntityObject(obj));
}
private TDataObj _GetDataObject(EntityObject entity)
{
TDataObj obj = null;
if (_owner.IsStored)
{
// Try to find data object through IWrapDataAccess.
obj = DataObjectHelper.GetDataObject(entity) as TDataObj;
if (obj == null)
{
DataObjectContext ctx = ContextHelper.GetObjectContext(
_entityRef);
obj = DataObjectHelper.GetOrCreateDataObject <TDataObj>(ctx,
entity);
}
}
else
{
obj = DataObjectHelper.GetDataObject(entity) as TDataObj;
if (obj == null)
{
throw new DataException(Properties.Messages.Error_InvalidDataObjectInstance);
}
}
return(obj);
}
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Adds data object to object context.
/// </summary>
/// <param name="dataObject">
/// DataObject object to add.
/// </param>
protected void AddObject(DataObject dataObject)
{
Debug.Assert(dataObject != null);
// add entity object to context
_context.AddObject(_fullEntitySet, DataObjectHelper.GetEntityObject(
dataObject));
}
/// <summary>
/// Retrieves data objects from the specified source.
/// </summary>
/// <typeparam name="T">The type of data objects to be retrieved.</typeparam>
/// <typeparam name="TEntity">The type of source entities.</typeparam>
/// <param name="source">The source of data objects to be retrieved.</param>
/// <returns>A collection of data objects from the specified source.</returns>
private IEnumerable <T> _FindObjects <T, TEntity>(IQueryable <TEntity> source)
where T : DataObject
where TEntity : EntityObject
{
foreach (var entity in source)
{
yield return(DataObjectHelper.GetOrCreateDataObject <T>(_context, entity));
}
}
private bool _CanAddObject(TDataObject dataObject)
{
if (_filter == null)
{
return(true);
}
var entity = (TEntity)DataObjectHelper.GetEntityObject(dataObject);
return(_filter(entity));
}
/// <summary>
/// Removes data object from the collection.
/// </summary>
public virtual bool Remove(T dataObject)
{
if (dataObject == null)
{
throw new ArgumentNullException();
}
_CheckReadOnlyFlag();
return(_entities.Remove(DataObjectHelper.GetEntityObject(
dataObject) as TEntity));
}
/// <summary>
/// Adds data object to the collection.
/// </summary>
public virtual void Add(T dataObject)
{
if (dataObject == null)
{
throw new ArgumentNullException();
}
_CheckReadOnlyFlag();
_entities.Add(DataObjectHelper.GetEntityObject(
dataObject) as TEntity);
}
private void _SetValue(TDataObj dataObject)
{
TEntity entity = null;
if (dataObject != null)
{
entity = DataObjectHelper.GetEntityObject(dataObject) as TEntity;
if (entity == null)
{
throw new DataException(Properties.Messages.Error_InvalidDataObjectInstance);
}
}
_entityRef.Value = entity;
}
/// <summary>
/// Removes data object from object context.
/// </summary>
/// <param name="dataObject">
/// DataObject object to remove.
/// </param>
protected void RemoveObject(DataObject dataObject)
{
Debug.Assert(dataObject != null);
EntityObject entity = DataObjectHelper.GetEntityObject(
dataObject);
// remove data object from cache
// TODO: entity stays in context until SaveChanges is called,
// so alternatively we can sync. cache with context handling
// SavingChanges event.
//_context.Cache.RemoveObject(entity);
// remove entity object from context
_context.DeleteObject(entity);
}
private void _CheckCanSave(ObjectStateEntry entry)
{
Debug.Assert(entry != null);
if (entry.State == EntityState.Added)
{
DataObject obj = DataObjectHelper.GetDataObject(entry.Entity as EntityObject);
if (obj != null)
{
if (!obj.CanSave)
{
this.Detach(entry.Entity);
}
}
}
}
/// <summary>
/// Retrieves data object by specified key name and object id.
/// </summary>
/// <param name="key">
/// EntityKey object that represents entity id.
/// </param>
/// <returns>
/// Generic data object. Null value is returned if the data object
/// cannot be found.
/// </returns>
protected T FindObjectById <T>(EntityKey key)
where T : DataObject
{
Debug.Assert(key != null);
T obj = default(T);
object entity = null;
if (_context.TryGetObjectByKey(key, out entity))
{
obj = DataObjectHelper.GetOrCreateDataObject <T>(_context,
entity as EntityObject);
}
return(obj);
}
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
public void AddObject(T dataObject)
{
EntityObject entity = DataObjectHelper.GetEntityObject(dataObject);
// check if entity already added
// entity could be implicitly added by setting a relation object
if (!_ContainsEntity(entity))
{
base.AddObject(dataObject);
}
else
{
// emulate Add event
_NotifyContextCollectionChanged(CollectionChangeAction.Add,
dataObject);
}
}
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
private void ObjectStateManager_Changed(object sender, CollectionChangeEventArgs e)
{
if (e.Action == CollectionChangeAction.Refresh)
{
_NotifyContextCollectionChanged(e);
}
else
{
if (e.Element != null && e.Element is EntityObject)
{
EntityObject entity = e.Element as EntityObject;
if (entity.EntityState != EntityState.Detached)
{
object obj = DataObjectHelper.GetDataObject(entity);
if (obj != null &&
obj.GetType() == typeof(T)) // NOTE: use exact types comparison, derived types are not accepted
{
_NotifyContextCollectionChanged(e, obj as T);
}
}
}
}
}
private void DataObjectContext_SavingChanges(object sender, EventArgs e)
{
IEnumerable <ObjectStateEntry> entries = this.ObjectStateManager.GetObjectStateEntries(
EntityState.Added |
EntityState.Modified |
EntityState.Deleted);
List <DataObject> addedItems = new List <DataObject>();
List <DataObject> modifiedItems = new List <DataObject>();
List <DataObject> deletedItems = new List <DataObject>();
foreach (ObjectStateEntry entry in entries)
{
if (!entry.IsRelationship &&
entry.EntitySet.ElementType is EntityType)
{
if (entry.State == EntityState.Added ||
entry.State == EntityState.Modified)
{
// apply database constraints
_ApplyConstraints(entry);
// check whether object can be saved
_CheckCanSave(entry);
// fill event collections
if (entry.State != EntityState.Detached)
{
DataObject item = DataObjectHelper.GetDataObject(
entry.Entity as EntityObject);
if (item != null)
{
if (entry.State == EntityState.Added)
{
addedItems.Add(item);
}
else if (entry.State == EntityState.Modified)
{
if (_IsMarkedAsDeleted(item))
{
deletedItems.Add(item);
}
else
{
modifiedItems.Add(item);
}
}
}
}
}
else if (entry.State == EntityState.Deleted)
{
DataObject item = DataObjectHelper.GetDataObject(
entry.Entity as EntityObject);
if (item != null)
{
deletedItems.Add(item);
}
}
}
}
_NotifySavingChanges(addedItems.AsReadOnly(),
modifiedItems.AsReadOnly(),
deletedItems.AsReadOnly());
}
