Les Objets de passage Par Référence ou la Valeur en C#

Objets ne sont pas transmis à tous. Par défaut, l'argument est évaluée et son valeur est passé par valeur, comme la valeur initiale du paramètre de la méthode que vous appelez. Maintenant, le point important est que la valeur est une référence pour les types de référence - un moyen d'arriver à un objet (ou null). Modifications de l'objet sera visible à partir de l'appelant. Toutefois, la modification de la valeur de ce paramètre pour faire référence à un autre objet pas être visible lorsque vous êtes en utilisant le passage par valeur, ce qui est la valeur par défaut pour tous types.

Si vous souhaitez utiliser par référence, vous doit utilisation out ou ref, si le type de paramètre est une valeur de type ou d'un type de référence. Dans ce cas, effectivement la variable elle-même est passé par référence, de sorte que le paramètre utilise le même emplacement de stockage comme argument - et les modifications du paramètre lui-même sont considérés par l'appelant.

Donc:

public void Foo(Image image)
{
    //This change won't be seen by the caller: it's changing the value
    //of the parameter.
    image = Image.FromStream(...);
}

public void Foo(ref Image image)
{
    //This change *will* be seen by the caller: it's changing the value
    //of the parameter, but we're using pass by reference
    image = Image.FromStream(...);
}

public void Foo(Image image)
{
    //This change *will* be seen by the caller: it's changing the data
    //within the object that the parameter value refers to.
    image.RotateFlip(...);
}

J'ai un l'article qui va dans beaucoup plus de détails dans ce. Fondamentalement, "passage par référence" ne veut pas dire ce que vous pensez que cela signifie.

Je suppose que c'est plus clair quand vous le faites comme ça. Je vous recommande de télécharger LinqPad pour tester ce genre de choses.

void Main()
{
var Person = new Person(){FirstName = "Egli", LastName = "Becerra"};
//Will update egli
WontUpdate(Person);
Console.WriteLine("WontUpdate");
Console.WriteLine($"First name: {Person.FirstName}, Last name: {Person.LastName}\n");
UpdateImplicitly(Person);
Console.WriteLine("UpdateImplicitly");
Console.WriteLine($"First name: {Person.FirstName}, Last name: {Person.LastName}\n");
UpdateExplicitly(ref Person);
Console.WriteLine("UpdateExplicitly");
Console.WriteLine($"First name: {Person.FirstName}, Last name: {Person.LastName}\n");
}
//Class to test
public class Person{
public string FirstName {get; set;}
public string LastName {get; set;}
public string printName(){
return $"First name: {FirstName} Last name:{LastName}";
}
}
public static void WontUpdate(Person p)
{
//New instance does jack...
var newP = new Person(){FirstName = p.FirstName, LastName = p.LastName};
newP.FirstName = "Favio";
newP.LastName = "Becerra";
}
public static void UpdateImplicitly(Person p)
{
//Passing by reference implicitly
p.FirstName = "Favio";
p.LastName = "Becerra";
}
public static void UpdateExplicitly(ref Person p)
{
//Again passing by reference explicitly (reduntant)
p.FirstName = "Favio";
p.LastName = "Becerra";
}

Et qui devrait sortir

WontUpdate

Prénom: Egli, nom de famille: Becerra

UpdateImplicitly

Prénom: Favio, nom de famille: Becerra

UpdateExplicitly

Prénom: Favio, nom de famille: Becerra

Comment avez-vous passer de l'objet à la méthode?

Faites-vous de nouveau à l'intérieur de cette méthode pour un objet? Si oui, vous devez utiliser ref dans la méthode.

Lien suivant vous donner une meilleure idée.

http://dotnetstep.blogspot.com/2008/09/passing-reference-type-byval-or-byref.html

La accepté de répondre sonne un peu faux et déroutant. Qu'est ce qu'une "copie d'une référence?"

Comment fait la déclaration suivante a un sens?:

"Toutefois, la modification de la valeur de ce paramètre pour faire référence à un autre objet ne sera pas visible lorsque vous êtes en utilisant le passage par valeur, ce qui est la valeur par défaut pour tous les types." Le passage par valeur n'est pas la valeur par défaut pour tous les types.

Son exemple dans son rapport tente de définir une instance d'un objet à null. L'objet n'est pas correctement définie à null en raison de collecte des ordures automatique. Il ne peut pas être supprimé de cette manière.

Voici un article de Microsoft comparant Java et C#.

De https://msdn.microsoft.com/en-us/library/ms836794.aspx

"Tous les Objets sont des Références

Types de référence sont très similaires à des pointeurs en C++, notamment lors de la définition d'un identificateur à une nouvelle instance de la classe. Mais lors de l'accès à des propriétés ou des méthodes de ce type de référence, utilisez l'opérateur".", qui est similaire à l'accès aux instances de données en C++, qui sont créés sur la pile. Toutes les instances de classe sont créés sur le segment de mémoire à l'aide de l'opérateur new, mais la suppression n'est pas possible, que les deux langues utilisent leurs propres systèmes de collecte des ordures, discuté ci-dessous."