C# Getter Setter (Wie es für Entwickler funktioniert)

Getter und Setter sind wesentliche Konzepte in objektorientierten Programmiersprachen wie C#. Diese beiden Methoden ermöglichen es uns, den Zugriff auf und die Änderung von Klasseneigenschaften zu kontrollieren. In diesem Tutorial werden wir sowohl Anfänger als auch Fortgeschrittene Aspekte von C# Gettern und privaten Settern anhand von Codeblöcken untersuchen.

Einführung in Getter und Setter

Was sind Getter und Setter?

Im Grunde genommen sind Getter und Setter nichts anderes als gleichnamige Methoden in einer Klasse. Der Getter gibt den Wert einer privaten Feldvariablen zurück, während der Setter die Bedeutung der Variablen ändert. Diese Methoden stellen sicher, dass die internen Daten einer Klasse (felder) sicher und korrekt zugegriffen oder geändert wird.

Warum brauchen wir sie?

Stellen Sie sich vor, Sie haben eine "öffentliche Klasse car" mit einer "privaten Stringbeschreibung property name". Wenn jemand außerhalb dieser Klasse die Beschreibung wissen möchte, kann er nicht direkt darauf zugreifen, da sie privat ist. Hier kommt die Rolle der Getter und Setter ins Spiel.

Ein Getter würde es den Benutzern ermöglichen, den Wert einer "privaten Zeichenfolgenbeschreibung" abzurufen, ohne dass sie direkten Zugriff darauf haben, um sie zu ändern. Andererseits würde ein Setter den Benutzern die Möglichkeit geben, die implizite Parameterbeschreibung unter den von uns festgelegten Bedingungen zu ändern.

Zugriffsmodifikatoren

Zugriffsmodifikatoren definieren den Grad der Sichtbarkeit und Zugänglichkeit eines Feldes oder einer Eigenschaft von außerhalb der Klasse. Die am häufigsten verwendeten Modifikatoren sind public und private.

• öffentlich": Auf Felder oder Eigenschaften, die als "öffentlich" deklariert sind, kann von überall in Ihrem Programm zugegriffen werden. Sie könnten zum Beispiel eine Eigenschaft "public int age" haben, auf die jeder Teil Ihres Codes zugreifen und sie ändern kann.
• privat": Auf Eigenschaften oder Felder, die als privat deklariert sind, kann nur innerhalb der definierten Klasse zugegriffen werden, z. B. private int age. Diese Kapselung hilft, unbefugte Änderungen zu verhindern und stellt sicher, dass der interne Zustand der Klasse ordnungsgemäß beibehalten wird.

Einfache Getter und Setter

Lassen Sie uns mit einem einfachen Beispiel beginnen.

//set accessor
public class Person
{
    private string name;  // This is a private string name property variable

    public string GetName()   // This is the getter
    {
        return name;
    }

    public void SetName(string newName)   // This is the setter, new value
    {
        name = newName;
    }
}

static void Main()
{
    Person person = new Person();
    person.SetName("John");
    Console.WriteLine(person.GetName());
}

//set accessor
public class Person
{
    private string name;  // This is a private string name property variable

    public string GetName()   // This is the getter
    {
        return name;
    }

    public void SetName(string newName)   // This is the setter, new value
    {
        name = newName;
    }
}

static void Main()
{
    Person person = new Person();
    person.SetName("John");
    Console.WriteLine(person.GetName());
}

'set accessor
Public Class Person
	Private name As String ' This is a private string name property variable

	Public Function GetName() As String ' This is the getter
		Return name
	End Function

	Public Sub SetName(ByVal newName As String) ' This is the setter, new value
		name = newName
	End Sub
End Class

Shared Sub Main()
	Dim person As New Person()
	person.SetName("John")
	Console.WriteLine(person.GetName())
End Sub

In der obigen "Klasse Person" haben wir sowohl einen Getter (GetName) und ein Einrichter (SetName) für die Eigenschaft "Name". Wenn Sie die Methode static void Main ausführen, wird sie "John" ausgeben, da wir diesen Wert für den Namen mit dem Setter gesetzt haben.

Auto-Implementierte Eigenschaften

Nun werden Sie vielleicht denken: "Muss ich immer separate Methoden für Getter und Setter schreiben?" Die Antwort lautet "Nein" C# hat ein Konzept namens "automatisch implementierte Eigenschaften" oder "automatische Eigenschaften" eingeführt, um dies zu vereinfachen.

In C# können Sie automatische Eigenschaften verwenden, die Ihnen eine Kurzform für die Deklaration eines "privaten Feldes" und seiner zugehörigen Eigenschaft bieten. Hier ist ein Beispiel:

