Porperties auf Basis- und abgeletete Klassen

[CopWorker]

Hallo,

ich habe eine Basisklasse.

public class CSSqlTable

Von der Basisklasse leite ich mehrere Klassen ab, wie z.Bsp.:

class CSMatVerb : CSSqlTable

Sowohl in der Basisklasse als auch in den abgeleiteten Klassen benötige ich ein Instanz zum Zweck des TraceLoggings.

private TraceLog clTrace;

Über die Properities kann ich nach Instanzierung der Basisklasse bzw. der abgeleiteten Klassen die TraceLogging Instanz den Klassen überlassen.

CSMatVerb clMatVerb = new CSMatVerb();
clMatVerb.Trace = clDbMain.Trace;

//Property der Basisklasse "CSSqlTable"
public TraceLog TraceLocal
{
    set => clTrace = value; //<--- Incomming
}

//Property der abgeleiteten Klasse "CSMatVerb"
public TraceLog TraceLocal
{
    set => clTrace = value; //<--- Incomming
}

Nur bei der Übergabe der TraceLogging Instanz an die Properties gelangt die Instanz nur an die Basisklasse.

Frage: Kann ich mit nur einer Übergabe an die Properties die TraceLogging Instanz auch an beide Klassen übergeben?

Vielen Dank im Voraus.
Grüße CopWorker

 

[Zvoni]

Ich glaube was du suchst ist eine "class variable"
Class Variables in C# - SyntaxDB - C# Syntax Reference
Müsste also Public Static in der Basis-Klasse sein
Würdest dann eine TraceLogging-Instanz für alle Klassen (inkl. abgeleiteter Klassen) haben

 

[CopWorker]

Hallo Zvoni,

tut leider nicht.
Ehrlich gesagt, bringt mir der Link nicht viel.
Ich weiß nicht ob ich die Instanzen der TraceLogging Klassen oder
die Properties auf "static" setzen soll. Oder beide.
Alles ausprobiert.
Schade, aber trotzdem vielen Dank für deine Mühe.

Grüße von CopWorker

 

[Zvoni]

Soweit ich es verstanden habe (und ich es auch aus FreePascal kenne):
Nur die Property der Basis-Klasse auf Public Static

EDIT: Habs gerade gesehen: Hast du eine eigene Property TraceLog TraceLocal in deinen abgeleiteten Klassen?
Bin kein Dot-Net'ler, aber würde da nicht ein Override passieren? Also die "lokale" Property verdeckt die Property der Basisklasse?

 

[CopWorker]

Hallo Zvoni,

genau das passiert dann, ein Override.
Ich kann auch der Basisklasse und der abgeleiteten Klasse ein Property.
Aber jeweils mit anderem Namen, das müsste auch gehen.

Grüße von CopWorker

 

[Zvoni]

Oder du lässt in den abgeleiteten Klassen die Property ganz weg, deklarierst in der Basisklasse die Property "Public Static" (womit sie dann auch in den abgeleiteten Klassen verfügbar sein müsste), und dann kannst du die Tests fahren:
Zuweisung der Property auf eine Instanz der Basisklasse, und schau nach ob die Property in der Instanz einer abgeleiteten Klasse gesetzt ist, und umgekehrt.

In FreePascal habe ich das meist so gemacht, dass ich zusätzlich eine "class variable" HasLog:Boolean in der Basisklasse habe. Dieses Flag wird auf True gesetzt, sobald der Property etwas gültiges zugewiesen wird
Aircode (Hab keine Ahnung von C#)

//Property der Basisklasse "CSSqlTable"
public static Boolean HasLog;

public static TraceLog TraceLocal
{
    set => clTrace = value; //<--- Incomming
    set => HasLog = True;
}

In der abgeleiteten Klasse ist es dann einfach zu prüfen

IF MyCSMatVerbInstanz.HasLog Then DoSomething

 

[CopWorker]

Hallo Zvoni,

das mit "static" tut auch nicht so richtig.
Ich habe jetzt nur in der Basisklasse die Property eingerichtet.
Und die Instanz "clTrace" im Property auf "get" und "set" deklariert.

public TraceLog Trace
{
    get => clTrace; //---> Outgoing
    set => clTrace = value; //<--- Incomming
}

Somit kann in von der abgeleiteten Klasse auf die Property (get) der Basisklasse zugreifen.
Einen anderen Weg scheint es nicht zu geben.

Wenn du noch eine weitere Lösung findest, kannst du gerne
diesen Beitrag erweitern.

Vielen Dank nochmals,
Grüße von CopWorker

 

[Spyke]

Ev. schaust du dir mal Trace an
Trace Klasse (System.Diagnostics)

den Trace beim start des Programmes ein Listener mit übergeben zum wegschreiben in eine Datei oder so und du kannst normal mit dem .Net Tracing arbeiten

Trace Listeners

(im Projekt muss nur die Eisntellung für Ausgabe der Trace gesetzt sein, ist meist schon vorbelegt)

 

[Zvoni]

Ansonsten hätte ich gesagt:
Jungfräuliches Projekt starten,
eine Basisklasse mit einer "class Property" (bsp. eine Integer) ausstatten, 2-3 Klassen davon ableiten, und dann rumtesten (property-Integer hoch-/runterzählen mit Ausgabe) wenn du auf die einzelnen jeweiligen Instanzen zugreifst

 

[Spyke]

für einen eigenen globalen statischen TraceLog der überall in der Anwendugn aufrufbar ist
(pseudocode, ausm kopf geschrieben)

public sealed class TraceLog
{
   private TraceLog(meineParameter)
   {
     .....
   }

   public void WriteLog(string text)
   {
      ...
   }

   public static void InitialiceLog(meineParameter)
   {
           if(MeinLog != null)
              throw new InvalidOperationException("Log bereits initialisiert")
      
        MeinLog=new TraceLog(meineParameter);
   }

   public static TraceLog MeinLog {get; private set; }
}

...

//beim ersten start des programmes aufrufen
TraceLog.InitialiceLog(dieParameter);

...
//später im programmverlauf
TraceLog.MeinLog.WriteLog("hallo welt")