Vererbung und Klassen-Hierarchie zur Laufzeit ändern

Hallo und noch einmal ich

geht sowas ähnliches wie das folgende zur laufzeit?

if(bZMDMCB)
{
    public class ComZMD31015: ComZMDMCB
	{}
}
else
{
    public class ComZMD31015: andreKlasse
	{}
}

Für vorschläge wäre ich dankbar

was willst du damit machen?

das geht nicht 😉 und wenn es gehen würde, würde ich sowas nicht benutzen wollen

Ich will die Struktur, die da gegeben ist nutzen um mit anderer Hardware, die in der Baseklasse definiert ist, weiterzuverwenden.

Hallo Knackes,

schreib doch einfach zwei verschiedene Klassen und verwende nur die jeweils passende davon.

Hallo Aurion,

ich weiß nicht, wie sehr sich die Klassen ähneln, aber wenn sie das tun sollten, bedeutet dein Vorschlag wg. der Redundanz Mehraufwand beim Warten der Klassen.

m0rius

Genau darum geht es
egal wie die geerbte klasse darunter aussieht, sollen Sie die Befehle, die in der Erbenden klasse stehen beibehalten werden, da sie egal welche hardware am ende angeschlossen ist diese befehlstruktur an die GUI weitergeben, die sich nicht verändern darf

Hallo,

Wenn die Klasse ComZMD31015 den "Gemeinsammen" Code enthält solltest du vielleicht einfach diese Klasse als Basiklasse verwenden g.

Grüße, Tachyon

Mit geänderter Hardware andern sich die Commands, die an diese geschickt werden, die befehle, für die ausführung nach oben bleiben aber die selbe

Ich verstehe die Problemstellung nicht.

Was für Funktionalitäten stellen die 3 erwähnten Klassen denn zur Verfügung, wo sind die Gemeinsamkeiten, wo sind die Unterschiede?

Edit:

Vielleicht ganz allgemein:

Die Basisklasse stellt ja gemeinsamme Funktionalität zur Verfügung und bietet die Möglichkeit abstrakte Member zu definieren, die dann von den Speziellen Klassen implementiert werden müssen.

Diese abstrakten Member können auch schon in der Basisklasse verwendet werde.

Das heißt, wenn du spezielle Funktionen hast, deklarierst du diese über abstrakte Methoden in der Basisklasse und implementierst sie in den speziellen Klassen.

Somit kannst du dann unterschiedliche Instanzen vom Typ der Basisklasse erstellen (über die speziellen Klassen) die jeweils anderen Code ausführen.

Hallo Knackes,

Hier für gibt es zwei Möglichkeiten:

1. Wenn sich nur die zu senden den Daten ändern, kannst du diese als "Property" implementieren.

public class [...]
{
  // hier die unterschiedlichen zusammenstellungen der Signal-Daten
  public static readonly ISignaldaten AnderesSignale = new Signaldaten("aaa",...);
  public static readonly ISignaldaten BZMDMCBSignale = new Signaldaten("a_a",...);

  public ISignaldaten Signaldaten{get;set;}

  public void FunktionA()
  {
    // hier die zugewiesenen Daten senden. Die können Variiert werden
    this.SendeAnHardWare(this.Signaldaten.ADaten);
  }
  public interface ISignaldaten
  {
    string ADaten{get;}
    ...
  }
}

2. Wenn sich die Signale grundsätzlich Unterscheiden kann man das Strategie-Pattern anwenden:

public class [...]
{
  public void [...]()
  {
    this.HardwareSteuerung.FuehreAktionAAus();
  }
}
public interface IHardwareSteuerung
{
  void FuehreAktionAAus();
}
public class AndereHardwareSteuerung : IHardwareSteuerung
{
  public FuehreAktionAAus()
  {
    // hier kommt der Hardware-Spezifische Teil
    this.Sende("AAA");
    this.Wait(10);
    this.Sende("BBB");
  }
}
public class BZMDMHardwareSteuerung : IHardwareSteuerung
{
  public FuehreAktionAAus()
  {
    // hier kommt  die andere Hardware-Steuerung, die sogar total anders sein
    this.Sende("B");
    this.Sende("Z");
    this.Sende("M");
    this.Sende("D");
    this.Sende("M");
  }
}

