private void update(ListContainer sc)
{
try
{
ISerializableObject sourceObject = sc.iso;
SyncItem si = FetchSyncItem(sourceObject.Rowguid);
Guid sinkGuid = sourceObject.Rowguid;
ISerializableObject sinkObject = FetchObject(sinkSerializer, sinkGuid, sourceObject.GetType());
if (LookupSynchronizationInformation.getImageClasses().Contains(sourceObject.GetType()))
{
//Bilder können nicht aktualisiert werden
ignore(sc);
return;
}
else
{
copyToSinkObject(sourceObject, sinkObject);
adjustAutoIncKeys(sinkObject);//Kann man verhindern, dass "richtige" Schlüssel zunächst falsch überschrieben und dann wieder richt zurücküberschrieben werden?
}
sinkSerializer.Connector.UpdatePlain(sinkObject);
syncSerializer.Connector.Save(si);
sinkObject = FetchObject(sinkSerializer, sinkGuid, sourceObject.GetType());
sc.State = SyncStates_Enum.SynchronizedState;
}
catch (Exception e)
{
MessageBox.Show("Update Failure: " + e.Message);
}
}
private void insert(ListContainer sc)
{
ISerializableObject sourceObject = sc.iso;
ISerializableObject sinkObject = sinkSerializer.CreateISerializableObject(sourceObject.GetType(), sc.iso.Rowguid);//Hier werden die Relationen mitgefüllt. Eigentlich ist da nicht nötig->Methode ändern? Zeitersparnis?
//Evtl. Problem, dass nicht alle Beziehungen aufgelöst werden können, weil noch nicht alle Objekte "rübersynchronisert" wurden.
copyToSinkObject(sourceObject, sinkObject);
if (LookupSynchronizationInformation.getImageClasses().Contains(sourceObject.GetType()))
{
try
{
MessageBox.Show("Insert Picture:" + sinkObject.Rowguid.ToString());
if (this.pictrans == null)
{
throw new TransferException("No TransferService is added");
}
insertPicture(sinkObject);
}
catch (Exception ex)
{
MessageBox.Show("Picture SyncFailure: " + ex.Message);
return;
}
}
try
{
adjustAutoIncKeys(sinkObject);
sinkSerializer.Connector.InsertPlain(sinkObject);
SyncItem si = syncSerializer.CreateISerializableObject <SyncItem>();
si.SyncGuid = sourceObject.Rowguid;
si.ClassID = sourceObject.GetType().Name;
syncSerializer.Connector.Save(si);
sinkObject = FetchObject(sinkSerializer, sinkObject.Rowguid, sinkObject.GetType());//Mit angepasstem AutoIncSChlüssel aus der DB holen
sc.State = SyncStates_Enum.SynchronizedState;
}
catch (Exception e)
{
MessageBox.Show("Insert Failure: " + e.Message + " All dependent Insert will also Fail and notice You");
}
}
private void adjustAutoIncKeys(ISerializableObject manipulatedObject)
{
try
{
Type t = manipulatedObject.GetType();
//1.Abhängigkeiten aus Liste holen <eigenes Feld,Klasse>
Dictionary <String, Type> foreignKeys = LookupSynchronizationInformation.getDeterminingFields(t);
foreach (KeyValuePair <String, Type> fk in foreignKeys)
{
FieldInfo foreignAutoInc = t.GetField(fk.Key, BindingFlags.NonPublic | BindingFlags.Instance);//Enthält die Information darüber in welchem Feld das manipulatedObject einen fremden AutoInc-Key stehen hat.
if (foreignAutoInc.GetValue(manipulatedObject) != null)
{
//2.AutoincFeld der PartnerKlasse holen
String autoInc = LookupSynchronizationInformation.getAutoIncFields()[fk.Value];
//3.In der QuelldatenBank nach dem referenzierten AutoincSchlüssel suchen und das entsprechnde Objekt laden.
IRestriction r = RestrictionFactory.Eq(fk.Value, autoInc, foreignAutoInc.GetValue(manipulatedObject));
ISerializableObject parent = sourceSerializer.Connector.Load(fk.Value, r);
Guid g = parent.Rowguid;
//4. synchronisierten Partner in der Zieldatenbank über Guid holen
ISerializableObject parentPartner = FetchObject(sinkSerializer, g, fk.Value);
FieldInfo partnerField = fk.Value.GetField(autoInc, BindingFlags.Instance | BindingFlags.NonPublic);
//5. Werte anpassen
foreignAutoInc.SetValue(manipulatedObject, partnerField.GetValue(parentPartner));
}
}
}
catch (Exception e)
{
MessageBox.Show("KeyAdjustmentError: " + e.Message);
if (e.InnerException != null)
{
MessageBox.Show(e.InnerException.Message);
}
throw new SerializerException("KeyAdjustmentError: " + e.Message);
}
}