public class Student
{
    public string Name { get; set; } // This is an auto-implemented or automatic property, public string Name
    public string Title {get; set;}
}

static void Main()
{
    Student student = new Student();
    student.Name = "Alice";  // Using setter
    Console.WriteLine(student.Name);  // Using getter
}

public class Student
{
    public string Name { get; set; } // This is an auto-implemented or automatic property, public string Name
    public string Title {get; set;}
}

static void Main()
{
    Student student = new Student();
    student.Name = "Alice";  // Using setter
    Console.WriteLine(student.Name);  // Using getter
}

Public Class Student
	Public Property Name() As String ' -  This is an auto-implemented or automatic property, public string Name
	Public Property Title() As String
End Class

Shared Sub Main()
	Dim student As New Student()
	student.Name = "Alice" ' Using setter
	Console.WriteLine(student.Name) ' Using getter
End Sub

In der "Klasse" "Student" ist die Eigenschaft "Name" sowohl ein Getter als auch ein Setter, die automatisch implementiert werden. Der C#-Compiler erstellt hinter den Kulissen ein Feld "Private String Name", und die Eigenschaft Name ermöglicht den Zugriff auf dieses Feld.

Erweiterte Zugriffsmodifikatoren in Eigenschaften

Nur-Lese-Eigenschaften

Manchmal möchten Sie vielleicht eine Eigenschaft bereitstellen, die von außen gelesen, aber nicht verändert werden kann. In diesem Fall sind schreibgeschützte Eigenschaften sehr nützlich. Sie können den Setter in einer Eigenschaft weglassen, um sie schreibgeschützt zu machen.

Nehmen wir an, wir wollen eine schreibgeschützte Eigenschaft "String Description" zu unserer Klasse "Person" hinzufügen:

public class Person
{
    public string Name { get; set; }
    public string Description { get; }

    public Person(string name, string description)
    {
        Name = name;
        Description = description;
    }
}

public class Person
{
    public string Name { get; set; }
    public string Description { get; }

    public Person(string name, string description)
    {
        Name = name;
        Description = description;
    }
}

Public Class Person
	Public Property Name() As String
	Public ReadOnly Property Description() As String

	Public Sub New(ByVal name As String, ByVal description As String)
		Me.Name = name
		Me.Description = description
	End Sub
End Class

In diesem Beispiel kann die Eigenschaft Description nur im Konstruktor der Klasse Person mit weniger Code gesetzt werden. Einmal eingestellt, kann er nicht mehr von außen geändert werden.

Private Einrichter

Manchmal möchten Sie vielleicht zulassen, dass die Eigenschaft von außerhalb der Klasse gelesen, aber nur innerhalb der Klasse gesetzt werden kann. Dies wird durch ein "privates Set" erreicht.

public class Program
{
    public string Description { get; private set; }

    public Program()
    {
        Description = "This is a program about getters and setters.";
    }
}

class ProgramTest
{
    static void Main()
    {
        Program myProgram = new Program();
        Console.WriteLine(myProgram.Description);  // Allowed
        // myProgram.Description = "New Description";  // Not allowed
    }
}

public class Program
{
    public string Description { get; private set; }

    public Program()
    {
        Description = "This is a program about getters and setters.";
    }
}

class ProgramTest
{
    static void Main()
    {
        Program myProgram = new Program();
        Console.WriteLine(myProgram.Description);  // Allowed
        // myProgram.Description = "New Description";  // Not allowed
    }
}

Public Class Program
	Private privateDescription As String
	Public Property Description() As String
		Get
			Return privateDescription
		End Get
		Private Set(ByVal value As String)
			privateDescription = value
		End Set
	End Property

	Public Sub New()
		Description = "This is a program about getters and setters."
	End Sub
End Class

Friend Class ProgramTest
	Shared Sub Main()
		Dim myProgram As New Program()
		Console.WriteLine(myProgram.Description) ' Allowed
		' myProgram.Description = "New Description";  // Not allowed
	End Sub
End Class

In der Klasse "Programm" hat die Eigenschaft "Beschreibung" einen "privaten Satz", was bedeutet, dass sie von außerhalb der Klasse nicht geändert werden kann, wodurch die Integrität der Daten gewährleistet wird.

Vererbung und Overriding

Wenn Sie mit abgeleiteten Klassen arbeiten, können Sie die Getter- und Setter-Methoden außer Kraft setzen, um ihr Verhalten anzupassen. So können Sie beim Abrufen oder Setzen von Werten zusätzliche Logik hinzufügen.

public class Person
{
    public virtual string Name { get; set; }
}

public class Student : Person
{
    private string studentID;

    public override string Name
    {
        get { return base.Name; }
        set
        {
            if (!string.IsNullOrEmpty(value))
                base.Name = value;
        }
    }
}

