Jaka jest różnica między słowami kluczowymi „ref” i „out”?

Tworzę funkcję, w której muszę przekazać obiekt, aby mogła zostać zmodyfikowana przez funkcję. Jaka jest różnica pomiędzy:

public void myFunction(ref MyClass someClass)

i

public void myFunction(out MyClass someClass)

Z których powinienem korzystać i dlaczego?

refinformuje kompilator, że obiekt został zainicjowany przed wejściem do funkcji, a outinformuje kompilator, że obiekt zostanie zainicjowany wewnątrz funkcji.

Chociaż refjest dwukierunkowy, outjest wyłączny.

W refmodyfikujące sposób, że:

1. Wartość jest już ustawiona i
2. Metoda może ją odczytać i zmodyfikować.

W outmodyfikujące sposób, że:

1. Wartość nie jest ustawiona i nie można jej odczytać, dopóki nie zostanie ustawiona.
2. Metoda musi to ustawić przed powrotem.

Powiedzmy, że Dom pojawia się w kabinie Petera na temat notatki o raportach TPS.

Gdyby Dom był argumentem referencyjnym, miałby wydrukowaną kopię notatki.

Gdyby Dom był sprzeczką, kazałby Peterowi wydrukować nową kopię notatki, aby zabrał go ze sobą.

Spróbuję swoich sił w wyjaśnieniu:

Myślę, że rozumiemy, w jaki sposób typy wartości działają prawidłowo? Typy wartości to (int, long, struct itp.). Kiedy wyślesz je do funkcji bez polecenia ref, KOPIUJE dane . Cokolwiek zrobisz z tymi danymi w funkcji, wpływa tylko na kopię, a nie na oryginał. Polecenie ref wysyła dane RZECZYWISTE, a wszelkie zmiany wpłyną na dane poza funkcją.

Przejdź do mylącej części, typy referencji:

Utwórzmy typ referencyjny:

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

Kiedy odkrywasz jakiś obiekt , tworzone są dwie części:

1. Blok pamięci przechowujący dane dla niektórych obiektów .
2. Odwołanie (wskaźnik) do tego bloku danych.

Teraz, gdy wysyłasz jakiś obiekt do metody bez odwołania , KOPIUJ wskaźnik odniesienia , a NIE dane. Więc teraz masz to:

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

Dwa odniesienia do tego samego obiektu. Jeśli zmodyfikujesz właściwość na jakimś obiekcie za pomocą referencji2, wpłynie to na te same dane, na które wskazuje referencja1.

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

Jeśli wyzerujesz referencję2 lub wskażesz nowe dane, nie wpłynie to na referencję1 ani na referencję danych1.

(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

Co się stanie, gdy wyślesz jakiś obiekt przez odwołanie do metody? Rzeczywiste odniesienie do someObject zostanie wysłany do metody. Masz teraz tylko jedno odniesienie do danych:

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

Ale co to znaczy? Działa dokładnie tak samo, jak wysyłanie jakiegoś obiektu nie przez referencję, z wyjątkiem dwóch głównych rzeczy:

1) Kiedy zerujesz referencję w metodzie, zeruje ona referencję spoza metody.

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

2) Możesz teraz wskazać odwołanie do zupełnie innej lokalizacji danych, a odwołanie poza funkcją będzie teraz wskazywać nową lokalizację danych.

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

ref jest wchodzące i wychodzące .

Powinieneś używać outpreferencji wszędzie tam, gdzie to wystarcza dla twoich wymagań.

na zewnątrz:

W języku C # metoda może zwrócić tylko jedną wartość. Jeśli chcesz zwrócić więcej niż jedną wartość, możesz użyć słowa kluczowego out. Modyfikator wyjściowy powraca jako return-by-reference. Najprostsza odpowiedź jest taka, że ​​słowo kluczowe „out” jest używane do uzyskania wartości z metody.

