Crear la propiedad automática en C#

1. Usar clases para implementar la propiedad automática en C#
2. Use la biblioteca Mono.Reflection o el paquete NuGet para asignar valores a los campos de respaldo de la propiedad automática en C#
3. Crear objeto de clase para modificar la propiedad automática en C#
4. Use la encapsulación para crear propiedades automáticas de solo lectura o solo escritura en C#

Siempre puede refactorizar una variable en una propiedad y viceversa. Hay muchas razones válidas para crear una propiedad trivial porque si confía en la reflexión y desea vincular datos, es más fácil usar todas las propiedades. En este tutorial, aprenderá todo lo relacionado con la propiedad automática y las formas de crearla en C#.

En la programación moderna de C#, el uso de propiedades automáticas es una gran práctica y la mejor opción para mantener la eficiencia en la escritura de código mientras se mantiene el rendimiento y las mejores prácticas.

Estas propiedades generalmente representan métodos, pero pueden funcionar bien cuando se implementan en interfaces. Estas propiedades funcionan como contratos para garantizar la presencia de ciertos métodos dentro de cualquier interfaz, clase o espacio de nombres que los implemente.

Usar clases para implementar la propiedad automática en C#

Una forma adecuada de inicializar las propiedades automáticas es mediante el uso de clases, es decir:

public class my_class {
  public int my_property { get; set; }
}

De esta forma, el código se vuelve más legible y más fácil de entender, ya que las propiedades automáticas transmiten la intención y garantizan la coherencia. Además, son la forma más rápida de definir pares de métodos get y set.

A menudo se considera el mejor enfoque para definir propiedades automáticas porque a medida que su código evoluciona e introduce una lógica diferente, su código no necesita volver a compilarse. Además, la propiedad automática es un atajo de codificación para ahorrarle algunas pulsaciones de teclas con solo escribir public string new_property {get; set;} y dejar que el compilador genere el resto por defecto.

using System;
using System.Windows.Forms;

namespace auto_property {
  public class NetworkDevice {
    public string IP { get; set; }  // custom types | represent elements and belongs to the property
    public string drr_add { get; set; }
    public string num_serial { get; set; }
  }

  // pre-defined part of the Windows Form
  public partial class Form1 : Form {
    public Form1() {
      // initialize the design or other components created at design time
      InitializeComponent();
    }

    // represents the on-click event for the button to create the auto property
    private void button1_Click(object sender, EventArgs e) {
      NetworkDevice new_device = new NetworkDevice();
      new_device.IP = "Red_dead Search 12-D Class A";
      new_device.drr_add = "NYC, New York";
      new_device.num_serial = "S11-E2237654-C";

      MessageBox.Show(
          $"The device name: {new_device.IP} \nThe location: {new_device.drr_add} \nThe serial: {new_device.num_serial}",
          "Auto Property", MessageBoxButtons.OKCancel, MessageBoxIcon.Warning);
    }
  }
}

Producción :

The device name: Red_dead Search 12-D Class A
The location: NYC, New York
The serial: 511-E2237654-C

Desde la versión 3.0 de C#, el dilema de la programación orientada a objetos ya no está presente. Puede omitir líneas con privado y tampoco necesita las definiciones para los métodos get y set.

En conclusión, las propiedades automáticas ayudaron a muchos programadores a reconocerlas y el resultado fue un código mantenible. No es un requisito principal usar la declaración de campo para los métodos get y set para modificar los campos, ya que el compilador maneja cada uno perfectamente.

Está por defecto en la funcionalidad del compilador crear o generar los campos privados y asegurar el mapeo. Además, completa los métodos get y set para permitir la lectura y escritura de los campos específicos que pertenecen a las propiedades automáticas.

Use la biblioteca Mono.Reflection o el paquete NuGet para asignar valores a los campos de respaldo de la propiedad automática en C#

La creación de propiedades automáticas es un enfoque más concreto para crear propiedades sin necesidad de una lógica adicional o detallada en los elementos de acceso a las propiedades.

Los campos de respaldo anónimos de las propiedades automáticas se pueden modificar utilizando los métodos get y set de la propiedad. La declaración de propiedad le permite escribir código que puede crear objetos y permitir que los compiladores creen campos de respaldo privados.

En general, la propiedad es automática si tiene un campo de respaldo generado por el compilador, lo que le evita tener que escribir getters y setters primitivos que deben devolver el valor del campo de respaldo o asignárselo. Su sintaxis es mucho más corta que crear una propiedad general y requiere una clase pública y una cadena pública con los métodos get y set.

