【C#】動的List(dynamic)内でsortを実行したい

Question

こんにちは。今回もよろしくお願いします。

前提・実現したいこと

下図の構成のようなListがあります。（LINQで作成）
構成は維持したまま、c[]内のresult　全てに対して、Choiseの値をキーにして昇順にソートを掛けたいのですが
エラーとなってしまいます。
式ツリー型にキャストすれば解決するのではという予測はついているのですがどのようにキャストするのか見当が付きません。

該当のソースコード

            c.ForEach(x => x.result.Sort((a,b) => string.Compare(a.Choise,b.Choise)));

発生している問題・エラーメッセージ

ラムダ式を最初にデリゲート型または式ツリー型にキャストせずに、動的にディスパッチされる操作の引数として使用することはできません

※(a,b) => string.Compare(a.Choise,b.Choise)　部分に波線

補足

LINQで求めているなら、orderbyをすればよいのでは　と思われるかもしれませんが、
LINQで求めたのちにListに対してadd処理を行っている為、再度sortしなおす必要があると考えています。

2020/3/23/16：58追記

より本番環境に近い形のサンプルコードを作成しました。

        private void test()
        {

            List<string[]> data1 = new List<string[]>();


            List<dynamic> c = new List<dynamic>();


            data1.Add(new string[2] { "1.aaa", "2.aaa" });
            data1.Add(new string[2] { "3.bbb", "2.bbb" });
            data1.Add(new string[2] { "2.ccc", "1.ccc" });


            int item_count = 0;
            for (int j = 0; j < 2; j++)
            {

                c.Add(new
                {
                    title = j.ToString() + ".test",
                    result = data1.GroupBy(x => x[item_count])
                             .Select(x => new { Choise = x.Key, Count = x.Count() })
                             .ToList()
                });

                item_count++;

            }

            foreach (var item in c)
            {
                List<dynamic> list = item.result;
                list.Sort((a, b) => string.Compare(a.Choise, b.Choise));
            }
        }

2020/3/23/14：55追記　（廃止）　

以下誤りです.
ご指摘により該当のListを作成するコードを作成しました。

        private void test()
        {

            List<dynamic> c = new List<dynamic>() {
                new {
                    result = new List<dynamic>()
                        {
                            new { Choise ="01.やまだ", Count = 1},
                            new { Choise ="03.さとう", Count = 3},
                            new { Choise ="02.やまもと", Count = 4}
                        },
                            title = "1.test"
                            
                    },
                new {
                    result = new List<dynamic>()
                        {
                            new { Choise ="01.aaa", Count = 1},
                            new { Choise ="03.bbb", Count = 3},
                            new { Choise ="02.ccc", Count = 4}
                        },
                            title = "2.test"
                    }
            };

           // c.ForEach(x => x.result.Sort((a, b) => string.Compare(a.Choise, b.Choise)));


        }

Comments

[Zuishin]

同じリストを回答者の手元で作れる短いコードを作って載せると解決が早いでしょう。

[inari_ken]

Zuishin様

ご指摘ありがとうございます。スモールコード作成しますので少々お待ちください

[inari_ken]

Zuishin様

作成しました。

[BluOxy]

dynamic型ではない静的な型を値(掲示されたコードでいうc）に持たせるのは難しいでしょうか。（データの取得元はJSONか何かでしょうか）

追記：動的か静的かはこの質問の本題ではなさそうなので、スルーでお願いします

[Zuishin]

これならわかりやすいです。誰か答えてくれるでしょう。こんなことはないと思いますが、もし長期間回答がつかないようなら私も試してみます。

LINQ 一発では無理で、ループ中で result を List<dynamic> にキャストしてソートするというのを result の回数だけ行えばできそうに思います。

[BluOxy]

> 既存プログラムの大部分で共用
本題から離れていると承知の上でコメントしますが、稼働中のプログラムだからこそdynamicはやめてクラスなり匿名型なりValueTupleなりに変更する方が良いと思います。これではコンパイルエラーが起きないので、未然にバグを防げません。

> 元の構成を変えてしまうと修正と検証に工数がかかってしまうため、本件に関しては構成を維持したままというところを前提とさせていただければと思います。

例えcのコレクションが持つ要素の型が静的な型に変わっても、他の参照箇所が正しく動いていたならコンパイルエラーは発生しないはずです。（つまり、影響としてはほとんどゼロの認識）
もし発生するならそこは元々正しく動かなかっただけであり、dynamicを使ったことによる弊害が出ていることになります。

この弊害をスルーすることによって今後技術的な負債を抱えるリスクがある。そのリスク対応に対して今dynamicを直す以上の工数がかかる可能性がある。ということを念頭に入れた上で構成を維持すべきかどうかは判断すべきだと思います。

Answer 1

dynamicをそのまま放置することになる意識の低い回答ですが参考程度に。

ラムダ式を最初にデリゲート型または式ツリー型にキャストせずに、動的にディスパッチされる操作の引数として使用することはできません

のエラーメッセージで示されているデリゲート型にキャストのパターンです。

Comparison<dynamic> dynamicSortComparison = 
    (dynamic a, dynamic b) => string.Compare(a.Choise, b.Choise);
foreach (var item in c)
{
    item.result.Sort(dynamicSortComparison);
}

Comments

[Zuishin]

これでできるんですね。

[inari_ken]

ご回答ありがとうございました。
いろいろと皆様のご回答でパターンを学べました。
これから他の方のご回答も一つ一つ試してどういった動作をするのか確認していきます。

ベストアンサーを決めるには私の知見が足りなさすぎて恐縮ですが、
最小コードで済んでいることと、ほぼ質問文のコードの原型を残していること
動作確認も完了したことから
こちらの方をベストアンサーとさせて頂きます。

皆様のご回答、ありがとうございました。
取り急ぎ御礼まで。

Answer 2

匿名型と dynamic が入り混じり、共変性反変性の問題もあるので手ごわいと思います。
何も考えず Comparison<T> を式木で組み立てて使いましたが、IComparer<T> の方がもしかすると簡単にできたかもしれません。

他のコードはともかく、できるところから dynamic を排除していくのをお勧めします。多用するものではありません。あと、匿名型を使う必然性も全く感じられません。これだけ再利用するのであれば普通に名前をつけたらいいと思います。

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            test();
        }

        private static void test()
        {

            List<string[]> data1 = new List<string[]>();


            List<dynamic> c = new List<dynamic>();


            data1.Add(new string[2] { "1.aaa", "2.aaa" });
            data1.Add(new string[2] { "3.bbb", "2.bbb" });
            data1.Add(new string[2] { "2.ccc", "1.ccc" });


            int item_count = 0;
            for (int j = 0; j < 2; j++)
            {

                c.Add(new
                {
                    title = j.ToString() + ".test",
                    result = data1.GroupBy(x => x[item_count])
                             .Select(x => new { Choise = x.Key, Count = x.Count() })
                             .ToList()
                });

                item_count++;

            }

            var itemType = new { Choise = "", Count = 0 }.GetType();
            var comparisonType = typeof(Comparison<>)
                .MakeGenericType(itemType);
            var compareMethod = typeof(string)
                .GetMethod("Compare", new[] { typeof(string), typeof(string) });
            var param1 = Expression.Parameter(itemType);
            var param2 = Expression.Parameter(itemType);
            var choise = itemType.GetMethod("get_Choise");
            var compare = Expression.Lambda(
                comparisonType,
                Expression.Call(
                    null,
                    compareMethod,
                    Expression.Call(param1, choise),
                    Expression.Call(param2, choise)),
                param1,
                param2
            ).Compile();

            var listType = typeof(List<>)
                .MakeGenericType(itemType);
            var sortMethod = listType.GetMethod("Sort", new[] { comparisonType });

            foreach (var item in c)
            {
                foreach (var result in item.result)
                {
                    Console.WriteLine(result);
                }
            }
            Console.WriteLine("-----");

            foreach (var item in c)
            {
                sortMethod.Invoke(item.result, new[] { compare });
            }

            foreach (var item in c)
            {
                foreach (var result in item.result)
                {
                    Console.WriteLine(result);
                }
            }
        }
    }
}

追記 IComparer<T> を使う場合(未検証)

var comparer = new Comparer(new { Choise = "", Count = 0 });
item.result.Sort(comparer);

class Comparer<T> : IComparer<T>
{
    public Comparer(T dummy) {}

    public int Compare([AllowNull] T x, [AllowNull] T y)
    {
        return string.Compare(((dynamic)x).Choise, ((dynamic)y).Choise);
    }
}

追記

IComparer と同様ダミーが気持ち悪いですが、これでキャストできますね。

List<T> ListFromDynamic<T>(dynamic list, T dummy)
{
    return (List<T>)list;
}

Comments

[inari_ken]

ご回答ありがとうございました。
内容咀嚼します。
取り急ぎ御礼まで。

Answer 3

sortを実行したい

については必要な時にOrderByをしたコレクションが返せれば必要十分に感じます。
あとdynamic 反対派です。

サンプルコードを用意しました。ポイントは以下の3つです。

• コレクションの要素をクラスに変更する
• クラスに並び替えたコレクションを取得するためのメソッドを定義する
• 使う側は必要な際にそのメソッドを呼び出す

using System.Collections.Generic;
using System.Linq;
using System;

public class Program{
    public static void Main(){
        test();
    }

    private static void test()
    {
        List<Data> c = new List<Data>() {
            new Data()
            {
                result = new List<Data2>()
                {
                    new Data2 { Choise ="01.やまだ", Count = 1},
                    new Data2 { Choise ="03.さとう", Count = 3},
                    new Data2 { Choise ="02.やまもと", Count = 4}
                },
                title = "1.test"
            },
            new Data()
            {
                result = new List<Data2>()
                {
                    new Data2 { Choise ="01.aaa", Count = 1},
                    new Data2 { Choise ="03.bbb", Count = 3},
                    new Data2 { Choise ="02.ccc", Count = 4}
                },
                title = "2.test"
            }
        };
        foreach(var data in c){
            foreach(var result in data.GetSortedResults()){
                Console.WriteLine(result.Choise);
            }
            Console.WriteLine("----");
        }
    }
}

//TODO:クラス名は適切な名称に変更する
public class Data{
    public string title { get; set; }
    public List<Data2> result { get; set; }
    public IOrderedEnumerable<Data2> GetSortedResults(){
        return result.OrderBy(x => x.Choise);
    }
}

public class Data2{
    public string Choise { get; set; }
    public int Count { get; set; }
}

Comments

[inari_ken]

ご回答ありがとうございました。
内容咀嚼します。
取り急ぎ御礼まで。

Answer 4

まずそんなことに dynamic を使っちゃ駄目です。
匿名型かValueTupleを使いましょう。

var c = new[]
{
    new
    {
        result = new[]
        {
            new { Choise ="01.やまだ", Count = 1},
            new { Choise ="03.さとう", Count = 3},
            new { Choise ="02.やまもと", Count = 4}
        }.ToList(),
        title = "1.test"
    },
    new
    {
        result = new[]
        {
            new { Choise ="01.aaa", Count = 1},
            new { Choise ="03.bbb", Count = 3},
            new { Choise ="02.ccc", Count = 4}
        }.ToList(),
        title = "2.test"
    }
}.ToList();

Comments

[inari_ken]

大変申し訳ございません。
提示したサンプルコードに誤りがあったため、再度質問を修正致しました。

ご指摘ありがとうございます。次回から作成するプログラムからに関しては安易にdynamicを使用しない設計にする予定です。
ただ、このListは既存プログラムの大部分で共用しており、元の構成を変えてしまうと修正と検証に工数がかかってしまうため、本件に関しては構成を維持したまま　というところを前提とさせていただければと思います。

なお、こうなってしまった背景は
実際は古い方のサンプルコードのようにnewをする形でListは作成しておらず
各項目ごとの配列を、その項目の集計結果（LINQ)＋項目タイトル名という形で保持しておきたかったためです。

Answer 5

Sortを使うためには、item.resultがList型で有ることを明示しないと、どのSort関数なのかわかりません。
そのため、ラムダ式のa, bの型も確定せず、エラーが出ているものだと思われます。

item.resultの型を確定させてやればいけました

foreach (var item in c)
{
  List<dynamic> list = item.result;
  list.Sort((a,b) => string.Compare(a.Choise, b.Choise));
}

Comments

[inari_ken]

大変申し訳ありません。
ご回答いただいた内容で動作することは確認できたのですが
サンプルコードのListの生成方法が誤っていたため、本番環境では動作しませんでした。

お手数おかけしますが、サンプルコードをより本番環境に近い形で作成しましたので
ご確認頂けますと幸いです。

ちなみに、本番環境でのエラー内容は下記となります。

'System.Collections.Generic.List<<>f__AnonymousType0<string,int>>' を
'System.Collections.Generic.List<object>' に変換できません'

[izmktr]

この解答を見て、何が悪いのかわからない程度の理解度や、
自分のコードに合わせて書き換える技量がないのなら、
dynamicは使うべきではありません
素直に、dynamicを使っている部分をclassを生成して作り直すべきです

[Zuishin]

そこまでの技量を求めるのは求めすぎじゃないでしょうか。List<dynamic> を List<匿名型> に書き換えるのはなかなか大変です。List<T> の場合 IEnumerable<T> と違って変性注釈が無いため、ポリモーフィズムで解決できません。よって一から書き換えねばならず、この回答のコードは参考になりません。

[izmktr]

私ならこの人が匿名型を使うことも反対しますよ

[Zuishin]

だいたい全員反対してますね。その件とは別問題です。

この回答を見て、何が悪いのかわかる「程度」の理解度や自分のコードに合わせて書き換える技量というのは結構レベルが高いという意味です。

[Zuishin]

誤解があるかもしれないので補足ですが、質問のコードは List<匿名型> なので List<dynamic> にキャストできません。そして匿名型は名前がないので List<匿名型> にキャストするのは困難です。よってこのコードから大幅に変更しなければならず、それができるレベルの人にはこのコードは必要ありません。

ということです。

[izmktr]

フレームのもとなんでやめてくれませんか？
dynamicなんてコンパイルエラーが出ず、実行時エラーの世界なんだから、
コンパイルエラーで躓かない程度の技量は求めますよ

[Zuishin]

なぜ自分でなく私がフレームの元なのか理解に苦しみますが、コンパイルエラーでつまずかない人に差し出す回答ではありませんね。私もコンパイルエラーでつまずく程度の技量です。

[inari_ken]

ご回答ありがとうございました。
内容咀嚼します。
取り急ぎ御礼まで。