public T Commit(TT pars = default(TT))
// Pars are the extra parameters send to the save and delete callbacks, in this way we can forward behaviors to the callbacks
{
object obj = _repo.BeginSave(Entity, Original, pars);
T ret;
using (_repo.RepoLock.WriterLock())
{
ShokoContext ctx = _repo.Provider.GetContext();
if (Original == null || !IsUpdate)
{
ret = Entity;
ctx.Add(Entity);
}
else
{
ret = Original;
Entity.DeepCloneTo(Original); //Tried to be 100% atomic and failed miserably, so is 99%.
//If we replace Original with Entity in cache (updating with 'this' as the model to update will not get the changes).
//So this is the best effort
ctx.Attach(Original);
ctx.Update(Original);
}
Release();
if (_repo.IsCached)
{
_repo.Cache.Update(ret);
}
ctx.SaveChanges();
}
_repo.EndSave(ret, obj, pars);
return(ret);
}
public List <T> Commit(TT pars = default(TT))
{
Dictionary <T, object> savedObjects = new Dictionary <T, object>();
foreach (T t in EntityList)
{
savedObjects[t] = _repo.BeginSave(t, References[t], pars);
}
List <T> returns = new List <T>();
var updates = References.Where(a => a.Value != null).ToList();
var creates = References.Where(a => a.Value == null).ToList();
using (_repo.RepoLock.WriterLock())
{
ShokoContext ctx = _repo.Provider.GetContext();
foreach (KeyValuePair <T, T> r in updates)
{
ctx.UpdateChanges(r.Value, r.Key);
/*
* r.Key.DeepCloneTo(r.Value); //Tried to be 100% atomic and failed miserably, so is 99%.
* //If we replace Original with Entity in cache (updating with 'this' as the model to update will not get the changes).
* //So this is the best effort
* ctx.Attach(r.Value);
* ctx.Update(r.Value);*/
returns.Add(r.Value);
}
foreach (KeyValuePair <T, T> r in creates)
{
ctx.Add(r.Key);
returns.Add(r.Key);
}
Release();
if (_repo.IsCached)
{
returns.ForEach(_repo.Cache.Update);
}
ctx.SaveChanges();
ctx.DetachRange(returns);
}
// TODO Needs a better way to index. r.Value and r.Key are not always the same, throwing an error on indexing
// At least the current references will work with this.
foreach (T t in savedObjects.Keys)
{
if (savedObjects.ContainsKey(t))
{
_repo.EndSave(t, savedObjects[t], pars);
}
}
return(EntityList);
}
public List <T> Commit(TT pars = default(TT))
{
Dictionary <T, object> savedObjects = new Dictionary <T, object>();
foreach (T t in EntityList)
{
savedObjects[t] = _repo.BeginSave(t, References[t], pars);
}
List <T> returns = new List <T>();
var updates = References.Where(a => a.Value != null).ToList();
var creates = References.Where(a => a.Value == null).ToList();
using (_repo.RepoLock.WriterLock())
{
ShokoContext ctx = _repo.Provider.GetContext();
foreach (KeyValuePair <T, T> r in updates)
{
r.Key.DeepCloneTo(r.Value); //Tried to be 100% atomic and failed miserably, so is 99%.
//If we replace Original with Entity in cache (updating with 'this' as the model to update will not get the changes).
//So this is the best effort
ctx.Attach(r.Value);
ctx.Update(r.Value);
returns.Add(r.Value);
}
foreach (KeyValuePair <T, T> r in creates)
{
ctx.Add(r.Key);
returns.Add(r.Key);
}
Release();
if (_repo.IsCached)
{
returns.ForEach(_repo.Cache.Update);
}
ctx.SaveChanges();
}
foreach (T t in returns)
{
_repo.EndSave(t, savedObjects[t], pars);
}
return(EntityList);
}
public List <T> Commit(TT pars = default(TT))
{
Dictionary <T, object> savedobjects = new Dictionary <T, object>();
if (_delete_not_updated)
{
foreach (T t in _originalItems.Keys.ToList())
{
if (_references.ContainsKey(t))
{
_originalItems.Remove(t);
}
}
if (_originalItems.Keys.Count > 0)
{
foreach (T e in _originalItems.Values)
{
savedobjects[e] = _repo.BeginDelete(e, pars);
}
ShokoContext ctx = _repo.Provider.GetContext();
ctx.AttachRange(_originalItems.Values);
ctx.RemoveRange(_originalItems.Values);
ctx.SaveChanges();
if (_repo.IsCached)
{
_originalItems.Values.ForEach(_repo.Cache.Remove);
}
foreach (T e in _originalItems.Values)
{
_repo.EndDelete(e, savedobjects[e], pars);
}
}
}
savedobjects.Clear();
List <T> returns = new List <T>();
if (_references.Count > 0)
{
foreach (T t in _references.Keys)
{
savedobjects[t] = _repo.BeginSave(t, _references[t], pars);
}
var updates = _references.Where(a => a.Value != null).ToList();
var creates = _references.Where(a => a.Value == null).ToList();
using (_repo.RepoLock.WriterLock())
{
ShokoContext ctx = _repo.Provider.GetContext();
foreach (KeyValuePair <T, T> r in updates)
{
ctx.UpdateChanges(r.Value, r.Key);
/*
*
* r.Key.DeepCloneTo(r.Value); //Tried to be 100% atomic and failed miserably, so is 99%.
* //If we replace Original with Entity in cache (updating with 'this' as the model to update, will not get the changes).
* //So this is the best effort
* ctx.Attach(r.Value);
* ctx.Update(r.Value);*/
returns.Add(r.Value);
}
foreach (KeyValuePair <T, T> r in creates)
{
ctx.Add(r.Key);
returns.Add(r.Key);
}
if (_repo.IsCached)
{
returns.ForEach(_repo.Cache.Update);
}
ctx.SaveChanges();
ctx.DetachRange(returns);
}
// At least the current references will work with this.
foreach (T t in savedobjects.Keys)
{
if (savedobjects.ContainsKey(t))
{
_repo.EndSave(t, savedobjects[t], pars);
}
}
}
return(returns);
}
public List <T> Commit(TT pars = default(TT))
{
Dictionary <T, object> savedobjects = new Dictionary <T, object>();
if (_originalsKeys.Count > 0)
{
List <T> listed = _repo.GetMany(_originalsKeys);
foreach (T e in listed)
{
savedobjects[e] = _repo.BeginDelete(e, pars);
}
using (_repo.RepoLock.ReaderLock())
{
_repo.Table.RemoveRange(listed);
_repo.Context.SaveChanges();
if (_repo.IsCached)
{
listed.ForEach(_repo.Cache.Remove);
}
}
foreach (T e in listed)
{
_repo.EndDelete(e, savedobjects[e], pars);
}
}
List <T> returns = new List <T>();
if (References.Count > 0)
{
Dictionary <T, object> savedObjects = new Dictionary <T, object>();
foreach (T t in EntityList)
{
savedObjects[t] = _repo.BeginSave(t, References[t], pars);
}
var updates = References.Where(a => a.Value != null).ToList();
var creates = References.Where(a => a.Value == null).ToList();
using (_repo.RepoLock.WriterLock())
{
foreach (KeyValuePair <T, T> r in updates)
{
r.Key.DeepCloneTo(r.Value); //Tried to be 100% atomic and failed miserably, so is 99%.
//If we replace Original with Entity in cache (updating with 'this' as the model to update, will not get the changes).
//So this is the best effort
returns.Add(r.Value);
}
foreach (KeyValuePair <T, T> r in creates)
{
_repo.Table.Add(r.Key);
returns.Add(r.Key);
}
if (_repo.IsCached)
{
returns.ForEach(_repo.Cache.Update);
}
}
_repo.Context.SaveChanges();
foreach (T t in returns)
{
_repo.EndSave(t, savedObjects[t], pars);
}
}
Release();
return(returns);
}
