Erstellen Sie die Auto-Eigenschaft in C#

1. Verwenden Sie Klassen, um die Auto-Eigenschaft in C# zu implementieren
2. Verwenden Sie die Mono.Reflection-Bibliothek oder das NuGet-Paket, um Werte zu unterstützenden Feldern der Auto-Eigenschaft in C# zuzuweisen
3. Erstellen Sie ein Klassenobjekt, um die Auto-Eigenschaft in C# zu ändern
4. Verwenden Sie die Kapselung, um eine schreibgeschützte oder schreibgeschützte automatische Eigenschaft in C# zu erstellen

Sie können eine Variable immer in eine Eigenschaft umgestalten und umgekehrt. Es gibt viele triftige Gründe, eine triviale Eigenschaft zu machen, denn wenn Sie sich auf Reflektion verlassen und Daten binden möchten, ist es einfacher, alle Eigenschaften zu verwenden. In diesem Lernprogramm erfahren Sie alles über die Auto-Eigenschaft und Möglichkeiten, sie in C# zu erstellen.

In der modernen C#-Programmierung ist die Verwendung von automatischen Eigenschaften eine hervorragende Vorgehensweise und die beste Option, um die Effizienz beim Schreiben von Code beizubehalten und gleichzeitig die Leistung und Best Practices beizubehalten.

Diese Eigenschaften stellen im Allgemeinen Methoden dar, können aber gut funktionieren, wenn sie in Schnittstellen implementiert werden. Diese Eigenschaften fungieren als Verträge, um das Vorhandensein bestimmter Methoden in jeder Schnittstelle, Klasse oder jedem Namensraum zu garantieren, der sie implementiert.

Verwenden Sie Klassen, um die Auto-Eigenschaft in C# zu implementieren

Ein geeigneter Weg, um automatische Eigenschaften zu initialisieren, ist die Verwendung von Klassen, d. H.:

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

Auf diese Weise wird der Code besser lesbar und verständlicher, da die Auto-Eigenschaften die Absicht vermitteln und Konsistenz gewährleisten. Außerdem sind sie der schnellste Weg, um Paare von get- und set-Methoden zu definieren.

Es wird oft als der beste Ansatz angesehen, automatische Eigenschaften zu definieren, da Ihr Code nicht neu kompiliert werden muss, wenn sich Ihr Code weiterentwickelt und Sie eine andere Logik einführen. Darüber hinaus ist die auto-Eigenschaft eine Codierungsverknüpfung, um Ihnen ein paar Tastenanschläge zu ersparen, indem Sie nur public string new_property {get; set;} und den Compiler standardmäßig den Rest generieren lassen.

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

Ausgang:

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

Seit C# Version 3.0 ist das Dilemma der objektorientierten Programmierung nicht mehr vorhanden. Mit private können Sie Zeilen überspringen und brauchen auch die Definitionen für die Methoden get und set nicht.

Zusammenfassend haben die Auto-Eigenschaften vielen Programmierern geholfen, ihre zu erkennen, und das Ergebnis war wartbarer Code. Es ist nicht unbedingt erforderlich, Felddeklarationen für die Methoden get und set zu verwenden, um die Felder zu modifizieren, da der Compiler jedes perfekt handhabt.

Es ist standardmäßig in der Funktionalität des Compilers, die privaten Felder zu erstellen oder zu generieren und die Zuordnung sicherzustellen. Zusätzlich füllt es die Methoden get und set, um das Lesen und Schreiben der spezifischen Felder zu ermöglichen, die zu den Auto-Eigenschaften gehören.

Verwenden Sie die Mono.Reflection-Bibliothek oder das NuGet-Paket, um Werte zu unterstützenden Feldern der Auto-Eigenschaft in C# zuzuweisen

Das Erstellen von Auto-Eigenschaften ist ein konkreterer Ansatz zum Erstellen von Eigenschaften, ohne dass zusätzliche oder ausführliche Logik in den Eigenschaftenzugriffsmethoden erforderlich ist.

