以與第一個串列相同的順序對物件串列中的多個串列進行排序-有解無憂

我有這個包含兩個字串串列的物件串列，它們是鏈接的我想對這兩個串列進行排序，valeurs并ProductUid 取決于 valeurs 的順序。

串列產品：

[
    {
        "groupBy": "coloris",
        "valeurs": [
            "Beige",
            "Gris clair",
            "Anthracite",
            "Beige",
            "Augusta",
            "Venezia"
        ],
        "ProductUid": [
            "TEST1",
            "TEST2",
            "TEST3",
            "TEST4",
            "TEST5",
            "TEST6"
        ]
    },
    {
        "groupBy": "ref_commercial",
        "valeurs": [
            "29245",
            "51625",
            "25269",
            "29245",
            "72585",
            "72584"
        ],
        "ProductUid": [
            "TEST1",
            "TEST2",
            "TEST3",
            "TEST4",
            "TEST5",
            "TEST6"
        ]
    }
]

所以最終的結果會是這樣。

排序結果：

    [
    {
        "groupBy": "coloris",
        "valeurs": [
            "Anthracite",
            "Augusta",
            "Beige",
            "Beige",
            "Gris clair",
            "Venezia"
        ],
        "ProductUid": [
            "TEST3",
            "TEST5",
            "TEST1",
            "TEST4",
            "TEST2",
            "TEST6"
        ]
    },
    {
        "groupBy": "ref_commercial",
        "valeurs": [
            "25269",
            "29245",
            "29245",
            "51625",
            "72584",
            "72585"
        ],
        "ProductUid": [
            "TEST3",
            "TEST1",
            "TEST4",
            "TEST2",
            "TEST6"
            "TEST5",
        ]
    }
]

我已經做的是

在創建 listProduct 時

var result = lProd.SelectMany(x => x.Caracteristiques.Distinct(), (parentObj, childnum) =>
new
{
    parentObj,
    childnum
})
.GroupBy(x => x.childnum.nom)
.Select(x => new 
{
groupBy = x.Key,
valeurs = x.Select(z => z.childnum.valeur).OrderBy(q => q), // Sort List Valeurs
ProductUid = x.Select(z => z.parentObj.ProductUid), // Want to do the same sort here
}).Where(sid => OrdredList.Any(si => si == sid.groupBy))
.OrderBy(x => OrdredList.IndexOf(x.groupBy));

我能夠對valeurs串列進行排序，但找不到在 productUID 上使用相同排序的方法，

請問有辦法嗎？

uj5u.com熱心網友回復：

您可以創建索引串列并通過在第一個串列中查找值對其進行排序，然后使用索引從第二個串列中選擇值。假設串列長度相等：

var l1 = new[] {1, 0, 2, 3};
var l2 = new[] {"b", "a", "c", "d"};
var indices = new int[l1.Length];
for (int i = 0; i < indices.Length; i  )
{
    indices[i] = i;
}

var sortedIndices = indices.OrderBy(i => l1[i]).ToList();
var l2Sorted = sortedIndices.Select(i => l2[i]).ToList();
var l1Sorted = sortedIndices.Select(i => l1[i]).ToList();
Console.WriteLine(string.Join(", ", l2Sorted));

uj5u.com熱心網友回復：

為了使您的任務更容易，我建議您將物件的結構更改為 (property, uid) 的元組。即使您不需要排序，我也建議您這樣做。

.Select(x => new 
{
    groupBy = x.Key,
    valeursAndUids = x
        .Select(z => (Valeur: z.childnum.valeur, Uid: z.parentObj.ProductUid))
        .OrderBy(q => q.Valeur)
}

uj5u.com熱心網友回復：

該程式產生所需的輸出：

var json = File.ReadAllText("data.json");

var list = JsonSerializer.Deserialize<List<X>>(json);

foreach(var x in list)
{
    var combined = x.valeurs.Zip( x.ProductUid, (valuer, uid) => (valuer, uid) );

    var sorted = combined.OrderBy(p => p.valuer);

    x.valeurs = sorted.Select( p => p.valuer).ToList();
    x.ProductUid = sorted.Select( p => p.uid).ToList();

// Or 
// var combined = x.valeurs.Zip(x.ProductUid);
// var sorted = combined.OrderBy(p => p.First);
// x.valeurs = sorted.Select( p => p.First).ToList();
// x.ProductUid = sorted.Select( p => p.Second).ToList();
}



Console.WriteLine(JsonSerializer.Serialize(list, new JsonSerializerOptions()
{
    WriteIndented = true
}));

class X {
    public List<string> valeurs {get; set; }
    public List<string> ProductUid {get; set; }
}

uj5u.com熱心網友回復：

這是實作此目的的一種相對簡單的方法：

var x = j.Select(e => {
        var map = e.Valeurs.Select((v, i) => (v, i)).OrderBy(t => t.v).Select(t => t.i).ToArray();

        return new SomeNamespace.SomeRoot
        {
            GroupBy = e.GroupBy,
            Valeurs = map.Select(i => e.Valeurs[i]).ToArray(),
            ProductUid = map.Select(i => e.ProductUid[i]).ToArray(),
        };
    }
);

j是原始 JSON 的物件表示。我將在答案的末尾給出決議它的類。本質上j是一個 2 長陣列SomeRoot，一個具有string GroupBy，string[] Valuers和string[] ProjectUids屬性的物件。它表示根 json 陣列中的物件

我們做的第一件事，在這條線上：

var map = e.Valeurs.Select((v, i) => (v, i)).OrderBy(t => t.v).Select(t => t.i).ToArray();

即，對于每個根物件，將投影e.Valuers到一個元組，該元組包括在處找到值的索引i。然后我們按值排序v；這意味著我們有一個排序陣列，它記住原始元素的找到位置：Anthracite在索引處，2但排序后陣列有一個元組(Anthracite, 2)作為它的第一個元素。整個陣列看起來像：

[
  (Anthracite, 2),      <-- now in slot 0 but remembers it used to be in slot 2
  (August, 4),
  (Beige, 0),
  (Beige, 3),
  (Gris clair, 1)
  (Venezia, 5)
]

這種“關于它在哪里的記憶”以后會很有用。我們接下來要做的就是扔掉Anthraciteetc 并保留2etc

這意味著它map是一個整數陣列，運行如下[2,4,0,3,1,5]

如果您按此順序（2、4、0、3、1、5）訪問原始 Valuers 陣列，您將按順序獲得顏色，Anthracite、August、Beige、Beige..

..因此您也可以使用相同的地圖陣列來訪問 ProjectUids 以獲取相同的順序，2,4,0,3,1,5

因此，您的新 Valuers 和 ProjectUid 陣列變為：

Valeurs = map.Select(i => e.Valeurs[i]).ToArray(),
ProductUid = map.Select(i => e.ProductUid[i]).ToArray(),

你可以把它想象成 * 因為map[0] == 2原來陣列中索引 2 中的內容現在位于排序陣列的索引 0 中。地圖陣列本質上映射“它需要在哪里：它實際上在哪里”

To change what you sort by, alter .OrderBy(t => t.v) - t is a tuple of v, the original Valuer value, and i, the index where it was found..

Here is the full code from your JSON to your requirement, including the classes for parsing your json:

//impl
            var s = 
@"[
    {
        ""groupBy"": ""coloris"",
        ""valeurs"": [
            ""Beige"",
            ""Gris clair"",
            ""Anthracite"",
            ""Beige"",
            ""Augusta"",
            ""Venezia""
        ],
        ""ProductUid"": [
            ""TEST1"",
            ""TEST2"",
            ""TEST3"",
            ""TEST4"",
            ""TEST5"",
            ""TEST6""
        ]
    },
    {
        ""groupBy"": ""ref_commercial"",
        ""valeurs"": [
            ""29245"",
            ""51625"",
            ""25269"",
            ""29245"",
            ""72585"",
            ""72584""
        ],
        ""ProductUid"": [
            ""TEST1"",
            ""TEST2"",
            ""TEST3"",
            ""TEST4"",
            ""TEST5"",
            ""TEST6""
        ]
    }
]";

            var j = SomeNamespace.SomeRoot.FromJson(s);

            var x =  j.Select(e => {
                    var map = e.Valeurs.Select((v, i) => (v, i)).OrderBy(t => t.v).Select(t => t.i).ToArray();

                    return new SomeNamespace.SomeRoot
                    {
                        GroupBy = e.GroupBy,
                        Valeurs = map.Select(i => e.Valeurs[i]).ToArray(),
                        ProductUid = map.Select(i => e.ProductUid[i]).ToArray(),
                    };
                }
            );




//parsing classes
namespace SomeNamespace
{
    using System;
    using System.Collections.Generic;

    using System.Globalization;
    using Newtonsoft.Json;
    using Newtonsoft.Json.Converters;

    public partial class SomeRoot
    {
        [JsonProperty("groupBy")]
        public string GroupBy { get; set; }

        [JsonProperty("valeurs")]
        public string[] Valeurs { get; set; }

        [JsonProperty("ProductUid")]
        public string[] ProductUid { get; set; }
    }

    public partial class SomeRoot
    {
        public static SomeRoot[] FromJson(string json) => JsonConvert.DeserializeObject<SomeRoot[]>(json, SomeNamespace.Converter.Settings);
    }

    public static class Serialize
    {
        public static string ToJson(this SomeRoot[] self) => JsonConvert.SerializeObject(self, SomeNamespace.Converter.Settings);
    }

    internal static class Converter
    {
        public static readonly JsonSerializerSettings Settings = new JsonSerializerSettings
        {
            MetadataPropertyHandling = MetadataPropertyHandling.Ignore,
            DateParseHandling = DateParseHandling.None,
            Converters =
            {
                new IsoDateTimeConverter { DateTimeStyles = DateTimeStyles.AssumeUniversal }
            },
        };
    }
}

轉載請註明出處，本文鏈接：https://www.uj5u.com/qiye/453237.html

標籤：C＃林克

上一篇：LINQ-將具有多個條目的搜索詞與具有多個條目的另一個字串進行比較

下一篇：LINQ查詢-自定義輸出、組標題