Vererbung von Klassen

[Alexander Widera]

Hallo,

folgendes Szenario:

abstract class MeineKlasseVorlage
{
....
....
internal class MeineInnereKlasse { ... }
....
}

--> landet in einer .dll
die dll benutzt ein Anwender und erstellt folgende Klasse

class MeineKlasse : MeineKlasseVorlage { ... }

In der Klasse "MeineKlasseVorlage" wird nun aber in einer Methode der
subklasse (MeineInnereKlasse) auf ein Objekt vom Typ MeineKlasse zugegriffen
(und nicht MeineKlasseVorlage).
Der Benutzer der dll, soll ja aber diese Klasse erst noch anlegen.

Wie kann ich dieses Problem lösen?

Danke,
Alex

[Frank Dzaebel]

Hallo Alexander,

> abstract class MeineKlasseVorlage
> { internal class MeineInnereKlasse { ... } }

> class MeineKlasse : MeineKlasseVorlage { ... }
> In der Klasse "MeineKlasseVorlage" wird nun aber in einer Methode der
> subklasse (MeineInnereKlasse) auf ein Objekt vom Typ MeineKlasse zugegriffen
> (und nicht MeineKlasseVorlage).
> Der Benutzer der dll, soll ja aber diese Klasse erst noch anlegen.

Also - wenn es MeineKlasse schon gibt (in der DLL)
dann kann man diese Klasse nicht einfach noch einmal
erstellen - oder muss sie ggf. über Namespace unterscheiden.
Ich schätze du meinst etwa folgendes:

public abstract class Gefährt
{ internal class MeineInnereKlasse { }
public class MeineKlasse {}
abstract public void Fahren(MeineKlasse km);
}

class MeinAuto : MyDllName.Gefährt
{
public override void Fahren(MyDllName.Gefährt.MeineKlasse mk)
{
MessageBox.Show("Mein Auto fährt");
}
}

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

[Alexander Widera]

Eher so war es gemeint:

das ist in der .dll:

public abstract class MeineKlasseVorlage
{
...
...
internal class MeineInnereKlasse
{
MeineKlasse mk = new MeineKlasse();
}
}

Und
public class MeineKlasse:MeineKlasseVorlage { }
wird erst später implementiert...

Irgendwie muss ich das umstrukturieren... oder anders aufbauen... oder?

Alex

"Frank Dzaebel" <Po...@FranksSeite.de> schrieb im Newsbeitrag
news:ujDeOkYL...@tk2msftngp13.phx.gbl...

[Frank Dzaebel]

Hallo Alexander,

> public abstract class MeineKlasseVorlage
> { internal class MeineInnereKlasse
> { MeineKlasse mk = new MeineKlasse();}
> }

Wenn Du eine Klasse (hier MeineKlasse) erst später
implementieren willst, musst Du sie abstract machen.
Dann kannst Du aber keine Instanz von ihr erzeugen.
Es geht aber über Interfaces.

> Irgendwie muss ich das umstrukturieren... oder anders aufbauen... oder?

Wäre z.B. über Interfaces möglich:

// DLL.cs:
public abstract class MeineKlasseVorlage
{
internal class MeineInnereKlasse
{ MeineKlasse mk = new MeineKlasse();
}
internal class MeineKlasse : IMeinInterface
{ public void Fahren(){throw new Exception("not implemented.");}
}
}
public interface IMeinInterface
{ void Fahren();
}

// Aufruf.cs:

class MeineKlasse : MyDllName.IMeinInterface
{ public void Fahren()
{ MessageBox.Show("Meine Implementierung");
}
}

Du musst IMHO jetzt dem DLL-MeineKlasseVorlage-
Konstruktor die Instanz Deiner neu implementierten
MeineKlasse mitgeben.