El atributo CompilerGenerated hace que la propiedad automática sea única ya que su nombre es visible para los usuarios, pero el compilador genera el cuerpo de sus descriptores de acceso get y set. Puede asignar valores a los campos de respaldo de una propiedad de automóvil; sin embargo, no se recomienda hacerlo y no se considera una práctica recomendada porque afecta el rendimiento y disminuye la seguridad y la protección, lo que, en cierto sentido, elimina el propósito de crear estas propiedades en primer lugar.

using System;
using System.Windows.Forms;

using Mono.Reflection;  // include after installing `Mono.Relection 2.0.0` NuGet package for your C#
                        // project

namespace auto_property {
  public class mono_exp {
    public const string name_official = "Great organization name with an excellent track record!";

    public string name_company { get; } = name_official;

    private string code_registration;

    // to assign new values to the `code_registration`
    public string pri_reg {
      get { return code_registration; }   // read
      set { code_registration = value; }  // write
    }

    // to read-only as an output
    public string name_display {
      // return the new value of `code_registration`
      get {
        return name_company + ": " + code_registration;
      }
      set {}  // empty
    }
  }
  public partial class Form1 : Form {
    public Form1() {
      InitializeComponent();
    }

    private void button1_Click(object sender, EventArgs e) {
      var company_name =
          typeof(mono_exp).GetProperty(nameof(mono_exp.name_company)).GetBackingField();

      var registration_no =
          typeof(mono_exp).GetProperty(nameof(mono_exp.pri_reg)).GetBackingField();

      MessageBox.Show($"{company_name.Name}, {registration_no.Name}", "Auto Property",
                      MessageBoxButtons.OKCancel, MessageBoxIcon.Warning);
    }
  }
}

Producción :

<name_company>k__BackingField, code_registration

Puede escribir algunos métodos auxiliares, asignar valores mediante la reflexión o asignar estados esperados a los objetos cuando los prueba unitariamente. Se recomienda establecer el estado esperado de una clase directamente sin llamar a los establecedores porque hacerlo puede iniciar una cadena de eventos que no son importantes para probar u optimizar su código.

Es crucial encontrar los campos de respaldo para las propiedades automáticas antes de asignarles valores. Una idea es usar el BackingFieldResolver de Jb Evain y agregar el paquete NuGet Mono.Reflection a su solución para agregar esta biblioteca.

Lance ArgumentException en cada búsqueda de campos de respaldo para que su código sea más eficiente y mejore su legibilidad.

Crear objeto de clase para modificar la propiedad automática en C#

El uso de propiedades automáticas puede hacer que las interfaces de programación de aplicaciones estén preparadas para el futuro y hacer posible el enlace de datos. El concepto de la implementación de propiedades automáticas es completamente comprensible utilizando los objetos de clase, y realizar cambios en los objetos puede mejorar su comprensión de los diferentes comportamientos de las propiedades automáticas.

Los accesores automáticos de propiedad (métodos get y set) para modificar y acceder a las propiedades se introducen con C# 3.0, y la funcionalidad de estas propiedades se mejora aún más con la introducción de accesores init en la versión C# 9.0. Como no puede declarar propiedades automáticas en las interfaces, debe definir un cuerpo que pueda ser una clase, y para llamar a cualquier función o atributo desde la propiedad automática, debe crear un nuevo objeto de clase.

Un objeto de clase puede ayudarlo a acceder a los elementos de propiedades automáticas en una interfaz y abre muchas posibilidades a los desarrolladores. Una forma de inicializar las propiedades automáticas y sus elementos es mediante:

public string {get; set;} = "example_text"

Hacerlo también permite que sus clases complejas contengan un comportamiento significativo (el comportamiento incluye métodos) y datos.

using System;
using System.Windows.Forms;

namespace auto_property {
  public class new_element {
    public double element_ip { get; set; }
    public string element_serial { get; set; }
    public int element_drr { get; set; }

    public new_element(double IP_add, string ser_no, int counter_ddr) {
      element_ip = IP_add;
      element_serial = ser_no;
      element_drr = counter_ddr;
    }
  }
  public partial class Form1 : Form {
    public Form1() {
      InitializeComponent();
    }

