C#-Referenzen

Ein Speicherort einer Variablen kann mithilfe eines Parameters referenziert werden, der in C# als Referenzparameter bezeichnet wird. Sie unterscheiden sich von Parametern, die als Wertparameter bezeichnet werden und bei denen die Werte als Parameter übergeben werden und für diese Werte ein neuer Speicherort erstellt wird. In Referenzparametern wird für diese Parameter kein Speicherplatz zugewiesen, da nur die Referenz dieser Parameter übergeben wird und die Referenzparameter mithilfe des Schlüsselworts ref.

Die Syntax zum Deklarieren des Referenzparameters in C# lautet wie folgt:

return type Method name(ref arg1, ref arg2)
Declare local variables, for example a, b
Calling the method,
Method name(ref a, ref b)

Die obige Syntax stellt die Deklaration von Referenzparametern in C# dar. Die Referenzparameter können mit dem Schlüsselwort ref deklariert werden und auf sie kann mit dem Schlüsselwort ref.

Arbeiten von Referenzparametern in C#

Betrachten Sie das folgende Programm, das aus zwei Methoden zum Addieren und Subtrahieren besteht. Die Add-Methode akzeptiert den als Wert übergebenen Parameter und die Subtract-Methode akzeptiert den als Referenz übergebenen Parameter. Zunächst werden zwei Variablen deklariert und mit zwei Werten initialisiert. Dann wird die Add-Methode aufgerufen, indem der Wert als Parameter übergeben wird. Der Wert ändert sich nicht, obwohl die Methode die Operation für den als Parameter übergebenen Wert ausführen soll, da dieser als Wert übergeben wird. Die nächste Subtraktionsmethode wird aufgerufen, an die der Referenzparameter übergeben wird. Die in der Subtraktionsmethode definierte Operation wird für den als Referenz übergebenen Wert ausgeführt und aktualisiert.

Code:

using System;
namespace refer {
public class check {
// Calling the main method
public void Main(string[] args)
{
// The values of a and b are initialized
int a = 15, b = 20;
// The values of a and b are displayed before making changes to the values
Console.WriteLine("value of a before changing is {0}", a);
Console.WriteLine("value of b before changing is {0}", b);
Console.WriteLine();
// The add method is called by passing the value
add(a);
// After calling the method by value, the changes value is displyed
Console.WriteLine("After calling the add function"+
" value of a is {0}", a);
// The sub method is called by passing the reference
subtract(ref b);
// Display modified value of b
Console.WriteLine("Value of b after "+
"subtration operation is {0}", b);
}
// Defining the add method which accepts value as parameters
public static void add(int a)
{
a += 5;
}
// Defining the subtract method which accepts reference as parameters
public static void subtract(ref int b)
{
b -= 5;
}
}
}

Ausgabe:

Arten von Referenzen in C#

Hier sind die folgenden Arten von Referenzen in C#

1. Klasse

Class ist einer der C#-Referenztypen und kann mit dem Schlüsselwort class deklariert werden. Die Syntax zum Deklarieren einer Klasse in C# ist unten dargestellt:

Class classname
{
}

Die Klasse unterstützt die Vererbung. Das heißt, eine Klasse kann die Implementierung der Basisklasse erben. Klassen können entweder öffentlich, privat oder geschützt sein. Das folgende Programm demonstriert die Erstellung der Klasse.

Code:

using System;
namespace check
{
class children
{
private int height;
private string names;
// This is the consturctor class which is default
public children()
{
names = "nobody";
}
// Defining a constructor with arguments
public children(string names, int height)
{
this.names = names;
this.height = height;
}
// The method to print the values
public void Print()
{
Console.WriteLine("{0} is {1} inches tall.", names, height);
}
}
class Test
{
static void Main()
{
// New operator is used to create the objects on the class
children child1 = new children("Shobha", 5);
children child2 = new children("Ravi", 6);
// An object is created using default constructor
children child3 = new children();
// The results are displayed
Console.Write("The first child: ");
child1.Print();
Console.Write("The second child: ");
child2.Print();
Console.Write("The third child: ");
child3.Print();
}
}
}

Ausgabe:

2. Schnittstelle

Ein Vertrag wird über eine Schnittstelle definiert. Die Mitglieder jeder Klasse verfügen über eine eindeutige Implementierung, die von der Schnittstelle bereitgestellt wird. Das folgende Programm demonstriert die Erstellung und Implementierung der Schnittstelle.

Code:

using System;
//An interface is defined
interface Point
{
int A
{
get;
set;
}
int B
{
get;
set;
}
double Dist
{
get;
}
}
//A class is implementing the interface
class Pointed : Point
{
// Constructor of the class
public Pointed(int a, int b)
{
A = a;
B = b;
}
public int A { get; set; }
public int B { get; set; }
public double Dist =>
Math.Sqrt(A * A + B * B);
}
class Maincl
{
static void PrintPointed(Point r)
{
Console.WriteLine("a={0}, b={1}", r.A, r.B);
}
static void Main()
{
Point r = new Pointed(2, 3);
Console.Write("the points are: ");
PrintPointed(r);
}
}

Ausgabe:

3. Delegieren

Die Deklaration eines Delegattyps ähnelt der Deklaration einer Methode. Es gibt einen Wert zurück und kann beliebig viele Argumente beliebigen Typs als Parameter annehmen. Es wird im Wesentlichen bei der Kapselung von Methoden verwendet, die als Zeiger auf eine Funktion fungieren. Ein Delegat kann mit dem Schlüsselwort „delegate“ deklariert werden. Die Syntax zum Deklarieren des Delegaten lautet wie folgt:

<access modifier> delegate <return type> <delegate_name>(<parameters>)

Betrachten Sie das folgende Programm, das die Erstellung von Delegierten demonstriert

Code:

using System;
class Program
{
// Creating delegates
public delegate void Printdel(int values);
static void Main(string[] args)
{
// We are printing a number using delegates
Printdel print = PrintNum;
print(100);
print(20);
//We are printing money using printmon delegate
print = PrintMon;
print(10);
print(20);
}
public static void PrintNum(int number)
{
Console.WriteLine("The Number is: {0,-12:N0}",number);
}
public static void PrintMon(int mon)
{
Console.WriteLine("The Money is: {0:C}", mon);
}
}

Ausgabe:

Fazit

In diesem Tutorial verstehen wir das Konzept der Referenzen in C# durch Definition und verstehen dann die Syntax und die Arten von Referenzen in C# anhand von Beispielprogrammen.

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