Was ist der Unterschied zwischen den Schlüsselwörtern "ref" und "out"?

Ich erstelle eine Funktion, bei der ich ein Objekt übergeben muss, damit es von der Funktion geändert werden kann. Was ist der Unterschied zwischen:

public void myFunction(ref MyClass someClass)

und

public void myFunction(out MyClass someClass)

Welches soll ich verwenden und warum?

refteilt dem Compiler mit, dass das Objekt vor dem Aufrufen der Funktion initialisiert wird, während outdem Compiler mitgeteilt wird, dass das Objekt innerhalb der Funktion initialisiert wird.

Also, während refes in beide Richtungen geht, outist es nur out.

Der refModifikator bedeutet:

1. Der Wert ist bereits eingestellt und
2. Die Methode kann es lesen und ändern.

Der outModifikator bedeutet:

1. Der Wert ist nicht festgelegt und kann von der Methode erst gelesen werden, wenn er festgelegt wurde.
2. Die Methode muss es vor der Rückkehr festlegen.

Nehmen wir an, Dom taucht in Peters Kabine über das Memo zu den TPS-Berichten auf.

Wenn Dom ein Ref-Argument wäre, hätte er eine gedruckte Kopie des Memos.

Wenn Dom ein Argument wäre, würde er Peter dazu bringen, eine neue Kopie des Memos auszudrucken, die er mitnehmen kann.

Ich werde mich an einer Erklärung versuchen:

Ich denke, wir verstehen, wie die Werttypen richtig funktionieren? Werttypen sind (int, long, struct usw.). Wenn Sie sie ohne einen ref-Befehl an eine Funktion senden, werden die Daten kopiert . Alles, was Sie mit diesen Daten in der Funktion tun, wirkt sich nur auf die Kopie aus, nicht auf das Original. Der Befehl ref sendet die IST-Daten und alle Änderungen wirken sich auf die Daten außerhalb der Funktion aus.

Ok, weiter zum verwirrenden Teil, Referenztypen:

Erstellen wir einen Referenztyp:

List<string> someobject = new List<string>()

Wenn Sie ein Objekt neu erstellen , werden zwei Teile erstellt:

1. Der Speicherblock, der Daten für ein Objekt enthält .
2. Ein Verweis (Zeiger) auf diesen Datenblock.

Wenn Sie nun ein Objekt in eine Methode ohne Referenz senden, kopiert es den Referenzzeiger , NICHT die Daten. Sie haben jetzt Folgendes:

(outside method) reference1 => someobject
(inside method)  reference2 => someobject

Zwei Referenzen, die auf dasselbe Objekt verweisen. Wenn Sie eine Eigenschaft für ein Objekt mithilfe von Referenz2 ändern, wirkt sich dies auf dieselben Daten aus, auf die Referenz1 verweist.

 (inside method)  reference2.Add("SomeString");
 (outside method) reference1[0] == "SomeString"   //this is true

Wenn Sie Referenz2 auf Null setzen oder auf neue Daten verweisen, wirkt sich dies weder auf Referenz1 noch auf die Datenreferenz1 aus.

(inside method) reference2 = new List<string>();
(outside method) reference1 != null; reference1[0] == "SomeString" //this is true

The references are now pointing like this:
reference2 => new List<string>()
reference1 => someobject

Was passiert nun, wenn Sie ein Objekt per Referenz an eine Methode senden ? Der tatsächliche Verweis auf ein Objekt wird an die Methode gesendet. Sie haben jetzt nur noch einen Verweis auf die Daten:

(outside method) reference1 => someobject;
(inside method)  reference1 => someobject;

Aber was bedeutet das? Es verhält sich genauso wie das Senden eines Objekts, nicht mit Ausnahme von zwei Hauptsachen:

1) Wenn Sie die Referenz innerhalb der Methode auf Null setzen, wird die außerhalb der Methode auf Null gesetzt.

 (inside method)  reference1 = null;
 (outside method) reference1 == null;  //true

2) Sie können jetzt die Referenz auf einen völlig anderen Datenort verweisen, und die Referenz außerhalb der Funktion zeigt jetzt auf den neuen Datenort.

 (inside method)  reference1 = new List<string>();
 (outside method) reference1.Count == 0; //this is true