Im Zweifelsfall verwende das Pattern.

Gruß
Juy Juka

Vielen Dank,
Genau das scheint mir die richtige vorgehensweise zu sein.

Jetzt müsste ich nur noch wissen, wie ich EVENTS von der unteren schicht über das Interface and die consumierende Klasse übergeben kann.

Für ale anregungen bin ich dankbar

Hallo Knackes,

Events kannst du auch in ein Interface schreiben.

Siehe auch [FAQ] Eigenen Event definieren.

herbivore

In einer meiner Klassen hier

public class ComZMDMCB:IMCBZMD
	{

habe ich einen EVENT mit

		public delegate void ErrorAccurred ( string strErrorReturn );
		public event ErrorAccurred ComZMDMCBError;

und

void MyLayer_ReceiveError ( string strErrorCode )
		{
			if ( ComZMDMCBError != null )
				ComZMDMCBError( strErrorCode );
		}

implementiert

Im Interface definiere ich

	public delegate void ErrorAccurred ( string strErrorReturn );
public interface IMCBZMD
	{
                #region events
		event ErrorAccurred ComZMDMCBError;
		#endregion
        }

Beim Kompilieren knallts dann

Mit

Fehler 1 "ZMDSeries.ComZMDMCB" implementiert den Schnittstellenmember "ZMDSeries.IMCBZMD.ComZMDMCBError" nicht. "ZMDSeries.ComZMDMCB.ComZMDMCBError" hat nicht den entsprechenden Rückgabetyp "ZMDSeries.ErrorAccurred" und kann "ZMDSeries.IMCBZMD.ComZMDMCBError" daher nicht implementieren. E:\Eigene Daten\Visual Studio 2008\Projects\tAdv31xSeries\clAdv31xSerie\clADV31xSerie.cs 10 15 clAdv31xSerie

HILFE

Hallo Knackes,

soweit ich das sehen, hast du ErrorAccurred zweimal definiert. Einmal innerhalb der Klasse und einmal innerhalb des Interfaces. Und die Compilermeldung sagt ja auch aus, dass das Interface nicht (richtig) implementiert wurde, weil der Rückgabetyp falsch ist. Wenn du dir mal den vollqualifizierenden Typnamen denkst, hast du in der Klasse als Rückgabetyp nicht IMCBZMD.ErrorAccurred, sondern ComZMDMCB.ErrorAccurred (und genau DAS steht auch in der Compilermeldung).

Gruß,
dN!3L

P.S.: Sollte es nicht ErrorOccurred heißen?

Das mit dem Interface und Event habe ich immer noch nicht ganz gerafft

Wo muss ich die Deklaration des Events machen

Im Interface darf ich nicht

Danke für die Hilfe

Du darfst den delegate NICHT noch mal in deiner Klasse definieren, da er ja schon in der Interface-Datei existiert.

Hallo Knackes,

Im Interface selbst darf das Event nur deklariert werden. Die Implementierung selbst erfolgt dann in der Klasse die das Interface implementiert.

Wie gesagt, wenn du gemeinsame Funktionalität hast kannst du anstelle der Interfaces auch eine abstrakte Basisklasse verwenden. Das hat den Vorteil das du die "gemeinsamme" Funktionalität nicht doppelt implementieren musst.

Implementierung im Interface:

// Deklaration der Event-Property.
event EventHandler<AnyEventArgs> AnyEvent;

Implementierung in der Klasse die das Interface implementiert:

// Deklaration des events
private event EventHandler<AnyEventArgs> myAnyEvent;

[...]

// Implementierung der Event-Property
public EventHandler<AnyEventArgs> AnyEvent
{
  add
  {
    this.myAnyEvent += value;
  }
  remove
  {
    this.myAnyEvent -= value;
  }
}

// Edit: Fehler im Codebeispiel behoben