Typ-Aliase definieren

Eine Funktion von Pascal, die ich sehr nützlich fand, war die Möglichkeit, einen Datentyp zu benennen, z

type
 person: record
             name: string;
             age: int;
         end;

var
 me: person;
 you: person;

etc

Können Sie etwas Ähnliches in C # tun? Ich möchte in der Lage sein, so etwas zu tun

using complexList = List<Tuple<int,string,int>>;

complexList peopleList;
anotherList otherList;

Wenn ich also die Definition des Datentyps ändern muss, kann ich dies an einem Ort tun.

Unterstützt C # einen Weg, dies zu erreichen?

Es ist nicht genau das, was Sie in Pascal tun, aber Sie können die using-directive verwenden. Schauen Sie sich hier an, wie man es benutzt

Beispiel:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using MyList = Dummy2.CompleXList;

namespace Dummy2
{
    public class Person 
    {
    }

    public class CompleXList : List<Person> 
    { 
    }


    class Program
    {
        static void Main(string[] args)
        {
            MyList l1 = new MyList();
        }
    }
}

Ja es ist möglich. Du kannst schreiben:

using System;
using System.Collections.Generic;

namespace ConsoleApplication12
{
    using MyAlias = List<Tuple<int, string, int>>;
}

oder, wenn außerhalb des Namespace deklariert:

using System;
using System.Collections.Generic;

using MyAlias = System.Collections.Generic.List<System.Tuple<int, string, int>>;

namespace ConsoleApplication12
{
}

Verwenden Sie es dann als Typ:

MyAlias test = new MyAlias();

Sie können einen Typ erstellen:

class ComplexList : List<Tuple<int,string,int>> { }

Dies ist nicht unbedingt dasselbe wie ein Alias, aber in den meisten Fällen sollten Sie keine Unterschiede feststellen.

Was ist mit Vererbung?

class ComplexList : List<Tuple<int, string, int>> {}

var complexList = new ComplexList();

Dies scheint ein ähnliches Konzept zu sein, aber es gibt kein direktes Äquivalent eines typbasierten Alias ​​in C #, sondern nur Namespace-Aliase .

Wenn Sie vermeiden möchten, dass Typnamen in Ihrem Code zusammenstoßen, ist Namespace-Aliasing der richtige Weg.

Wenn Sie einen neuen Typ erstellen möchten, der eine Instanz eines anderen Typs ist, ist die Vererbung eine Option.

Aus der in der ersten Frage gezeigten Syntax geht hervor, dass Sie wirklich nur fragen, wie eine Klasse in C # erstellt wird und nicht, wie ein Typ aliasisiert wird.

Wenn Sie einen einfacheren Namen eingeben möchten als List<Tuple<int,string,int>>und "global" (dh nicht pro Datei), würde ich eine neue Klasse erstellen, die diese Klasse erbt und keine zusätzlichen Mitglieder deklariert. So was:

public class MyTrinaryTupleList: List<Tuple<int,string,int>> { }

Dies gibt einen einzigen Verwaltungsstandort und erfordert keine zusätzlichen using-Anweisungen.

Ich würde jedoch auch noch einen Schritt weiter gehen und wagen, dass Sie wahrscheinlich kein Tupel wollen, sondern eine andere Klasse, wie zum Beispiel:

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; 
    }
}

Und dann können Sie für Ihren Listentyp Folgendes tun:

public class PersonList: List<Person> { }

Wenn Sie andere listenspezifische Hilfseigenschaften oder -methoden benötigen, können Sie diese auch der PersonList-Klasse hinzufügen.

Ja, Sie können dies tun, müssen jedoch die vollständigen Typen angeben, dh die Definition lautet:

using ComplexList = System.Collections.Generic.List<System.Tuple<int,string,int>>;

Dies wird pro Datei angegeben, ähnlich wie bei den using-Anweisungen für Namespaces.

nitpick: Herkömmlicherweise ist ein Typ in .NET PascalCased.

Nur eine einfache Verwendung würde reichen:

using Foo = System.UInt16;

public class Test {
  public Foo Bar { get;set; }
}