ref ist rein und raus .

Sie sollten outbevorzugt verwenden, wo immer es für Ihre Anforderungen ausreicht.

aus:

In C # kann eine Methode nur einen Wert zurückgeben. Wenn Sie mehr als einen Wert zurückgeben möchten, können Sie das Schlüsselwort out verwenden. Der Modifikator out wird als Referenz zurückgegeben. Die einfachste Antwort ist, dass das Schlüsselwort "out" verwendet wird, um den Wert aus der Methode abzurufen.

1. Sie müssen den Wert in der aufrufenden Funktion nicht initialisieren.
2. Sie müssen den Wert in der aufgerufenen Funktion zuweisen, sonst meldet der Compiler einen Fehler.

ref:

Wenn Sie in C # einen Werttyp wie int, float, double usw. als Argument an den Methodenparameter übergeben, wird dieser als Wert übergeben. Wenn Sie den Parameterwert ändern, wirkt sich dies daher nicht auf das Argument im Methodenaufruf aus. Wenn Sie den Parameter jedoch mit dem Schlüsselwort "ref" markieren, wird er in der tatsächlichen Variablen wiedergegeben.

1. Sie müssen die Variable initialisieren, bevor Sie die Funktion aufrufen.
2. Es ist nicht zwingend erforderlich, dem Parameter ref in der Methode einen Wert zuzuweisen. Wenn Sie den Wert nicht ändern, müssen Sie ihn dann als "ref" markieren.

Beispiel Hund erweitern, Katze. Die zweite Methode mit ref ändert das Objekt, auf das der Aufrufer verweist. Daher "Katze" !!!

    public static void Foo()
    {
        MyClass myObject = new MyClass();
        myObject.Name = "Dog";
        Bar(myObject);
        Console.WriteLine(myObject.Name); // Writes "Dog". 
        Bar(ref myObject);
        Console.WriteLine(myObject.Name); // Writes "Cat". 
    }

    public static void Bar(MyClass someObject)
    {
        MyClass myTempObject = new MyClass();
        myTempObject.Name = "Cat";
        someObject = myTempObject;
    }

    public static void Bar(ref MyClass someObject)
    {
        MyClass myTempObject = new MyClass();
        myTempObject.Name = "Cat";
        someObject = myTempObject;
    }

Da Sie einen Referenztyp (eine Klasse) übergeben, ist keine Verwendung erforderlich, refda standardmäßig nur eine Referenz auf das tatsächliche Objekt übergeben wird und Sie daher immer das Objekt hinter der Referenz ändern.

Beispiel:

public void Foo()
{
    MyClass myObject = new MyClass();
    myObject.Name = "Dog";
    Bar(myObject);
    Console.WriteLine(myObject.Name); // Writes "Cat".
}

public void Bar(MyClass someObject)
{
    someObject.Name = "Cat";
}

Solange Sie eine Klasse bestehen, müssen Sie diese nicht verwenden, refwenn Sie das Objekt in Ihrer Methode ändern möchten.

refund outverhalten sich ähnlich, mit Ausnahme der folgenden Unterschiede.

• refDie Variable muss vor der Verwendung initialisiert werden. outVariable kann ohne Zuordnung verwendet werden
• outDer Parameter muss von der Funktion, die ihn verwendet, als nicht zugewiesener Wert behandelt werden. Wir können also initialisierte outParameter im aufrufenden Code verwenden, aber der Wert geht verloren, wenn die Funktion ausgeführt wird.

Für diejenigen, die anhand eines Beispiels lernen (wie ich), sagt Anthony Kolesov Folgendes .

Ich habe einige minimale Beispiele für ref, out und andere erstellt, um den Punkt zu veranschaulichen. Ich gehe nicht auf Best Practices ein, sondern nur auf Beispiele, um die Unterschiede zu verstehen.

https://gist.github.com/2upmedia/6d98a57b68d849ee7091

"Bäcker"

