/// <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()); }