Definir el alias de tipo en C#

1. Utilice la directiva using alias para definir el tipo de alias en C#
2. Utilice la palabra clave espacio de nombres para definir el alias de tipo en C#
3. Usar herencia para definir el tipo de alias en C#
4. Utilice los paquetes NuGet para definir el tipo de alias en C#

Un alias de tipo es algo así como typedefs esencial para la programación segura de tipos y para crear un nuevo tipo semánticamente idéntico a un tipo existente. C# no ofrece un alias de tipo incorporado; sin embargo, puede usar directivas, clases y herencia de C# para crear tipos personalizados.

En este tutorial, aprenderá las cuatro formas principales de crear y definir alias de tipo en C#.

Cada método tiene limitaciones, como el uso de la herencia para crear un alias de tipo que no funcionará para los tipos primitivos. Como resultado, no puede derivar de las clases selladas y la mayoría de las clases .NET están selladas.

Utilice la directiva using alias para definir el tipo de alias en C#

La palabra clave using está en el corazón de las funciones relacionadas con el alias de tipo en C# o .NET. Aclara a los programadores cómo utilizar las propiedades de alias, hacer que su código sea flexible y mejorar su legibilidad.

Su capacidad para definir el alcance de los objetos a su disposición lo hace extremadamente eficiente; es una parte importante de la creación de un alias para un espacio de nombres. Puede llevar a los programadores a importar miembros de una sola clase con la directiva estática o importar tipos específicos de otros espacios de nombres.

Lo que es más importante, el alias de tipo resuelve la ambigüedad al evitar importar un espacio de nombres completo y facilita el trabajo con varios tipos. Además, el uso de alias permite la creación de alias globales que funcionan en proyectos de C#; pasar un tipo de parámetro le permite crear alias de tipos genéricos, por ejemplo, using type_alias = System.IO.StreamWriter y para el alias genérico de un tipo:

using type_generic = System.Nullable<System.Int32>

Código de ejemplo:

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!");
      }
    }
  }
}

Producción :

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

Usar typedef es otro enfoque para crear un alias de tipo, pero hace que el proceso sea extremadamente complejo. Para simplificarlo, debe usar el patrón de plantilla curiosamente recurrente.

Ignorando los métodos complejos y basados en situaciones que incluyen, “sintaxis lambda” y typedef, puede definir un tipo de delegado usando GenericHandler EventHandler<EventData> o gcInt.MyEvent += en Visual Studio porque proporciona una completa Firma de manejo de eventos IntelliSense.

// 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# proporciona formas de introducir nombres más cortos para cosas como using Console = System.Console;. Estos accesos directos no tienen sus propias identidades y pueden llamarse alias, lo que permite que un tipo existente tenga un nombre diferente.

El alias no introduce nuevos tipos, por lo que verá símbolos decorados con sus nombres originales en el depurador, lo que puede resultar confuso pero bueno y eficiente.

La directiva using es un equivalente perfecto de typedef; sin embargo, es importante crear un alias para un tipo genérico para cerrarlo después de una operación exitosa porque es increíblemente dañino dejar el tipo abierto. Es importante resolver los parámetros de tipo dentro de la directiva using antes de intentar algo como using NullableThing<T> = System.Nullable<T>;.

Utilice la palabra clave espacio de nombres para definir el alias de tipo en C#

Los espacios de nombres usan clases, lo que los convierte en una forma perfecta de definir el alias de tipo. El alias de tipo o espacio de nombres se denomina directiva using alias, como using Project = style.custom.myproject;.

Los espacios de nombres pueden ser definidos por el usuario o por el sistema, y una directiva de “uso” no le da acceso a ningún espacio de nombres anidado en el espacio de nombres que especifique. Los espacios de nombres facilitan el uso de los miembros privados de una clase al definir el alias de tipo en público como using example = Innerclass; y declarando el esquema como Outerclass::example inner;.

Código de ejemplo:

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

Producción :

You are in type_newClass.custom_class.

Usar herencia para definir el tipo de alias en C#

El uso de la herencia es un concepto similar, por ejemplo, class ComplexList : List<Tuple<int, string, int>> {} y el alias namespace es una forma de obtener un código C# sin conflictos. La herencia es una opción para hacer un nuevo tipo, una instancia de otro tipo.

La herencia beneficia al usar las características de las subclases, pero en cualquier otro caso, esto agrega sobrecarga, direccionamiento indirecto, lentitud y falta de confiabilidad. La herencia no es un alias, pero puede dar resultados similares en algunos casos condicionales.

El enfoque de alias de nombre puede obligarlo a redefinirlo en todas partes, lo que resulta en un código menos legible. La herencia es una mejor opción en caso de que agregue alguna funcionalidad a la clase base, algo como:

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

Además, la herencia de IEnumerable hace que la clase se pueda utilizar en operaciones enumerables y le permite definir completamente el comportamiento de todas las clases.

Código de ejemplo:

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

Producción :

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

Utilice los paquetes NuGet para definir el tipo de alias en C#

Un alias de tipo no se limita a un solo archivo de código fuente o bloque de espacio de nombres, ya que normalmente puede declararlos en archivos de encabezado como globales y miembros de clase. Para evitar la verbosidad del tipo, puede declarar nombres concisos en funciones, especialmente cuando usa código genérico como HashMap<TKey, TValue>.

Estos alias se pueden crear una vez y compartir en todo el proyecto, y sus plantillas van más allá, lo que le permite crear alias que no se resuelven en un tipo concreto.

El uso de paquetes NuGet para escribir alias puede evitar una gran cantidad de duplicación de código y dar nombres a pasos intermedios como mapa que vive entre el muy genérico HashMap<TKey, TValue> y el muy concreto LocationMap.

El LikeType le brinda el comportamiento GenericClass<int> como una biblioteca de código abierto y un paquete NuGet que puede utilizar para escribir alias en C#. Lo que es más importante, no olvide agregar el paquete NuGet Kleinware.LikeType 3.00 a su proyecto C# en Visual Studio porque using Kleinware.LikeType; pertenece a este paquete y ofrece una especie de funcionalidad typedef a su proyecto C#.

Código de ejemplo:

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

Producción :

Successful! Requires self-observation.

Este tutorial le enseñó diferentes formas optimizadas de creación de alias en C#. Puede usar estos enfoques para crear aplicaciones de C# más robustas pero limpias.

Puede aprender mucho de los cuatro ejemplos técnicos que demuestran los casos de uso principales para el alias de tipo y cómo podrían beneficiar sus aplicaciones.