Definieren Sie den Typalias in C#

1. Verwenden Sie die Direktive using alias, um den Typ-Alias in C# zu definieren
2. Verwenden Sie das Schlüsselwort namespace, um den Typ-Alias in C# zu definieren
3. Verwenden Sie Vererbung, um den Typ-Alias in C# zu definieren
4. Verwenden Sie die NuGet-Pakete, um den Typ-Alias in C# zu definieren

Ein Typ-Alias ist so etwas wie typedefs, das für die typsichere Programmierung und zum Erstellen eines neuen Typs, der mit einem vorhandenen Typ semantisch identisch ist, unerlässlich ist. C# bietet keinen integrierten Typalias; Sie können jedoch C#-Direktiven, -Klassen und -Vererbung verwenden, um benutzerdefinierte Typen zu erstellen.

In diesem Tutorial lernen Sie die vier wichtigsten Methoden zum Erstellen und Definieren von Typaliasnamen in C# kennen.

Jede Methode hat Einschränkungen, z. B. funktioniert die Verwendung der Vererbung zum Erstellen von Typaliasen nicht für primitive Typen. Infolgedessen können Sie nicht von den versiegelten Klassen ableiten, und die meisten .NET-Klassen sind versiegelt.

Verwenden Sie die Direktive using alias, um den Typ-Alias in C# zu definieren

Das Schlüsselwort using ist das Herzstück von Type-Alias-bezogenen Features in C# oder .NET. Es verdeutlicht Programmierern, wie sie Aliasing-Eigenschaften verwenden, Ihren Code flexibel gestalten und seine Lesbarkeit verbessern können.

Seine Fähigkeit, den Umfang der ihm zur Verfügung stehenden Objekte zu definieren, macht es äußerst effizient; Dies ist ein wichtiger Teil beim Erstellen eines Alias für einen Namespace. Es kann Programmierer dazu bringen, Mitglieder einer einzelnen Klasse mit der statischen Direktive zu importieren oder bestimmte Typen aus anderen Namespaces zu importieren.

Am wichtigsten ist, dass Typalias Mehrdeutigkeiten auflöst, indem vermieden wird, einen ganzen Namespace zu importieren, und es einfach ist, mit mehreren Typen zu arbeiten. Darüber hinaus ermöglicht der using alias die Erstellung globaler Aliase, die über C#-Projekte hinweg funktionieren; Das Übergeben eines Parametertyps ermöglicht es Ihnen, generische Typen zu aliasieren, z. B. using type_alias = System.IO.StreamWriter und für den generischen Alias eines Typs:

using type_generic = System.Nullable<System.Int32>

Beispielcode:

using System;
using System.Windows.Forms;

using stream_writer = System.IO.StreamWriter;  // custom type

namespace type_alias {
  public partial class Form1 : Form {
    public Form1() {
      InitializeComponent();
    }

    private void button1_Click(object sender, EventArgs e) {
      string[] type_data = { "Name: Widow's Sorrow", "Assignment: APK-1229-C", "Success Ratio: 78%",
                             "Charisma: 11%", "Style: Professional" };

      using (stream_writer type_alias = new stream_writer(@"C:\Temp\MyFile.txt")) {
        foreach (string line in type_data) {
          type_alias.WriteLine(line);
          // for compile purposes; MessageBox.Show(line);
        }
        MessageBox.Show("Process completed!");
      }
    }
  }
}

Ausgang:

Name: Widow's Sorrow
Assignment: APK-1229-C
Success Ratio: 78%
Charisma: 11%
Style: Professional

Die Verwendung von typedef ist ein weiterer Ansatz zum Erstellen eines Typ-Alias, aber es macht den Prozess extrem komplex. Um es zu vereinfachen, müssen Sie das Curiously Recurring Template Pattern verwenden.

Wenn Sie die komplexen und situativen Methoden einschließlich lambda syntax und typedef ignorieren, können Sie einen Delegattyp definieren, indem Sie GenericHandler EventHandler<EventData> oder gcInt.MyEvent += in Visual Studio verwenden, da es eine vollständige IntelliSense-Event-Handling-Signatur.

// you can define a type alias for specific types as follows:

using stream_writer = System.IO.StreamWriter                    // create stream writer object
                      using file_stream = System.IO.FileStream  // create file stream object

                                          // you can define generic alias for a type as follows:

                                          using alias_int = System.Nullable<System.Int32>;
using alias_double = System.Nullable<System.Double>;

C# bietet Möglichkeiten, kürzere Namen für Dinge wie using Console = System.Console; einzuführen. Diese Abkürzungen haben keine eigenen Identitäten und können als Aliase bezeichnet werden, sodass ein vorhandener Typ einen anderen Namen haben kann.

Der Alias führt keine neuen Typen ein, weshalb Sie im Debugger Symbole sehen, die mit ihren ursprünglichen Namen verziert sind, was verwirrend sein kann, aber gut und effizient ist.

Die Direktive using ist ein perfektes Äquivalent zu typedef; Es ist jedoch wichtig, einen Alias für einen generischen Typ zu erstellen, um ihn nach einer erfolgreichen Operation zu schließen, da es unglaublich schädlich ist, den Typ offen zu lassen. Es ist wichtig, Typparameter innerhalb der Direktive using aufzulösen, bevor Sie etwas wie using NullableThing<T> = System.Nullable<T>; versuchen.

Verwenden Sie das Schlüsselwort namespace, um den Typ-Alias in C# zu definieren

Die Namespaces verwenden Klassen, was sie zu einer perfekten Möglichkeit macht, Typenaliase zu definieren. Typ- oder Namespace-Alias wird als using alias-Direktive bezeichnet, wie using Project = style.custom.myproject;.

Namespaces können benutzerdefiniert oder systemdefiniert sein, und eine using-Direktive gibt Ihnen keinen Zugriff auf Namespaces, die in dem von Ihnen angegebenen Namespace verschachtelt sind. Die Namespaces machen es einfach, die privaten Member einer Klasse zu verwenden, indem Typaliase öffentlich definiert werden, wie z. B. using example = Innerclass; und die Gliederung wie Outerclass::example inner; deklarieren.

Beispielcode:

using System;
using System.Windows.Forms;

using class_alias = type_newClass.custom_class;
using typealias_using = namespace_alias.custom_class<int>;

namespace type_newClass {
  public class custom_class {
    public override string ToString() {
      return "You are in type_newClass.custom_class.";
    }
  }

}

namespace namespace_alias {
  class custom_class<T> {
    public override string ToString() {
      return "You are in namespace_alias.custom_class.";
    }
  }
}

namespace type_alias {
  using type_newClass;    // use directive for namespace `type_newClass`
  using namespace_alias;  // use the directive for namespace `namespace_alias`
  public partial class Form1 : Form {
    public Form1() {
      InitializeComponent();
    }

    private void button1_Click(object sender, EventArgs e) {
      class_alias inst_typealias_one = new class_alias();
      MessageBox.Show(inst_typealias_one.ToString());

      typealias_using inst_typealias_two = new typealias_using();
      MessageBox.Show(inst_typealias_two.ToString());
    }
  }
}

Ausgang:

You are in type_newClass.custom_class.

Verwenden Sie Vererbung, um den Typ-Alias in C# zu definieren

Die Verwendung von Vererbung ist ein ähnliches Konzept, z. B. class ComplexList : List<Tuple<int, string, int>> {} und das namespace-Aliasing ist eine Möglichkeit für einen kollisionsfreien C#-Code. Vererbung ist eine Option, um einen neuen Typ zu erstellen, eine Instanz eines anderen Typs.

Vererbungsvorteile Sie verwenden die Funktionen von Unterklassen, aber in jedem anderen Fall fügt dies Overhead, Umwege, Langsamkeit und Unzuverlässigkeit hinzu. Die Vererbung ist kein Aliasing, kann aber in einigen bedingten Fällen zu ähnlichen Ergebnissen führen.

Der Namens-Aliasing-Ansatz kann Sie dazu zwingen, ihn überall neu zu definieren, was zu weniger lesbarem Code führt. Vererbung ist eine bessere Option, falls Sie der Basisklasse einige Funktionen hinzufügen, etwa so:

public class SoldierList : System.Collections.Generic.List<Soldier> {...}

