Я прочитал версию этого вопроса на C ++, но не понял этого.
Может кто-нибудь, пожалуйста, объясните четко, если это можно сделать и как?
Я прочитал версию этого вопроса на C ++, но не понял этого.
Может кто-нибудь, пожалуйста, объясните четко, если это можно сделать и как?
Ответы:
В C # 7 и выше, смотрите этот ответ .
В предыдущих версиях вы можете использовать .NET 4.0 + Tuple :
Например:
public Tuple<int, int> GetMultipleValue()
{
return Tuple.Create(1,2);
}
Кортежи с двумя значениями имеют Item1
и Item2
свойства.
public (int sum, int count) GetMultipleValues() { return (1, 2); }
Этот пример взят из нашего примера с документацией по этому вопросу .
Теперь, когда C # 7 выпущен, вы можете использовать новый включенный синтаксис Tuples
(string, string, string) LookupName(long id) // tuple return type
{
... // retrieve first, middle and last from data storage
return (first, middle, last); // tuple literal
}
который затем можно использовать так:
var names = LookupName(id);
WriteLine($"found {names.Item1} {names.Item3}.");
Вы также можете предоставить имена своим элементам (чтобы они не были "Item1", "Item2" и т. Д.). Вы можете сделать это, добавив имя к подписи или методы возврата:
(string first, string middle, string last) LookupName(long id) // tuple elements have names
или
return (first: first, middle: middle, last: last); // named tuple elements in a literal
Их также можно деконструировать, что является довольно приятной новой функцией:
(string first, string middle, string last) = LookupName(id1); // deconstructing declaration
Проверьте эту ссылку, чтобы увидеть больше примеров того, что можно сделать :)
Вы можете использовать три разных способа
1. параметры ref / out
используя ref:
static void Main(string[] args)
{
int a = 10;
int b = 20;
int add = 0;
int multiply = 0;
Add_Multiply(a, b, ref add, ref multiply);
Console.WriteLine(add);
Console.WriteLine(multiply);
}
private static void Add_Multiply(int a, int b, ref int add, ref int multiply)
{
add = a + b;
multiply = a * b;
}
используя:
static void Main(string[] args)
{
int a = 10;
int b = 20;
int add;
int multiply;
Add_Multiply(a, b, out add, out multiply);
Console.WriteLine(add);
Console.WriteLine(multiply);
}
private static void Add_Multiply(int a, int b, out int add, out int multiply)
{
add = a + b;
multiply = a * b;
}
2. структура / класс
используя структуру:
struct Result
{
public int add;
public int multiply;
}
static void Main(string[] args)
{
int a = 10;
int b = 20;
var result = Add_Multiply(a, b);
Console.WriteLine(result.add);
Console.WriteLine(result.multiply);
}
private static Result Add_Multiply(int a, int b)
{
var result = new Result
{
add = a * b,
multiply = a + b
};
return result;
}
используя класс:
class Result
{
public int add;
public int multiply;
}
static void Main(string[] args)
{
int a = 10;
int b = 20;
var result = Add_Multiply(a, b);
Console.WriteLine(result.add);
Console.WriteLine(result.multiply);
}
private static Result Add_Multiply(int a, int b)
{
var result = new Result
{
add = a * b,
multiply = a + b
};
return result;
}
3. Кортеж
Класс кортежа
static void Main(string[] args)
{
int a = 10;
int b = 20;
var result = Add_Multiply(a, b);
Console.WriteLine(result.Item1);
Console.WriteLine(result.Item2);
}
private static Tuple<int, int> Add_Multiply(int a, int b)
{
var tuple = new Tuple<int, int>(a + b, a * b);
return tuple;
}
C # 7 кортежей
static void Main(string[] args)
{
int a = 10;
int b = 20;
(int a_plus_b, int a_mult_b) = Add_Multiply(a, b);
Console.WriteLine(a_plus_b);
Console.WriteLine(a_mult_b);
}
private static (int a_plus_b, int a_mult_b) Add_Multiply(int a, int b)
{
return(a + b, a * b);
}
Вы не можете сделать это в C #. То, что вы можете сделать, это иметь out
параметр или вернуть свой собственный класс (или структуру, если вы хотите, чтобы он был неизменным).
public int GetDay(DateTime date, out string name)
{
// ...
}
Использование пользовательского класса (или структуры)
public DayOfWeek GetDay(DateTime date)
{
// ...
}
public class DayOfWeek
{
public int Day { get; set; }
public string Name { get; set; }
}
async
методов. Tuple
это путь (Я использую out
параметры в синхронных операциях, хотя они действительно полезны в этих случаях.)
Если вы имеете в виду возврат нескольких значений, вы можете либо вернуть класс / структуру, содержащую значения, которые вы хотите вернуть, либо использовать ключевое слово «out» для ваших параметров, например, так:
public void Foo(int input, out int output1, out string output2, out string errors) {
// set out parameters inside function
}
Предыдущий постер прав. Вы не можете вернуть несколько значений из метода C #. Тем не менее, у вас есть несколько вариантов:
За и против здесь часто трудно понять. Если вы возвращаете структуру, убедитесь, что она мала, потому что структуры являются типом значения и передаются в стек. Если вы возвращаете экземпляр класса, здесь есть некоторые шаблоны проектирования, которые вы, возможно, захотите использовать, чтобы избежать проблем - члены классов могут быть изменены, потому что C # передает объекты по ссылке (у вас нет ByVal, как в VB ).
Наконец, вы можете использовать выходные параметры, но я бы ограничил их использование сценариями, когда у вас есть только пара (например, 3 или менее) параметров - в противном случае все становится уродливым и сложным в обслуживании. Кроме того, использование выходных параметров может быть препятствием для гибкости, поскольку сигнатура вашего метода будет меняться каждый раз, когда вам нужно что-то добавить к возвращаемому значению, тогда как возвращая экземпляр структуры или класса, вы можете добавлять члены без изменения сигнатуры метода.
С архитектурной точки зрения я бы рекомендовал не использовать пары ключ-значение или словари. Я считаю, что этот стиль кодирования требует «секретных знаний» в коде, который использует метод. Он должен заранее знать, какими будут ключи и что означают значения, и если разработчик, работающий над внутренней реализацией, изменит способ создания словаря или KVP, он может легко создать каскад сбоев во всем приложении.
Exception
если второе значение, которое вы хотите вернуть, является дизъюнктивным по отношению к первому: например, когда вы хотите вернуть либо тип успешного значения, либо тип неудачного значения.
Вы либо возвращает экземпляр класса или использовать из параметров. Вот пример выходных параметров:
void mymethod(out int param1, out int param2)
{
param1 = 10;
param2 = 20;
}
Назовите это так:
int i, j;
mymethod(out i, out j);
// i will be 20 and j will be 10
Есть много способов; но если вы не хотите создавать новый объект или структуру или что-то подобное, вы можете сделать, как показано ниже, после C # 7.0 :
(string firstName, string lastName) GetName(string myParameter)
{
var firstName = myParameter;
var lastName = myParameter + " something";
return (firstName, lastName);
}
void DoSomethingWithNames()
{
var (firstName, lastName) = GetName("myname");
}
В C # 7 появился новый Tuple
синтаксис:
static (string foo, int bar) GetTuple()
{
return ("hello", 5);
}
Вы можете вернуть это как запись:
var result = GetTuple();
var foo = result.foo
// foo == "hello"
Вы также можете использовать новый синтаксис деконструктора:
(string foo) = GetTuple();
// foo == "hello"
Будьте осторожны с сериализацией, однако, все это синтаксический сахар - в фактическом скомпилированном коде это будет Tuple<string, int>
( согласно принятому ответу ) с Item1
и Item2
вместо foo
и bar
. Это означает, что сериализация (или десериализация) будет использовать вместо этих имен свойств.
Итак, для сериализации объявите класс записи и верните его вместо этого.
Также новым в C # 7 является улучшенный синтаксис для out
параметров. Теперь вы можете объявить out
inline, который лучше подходит в некоторых контекстах:
if(int.TryParse("123", out int result)) {
// Do something with result
}
Однако в основном вы будете использовать это в собственных библиотеках .NET, а не в своих собственных функциях.
Некоторые ответы предлагают использовать параметры, но я рекомендую не использовать это, потому что они не работают с асинхронными методами . Смотрите это для получения дополнительной информации.
Другие ответы приведены с использованием Tuple, который я бы тоже рекомендовал, но с использованием новой функции, представленной в C # 7.0.
(string, string, string) LookupName(long id) // tuple return type
{
... // retrieve first, middle and last from data storage
return (first, middle, last); // tuple literal
}
var names = LookupName(id);
WriteLine($"found {names.Item1} {names.Item3}.");
Дополнительную информацию можно найти здесь .
Есть несколько способов сделать это. Вы можете использовать ref
параметры:
int Foo(ref Bar bar) { }
Это передает ссылку на функцию, тем самым позволяя функции изменять объект в стеке вызывающего кода. Хотя это технически не «возвращаемое» значение, это способ заставить функцию сделать нечто подобное. В приведенном выше коде функция будет возвращать int
и (потенциально) изменять bar
.
Другой аналогичный подход заключается в использовании out
параметра. out
Параметр идентичен ref
параметру с дополнительным, компилятор применяются правила. Это правило заключается в том, что если вы передаете out
параметр в функцию, эта функция должна установить его значение перед возвратом. Помимо этого правила, out
параметр работает так же, как ref
параметр.
Последний подход (и лучший в большинстве случаев) заключается в создании типа, который инкапсулирует оба значения и позволяет функции возвращать это:
class FooBar
{
public int i { get; set; }
public Bar b { get; set; }
}
FooBar Foo(Bar bar) { }
Этот последний подход проще и легче для чтения и понимания.
Нет, вы не можете вернуть несколько значений из функции в C # (для версий ниже C # 7), по крайней мере, не так, как вы можете сделать это в Python.
Тем не менее, есть несколько альтернатив:
Вы можете вернуть массив объектов типа с несколькими значениями, которые вы хотите в нем.
private object[] DoSomething()
{
return new [] { 'value1', 'value2', 3 };
}
Вы можете использовать out
параметры.
private string DoSomething(out string outparam1, out int outparam2)
{
outparam1 = 'value2';
outparam2 = 3;
return 'value1';
}
В C # 4 вы сможете использовать встроенную поддержку для кортежей, чтобы справиться с этим легко.
А пока есть два варианта.
Во-первых, вы можете использовать параметры ref или out для назначения значений вашим параметрам, которые возвращаются в вызывающую подпрограмму.
Это выглядит так:
void myFunction(ref int setMe, out int youMustSetMe);
Во-вторых, вы можете заключить возвращаемые значения в структуру или класс и передать их обратно как члены этой структуры. KeyValuePair хорошо работает для 2 - для более чем 2 вам понадобится пользовательский класс или структура.
Вы можете попробовать эту "KeyValuePair"
private KeyValuePair<int, int> GetNumbers()
{
return new KeyValuePair<int, int>(1, 2);
}
var numbers = GetNumbers();
Console.WriteLine("Output : {0}, {1}",numbers.Key, numbers.Value);
Вывод :
Выход: 1, 2
Классы, структуры, коллекции и массивы могут содержать несколько значений. Выходные и опорные параметры также могут быть установлены в функции. Возврат нескольких значений возможен в динамических и функциональных языках с помощью кортежей, но не в C #.
В основном есть два метода. 1. Использовать параметры out / ref. 2. Возвращать массив объектов.
Вот основные Two
методы:
1) Использование ' out
' в качестве параметра.
Вы можете использовать 'out' как для 4.0, так и для минорных версий.
Пример 'out':
using System;
namespace out_parameter
{
class Program
{
//Accept two input parameter and returns two out value
public static void rect(int len, int width, out int area, out int perimeter)
{
area = len * width;
perimeter = 2 * (len + width);
}
static void Main(string[] args)
{
int area, perimeter;
// passing two parameter and getting two returning value
Program.rect(5, 4, out area, out perimeter);
Console.WriteLine("Area of Rectangle is {0}\t",area);
Console.WriteLine("Perimeter of Rectangle is {0}\t", perimeter);
Console.ReadLine();
}
}
}
Вывод:
Площадь прямоугольника 20
Периметр прямоугольника 18
* Примечание: * out
-keyword описывает параметры, чьи фактические местоположения переменных копируются в стек вызываемого метода, где эти же местоположения могут быть переписаны. Это означает, что вызывающий метод получит доступ к измененному параметру.
2) Tuple<T>
Пример кортежа:
Возврат нескольких значений DataType с использованием Tuple<T>
using System;
class Program
{
static void Main()
{
// Create four-item tuple; use var implicit type.
var tuple = new Tuple<string, string[], int, int[]>("perl",
new string[] { "java", "c#" },
1,
new int[] { 2, 3 });
// Pass tuple as argument.
M(tuple);
}
static void M(Tuple<string, string[], int, int[]> tuple)
{
// Evaluate the tuple's items.
Console.WriteLine(tuple.Item1);
foreach (string value in tuple.Item2)
{
Console.WriteLine(value);
}
Console.WriteLine(tuple.Item3);
foreach (int value in tuple.Item4)
{
Console.WriteLine(value);
}
}
}
Вывод
perl
java
c#
1
2
3
ПРИМЕЧАНИЕ. Использование Tuple действительно с версии 4.0 и выше . Tuple
Тип это class
. Он будет размещен в отдельном месте в управляемой куче в памяти. После того, как вы создадите Tuple
, вы не сможете изменить его значения fields
. Это делает Tuple
больше похожим на struct
.
Метод, принимающий делегат, может предоставить вызывающей стороне несколько значений. Это заимствовано из моего ответа здесь и использует немного из принятого ответа Хадаса .
delegate void ValuesDelegate(int upVotes, int comments);
void GetMultipleValues(ValuesDelegate callback)
{
callback(1, 2);
}
Вызывающие операторы предоставляют лямбда (или именованную функцию), а подсказки intellisense копируют имена переменных из делегата.
GetMultipleValues((upVotes, comments) =>
{
Console.WriteLine($"This post has {upVotes} Up Votes and {comments} Comments.");
});
Просто используйте в ООП класс, как это:
class div
{
public int remainder;
public int quotient(int dividend, int divisor)
{
remainder = ...;
return ...;
}
}
Член функции возвращает частное, в котором большинство абонентов в первую очередь заинтересованы. Кроме того, он сохраняет остаток как элемент данных, который впоследствии легко доступен для вызывающего абонента.
Таким образом, вы можете иметь много дополнительных «возвращаемых значений», что очень полезно, если вы реализуете вызовы базы данных или сети, где может потребоваться множество сообщений об ошибках, но только в случае возникновения ошибки.
Я ввел это решение также в вопрос C ++, на который ссылается OP.
Будущая версия C # будет включать именованные кортежи. Посмотрите этот сеанс на канале 9 для демонстрации https://channel9.msdn.com/Events/Build/2016/B889
Перейдите к 13:00 для кортежей. Это позволит такие вещи, как:
(int sum, int count) Tally(IEnumerable<int> list)
{
// calculate stuff here
return (0,0)
}
int resultsum = Tally(numbers).sum
(неполный пример из видео)
Вы можете использовать динамический объект. Я думаю, что он лучше читается, чем Tuple.
static void Main(string[] args){
var obj = GetMultipleValues();
Console.WriteLine(obj.Id);
Console.WriteLine(obj.Name);
}
private static dynamic GetMultipleValues() {
dynamic temp = new System.Dynamic.ExpandoObject();
temp.Id = 123;
temp.Name = "Lorem Ipsum";
return temp;
}
Способы сделать это:
1) KeyValuePair (лучшая производительность - 0,32 нс):
KeyValuePair<int, int> Location(int p_1, int p_2, int p_3, int p_4)
{
return new KeyValuePair<int,int>(p_2 - p_1, p_4-p_3);
}
2) кортеж - 5,40 нс:
Tuple<int, int> Location(int p_1, int p_2, int p_3, int p_4)
{
return new Tuple<int, int>(p_2 - p_1, p_4-p_3);
}
3) out (1.64 нс) или ref 4) Создайте свой собственный класс / структуру
нс -> наносекунды
Ссылка: множественные возвращаемые значения .
ты можешь попробовать это
public IEnumerable<string> Get()
{
return new string[] { "value1", "value2" };
}
yield return "value1"; yield return "value2";
чтобы не пришлось явно создавать новый string[]
?
Вы также можете использовать OperationResult
public OperationResult DoesSomething(int number1, int number2)
{
// Your Code
var returnValue1 = "return Value 1";
var returnValue2 = "return Value 2";
var operationResult = new OperationResult(returnValue1, returnValue2);
return operationResult;
}
Быстрый ответ специально для возвращаемых типов массивов:
private int[] SumAndSub(int A, int B)
{
return new[] { A + B, A - B };
}
С помощью:
var results = SumAndSub(20, 5);
int sum = results[0];
int sub = results[1];