что такое использование параметра в c#

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

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

Чтобы использовать выходной параметр, аргумент должен быть явно передан в метод как выходной аргумент. Значение аргумента out не будет передан в параметр out.

Переменная, переданная как аргумент out инициализировать не нужно. Тем не менее параметру out должно быть присвоено значение перед возвратом метода.

Пример:

using System;
public class MyClass 
{
   public static int TestOut(out char i) 
   {
      i = 'b';
      return -1;
   }

   public static void Main() 
   {
      char i;   // variable need not be initialized
      Console.WriteLine(TestOut(out i));
      Console.WriteLine(i);
   }
}

Лучший пример правильного использования параметра out - методы TryParse .

int result =-1;
if (!Int32.TryParse(SomeString, out result){
    // log bad input
}

return result;

Использование TryParse вместо ParseInt устраняет необходимость в обработке исключений и делает код намного более элегантным.

Параметр out по существу допускает более одного возвращаемого значения из метода.

http://msdn.microsoft.com/en-us/vcsharp/aa336814.aspx

Выходные параметры - это только выходные параметры, то есть они могут передавать только значение из функции. Мы. создать параметр "out", указав перед типом данных параметра модификатор out. Когда когда-либо передается параметр «out», в функцию передается только неназначенная ссылка.

using System;
class ParameterTest
{
 static void Mymethod(out int Param1)
 {
  Param1=100;
 }
 static void Main()
 {
  int Myvalue=5;
  MyMethod(Myvalue);
  Console.WriteLine(out Myvalue);             
 }
}

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

Модификатор "out" должен предшествовать параметру, передаваемому даже в вызывающей части. Параметры "out" нельзя использовать внутри функции до присвоения ей значения. Значение должно быть присвоено параметру out перед возвратом метода.

из http://msdn.microsoft.com/en-us/vcsharp/aa336814.aspx

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

Напротив, параметры ref считаются изначально назначенными вызываемым объектом. Таким образом, вызываемому не требуется назначать параметр ref перед использованием. Параметры Ref передаются как в метод, так и из него.

Типичный вариант использования - это метод, который должен возвращать более одного значения, поэтому он не может просто использовать возвращаемое значение. Обычно возвращаемое значение используется для флага успеха, в то время как параметр (ы) out устанавливает значения, когда метод успешен.

Классический пример:

public bool TryGet( 
   string key,
   out string value
)

Если он возвращает истину, то значение установлен. В противном случае это не так. Это позволяет вам писать такой код:

string value;
if (!lookupDictionary.TryGet("some key", out value))
  value = "default";

Обратите внимание, что для этого не требуется вызывать Contains перед использованием индексатора, что делает его быстрее и чище. Я также должен добавить, что, в отличие от очень похожего модификатора ref , компилятор не будет жаловаться, если параметр out никогда не был инициализирован.

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

Помимо возможности иметь несколько возвращаемых значений, еще одно применение - уменьшить накладные расходы при копировании типа с большим значением в метод. Когда вы передаете что-то в метод, создается копия значения этого чего-то. Если это ссылочный тип (например, строка), то создается копия ссылки (значение ссылочного типа). Однако, когда вы копируете тип значения ( struct , например int или double ), создается копия всего объекта (значение тип значения - это сама вещь). Теперь ссылка составляет 4 байта (в 32-битных приложениях), а int - 4 байта, поэтому копирование не проблема. Однако можно иметь очень большие типы значений, и хотя это не рекомендуется, иногда это может потребоваться. А когда у вас есть тип значения, скажем, 64 байта, стоимость его копирования в методы непомерно высока (особенно, когда вы используете такую ​​большую структуру struct в первую очередь из соображений производительности). Когда вы используете out , копия объекта не создается, вы просто ссылаетесь на то же самое.

public struct BigStruct
{
  public int A, B, C, D, E, F, G, H, J, J, K, L, M, N, O, P;
}

SomeMethod(instanceOfBigStruct); // A copy is made of this 64-byte struct.

SomeOtherMethod(out instanceOfBigStruct); // No copy is made

Второе использование непосредственно в соответствии с этим состоит в том, что, поскольку вы не делаете копию структуры, а ссылаетесь на ту же самую вещь в методе, как и вне метода, любой изменения, внесенные в объект внутри метода, сохраняются вне метода. Это уже относится к ссылочному типу, но не к типам значений.

Некоторые примеры:

 public void ReferenceExample(SomeReferenceType s)
 {
   s.SomeProperty = "a string"; // The change is persisted to outside of the method
 }

 public void ValueTypeExample(BigStruct b)
 {
   b.A = 5; // Has no effect on the original BigStruct that you passed into the method, because b is a copy!
 }

 public void ValueTypeExampleOut(out BigStruct b)
 {
   b = new BigStruct();
   b.A = 5; // Works, because you refer to the same thing here
 }

Теперь вы, возможно, заметили, что внутри ValueTypeExampleOut я сделал новый экземпляр BigStruct . Это потому, что, если вы используете out , вы должны назначить переменную чему-то перед выходом из метода.

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

int a;
if(TrySomething(out a)) {}

Это работает, потому что TrySomething вынужден назначить что-то для a .

int a;
if(TrySomething(ref a)) {} 

Это не сработает, потому что a не назначен (только что объявлен), а ref требует, чтобы вы использовали его только с назначенной переменной.

Это работает, потому что назначен:

int a = 0;
if(TrySomething(ref a)) {}

Однако, в обоих случаях ( ref и out ) любые изменения, внесенные в a в методе TrySomething , сохраняются в a ].

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

