C# で複数の戻り値を返す

# はじめに

C# では、関数の戻り値は `void` または任意の型をひとつ指定します。複数の戻り値を返したい場合にそのままでは返せないため、[タプル](https://learn.microsoft.com/ja-jp/dotnet/csharp/language-reference/builtin-types/value-tuples)を使うのが有効です。

```cs
(int age, string name) GetPerson() => (20, "Taro");

// タプルで受け取り
var person = GetPerson();

// 分解して受け取り
(var age, var name) = GetPerson();
```

## タプル要素名の大文字小文字問題

<https://ufcpp.net/blog/2018/12/tupleelementcase/>

C# では `public` なメンバーは PascalCase が一般的です。メソッドの引数は camelCase が一般的です。ここで、タプル要素名の大文字小文字問題が起こります。

- 立場1: 構造体のフィールド派
- 立場2: 引数の一般化派

両者は**殴り合い**に発展し、ついに「**`public` なところでタプルは使うな**」というお触れが出るに至ります。

この問題は後述のレコード型を使うことで穏便に解消できそうです。

## レコード型

<https://learn.microsoft.com/ja-jp/dotnet/csharp/fundamentals/types/records>


C# 9.0 で、レコード型 `record class` が、C# 10.0 で値レコード型 `record struct` が追加されました。

```cs
file record ClassRecord(int X, int Y);

file record struct ValueRecord(int X, int Y);

// 参照型のレコード
ClassRecord classRecord = new ClassRecord(1, 2);
// 分解
(x, y) = classRecord;
// with 式
(x, y) = classRecord with { X = 3 };

// 値型のレコード
ValueRecord valueRecord = new ValueRecord(1, 2);
// 分解
(x, y) = valueRecord;
// with 式
(x, y) = valueRecord with { X = 3 };
```

**１行で型定義**できるため手間がかかりません。それだけではなく、この手の型では毎回必要だった `Equals()` や `GetHashCode()` のオーバーライド、`IEquatable<T>` の継承もコンパイラが自動で実装してくれます。  
一応、通常の値型を定義したときに標準で機能する `Equals()` と `GetHashCode()` はありますが、リフレクションを使ったものであり、あまりパフォーマンスはよくないです。

## 参照引数問題