1. Nie musisz inicjować wartości w funkcji wywołującej.
2. Musisz przypisać wartość do wywoływanej funkcji, w przeciwnym razie kompilator zgłosi błąd.

ref:

W języku C #, gdy przekazujesz typ wartości, taki jak int, float, double itp. Jako argument do parametru metody, jest on przekazywany przez wartość. Dlatego zmiana wartości parametru nie wpływa na argument w wywołaniu metody. Ale jeśli zaznaczysz parametr słowem kluczowym „ref”, będzie on odzwierciedlał rzeczywistą zmienną.

1. Musisz zainicjować zmienną przed wywołaniem funkcji.
2. Przypisanie jakiejkolwiek wartości do parametru ref w metodzie nie jest obowiązkowe. Jeśli nie zmienisz wartości, to co trzeba oznaczyć jako „ref”?

Przykład rozszerzenia psa, kota. Druga metoda z ref zmienia obiekt, do którego odwołuje się wywołujący. Stąd „Kot” !!!

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

Ponieważ podajesz typ referencyjny (klasę), nie ma potrzeby używania, refponieważ domyślnie przekazywane jest tylko odwołanie do rzeczywistego obiektu, a zatem zawsze zmieniasz obiekt za referencją.

Przykład:

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

Tak długo, jak zaliczasz klasę, nie musisz jej używać, refjeśli chcesz zmienić obiekt w swojej metodzie.

refi outzachowują się podobnie, z wyjątkiem następujących różnic.

• refZmienna musi zostać zainicjowana przed użyciem. outZmienna może być używana bez przypisania
• outparametr musi być traktowany jako nieprzypisana wartość przez funkcję, która go używa. Możemy więc użyć zainicjowanego outparametru w kodzie wywołującym, ale wartość zostanie utracona podczas wykonywania funkcji.

Dla tych, którzy uczą się na przykładzie (jak ja), oto, co mówi Anthony Kolesov .

Stworzyłem kilka minimalnych przykładów ref, out i innych, aby zilustrować tę kwestię. Nie omawiam najlepszych praktyk, tylko przykłady, aby zrozumieć różnice.

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

"Piekarz"

To dlatego, że pierwszy zmienia odniesienie do ciągu na „Baker”. Zmiana referencji jest możliwa, ponieważ przekazałeś ją przez słowo kluczowe ref (=> referencja do referencji do ciągu). Drugie wywołanie otrzymuje kopię odwołania do ciągu.

Sznurek na początku wygląda na specjalny. Ale ciąg znaków to tylko klasa referencyjna i jeśli ją zdefiniujesz

string s = "Able";

następnie s jest odwołaniem do klasy łańcuchowej, która zawiera tekst „Able”! Kolejne przypisanie do tej samej zmiennej przez

s = "Baker";

nie zmienia oryginalnego ciągu, ale po prostu tworzy nowe wystąpienie i wskażmy na to wystąpienie!

Możesz to wypróbować za pomocą następującego małego kodu:

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

Czego oczekujesz? To, co otrzymasz, to wciąż „Zdolny”, ponieważ po prostu ustawiasz odwołanie ws do innej instancji, podczas gdy s2 wskazuje na oryginalną instancję.

EDYCJA: łańcuch znaków jest również niezmienny, co oznacza, że ​​po prostu nie ma metody ani właściwości, która modyfikowałaby istniejącą instancję łańcucha (możesz spróbować znaleźć ją w dokumentacji, ale nie będziesz finsował :-)). Wszystkie metody manipulacji ciągami zwracają nową instancję ciągu! (Dlatego często uzyskuje się lepszą wydajność podczas korzystania z klasy StringBuilder)

ref oznacza, że ​​wartość parametru ref jest już ustawiona, metoda może ją odczytać i zmodyfikować. Użycie słowa kluczowego ref jest tym samym, co powiedzenie, że wywołujący jest odpowiedzialny za zainicjowanie wartości parametru.

