3

我有以下形状的数据

someArray = [{ Name: "Some Class", TypeEnum: "Default" },
 { Name: "Some Class", TypeEnum: "Other" },
 { Name: "Some Class 2", TypeEnum: "Default" },
 { Name: "Some Class 2", TypeEnum: "Other" },
 { Name: "Some Class 3", TypeEnum: "Default" },
 { Name: "Some Class 4", TypeEnum: "Not Other" }]

将它们中的每一个想象成 C# 中的对象

我需要的是该数组的一个不同版本的数组，优先选择一个选定的 TypeEnum。例如，如果我选择了其他的 TypeEnum，如果找不到具有“其他”TypeEnum 的类的版本，我仍然希望它默认为默认值

例如选择“其他”作为类型枚举，上面的数据看起来像

 [{ Name: "Some Class", TypeEnum: "Other" },
 { Name: "Some Class 2", TypeEnum: "Other" },
 { Name: "Some Class 3", TypeEnum: "Default" }]

我现在正在做的是从这里开始的 lambda 比较

TypeEnum myEnum = "Other"
someArray.Distinct((x,y) => x.Name == y.Name && 
                   x.TypeEnum != myEnum && 
                   (y.TypeEnum == myEnum || y.TypeEnum == "Default"));

我希望 Distinct 从数组中弹出任何从该表达式中得到为真的 x 。

我认为 Distinct 的工作方式是错误的。如果我是，我应该用什么代替？

4

4 回答 4

2

您可以定义一个Comparer<T>类来处理您的比较偏好，如下所示：

public class SomeClassComparer : Comparer<SomeClass>
{
    private TypeEnum _preference;

    public SomeClassComparer(TypeEnum preference)
        : base()
    {
        _preference = preference;
    }

    public override int Compare(SomeClass x, SomeClass y)
    {
        if (x.Name.Equals(y.Name))
        {
            return x.TypeEnum == y.TypeEnum ? 0
                : x.TypeEnum == _preference ? -1
                : y.TypeEnum == _preference ? 1
                : x.TypeEnum == TypeEnum.Default ? -1
                : y.TypeEnum == TypeEnum.Default ? 1
                : x.TypeEnum.CompareTo(y.TypeEnum);
        }
        else
            return x.Name.CompareTo(y.Name);
    }
}

更新：如果您只对首选或 Default 的元素感兴趣，则TypeEnum可以先过滤掉其余的元素。然后根据比较器对数组进行排序，即给予TypeEnum比默认更高的优先级。最后按对象的名称对对象进行分组，并从每个组中取出第一个：

var result = someArray.Where(x => x.TypeEnum == TypeEnum.Default || x.TypeEnum == myEnum)
                      .OrderBy(x => x, new SomeClassComparer(myEnum))
                      .GroupBy(x => x.Name)
                      .Select(x => x.First());

或者，如果您不想定义 Comparer 类，可以使用以下版本：

Comparison<SomeClass> compareByTypeEnum = (x, y) =>
{
    if (x.Name.Equals(y.Name))
    {
        return x.TypeEnum == y.TypeEnum ? 0
            : x.TypeEnum == myEnum ? -1
            : y.TypeEnum == myEnum ? 1
            : x.TypeEnum == TypeEnum.Default ? -1
            : y.TypeEnum == TypeEnum.Default ? 1
            : x.TypeEnum.CompareTo(y.TypeEnum);
    }
    else
        return x.Name.CompareTo(y.Name);
};
Array.Sort(someArray, compareByTypeEnum);
var result = someArray.Where(x => x.TypeEnum == TypeEnum.Default || x.TypeEnum == TypeEnum.Other)
                      .GroupBy(x => x.Name)
                      .Select(x => x.First());
于 2012-11-09T06:46:34.717 回答
1

您可以使用 GroupBy 获取字典来完成此类工作。可能它也简单得多。

List<Tuple<string, string>> lst = new List<Tuple<string, string>>();
lst.Add(new Tuple<string, string>("Some Class", "Default"));
lst.Add(new Tuple<string, string>("Some Class", "Other"));
lst.Add(new Tuple<string, string>("Some Class 2", "Default"));
lst.Add(new Tuple<string, string>("Some Class 2", "Other"));
lst.Add(new Tuple<string, string>("Some Class 3", "Default"));

var dict = lst.GroupBy(g => g.Item1)
              .ToDictionary(g => g.Key, k => k.Select(s => s.Item2)
                                              .Where(p => p == "Other")
                                              .DefaultIfEmpty("Default")
                                              .First());

或者在你的情况下：

TypeEnum myEnum = "Other"
var dict = lst.GroupBy(g => g.Name)
    .ToDictionary(g => g.Key, k => k.Select(s => s.TypeEnum)
                                .Where(p => p == myEnum)
                                .DefaultIfEmpty("Default")
                                .First());
于 2012-11-09T06:49:59.033 回答
1

Distinct 无法按照您想要的方式工作，这就是为什么您可能永远无法让它自己工作的原因。Distinct 使用哈希表来查找唯一值。它按顺序将每个项目添加到哈希表中，并省略添加哈希值等于哈希表中已经存在的任何其他值的任何值。

这意味着您的项目的顺序很重要，因为数组中的第一个项目获胜。我们可以通过在调用 distinct 之前修改列表的顺序来利用这一点。稍微修改@Fung的解决方案，我们得到这个......

var result = someArray.OrderBy(key => key.TypeEnum, new TypeEnumComparer(myEnum))
    .Distinct(new LambdaEqualityComparer<SomeClass>((x, y) => x.Name == y.Name));

使用修改后的比较器...

public class TypeEnumComparer : Comparer<TypeEnum>
{
    private TypeEnum _preference;

    public TypeEnumComparer(TypeEnum preference)
        : base()
    {
        _preference = preference;
    }

    public override int Compare(TypeEnum x, TypeEnum y)
    {
        if (x == y)                return 0;
        if (x == _preference)      return -1;
        if (y == _preference)      return 1;
        if (x == TypeEnum.Default) return -1;
        if (y == TypeEnum.Default) return 1;

        return x.CompareTo(y);
    }
}
于 2012-11-09T07:18:15.557 回答
0

试试这个，使用DefaultIfEmpty("Default")

        var someArray = new List<TestClass>
                            {
                                new TestClass {Name = "Some Class", TypeEnum = "Default"},
                                new TestClass {Name = "Some Class", TypeEnum = "Other"},
                                new TestClass {Name = "Some Class 2", TypeEnum = "Default"},
                                new TestClass {Name = "Some Class 2", TypeEnum = "Other"},
                                new TestClass {Name = "Some Class 3", TypeEnum = "Default"}
                            };

        string myEnum = "Other";

        var result = someArray.GroupBy(t => t.Name).
                     Select(t => new TestClass
                       {
                           Name = t.Key,
                           TypeEnum = t.Select(s => s.TypeEnum).Where(p => p == myEnum).DefaultIfEmpty("Default").FirstOrDefault()
                       });
于 2012-11-09T06:46:43.173 回答