「拡張メソッド」の記事 - Crieit

【C#】LINQ のメソッド名が SQL っぽいからラップする

2022-06-06T18:50:19+09:00

SQL チックなメソッド名

C# の LINQ to Object（以下、単に LINQ と記載）はとても便利なんですけど、メソッド名が SQL っぽくて、いまいち直感的ではない上にダサいです。例として、JavaScript と比較してみましょう。

LINQ でのメソッド名	JavaScript のメソッド名
Select	map
Where	filter
OrderBy	sort

以下は、実際に利用する例です。
JavaScript ではこう。

const hoge = [10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0];
const fuga = hoge.filter(x => x % 2 === 0).map(x => x * 2).sort();

C# ではこう。

var hoge = new[] { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
var fuga = hoge.Where(x => x % 2 == 0).Select(x => x * 2).OrderBy(x => x).ToArray();

もちろん慣れてくれば Select だろうが Where だろうがスラスラ読めるのですが、慣れていなければ引っかかるかもしれません。一方、map, filter, sort というのは直感的で意味がわかりやすいです。

ラップする

ということで、ラッパーメソッドで名前を変えます。

`Select` => `Map`

public static IEnumerable Map(this IEnumerable source, Func func)
    => source.Select(x => func(x));

public static IEnumerable Map(this IEnumerable source, Func func)
    => source.Select((x, index) => func(x, index));

`Where` => `Filter`

public static IEnumerable Filter(this IEnumerable source, Func func)
    => source.Where(x => func());

public static IEnumerable Filter(this IEnumerable source, Func func)
    => source.Where(x => func(x));

public static IEnumerable Filter(this IEnumerable source, bool func)
    => source.Where(x => func);

`OrderBy` => `Sort`

public static IOrderedEnumerable Sort(this IEnumerable sources, Func keySelector, IComparer comparer)
    => sources.OrderBy(keySelector, comparer);

public static IOrderedEnumerable Sort(this IEnumerable sources, Func keySelector)
    => sources.OrderBy(keySelector);

public static IOrderedEnumerable SortByDesc(this IEnumerable sources, Func keySelector, IComparer comparer)
    => sources.OrderByDescending(keySelector, comparer);

public static IOrderedEnumerable SortByDesc(this IEnumerable sources, Func keySelector)
    => sources.OrderByDescending(keySelector);

ソートに関しては、元の OrderBy が、昇順か降順かでメソッドが別れています。昇順のソートが OrderBy、降順のソートが OrderByDescending なので、それぞれ Sort、 SortByDesc というメソッド名でラップしましたが、ここは昇順か降順かをオプション引数で切り替える Sort という名前のメソッドにしても良いでしょう。

「昇順か降順かをメソッド名だけで判断できる」という利点はありますが、同じようなことが別の名前のメソッドで定義されているのも、個人的には気持ち悪いと感じます。

同様に、ThenBy と ThenByDescending も Then というメソッドでラップしてみます。

public static IOrderedEnumerable Sort(this IEnumerable sources, Func keySelector, IComparer comparer, bool byDesc)
    => byDesc ? sources.OrderByDescending(keySelector, comparer) 
              : sources.OrderBy(keySelector, comparer);

public static IOrderedEnumerable Sort(this IEnumerable sources, Func keySelector, bool byDesc)
    => byDesc ? sources.OrderByDescending(keySelector)
              : sources.OrderBy(keySelector);

public static IOrderedEnumerable Then(this IOrderedEnumerable sources, Func keySelector, IComparer comparer, bool byDesc)
    => byDesc ? sources.ThenByDescending(keySelector, comparer)
              : sources.ThenBy(keySelector, comparer);

public static IOrderedEnumerable Then(this IOrderedEnumerable sources, Func keySelector, bool byDesc)
    => byDesc ? sources.ThenByDescending(keySelector)
              : sources.ThenBy(keySelector);

オプション引数 byDesc を設定しました。これにより、次のようにコードを書けます。

// ラップ前
var hoge = GetEmployee.OrderBy(s => s.Age).ThenByDesc(x => x.Salary);

// ラップ後
var hoge = GetEmployee.Sort(s => s.Age).Then(s => s.Salary, byDesc: true);

もちろん引数名の byDesc を省略することもできますが、理由があり記載しています。理由については、以下の記事で解説しているので、よかったらご覧ください。

【C#】あえて引数名を書くパターン

比較

メソッド名をラップしてみることで、冒頭のコードは次のように書けるようになりました。

// 変更前
var hoge = new[] { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
var fuga = hoge.Where(x => x % 2 == 0).Select(x => x * 2).OrderBy(x => x).ToArray();

// 変更後
var hoge = new[] { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
var fuga = hoge.Filter(x => x % 2 == 0).Map(x => x * 2).Sort(x => x).ToArray();

LINQ にあまり慣れていない人でも、よりスッと入ってきやすいコードになったのではないでしょうか。

【C#】え！！C#でif式を？できらぁ！

2021-11-17T20:22:26+09:00

タイトルは正確ではありません。すいません。if式っぽく書ける条件判定関数的なものです。if式っぽく書きたかったので作ってみました。

C#のifは文であって式ではありません。式ではないので

var name = "ほげほげ君";

// こうは書けない
var exName1 = if (name.EndsWith("君")) {
                return name;
              }
              else {
                  return name + "君";
              }

// こう書く
var exName2 = "";
if (name.EndsWith("君"))
    exName = name;
else
    exName2 = name + "君";

みたいに書かなければいけません。人によるかと思いますが、これ読みにくくないですか？exName2への代入が2箇所あるので読んでて鬱陶しいです。何度もこういうコードが出てくると嫌です。

このくらいのコードであれば三項演算子で解決するという方法もあるでしょう。

var name = "ほげほげ君";
var newName = name.EndsWith("君") ? name : name + "君";

これであれば代入は1箇所ですし分かりやすいですね。しかし、次のようなケースではどうでしょう。

// 三項演算子
var newName = name.EndsWith("さん") ? Regex.Replace(name, "さん$", "君") : (name.EndsWith("君") ? name : name + "君");

// if文
var newName = "";
if (name.EndsWith("さん"))
    newName = Regex.Replace(name, "さん$", "君");
else if (name.EndsWith("君"))
    newName = name;
else
    newName = name + "君";

最後が"さん"であれば"君"に変換するという場合は、三項演算子を使えば分かりにくくなり、if else if elseでは悪戯に長くなりますし結局代入箇所が分散していますね。もっとこう、スパっと書けないものでしょうか。ということでif式っぽいものを作りました。

// ex.1
var newName1 = Ext.If(name.EndsWith("さん"), Regex.Replace(name, "さん$", "君"))
                  .ElseIf(!name.EndsWith("君"), name + "君")
                  .Else(name);

あるいは

// ex.2
var newName2 = name.EndsWith("さん").Then(Regex.Replace(name, "さん$", "君"))
                                    .ElseIf(!name.EndsWith("君"), name + "君")
                                    .Else(name);

上記のように書くためのメソッドです。条件に対して欲しい結果をメソッドチェーンで書いていけるのでなんとなく読みやすいと思います。

まずはex.1にあるIf ElseIf Elseというメソッドがこちら。

public static Tuple If(bool term, T value)
{
    if (term)
    {
        // 条件が成立する場合はvalue
        return new Tuple(true, value);
    }
    else
    {
        // 条件が成立しない場合はT型のdefault
        return new Tuple(false, default);
    }
}

public static Tuple ElseIf(this Tuple prev, bool term, T value)
{
    if (prev.Item1)
    {
        // 前の式が成立している場合はそれをそのまま返す
        return prev;
    }
    else if (term)
    {
        // 条件が成立する場合はvalue
        return new Tuple(true, value);
    }
    else
    {
        // 条件が成立しない場合はT型のdefault
        return new Tuple(false, default);
    }
}

public static T Else Else(this Tuple prev, T value)
{
    if (prev.Item1)
    {
        // 前の式が成立する場合は、その値を取り出して返す
        return prev.Item2;
    }
    else
    {
        // 前の式が成立しない場合は規定値としてvalueを返す
        return value;
    }
}

if式を実現するにあたり、前の式の計算結果と値を受け取って引き継ぎつつ、最終的には値のみを返すという処理をする必要があります。そのため、Tupleでそれらの情報を受け渡し、最終的にElseでT型の値部分のみを返しています。

ElseIfとElseではTupleの拡張メソッドを使用しています。なので、このメソッドはstaticなクラスで宣言する必要があります。

続いてex.2にあるThenについて。ex.2のElseIfとElseはex.1のものと同様です。

public static Tuple Then(this bool term, T value)
{
    if (term)
    {
        // 条件が成立する場合はvalue
        return new Tuple(true, value);
    }
    else
    {
        // 条件が成立しない場合はT型のdefault
        return new Tuple(false, default);
    }
}

これも単純にex.1のIfの引数termを、引数ではなくメソッドチェーン的に取れるようにthisキーワードで拡張したメソッドになります。thisキーワードにしている引数は明示的に指定することも可能なので、なんならex.1のIfメソッドをこのThenメソッドで代用することも可能です。(条件を指定するならIf的な名前がいいと思って別に定義しました)

ElseIfは必要に応じて省略することも、複数記述することもできます。

var point = GetPoint();
var score = Ext.If(point == 100, "S")
               .ElseIf(point >= 80, "A")
               .ElseIf(point >= 60, "B")
               .ElseIf(point >= 40, "C")
               .ElseIf(point >= 30, "D")
               .Else("E");

このように書けます。if文でちまちま書いたり三項演算子でネストして書いていくよりはるかにわかりやすいと思います。

FuncやActionを受け取るよう拡張すれば、ラムダ式などを使ってより柔軟な表現が出来るようになると思います。たとえばActionだと、

public static bool Then(this bool term, Action action)
{
    if (!term)
        return false;

    action();
    return true;
}

public static bool ElseIf(this bool previous, bool term, Action action)
{
    if (previous)
        return true;
    else if (!term)
        return false;

    action();
    return true;
}

public static void Else(this bool previous, Action action)
{
    if (previous)
        return;

    action();
}

// ***

var point = GetPoint();
(point == 100).Then(() => Console.WriteLine("S"))
              .ElseIf((point >= 80), () => Console.WriteLine("A"))
              .ElseIf((point >= 60), () => Console.WriteLine("B"))
              .ElseIf((point >= 40), () => Console.WriteLine("C"))
              .ElseIf((point >= 30), () => Console.WriteLine("D"))
              .Else(() => Console.WriteLine("E"));

こんな感じで書けます。

ジェネリクスを使用していますが制約などはつけていませんし、より最適なコードもあるかもしれません。ある程度拡張性はあると思いますが、もっといいやり方あるよ！などがあれば、是非教えてください。

【C#】拡張メソッド

2021-01-05T20:44:40+09:00

序論

C#には拡張メソッドという機能があって、まぁ知ってれば大変便利なのですが、弊社謹製レガシーライブラリはなんともまぁ前時代的な書き方をしてあり大変煩わしいしです。そのうえ誰もメンテしないから使いにくくて仕方がない、私がメンテしようにもテストコードすら書かれていないのでめんどくせぇ。というヘイト全開で拡張メソッドの素晴らしさを書いていこうと思います。弊社に届け、この思い☆

拡張メソッド

C#における拡張メソッドは、あたかもそのクラスに元からあるかのように使用できるインスタンスメソッドを実装するという方法です。

たとえば、stringにはstring.IsNullOrEmptyというメソッドがあります。引数で渡された文字列が空白またはnullの場合にtrueを返してくれるというメソッドです。

string text = "";

Console.Write(string.IsNullOrEmpty(text));
// 結果 -> true

この書き方、なんか嫌じゃないですか？つまり、textというインスタンスがIsNullOrEmptyかどうかをいちいちstringのメソッド越しに聞くの嫌じゃないですか？子どもと話してて、お父さんお母さんに「何歳ですか？」って聞いてるみたいで嫌じゃないですか？子どもに聞いて子どもに答えてほしい。なのでそうしましょう。

public static class StringExtension
{
    public static bool IsNullOrEmpty(this string text)
    {
        return string.IsNullOrEmpty(text);
    }
}

上記のメソッドを用意することで、以下のように書けます。

string text = "";

Console.Write(text.IsNullOrEmpty());
// 結果 -> true

比べてみましょう。

string text = "";

Console.Write(string.IsNullOrEmpty(text));  // 拡張メソッドじゃないver
Console.Write(text.IsNullOrEmpty());        // 拡張メソッドver

あらまぁ見てくださいよこのコード量の違いを。素晴らしいですね。

あたかも、textというインスタンスのIsNullOrEmptyメソッドを呼び出しているようでしょう。

拡張メソッド記述のポイント

拡張メソッドのポイントは3つ。

staticクラス内に記載すること
staticメソッドにすること
第1引数の頭にthisキーワードをつけること

こうすることで、そのメソッドをインスタンスメソッドのように扱うことができます。

コードがスッキリする

例えば以下のようなコードがあるとしましょう。

string result = string.Join(",", Enumerable.Range(1, 20).Select(n => ((n % 3 == 0) || $"{n}".Contain("3")) ? "アホ" : $"{n}"));

// 結果 -> 1, 2, アホ, 4, 5, アホ, 7, 8, アホ, 10, 11, アホ, アホ, 14, アホ, 16, 17, アホ, 19, 20

上記コードは1から20のうち、3の倍数と3がつく数字の時は"アホ"を、それ以外はその数字を返すコレクションを", "で区切って連結するというものですが、このコードを読む時って

まずstring.Joinがあることで何かが区切って連結される
何が区切られるかを読む

という順番で読むことになると思います。で、何が区切られるのかを読み始めたらめんどくさいコレクション操作をしていて嫌になりますね。

ですが、以下のような拡張メソッドが用意されていたらどうでしょう。

public static class GenericsExtensions
{
    public static string JoinBy(this IEnumerable source, string separater)
    {
        // nullチェックは省略
        return string.Join(separater, source);
    }
}

これを使うと、以下のように書けます。

string result = Enumerable.Range(1, 20).Select(n => ((n % 3 == 0) || $"{n}".Contain("3")) ? "アホ" : $"{n}").JoinBy(",");

// 結果 -> 1, 2, アホ, 4, 5, アホ, 7, 8, アホ, 10, 11, アホ, アホ, 14, アホ, 16, 17, アホ, 19, 20

これならどうでしょう。対象の数字を"アホ"へ変換した後に、", "で区切って連結させると自然に読めますよね。

この自然に読めるということが超重要なんです。ただでさえ頭を使うことが多いので、不要なストレスを省くようにすべきだと思います。(別の話になりますが、LINQは頭の中のロジック通りに書けて、書いてある通りに自然に読めるので本当にすごい)

拡張メソッドを上手く活用できれば、可読性を上げることもできます。

おまけですが、以下のようなアホ判定拡張メソッドを用意するともっとスッキリすることでしょう。

public static class IntExtensions
{
    public static bool IsMultipleOf(this int value, int @base)
    {
        return (value % @base == 0);
    }

    public static bool IsAho(this int value)
    {
        const int AhoTrigger = 3;
        return value.IsMultipleOf(AhoTrigger) || $"{value}".Contains($"{AhoTrigger}");
    }
}

// こう書ける
string result = Enumerable.Range(1, 20).Select(n => n.IsAho() ? "アホ" : $"{n}").JoinBy(", ");

// 結果 -> 1, 2, アホ, 4, 5, アホ, 7, 8, アホ, 10, 11, アホ, アホ, 14, アホ, 16, 17, アホ, 19, 20

終わりに

拡張メソッドは上記の通りとてもメリットが大きく、一度実装してしまえば使う側は何も考えずに使える素晴らしい機能です。再利用性や拡張性も高いです。

とりあえずよく使うstring.IsNullOrEmptyやstring.Formatなどを拡張メソッドにするだけでもかなり便利になります。

これでみんな幸せになります、めでたしめでたし…と言いたいところですが全然めでたくないのが弊社です。私は日々弊社謹製レガシーライブラリと戦っています。ちくせう。