Namespace-Alias in C#
Dieses Tutorial hilft Ihnen, das Konzept des Namespace-Alias in C# zu verstehen. Wir werden einen Demo-Code implementieren, um Ihnen zu helfen, dieses Konzept vollständig zu verstehen.
Namensraum in C#
In C# wird ein Namespace verwendet, um die Methoden, Klassen, Strukturen und Aufzählungen logisch zu organisieren, um sie effizient zu machen und den Umfang von Funktionen und Klassen zu steuern.
Typ- oder Namespace-Aliasing ist hilfreich, um Code leicht verständlich zu machen, und spart Entwicklern Zeit. Typaliasing ist nützlich, wenn Sie eine bestimmte Klasse oder Funktion aus einem einzelnen Namespace aliasieren möchten.
Das Schlüsselwort using ermöglicht uns den Zugriff auf diese Funktionalitäten in C#.
die Direktive using in C#
Die Compiler-Direktive using in C# kann verwendet werden, um einen Gültigkeitsbereich zu definieren. Es kann auch verwendet werden, um einen Alias für einen Namespace zu erstellen, statische Member einer Klasse zu importieren oder bestimmte Typen aus anderen Namespaces zu importieren.
Die Konsoleneingabe und -ausgabe ist die grundlegende Sache beim Programmieren. In C# wird die Klasse Console aus dem Namensraum System verwendet, um Konsolenoperationen durchzuführen, also Ein- oder Ausgaben.
Sie müssen es in C#-Projekten als using System verwendet haben, um auf WriteLine(), ReadLine() usw. zugreifen zu können.
Alias in C#
Alias hilft, mehrdeutige Anweisungen oder Klassen zu vermeiden, indem lange Namensraum-/Klassennamen durch kurze ersetzt werden. Es trainiert die ursprüngliche logische Funktionalität neu.
Der Entwickler kann einen Alias verwenden, um die Namespace-Funktionalität schneller und effektiver zu nutzen. Es hat keine nachteiligen Auswirkungen auf die Programmlaufzeit; vielmehr beschleunigt es die Entwicklungszeit.
Um das Konzept zu verstehen, erstellen wir zunächst ein einfaches C#-Konsolenprojekt und schreiben den folgenden Code, der keine Aliase verwendet.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace NamespaceAliasing {
class Program {
static void Main(string[] args) {
Console.WriteLine("Hi! I am a Console.WriteLine");
Console.Write("Let me know your good name: ");
var name = Console.ReadLine();
Console.WriteLine("Welcome: " + name);
Console.ReadKey();
}
}
}
Wenn Sie als Eingabe user eingeben, sieht die Ausgabe wie folgt aus.
Hi! I am a Console.WriteLine
Let me know your good name: user
Welcome: user
Wenn Sie ein C#-Konsolenprojekt in Visual Studio erstellen, werden einige grundlegende Namespaces selbst importiert. Wie Sie sehen können, werden das using System und andere Namensräume über der Quelldatei importiert.
Wenn Sie einen Namespace importieren, weiß der Compiler, dass Sie auf alle Mitgliedsklassen, Methoden und Variablen aus diesem Namespace zugreifen müssen. Durch Importieren des Namensraums System können Sie also auf die Methoden ReadLine(), WriteLine(), Write() zugreifen.
Lassen Sie uns nun einen Alias für die Klasse Console erstellen, damit wir ihn nicht immer eingeben müssen, während wir die zugehörigen Methoden aufrufen. Wir haben im folgenden Code einen Alias S für System.Console erstellt.
Jetzt können wir mit diesem Alias S auf die Konsolenmethoden zugreifen, anstatt Console einzugeben.
Es ist wichtig zu beachten, dass ein Alias nur ein anderer Name für einen Bezeichner ist, sodass der vorherige Bezeichner so funktioniert, als wäre er früher verfügbar gewesen.
Im folgenden Code ist beispielsweise System.Console weiterhin zugänglich und funktionsfähig wie vor der Deklaration eines Alias.
using S = System.Console;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace NamespaceAliasing {
class Program {
static void Main(string[] args) {
S.WriteLine("Hi! I am a S.WriteLine");
S.Write("Let me know your good name: ");
var name = S.ReadLine();
S.WriteLine("Welcome: " + name);
System.Console.WriteLine("I am Console.WriteLine");
S.ReadKey();
}
}
}
Ausgang:
Hi! I am a S.WriteLine
Let me know your good name: user
Welcome: user
I am Console.WriteLine
Eine andere Verwendung eines Alias ist, wenn Sie mehrere Klassen aus verschiedenen Namespaces verwenden müssen, aber Typen mit denselben Namen haben.
Sie können dies entweder implementieren, indem Sie den vollständigen Namen verwenden, der auf bestimmte Klassen verweist, oder Aliase für Namespaces und Zugriffstypen mithilfe von Aliasen erstellen.
Das folgende Beispiel zeigt ein Szenario, in dem zwei Namespaces Methoden mit demselben Namen haben.
using S = System.Console;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace NamespaceAliasing {
using Alias1 = NameSpace1.ClassOne;
using Alias2 = NameSpace2.ClassTwo;
class Program {
static void Main(string[] args) {
var object1 = new Alias1();
object1.Sample();
var object2 = new Alias2();
object2.Sample();
S.ReadKey();
}
}
}
namespace NameSpace1 {
public class ClassOne {
public void Sample() {
S.WriteLine("I am a Sample from Namespace1");
}
}
}
namespace NameSpace2 {
class ClassTwo {
public void Sample() {
S.WriteLine("I am a Sample from Namespace2");
}
}
}
Ausgang:
I am a Sample from Namespace1
I am a Sample from Namespace2
Das obige Code-Snippet hat zwei Namespaces namens NameSpace1 und NameSpace2. Beide haben Klassen namens ClassOne bzw. ClassTwo,.
Die Methoden aus beiden Namespaces haben denselben Namen, wenn wir sie also nur mit ihrem Namen aufrufen, also Sample(), kann der Compiler nicht angeben, aus welchem Namespace er aufgerufen wird.
Wir müssen die vollständige Referenz darauf angeben, indem wir Namespace1.ClassOne.Sample() für die korrekte Ausführung eingeben.
Es ist herausfordernd und mehrdeutig, wenn wir es mehrmals in unserem Code verwenden. Dieses Problem kann gelöst werden, indem Aliasse von Namespaces erstellt werden, wie wir sie im obigen Beispielcode erstellt haben.
Wir müssen nicht jedes Mal Namespace1.ClassOne.Sample eingeben; Stattdessen können wir die Aliase Alias1 und Alias2 verwenden.
Aliasing kann sich auf die statischen Member einer Klasse beziehen und sie mit ihren Namen verwenden, anstatt die gesamte Referenz einzugeben. Beispielsweise enthält die Klasse Math aus dem Namensraum System statische Funktionen wie Sqrt() und statische Elemente wie PI und E.
Im Folgenden finden Sie ein Beispiel für den Aufruf einer statischen Funktion aus einem anderen Namespace durch Erstellen eines Alias.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static NameSpace1.SampleClass;
namespace StaticAliasing {
class Program {
static void Main(string[] args) {
function1();
Console.ReadKey();
}
}
}
namespace NameSpace1 {
public class SampleClass {
public static void function1() {
System.Console.WriteLine("I am a static function.");
}
}
}
Ausgang:
I am a static function.
Stellen Sie sich vor, Sie müssten function1() im Laufe des Programms mehrmals verwenden. Wir müssen jedes Mal NameSpace1.SampleClass.function1 eingeben.
Aber jetzt können wir es beim Namen nennen. Weitere Informationen finden Sie unter using-Direktive in C#.