编程中经常遇到有多个返回值的情况，下面提供了几种方法供参考。

方法一：

GetPerson(out var Name, out var Age, out var Male);
Debug.Log(Name + " " + Age + " " + Male);

public void GetPerson(out string name, out int age, out bool male)
{
    name = "Jack";
    age = 56;
    male = true;
}

方法二：

var person = GetPerson();
Debug.Log(person.Name + " " + person.Age + " " + person.Male);

public struct Person
{
    public string Name;
    public int Age;
    public bool Male;
}

public Person GetPerson()
{
    return new Person()
    {
        Name = "Jack",
        Age = 56,
        Male = true
    };
}

方法三：

var person = GetPerson_();
Debug.Log(person.Name + " " + person.Age + " " + person.Male);

public (string Name, int Age, bool Male) GetPerson()
{
    return ("Jack", 56, true);
}

个人理解：
方法一使用了out,写起来也比较方便，但是会造成API的不容易理解，因为out更多被视为额外输出。

https://docs.microsoft.com/en-us/dotnet/standard/design-guidelines/parameter-design?redirectedfrom=MSDN

方法二使用了结构体， 结构体的还是能比较好的总结输出，但大量使用一次性类型会将代码弄得一团糟。

方法三使用了valueTuple，valueTuple的字段和结构体一样拥有描述性名字，用起来也比较方便，但是元组这个方案增加字段不是很方便。 TupleElementNames 属性只能由编译器赋予。如果返回类型上使用了反射，你将只能看到裸的 ValueTuple 结构体。因为在获得结果时，属性是位于函数本身上，而这个信息丢失了。

综上，如果是数据比较大的返回值可以用引用类型，如果是数据比较小的返回值，使用频繁的话可以使用结构体，但是一次性的建议使用元组。对于public API并且数据可能会被修改的话，可以使用结构体，非public的话可以使用元组，这样使用和修改都挺方便。out返回值更多被视为返回值的补充，不要把数据一股脑使用out返回。

先来说下C#中的数据类型.分值类型和引用类型两大类.

　　值类型:直接存储数据的值,保存在内存中的stack(堆栈)中

　　引用类型:存储对值的引用,实际上存储的就是一个内存的地址.引用类型的保存分成两块,实际值保存在托管堆(heap)中.实际值的内存地址保存在stack中

　　当使用引用类型时先找到stack中的地址,再找到heap中的实际值.

　　也就是说保存引用类型时要用到stack和heap,但使用引用类型时我们实际上只用到stack中的值,然后通过这个值间接的访问heap中的值

　　C#预定义的简单类型,像int,float,bool,char都是值类型，另外enum(枚举),struct(结构)也是值类型

　　string,数组,自定义的class就都是引用类型了.其中的string是比较特殊的引用类型.C#给它增加个字符恒定的特性.

　　C#函数的参数如果不加ref,out这样的修饰符显式申明参数是通过引用传递外,默认都是值传递.

　　这里要注意的一个问题是,参数的类型是值类型还是引用类型和传参数时用值传递还是引用传递是两个不同的概念.

　　假如有void FunTest(int [] array) 和void FunTest(int a) 
这两个函数.参数array是引用类型,a是值类型.但是他们传递时都是按值传递.

　　我们来举个例子说明下

　　按值传递参数:

　　class Program

　　{

　　public static void ChangeInt(int num)

　　{

　　num = 123;

　　}

　　public static void ChangeArray(int[] array)

　　{

　　array[0] = 10;

　　array = new int[] { 6, 7, 8, 9 };

　　}

　　static void Main(string[] args)

　　{

　　int anum = 1;

　　int[] aarray = { 1, 2, 3 };

　　ChangeInt(anum);

　　ChangeArray(aarray);

　　Console.WriteLine("value of num: " + anum);

　　Console.Write("value of aarray: ");

　　foreach (int i in aarray)

　　Console.Write(i + " ");

　　}

　　}

　　结果是:value of anum : 1

　　value of aarray :10 2 3

　　可能看到结果会有点奇怪.我们一般认为值传递就是把值拷贝一份,然后不管在函数中对传入的参数做啥改变,参数之前的值不会受啥影响,所以anum没有变成123,仍然是1

　　但是aarray[0]为啥却变成10了呢?

　　前面我们有说到引用类型在内存中是保存为两个部分,一个是stack中的内存地址,另一个是heap中的实际值.用时我们只直接用stack中的值,我们假如stack中的值为0xabcdefgh 
,就说是aaraay指向它吧. 那么我们按值传递时就是把这个stack的值拷贝成另一份就假如是array指向它吧.跟拷贝anum的值1一样.

　　但是我们操作内存地址这样的值时不会像整数一样直接操作它,而只会通过它去找heap中的实际值.

　　于是我们array[0] = 10.改变了实际上还是heap中数组的值了. 但array = new int [] 
{6,7,8,9}没有对之前传的aarray产生影响.这个操作的意义是在heap中重新开辟一块内存,保存着值6,7,8,9. 
这这块内存的地址赋给array,于是它之前的值0xabcdefgh被改写了.但aarray指的值stack值仍没变,仍是0xabcdefgh

