LINQチートシート的なもの ref: https://qiita.com/Marimoiro/items/0e119b47d65bf138789a

ccharp,Foundation.cs

namespace LINQCheatSheet
{
    class Foundation
    {
        /// <summary>
        /// 基本的なメソッド
        /// </summary>
        public static void Start()
        {
            //0～9までの配列
            var enumerable = Enumerable.Range(0, 10).ToArray();

            /*
            ** f:IEnumerable -> IEnumerable メソッド
            ** 出力がリストのメソッド
            */

            //条件にあったものを検索して取得する(filter)
            //0,2,4,6,8
            var evens = enumerable.Where(i => i%2 == 0);
            Program.Write("Where",evens);

            //リストのすべての値に関数を適用したものを返す(map,射影)
            //0,1,4,9,16,25,36,49,64,81
            var aquares = enumerable.Select(i => i * i);
            Program.Write("Select",aquares);

            //先頭からいくつか取る(head)
            //0,1,2
            var oneTwoThree = enumerable.Take(3);
            Program.Write("Take",oneTwoThree);

            //幾つかを飛ばして残りを取る
            //7,8,9
            var sevenEightNine = enumerable.Skip(7);
            Program.Write("Skip",sevenEightNine);

            //先頭から条件を満たさなくなるまでとる(Whereとは一度でも条件を満たさなくなったらストップする点でちがう)
            //0,1,2,3
            var while4 = enumerable.TakeWhile(i => (i + 1)%5 != 0);
            Program.Write("TakeWhile",while4);

            //条件を満たしている間スキップして残りをとる
            //4,5,6,7,8,9
            var skip4 = enumerable.SkipWhile(i => (i + 1) % 5 != 0);
            Program.Write("SkipWhile",skip4);


            /*
            ** 一つの値を探すメソッド
            */

            //先頭を取得する
            //0
            var first = enumerable.First();
            Program.Write("First",first);

            //条件を満たす最初の要素を取得する
            //条件をみたすものがない場合例外になる
            //enumerable.First(i => i < -10); これは例外
            //1
            var firstOdds = enumerable.First(i => i%2 == 1);
            Program.Write("First(f)", firstOdds);

            //Firstの条件をみたすものがないときはdefault(T)を返すパターン
            //0
            var default0 = enumerable.FirstOrDefault(i => i < -10);
            Program.Write("FirstOrDefault(f)", default0);


            //最後を取得する
            //9
            var last = enumerable.Last();
            Program.Write("Last", last);

            //条件を満たす最後の要素を取得する
            //もちろんOrDefaultもある
            //8
            var lastEven = enumerable.Last(i => i % 2 == 0);
            Program.Write("Last(f)", lastEven);


            //リストの中に要素が一つしかない場合それを返す
            //それ以外の場合は例外
            //19
            var single = new int[1] {19}.Single();
            Program.Write("Single", single);

            //条件を満たす唯一の要素を取得する
            //複数ある場合は例外
            //もちろんOrDefaultもある(見つからない場合はdefault(T)だが複数の場合は例外)
            //9
            var nine = enumerable.Single(i => i == 9);
            Program.Write("Single(f)", nine);
        }
    }
}

csharp,Foundation.cs

namespace LINQCheatSheet
{
    class Foundation
    {
        /// <summary>
        /// 基本的なメソッド
        /// </summary>
        public static void Start()
        {
            //0～9までの配列
            var enumerable = Enumerable.Range(0, 10).ToArray();

            /*
            ** f:IEnumerable -> IEnumerable メソッド
            ** 出力がシーケンスのメソッド
            */

            //条件にあったものを検索して取得する(filter)
            //0,2,4,6,8
            var evens = enumerable.Where(i => i%2 == 0);
            Program.Write("Where",evens);

            //シーケンスのすべての値に関数を適用したものを返す(map,射影)
            //0,1,4,9,16,25,36,49,64,81
            var aquares = enumerable.Select(i => i * i);
            Program.Write("Select",aquares);

            //先頭からいくつか取る(head)
            //0,1,2
            var oneTwoThree = enumerable.Take(3);
            Program.Write("Take",oneTwoThree);

            //幾つかを飛ばして残りを取る
            //7,8,9
            var sevenEightNine = enumerable.Skip(7);
            Program.Write("Skip",sevenEightNine);

            //先頭から条件を満たさなくなるまでとる(Whereとは一度でも条件を満たさなくなったらストップする点でちがう)
            //0,1,2,3
            var while4 = enumerable.TakeWhile(i => (i + 1)%5 != 0);
            Program.Write("TakeWhile",while4);

            //条件を満たしている間スキップして残りをとる
            //4,5,6,7,8,9
            var skip4 = enumerable.SkipWhile(i => (i + 1) % 5 != 0);
            Program.Write("SkipWhile",skip4);


            /*
            ** 一つの値を探すメソッド
            ** 利用順としては First >>>>>>> Single >= Last くらい
            */

            //先頭を取得する
            //0
            var first = enumerable.First();
            Program.Write("First",first);

            //条件を満たす最初の要素を取得する
            //条件をみたすものがない場合例外になる
            //enumerable.First(i => i < -10); これは例外
            //1
            var firstOdds = enumerable.First(i => i%2 == 1);
            Program.Write("First(f)", firstOdds);

            //Firstの条件をみたすものがないときはdefault(T)を返すパターン
            //0
            var default0 = enumerable.FirstOrDefault(i => i < -10);
            Program.Write("FirstOrDefault(f)", default0);


            //最後を取得する
            //9
            var last = enumerable.Last();
            Program.Write("Last", last);

            //条件を満たす最後の要素を取得する
            //もちろんOrDefaultもある
            //8
            var lastEven = enumerable.Last(i => i % 2 == 0);
            Program.Write("Last(f)", lastEven);


            //シーケンスの中に要素が一つしかない場合それを返す
            //それ以外の場合は例外
            //19
            var single = new int[1] {19}.Single();
            Program.Write("Single", single);

            //条件を満たす唯一の要素を取得する
            //複数ある場合は例外
            //もちろんOrDefaultもある(見つからない場合はdefault(T)だが複数の場合は例外)
            //9
            var nine = enumerable.Single(i => i == 9);
            Program.Write("Single(f)", nine);
        }
    }
}

