В чем разница между ключевыми словами ref и out?

ref и out работают так же, как передача по ссылкам и передача по указателям, как в C ++.

Для ref аргумент должен быть объявлен и инициализирован.

Для out аргумент должен быть объявлен, но может быть инициализирован или не инициализирован.

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

Время создания:

(1) Создаем вызывающий метод Main()

(2) он создает объект List (который является объектом ссылочного типа) и сохраняет его в переменной myList.

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

Во время выполнения:

(3) Среда выполнения выделяет память в стеке под номером # 00, достаточно широкой, чтобы хранить адрес (# 00 = myList, поскольку имена переменных на самом деле являются просто псевдонимами для ячеек памяти)

(4) Среда выполнения создает объект списка в куче в ячейке памяти #FF (все эти адреса, например, являются сакэ)

(5) Среда выполнения затем сохранит начальный адрес #FF объекта в # 00 (или, говоря словами, сохраняет ссылку на объект List в указателе myList)

Назад ко времени создания:

(6) Затем мы передаем объект List в качестве аргумента myParamList вызываемому методу modifyMyList и назначаем ему новый объект 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;
}

Во время выполнения:

(7) Среда выполнения запускает процедуру вызова для вызываемого метода и как ее часть проверяет тип параметров.

(8) После нахождения ссылочного типа он выделяет память в стеке в # 04 для псевдонима переменной параметра myParamList.

(9) Затем он также сохраняет в нем значение #FF.

(10) Среда выполнения создает объект списка в куче в ячейке памяти # 004 и заменяет #FF в # 04 этим значением (или разыменовывает исходный объект List и указывает на новый объект List в этом методе).

Адрес в # 00 не изменяется и сохраняет ссылку на #FF (или исходный указатель myList не изменяется).

Ключевое слово ref - это директива компилятора для пропуска генерации кода времени выполнения для (8) и (9), что означает отсутствие выделения кучи для параметров метода. Он будет использовать исходный указатель # 00 для работы с объектом в #FF. Если исходный указатель не инициализирован, среда выполнения перестанет жаловаться на невозможность продолжения работы, поскольку переменная не инициализирована.

Ключевое слово out - это директива компилятора, которая почти такая же, как ref, с небольшими изменениями в (9) и (10). Компилятор ожидает, что аргумент не инициализирован, и продолжит с (8), (4) и (5), чтобы создать объект в куче и сохранить его начальный адрес в переменной аргумента. Никакая неинициализированная ошибка не будет выдана, и любая предыдущая сохраненная ссылка будет потеряна.

Помимо возможности переназначить чужую переменную другому экземпляру класса, вернуть несколько значений и т. Д., использование ref или out позволяет кому-то другому узнать, что вам от них нужно и что вы собираетесь делать с переменной, которую они предоставляют.

• Вам не нужно ref или out, если все, что вам нужно сделать, это изменить что-то внутри экземпляра MyClass, переданного в аргументе someClass.

  • The calling method will see changes like someClass.Message = "Hello World" whether you use ref, out or nothing
  • Запись someClass = new MyClass() внутри myFunction(someClass) заменяет объект, видимый someClass, только в рамках метода myFunction. Вызывающий метод все еще знает об исходном экземпляре MyClass, который он создал и передал вашему методу.

• Вам понадобится ref или out, если вы планируете заменить someClass полностью новым объектом и хотите, чтобы вызывающий метод видел ваши изменения.

  • Writing someClass = new MyClass() inside myFunction(out someClass) changes the object seen by the method that called myFunction

Есть другие программисты

И они хотят знать, что вы собираетесь делать с их данными. Представьте, что вы пишете библиотеку, которой будут пользоваться миллионы разработчиков. Вы хотите, чтобы они знали, что вы собираетесь делать с их переменными, когда они вызывают ваши методы.

• Использование ref приводит к утверждению: «Передайте переменную, которой присвоено какое-то значение, когда вы вызываете мой метод. Имейте в виду, что я могу полностью заменить ее на что-то другое в ходе моего метода. Не ожидайте, что ваша переменная будет указывать на старую возражать, когда я закончу "

