public TruncateState(SyncContainer owner) : base(owner) { foreach (SyncContainer sc in StateOwner.Children) { sc.Truncate(); } }
protected override void SynchronizeImpl() { ISerializableObject source = StateOwner.SourceObject; ISerializableObject sink = StateOwner.SinkSerializer.CreateISerializableObject(StateOwner.SynchronizedType); CopyUtils.PlainCopy(StateOwner.SinkSerializer, KeyCarrier, sink, new FieldLock(source.GetType()), true); CopyUtils.PlainCopy(StateOwner.SinkSerializer, source, sink, new FieldLock(source.GetType()), false); StateOwner.SinkSerializer.Connector.InsertPlain(sink); StateOwner.SinkObject = sink; SyncItem si1 = StateOwner.SyncSerializer.CreateISerializableObject <SyncItem>(); SyncItem si2 = StateOwner.SyncSerializer.CreateISerializableObject <SyncItem>(); si1.SyncGuid = AttributeWorker.RowGuid(source); si2.SyncGuid = AttributeWorker.RowGuid(sink); si1.ClassID = source.GetType().Name; si2.ClassID = source.GetType().Name; si1.Hashcode = SyncContainer.ComputeHashCode(StateOwner.SourceSerializer.Target, source); si2.Hashcode = SyncContainer.ComputeHashCode(StateOwner.SinkSerializer.Target, sink); si1.CounterPart = si2; StateOwner.SyncSerializer.Connector.Save(si1); StateOwner.SyncSerializer.ConnectOneToOne(si1, si2); StateOwner.SyncSerializer.Connector.Save(si2); StateOwner.SyncSerializer.ConnectOneToOne(si2, si1); StateOwner.SyncSerializer.Connector.Save(si1); StateOwner.UpdateFieldStates(StateOwner.SourceSerializer.Target, si1, source);//Deaktiviert StateOwner.UpdateFieldStates(StateOwner.SinkSerializer.Target, si2, sink); }
protected override void SynchronizeImpl() { ISerializableObject source = StateOwner.SourceObject; ISerializableObject sink = StateOwner.SinkObject; CopyUtils.ForeignKeyCopy(StateOwner.SinkSerializer, KeyCarrier, sink, base._fieldLock); //Kopiere die angepassten Daten... CopyUtils.PlainCopy(StateOwner.SinkSerializer, _resolved, sink, base._fieldLock, false); CopyUtils.PlainCopy(StateOwner.SourceSerializer, _resolved, source, base._fieldLock, false); StateOwner.SinkSerializer.Connector.UpdatePlain(sink); StateOwner.SourceSerializer.Connector.UpdatePlain(source); _sourceSyncItem.Hashcode = SyncContainer.ComputeHashCode(StateOwner.SourceSerializer.Target, source); StateOwner.SyncSerializer.Connector.Save(_sourceSyncItem); SyncItem tmp = _sourceSyncItem.CounterPart; tmp.Hashcode = SyncContainer.ComputeHashCode(StateOwner.SinkSerializer.Target, sink); StateOwner.SyncSerializer.Connector.Save(tmp); StateOwner.UpdateFieldStates(StateOwner.SourceSerializer.Target, _sourceSyncItem, source); StateOwner.UpdateFieldStates(StateOwner.SinkSerializer.Target, tmp, sink); }
internal TruncateState(SyncContainer owner, SyncState previous) : base(owner, previous) { foreach (SyncContainer sc in StateOwner.Children) { sc.Truncate(); } }
internal void AddISerializableObject(ISerializableObject iso) { if (!_pooledObjects.ContainsKey(AttributeWorker.RowGuid(iso))) { SyncContainer container = new SyncContainer(iso, _syncSerializer, _serializer); _pooledObjects[AttributeWorker.RowGuid(iso)] = container; } }
protected override void SynchronizeImpl() { ISerializableObject source = StateOwner.SourceObject; ISerializableObject sink = StateOwner.SinkObject; CopyUtils.PlainCopy(StateOwner.SinkSerializer, KeyCarrier, sink, _fieldLock, true); CopyUtils.PlainCopy(StateOwner.SinkSerializer, source, sink, _fieldLock, false); StateOwner.SinkSerializer.Connector.UpdatePlain(sink); _sourceSyncItem.Hashcode = SyncContainer.ComputeHashCode(StateOwner.SourceSerializer.Target, source); StateOwner.SyncSerializer.Connector.Save(_sourceSyncItem); SyncItem sinkSyncItem = _sourceSyncItem.CounterPart; sinkSyncItem.Hashcode = SyncContainer.ComputeHashCode(StateOwner.SinkSerializer.Target, sink); StateOwner.SyncSerializer.Connector.Save(sinkSyncItem); StateOwner.UpdateFieldStates(StateOwner.SourceSerializer.Target, _sourceSyncItem, source); StateOwner.UpdateFieldStates(StateOwner.SinkSerializer.Target, sinkSyncItem, sink); }
internal void StartSynchronizing(SyncTool syncPeer) { if (!_initialized) { throw new SyncException("Syncpool is not initialized!"); } if (!CheckSyncContext(syncPeer)) { throw new SyncException("SyncPool is not compatible with SyncPeer!"); } if (!CheckTarget(syncPeer)) { throw new SyncException("Synchronising form source to source is not valid!"); } _syncSerializer.Connector.BeginTransaction(); syncPeer.Serializer.Connector.BeginTransaction(); SyncContainer lastContainer = null; try { foreach (SyncContainer c in _pooledObjects.Values) { lastContainer = c; c.Synchronize(); } _syncSerializer.Connector.Commit(); syncPeer.Serializer.Connector.Commit(); } catch (Exception ex) { ResetSynchronizedState(); if (!OnSynchronizeEvent(new SynchronizeEventArgs())) { throw new Exception("Synchronizing failed at: " + lastContainer, ex); } } }
public void HandleOneToMany(ISerializableObject handledItem, OneToManyAttribute attr, FieldInfo field) { IEnumerable set = (IEnumerable)field.GetValue(handledItem); foreach (ISerializableObject iso in set) { try { SyncContainer s = _pooledObjects[AttributeWorker.RowGuid(iso)]; if (!_owner._children.Contains(s)) { _owner._children.Add(s); } if (!s._parents.Contains(_owner)) { s._parents.Add(_owner); } } catch (KeyNotFoundException) { } } }
public void HandleManyToOne(ISerializableObject handledItem, ManyToOneAttribute attr, FieldInfo field) { ISerializableObject iso = (ISerializableObject)field.GetValue(handledItem); if (iso != null) { try { SyncContainer s = _pooledObjects[AttributeWorker.RowGuid(iso)]; if (!_owner._parents.Contains(s)) { _owner._parents.Add(s); } if (!s._children.Contains(_owner)) { s._children.Add(_owner); } } catch (KeyNotFoundException) { } } }
public DependencyRelationHandler(SyncContainer owner, IDictionary <Guid, SyncContainer> pooledObjects) { _pooledObjects = pooledObjects; _owner = owner; }
public PrematureState(SyncContainer owner) : base(owner) { }
internal SynchronizedState(SyncContainer owner, SyncState previous) : base(owner, previous) { }
public DeletedState(SyncContainer owner, SyncItem sourceSyncItem) : base(owner, sourceSyncItem) { }
public ConflictState(SyncContainer owner, SyncItem sourceSyncItem) : base(owner) { _sourceSyncItem = sourceSyncItem; }
internal WritingStates(SyncContainer owner, SyncState previous) : base(owner, previous) { _doSynchronizing = true; }
public ConflictResolvedState(SyncContainer owner, ISerializableObject resolved, SyncItem sourceSyncItem) : base(owner, sourceSyncItem) { _resolved = resolved; }
internal IgnoreState(SyncContainer owner, SyncState previous) : base(owner, previous) { }
internal UpdateState(SyncContainer owner, SyncItem sourceSyncItem, SyncState previous) : base(owner, previous) { _sourceSyncItem = sourceSyncItem; _fieldLock = new FieldLock(_sourceSyncItem.GetType()); }
public UpdateState(SyncContainer owner, SyncItem sourceSyncItem) : base(owner) { _sourceSyncItem = sourceSyncItem; _fieldLock = new FieldLock(_sourceSyncItem.GetType()); }
internal SyncState(SyncContainer owner, SyncState previousState) { _StateOwner = owner; _PreviousState = previousState; }
public InsertState(SyncContainer owner) : base(owner) { }
internal ConflictResolvedState(SyncContainer owner, ISerializableObject resolved, SyncItem sourceSyncItem, SyncState previous) : base(owner, sourceSyncItem, previous) { _resolved = resolved; }
public SyncState(SyncContainer owner) { _StateOwner = owner; _PreviousState = null; }
public IgnoreState(SyncContainer owner) : base(owner) { }
public WritingStates(SyncContainer owner) : base(owner) { _doSynchronizing = true; }