file0.cs

        public static void Write<T>(string tag, IEnumerable<T> e)
        {
            Console.WriteLine(tag.PadRight(20) + String.Join(",", e));
        }

        public static void Write<T>(string tag, T e)
        {
            Console.WriteLine(tag.PadRight(20) + e);
        }

file0.txt

        public static void Write<T>(string tag, IEnumerable<T> e)
        {
            Console.WriteLine(tag.PadRight(20) + String.Join(",", e));
        }

        public static void Write<T>(string tag, T e)
        {
            Console.WriteLine(tag.PadRight(20) + e);
        }

file2.cs

namespace LINQCheatSheet
{
    class Check
    {
        /// <summary>
        /// チェックするときにとか使えるメソッド
        /// </summary>
        public static void Start()
        {

            //0～9までの配列
            var enumerable = Enumerable.Range(0, 10).ToArray();


            //要素数数える
            //配列ならLengthと同じ
            //10
            int count = enumerable.Count();
            Program.Write("Count",count);

            //条件を満たす要素数を返す
            //Where(f).Count()と同値
            //5
            int countEven = enumerable.Count(i => i%2 == 0);
            Program.Write("Count(f)", countEven);

            //すべての要素が条件をみたすならtrueさもなくばfalse
            //true
            bool all = enumerable.All(i => i < 10);
            Program.Write("All(f)",all);

            //一つでも要素があればtrue
            //Allには無い（恒真命題になるからね）
            //true
            bool any = enumerable.Any();
            Program.Write("Any", any);

            //条件を満たす要素が一つでもあればtrue
            //Count() > 0とかしちゃダメよ
            //true
            bool anyEven = enumerable.Any(i => i%2 == 0);
            Program.Write("Any(f)", anyEven);



        }
    }
}

file3.cs

var where = enumerable.Where( i => { Console.WriteLine(i);return true });

file4.cs

var array = enumerable.Where( i => { Console.WriteLine(i);return true }).ToArray();

file5.cs

namespace LINQCheatSheet
{

    class Instantiate
    {
        /// <summary>
        /// インスタンス化するメソッド
        /// Enumerableを返さないメソッドもインスタン化するけど
        /// ここではリスト系を返すメソッドを
        /// 出力は変わらないのであんまりなし
        /// </summary>
        public static void Start()
        {
            //配列化 一番単純なデータ構造なので普通はこれを選択
            //0～9までの配列
            var enumerable = Enumerable.Range(0, 10).ToArray();

            //List<T>化
            //あんまり用途はないかも
            var list = enumerable.ToList();

            //Dictionary化
            //1,24,9,16,25,36,49,64,81
            var dictionary = enumerable.ToDictionary(i => i, i => i*i);
            Program.Write("Dictionary",dictionary.Values);


        }
    }
}

file6.cs

namespace LINQCheatSheet
{
    /// <summary>
    /// 数学関数的なやつ
    /// </summary>
    class Math
    {
        public static void Start()
        {
            //0～9までの配列
            var enumerable = Enumerable.Range(0, 10).ToArray();

            //最大値
            //9
            int max = enumerable.Max();
            Program.Write("Max",max);

            //関数適用した後の最大値
            //81
            int max2 = enumerable.Max( i=> i* i);
            Program.Write("Max(f)",max2);

            //最小値
            //0
            int min = enumerable.Min();
            Program.Write("Min", min);

            //関数適用した後の最小値
            //5
            int min2 = enumerable.Min(i => i + 5 );
            Program.Write("Min(f)", min2);


        }
    }
}

file7.cs

namespace LINQCheatSheet
{
    class Generate
    {
        /// <summary>
        /// シーケンスを作成するメソッド
        /// </summary>
        public static void Start()
        {

            //startからcount個の連番のシーケンスを生成します
            //0,1,2,3,4,5,6,7,8,9
            var enumerable = Enumerable.Range(0, 10);
            Program.Write("Range",enumerable);

            //Rangeにはいくつ飛ばすという引数がありませんが、もしそのようなシーケンスが作りたい場合は
            //Selectと合わせて作ります
            //0,2,4,6,8,10,12,14,16,18
            var evens = enumerable.Select(i => i*2);
            Program.Write("Range+Select", evens);

            //同じ値をcount回繰り返すシーケンスを作ります
            //4,4,4,4,4
            var repeat = Enumerable.Repeat(4, 5);
            Program.Write("Repeat", repeat);

            //Repeatは同じ値を繰り返すだけで毎回式を評価するわけではないことに注意

            //例えばこれはNext1回の結果が5回繰り返されるだけに注意
            //n,n,n,n,nになる(nは一つの同じ値)
            //var rnd = new Random();
            //Enumerable.Repeat(rnd.Next(), 5);

            //ランダムな5つの数値がほしいならこうすべき
            //(インスタンス生成とかも同じ要領で)
            //_は値を使わないことの明示(Rxとかの慣例ってだけです)
            var rnd = new Random();
            var rnds = new int[5].Select(_ => rnd.Next()); //new int[5]は0を5個の配列になる
            Program.Write("Randoms", rnds);

            //空のシーケンスを返すだけ(いわゆるφ空集合)
            //あんまり用途ないけど戻り値nullだと駄目なパターンとか
            //型引数は推論できないため明示してあげる必要あり
            //出力なし
            var empty = Enumerable.Empty<int>();
            Program.Write("Empty", empty);


        }
    }
}

file8.cs

namespace LINQCheatSheet
{
    class Connect
    {
        /// <summary>
        /// 2つのシーケンスを合成する
        /// といっても合成方法はいろいろ
        /// Ixだと2つ以上の合成できたり
        /// </summary>
        public static void Start()
        {
            //合成なので0～4のシーケンスとそれを自乗したシーケンスの２つをご用意
            var enumerable = Enumerable.Range(0, 5).ToArray();
            var other = enumerable.Select(i => i*i).ToArray();

            //単純に２つつなげるだけ(cat)
            //0,1,2,3,4,0,1,4,9,16
            var concat = enumerable.Concat(other);
            Program.Write("Concat",concat);

            //concatの次点で使いやすいメソッド
            //２つのシーケンスのi番目の要素同士を第二引数のFunc<TFirst, TSecond>で合成する
            //.Net4以上なのでUnityでは使えない$形式のフォーマットも使えない・・・悲しみ
            //(0,0),(1,1),(2,4),(3,9),(4,16)
            var zip = enumerable.Zip(other, (e, o) => $"({e},{o})");
            Program.Write("Zip", zip);


            //こっからあんまり使った記憶が無い

            //Zipより複雑なバージョン
            //Zipはi番目の要素同士を合成していたがこちらは要素それぞれがキーを作成して
            //そのキーが一致していたら第4引数で合成する　結構ややこしいし重いし使いドコロ難しい
            //(0,1),(1,4),(2,9),(3,16)

            var join = enumerable.Join(other, e => (e + 1)*(e + 1), o => o, (e, o) => $"({e},{o})");
            Program.Write("Join", join);

            //因みに同じキーを生成したものが複数ある場合それぞれが合致する
            //(0,0),(0,1),(1,0),(1,1),(2,0),(2,1),(3,0),(3,1),(4,0),(4,1)
            var joinDuplicate = enumerable.Join(other, e => 0, o => System.Math.Max(o - 1, 0), (e, o) => $"({e},{o})");
            Program.Write("JoinDuplicate", joinDuplicate);

            /*
            *  以下集合演算
            */

            //いわゆる和集合
            //0,1,2,3,4,9,16
            var union = enumerable.Union(other);
            Program.Write("Union",union);

            //いわゆる積集合
            //0,1,4
            var intersect = enumerable.Intersect(other);
            Program.Write("Intersect", intersect);

            //いわゆる差集合
            //0,1,4
            var except = enumerable.Except(other);
            Program.Write("Except", except);

            //ちなみに排他的論理和取りたければこうすればいい
            //2,3,9,16
            var xor = union.Except(intersect);
            Program.Write("Xor",xor);
        }
    }
}