internal void Delete(ISerializableObject iso, ISerializerTransaction transaction) { if (!IsManaged(iso)) { return; } AttributeWorker w = AttributeWorker.GetInstance(Target); ResolverData <ISerializableObject> data = new ResolverData <ISerializableObject>(); data.FieldsToResolve = AttributeWorker.RetrieveAllFields(iso.GetType()); data.HandledItem = iso; DeleteHandler h = new DeleteHandler(this); RelationResolver <ISerializableObject> res = new RelationResolver <ISerializableObject>(); res.Handler = h; h.MODE = DeleteHandler.DOWNMODE; res.StartRelationResolving(data); _objectPool.DeleteObject(iso, _connection, transaction); h.MODE = DeleteHandler.UPMODE; res.StartRelationResolving(data); }
public CsvPKey(Type type, String csvKey, String target) { _csvKey = csvKey; _type = type; IDictionary <String, FieldInfo> ids = AttributeWorker.GetInstance(target).GetPrimaryKeyFields(type); String[] split = Split(_csvKey, ";", "/;"); foreach (String s in split) { String[] tmp = Split(s, "=", "/="); FieldInfo f = ids[tmp[0]]; tmp[1] = tmp[1].Replace("/;", ";"); tmp[1] = tmp[1].Replace("/=", "="); tmp[1] = tmp[1].Replace("//", "/"); Object val; if (f.FieldType.IsGenericType && f.FieldType.GetGenericTypeDefinition() == typeof(Nullable <>)) { Type t = Nullable.GetUnderlyingType(f.FieldType); val = Convert.ChangeType(tmp[1], t, null); } else { val = Convert.ChangeType(tmp[1], f.FieldType, null); } _fields.Add(f); _values.Add(val); } }
internal bool Exists(String column, Object value, String table, ISerializerTransaction transaction) { AttributeWorker w = AttributeWorker.GetInstance(Target); StringBuilder b = new StringBuilder(); b.Append("SELECT ").Append(column).Append(" FROM ").Append(table).Append(" WHERE ").Append(column).Append("="); b.Append(SqlUtil.SqlConvert(value)); DbCommand com = _connection.CreateCommand(); transaction.Guard(com); com.CommandText = b.ToString(); //Console.WriteLine(com.CommandText); DbDataReader r = com.ExecuteReader(); if (r.Read()) { r.Close(); return(true); } r.Close(); return(false); }
internal void copyToSinkObject(ISerializableObject from, ISerializableObject to) { AttributeWorker w = AttributeWorker.GetInstance(sinkSerializer.Target);//Am besten durch Kopiervorgang ersetzen, der ohne Attributeworker auskommt. FieldInfo[] fis = AttributeWorker.RetrieveAllFields(from.GetType()); foreach (FieldInfo fi in fis) { if (w.IsAutoincID(fi)) { continue; //Kann man aus Lookup-Tabelle holen } if (!w.IsPersistentField(fi)) { continue; //wirklich nötig? } //DirectSync wird im Moment nicht unterstützt if (AttributeWorker.IsRowGuid(fi)) { continue; //Kann man als Lookup-Tabelle definieren } Object val = fi.GetValue(from); fi.SetValue(to, val); } }
public ISerializableObject CreateISerializableObject(Type type) { AttributeWorker w = AttributeWorker.GetInstance(Target); ISerializableObject iso = null; try { iso = (ISerializableObject)Activator.CreateInstance(type); } catch (InvalidCastException) { throw new SerializerException(); } _objectPool.Register(iso); ResolverData <ISerializableObject> data = new ResolverData <ISerializableObject>(); data.FieldsToResolve = AttributeWorker.RetrieveAllFields(iso.GetType()); data.HandledItem = iso; CreateHandler handler = new CreateHandler(this); RelationResolver <ISerializableObject> resolver = new RelationResolver <ISerializableObject>(); resolver.Handler = handler; resolver.StartRelationResolving(data); return(iso); }
public UpdateStates UpdateObject(ISerializableObject iso, DbConnection connection, ISerializerTransaction transaction) { UpdateStates state = UpdateStates.UPDATED; AttributeWorker w = AttributeWorker.GetInstance(Target); DbCommand com = connection.CreateCommand(); Guid g = AttributeWorker.RowGuid(iso); GenericWeakReference <ISerializableObject> tmp; try { tmp = _persistentObjects[g]; } catch (KeyNotFoundException ex) { throw new UpdateException("update failed. object is not known by the system and must be loaded first", ex); } com.CommandText = _owner.SerializeUpdate(iso, ref state, tmp); transaction.Guard(com); //Console.WriteLine(com.CommandText); try { if (com.ExecuteNonQuery() < 1) { state = UpdateStates.NO_ROWS_AFFECTED; return(state); } return(state); } catch (Exception ex) { throw new SerializerException("update failed", ex); } }
public void Activate(string target) { _target = target; _connection = (DbConnection)CreateConnection(); if (_connection.State == ConnectionState.Closed || _connection.State == ConnectionState.Broken) { try { _connection.Close(); } catch (Exception ex) { } } _connection.Open(); //Initialisierung des AttributeWorkers ... AttributeWorker.GetInstance(Target); VirtualKeyFactory vkf = new VirtualKeyFactory(AttributeWorker.GetInstance(target)); foreach (Type t in RegisteredTypes) { vkf.RegisterType(t); } AttributeWorker.GetInstance(Target).AddVirtualKeyFactory(this, vkf); _objectPool = new SortedSerializableObjectPool(this, _registeredTypes); ((SortedSerializableObjectPool)_objectPool).Cleaner = new DefaultCleaner(); }
internal virtual String Delete(ISerializableObject iso) { AttributeWorker w = AttributeWorker.GetInstance(Target); StringBuilder sql = new StringBuilder(); sql.Append("DELETE FROM ").Append(w.GetTableMapping(iso.GetType(), _praefix)); sql.Append(" WHERE "); FieldInfo[] fis = AttributeWorker.RetrieveAllFields(iso.GetType()); bool start = true; foreach (FieldInfo fi in fis) { if (w.IsID(fi)) { String col = w.GetColumnMapping(fi); Object val = fi.GetValue(iso); if (val == null) { throw new SerializerException("Not deletable ..."); } if (!start) { sql.Append(" AND "); } start = false; sql.Append(col).Append("=").Append(SqlUtil.SqlConvert(val)); } } return(sql.ToString()); }
public CsvPimaryKey(ISerializableObject iso, String target) { _type = iso.GetType(); IDictionary <String, FieldInfo> ids = AttributeWorker.GetInstance(target).GetPrimaryKeyFields(iso.GetType()); List <String> tmpList = new List <String>(ids.Count); StringBuilder csvKey = new StringBuilder(); String tmp; foreach (String id in ids.Keys) { StringBuilder tmpBuilder = new StringBuilder(); _fields.Add(ids[id]); _values.Add(ids[id].GetValue(iso)); try { //if (ids[id].GetValue(iso) is DateTime) //{ // DateTime dt = (DateTime)ids[id].GetValue(iso); // tmp = SqlUtil.SqlConvert(dt); //} //else // tmp = ids[id].GetValue(iso).ToString(); tmp = SqlUtil.SqlConvert(ids[id].GetValue(iso)).ToString(); } catch (NullReferenceException ex) { throw new KeyNotFoundException("", ex); } //Maskierung der Kommata tmp = tmp.Replace("/", "//"); tmp = tmp.Replace(";", "/;"); tmp = tmp.Replace("=", "/="); tmpBuilder.Append(id).Append("="); tmpBuilder.Append(tmp); tmpList.Add(tmpBuilder.ToString()); } tmpList.Sort(); bool initial = true; foreach (String s in tmpList) { if (!initial) { csvKey.Append(";"); } initial = false; csvKey.Append(s); } _csvKey = csvKey.ToString(); }
public override void UpdateOneToMany(Object iterator, ISerializableObject owner, Type storedType, Serializer serializer) { IVirtualKey vKey = AttributeWorker.GetInstance(serializer.Target).CreateVirtualKey(serializer, owner.GetType(), storedType); vKey.InitVirtualKeyBySource(owner); ((IDirectAccessIteratorConfiguration)iterator).Restriction = Restrictions.RestrictionFactory.SqlRestriction(storedType, vKey.ToSqlStringForward(serializer.Target)); }
public override String ToSqlString(Serializer.Serializer serializer, Type type, String target) { AttributeWorker w = AttributeWorker.GetInstance(target); IList <Type> path = w.ComputeVirtualKeyPath(serializer, _type, type); //ComputePath(type, _type, target); return(ComputeSqlJoin(serializer, path, _sqlString, target).ToString()); }
internal void AdjustKeyDownward(ISerializableObject iso) { AttributeWorker w = AttributeWorker.GetInstance(_sinkSerializer.Target); IVirtualKey vKey = w.CreateVirtualKey(_sinkSerializer, _synchronizedType, iso.GetType()); vKey.InitVirtualKeyBySource(FetchObject(_sinkSerializer, _sinkGuid)); vKey.ApplyVirtualKeyToTarget(iso); }
internal virtual String SerializeInsert(ISerializableObject iso, string table) { AttributeWorker w = AttributeWorker.GetInstance(Target); StringBuilder sql = new StringBuilder(); StringBuilder values = new StringBuilder(); sql.Append("INSERT INTO ").Append(table); sql.Append(" ("); FieldInfo[] fis = AttributeWorker.RetrieveAllFields(iso.GetType()); bool start = true; foreach (FieldInfo fi in fis) { if (w.IsAutoincID(fi)) { continue; } try { String col = w.GetColumnMapping(fi); Object val = fi.GetValue(iso); if (val == null && (w.IsID(fi) && !w.IsAutoincID(fi))) { throw new SerializerException("PRIMARY KEY FIELD NOT SET!!!!!!!!"); } if (!start) { sql.Append(", "); values.Append(", "); } else { start = false; } sql.Append(col); values.Append(SqlUtil.SqlConvert(val)); } catch (SerializerException) { } } sql.Append(") VALUES ("); sql.Append(values); sql.Append(")"); return(sql.ToString()); }
protected StringBuilder ComputeSqlJoin(Serializer.Serializer serializer, IList <Type> path, String restriction, String target) { AttributeWorker w = AttributeWorker.GetInstance(target); QueryGenerator ret = new QueryGenerator(); ret.AddQueryComponent(new PlaceHolderComponent()); //StringBuilder b = new StringBuilder(); //b.Append(" @@@"); for (int i = 0; i < path.Count - 1; i++) { Type from = path[i]; Type to = path[i + 1]; //if (i > 0) //{ // b.Replace(" @@@", " WHERE @@@"); //} IVirtualKey vKey = w.CreateVirtualKey(serializer, from, to); QueryGenerator gen1 = vKey.ToSqlRestriction(target, from, to, serializer); ret.ReplacePlaceHolders(gen1); //b.Replace(" @@@", vKey.ToSqlRestriction(target, from, to)); if (i == path.Count - 2) { QueryGenerator gen2 = new QueryGenerator(); gen2.AddQueryComponent(new SqlStringComponent(" WHERE ")); gen2.AddQueryComponent(new SqlStringComponent(restriction)); ret.ReplacePlaceHolders(gen2); //b.Replace(" @@@", " WHERE @@@"); //b.Replace(" @@@", restriction); } } if (path.Count == 1) { QueryGenerator gen3 = new QueryGenerator(); gen3.AddQueryComponent(new SqlStringComponent(" WHERE ")); gen3.AddQueryComponent(new SqlStringComponent(restriction)); ret.ReplacePlaceHolders(gen3); //b.Replace(" @@@", " WHERE @@@"); //b.Replace(" @@@", restriction); } //Entferne das führende " WHERE " return(ret.ToSqlString()); //return b.Remove(0,7); }
public void InsertObject(ISerializableObject iso, DbConnection connection, ISerializerTransaction transaction) { AttributeWorker w = AttributeWorker.GetInstance(Target); DbCommand com = connection.CreateCommand(); com.CommandText = _owner.SerializeInsert(iso); transaction.Guard(com); //Console.WriteLine(com.CommandText); try { //Console.WriteLine(com.ExecuteNonQuery()); com.ExecuteNonQuery(); } catch (Exception ex) { throw new SerializerException("insert failed", ex); } FieldInfo autoincField; Guid g = AttributeWorker.RowGuid(iso); if ((autoincField = w.GetAutoincField(iso.GetType())) != null) { StringBuilder b = new StringBuilder(); b.Append("SELECT * FROM ").Append(w.GetTableMapping(iso.GetType(), _owner.Praefix)).Append(" WHERE "); b.Append(w.GetColumnMapping(AttributeWorker.RowGuid(iso.GetType()))).Append("='"); b.Append(g.ToString()).Append("'"); com.CommandText = b.ToString(); DbDataReader r = com.ExecuteReader(); if (r.Read()) { Object o = r[w.GetColumnMapping(w.GetAutoincField(iso.GetType()))]; autoincField.SetValue(iso, o); } else { r.Close(); throw new SerializerException("Insert core method failed! error unknown..."); } r.Close(); } GenericWeakReference <ISerializableObject> tmp = new GenericWeakReference <ISerializableObject>(iso); _persistentObjects[g] = tmp; MemoriseKeys(iso, w, tmp); }
private ISerializableObject FetchObject(Serializer s, Guid guid) { FieldInfo fi = AttributeWorker.RowGuid(_synchronizedType); String col = AttributeWorker.GetInstance(s.Target).GetColumnMapping(fi); StringBuilder tmp = new StringBuilder(); tmp.Append(col).Append("='").Append(guid).Append("'");; IRestriction res = RestrictionFactory.SqlRestriction(_synchronizedType, tmp.ToString()); ISerializableObject iso = s.Connector.Load(_synchronizedType, res); return(iso); }
public override Object LoadOneToMany(ISerializableObject owner, Type storedType, Serializer serializer) { Type genType = typeof(DirectAccesIteratorImpl <>).MakeGenericType(new Type[] { storedType }); IDirectAccessIteratorConfiguration conf = (IDirectAccessIteratorConfiguration)Activator.CreateInstance(genType); IVirtualKey vKey = AttributeWorker.GetInstance(serializer.Target).CreateVirtualKey(serializer, owner.GetType(), storedType); vKey.InitVirtualKeyBySource(owner); conf.Restriction = Restrictions.RestrictionFactory.SqlRestriction(storedType, vKey.ToSqlStringForward(serializer.Target)); conf.Serializer = serializer; return(conf); }
public void ConnectOneToOne(ISerializableObject source, ISerializableObject target) { IVirtualKey vKey = AttributeWorker.GetInstance(Target).CreateVirtualKey(this, source.GetType(), target.GetType()); vKey.InitVirtualKeyBySource(source); vKey.ApplyVirtualKeyToTarget(target); try { vKey.TargetField.SetValue(target, source); } catch (Exception) { } }
public override string ToSqlString(Serializer.Serializer serializer, Type type, string target) { AttributeWorker w = AttributeWorker.GetInstance(target); FieldInfo f = w.RetrieveField(_type, _field, false); if (f == null) { throw new RestrictionException("Field '" + _field + "' not found in '" + _type.ToString() + "'"); } if (!(_value is String) || f.FieldType != typeof(String)) { throw new RestrictionException("LIKE operator can only applied to Strings"); } return(base.ToSqlString(serializer, type, target)); }
public override String ToSqlString(Serializer.Serializer serializer, Type type, String target) { AttributeWorker w = AttributeWorker.GetInstance(target); IList <Type> path = w.ComputeVirtualKeyPath(serializer, _type, type); //ComputePath(_type, type, target); StringBuilder b = new StringBuilder(); FieldInfo f = w.RetrieveField(_type, _field, false); if (f == null) { throw new RestrictionException("Field '" + _field + "' not found in '" + _type.ToString() + "'"); } b.Append(w.GetColumnMapping(f)); b.Append(_comparer).Append(SqlUtil.SqlConvert(_value)); String tmp = ComputeSqlJoin(serializer, path, b.ToString(), target).ToString(); return(tmp); }
public CsvPKey(Type type, DbDataReader reader, String target) { _type = type; IDictionary <String, FieldInfo> ids = AttributeWorker.GetInstance(target).GetPrimaryKeyFields(type); List <String> tmpList = new List <String>(ids.Count); StringBuilder csvKey = new StringBuilder(); foreach (String id in ids.Keys) { StringBuilder tmpBuilder = new StringBuilder(); _fields.Add(ids[id]); _values.Add(reader[id]); String tmp = reader[id].ToString(); //Maskierung der Kommata tmp = tmp.Replace("/", "//"); tmp = tmp.Replace(";", "/;"); tmp = tmp.Replace("=", "/="); tmpBuilder.Append(id).Append("="); tmpBuilder.Append(tmp); tmpList.Add(tmpBuilder.ToString()); } tmpList.Sort(); bool initial = true; foreach (String s in tmpList) { if (!initial) { csvKey.Append(";"); } initial = false; csvKey.Append(s); } _csvKey = csvKey.ToString(); }
internal static void PlainCopy(Serializer context, ISerializableObject from, ISerializableObject to, FieldLock fieldLock, bool forceForeignKeyCopy) { AttributeWorker w = AttributeWorker.GetInstance(context.Target); FieldInfo[] fis = AttributeWorker.RetrieveAllFields(from.GetType()); foreach (FieldInfo fi in fis) { if (fieldLock.IsLocked(fi)) { continue; } if (AttributeWorker.IsRelationField(fi)) { continue; } if (w.IsAutoincID(fi)) { continue; } if (!w.IsPersistentField(fi)) { continue; } if (AttributeWorker.IsRowGuid(fi)) { continue; } if (w.IsForeignKey(context, fi) && !forceForeignKeyCopy) { DirectSyncAttribute a = (DirectSyncAttribute)Attribute.GetCustomAttribute(fi, typeof(DirectSyncAttribute)); if (a == null) { continue; } } Object val = fi.GetValue(from); fi.SetValue(to, val); } }
public void HandleOneToOneReflexive(ISerializableObject handledItem, OneToOneDefAttribute attr, FieldInfo field) { Type type = field.FieldType; IVirtualKey vKey = AttributeWorker.GetInstance(_serializer.Target).CreateVirtualKey(_serializer, type, handledItem.GetType()); try { vKey.InitVirtualKeyBySource(handledItem); } catch (InvalidOperationException) { field.SetValue(handledItem, null); return; } IRestriction r = Restrictions.RestrictionFactory.SqlRestriction(type, vKey.ToSqlStringForward(_serializer.Target)); ISerializableObject tmp = _serializer.Connector.Load(type, r); field.SetValue(handledItem, tmp); }
internal void Save(ISerializableObject iso, ISerializerTransaction transaction) { AttributeWorker w = AttributeWorker.GetInstance(Target); if (!IsManaged(iso)) { // Console.WriteLine("SERIALIZE"); _objectPool.InsertObject(iso, _connection, transaction); ResolverData <ISerializableObject> rData = new ResolverData <ISerializableObject>(); rData.HandledItem = iso; rData.FieldsToResolve = AttributeWorker.RetrieveAllFields(iso.GetType()); LoadHandler handler = new LoadHandler(this); RelationResolver <ISerializableObject> res = new RelationResolver <ISerializableObject>(); res.Handler = handler; res.StartRelationResolving(rData); } else { // Console.WriteLine("UPDATE"); UpdateStates state = _objectPool.UpdateObject(iso, _connection, transaction); if (state == UpdateStates.NO_ROWS_AFFECTED) { throw new SerializerException("entry could not be updated ..."); } else if (state == UpdateStates.PRIMARYKEY_MODIFIED) { UpdateEventArgs args = new UpdateEventArgs(state); OnUpdateEvent(args); } ResolverData <ISerializableObject> data = new ResolverData <ISerializableObject>(); data.HandledItem = iso; data.FieldsToResolve = AttributeWorker.RetrieveAllFields(iso.GetType()); RelationResolver <ISerializableObject> res = new RelationResolver <ISerializableObject>(); res.Handler = new UpdateHandler(this); res.StartRelationResolving(data); } }
// //////////////////////////////////////////// private ISerializableObject Deserialize(Type type, DbDataReader reader) { ISerializableObject data = (ISerializableObject)Activator.CreateInstance(type); FieldInfo[] fis = AttributeWorker.RetrieveAllFields(type); foreach (FieldInfo fi in fis) { if (AttributeWorker.GetInstance(Target).IsPersistentField(fi)) { Object o = null; Type t = null; try { o = reader[AttributeWorker.GetInstance(Target).GetColumnMapping(fi)]; t = o.GetType(); if (o is DBNull) { o = null; } fi.SetValue(data, o); } catch (ArgumentException ex) { String s = o.GetType().FullName; Type targetType = FieldMapping.Mapping[o.GetType().FullName]; if (targetType.Equals(typeof(String))) { fi.SetValue(data, o.ToString()); } } catch (IndexOutOfRangeException) { System.Text.StringBuilder msg = new System.Text.StringBuilder(); msg.Append("column: ").Append(AttributeWorker.GetInstance(Target).GetColumnMapping(fi)).Append(" not found\n"); msg.Append("in table: " + AttributeWorker.GetInstance(Target).GetTableMapping(data.GetType(), _owner.Praefix)).Append("!"); throw new SerializerException(msg.ToString()); } } } return(data); }
internal static void ForeignKeyCopy(Serializer context, ISerializableObject from, ISerializableObject to, FieldLock fieldLock) { AttributeWorker w = AttributeWorker.GetInstance(context.Target); FieldInfo[] fis = AttributeWorker.RetrieveAllFields(from.GetType()); foreach (FieldInfo fi in fis) { if (fieldLock.IsLocked(fi)) { continue; } if (!w.IsForeignKey(context, fi)) { continue; } Object val = fi.GetValue(from); fi.SetValue(to, val); } }
public ISerializableObject RetrieveObject(Type objectType, DbDataReader reader, ref bool isLoaded) { if (_cleaner == null) { throw new NullReferenceException("No cleaner attached SerializableObjectPool needs a Cleaner to work..."); } ISerializableObject ret = null; FieldInfo fi = AttributeWorker.RowGuid(objectType); Object o = reader[AttributeWorker.GetInstance(Target).GetColumnMapping(fi)]; Guid g = (Guid)o; try { ret = _persistentObjects[g].Target; isLoaded = false; if (ret == null) { throw new KeyNotFoundException(); } } catch (KeyNotFoundException) { ret = Deserialize(objectType, reader); GenericWeakReference <ISerializableObject> tmp = new GenericWeakReference <ISerializableObject>(ret); _persistentObjects[AttributeWorker.RowGuid(ret)] = tmp; MemoriseKeys(ret, AttributeWorker.GetInstance(Target), tmp); isLoaded = true; } _cleaner.Cleanup(); return(ret); }
internal static String ComputeHashCode(String target, ISerializableObject iso) { AttributeWorker w = AttributeWorker.GetInstance(target); FieldInfo[] fis = AttributeWorker.RetrieveAllFields(iso.GetType()); StringBuilder b = new StringBuilder(); foreach (FieldInfo fi in fis) { if (w.IsPersistentField(fi) && !w.IsID(fi)) { Object val = fi.GetValue(iso); b.Append(val); } } System.Text.ASCIIEncoding encoding = new System.Text.ASCIIEncoding(); Byte[] tmp = encoding.GetBytes(b.ToString()); return(BitConverter.ToString(new MD5CryptoServiceProvider().ComputeHash(tmp)).Replace("-", "").ToLower()); }
internal virtual String SerializeUpdate(ISerializableObject iso, ref UpdateStates state, GenericWeakReference <ISerializableObject> tmp) { AttributeWorker w = AttributeWorker.GetInstance(Target); StringBuilder sql = new StringBuilder(); StringBuilder where = new StringBuilder(); Guid g = AttributeWorker.RowGuid(iso); FieldInfo f = AttributeWorker.RowGuid(iso.GetType()); sql.Append("UPDATE ").Append(w.GetTableMapping(iso.GetType(), _praefix)); sql.Append(" SET "); where.Append(" WHERE ").Append(AttributeWorker.GetInstance(Target).GetColumnMapping(f)); where.Append("='").Append(g).Append("'");; FieldInfo[] fis = AttributeWorker.RetrieveAllFields(iso.GetType()); bool start = true; foreach (FieldInfo fi in fis) { try { String col = w.GetColumnMapping(fi); Object val = fi.GetValue(iso); Object oldVal; if (w.IsAutoincID(fi)) { continue; } if (AttributeWorker.IsRowGuid(fi)) { continue; } if (w.IsID(fi)) { oldVal = tmp.Properties[fi.Name]; if (!Object.Equals(val, oldVal)) { state = UpdateStates.PRIMARYKEY_MODIFIED; } tmp.Properties[fi.Name] = val; } if (!start) { sql.Append(", "); } else { start = false; } sql.Append(col).Append("=").Append(SqlUtil.SqlConvert(val)); } catch (SerializerException) { } } sql.Append(where); return(sql.ToString()); }
internal void Analyze() { SyncItem sourceSyncItem = FetchSyncItem(_sourceGuid); SyncItem sinkSyncItem; ISerializableObject source = FetchObject(_sourceSerializer, _sourceGuid); if (sourceSyncItem == null)//In der Synchronisationstabelle gibt es keinen korrepondierenden Eintrag { #if DEBUG logger.Debug(source.GetType().Name + ", guid=" + AttributeWorker.RowGuid(source) + " is not synchronized and will be inserted"); #endif SyncState = new InsertState(this); } else //in der Synchronisationstabelle ist ein Eintrag vorhanden { sinkSyncItem = sourceSyncItem.CounterPart; _sinkGuid = sinkSyncItem.SyncGuid; ISerializableObject sink = FetchObject(_sinkSerializer, _sinkGuid); //Das korrepondierende Objekt wird aus der Zieldatenbankgeholt if (sink == null) //Wenn es nicht vorhanden ist wurde es gelöscht { #if DEBUG logger.Debug(sourceSyncItem.ClassID + ", guid=" + AttributeWorker.RowGuid(source) + " does not exist, the conflict has to be resolved"); #endif SyncState = new DeletedState(this, sourceSyncItem); } else { String h1 = sinkSyncItem.Hashcode; String sinkHashCode = ComputeHashCode(_sinkSerializer.Target, sink); if (h1 != sinkHashCode)//Änderung der Daten in der Zieldatenbank--warum ist das schon ein Konflikt? { #if DEBUG logger.Debug(sourceSyncItem.ClassID + ", guid=" + AttributeWorker.RowGuid(source) + " is involved in a conflict, which has to be resolved"); #endif SyncState = new ConflictState(this, sourceSyncItem); } else //zieldatenbank unverändert { String sourceHashCode = ComputeHashCode(SourceSerializer.Target, source); if (sourceHashCode == sourceSyncItem.Hashcode)//Quelldatenbank unverändert { #if DEBUG logger.Debug(sourceSyncItem.ClassID + ", guid=" + AttributeWorker.RowGuid(source) + " has not changed and will not be synchronized"); #endif SyncState = new IgnoreState(this); } else//Quelldatenbank verändert-Zieldatenbank unverändert ->update { #if DEBUG logger.Debug(sourceSyncItem.ClassID + ", guid=" + AttributeWorker.RowGuid(source) + " has changed on the sourceside and will be updated"); #endif SyncState = new UpdateState(this, sourceSyncItem); } } } } AttributeWorker w = AttributeWorker.GetInstance(_sinkSerializer.Target); IList <FieldInfo> fis = w.GetFieldByAttribute <CheckForeingKeyConstraintAttribute>(_synchronizedType); foreach (FieldInfo fi in fis) { Object val = fi.GetValue(source); if (val == null) { continue; } CheckForeingKeyConstraintAttribute attr = w.GetAttribute <CheckForeingKeyConstraintAttribute>(fi); String table = attr.UnmappedTable; String column = attr.ExternColumn; if (column == null) { column = w.GetColumnMapping(fi); } if (!_sinkSerializer.Connector.Exists(column, val, table)) { //Hier kann man einen neuen Status einführen, der dieses Problem abfängt throw new InvalidOperationException("Insertion of " + _synchronizedType.Name + " will fail. Unmapped foreign key " + column + "=" + val + " does not exist in target database!"); } } }