Die anonymen Unterstützungsfelder von Auto-Eigenschaften können mit den Methoden get und set der Eigenschaft geändert werden. Die Eigenschaftsdeklaration ermöglicht es Ihnen, Code zu schreiben, der Objekte erstellen und Compilern ermöglichen kann, private Unterstützungsfelder zu erstellen.

Im Allgemeinen ist die Eigenschaft automatisch, wenn sie über ein vom Compiler generiertes Unterstützungsfeld verfügt, was Sie davor bewahrt, primitive Getter und Setter zu schreiben, die den Wert des Unterstützungsfelds zurückgeben oder ihm zuweisen müssen. Seine Syntax ist viel kürzer als das Erstellen einer allgemeinen Eigenschaft und erfordert eine öffentliche Klasse und einen öffentlichen String mit den Methoden get und set.

Das Attribut CompilerGenerated macht die Eigenschaft auto eindeutig, da ihr Name für Benutzer sichtbar ist, aber der Compiler den Hauptteil seiner Accessoren get und set generiert. Sie können den Hintergrundfeldern einer Auto-Eigenschaft Werte zuweisen; Dies wird jedoch nicht empfohlen und nicht als bewährte Methode angesehen, da dies die Leistung beeinträchtigt und die Sicherheit und den Schutz verringert, wodurch der Zweck der Erstellung dieser Eigenschaften in gewisser Weise zunichte gemacht wird.

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

Ausgang:

<name_company>k__BackingField, code_registration

Sie können einige Hilfsmethoden schreiben, Werte mithilfe von Reflektion zuweisen oder Objekten beim Komponententest erwartete Zustände zuweisen. Es wird empfohlen, den erwarteten Zustand einer Klasse direkt festzulegen, ohne die Setter aufzurufen, da dies eine Kette von Ereignissen starten kann, die beim Testen oder Optimieren Ihres Codes nicht wichtig sind.

Es ist wichtig, die Hintergrundfelder für automatische Eigenschaften zu finden, bevor Sie ihnen Werte zuweisen. Eine Idee ist, den BackingFieldResolver von Jb Evain zu verwenden und Ihrer Lösung das NuGet-Paket Mono.Reflection hinzuzufügen, um diese Bibliothek hinzuzufügen.

Wirf ArgumentException bei jeder Suche nach Hintergrundfeldern, um deinen Code effizienter zu machen und seine Lesbarkeit zu verbessern.

Erstellen Sie ein Klassenobjekt, um die Auto-Eigenschaft in C# zu ändern

Die Verwendung automatischer Eigenschaften kann die Anwendungsprogrammierschnittstellen zukunftssicher machen und die Datenbindung ermöglichen. Das Konzept der Auto-Property-Implementierung ist unter Verwendung der Klassenobjekte vollständig verständlich, und das Vornehmen von Änderungen an Objekten kann Ihr Verständnis der unterschiedlichen Verhaltensweisen der Auto-Eigenschaften verbessern.

Die Auto-Property-Accessoren (get- und set-Methoden) zum Ändern und Zugreifen auf Eigenschaften werden mit C# 3.0 eingeführt, und die Funktionalität dieser Eigenschaften wird durch die Einführung von init-Accessoren in der C# 9.0-Version weiter verbessert. Da Sie in Schnittstellen keine Auto-Eigenschaften deklarieren können, müssen Sie einen Körper definieren, der eine Klasse sein kann, und um eine Funktion oder ein Attribut aus der Auto-Eigenschaft aufzurufen, müssen Sie ein neues Klassenobjekt erstellen.

Ein Klassenobjekt kann Ihnen beim Zugriff auf die Auto-Eigenschaftselemente in einer Schnittstelle helfen und eröffnet den Entwicklern viele Möglichkeiten. Eine Möglichkeit, Auto-Eigenschaften und ihre Elemente zu initialisieren, ist die Verwendung von:

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

Dadurch können Ihre komplexen Klassen auch signifikantes Verhalten (Verhalten beinhaltet Methoden) und Daten enthalten.

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

