public bool analyzeObjects()
{
if (object1.Rowguid != object2.Rowguid)
{
throw new Exception("Objects don´t correspond.");
}
bool inConflict = false;
FieldInfo[] fields = AttributeWorker.RetrieveAllFields(ownerType);
foreach (FieldInfo fi in fields)
{
Attribute at = Attribute.GetCustomAttribute(fi, typeof(ColumnAttribute));
IDAttribute id = (IDAttribute)Attribute.GetCustomAttribute(fi, typeof(IDAttribute));
if (at != null)
{
if (id != null && id.Autoinc == true)
{
}
else
{
Conflict cf = compareFields(fi, object1, object2);
if (cf != null)
{
inConflict = true;
this.conflicts.Add(cf);
}
}
}
}
return(inConflict);
}
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);
}
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);
}
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());
}
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());
}
internal ISerializableObject Load(Type type, string table, IRestriction restriction, ISerializerTransaction transaction)
{
bool found = false;
bool multiple = false;
bool isLoaded = false;
DbDataReader reader = CreateDataReader(type, table, restriction, transaction);
ISerializableObject data = null;
if (reader.Read())
{
data = _objectPool.RetrieveObject(type, reader, ref isLoaded);
found = true;
}
if (reader.Read())
{
multiple = true;
}
reader.Close();
if (multiple)
{
throw new MultipleResultException("More than one Result found for the given Restriction ...");
}
if (data == null)
{
return(null);
}
bool doRelationLoading = found && isLoaded;
if (doRelationLoading)
{
ResolverData <ISerializableObject> rData = new ResolverData <ISerializableObject>();
rData.HandledItem = data;
rData.FieldsToResolve = AttributeWorker.RetrieveAllFields(data.GetType());
LoadHandler handler = new LoadHandler(this);
RelationResolver <ISerializableObject> res = new RelationResolver <ISerializableObject>();
res.Handler = handler;
res.StartRelationResolving(rData);
}
return(data);
}
internal T Load <T>(IRestriction restriction, int readerPosition, ISerializerTransaction transaction) where T : ISerializableObject
{
if (readerPosition < 0)
{
throw new ArgumentOutOfRangeException("The passed reader position is less than 0.");
}
bool found = false;
bool isLoaded = false;
DbDataReader reader = CreateDataReader(typeof(T), restriction, transaction);
T data = default(T);
for (int i = 0; i <= readerPosition; i++)
{
if (!reader.Read())
{
reader.Close();
throw new ArgumentOutOfRangeException("The passed reader position is too big.");
}
}
data = (T)_objectPool.RetrieveObject(typeof(T), reader, ref isLoaded);
found = true;
reader.Close();
if (data == null)
{
return(default(T));
}
bool doRelationLoading = found && isLoaded;
if (doRelationLoading)
{
ResolverData <ISerializableObject> rData = new ResolverData <ISerializableObject>();
rData.HandledItem = data;
rData.FieldsToResolve = AttributeWorker.RetrieveAllFields(data.GetType());
LoadHandler handler = new LoadHandler(this);
RelationResolver <ISerializableObject> res = new RelationResolver <ISerializableObject>();
res.Handler = handler;
res.StartRelationResolving(rData);
}
return(data);
}
internal void InitSyncContainer(IDictionary <Guid, SyncContainer> pooledObjects)
{
ResolverData <ISerializableObject> data = new ResolverData <ISerializableObject>();
ISerializableObject iso = FetchObject(_sourceSerializer, _sourceGuid);
data.HandledItem = iso;
data.FieldsToResolve = AttributeWorker.RetrieveAllFields(iso.GetType());//Sind alle nötig?
DependencyRelationHandler h = new DependencyRelationHandler(this, pooledObjects);
RelationResolver <ISerializableObject> r = new RelationResolver <ISerializableObject>();
r.Handler = h;
r.StartRelationResolving(data);
}
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);
}
}
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);
}
}
public bool compareObjects()
{
bool inConflict = false;
FieldInfo[] fields = AttributeWorker.RetrieveAllFields(ownerType);
foreach (FieldInfo fi in fields)
{
Attribute at = Attribute.GetCustomAttribute(fi, typeof(ColumnAttribute));
if (at != null)
{
Conflict cf = compareFields(fi, object1, object2);
if (cf != null)
{
inConflict = true;
this.conflicts.Add(cf);
}
}
}
return(inConflict);
}
// ////////////////////////////////////////////
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);
}
}
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());
}