• Использование out означает: «Передать переменную-заполнитель моему методу. Неважно, имеет ли она значение или нет; компилятор заставит меня присвоить ему новое значение. Я абсолютно гарантирую, что объект, на который указывает ваша переменная до того, как вы вызвали мой метод, будет измениться к тому времени, когда я закончу

Кстати, в C # 7.2 тоже есть модификатор in

И это не позволяет методу заменять переданный экземпляр другим экземпляром. Думайте об этом, как если бы вы сказали миллионам разработчиков: «Передайте мне свою исходную ссылку на переменную, и я обещаю не менять ваши тщательно обработанные данные на что-то еще». in имеет некоторые особенности, и в некоторых случаях, например, когда может потребоваться неявное преобразование, чтобы сделать ваш шорт совместимым с in int, компилятор временно сделает int, расширит ваш шорт к нему, передаст его по ссылке и завершит. Он может это сделать, потому что вы заявили, что не собираетесь с этим связываться.

Microsoft сделала это с помощью .TryParse методов для числовых типов:

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

Помечая параметр как out, они активно заявляют здесь, что «мы определенно собираемся изменить ваше тщательно созданное значение 98234957 на что-то другое»

Конечно, они вроде как должны, для таких вещей, как анализ типов значений, потому что, если бы методу синтаксического анализа не было разрешено заменять тип значения на что-то еще, это не сработало бы очень хорошо ... Но представьте, что в каком-то из них был какой-то фиктивный метод библиотека, которую вы создаете:

public void PoorlyNamedMethod(out SomeClass x)

Вы можете видеть, что это out, и, таким образом, вы можете знать, что если вы часами вычисляете числа, создавая идеальный SomeClass:

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

Что ж, это была пустая трата времени - потратить все эти часы на то, чтобы получить идеальный урок. Его определенно выбросят и заменят на PoorlyNamedMethod.

Чтобы проиллюстрировать множество прекрасных объяснений, я разработал следующее консольное приложение:

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: передана копия StringList с именем LiStri. В начале метода эта копия ссылается на исходный список и, следовательно, может использоваться для изменения этого списка. Позже LiStri ссылается на другой List<string> объект внутри метода, который не влияет на исходный список.

• HalloWelt: LiStriRef - это псевдоним уже инициализированного ListStringRef. Переданный объект List<string> используется для инициализации нового, поэтому ref был необходим.

• CiaoMondo: LiStriOut является псевдонимом ListStringOut и должен быть инициализирован.

Итак, если метод просто изменяет объект, на который ссылается переданная переменная, компилятор не позволит вам использовать out, и вы не должны использовать ref, потому что это запутает не компилятор, а читатель кода. Если метод заставляет переданный аргумент ссылаться на другой объект, используйте ref для уже инициализированного объекта и out для методов, которые должны инициализировать новый объект для переданного аргумента. Кроме того, ref и out ведут себя одинаково.

Они почти одинаковы - единственная разница в том, что переменную, которую вы передаете как параметр out, не нужно инициализировать, а метод, использующий параметр ref, должен что-то установить.

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

Параметры Ref предназначены для данных, которые могут быть изменены, параметры out - для данных, которые являются дополнительным выходом для функции (например, int.TryParse), которые уже используют возвращаемое значение для чего-то.

Ссылка: ключевое слово ref используется для передачи аргумента в качестве ссылки. Это означает, что когда значение этого параметра изменяется в методе, оно отражается в вызывающем методе. Аргумент, который передается с использованием ключевого слова ref, должен быть инициализирован в вызывающем методе, прежде чем он будет передан в вызываемый метод.

Out: ключевое слово out также используется для передачи аргумента, такого как ключевое слово ref, но аргумент может быть передан без присвоения ему какого-либо значения. Аргумент, который передается с использованием ключевого слова out, должен быть инициализирован в вызываемом методе, прежде чем он вернется к вызывающему методу.

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, и out нельзя использовать при перегрузке метода одновременно. Однако во время выполнения ref и out обрабатываются по-разному, но во время компиляции они обрабатываются одинаково (CLR не различает их, пока создает IL для ref и out).

Ниже я показал пример, в котором используются как Ref, так и out. Теперь у вас все будет ясно по поводу ref и out.

В приведенном ниже примере, когда я комментирую строку // myRefObj = new myClass {Name = "ref outside called !!"};, выдается сообщение об ошибке: «Использование неназначенной локальной переменной 'myRefObj '", но в out такой ошибки нет.