C# にタプルがない頃は別の方法を使う必要がありました。戻り値型を定義する方法と、参照引数を使う方法です。  
戻り値型を定義する方法は、戻り値を表すことにしか使い道のない型を作るという微妙な作業が必要でした。現在ではレコード型があるため煩わしさも減り、この方法が有効です。[`file` 型修飾子](https://learn.microsoft.com/ja-jp/dotnet/csharp/language-reference/keywords/file)も追加されたため、より可視性を狭めることも可能です。

参照引数（`ref` `out`）を使う伝統的な方法もあります。

```cs
void GetPersonReference(out int age, out string name)
{
    age = 20;
    name = "Taro";
}
```

しかしながら、今日ではこの方法は微妙とされています。参照引数はローカル関数やラムダ式からアクセスできないですし、非同期処理でも使えません。

```cs
void GetPersonReference(out int age, out string name)
{
    age = 20;
    name = "Taro";
    void SetAge() => age = 30; // エラー！
}

async Task GetPersonAsync(out int age, out string name) // エラー！
{
    age = await Task.Run(() => 20);
    name = await Task.Run(() => "Taro");
}
```

一応 ↓ の場合に、参照引数を採用する余地がありそうです。

> - 複数のオーバーロードを用意したい場合（タプルというか、戻り値だとオーバーロードできない）
> - `Try` パターンなんかだと、単一の `bool` を返す意味がある。`if` ステートメントの条件式とかで使えるように

<https://ufcpp.net/blog/2016/8/rickuproslyn0827/>

```cs
var str = "123";
if (int.TryParse(str, out var value))
{
    // value を使う
}
```

## 古い機能

これらは .NET Framework 時代からの機能ですが、やや古く機能が少ないので、特に理由がなければ値型タプルやレコード型を使うほうがよさそうです。

- 参照型タプル <https://learn.microsoft.com/ja-jp/dotnet/api/system.tuple-2?view=net-8.0>
- 匿名型 <https://learn.microsoft.com/ja-jp/dotnet/csharp/fundamentals/types/anonymous-types>

<details>
<summary>古い機能</summary>

```cs
int x, y;

// 参照型タプル
System.Tuple<int, int> classTuple = Tuple.Create(1, 2);
// 分解
(x, y) = classTuple;
// with 式は使えない！
// (x, y) = classTuple with { X = 3 }; // エラー

// 匿名型（参照型）
var anonymousType = new { X = 1, Y = 2 };
// 分解できない！
// (x, y) = anonymousType; // エラー
// with 式
var anonymousTypeWith = anonymousType with { X = 3 };
```

</details>

## おわりに

パフォーマンス比較します。見た感じ、特に理由がなければ `ValueTuple` か `ValueRecord` を使うのがよさそうです。

| Test          | Score |      % |  CG0 |
| ------------- | ----: | -----: | ---: |
| ValueTuple    | 1,929 | 100.0% |    0 |
| ClassRecord   |   407 |  21.1% |  116 |
| ValueRecord   | 1,814 |  94.0% |    0 |
| ClassTuple    |   394 |  20.4% |  113 |
| AnonymousType |    21 |   1.1% |   30 |

実行環境: Windows11 x64 .NET Runtime 9.0.0  
**Score** は高いほどパフォーマンスがよいです。  
**GC0** はガベージコレクション回数を表します（少ないほどパフォーマンスがよい）。

- ValueTuple と ValueRecord は値型のため高速です。
- ClassRecord と ClassTuple は参照型のためヒープにメモリが確保され、値型に比べると少しパフォーマンスが下がります。
- AnonymousType は `dynamic` を使用しているため低速です。

<details>
<summary>テストコード</summary>

```cs
using Xunit;

file record ClassRecord(int X, int Y);

file record struct ValueRecord(int X, int Y);

public class _TupleTest
{
    (int age, string name) GetPerson() => (20, "Taro");

    void GetPersonReference(out int age, out string name)
    {
        age = 20;
        name = "Taro";
        // void SetAge() => age = 30;
    }

    // async Task GetPersonAsync(out int age, out string name)
    // {
    //     age = await Task.Run(() => 20);
    //     name = await Task.Run(() => "Taro");
    // }

    void ExampleTryPattern()
    {
        var str = "123";
        if (int.TryParse(str, out var value))
        {
            // value を使う
        }
    }

    /// <summary>
    /// 戻り値のタプル要素名は省略できる<br/>
    /// 戻り値の第１要素は X 成分を表す<br/>
    /// 戻り値の第２要素は Y 成分を表す
    /// </summary>
    /// <param name="x"></param>
    /// <param name="y"></param>
    (int, int) GetTuple(int x, int y) => (x, y);

    void Example1()
    {
        // 受け取り側で名前をつける
        (var x, var y) = GetTuple(1, 2);
    }

    void Example2()
    {
        int x, y;

        // 値型のタプル
        (int X, int Y) valueTuple = (1, 2);
        // 分解
        (x, y) = valueTuple;
        // with 式
        (x, y) = valueTuple with { X = 3 };

        // 参照型のレコード
        ClassRecord classRecord = new ClassRecord(1, 2);
        // 分解
        (x, y) = classRecord;
        // with 式
        (x, y) = classRecord with { X = 3 };

        // 値型のレコード
        ValueRecord valueRecord = new ValueRecord(1, 2);
        // 分解
        (x, y) = valueRecord;
        // with 式
        (x, y) = valueRecord with { X = 3 };
    }

    void Example3()
    {
        int x, y;

        // 参照型のタプル
        System.Tuple<int, int> classTuple = Tuple.Create(1, 2);
        // 分解
        (x, y) = classTuple;
        // with 式は使えない！
        // (x, y) = classTuple with { X = 3 }; // エラー

        // 匿名型（参照型）
        var anonymousType = new { X = 1, Y = 2 };
        // 分解できない！
        // (x, y) = anonymousType; // エラー
        // with 式
        var anonymousTypeWith = anonymousType with { X = 3 };
    }

    [Fact]
    void TupleTest()
    {
        var tuple = (1, 2);
        (var x, var y) = tuple;
        var tuple2 = GetTuple2(x, y);

        Assert.Equal(tuple, tuple2);
    }

    static (int, int) GetTuple2(int x, int y) => (x, y);

    static Action ValueTuplePerformance()
    {
        (int x, int y) GetTuple(int n) => (n, n * 2);

        return () =>
        {
            var sum = 0;
            for (int n = 0; n < 100000; ++n)
            {
                var (x, y) = GetTuple(n);
                sum += x + y;
            }
        };
    }

    static Action ClassRecordPerformance()
    {
        ClassRecord GetClassRecord(int n) => new ClassRecord(n, n * 2);

        return () =>
        {
            var sum = 0;
            for (int n = 0; n < 100000; ++n)
            {
                var record = GetClassRecord(n);
                sum += record.X + record.Y;
            }
        };
    }

    static Action ValueRecordPerformance()
    {
        ValueRecord GetValueRecord(int n) => new ValueRecord(n, n * 2);

        return () =>
        {
            var sum = 0;
            for (int n = 0; n < 100000; ++n)
            {
                var record = GetValueRecord(n);
                sum += record.X + record.Y;
            }
        };
    }

    static Action ClassTuplePerformance()
    {
        System.Tuple<int, int> GetTuple(int n) => Tuple.Create(n, n * 2);

        return () =>
        {
            var sum = 0;
            for (int n = 0; n < 100000; ++n)
            {
                var tuple = GetTuple(n);
                sum += tuple.Item1 + tuple.Item2;
            }
        };
    }

    static Action AnonymousTypePerformance()
    {
        object GetAnonymousType(int n) => new { X = n, Y = n * 2 };

        return () =>
        {
            var sum = 0;
            for (int n = 0; n < 100000; ++n)
            {
                dynamic anonymousType = GetAnonymousType(n);
                sum += anonymousType.X + anonymousType.Y;
            }
        };
    }
}

```

</details>