Однако это ничего не делает:

public void Example(SomeReferenceType s)
{
  s = null;
}

Здесь вы просто устанавливаете копию ссылки на s равной null, которая существует только в рамках метод. Он не оказывает никакого влияния на все, что вы передали в метод.

Если вы хотите сделать это по какой-либо причине, используйте это:

public void Example1(ref SomeReferenceType s)
{
  s = null; // Sets whatever you passed into the method to null
}

Я думаю, что это охватывает все варианты использования out и ссылка .

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

Однако это ничего не делает:

public void Example(SomeReferenceType s)
{
  s = null;
}

Здесь вы просто устанавливаете копию ссылки на s равной null, которая существует только в рамках метод. Он не оказывает никакого влияния на все, что вы передали в метод.

Если вы хотите сделать это по какой-либо причине, используйте это:

public void Example1(ref SomeReferenceType s)
{
  s = null; // Sets whatever you passed into the method to null
}

Я думаю, что это охватывает все варианты использования out и ссылка .

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

Однако это ничего не делает:

public void Example(SomeReferenceType s)
{
  s = null;
}

Здесь вы просто устанавливаете копию ссылки на s равной нулю, которая существует только в рамках метод. Он не оказывает никакого влияния на все, что вы передали в метод.

Если вы хотите сделать это по какой-либо причине, используйте это:

public void Example1(ref SomeReferenceType s)
{
  s = null; // Sets whatever you passed into the method to null
}

Я думаю, что это охватывает все варианты использования out и ссылка .

который существует только в рамках метода. Он не оказывает никакого влияния на все, что вы передали в метод.

Если вы хотите сделать это по какой-либо причине, используйте это:

public void Example1(ref SomeReferenceType s)
{
  s = null; // Sets whatever you passed into the method to null
}

Я думаю, что это охватывает все варианты использования out и ссылка .

который существует только в рамках метода. Он не оказывает никакого влияния на все, что вы передали в метод.

Если вы хотите сделать это по какой-либо причине, используйте это:

public void Example1(ref SomeReferenceType s)
{
  s = null; // Sets whatever you passed into the method to null
}

Я думаю, что это охватывает все варианты использования out и ссылка .

Я полагаю, вы могли бы назвать это обычным временем восстановления , .

Это может помочь обобщить: знание логики программирования + синтаксис и API = знание языка ... потому что ...

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

Недавно я потратил много времени на программирование на Python после того, как долгое время был почти на 100% C. Я довольно легко освоил Python и теперь переключаюсь обратно на C. К моему удивлению , проблем, с которыми я думал, что я столкнусь (отсутствие точек с запятой, случайный импульс к отступу), не было.

Я пришел к выводу, что это потому, что:

1. Когда я программировал Python, я часто (ежедневно) смотрел исходники C других проектов, чтобы вспомнить те, которые я не слишком хорошо документировал. Потому что мои проекты на C соответствуют материалам Python.
2. Я всегда смотрел на C-реализацию некоторых вещей Python

Думаю, уловка состоит в том, чтобы связать новые навыки со старыми , чтобы, когда вы выполняете задачи с новым набором навыков, ваши мозг все еще думает о старых навыках и о том, как они связаны. Многие предполагают, что обучение основано на этом реляционном фундаменте в вашем уме, и знание этого может помочь вам сократить кривую обучения и время до восстановления.

Думайте об этом как о реляционной базе данных. Когда вы делаете что-то новое, создайте чужой ключ и нормализуйте ситуацию. Не создавайте целую новую таблицу или базу данных.

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