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 delete(ListContainer sc)
        {
            //Wenn nach Bestätigung immer noch deleted: Löscht sc.iso aus der source-Datenbank und die SyncItems aus der Synchronisationsdatenbank.
            ISerializableObject sourceObject = sc.iso;
            SyncItem            syncItem     = FetchSyncItem(sourceObject.Rowguid);

            sourceSerializer.Connector.Delete(sourceObject);
            syncSerializer.Connector.Delete(syncItem);
            sc.State = SyncStates_Enum.SynchronizedState;
        }
        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 conflictResolved(ListContainer sc)
 {
     //Idee: Teile diese Typ in update des sourceObjects beim ConflictHandling und update des sinkObjects bei der Synchronisation
     update(sc);
 }
 private void ignore(ListContainer sc)
 {
     sc.State = SyncStates_Enum.SynchronizedState;
 }