Optionale Parameter & Konstanten

Wieder einmal bin ich nicht der erste der dieses Thema aufgreift. Ich finde das Thema hat aber einen eigenen Eintrag verdient.

Nehmen wir mal an wir haben ein Projekt, das aus zwei Assemblys besteht. Die eine soll unsere Hauptanwendung repräsentieren und in der anderen sind Konstanten für diese definiert.

Unsere Hauptanwendung ist eine kleine Konsolenapplikation:

1
2
3
4
5
6
static void Main(string[] args)
{
    Console.WriteLine("Value 1: " + Constants.Constants.value1);
    Console.WriteLine("Value 2: " + Constants.Constants.value2);
    Console.ReadLine();
}

Die Konstanten werden in der zweiten Assembly wie folgt definiert

1
2
3
4
5
public class Constants
{
    public const int value1 = 10;
    public const int value2 = 3;
}

Nehmen wir nun an, wir hätten diese High-End Anwendung an unsere Kunden ausgeliefert. Jetzt stellen wir aber fest, dass uns bei den Konstanten ein Fehler unterlaufen ist. Eigentlich hätten die Konstanten mit anderen Werten vorbelegt werden sollen. Hmm. Damit wir nicht die ganze Anwendung neu ausliefern müssen ändern wir nur die Konstanten, kompilieren diese Assembly und tausche diese bei unseren Kunden aus.

1
2
3
4
5
public class Constants
{
    public const int value1 = 5;
    public const int value2 = 4;
}

Die neue DLL ist nun bei unserem Kunden und wir sind glücklich – der Kunde allerdings nicht. Warum? Beim Kunden wird immer noch ’10‘ und ‚3‘ ausgegeben. Wir haben die Werte doch geändert, also was ist da passiert?
Nehmen wir doch mal unsere Konsolenanwendung und sehen uns den generierten Code an.

1
2
3
4
5
6
private static void Main(string[] args)
{
    Console.WriteLine("Value 1: " + 10);
    Console.WriteLine("Value 2: " + 3);
    Console.ReadLine();
}

Wie man sieht werden die Konstanten beim Kompilieren durch ihre eigentlichen Werte ersetzt. Somit hat eine nachträgliche Änderung der Konstanten-Assembly keine Auswirkung auf die Anwendung – erst wenn die Anwendung selbst neu kompiliert wird, werden die neuen Werte übernommen. Jetzt stellt sich die Frage wie man das umgehen kann? Definiert man die Konstanten wie folgt, tritt das Problem nicht auf:

1
2
3
4
5
public class Constants
{
    public static readonly int value1 = 10;
    public static readonly int value2 = 3;
}

Das bringt mich gleich zum nächsten Thema: Optionale Parameter. Auch hier gibt es etwas zu beachten. Die Voraussetzungen sind ähnlich wie beim ersten Beispiel. Wir haben wieder eine Konsolenapplikation und eine weitere Assembly in der wir unsere Funktionen auslagern.

Die Konsolenapplikation:

1
2
3
4
5
6
7
static void Main(string[] args)
{
    Functions functions = new Functions();
    functions.WriteValues();
    functions.WriteValues("My Hello");
    Console.ReadLine();
}

Die Assembly mit den Funktionen:

1
2
3
4
public void WriteValues(string value1 = "Hello", string value2 = " ", string value3 = "World")
{
    Console.WriteLine(String.Concat(value1, value2, value3));
}

Gleiches Spiel wie vorher. Anwendung ist ausgeliefert und wir stellen fest, dass wir leider bei den Funktionen andere Standardwerte angeben wollten. Wieder ändern wir die Werte in der Assembly ab und tauschen beim Kunden nur diese Assembly aus. Auch hier hat der Kunde mit der neuen Assembly wieder wenig Freude. Startet er nämlich die Applikation mit den neuen Standardwerten, wird in seiner Anwenung weiterhin Hello World und My Hello World ausgegeben. Den Grund dafür sehen wir wieder am schnellsten, wenn wir uns den generierten Code in der Anwendung ansehen:

1
2
3
4
5
6
7
private static void Main(string[] args)
{
    Functions functions = new Functions();
    functions.WriteValues("Hello", " ", "World");
    functions.WriteValues("My Hello", " ", "World");
    Console.ReadLine();
}

Wie auch schon bei den Konstanten sehen wir, dass im Aufrufer plötzlich die Werte stehen, die in der Aufzurufenden Funktion als Standard angegeben waren. Sprich das Austauschen der Funktionsbibliothek hat keinerlei Auswirkung auf die Hauptanwendung, da diese alle drei Parameter an die Funktion übergibt.


Einzelne Assemblys in einer Anwendung auszutauschen klappt in der Regel ganz gut, wenn man sich im Klaren ist, dass jede Regel ihre Ausnahmen hat …

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert