Variablen in C#

In C# ist eine Variable ein Name, den wir dem Speicherort geben, und jede Variable hat einen angegebenen Typ, der die Art der Werte angibt, die in einer Variablen gespeichert werden können. Alle Variablen sollten vor ihrer Verwendung deklariert werden; Jede Variable hat einen bestimmten Typ, der über die Größe und den Bereich der Variablen entscheidet. Um eine Operation an Variablen durchzuführen, ist es wichtig, eine Variable mit einem bestimmten Datentyp zu definieren, um den Datentyp anzugeben, den die Variable in unserer Anwendung enthalten kann. Sehen wir uns ein paar grundlegende Dinge über Variablen an

• Variablen sind nichts anderes als eine Bezeichnung für Datenwerte.
• Variablen können den Wert bestimmter Datentypen enthalten, zum Beispiel int, string, float usw.
• Deklaration und Initialisierung von Variablen erfolgen in separaten Anweisungen.
• Variablen können durch mehrere, durch Komma getrennte Variablen sowie ein- und mehrzeilig bis zum Ende des Semikolons definiert werden.
• Werte müssen einer Variablen zugewiesen werden, bevor wir sie verwenden; Andernfalls wird ein Fehler bei der Kompilierung angezeigt.
• Der Wert einer Variablen kann jederzeit geändert werden, bis das Programm zugänglich ist.

Wie deklariere ich Variablen in C#?

Es gibt einige Regeln zum Deklarieren von C#-Variablen:

• Wir müssen einen Variablennamen mit der Kombination aus Zahlen, Buchstaben und Unterstrich definieren.
• Jeder Variablenname sollte mit Buchstaben oder Unterstrichen beginnen.
• Zwischen dem Variablennamen sollte kein Leerraum zulässig sein.
• Variablennamen sollten keine Reserveschlüsselwörter wie int, char, float usw. enthalten.

Die Syntax für die Variablendefinition in C#

<data_type> <variable_name>;
<data_type> <variable_name>=value;
<access_specifier><data_type> <variable_name>=value;

Hier ist ein Datentyp, bei dem die Variable die Typen Integer, Sting, Float usw. enthalten kann. ist der Name einer Variablen, die den Wert in unserer Anwendung enthält, und weist der Variablen einen bestimmten Wert zu und schließlich  wird verwendet, um Zugriffsberechtigungen für die Variable zu erteilen. Dies sind einige geeignete Methoden zur Beschreibung der Variablennamen in der Programmiersprache c#.

int name;
float value;
char _firstname;

Sie können eine Variable auch zum Zeitpunkt der Definition wie folgt initialisieren:

int value = 100;

Wie initialisiere ich Variablen in C#?

Um einer Variablen einen Wert zuzuweisen, der als Initialisierung bezeichnet wird, können Variablen durch den konstanten Ausdruck mit einem Gleichheitszeichen initialisiert werden, Variablen können auch bei ihrer Deklaration initialisiert werden.

Syntax:

<data_type> <variable_name> = value;

Oder

variable_name = value;

Zum Beispiel

int value1=5, value2= 7;
double pi= 3.1416;
char name='Rock';

Variablentypen in C# mit Beispielen

Es gibt verschiedene Arten von Variablen, wie zum Beispiel

1. Lokale Variablen
2. Instanzvariablen oder nichtstatische Variablen
3. Statische Variablen oder Klassenvariablen
4. Konstante Variablen
5. Schreibgeschützte Variablen

1. Lokale Variablen

Eine lokale Variable, die innerhalb einer Methode, eines Blocks oder eines Konstruktors definiert ist. Sobald die Variable deklariert ist, existieren diese Variablen nur innerhalb des Blocks und wir können nur innerhalb des Blocks auf diese Variablen zugreifen. Die Variable wird erstellt, wenn die Funktion aufgerufen oder der Block betreten wird, und sie wird einmal gelöscht, nachdem sie aus dem Block existiert oder während der Aufruf von der Funktion zurückkehrt.

Im Beispielprogramm ist die Variable „customer_age“ eine lokale Variable für die Funktion GetAge(). Der Compiler generiert einen Fehler, sobald wir die Variable customer_age außerhalb der Funktion GetAge() anwenden.

Beispielprogramm – Lokale Variablen