Где использовать Ref: когда мы вызываем процедуру с параметром in, и тот же параметр будет использоваться для сохранения вывода этой процедуры.

Где использовать Out: когда мы вызываем процедуру без параметра in, и тот же параметр будет использоваться для возврата значения из этой процедуры. Также обратите внимание на вывод

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

вы можете проверить этот код, он опишет вам его полное отличие, когда вы используете "ref", это означает, что вы уже инициализировали эту int / string

но когда вы используете "out", он работает в обоих условиях, если вы инициализируете этот int / string или нет, но вы должны инициализировать этот int / string в этой функции

С точки зрения метода, который получает параметр, разница между ref и out заключается в том, что C # требует, чтобы методы записывали каждый параметр out перед возвратом и не должны ничего делать с таким параметром, кроме передачи его как параметра out. или записывая в него, пока он не будет передан как параметр out другому методу или записан напрямую. Обратите внимание, что некоторые другие языки не предъявляют таких требований; виртуальный или интерфейсный метод, объявленный на C # с параметром out, может быть переопределен на другом языке, который не налагает никаких особых ограничений на такие параметры.

С точки зрения вызывающей стороны C # во многих случаях предполагает, что вызов метода с параметром out приведет к записи переданной переменной без предварительного чтения. Это предположение может быть неверным при вызове методов, написанных на других языках. Например:

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

Если myDictionary идентифицирует IDictionary<TKey,TValue> реализацию, написанную на языке, отличном от C #, даже если MyStruct s = new MyStruct(myDictionary); выглядит как присвоение, он потенциально может оставить s без изменений.

Обратите внимание, что конструкторы, написанные на VB.NET, в отличие от конструкторов на C #, не делают никаких предположений о том, будут ли вызываемые методы изменять какие-либо out параметры, и безоговорочно очищают все поля. Странное поведение, упомянутое выше, не произойдет с кодом, полностью написанным на VB или полностью на C #, но может возникнуть, когда код, написанный на C #, вызывает метод, написанный на VB.NET.

Если вы хотите передать свой параметр в качестве ссылки, вам следует инициализировать его перед передачей параметра функции, иначе компилятор сам покажет ошибку. Но в случае параметра out вам не нужно инициализировать параметр объекта перед его передачей в Вы можете инициализировать объект в самом вызывающем методе.

Есть два основных отличия, которые я хочу привести для примера:

1. ref и out передаются по ссылке, hense;

 class Program
    {
        public static void Main(string[] args)
        {
            var original = new ObjectWithMememberList(3);
            Console.WriteLine(original.MyList.Capacity); // 3
            ChangeList(original.MyList);
            Console.WriteLine(original.MyList.Capacity); // 3
        }

        static void ChangeList(List<int> vr)
        {
            vr = new List<int>(2);
        }
}

но:

 class Program
    {
        public static void Main(string[] args)
        {
            var original = new ObjectWithMememberList(3);
            Console.WriteLine(original.MyList.Capacity); // 3
            ChangeList(ref original.MyList);
            Console.WriteLine(original.MyList.Capacity); // 2
        }

        static void ChangeList(ref List<int> vr)
        {
            vr = new List<int>(2);
        }
}

и то же самое с out. 2. Аргумент ref должен быть назначаемой переменной. курица:

ChangeList(ref new List<int>()); // Compile Error [might not be initialized before accessing]

но:

List<int> xs;
ChangeList(out xs); // Compiles

Помните, что ссылочный параметр, который передается внутри функции, обрабатывается напрямую.

Например,

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

Это будет писать «Собака», а не «Кошка». Следовательно, вы должны напрямую работать с someObject.

Возможно, я не настолько хорош в этом, но, конечно, строки (даже если они технически являются ссылочными типами и находятся в куче) передаются по значению, а не по ссылке?

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

Вот почему вам нужна ссылка, если вы хотите, чтобы изменения существовали за пределами области действия функции, которая их делает, иначе вы не передадите ссылку.

Насколько мне известно, вам нужен ref только для типов структур / значений и самой строки, поскольку строка является ссылочным типом, который притворяется, но не является типом значения.

Я могу ошибаться здесь, я новичок.