Références C#

Un emplacement mémoire d'une variable peut être référencé en utilisant un paramètre appelé paramètre de référence en C# et ils sont différents des paramètres appelés paramètres de valeur dans lesquels les valeurs sont passées en tant que paramètres et un nouvel emplacement mémoire est créé pour ces valeurs alors que, dans les paramètres de référence, aucun emplacement mémoire n'est alloué pour ces paramètres car seules les références de ces paramètres sont passées et les paramètres de référence peuvent être déclarés en utilisant le mot-clé ref.

La syntaxe pour déclarer le paramètre de référence en C# est la suivante :

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

La syntaxe ci-dessus représente la déclaration des paramètres de référence en C#. Les paramètres de référence peuvent être déclarés à l'aide du mot-clé ref et ils sont accessibles à l'aide du mot-clé ref.

Fonctionnement des paramètres de référence en C#

Considérez le programme suivant qui consiste en deux méthodes d'addition et de soustraction. La méthode add accepte le paramètre passé par valeur et la méthode soustract accepte le paramètre passé comme référence. Initialement, deux variables sont déclarées et initialisées avec deux valeurs. Ensuite, la méthode add est appelée en passant la valeur comme paramètre. Il n'y a aucun changement dans la valeur même si la méthode est censée effectuer l'opération sur la valeur passée en paramètre car celle-ci passe par valeur. La méthode de soustraction suivante est appelée à laquelle le paramètre de référence est transmis. L'opération définie dans la méthode de soustraction est effectuée sur la valeur passée en référence et elle est mise à jour.

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

Sortie :

Types de références en C#

Voici les types de références suivants en C#

1. Classe

Class est l'un des types de référence C# et ils peuvent être déclarés à l'aide du mot-clé class. La syntaxe pour déclarer une classe en C# est présentée ci-dessous :

Class classname
{
}

La classe prend en charge l'héritage. Autrement dit, une classe peut hériter de l’implémentation de la classe de base. Les cours peuvent être publics, privés ou protégés. Le programme suivant montre la création de la classe.

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

Sortie :

2. Interface

Un contrat se définit à l'aide d'une interface. Les membres de n'importe quelle classe ont une implémentation définie fournie par l'interface. Le programme suivant démontre la création et la mise en œuvre de l'interface.

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

Sortie :

3. Délégué

La déclaration d'un type délégué est comme la déclaration d'une méthode. Il renvoie une valeur et peut prendre n’importe quel nombre d’arguments de n’importe quel type comme paramètres. Il est essentiellement utilisé dans l’encapsulation de méthodes agissant comme un pointeur vers une fonction. Un délégué peut être déclaré à l'aide du mot-clé délégué. La syntaxe pour déclarer le délégué est la suivante :

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

Considérez le programme ci-dessous démontrant la création de délégués

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

Sortie :

Conclusion

Dans ce didacticiel, nous comprenons le concept de références en C# à travers la définition , puis nous comprenons la syntaxe et les types de références en C# à travers des exemples de programmes.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!