Forums Neueste Beiträge
 

Designfrage

18/08/2008 - 15:38 von Thomas Schremser | Report spam
Hallo allerseits!

In einer Assembly (DLL) definiere ich Klassen, die Daten aus einer Datenbank
enthalten. Diese Klassen verfügen über eine ID, die, einmal vergeben, nicht
mehr geàndert werden soll. Erzeugt werden diese Objekte über eine statische
Factory-Klasse, mit Daten gefüllt werden sie über ein zugeöriges Objekt, das
den DB-Zugriff kapselt. Das sieht dann prinzipiell so aus:

// Assembly A

public class Foo
{
internal Foo() { }

public int ID
{
get;
internal set;
}
}

public class SqlFooReader : IFooReader
{
private Foo mFoo;

public SqlFooReader(Foo foo)
{
mFoo = foo;
}

public void Execute()
{
mFoo.ID = ... // ID aus der Datenbank lesen
}
}

public static class ObjectFactory
{
public static Foo LoadFoo(int id)
{
Foo foo = new Foo();
IFooReader reader = CreateFooReader(foo);
reader.Execute();
return foo;
}

private IFooReader CreateFooReader(Foo foo)
{
if (db == "SQLServer")
return new SqlFooReader(foo);
else if(db == "Oracle")
return new OracleFooReader(foo);
...
}
}

Nun würde ich gern die Klassen für den DB-Zugriff in eine eigene Assembly
auslagern, um in der ursprünglichen Assemly nicht die spezialisierten
Klassen für alle unterstützten DB-Provider mitschleppen zu müssen. Das
bedingt aber, daß die Klassen in der neuen Assembly in Foo.ID schreiben
können. Da ich diese Eigenschaft nicht public machen möchte, hab' ich mir
so beholfen, daß ich für die Zugriffsklassen eine abstrakte Basisklasse
definiert habe, die mir die Eigenschaft "durchschleust":

// Assembly A

public abstract class FooReader : IFooReader
{
private Foo mFoo;

public FooReader(Foo foo)
{
mFoo = foo;
}

public int ID
{
get { return mFoo.ID ; }
set { mFoo.ID = value ; }
}

public abstract void Execute();
}

// Spezialisierte Assembly

public class SqlFooReader : FooReader
{
public SqlFooReader(Foo foo) : base(foo) { }

public override void Execute()
{
base.ID = ... // ID aus der Datenbank lesen
}
}

Das funktioniert zwar, kommt mir aber irgendwie holprig und wenig elegant
vor. Hat jemand eine Idee, wie man das schöner lösen kann, oder bin ich hier
mit meiner gesamten Architektur auf einem Holzweg?

TIA

Grüße
Thomas

Any problem in computer science can be solved with another layer
of indirection. But that usually will create another problem.
David Wheeler
 

Lesen sie die antworten

#1 Frank Dzaebel
18/08/2008 - 16:12 | Warnen spam
Hallo Thomas,

In einer Assembly (DLL) definiere ich Klassen, die Daten
aus einer Datenbank enthalten.
Diese Klassen verfügen über eine ID, die, einmal vergeben,
nicht mehr geàndert werden soll. Erzeugt werden diese
Objekte über eine statische Factory-Klasse, mit Daten
gefüllt werden sie über ein zugeöriges Objekt, das
den DB-Zugriff kapselt.



Kennst Du eigentlich das "ADO .NET Entity Framework"?
Zusammen mit den "ADO.NET Data Services" wohl beim
ersten "Hinsehen" eher angebracht, als (in diesem Szenario)
eigenes Design zu implementieren. Da jetzt auch über
.NET 3.5 SP1 von Microsoft released, hast Du im Prinzip gute Karten.


ciao Frank
Dipl.Inf. Frank Dzaebel [MCP/MVP C#]
http://Dzaebel.NET

Ähnliche fragen