Passage de tableaux en paramètre
Si l'on modifie le contenu du tableau passé en paramètre à l'intérieur d'une méthode, la modification est effectuée sur la copie de l'argument et non l'argument d'origine donc le résultat n'est pas visible.
Quel est le processus qui se produit lorsque nous appelons la méthode de référence type d'argument?
Voici le code échantillon de ce que je veux demander
using System;
namespace Value_Refrence_Type
{
class Program
{
public static void Main()
{
int[] callingarray = { 22, 200, 25485 };
abc(callingarray);
Console.WriteLine("This is callingarray");
foreach (int element in callingarray)
Console.WriteLine(element);
}
//method parameter
static void abc(int[] calledarray)
{
Console.WriteLine("Method Called--------");
foreach (int element in calledarray)
Console.WriteLine(element);
//Here on changing the value of elements of calledarray does't afftect the value of element of callingarray
//if both refrences to same memory location then the value needs to change, which is not happening here
calledarray = new int[] {55, 54, 65};
foreach (int element in calledarray)
Console.WriteLine(element);
}
}
}
des tableaux ou tout autre objet ne sont pas passés par référence. Tous les objets en C# sont passés par valeur par défaut. De passage par référence, vous devez utiliser le
encore une fois, vous confondez le comportement d'un type de référence transmis par valeur avec passage d'argument par référence. Lorsque le passage par référence, vous pouvez attribuer un nouveau tableau à l'argument et il va changer la variable à la callsite qui n'est clairement pas le cas dans le code que nous sommes en train de discuter. Encore une fois, c'est très simple, pour passer un argument par référence, vous devez utiliser des mots-clés
drôle que vous le point à ma propre réponse. Je vois que vous êtes pas convaincu, donc je vais citation MSDN ici: "(...) Pour passer un paramètre par référence, utiliser la ref ou mot-clé. (...)".
Non, je vois un paramètre est passé par valeur qui signifie que la variable est copiée. Parce que la variable contient un type de référence, la référence est copiée et la pointer vers le même objet. Mais ce n'est pas le passage d'un paramètre par référence. Passage d'argument par référence exige d'utiliser la
Ce n'est pas problématique dans les conversations entre les personnes qui ont réellement comprendre ce qui se passe derrière les coulisses, mais pour ceux qui ne comprennent pas ce qui se passe réellement, comme nicomp, il crée un sévèrement incorrect modèle mental de ce qui se passe, qui résultats dans le programme de ne pas se comporter comme ils s'attendent à parce qu'ils pensent qu'ils sont la transmission de valeurs par référence quand ils ne le sont pas. Si le passage d'une référence par la valeur et une valeur par référence, en réalité, a la même sémantique, puis la différenciation entre eux ne serait pas important, mais ils ne pas ont le même comportement.
ref
ou out
mot-clé. Vous semblez être source de confusion types de référence avec l'argument de passage.encore une fois, vous confondez le comportement d'un type de référence transmis par valeur avec passage d'argument par référence. Lorsque le passage par référence, vous pouvez attribuer un nouveau tableau à l'argument et il va changer la variable à la callsite qui n'est clairement pas le cas dans le code que nous sommes en train de discuter. Encore une fois, c'est très simple, pour passer un argument par référence, vous devez utiliser des mots-clés
ref
ou out
, sinon il sera passé par valeur. Je vous suggère de lire les domaines connexes de la C# spécifications si vous n'êtes toujours pas convaincu.drôle que vous le point à ma propre réponse. Je vois que vous êtes pas convaincu, donc je vais citation MSDN ici: "(...) Pour passer un paramètre par référence, utiliser la ref ou mot-clé. (...)".
Non, je vois un paramètre est passé par valeur qui signifie que la variable est copiée. Parce que la variable contient un type de référence, la référence est copiée et la pointer vers le même objet. Mais ce n'est pas le passage d'un paramètre par référence. Passage d'argument par référence exige d'utiliser la
ref
mot-clé et il vous permet de changer à la callsite le valeur de la variable d'origine, c'est ce que je pouvais dire a = null
et le retour à la callsite la variable serait null
lorsque le renvoi de la méthode. Essayez, dans votre exemple, et de voir comment il fonctionne. De nouveau, il suffit de lire le lien dans ma réponse précédente.Ce n'est pas problématique dans les conversations entre les personnes qui ont réellement comprendre ce qui se passe derrière les coulisses, mais pour ceux qui ne comprennent pas ce qui se passe réellement, comme nicomp, il crée un sévèrement incorrect modèle mental de ce qui se passe, qui résultats dans le programme de ne pas se comporter comme ils s'attendent à parce qu'ils pensent qu'ils sont la transmission de valeurs par référence quand ils ne le sont pas. Si le passage d'une référence par la valeur et une valeur par référence, en réalité, a la même sémantique, puis la différenciation entre eux ne serait pas important, mais ils ne pas ont le même comportement.
OriginalL'auteur mdadil2019 | 2016-05-28
Vous devez vous connecter pour publier un commentaire.
Non, ce n'est pas correct.
Les Arguments sont passés par valeur par défaut en C#, ce qui signifie que vous obtenez une copie de la variable. Mais il est important de réaliser que ce qui est copié est juste la variable, pas nécessairement l'objet; si la variable contient un type de référence (un tableau par exemple), alors la variable est vraiment juste un "pointeur" vers une adresse mémoire où l'objet vies. Ainsi, lorsque vous passer cette variable à un appel de méthode, la référence est copiée oui, mais il reste encore des points à exactement le même objet, la variable d'origine se réfère.
Choses sont très différentes lorsque l'argument est un type valeur. Dans ce cas, la variable elle-même détient l'objet et, par conséquent, vous obtiendrez le comportement que vous semblez attendre.
exactement, parce que vous êtes la modification d'un copier de la référence d'origine. Si vous souhaitez modifier ce que la variable d'origine, est de pointer ensuite, vous devez passer l'argument par référence.
Alors que les lignes de l'image(livre) tiens à expliquer, est-ce mal?
Pas de. La modification d'un élément du tableau,
a[1] = 1;
persistera parce que l'argument est pointant vers le même objet, la variable d'origine. Cependant procédant de la manière suivantea = new[] { ...}
sera pas persister en raison de l'affectation d'une nouvelle référence à une copie de la variable d'origine. La variable d'origine ou le tableau de pointage n'ont aucune idée et ne se soucient pas de ce que vous venez d'affecter un tableau à une copie qui a été faite de la variable.OriginalL'auteur InBetween
Voici de nombreuses réponses avec une description. J'ai essayer de donner un exemple. Disons que c'est votre méthode:
Si vous appelez la méthode comme ceci:
il sera de retour 999 parce que
ProcessData
accède à la mémoire de la matrice.Comme @InBetween décrit:
Cela signifie que, si vous définissez les données de votre méthode à null:
il ne serait pas réglé votre
dataToProcess
à null. Cela signifie:Vous êtes de passage à la copie d'un pointeur vers la mémoire de votre tableau à la méthode.
OriginalL'auteur Fruchtzwerg
Les tableaux sont un référence type en C#. Cela signifie que chaque fois qu'un tableau est passé comme argument à une fonction, la référence (ou un pointeur) à l'argument est passé à la fonction. Ainsi, les modifications que vous faites pour le tableau dans la fonction sont faites dans le réel argument.
Le comportement que vous faites référence ici est pour valeur types et pas les types de référence. Types de valeur en C# sont
struct
s etenum
s, et les types référence en C# sontclass
es et des tableaux.En c# les arguments est passé de paramètre par valeur (par défaut) pour passer des arguments par référence, nous devons utiliser la ref ou mot-clé.
OriginalL'auteur EvilTak
Tableaux en c# peuvent être passés comme arguments pour les paramètres de la méthode. Car les tableaux sont des types référence, la méthode peut changer la valeur des éléments.Pour de plus amples vous devriez regarder dehors pour cette doc msdn.
Because arrays are reference types, the method can change the value of the elements.
Tableaux ne sont pas mutables parce que ils sont des types référence. C'est mutable, et un type de référence. Il n'y a pas de lien de causalité.J'ai trouvé le lien pour contenir exemple utile. Merci.
OriginalL'auteur Himanshu Dwivedi