Функция C# возврат двух значений [дубликат]

вы можете использовать ключевое слово "out" на параметре

Попробуйте использовать тип Tuple . Он предназначен для объединения связанных значений без определения нового типа.

public Tuple<int[],int> MyFunction(int[] inputArray) {      
  ...
  int[] resultArray = ...
  int resultValue = ...;
  return Tuple.Create(resultArray,resultValue);
}

Затем вы можете получить доступ к значениям через свойства Item1 и Item2 .

Tuple<int[],int> tuple = MyFunction(myArray);
int[] array = tuple.Item1;
int value = tuple.Item2;

Ссылки

• http://msdn.microsoft.com/en-us/magazine/dd942829.aspx
• http://sankarsan.wordpress.com/2009/11/29/tuple-in-c -4-0 /

У вас есть несколько вариантов (в порядке моего предпочтения):

Создать класс и вернуть его:

class MyResult
{
    public int[] Array { get; set; }
    public int Integer { get; set; }
}

...

private MyResult FunctionName(int[] inputArray)
{
    return new MyResult { Array = ..., Integer = ... };
}

Вы можете использовать встроенный тип, который в основном делает определение настраиваемого класса немного проще:

private Tuple<int[], int> FunctionName(int[] inputArray)
{
    return Tuple.Create( ..., ... );
}

Вы можете использовать параметр out :

private int[] FunctionName(int[] inputArray, out int integerResult)
{
    integerResult = 123;
    return new int[] { ... };
}

(Очевидно, что имена функций, свойства и т. д. являются лишь примерами ... Я предполагаю, что вы выберете более значимые имена)

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

Есть три простых способа сделать это:

Первый способ:

//use a struct to wrap values:
struct returnPair { public int number; public int[] array; }
private returnPair MyFunction(int arg1) {
   return new returnPair { number = ...., array = ...., };
}

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

Второй метод:

Используйте кортеж через Tuple.Create (...., ....) - это объясняется в других ответах.

Третий метод:

Используйте продолжение / обратный вызов. Не переусердствуйте; но иногда это хорошая альтернатива; особенно если вы хотите «вернуть» несколько элементов, но не можете легко использовать стратегию yield return , например, при работе с сильно рекурсивными функциями или перечисление более одного раза не поддерживается. Он также имеет то преимущество, что разрешает вполне читаемые вызовы - лучше, чем кортежи в C #.

private void MyFunction(int arg1, Action<int, int[]> yieldF) {
   yieldF(....num, ....arr);
   yieldF(....num2, ....arr2); //and again...
}
//call like this note that unlike a tuple params are labelled and readable,
//basically like a foreach loop with multiple loop variables:
MyFunction(3+4+5, (intp, arrp) => {
    Do-My-Side-Effect
});

Подлый метод: -)

Если вы подлый (не рекомендуется), вы даже можете комбинировать первый и третий параметры и злоупотреблять выводом типов, чтобы получить именованные параметры, заключенные в автоматически сгенерированный класс только для чтения: -)

private T MyFunction<T>(int arg1, Func<int, int[], T> yieldF) {
   return yieldF(....num2, ....arr2); //and again...
}
//...
var anontuple = MyFunction(3+4+5, (intp, arrp) => new { IntP = intp, ArrP = arrp, });
int foobar = anontuple.IntP + anontuple.ArrP[0];//with intellisense...

Possible. Используйте структуры.

struct retArguments{
    public int result;
    public int array[];
} ;

Также вы можете посетить http://msdn.microsoft.com/en-us/library/aa288471%28VS.71%29.aspx

Есть несколько вариантов использования массивов out и ref , но я бы не рекомендовал их, поскольку они продвигают программирование с побочными эффектами (то есть вы не 'не всегда знаю, где может измениться переменная), что затрудняет понимание вашего кода.

Другой вариант - создать класс для хранения нужных вам возвращаемых значений - это хорошо работает, если нужный вам результат состоит из разных типов (например, int и int [] ). Это хороший выбор, если возвращаемые значения принадлежат друг другу и логически принадлежат друг другу, и вы можете повторно использовать класс.

Если нет, вы всегда можете использовать встроенные общие классы Tuple , которые предназначены для хранения нескольких элементов вместе:

private Tuple<int,int[]> FunctionName (int[] InputArray)
{
    int intRes = ...;
    int intArrayRes = ...'
    Tuple<int,int[]> myResult = Tuple.Create(intRes, intArrayRes);
    ....
    return myResult; 
}

Вы можете получить доступ к значениям, используя различные ItemX properties:

Tuple<int,int[]> result = FunctionName(myArray);
result.Item1; 'Gets the integer
result.Item2; 'Gets the integer array