Zugriff auf Variable anderer Klasse

Hallo,

ich habe 3 Klassen (aufgeteilt in 3 cs-Files):

FHC_Main.cs

class FHC_Main
    {
        static void Main(string[] args)
        {
            CommandLineCheck commandLineCheck = new CommandLineCheck();
            commandLineCheck.DoCommandLineCheck();

            Logger logger = new Logger();
            logger.log();
        }
    }

CommandLineCheck.cs

internal class CommandLineCheck
    {
        public static string log;
        public void DoCommandLineCheck() 
        {
                log = @"D:\Entwicklung\temp\logfile.txt";
        }
    }

Logger.cs

internal class Logger
    {
        public void log()
        {
                System.IO.StreamWriter LogToFile = new System.IO.StreamWriter(CommandLineCheck.log, append: true);
                LogToFile.WriteLine("TEST");
                LogToFile.Close();
        }
    }

Ich habe also in der Klasse "CommandLineCheck" die Variable "log" als public static string definiert und kann dann aus der Klasse "Logger" darauf zugreifen (CommandLineCheck.log).
Das funktioniert einwandfrei...

Ich frage mich aber, ob "man das so macht" oder ob es da keine elegantere Methode gibt...
Ich brauche den Inhalt von "log" in der Logger-Klasse, evtl. aber auch in anderen Klassen.
Ich hätte gerne "log" als globale Variable...

Ist das was ich hier tue der richtige Weg oder kann man das eleganter machen?

Danke euch!
Arti

Nein macht man nicht so, denn das ist nicht die Grundidee von Objektorientierte Programmierung - auch sowas wie "globale Variablen" sollte es nicht geben. Sehr klares Zeichen für Spaghetti-Code.
Der Code von Dir offenbart ein bisschen, dass Du die Grundlagen von OOP nich nicht so im Griff hast. Da würde die Investition in ein Tutorial und Lektüre sehr gut tun 😉

Eine Situation, wie Du sie hast, sind simple Abhängigkeiten, und in OOP arbeitet man mit Instanzen.
Der Trick ist also, dass beim Erstellen des Loggers Optionen mitgegeben, wobei die Optionen selbst eine eigene Klasse sind.

public class LoggerOptions
{
    public string LogPath { get; set; }
}

public class LoggerProvider
{
    private readonly LoggerOptions _options;

    public LoggerProvider(LoggerOptions options)
    {
        _options = options;
    }

    public async Task WriteLog()
    {
        // _options.LogPath ist hier nun verfügbar.
    }
}

Dann kannst Du den Logger sehr simpel erstellen - und brauchst nirgends irgendwelche Workarounds wie Global oder static.

LoggerOptions options = new LoggerOptions() { LogPath = @"D:\Entwicklung\temp\logfile.txt" };
LoggerProvider logger = new(options);

Und den Logger kannst Du nun überall übergeben, wo er benötigt wird - ohne dass zB Deine CommandLineCheck die Implementierung von LoggerProvider kennen muss.
Aber das sind wirklich absolute OOP Basics - das lernt man auf den ersten 10 Seiten eines Einsteigertutorials 🙂

PS: einen Logger musst Du nicht selbst schreiben, vor allem da seine Stream Lösung wie diese sehr Ineffizient ist.
Logging - .NET
Der funktioniert sogar so ähnlich wie der hier gezeigte Aufbau.

Schau dir mal Serilog an.

Serilog ist "nur" ein Provider für Logging - .NET (und dessen Interfaces).
Für Serilog muss man aber zwingend ILogger verstehen; daher der Reihe nach lieber anfangen, wenn es schon an OOP hapert 🙂