Darüber hinaus macht die Vererbung von IEnumerable die Klasse in aufzählbaren Operationen verwendbar und ermöglicht es Ihnen, das gesamte Klassenverhalten vollständig zu definieren.

Beispielcode:

using System;
using System.Windows.Forms;
using System.Collections.Generic;

namespace type_alias {
  // a simple approach
  class ComplexList : List<Tuple<int, string, int>> {}

  // more complex approach - enhances its usability
  public class Person {
    public string Name { get; set; }
    public int Age { get; set; }
    public int FavoriteNumber { get; set; }

    public Person() {}

    public Person(string name, int age, int favoriteNumber) {
      this.Name = name;
      this.Age = age;
      this.FavoriteNumber = favoriteNumber;
    }
  }

  public class PersonList : List<Person> {}  // most-refined

  public partial class Form1 : Form {
    public Form1() {
      InitializeComponent();
    }

    private void button1_Click(object sender, EventArgs e) {
      var complexList = new ComplexList();  // for first approach
      var personList = new PersonList();    // for second approach

      /*
       type your code or program something based on the
       new types you created
       */

      MessageBox.Show(
          "Some function is performed successfully by creating a type alias using inheritance!",
          "Type Alias", MessageBoxButtons.OKCancel, MessageBoxIcon.Warning);
    }
  }
}

Ausgang:

Some function is performed successfully by creating a type alias using inheritance!

Verwenden Sie die NuGet-Pakete, um den Typ-Alias in C# zu definieren

Ein Typalias ist nicht auf eine einzelne Quellcodedatei oder einen Namensraumblock beschränkt, da Sie sie üblicherweise in Header-Dateien als Globals und Klassenmitglieder deklarieren können. Um Typausführlichkeit zu vermeiden, können Sie knappe Namen in Funktionen deklarieren, insbesondere wenn Sie generischen Code wie HashMap<TKey, TValue> verwenden.

Diese Aliase können einmal erstellt und im gesamten Projekt gemeinsam genutzt werden, und ihre Vorlagen gehen sogar noch weiter, sodass Sie Aliase erstellen können, die sich nicht in einen konkreten Typ auflösen lassen.

Die Verwendung von NuGet-Paketen zur Eingabe von Aliasnamen kann eine Menge Codeduplizierung verhindern und Zwischenschritten Namen geben, wie etwa map, das zwischen dem sehr generischen HashMap<TKey, TValue> und dem sehr konkreten LocationMap lebt.

Der LikeType gibt Ihnen das GenericClass<int>-Verhalten als Open-Source-Bibliothek und ein NuGet-Paket, das Sie für Typ-Alias in C# verwenden können. Vergessen Sie vor allem nicht, das NuGet-Paket Kleinware.LikeType 3.00 zu Ihrem C#-Projekt in Visual Studio hinzuzufügen, da das using Kleinware.LikeType; gehört zu diesem Paket und bietet Ihrem C#-Projekt eine Art typedef-Funktionalität.

Beispielcode:

// install `Kleinware.LikeType 3.00` NuGet Package before the program's execution

using System;
using System.Windows.Forms;
using System.Collections.Generic;

using Kleinware.LikeType;  // belongs to the `Kleinware.LikeType 3.00`

namespace type_alias {
  // type_alias creation
  public class SomeInt : LikeType<int>  // inherits the integer properties
  {
    public SomeInt(int value) : base(value) {}  // represents the base value
  }

  public partial class Form1 : Form {
    public Form1() {
      InitializeComponent();
    }

    private void button1_Click(object sender, EventArgs e) {
      /*
       some example C# code that benefits from `Kleinware.LikeType 3.00`
       */
      MessageBox.Show("Successful! Requires self-obervation.", "Type Alias",
                      MessageBoxButtons.OKCancel, MessageBoxIcon.Information);
    }
  }
}

Ausgang:

Successful! Requires self-observation.

In diesem Tutorial haben Sie verschiedene optimierte Aliasing-Methoden in C# kennengelernt. Sie können diese Ansätze verwenden, um robustere und dennoch saubere C#-Anwendungen zu erstellen.

Sie können viel aus den vier technischen Beispielen lernen, die die wichtigsten Anwendungsfälle für Typ-Alias demonstrieren und zeigen, wie sie Ihren Anwendungen zugute kommen könnten.