　　按引用传递参数

　　可以用out或ref显式指定.它们大部分时候可以通用,只是有一点细小区别.

　　先用ref 来举例吧,还用上面的例子,只是加个了关键字ref

　　class Program

　　{

　　public static void ChangeInt(ref int num)

　　{

　　num = 123;

　　}

　　public static void ChangeArray(ref int[] array)

　　{

　　array[0] = 10;

　　array = new int[] { 6, 7, 8, 9 };

　　}

　　static void Main(string[] args)

　　{

　　int anum = 1;

　　int[] aarray = { 1, 2, 3 };

　　ChangeInt(ref anum);

　　ChangeArray(ref aarray);

　　Console.WriteLine("value of num: " + anum);

　　Console.Write("value of aarray: ");

　　foreach (int i in aarray)

　　Console.Write(i + " ");

　　}

　　}

　　结果是:value of anum : 123

　　value of aarray :6 7 8 9

　　跟按值传递的结果完全不同吧

　　num = 123我们是容易理解.我们再来说下aarray的值为啥变了吧

　　按引用传递时aarray指向的stack中的值不会复制一份,而是直接传过去.这样array[0]= 10这样赋值时也同样改变了heap中 1 2 3 
的值,变为10 2 3,如果

　　没有array = new int [] {6,7,8,9} 
这个语句,则它的结果跟上面按值传递是完全一样的.但有个这句话后就不一样,我们知道上面说了它的含义,在heap中开辟一块新内存

　　值是6 7 8 9,而aarray指向的stack的值被改写了,改为指向保存6 7 8 9的内存地址了.那含有10 2 
3的那一块内存其实还继续存在,只是没有谁引用到它了.到时垃圾回收器会把它回收的.

　　补充:

　　说下out 和ref的细小区别

　　ref 传进来的参数必须要先赋值.

　　像上面 的例子中如果这样写

　　int num;

　　ChangeInt(ref int num);

　　就会出错,必须先给num给个值1.

　　而且out传进来的参数可以不先赋值.

　　out num;

　　ChangeInt(out int num);是对的

　　另外还有个区别就是如果用out的时候ChangeInt函数中必须有某个地方给num赋值了,而用ref不一定需要在函数中给num赋值

　　其实这样做的目的很好理解.C#为了确保在任何情况下num必须有个值,不能为空.

　　因为用ref,在调用函数前必须保证参数有值,所以在函数中就不必要求它一定再赋值

　　而用out由于在调用函数前不用保证参数必须有值,所以在函数中必须保证给它个值

　　ChangeInt(ref int num)和ChangeInt(out int num)虽然不一样,但是不同共存,不能当作两个不同的函数

　　而ChangeInt(int num)和上面 的两个函数是完全不一样的,可以放到一起共存

　　这样的话调用的时候ref ,out这样的关键字不能省的.必须匹配

引言

之前分享了一个文章：Unity显示C++动态库中的Log，其中使用到的主要能力就是，由C++动态库回调C#函数达到的。
这里我再对该功能进行专门的记录，并使用上面的这个文章做例子。

C++

首先，C++动态库中，先声明一个函数指针。

typedef void (*Log)(char* message, int iSize);

接着声明一下该指针类型的变量。

Log g_log;

如果需要将从C#传过来的函数地址全局保存，让其他的类都可以用这个回调函数，所以其他需要用到回调函数的ccp文件里，就需要再声明一次。

extern Log g_log;

然后就是导出一个接口，用来注册设置C#的函数地址。
头文件：

#ifndef DLL_API
#define DLL_API extern "C"
#endif

DLL_API void InitCSharpDelegate(void (*Log)(char* message, int iSize));

源文件：

DLL_API void InitCSharpDelegate(void (*Log)(char* message, int iSize))
{
	g_log = Log;
}

这样，源文件的任何位置，当需要回调C#的函数时，只要调g_log就可以了。

g_log(acLogStr, strlen(acLogStr));

C#

下面就是C#的代码，在C#中是由函数的委托来代替函数指针的。故代码如下。

[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate void LogDelegate(IntPtr message, int iSize);
[DllImport("mac", CallingConvention = CallingConvention.Cdecl)]
public static extern void InitCSharpDelegate(LogDelegate log);
[MonoPInvokeCallback(typeof(LogDelegate))]
public static void LogMessageFromCpp(IntPtr message, int iSize)
{
    Debug.Log(Marshal.PtrToStringAnsi(message, iSize));
}
public static void ShowLog()
{
    InitCSharpDelegate(LogMessageFromCpp);
}

现在，只需要在C#代码中调用ShowLog静态函数（设置注册回调）之后，C++动态库就能回调C#端的函数了。
完整的代码示例在文章Unity显示C++动态库中的Log中，但有些差别，可以一起对照查看。

参考链接

https://blog.csdn.net/u011414997/article/details/50574434