Das liegt daran, dass der erste Ihre Zeichenfolgenreferenz so ändert, dass er auf "Baker" zeigt. Das Ändern der Referenz ist möglich, weil Sie sie über das Schlüsselwort ref übergeben haben (=> eine Referenz auf eine Referenz auf eine Zeichenfolge). Der zweite Aufruf erhält eine Kopie des Verweises auf die Zeichenfolge.

Die Saite sieht auf den ersten Blick etwas Besonderes aus. Aber String ist nur eine Referenzklasse und wenn Sie definieren

string s = "Able";

dann ist s ein Verweis auf eine String-Klasse, die den Text "Able" enthält! Eine weitere Zuordnung zu derselben Variablen über

s = "Baker";

ändert nicht die ursprüngliche Zeichenfolge, sondern erstellt nur eine neue Instanz und zeigt auf diese Instanz!

Sie können es mit dem folgenden kleinen Codebeispiel versuchen:

string s = "Able";
string s2 = s;
s = "Baker";
Console.WriteLine(s2);

Was erwartest du? Was Sie erhalten, ist immer noch "Able", da Sie nur die Referenz in s auf eine andere Instanz setzen, während s2 auf die ursprüngliche Instanz zeigt.

BEARBEITEN: Zeichenfolge ist auch unveränderlich, was bedeutet, dass es einfach keine Methode oder Eigenschaft gibt, die eine vorhandene Zeichenfolgeninstanz ändert (Sie können versuchen, eine in den Dokumenten zu finden, aber Sie werden keine finden :-)). Alle String-Manipulationsmethoden geben eine neue String-Instanz zurück! (Deshalb erzielen Sie häufig eine bessere Leistung, wenn Sie die StringBuilder-Klasse verwenden.)

ref bedeutet, dass der Wert im Parameter ref bereits festgelegt ist und von der Methode gelesen und geändert werden kann. Die Verwendung des Schlüsselworts ref entspricht der Aussage, dass der Aufrufer für die Initialisierung des Werts des Parameters verantwortlich ist.

out teilt dem Compiler mit, dass die Initialisierung des Objekts in der Verantwortung der Funktion liegt, die die Funktion dem Parameter out zuweisen muss. Es ist nicht erlaubt, es nicht zugewiesen zu lassen.

Out: Eine return-Anweisung kann verwendet werden, um nur einen Wert von einer Funktion zurückzugeben. Mithilfe von Ausgabeparametern können Sie jedoch zwei Werte von einer Funktion zurückgeben. Ausgabeparameter sind wie Referenzparameter, außer dass sie Daten eher aus der Methode als in diese übertragen.

Das folgende Beispiel veranschaulicht dies:

using System;

namespace CalculatorApplication
{
   class NumberManipulator
   {
      public void getValue(out int x )
      {
         int temp = 5;
         x = temp;
      }

      static void Main(string[] args)
      {
         NumberManipulator n = new NumberManipulator();
         /* local variable definition */
         int a = 100;

         Console.WriteLine("Before method call, value of a : {0}", a);

         /* calling a function to get the value */
         n.getValue(out a);

         Console.WriteLine("After method call, value of a : {0}", a);
         Console.ReadLine();

      }
   }
}

ref: Ein Referenzparameter ist eine Referenz auf einen Speicherort einer Variablen. Wenn Sie Parameter als Referenz übergeben, wird im Gegensatz zu Wertparametern kein neuer Speicherort für diese Parameter erstellt. Die Referenzparameter stellen denselben Speicherort dar wie die tatsächlichen Parameter, die der Methode zur Verfügung gestellt werden.

In C # deklarieren Sie die Referenzparameter mit dem Schlüsselwort ref. Das folgende Beispiel zeigt dies:

using System;
namespace CalculatorApplication
{
   class NumberManipulator
   {
      public void swap(ref int x, ref int y)
      {
         int temp;

         temp = x; /* save the value of x */
         x = y;   /* put y into x */
         y = temp; /* put temp into y */
       }

      static void Main(string[] args)
      {
         NumberManipulator n = new NumberManipulator();
         /* local variable definition */
         int a = 100;
         int b = 200;

         Console.WriteLine("Before swap, value of a : {0}", a);
         Console.WriteLine("Before swap, value of b : {0}", b);

         /* calling a function to swap the values */
         n.swap(ref a, ref b);

         Console.WriteLine("After swap, value of a : {0}", a);
         Console.WriteLine("After swap, value of b : {0}", b);

         Console.ReadLine();

      }
   }
}