using System;
class CustomerEntry
{
public void GetAge()
{
int customer_age=0;         // local variable
customer_age= customer_age+28;
Console. WriteLine("Customer Age: "+ customer_age);
}
public static void Main(String[] args)
{
CustomerEntry _customerObj=new CustomerEntry();
_customerObj.GetAge();
}
}

Ausgabe:

2. Instanzvariablen oder nichtstatische Variablen

Instanzvariablen werden als nicht statische Variablen bezeichnet. Die Instanzvariablen werden in einer Klasse deklariert, jedoch außerhalb einer Methode, eines Blocks oder eines Konstruktors. Diese Variablen werden erstellt, sobald das Objekt einer Klasse erstellt wurde, und werden zerstört, wenn das Objekt zerstört wird. Beispielsweise können wir die Zugriffsspezifizierer für Variablen verwenden.

Im Programm sind die Instanzvariablen markEnglish, markMaths. Wir können mehrere Objekte erstellen, jedes der Objekte hat seine Kopie der Instanzvariablen.

Beispielprogramm – Instanzvariablen

using System;
class StudentMarks {
// instance variables
int markEnglish;
int markMaths;
int markPhysics;
public static void Main(String[] args) // Main Method
{
StudentMarks obj1 = new StudentMarks ();  //Object creation 1
obj1. markEnglish = 90;
obj1. markMaths = 80;
obj1. markPhysics = 93;
StudentMarks obj2 = new StudentMarks (); //Object creation 1
obj2. markEnglish = 95;
obj2. markMaths = 70;
obj2. markPhysics = 90;
Console.WriteLine("Marks Obtained from first object:");
Console.WriteLine(obj1. markEnglish);
Console.WriteLine(obj1. markMaths);
Console.WriteLine(obj1. markPhysics);
Console.WriteLine("Marks obtained from second object:");
Console.WriteLine(obj2. markEnglish);
Console.WriteLine(obj2. markMaths);
Console.WriteLine(obj2. markPhysics);
}
}

Ausgabe:

3. Statische Variablen oder Klassenvariablen

Eine statische Variable wird zu Beginn der Programmausführung erstellt und am Ende der Ausführung zerstört. Statische Variablen werden auch als Klassenvariablen bezeichnet. Für den Zugriff auf statische Variablen müssen wir kein Objekt der Klasse erstellen; Wir können einfach auf die Variable zugreifen als,

Class_name.variable_name;

Eine statische Variable wird mit dem Schlüsselwort static innerhalb einer Klasse oder außerhalb einer Methode oder eines Konstruktors deklariert.

Sample Program – Static Variable

using System;
class Employee
{
static double empSalary;
static string empName="Smith";
public static void Main(String[] args)
{
Employee.empSalary=100000;  // accessing the static variable
Console. WriteLine(Employee.empName+ "'s Salary:" + Employee.empSalary);
}
}

Output:

4. Constants Variables

Constant variables are similar to the static variables, once initialized and the one-time life cycle of a class and it does not need the instance of the class for initializing or accessing. The constant variable is declared by using the ‘const’ keyword, these variables cannot be altered once it declared, and it should be initialized at the time of the declaration part only.

Sample Program – Constant Variable

using System;
class Program_A
{
int x= 25; // instance variable
static int y= 35; // static variable
const float maxValue =75; // constant variable
public static void Main()
{
Program_A classObject= new Program_A(); // object creation
Console.WriteLine("Value of x : " + classObject.x);
Console.WriteLine("Value of y : " + Program_A.y);
Console.WriteLine("Value of max " + Program_A. maxValue);
}
}

Output:

5. Read-Only Variables

A read-only variable is declared using the keyword ‘read-only‘ and those variables cannot be altered like constant variables. The constant variable is an unchanging value for the entire class whereas read-only is a permanent value for a specific instance of a class. There is no compulsion to initialize a read-only variable at the time declaration, it can be initialized under constructor. The default value set to the variable is 0.

Sample Program – Read-Only

using System;
class Program_B
{
const float maxValue =75; // constant variable
readonly int x; // read-only variable
public static void Main()
{
Program_B classObject= new Program_B(); // object creation
Console.WriteLine("Value of max: " + Program_B. maxValue);
Console.WriteLine("Value of x : " + classObject.x);
}
}

Output:

Conclusion

Finally, you have known about how variables allow you to store data in different ways. In this article, we learned about how to declare and initialize variables and how to make use of it. I hope this article would have helped you out with the working process of variables.

Das obige ist der detaillierte Inhalt vonVariablen in C#. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!