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 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);
}
public void Get_Should_ReturnAllTypes()
{
var resolver = new RelationResolver();
var types = new List <Type>()
{
typeof(TestModel1),
typeof(TestModel2),
typeof(ITestInterface1)
};
var processedTypes = resolver.Resolve(types);
var duplicatedTypes = processedTypes.Select(x => x.Type).ToList().OrderBy(x => x.Name);
var disitinctTypes = duplicatedTypes.Distinct();
Assert.Equal(disitinctTypes.Count(), processedTypes.Count);
Assert.Equal(2, processedTypes.Where(x => x.ProcessingCategory == ProcessingCategory.Enum).Count());
Assert.Equal(5, processedTypes.Where(x => x.ProcessingCategory == ProcessingCategory.Object).Count());
Assert.Equal(2, processedTypes.Where(x => x.ProcessingCategory == ProcessingCategory.Interface).Count());
}
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);
}
}