public class Person
{
    public virtual string Name { get; set; }
}

public class Student : Person
{
    private string studentID;

    public override string Name
    {
        get { return base.Name; }
        set
        {
            if (!string.IsNullOrEmpty(value))
                base.Name = value;
        }
    }
}

Public Class Person
	Public Overridable Property Name() As String
End Class

Public Class Student
	Inherits Person

	Private studentID As String

	Public Overrides Property Name() As String
		Get
			Return MyBase.Name
		End Get
		Set(ByVal value As String)
			If Not String.IsNullOrEmpty(value) Then
				MyBase.Name = value
			End If
		End Set
	End Property
End Class

In diesem Beispiel erbt die Klasse "Student" von "Person" und überschreibt den Setter der Eigenschaft "Name". Es fügt eine Validierungsprüfung hinzu, bevor der Name gesetzt wird, um sicherzustellen, dass er nicht leer oder null ist.

Einführung der Iron Suite zur Verbesserung Ihrer C#-Entwicklung

Iron Suite ist eine Sammlung von Forschungswerkzeugen, die die C#-Entwicklungsfähigkeiten erheblich verbessern. Es umfasst IronPDF, IronXL, IronOCR und IronBarcode. Jedes dieser Tools dient einem bestimmten Zweck und kann in verschiedene Aspekte von C# integriert werden.

IronPDF - Ein leistungsfähiges PDF-Management-Tool

ironPDF ist eine Bibliothek, mit der Entwickler PDF-Dokumente in C# erstellen, lesen und bearbeiten können. Ob es sich um die Konvertierung von HTML in PDF mit dem hTML-zu-PDF-Tutorial oder die Verwaltung von PDF-Metadaten über Getter und Setter - IronPDF hat alles, was Sie brauchen.

IronXL - Excel-Bearbeitung leicht gemacht

Bei der Arbeit mit Excel-Dateien, ironXL vereinfacht den Lese- und Schreibvorgang. Mit diesem Tool können Sie die privaten und öffentlichen Strings oder Integer von Excel-Dateien manipulieren, ähnlich wie Sie Daten innerhalb einer Klasse mit der gleichen Syntax für Getter und Setter in C# behandeln können.

IronOCR - Optische Zeichenerkennung in C#

ironOCR ist eine Bibliothek zur optischen Zeichenerkennung, die Bilder in durchsuchbaren Text umwandelt. Wenn Ihre Anwendung das Lesen von Text aus gescannten Dokumenten beinhaltet, können die leistungsstarken Funktionen von IronOCR leicht integriert werden. Sie kann mit privaten Feldern und öffentlichen String-Beschreibungen umgehen, genau wie Sie es von der Klasse Person oder der Klasse Student aus dem vorherigen Beispiel erwarten würden.

IronBarcode - Bibliothek zum Lesen und Schreiben von Barcodes

IronBarcode ist ein unverzichtbares Werkzeug für Anwendungen, die das Lesen und Schreiben von Barcodes erfordern. Sie ermöglicht sowohl den direkten Zugriff auf Barcodedaten als auch die Anpassung durch automatische Eigenschaften, genau wie die in der C#-Programmierung verwendeten Getter und Setter.

Iron Suite und Getters and Setters

Das Iron Suite-Paket lässt sich nahtlos in die C#-Entwicklung integrieren, einschließlich Getter und Setter. Diese Tools sind für jedes C#-Projekt von großem Wert.

Schlussfolgerung

Zusammengefasst:

1. getter und Setter": Sie helfen, auf die privaten Felder einer Klasse zuzugreifen und sie zu ändern.

2. auto-Eigenschaften": Eine elegante Art, automatische Getter und Setter mit Hilfe von automatisch implementierten Eigenschaften zu haben.

3. zugangsmodifikatoren": Sie helfen bei der Feinabstimmung der Zugänglichkeit von Eigenschaften.

   Inzwischen sollten Sie ein solides Verständnis für die Verwendung von Gettern und Settern in C# haben.

   Die Tool-Suite von Iron Suite bietet C#-Entwicklern unglaubliche Funktionen. Jedes dieser Produkte, einschließlich IronPDF, IronXL, IronOCR und IronBarcode, wird mit einem kostenlos testenso können Sie diese leistungsstarken Bibliotheken ohne Anfangsinvestitionen erkunden und in Ihre Projekte integrieren.

   Wenn Sie bereit sind, sich zu verpflichten, beginnen die einzelnen Lizenzen mit $749. Wenn Sie feststellen, dass mehr als eines dieser Tools Ihren Anforderungen entspricht, können Sie die Möglichkeit nutzen, das komplette Iron Suite-Paket zum Preis von nur zwei Einzellizenzen zu erwerben.