ref und out funktionieren genauso wie das Übergeben von Referenzen und das Übergeben von Zeigern wie in C ++.

Für ref muss das Argument deklariert und initialisiert werden.

Für out muss das Argument deklariert werden, kann aber initialisiert werden oder nicht

        double nbr = 6; // if not initialized we get error
        double dd = doit.square(ref nbr);

        double Half_nbr ; // fine as passed by out, but inside the calling  method you initialize it
        doit.math_routines(nbr, out Half_nbr);

Authoring Time:

(1) Wir erstellen die aufrufende Methode Main()

(2) Es erstellt ein Listenobjekt (das ein Referenztypobjekt ist) und speichert es in der Variablen myList.

public sealed class Program 
{
    public static Main() 
    {
        List<int> myList = new List<int>();

Während der Laufzeit:

(3) Runtime weist einen Speicher auf dem Stapel bei # 00 zu, der breit genug ist, um eine Adresse zu speichern (# 00 = myList, da Variablennamen eigentlich nur Aliase für Speicherorte sind).

(4) Runtime erstellt ein Listenobjekt auf dem Heap am Speicherort #FF (alle diese Adressen sind zum Beispiel Sake).

(5) Runtime würde dann die Startadresse #FF des Objekts bei # 00 speichern (oder in Worten die Referenz des List-Objekts im Zeiger speichern myList).

Zurück zur Authoring-Zeit:

(6) Wir übergeben dann das List-Objekt als Argument myParamListan die aufgerufene Methode modifyMyListund weisen ihr ein neues List-Objekt zu

List<int> myList = new List<int>();

List<int> newList = ModifyMyList(myList)

public List<int> ModifyMyList(List<int> myParamList){
     myParamList = new List<int>();
     return myParamList;
}

Während der Laufzeit:

(7) Runtime startet die Aufrufroutine für die aufgerufene Methode und überprüft als Teil davon die Art der Parameter.

(8) Beim Auffinden des Referenztyps wird bei # 04 ein Speicher auf dem Stapel zum Aliasing der Parametervariablen zugewiesen myParamList.

(9) Es speichert dann auch den Wert #FF darin.

(10) Runtime erstellt ein Listenobjekt auf dem Heap am Speicherort # 004 und ersetzt #FF in # 04 durch diesen Wert (oder dereferenziert das ursprüngliche List-Objekt und verweist bei dieser Methode auf das neue List-Objekt).

Die Adresse in # 00 wird nicht geändert und behält den Verweis auf #FF bei (oder der ursprüngliche myListZeiger wird nicht gestört).

Das Schlüsselwort ref ist eine Compiler-Direktive zum Überspringen der Generierung von Laufzeitcode für (8) und (9). Dies bedeutet, dass für Methodenparameter keine Heap-Zuordnung erfolgt. Es wird der ursprüngliche Zeiger # 00 verwendet, um das Objekt bei #FF zu bearbeiten. Wenn der ursprüngliche Zeiger nicht initialisiert wird, hört die Laufzeit auf, sich zu beschweren, dass er nicht fortgesetzt werden kann, da die Variable nicht initialisiert wird

Das Schlüsselwort out ist eine Compiler-Direktive, die mit einer geringfügigen Änderung bei (9) und (10) ziemlich genau der Referenz entspricht. Der Compiler erwartet, dass das Argument nicht initialisiert ist, und fährt mit (8), (4) und (5) fort, um ein Objekt auf dem Heap zu erstellen und seine Startadresse in der Argumentvariablen zu speichern. Es wird kein nicht initialisierter Fehler ausgegeben und alle zuvor gespeicherten Referenzen gehen verloren.

Neben Sie neu zuweisen jemand anderes Variable auf eine andere Instanz einer Klasse ermöglicht, mehrere Werte usw. zurückkehren, mit refoder outläßt wissen , jemand anderes , was man von ihnen braucht und was Sie mit den Variablen zu tun beabsichtigen , sie bieten

• Sie brauchen ref oder outmüssen nur die Dinge in der MyClassInstanz ändern , die im Argument übergeben wird someClass.

  • Der Aufruf der Methode werden Veränderungen wie , someClass.Message = "Hello World"ob Sie verwenden ref, outoder nichts
  • Durch das Schreiben im someClass = new MyClass()Inneren myFunction(someClass)wird das Objekt ausgetauscht, das nur someClassim Bereich der myFunctionMethode angezeigt wird. Die aufrufende Methode kennt immer noch die ursprüngliche MyClassInstanz, die sie erstellt und an Ihre Methode übergeben hat

• Sie benötigen ref oder möchten das Out gegen ein ganz neues Objekt outaustauschen someClassund möchten, dass die aufrufende Methode Ihre Änderung sieht

  • Das Schreiben im someClass = new MyClass()Inneren myFunction(out someClass)ändert das Objekt, das von der aufgerufenen Methode gesehen wirdmyFunction

Andere Programmierer existieren

Und sie möchten wissen, was Sie mit ihren Daten tun werden. Stellen Sie sich vor, Sie schreiben eine Bibliothek, die von Millionen von Entwicklern verwendet wird. Sie möchten, dass sie wissen, was Sie mit ihren Variablen tun, wenn sie Ihre Methoden aufrufen

• Mit using wird refdie Anweisung "Übergeben Sie eine Variable, die einem bestimmten Wert zugewiesen ist, wenn Sie meine Methode aufrufen. Beachten Sie, dass ich sie im Verlauf meiner Methode möglicherweise vollständig gegen etwas anderes austauschen kann. Erwarten Sie nicht, dass Ihre Variable auf das alte Objekt zeigt wenn ich fertig bin"

• Mit using wird outdie Anweisung "Übergeben Sie eine Platzhaltervariable an meine Methode. Es spielt keine Rolle, ob sie einen Wert hat oder nicht; der Compiler zwingt mich, ihn einem neuen Wert zuzuweisen. Ich garantiere absolut, dass das Objekt, auf das Sie zeigen Variable, bevor Sie meine Methode aufgerufen haben, wird zu dem Zeitpunkt, an dem ich fertig bin , anders sein

Übrigens gibt es in C # 7.2 auch einen inModifikator

Dadurch wird verhindert, dass die Methode die übergebene Instanz gegen eine andere Instanz austauscht. Stellen Sie sich vor, Sie sagen zu diesen Millionen von Entwicklern: "Geben Sie mir Ihre ursprüngliche Variablenreferenz, und ich verspreche, Ihre sorgfältig ausgearbeiteten Daten nicht gegen etwas anderes auszutauschen." inhat einige Besonderheiten, und in einigen Fällen, z. B. wenn eine implizite Konvertierung erforderlich sein könnte, um Ihren Kurzfilm mit einem kompatibel zu machen, wird in intder Compiler vorübergehend einen Int erstellen, Ihren Kurzfilm darauf erweitern, ihn als Referenz übergeben und fertig stellen. Es kann dies tun, weil Sie erklärt haben, dass Sie sich nicht damit anlegen werden.

Microsoft hat dies mit den .TryParseMethoden für die numerischen Typen getan :

int i = 98234957;
bool success = int.TryParse("123", out i);

Indem Sie den Parameter markieren, während outer hier aktiv erklärt: "Wir werden Ihren sorgfältig ausgearbeiteten Wert von 98234957 definitiv gegen etwas anderes austauschen."

Natürlich müssen sie das für Dinge wie das Parsen von Werttypen, denn wenn die Analysemethode den Wertetyp nicht gegen etwas anderes austauschen könnte, würde es nicht sehr gut funktionieren. Aber stellen Sie sich vor, es gäbe eine fiktive Methode in einigen Bibliothek, die Sie erstellen:

public void PoorlyNamedMethod(out SomeClass x)

Sie können sehen, dass es eine ist out, und Sie können somit wissen, dass, wenn Sie Stunden damit verbringen, Zahlen zu knacken, die perfekte SomeClass erstellt wird:

SomeClass x = SpendHoursMakingMeAPerfectSomeClass();
//now give it to the library
PoorlyNamedMethod(out x);

Nun, das war Zeitverschwendung, all diese Stunden zu brauchen, um diesen perfekten Unterricht zu machen. Es wird definitiv weggeworfen und durch PoorlyNamedMethod ersetzt

Für diejenigen, die eine prägnante Antwort suchen.

Sowohl refals auch outSchlüsselwörter werden zum Übergeben verwendet reference.

---

Eine Variable des refSchlüsselworts muss einen Wert haben oder auf ein Objekt verweisen oder null bevor es übergeben wird.

---

Im Gegensatz dazu refmuss eine Variable des outSchlüsselworts einen Wert haben oder auf ein Objekt oder null nach dessen Übergabe verweisen sowie vor dem Übergeben keinen Wert haben oder auf ein Objekt verweisen .

Um die vielen hervorragenden Erklärungen zu veranschaulichen, habe ich die folgende Konsolen-App entwickelt:

using System;
using System.Collections.Generic;

namespace CSharpDemos
{
  class Program
  {
    static void Main(string[] args)
    {
      List<string> StringList = new List<string> { "Hello" };
      List<string> StringListRef = new List<string> { "Hallo" };

      AppendWorld(StringList);
      Console.WriteLine(StringList[0] + StringList[1]);

      HalloWelt(ref StringListRef);
      Console.WriteLine(StringListRef[0] + StringListRef[1]);

      CiaoMondo(out List<string> StringListOut);
      Console.WriteLine(StringListOut[0] + StringListOut[1]);
    }

    static void AppendWorld(List<string> LiStri)
    {
      LiStri.Add(" World!");
      LiStri = new List<string> { "¡Hola", " Mundo!" };
      Console.WriteLine(LiStri[0] + LiStri[1]);
    }

    static void HalloWelt(ref List<string> LiStriRef)
     { LiStriRef = new List<string> { LiStriRef[0], " Welt!" }; }

    static void CiaoMondo(out List<string> LiStriOut)
     { LiStriOut = new List<string> { "Ciao", " Mondo!" }; }
   }
}
/*Output:
¡Hola Mundo!
Hello World!
Hallo Welt!
Ciao Mondo!
*/

• AppendWorld: Eine Kopie von StringListnamed LiStriwird übergeben. Zu Beginn der Methode verweist diese Kopie auf die ursprüngliche Liste und kann daher zum Ändern dieser Liste verwendet werden. LiStriVerweist später auf ein anderes List<string>Objekt innerhalb der Methode, das die ursprüngliche Liste nicht beeinflusst.

• HalloWelt: LiStriRefist ein Alias ​​des bereits initialisierten ListStringRef. Das übergebene List<string>Objekt wird verwendet, um ein neues zu initialisieren, daher refwar dies erforderlich.

• CiaoMondo: LiStriOutist ein Alias ​​von ListStringOutund muss initialisiert werden.

Wenn eine Methode nur das Objekt ändert, auf das von der übergebenen Variablen verwiesen wird, lässt der Compiler outSie nicht zu und Sie sollten es nicht verwenden, refda dies nicht den Compiler, sondern den Leser des Codes verwirren würde. Wenn die Methode das übergebene Argument auf ein anderes Objekt verweisen lässt, verwenden Sie es reffür ein bereits initialisiertes Objekt und outfür Methoden, die ein neues Objekt für das übergebene Argument initialisieren müssen. Außerdem refund outbenimm dich gleich.

Sie sind ziemlich gleich - der einzige Unterschied besteht darin, dass eine Variable, die Sie als out-Parameter übergeben, nicht initialisiert werden muss und die Methode, die den ref-Parameter verwendet, sie auf etwas setzen muss.

int x;    Foo(out x); // OK 
int y;    Foo(ref y); // Error

Ref-Parameter beziehen sich auf Daten, die möglicherweise geändert werden. Out-Parameter beziehen sich auf Daten, die eine zusätzliche Ausgabe für die Funktion darstellen (z. B. int.TryParse), die bereits den Rückgabewert für etwas verwenden.

Unten habe ich ein Beispiel gezeigt, das sowohl Ref als auch out verwendet . Jetzt werden Sie alle über ref und out geklärt.

Im unten genannten Beispiel, wenn ich kommentiere // myRefObj = new myClass {Name = "ref außerhalb genannt !!"}; In der Zeile wird die Fehlermeldung "Verwendung der nicht zugewiesenen lokalen Variablen 'myRefObj'" angezeigt , es tritt jedoch kein solcher Fehler auf .

Verwendungszweck Ref : Wenn wir eine Prozedur mit einem in-Parameter aufrufen und derselbe Parameter zum Speichern der Ausgabe dieses Prozesses verwendet wird.

Verwendungszweck von Out: Wenn wir eine Prozedur ohne Parameter in aufrufen und derselbe Parameter verwendet wird, um den Wert von diesem Prozess zurückzugeben. Beachten Sie auch die Ausgabe

public partial class refAndOutUse : System.Web.UI.Page
{
    protected void Page_Load(object sender, EventArgs e)
    {
        myClass myRefObj;
        myRefObj = new myClass { Name = "ref outside called!!  <br/>" };
        myRefFunction(ref myRefObj);
        Response.Write(myRefObj.Name); //ref inside function

        myClass myOutObj;
        myOutFunction(out myOutObj);
        Response.Write(myOutObj.Name); //out inside function
    }

    void myRefFunction(ref myClass refObj)
    {
        refObj.Name = "ref inside function <br/>";
        Response.Write(refObj.Name); //ref inside function
    }
    void myOutFunction(out myClass outObj)
    {
        outObj = new myClass { Name = "out inside function <br/>" }; 
        Response.Write(outObj.Name); //out inside function
    }
}

public class myClass
{
    public string Name { get; set; }
} 

 public static void Main(string[] args)
    {
        //int a=10;
        //change(ref a);
        //Console.WriteLine(a);
        // Console.Read();

        int b;
        change2(out b);
        Console.WriteLine(b);
        Console.Read();
    }
    // static void change(ref int a)
    //{
    //    a = 20;
    //}

     static void change2(out int b)
     {
         b = 20;
     }

Sie können diesen Code überprüfen, der Ihnen den vollständigen Unterschied beschreibt, wenn Sie "ref" verwenden. Dies bedeutet, dass Sie diesen int / string bereits initialisiert haben

Aber wenn Sie "out" verwenden, funktioniert es unter beiden Bedingungen, ob Sie diesen int / string initialisieren oder nicht, aber Sie müssen diesen int / string in dieser Funktion initialisieren

Ref: Das Schlüsselwort ref wird verwendet, um ein Argument als Referenz zu übergeben. Dies bedeutet, dass der Wert dieses Parameters in der Methode in der aufrufenden Methode wiedergegeben wird. Ein Argument, das mit einem ref-Schlüsselwort übergeben wird, muss in der aufrufenden Methode initialisiert werden, bevor es an die aufgerufene Methode übergeben wird.

Out: Das Schlüsselwort out wird auch verwendet, um ein Argument wie das Schlüsselwort ref zu übergeben. Das Argument kann jedoch übergeben werden, ohne ihm einen Wert zuzuweisen. Ein Argument, das mit einem out-Schlüsselwort übergeben wird, muss in der aufgerufenen Methode initialisiert werden, bevor es zur aufrufenden Methode zurückkehrt.

public class Example
{
 public static void Main() 
 {
 int val1 = 0; //must be initialized 
 int val2; //optional

 Example1(ref val1);
 Console.WriteLine(val1); 

 Example2(out val2);
 Console.WriteLine(val2); 
 }

 static void Example1(ref int value) 
 {
 value = 1;
 }
 static void Example2(out int value) 
 {
 value = 2; 
 }
}

/* Output     1     2     

Ref und out in Methodenüberladung

Sowohl ref als auch out können nicht gleichzeitig bei der Methodenüberladung verwendet werden. Ref und Out werden zur Laufzeit unterschiedlich behandelt, aber zur Kompilierungszeit werden sie gleich behandelt (CLR unterscheidet nicht zwischen beiden, während IL für ref und out erstellt wurde).

Vom Standpunkt einer Methode, die einen Parameter empfängt, besteht der Unterschied zwischen refund outdarin, dass C # erfordert, dass Methoden outvor der Rückgabe in jeden Parameter schreiben müssen und mit einem solchen Parameter nichts anderes tun dürfen, als ihn als outParameter zu übergeben oder an ihn zu schreiben , bis es entweder als outParameter an eine andere Methode übergeben oder direkt geschrieben wurde. Beachten Sie, dass einige andere Sprachen solche Anforderungen nicht stellen. Eine virtuelle oder Schnittstellenmethode, die in C # mit einem outParameter deklariert ist, kann in einer anderen Sprache überschrieben werden, die solchen Parametern keine besonderen Einschränkungen auferlegt.

Vom Standpunkt des Aufrufers aus geht C # unter vielen Umständen davon aus, dass beim Aufrufen einer Methode mit einem outParameter die übergebene Variable geschrieben wird, ohne zuvor gelesen worden zu sein. Diese Annahme ist möglicherweise nicht korrekt, wenn Methoden aufgerufen werden, die in anderen Sprachen geschrieben sind. Zum Beispiel:

struct MyStruct
{
   ...
   myStruct(IDictionary<int, MyStruct> d)
   {
     d.TryGetValue(23, out this);
   }
}

Wenn myDictionaryeine IDictionary<TKey,TValue>Implementierung identifiziert wird , die in einer anderen Sprache als C # geschrieben ist, obwohl sie MyStruct s = new MyStruct(myDictionary);wie eine Zuweisung aussieht, kann sie möglicherweise sunverändert bleiben.

Beachten Sie, dass in VB.NET geschriebene Konstruktoren im Gegensatz zu denen in C # keine Annahmen darüber treffen, ob aufgerufene Methoden outParameter ändern und alle Felder bedingungslos löschen. Das oben erwähnte seltsame Verhalten tritt nicht bei Code auf, der vollständig in VB oder vollständig in C # geschrieben ist, sondern kann auftreten, wenn in C # geschriebener Code eine in VB.NET geschriebene Methode aufruft.

Wenn Sie Ihren Parameter als Referenz übergeben möchten, sollten Sie ihn initialisieren, bevor Sie den Parameter an die Funktion übergeben. Andernfalls zeigt der Compiler selbst den Fehler an. Bei out-Parametern müssen Sie den Objektparameter jedoch nicht initialisieren, bevor Sie ihn an den übergeben Methode. Sie können das Objekt in der aufrufenden Methode selbst initialisieren.

Beachten Sie, dass der Referenzparameter, der innerhalb der Funktion übergeben wird, direkt bearbeitet wird.

Zum Beispiel,

    public class MyClass
    {
        public string Name { get; set; }
    }

    public void Foo()
    {
        MyClass myObject = new MyClass();
        myObject.Name = "Dog";
        Bar(myObject);
        Console.WriteLine(myObject.Name); // Writes "Dog".
    }

    public void Bar(MyClass someObject)
    {
        MyClass myTempObject = new MyClass();
        myTempObject.Name = "Cat";
        someObject = myTempObject;
    }

Dies wird Hund schreiben, nicht Katze. Daher sollten Sie direkt an someObject arbeiten.

Ich bin vielleicht nicht so gut darin, aber Zeichenfolgen (obwohl sie technisch Referenztypen sind und auf dem Heap leben) werden als Wert übergeben, nicht als Referenz?

        string a = "Hello";

        string b = "goodbye";

        b = a; //attempt to make b point to a, won't work.

        a = "testing";

        Console.WriteLine(b); //this will produce "hello", NOT "testing"!!!!

Aus diesem Grund benötigen Sie ref, wenn Änderungen außerhalb des Funktionsumfangs vorgenommen werden sollen. Andernfalls übergeben Sie keine Referenz.

Soweit mir bekannt ist, benötigen Sie nur ref für Strukturen / Werttypen und Zeichenfolge selbst, da Zeichenfolge ein Referenztyp ist, der vorgibt, dies zu sein, aber kein Werttyp ist.

Ich könnte hier allerdings völlig falsch liegen, ich bin neu.