    private void button1_Click(object sender, EventArgs e) {
      new_element element_new = new new_element(2860.01, "Red_Dead", 9743822);
      element_new.element_ip += 499.99;

      MessageBox.Show(
          $"{element_new.element_ip}, {element_new.element_serial}, {element_new.element_drr}",
          "Auto Property", MessageBoxButtons.OKCancel, MessageBoxIcon.Warning);
    }
  }
}

Producción :

3360, Red_Dead, 9743822

Cuando los accesores de propiedad no requieren ninguna lógica adicional, ahí es donde se usan las propiedades automáticas y se definen como public int some_property {get; set;}. Las propiedades automáticas le permiten crear algo conciso y concreto como la filosofía de diseño detrás de ellas, por ejemplo, nunca exponer los campos como públicos pero siempre acceder a todo a través de las propiedades.

Las versiones 3.0 o posteriores de C# permiten que el código del cliente cree y modifique objetos, lo que lleva a una declaración de propiedades más concisa y a la creación de propiedades automáticas de alto rendimiento. El desarrollo en Visual Studio permite puntos de interrupción en get y set, ya que puede modificarlos sin romper ningún contrato con la persona que llama a la propiedad y realizar cambios mediante la reflexión debido a una fuente de cambio no obvia.

Use la encapsulación para crear propiedades automáticas de solo lectura o solo escritura en C#

El cifrado facilita el manejo y la modificación de propiedades automáticas, pero aún puede realizar cambios dentro de la clase y no es inmutable, ya que aún puede acceder al setter privado a través de la reflexión. A partir de C# 6.0 y versiones posteriores, puede crear verdaderas propiedades automáticas de solo lectura y solo escritura.

Las propiedades automáticas de solo lectura pueden ser propiedades inmutables que no se pueden cambiar fuera del constructor:

public string new_property { get; }
public new_class() {
  this.new_property = "something";
}

Luego, esta propiedad inmutable (solo lectura) en tiempo de compilación se convertirá en algo como esto:

readonly string new_name;
public string new_property {
  get { return this.new_name; }
}
public new_class() {
  this.new_name = "something";
}

Como resultado, hacerlo puede ahorrarle mucho tiempo al optimizar el código y eliminar el exceso de código. Debe tener una comprensión básica de la encapsulación para lograr una propiedad automática exitosa declarando campos/variables como privados y proporcionando métodos públicos get y set para acceder y actualizar el valor de un campo privado.

Además de una mayor seguridad y una mayor flexibilidad, las propiedades automáticas pueden permitirle crear propiedades de solo lectura (solo con el método get) o de solo escritura (solo con el método set).

La asignación directa de valores a las propiedades automáticas parece limpia y hermosa. Aún así, es una ilusión, y después de compilar el código en el modo de lanzamiento, eliminar la base de datos de depuración del programa y abrir la biblioteca resultante con un descompilador, verá la diferencia.

using System;
using System.Windows.Forms;

namespace auto_property {
  public class new_element {
    /*

    // write only auto property example

    private int _int;
    public int _newint
    {
        set { _int = value; }
    }

     */
    public double element_ip { get; set; }
    public string element_serial { get; }  // read-only
    public int element_drr { get; }        // read-only

    public new_element(double IP_add, string ser_no, int counter_ddr) {
      element_ip = IP_add;
      element_serial = ser_no;
      element_drr = counter_ddr;
    }
  }
  public partial class Form1 : Form {
    public Form1() {
      InitializeComponent();
    }

    private void button1_Click(object sender, EventArgs e) {
      new_element element_new = new new_element(2860.01, "Red_Dead", 9743822);
      element_new.element_ip += 499.99;  // modification

      MessageBox.Show(
          $"{element_new.element_ip}, {element_new.element_serial}, {element_new.element_drr}",
          "Auto Property", MessageBoxButtons.OKCancel, MessageBoxIcon.Warning);
    }
  }
}

Producción :

3360, Red_Dead, 9743822

Como hay tanta fricción entre las variables y las propiedades, Kevin Dente introdujo una nueva sintaxis, public property int example_var;, ya que las propiedades hacen lo mismo que las variables pero con un mejor control granular sobre la visibilidad. Las propiedades automáticas deben ser livianas y se pueden refactorizar en métodos explícitos si requieren un esfuerzo significativo.

La propiedad automática es más efectiva que la propiedad normal y no es antipatrón, ya que también recibe las mismas optimizaciones que la normal; la única diferencia es que los campos de respaldo se generan automáticamente. Este tutorial le enseñó cómo definir, optimizar y modificar la propiedad automática en C#.