Exemplo n.º 1
0
                public void Update(DataBaseWorker dbWorker, IDataBaseProvider databaseProvider)
                {
                    Init(false);

                    List <IFillAbleObject> dropCommitEntries = new List <IFillAbleObject>(_items.Count);
                    List <IFillAbleObject> deattach          = new List <IFillAbleObject>(_items.Count);

                    try
                    {
                        dbWorker.SaveObjects(_items.Union(_deletedItems).Cast <IFillAbleObject>(),
                                             x =>
                        {
                            switch (x.State)
                            {
                            case State.Created:
                                return(databaseProvider.GetInsertCommandBuilder());

                            case State.Changed:
                                return(databaseProvider.GetUpdateCommandBuilder());

                            case State.Deleted:
                                x.DeleteChildObjects();
                                x.SaveChildObjects();
                                return(databaseProvider.GetDeleteCommandBuilder());

                            case State.Original:
                                x.SaveChildObjects();
                                return(null);

                            default:
                                return(null);
                            }
                        },
                                             (x, reader) =>
                        {
                            switch (x.State)
                            {
                            case State.Changed:
                            case State.Created:
                                if (reader == null)
                                {
                                    x.Deattach();
                                }
                                else
                                {
                                    x.Fill(reader);
                                }
                                break;

                            default:
                                break;
                            }
                        },
                                             x =>
                        {
                            switch (x.State)
                            {
                            case State.Changed:
                            case State.Created:
                                dropCommitEntries.Add(x);
                                x.SaveChildObjects();
                                break;

                            case State.Deleted:
                                x.Deattach();
                                break;

                            default:
                                x.SaveChildObjects();
                                break;
                            }
                        });
                        if (System.Transactions.Transaction.Current == null)
                        {
                            foreach (IFillAbleObject obj in dropCommitEntries)
                            {
                                obj.Commit(true);
                            }
                        }
                        else
                        {
#if !NETCOREAPP1_0
                            string transactionLocalIdentifier = System.Transactions.Transaction.Current.TransactionInformation.LocalIdentifier;
                            if (_objectsToCommit.ContainsKey(transactionLocalIdentifier))
                            {
                                _objectsToCommit[transactionLocalIdentifier] = _objectsToCommit[transactionLocalIdentifier].Union(dropCommitEntries);
                            }
                            else
                            {
                                _objectsToCommit.Add(transactionLocalIdentifier, dropCommitEntries);
                                System.Transactions.Transaction.Current.TransactionCompleted +=
                                    (s, e) =>
                                {
                                    switch (e.Transaction.TransactionInformation.Status)
                                    {
                                    case System.Transactions.TransactionStatus.Aborted:
                                        foreach (IFillAbleObject obj in _objectsToCommit[e.Transaction.TransactionInformation.LocalIdentifier])
                                        {
                                            obj.Rollback();
                                        }
                                        break;

                                    case System.Transactions.TransactionStatus.Committed:
                                        foreach (IFillAbleObject obj in _objectsToCommit[e.Transaction.TransactionInformation.LocalIdentifier])
                                        {
                                            obj.Commit(true);
                                        }
                                        break;

                                    default:
                                        break;
                                    }
                                    _objectsToCommit.Remove(e.Transaction.TransactionInformation.LocalIdentifier);
                                };
                            }
#endif
                        }
                    }
                    catch (EntitySaveException)
                    {
                        foreach (IFillAbleObject obj in dropCommitEntries)
                        {
                            obj.Rollback();
                        }

                        throw;
                    }
                }