out mówi kompilatorowi, że inicjalizacja obiektu jest odpowiedzialnością funkcji, funkcja musi przypisać do parametru out. Nie wolno pozostawiać nieprzypisanego.

Out: Instrukcja return może być użyta do zwrócenia tylko jednej wartości z funkcji. Jednak używając parametrów wyjściowych, możesz zwrócić dwie wartości z funkcji. Parametry wyjściowe są jak parametry odniesienia, z tym wyjątkiem, że przenoszą dane z metody, a nie do niej.

Poniższy przykład ilustruje to:

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: Parametr referencyjny jest referencją do lokalizacji pamięci zmiennej. Po przekazaniu parametrów przez odniesienie, w przeciwieństwie do parametrów wartości, nowa lokalizacja pamięci nie jest tworzona dla tych parametrów. Parametry referencyjne reprezentują tę samą lokalizację pamięci, co rzeczywiste parametry dostarczane do metody.

W języku C # deklarujesz parametry referencyjne za pomocą słowa kluczowego ref. Poniższy przykład to pokazuje:

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 i out działają tak samo, jak przekazywanie referencji i przekazywanie wskaźników jak w C ++.

W przypadku odwołania argument musi zostać zadeklarowany i zainicjowany.

Na zewnątrz argument musi zostać zadeklarowany, ale może zostać zainicjowany lub nie

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

Czas tworzenia:

(1) Tworzymy metodę wywoływania Main()

(2) tworzy obiekt List (który jest obiektem typu odwołania) i przechowuje go w zmiennej myList.

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

Podczas działania:

(3) Środowisko wykonawcze przydziela pamięć na stosie na # 00, wystarczająco szeroką, aby przechowywać adres (# 00 = myList, ponieważ nazwy zmiennych są tak naprawdę aliasami dla lokalizacji pamięci)

(4) Środowisko wykonawcze tworzy obiekt listy na stercie w lokalizacji pamięci #FF (wszystkie te adresy są na przykład sake)

(5) Środowisko wykonawcze zapisuje następnie adres początkowy #FF obiektu pod numerem 00 (lub słownie, przechowuje odwołanie do obiektu List we wskaźniku myList )

Powrót do czasu tworzenia:

(6) Następnie przekazujemy obiekt List jako argument myParamListdo wywoływanej metody modifyMyListi przypisujemy mu nowy obiekt List

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

List<int> newList = ModifyMyList(myList)

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

Podczas działania:

(7) Środowisko wykonawcze uruchamia procedurę wywoływania dla wywoływanej metody i jako jej część sprawdza typ parametrów.

(8) Po znalezieniu typu odniesienia przydziela pamięć na stosie w pozycji # 04 w celu aliasingu zmiennej parametru myParamList.

(9) Następnie zapisuje w nim również wartość #FF.

(10) Środowisko wykonawcze tworzy obiekt listy na stercie w miejscu pamięci # 004 i zastępuje #FF w # 04 tą wartością (lub dereferencyjnie oryginalny obiekt List i wskazywał nowy obiekt List w tej metodzie)

Adres w # 00 nie jest zmieniany i zachowuje odniesienie do #FF (lub oryginalny myListwskaźnik nie jest zakłócany).

Ref kluczowe jest dyrektywą kompilator pominięcia generowania kodu wykonawczego dla (8) i (9), co oznacza, że nie będzie żadnego przydziału sterty parametrów sposobu. Użyje oryginalnego wskaźnika # 00 do działania na obiekcie w #FF. Jeśli oryginalny wskaźnik nie zostanie zainicjowany, środowisko wykonawcze przestanie narzekać, że nie można kontynuować, ponieważ zmienna nie została zainicjowana

Się kluczowe jest dyrektywa kompilator, który dość dużo jest taka sama jak ref z niewielkimi zmianami w (9) i (10). Kompilator oczekuje, że argument nie zostanie zainicjowany i będzie kontynuował (8), (4) i (5), aby utworzyć obiekt na stercie i zapisać swój adres początkowy w zmiennej argumentu. Nie zostanie zgłoszony żaden niezainicjowany błąd, a wszelkie poprzednie zapisane odniesienia zostaną utracone.

Oprócz tego, że możesz ponownie przypisać zmienną innej osoby do innej instancji klasy, zwróć wiele wartości itp., Używając reflub outpowiadamiając kogoś innego, czego potrzebujesz od niego i co zamierzasz zrobić ze zmienną, którą udostępnia

• Ty nie potrzebujesz ref lub outjeśli wszystko, co zamierzamy zrobić, to Modyfikacja rzeczy wewnątrz na MyClassprzykład, która jest przekazywana w argumencie someClass.

  • Metoda wywołująca zobaczy zmiany takie jak someClass.Message = "Hello World"użycie ref, outczy nic
  • Pisanie someClass = new MyClass()wewnątrz myFunction(someClass)zamienia obiekt widziany tylko someClassw zakresie myFunctionmetody. Metoda wywołująca nadal wie o oryginalnej MyClassinstancji, którą utworzyła i przekazała do twojej metody

• Państwo musi ref albo outjeśli planujesz zamianę someClassna zewnątrz dla całego nowego obiektu i chcesz metodę telefonicznej, aby zobaczyć swoje zmiany

  • Zapis w someClass = new MyClass()środku myFunction(out someClass)zmienia obiekt widziany przez metodę, która wywołałamyFunction

Istnieją inni programiści

I chcą wiedzieć, co zrobisz z ich danymi. Wyobraź sobie, że piszesz bibliotekę, z której będą korzystać miliony programistów. Chcesz, aby wiedzieli, co zrobisz z ich zmiennymi, gdy wywołasz twoje metody

• Użycie refpowoduje wyrażenie „Przekaż zmienną przypisaną do pewnej wartości, gdy wywołujesz moją metodę. Pamiętaj, że mogę ją zmienić na coś zupełnie innego w trakcie mojej metody. Nie oczekuj, że twoja zmienna będzie wskazywała na stary obiekt kiedy skończę"

• Użycie outpowoduje wyrażenie „Przekaż zmienną zastępczą do mojej metody. Nie ma znaczenia, czy ma ona wartość, czy nie; kompilator zmusi mnie do przypisania jej do nowej wartości. Absolutnie gwarantuję, że obiekt wskazany przez twoją zmienna przed wywołaniem mojej metody, będzie inna do czasu, kiedy skończę

Nawiasem mówiąc, w C # 7.2 jest też inmodyfikator

A to zapobiega zamianie metody przekazanej instancji na inną instancję. Pomyśl o tym jak powiedz tym milionom programistów: „przekaż mi swoje oryginalne zmienne i obiecuję, że nie zamienię twoich starannie spreparowanych danych na coś innego”. inma pewne cechy szczególne, aw niektórych przypadkach, np. gdy konieczna może być niejawna konwersja, aby twój skrót był kompatybilny z in intkompilatorem, tymczasowo utworzy int, rozszerzy skrót do niego, przekaże go przez odniesienie i zakończy. Może to zrobić, ponieważ zadeklarowałeś, że nie będziesz z tym bałaganu.

Microsoft zrobił to za pomocą .TryParsemetod na typach numerycznych:

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

Oznaczając parametr out, gdy aktywnie go tutaj deklarują „na pewno zmienimy twoją skrupulatnie spreparowaną wartość 98234957 na coś innego”

Oczywiście muszą to robić, na przykład w przypadku analizowania typów wartości, ponieważ jeśli metoda analizy składni nie mogłaby zamienić typu wartości na coś innego, nie działałaby zbyt dobrze. Ale wyobraź sobie, że w niektórych metodach była fikcja tworzona biblioteka:

public void PoorlyNamedMethod(out SomeClass x)

Możesz zobaczyć, że to jest out, i dzięki temu możesz wiedzieć, że jeśli spędzasz godziny na zgniataniu liczb, tworzymy idealny SomeClass:

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

Cóż, to była strata czasu, poświęcenie wszystkich tych godzin na stworzenie idealnej klasy. Na pewno zostanie odrzucony i zastąpiony przez PoorlyNamedMethod

Dla tych, którzy szukają zwięzłej odpowiedzi.

Oba refi outsłowa kluczowe są używane do przekazywania reference.

---

Zmienna refsłowa kluczowego musi mieć wartość lub musi odnosić się do obiektu lub null przed jego przekazaniem.

---

W przeciwieństwie refdo zmiennej outsłowo kluczowe musi mieć wartość lub musi odnosić się do obiektu lub null po jego przekazaniu, a także nie musi mieć wartości ani odwoływać się do obiektu przed przekazaniem.

Aby zilustrować wiele doskonałych wyjaśnień, opracowałem następującą aplikację na konsolę:

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: Kopia StringListnazwanego LiStrijest przekazywana. Na początku metody ta kopia odwołuje się do oryginalnej listy i dlatego można jej użyć do zmodyfikowania tej listy. Później LiStriodwołuje się do innego List<string>obiektu w metodzie, który nie wpływa na oryginalną listę.

• HalloWelt: LiStriRefjest aliasem już zainicjowanego ListStringRef. Przekazany List<string>obiekt służy do zainicjowania nowego, dlatego refbył konieczny.

• CiaoMondo: LiStriOutjest aliasem ListStringOuti musi zostać zainicjowany.

Tak więc, jeśli metoda po prostu modyfikuje obiekt, do którego odwołuje się przekazywana zmienna, kompilator nie pozwoli ci na użycie outi nie powinieneś go używać, refponieważ nie pomyliłby to kompilatora, ale czytnika kodu. Jeśli metoda sprawi, że przekazany argument będzie odwoływał się do innego obiektu, użyjref dla już zainicjowanego obiektu i outdla metod, które muszą zainicjować nowy obiekt dla przekazanego argumentu. Poza tym, refi outzachowują się tak samo.

Są prawie takie same - jedyną różnicą jest to, że zmienna przekazywana jako parametr wyjściowy nie musi być inicjowana, a metoda wykorzystująca parametr ref musi ustawić na coś.

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

Parametry ref odnoszą się do danych, które mogą być modyfikowane, parametry out dotyczą danych, które są dodatkowym wyjściem dla funkcji (np. Int.TryParse), które już korzystają z wartości zwracanej dla czegoś.

Poniżej pokazałem przykład z użyciem zarówno Ref, jak i Out . Teraz wszystko zostanie wyjaśnione na temat ref i out.

W poniższym przykładzie, gdy komentuję // myRefObj = new myClass {Name = "ref outside call !!"}; otrzyma błąd z informacją „Użyj nieprzypisanej zmiennej lokalnej„ myRefObj ”” , ale nie ma takiego błędu na zewnątrz .

Gdzie używać Ref : gdy wywołujemy procedurę z parametrem in, a ten sam parametr zostanie użyty do przechowywania danych wyjściowych tego proc.

Gdzie użyć Out: gdy wywołujemy procedurę bez parametru i ten sam parametr zostanie użyty do zwrócenia wartości z tego proc. Zwróć także uwagę na wynik

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

możesz sprawdzić ten kod, który opisałby cię zupełnie inaczej, gdy użyjesz „ref” oznacza to, że już zainicjalizowałeś ten int / string

ale kiedy użyjesz „out”, działa to w obu warunkach, gdy inicjujesz ten int / string, ale nie musisz, ale musisz inicjować ten int / string w tej funkcji

Ref: Słowo kluczowe ref służy do przekazania argumentu jako odwołania. Oznacza to, że gdy wartość tego parametru zostanie zmieniona w metodzie, zostanie odzwierciedlona w metodzie wywołującej. Argument przekazywany za pomocą słowa kluczowego ref musi zostać zainicjowany w metodzie wywołującej, zanim zostanie przekazany do metody wywoływanej.

Out: Słowo kluczowe out służy również do przekazania argumentu takiego jak słowo kluczowe ref, ale argument można przekazać bez przypisywania mu żadnej wartości. Argument przekazany przy użyciu słowa kluczowego out musi zostać zainicjowany w wywołanej metodzie, zanim powróci do metody wywołującej.

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 i out w przeciążeniu metody

Zarówno ref, jak i out nie mogą być używane jednocześnie w przeciążeniu metody. Jednak ref i out są traktowane inaczej w czasie wykonywania, ale są traktowane tak samo w czasie kompilacji (CLR nie rozróżnia między nimi, podczas gdy tworzył IL dla ref i out).

Z punktu widzenia metody, która odbiera parametr, różnica między refi outpolega na tym, że C # wymaga, aby metody musiały zapisywać każdy outparametr przed zwróceniem, i nie mogą robić nic z takim parametrem, poza przekazaniem go jako outparametru lub zapisaniem do niego , dopóki nie zostanie przekazany jako outparametr do innej metody lub zapisany bezpośrednio. Pamiętaj, że niektóre inne języki nie nakładają takich wymagań; metoda wirtualna lub interfejs zadeklarowana w języku C # z outparametrem może zostać zastąpiona w innym języku, który nie nakłada żadnych specjalnych ograniczeń na takie parametry.

Z punktu widzenia wywołującego C # w wielu okolicznościach zakłada, że ​​wywołanie metody z outparametrem spowoduje zapisanie przekazanej zmiennej bez uprzedniego odczytania. To założenie może być nieprawidłowe w przypadku wywoływania metod napisanych w innych językach. Na przykład:

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

Jeśli myDictionaryidentyfikuje IDictionary<TKey,TValue>implementację napisaną w języku innym niż C #, nawet jeśli MyStruct s = new MyStruct(myDictionary);wygląda jak przypisanie, może potencjalnie pozostać sniezmodyfikowana.

Zauważ, że konstruktory napisane w VB.NET, w przeciwieństwie do C #, nie przyjmują żadnych założeń co do tego, czy wywoływane metody będą modyfikować dowolne outparametry i bezwarunkowo usuwają wszystkie pola. Dziwne zachowanie wspomniane powyżej nie wystąpi w przypadku kodu napisanego całkowicie w VB lub całkowicie w C #, ale może wystąpić, gdy kod napisany w C # wywoła metodę napisaną w VB.NET.

Jeśli chcesz przekazać parametr jako referencję, powinieneś go zainicjować przed przekazaniem parametru do funkcji, w przeciwnym razie sam kompilator wyświetli błąd, ale w przypadku parametru out nie musisz inicjować parametru obiektu przed przekazaniem go do parametru Możesz zainicjować obiekt w samej metodzie wywołującej.

Pamiętaj, że parametr referencyjny przekazywany wewnątrz funkcji jest przetwarzany bezpośrednio.

Na przykład,

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

To napisze Pies, nie Kot. Dlatego powinieneś bezpośrednio pracować na someObject.

Być może nie jestem w tym dobry, ale z pewnością ciągi znaków (mimo że są technicznie typami referencyjnymi i znajdują się na stosie) są przekazywane według wartości, a nie referencji?

        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"!!!!

Dlatego potrzebujesz ref, jeśli chcesz, aby zmiany istniały poza zakresem funkcji ich tworzenia, nie przekazujesz referencji inaczej.

O ile mi wiadomo, potrzebujesz tylko ref dla typów struktur / wartości i samego łańcucha, ponieważ łańcuch jest typem odniesienia, który udaje, że jest, ale nie jest typem wartości.

Mogę się jednak całkowicie mylić, jestem nowy.