Aufbau der Klassenbibliothek
Alexander Widera
ich habe ein Problem mit der Programmstruktur.
Ich möchte gern eine allgemein gehaltene Klassenbibliothek schreiben, die in
verschiedenen Projekten leicht angepasst verwendet werden soll.
Dabei möchte ich alles was in den angepassten Klassenbibliotheken gleich ist
(mit der allgemeinen) immer nur an einer Stelle ändern (also in der
allgemeinen).
vielleicht erkläre ich es besser an einem Beispiel:
allgemeine Klassenbibliothek:
namespace: MeineBibliothek
Klassen: Obst, Gemüse
Methoden: Obst.Schälen(), Gemüse.Waschen()
diese Klassenbibliothek soll leicht verändert in Projekten verwendet werden
z.B.
namespace: Projekt1Bibliothek
Klassen: Obst, Gemüse
Methoden: Obst.Schälen(), Obst.Essen(), Gemüse.Waschen()
(es ist also eine Methode hinzugekommen zur Klasse Obst, ebenso wurde in
Obst.Schälen() irgendetwas verändert (egal was))
ein anderes Beispiel:
namespace: Projekt2Bibliothek
Klassen: Obst, Gemüse, Wurst
Methoden: Obst.Schälen(), Gemüse.Waschen(), Wurst.Essen()
(es ist eine Klasse hinzugekommen und eine Methode davon, diese wird dann
z.b. in Gemüse.Waschen() aufgerufen)
In der allgemeinen Klasse Obst oder Gemüse wird in den Methoden irgendwie
auf Objekte der allgemeinen Klassenbibliothek zugegriffen ....
Wie organisiere ich das ganze am besten? In den Projekten soll NUR direkt
auf die Klassenbibliothek des Projektes (z.B. Projekt1Bibliothek)
zugegriffen werden und nicht auf die allgemeine Bibliothek.
Vielen Dank für Ideen und Hilfe im Voraus,
Alex
Ulf Kadner
> Ich möchte gern eine allgemein gehaltene Klassenbibliothek schreiben,
Was bedeutet "allgemein enthalten"? Auf welchen Gültigkeitsbereich
(Scope) bezieht sich das?
> vielleicht erkläre ich es besser an einem Beispiel:
Besser is das! :-)
> allgemeine Klassenbibliothek:
> Klassen: Obst, Gemüse
> Methoden: Obst.Schälen(), Gemüse.Waschen()
>
> diese Klassenbibliothek soll leicht verändert in Projekten verwendet werden
Also must Du eine neu Klasse davon ableiten.
> Klassen: Obst, Gemüse
> Methoden: Obst.Schälen(), Obst.Essen(), Gemüse.Waschen()
> (es ist also eine Methode hinzugekommen zur Klasse Obst, ebenso wurde in
Ist ist generell keine gute Idee! Ein Objekt stellt immer ein bestimmtes
Interface bereit. Ein neues Objekt in einem anderen Namespace mit
anderer/erweiterter Funktionalität benötig auch einen anderen Namen.
Das OOP-Stichwort was Du suchst heist Vererbung.
> Obst.Schälen() irgendetwas verändert (egal was))
Dazu must Du Schälen in Deiner "allgeinen Klassenbibliothek" als virtual
definieren und in der Ableitung überschreiben.
MfG, Ulf
Alexander Widera
> bezieht sich das?
Ich definiere Funktionen in der allgemeinen Bibliothek die in allen
"Unter"-Projekten gültig sein sollen.Es kann aber notwendig sein, dass in
einzelnen Projekten die irgendeine Funktion komplett umgeschrieben werden
muss (also überschrieben wird) (von der Anweisungslogik, aber nicht von den
Interfaces).
>> allgemeine Klassenbibliothek:
>> Klassen: Obst, Gemüse
>> Methoden: Obst.Schälen(), Gemüse.Waschen()
>>
>> diese Klassenbibliothek soll leicht verändert in Projekten verwendet
>> werden
>
> Also must Du eine neu Klasse davon ableiten.
>
>> Klassen: Obst, Gemüse
>> Methoden: Obst.Schälen(), Obst.Essen(), Gemüse.Waschen()
>> (es ist also eine Methode hinzugekommen zur Klasse Obst, ebenso wurde in
>
> Ist ist generell keine gute Idee! Ein Objekt stellt immer ein bestimmtes
> Interface bereit. Ein neues Objekt in einem anderen Namespace mit
> anderer/erweiterter Funktionalität benötig auch einen anderen Namen.
>
> Das OOP-Stichwort was Du suchst heist Vererbung.
Einfach gesagt.. aber getan?
> Dazu must Du Schälen in Deiner "allgeinen Klassenbibliothek" als virtual
> definieren und in der Ableitung überschreiben.
ja. so würde ich es auch machen.
Nur besteht jetzt noch das Problem, dass der Zugriff nur über die
Projektbibliotheken in den Projekten erfolgen soll... also müsste ich quasi
für alle Klassen eine Klasse ableiten (im Namespace des Projektes) auch wenn
dort garnichts verändert wird, oder?
Da ja aber die Verarbeitungslogik (zumindest Teilweise) in der allgemeinen
Bibliothek ist, müsste ich alle Klassen mit Interfaces ausstatten, oder?
Gibt es keine andere einfachere Lösung oder einen Ansatz?
Viele Grüße, Alex
Alexander Widera
wie es geht ....
In der allgemeinen Bibliothekt werden in Methoden Objekte der Klassen der
allgemeinen Bibliothek verwendet ...
in der Projektbibliothek (die eine Erweitung/Veränderung der allgemienen
Bibiliothek ist) sollen in den Methoden die Obejkte der Klassen aus der
Projektdatenbank verwendet werden
kurzes Beispiel:
namespace allgemein
{
public class Gemuese
{
public string testtext = "ich bin allgemeines gemüse";
}
public class Obst
{
public void machEtwas()
{
Gemuese g = new Gemuese();
return "ich bin obst und das ist: " + g.testtext;
}
}
}
namespace projekt1
{
public class Gemuese
{
public string testtext = "ich bin gemüse aus projekt1";
}
public class Obst
{
public void machEtwas()
{
Gemuese g = new Gemuese();
return "ich bin obst und das ist: " + g.testtext;
}
}
}
In Projekt1 ist ja alles gleich, bis auf den testtext. Deshalb soll der
gleiche Teil Code (in dem Fall klasse obst) aus dem Projekt verschwinden und
an der zentralen Stelle in der allgemeinen Klassenbibliothek stehen.
Da ja nun aber Projekt1 sich auf das Gemuese aus Projekt1 beziehen soll und
nicht auf das Gemuese aus der allgemeinen Klassenbibliothek geht das nicht
ganz so einfach...
Ja .. .es klingt als müsste man da mit Interfaces arbeiten...
gibt es aber noch eine andere Lösung? Irgendwie soetwas wie ein
Objekt/Klassen-Builder, der die korrekte Klasse zurückliefert? Oder eine
möglichkeit die zu verwendenden Klassentypen irgenwo anzugeben - so in etwa
wie:
Gemüse : nimm die Klasse die hier im Projekt definiert ist
Obst : nimm die Klasse aus der allgemeinen Klassenbibliothek
wenn ich dann neue Objekte erzeugen will soll er schauen welches er wirklich
erzeugen soll...
das dürfte dann sicherlich auch mit Interfaces gemacht werden müssen ... und
einer Funktion die das richtige Objekt zurückliefert ..
.
jedoch fehlt mir der Anfang für die Umsetzung.
Viele Grüße
Alex
Carsten Posingies
> Ich möchte gern eine allgemein gehaltene Klassenbibliothek
> schreiben, die in verschiedenen Projekten leicht angepasst
> verwendet werden soll.
> Dabei möchte ich alles was in den angepassten
> Klassenbibliotheken gleich ist (mit der allgemeinen) immer
> nur an einer Stelle ändern (also in der allgemeinen).
>
> In der allgemeinen Klasse Obst oder Gemüse wird in den
> Methoden irgendwie auf Objekte der allgemeinen
> Klassenbibliothek zugegriffen ....
>
> Wie organisiere ich das ganze am besten? In den Projekten
> soll NUR direkt auf die Klassenbibliothek des Projektes
> (z.B. Projekt1Bibliothek) zugegriffen werden und nicht auf
> die allgemeine Bibliothek.
Hier, beim letzten Absatz, habe ich wohl ein Verständnis-Problem...
Beispiel:
namespace Allgemein
{
public class Obst : IObst
{
public virtual void Schneiden()
{ ... }
}
}
// ...
namespace Speziell
{
public class Himbeere : Allgemein.Obst
{
// Himbeeren werden nicht geschnitten,
// also keine "Schneiden"-Methode
}
public class Apfel : Allgemein.Obst
{
// Äpfel schon
public void Schneiden()
{
DoSchneiden();
}
}
public sealed class Anwendung
{
private Himbeere him;
private Apfel apf;
// ...
}
}
Beachte die Vererbung: Jegliches spezielle Obst erbt vom allgemeinen Obst.
Der Punkt ist, dass Du, wenn Du "Allgemein" benutzt, sowieso eine Referenz
auf die Lib / Assembly(s) brauchst. Du musst sie also mit ausliefern. Ohne
geht gar nichts.
Natürlich kannst Du nun in "Allgemein.Obst.Schneiden()" irgendwas
implementieren. Du kannst dann in "Apfel.Schneiden()" mit "base.Schneiden()"
auf diese Methode zugreifen. Du könntest zum Beispiel in "Apfel" sagen:
// ...
public void Schneiden()
{
// erst entkernen
Entkernen();
base.Schneiden();
}
private void Entkernen()
{
// was auch immer
}
// ...
Deine spezielle Anwendung greift also implizit (!) immer (!) auf die
allgemeinen Klassen zu. In den speziellen Obstsorten überschreibst Du nur
die Methoden, die sich anders verhalten sollen als die allgemeine Methode.
Wenn Du in der allgemeinen Methode etwas veränderst, wirkt sich das genau
dann in den abgeleiteten Klassen aus, wenn Du die Methode /nicht/
überschreibst. Überschreibst Du sie, aber willst die allgemeine Methode
dennoch ausgeführt wissen, rufst Du sie eben über "base.Methode()" auf.
HTH,
Carsten
Alexander Widera
"Carsten Posingies" <carsten....@gmx.net> schrieb im Newsbeitrag
news:eQJvjv8Z...@TK2MSFTNGP05.phx.gbl...
> Deine spezielle Anwendung greift also implizit (!) immer (!) auf die
> allgemeinen Klassen zu. In den speziellen Obstsorten überschreibst Du nur
> die Methoden, die sich anders verhalten sollen als die allgemeine Methode.
> Wenn Du in der allgemeinen Methode etwas veränderst, wirkt sich das genau
> dann in den abgeleiteten Klassen aus, wenn Du die Methode /nicht/
> überschreibst. Überschreibst Du sie, aber willst die allgemeine Methode
> dennoch ausgeführt wissen, rufst Du sie eben über "base.Methode()" auf.
Das heißt also, dass ich, wenn ich NUR über die ProjektBibliothek Zugriffe
tätigen will, alle Klassen ableiten muss und dort drin einfach nichts
ändere.
Jetzt habe ich aber das folgende Problem. In der allgemeinen Bibliothek wird
in einer Methode Allgemein.Obst verwendet. z.B.
namespace Allgemein
{
public virtual class Obst
{
public void Schneiden()
{
/* mach was */
}
}
public class Anwendung
{
public void arbeite()
{
Obst apfel = new Obst();
apfel.Schneiden();
}
}
}
In der Projektbibliothek wird Obst nun überschieben und das Schneiden um
Entkernen erweitert. Die Klasse Anwendung wird aber nicht weiter geändert.
Trotzdem soll jetzt dort das Obst aus der Projektbibliothek verwendet werden
(und nicht mehr aus dem allgemeinen Teil).
Um diesen Code der in Anwendung steht geht es mir. Dieser ist überall gleich
und soll zentral sein, wobei die Klassen Obst und Gemüse immer etwas anders
sein können, jedoch größtenteils gleich sind.
Da muss ich sicher Interfaces nehmen... aber wie baue ich die Anwendung auf,
so dass der die Klassen aus der Projektbibliothek nimmt? Kann ich irgendwo
die Typen angeben, die er für Obst nehmen soll?
VG Alex
Ulf Kadner
> Ich definiere Funktionen in der allgemeinen Bibliothek die in allen
> "Unter"-Projekten gültig sein sollen.Es kann aber notwendig sein, dass in
> einzelnen Projekten die irgendeine Funktion komplett umgeschrieben werden
> muss (also überschrieben wird) (von der Anweisungslogik, aber nicht von den
> Interfaces).
Ich verstehe nicht ganz was Du damit sagen willst.
Willst Du ne Empfehlung?
Die von Dir nachgefragen Dinge sind einfachste OOP-Grundlagen. Sowas
sollte man sich im allgemeinen schon im Vorfeld anlesen. Alles hier
nochmal neu zu erzählen wird Dir auf Grund von evtl.
Verständnisproblemen nicht weiterhelfen und nur unnütze Arbeit machen.
Es gibt zahlreiche OOP-Tutorials im Web. Gute Bücher existieren auch.
Bitte verstehe mich nicht falsch! Ich denke nur das würde Dir hier am
besten helfen.
MfG, Ulf
Alexander Widera
OO kann ich, versteh ich, wende ich lange an ...
aber in diesem konkreten Fall fehlt mir der geeignete Aufbau (den ich
nirgendwo im Web finde zu meinem Problem).
Die beste Erklärung zu meinem Problem ist in meinem Beitrag von 16:39 Uhr im
Thread.
Alex
"Ulf Kadner" <dr_l...@gmx.net> schrieb im Newsbeitrag
news:eteejk$qk3$01$1...@news.t-online.com...
Carsten Posingies
einfaches Beispiel:
namespace A
{
class Obst
{
// ctor
public Obst
{
System.Console.WriteLine("A.Obst.ctor");
}
public virtual void Schaele()
{
System.Console.WriteLine("A.Obst.Schaele()");
}
}
}
---------------------------------
namespace S1
{
class Erdbeere : A.Obst
{
// kein ctor
// und keine eigene Schaele()
}
class Apfel : A.Obst
{
// kein ctor
public void Schaele()
{
System.Console.WriteLine("S1.Apfel.Schaele()");
}
}
class Birne : A.Obst
{
public Birne : base()
{
System.Console.WriteLine("S1.Birne.ctor");
}
public void Schaele()
{
base.Schaele();
System.Console.WriteLine("S1.Birne.Schaele()");
}
}
}
----------------------------------
using S1;
namespace foo
{
class bar
{
static void Main()
{
Erdbeere e = new Erdbeere();
Apfel a = new Apfel();
Birne b = new Birne();
e.Schaele();
a.Schaele();
b.Schaele();
}
}
}
ergibt:
A.Obst.ctor // die Erdbeere
A.Obst.ctor // der Apfel
A.Obst.ctor // die Birne
S1.Birne.ctor // immer noch die Birne
A.Obst.Schaele() // die Erdbeere
S1.Apfel.Schaele() // der Apfel
A.Obst.Schaele() // die Birne
S1.Birne.Schaele() // immer noch die Birne
Wenn Du nun im ctor (Konstruktor) vom A.Obst was änderst, wird das in alle
abgeleiteten Klassen durchgereicht. Wenn Du an "Schaele()" vom Obst was
änderst, ändert sich das Verhalten der Erdbeere, weil sie die
Schaele()-Methode vom Obst erbt, und am Verhalten der Birne, weil sie die
Schaele()-Methode vom Obst explizit aufruft. Am Verhalten vom Apfel ändert
sich nix, weil Du die Schaele()-Methode da komplett überschreibst.
Carsten
Alexander Widera
soweit ich das jetzt überblickt habe, ist dein Beispiel ja eine einfache
Vererbung. Alles von Obst abgeleitet...
das Problem das ich habe ist jedoch die Interaktion zwischen mehreren
Klassen / verschiedenartigen Objekten.
Ich verwende in Allgmein.Program.ObstKaufen Objekte der Klasse
Allgemein.Obst.
In meinem Projekt sollen dann aber beim Aufruf der unveränderten Methode
Projekt.Program.ObstKaufen (die einfach vererbt wird, aber nicht verändert
wird) die Objekte der Klasse Projekt.Obst verwendet werden...
ich glaube so habe ich jetzt endlich mein Problem kurz, knapp und vor allem
verständlich formuliert. Tut mir leid für meine vorherigen schlechten
erklärungen :)
Alex
Uwe Lesta
Schau mal in der Pattern gemeinde e.g.
http://www.dofactory.com/Patterns/Patterns.aspx
das Strategy muster scheit für dich zu passen ( habe den thread nur über flogen )
--
--
Kind regards
Uwe
Lesta at SBS-Softwaresysteme.de
Carsten Posingies
> soweit ich das jetzt überblickt habe, ist dein Beispiel ja
> eine einfache Vererbung. Alles von Obst abgeleitet...
> das Problem das ich habe ist jedoch die Interaktion
> zwischen mehreren Klassen / verschiedenartigen Objekten.
>
> ich glaube so habe ich jetzt endlich mein Problem kurz,
> knapp und vor allem verständlich formuliert. Tut mir leid
> für meine vorherigen schlechten erklärungen :)
Ah, jetzt ja, ein Obstsalat! (Ich hoff's wenigstens...)
Das, was Uwe sagte, trifft's. Allgemein google mal ein bisschen nach "GoF"
("Gang of Four") bzw "GoF patterns". Da wird Dich geholfen. Kurz gesagt,
wenn Du Objekte verschiedenster Klassen hast, die aber etwas gemeinsam
können, bastelst Du diese Fähigkeit in die Klassen hinein. Beispiel: ein
Auto kann sich 1 km nach Norden bewegen, ein Mensch auch. Beide tun das auf
unterschiedliche Weise, aber jemandem, der einfach will, dass sich die
Objekte bewegen, kann die interne Implementation egal sein. Er will nur
wissen, ob sich die Objekte bewegen können. Und richtig: das schreit
geradezu nach Interfaces. Hat natürlich den Haken, dass Du die Methoden für
jede Klasse einzeln implementieren musst, sofern Du nicht wieder ableitest.
Aber Spargel schälst Du ja auch anders als eine Orange ;)
Du kannst dieses Prinzip sogar so weit treiben, dass es Deiner Schälmaschine
am Ende egal ist, ob Du Spargel oder Erdbeeren rein wirfst. Wenn ein Objekt
ein bestimmtes Interface nicht implementiert, kommt es eben unverändert
wieder raus. Und wenn Du die einzelnen Maschinen clever implementierst,
kannst Du sie nachher ähnlich wie Streams aneinander hängen wie an einem
Fließband. Vorne wirfst Du blind Deine Objekte drauf, hinten kommen sie
verarbeitet wieder raus. Wenn das bei Dir eine häufige Vorgehensweise ist,
empfiehlt es sich, über das "Fließband" eine Controller-Klasse zu setzen,
die zB für Konfiguration oder auch asynchrones Abarbeiten zuständig ist
(Lastverteilung).
Nimm beispielsweise an, Du schreibst ein Modul für den Jahresabschluss von
Konten. Bei manchen Konten müssen Zinsen berechnet werden, bei manchen
(zusätzlich oder auch nicht) Gebühren, bei manchen fallen Steuern an usw. Da
ists doch praktisch, einfach alle Konten durchlaufen zu lassen, und am Ende
kommen alle Konten wieder abgerechnet raus, ganz egal, ob nun was zu tun war
oder nicht. Noch komplexer würden die Operationen bei der Abrechnung von
Gehältern (ich weiß in diesem speziellen Beispiel, wovon ich rede...
*ächz*).
Diese Art von Software-Aufbau erinnert an eine Getränke-Abfüll-Anlage. Wenn
Coca etwa Cola abfüllt, werden blind alle Leergut-Kästen in die Anlage
geschoben. Fanta- und Sprite-Flaschen werden einfach aussortiert, die
Cola-Flaschen werden auf nicht entfernbare Verunreinigungen geprüft (und
ggf. aussortiert) usw., bis am Ende frisch befüllte Flaschen in Kästen
herauskommen.
LG
Carsten
Ulf Kadner
> nein...
> OO kann ich, versteh ich, wende ich lange an ...
Entschuldige, dan hab ich Dich falsch eingeschätzt. Hatte durch Deine
unpräzisen Angaben den Anschein.
MfG, Ulf
Alexander Widera
Ich werde die Seite aufmerksam durchstudieren.
Danke euch beiden.
Alex
Uwe Lesta
Alexander Widera wrote:
> Ja Perfekt!!! Genau das habe ich gesucht.
> Ich werde die Seite aufmerksam durchstudieren.
Ein empfelenswertes buch zu dem thema (must have):
"Entwurfsmuster" aus dem Addison-wesley verlag ( GoF )
imho eine ausgezeichnete übersetzung ins deutsche
ebenso
"Pattern-orientierte Softwarearchitektur" ebenfalls aus dem Addison-Wesley verlag
Alexander Widera
ich habe einige DesignPatterns durchgeforscht, werde aber nicht so richtig
schlau und laufe ständig im Kreis. Deshalb möchte ich gern ein Beispiel
bringen, wie es ungefähr aussehen soll. Ich habe ein Schema gezeichnet.
Zugriff über http://www.widera.info/csharp/schema.jpg
Die gestrichelten Linien heißt, einfach nur, dass dies Ableitungen sind.
Der untere Kasten ist die Allgemeine Bibliothek ... im oberen Kasten (leicht
blau) ist die Projektbibliothek.
In der Projektbibliothek werden alle Klassen der allgemeinen Bibliothek
abgeleitet, da der Zugriff NUR über sie erfolgen soll.
Es ist noch zu sagen, dass Start bzw. ProjektStart statische Methoden
besitzen, die als zentraler Zugriffspunkt für andere Methoden dienen (mehr
dazu später).
Wenn also z.B. ProjektStart.FindeObst() aufgerufen wird, dann soll ein
SpezialObst zurückgegeben werden. (Der Zugriff also direkt über die
ProjektBibliothek) Diesen Fall habe ich bereits erfolgreich umgesetzt
durch - generische Klassen, denen ich den korrekten Typ übergebe.
(Vielleicht ist das auch irgendwie besser lösbar?)
Aber an einem 2. Fall verzweifle ich. Hier dazu die Skizze leicht verändert:
http://www.widera.info/csharp/schema2.jpg
Die rote Linie zeigt, wie es sein soll.
Da ProjektStart von Start abgeleitet ist, werden einige Methoden vererbt,
bei denen aber auf statische Methoden von Start zugegriffen wird (und nicht
von ProjektStart).
Nehmen wir an, in Obst gibt es eine Methode X in der ein Aufruf einer
anderen Methode über Start notwendig ist. z.B. Start.FindeAehnliches(), das
ein weiteres Obst zurückgibt.
Betrachtet man nur die allgemeine Bibliothek allein, so ist dies ein
einfaches Problem mit einer einfachen Lösung.
Betrachtet man aber beide Bibliotheken zusammen, dann finde ich dort keinen
Ansatz für die Lösung.
Da SpezialObst von Obst abgeleitet ist gibt es dort auch die MethodeX, die
Start.FindeAehnliches() aufruft (und nicht ProjektStart.FindeAehnliches()).
Diese soll nun aber kein Obst mehr zurückliefern, sondern ein Spezialobst.
Ich denke das muss irgendwie mit generischen Klassen gehen, oder evtl. über
Reflection? Mir fehlt jedoch der Ansatz bzw. ein Beispiel.
Kann man irgendwo hinterlegen, welchen Typ eine Methode zurückgeben soll?
Kann mir bitte jemand weiterhelfen?
Viele Grüße
Alex
Carsten Posingies
> Da SpezialObst von Obst abgeleitet ist gibt es dort auch
> die MethodeX, die Start.FindeAehnliches() aufruft (und
> nicht ProjektStart.FindeAehnliches()). Diese soll nun aber
> kein Obst mehr zurückliefern, sondern ein Spezialobst.
Warum ruft MethodeX Start.FindeAehnliches() auf und nicht
ProjektStart.FindeAehnliches()? Versteh' ich nicht, zumal Du noch sagtest,
dass Du im Projekt nur mit den abgeleiteten Klassen arbeitest? Dass in einer
klassischen Modellierung Start nix von SpezialObst weiß, ist doch klar.
Allerdings sollte es Start egal sein, wenn Obst o = new SpezialObst() ist,
sofern die Schnittstelle sauber definiert ist. Schließlich wird Start nur
mit solchen Methoden und Eigenschaften von o hantieren, die auch zu Obst
gehören.
Haben Deine Klassen allesamt sauber definierte Schnittstellen?
Carsten