Ausgang:

3360, Red_Dead, 9743822

Wenn Eigenschaftszugriffsmethoden keine zusätzliche Logik erfordern, werden dort automatische Eigenschaften verwendet und als public int some_property {get; set;}. Mit automatischen Eigenschaften können Sie etwas Prägnantes und Konkretes als Designphilosophie dahinter erstellen, z. B. Felder niemals als öffentlich verfügbar machen, sondern immer über Eigenschaften auf alles zugreifen.

Die Versionen 3.0 oder höher von C# ermöglichen Clientcode das Erstellen und Ändern von Objekten, was zu einer präziseren Eigenschaftendeklaration und der Erstellung leistungsstarker automatischer Eigenschaften führt. Die Entwicklung in Visual Studio erlaubt Breakpoints auf get und set, da Sie sie ändern können, ohne einen Vertrag mit dem Eigenschaftenaufrufer zu brechen, und Änderungen mithilfe von Reflektion aufgrund einer nicht offensichtlichen Änderungsquelle vornehmen können.

Verwenden Sie die Kapselung, um eine schreibgeschützte oder schreibgeschützte automatische Eigenschaft in C# zu erstellen

Die Verschlüsselung macht es einfach, Auto-Eigenschaften zu handhaben und zu ändern, aber Sie können immer noch Änderungen innerhalb der Klasse vornehmen, und sie ist nicht unveränderlich, da Sie immer noch durch Reflektion auf den privaten Setter zugreifen können. Ab C# 6.0 und höher können Sie echte schreibgeschützte und schreibgeschützte Auto-Eigenschaften erstellen.

Die schreibgeschützten automatischen Eigenschaften können unveränderliche Eigenschaften sein, die außerhalb des Konstruktors nicht geändert werden können:

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

Danach wird diese unveränderliche (schreibgeschützte) Eigenschaft zur Kompilierzeit etwa so:

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

Dadurch können Sie viel Zeit sparen, indem Sie den Code optimieren und den überschüssigen Code beenden. Sie müssen über ein grundlegendes Verständnis der Kapselung verfügen, um eine erfolgreiche automatische Eigenschaft zu erreichen, indem Sie Felder/Variablen als privat deklarieren und öffentliche get- und set-Methoden bereitstellen, um auf den Wert eines privaten Felds zuzugreifen und ihn zu aktualisieren.

Neben erhöhter Sicherheit und verbesserter Flexibilität können Sie mit den Auto-Eigenschaften Eigenschaften entweder schreibgeschützt (nur durch Verwendung der Methode get) oder schreibgeschützt (nur durch Verwendung der Methode set) machen.

Das direkte Zuweisen von Werten zu automatischen Eigenschaften scheint sauber und schön zu sein. Dennoch ist es eine Illusion, und nachdem Sie Code im Release-Modus erstellt, die Debug-Datenbank des Programms entfernt und die resultierende Bibliothek mit einem Decompiler geöffnet haben, werden Sie den Unterschied sehen.

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

Ausgang:

3360, Red_Dead, 9743822

Da es so viele Reibungen zwischen Variablen und Eigenschaften gibt, hat Kevin Dente eine neue Syntax eingeführt, public property int example_var;, da die Eigenschaften genau dasselbe tun wie Variablen, aber mit einer besseren granularen Kontrolle über die Sichtbarkeit. Die Auto-Eigenschaften sollten leichtgewichtig sein und können in explizite Methoden umgestaltet werden, wenn sie erheblichen Aufwand erfordern.

Die auto-Eigenschaft ist effektiver als die reguläre Eigenschaft und kein Anti-Pattern, da sie auch die gleichen Optimierungen wie die reguläre Eigenschaft erhält; Der einzige Unterschied besteht darin, dass Unterstützungsfelder automatisch generiert werden. In diesem Tutorial haben Sie gelernt, wie Sie die Auto-Eigenschaft in C# definieren, optimieren und ändern.