C# 用LINQ匹配不变字符串

我得到了具有字符串属性的结构集合。给定一个字符串数组，我想检查是否有任何内部字符串与数组中的某些字符串匹配的结构。我是这样做的：

    struct S
    {
        public string s { get; set; }
    }

    private List<S> List = new List<S>(); // populated somewhere else

    public bool Check(params string[] arr)
    {
        return (from s1 in List
                select s1.s into s1
                where !string.IsNullOrEmpty(s1)
                join s2 in arr on s1.ToLowerInvariant() equals s2.ToLowerInvariant() select s1).Any();
    }

结构
{
公共字符串s{get；set；}
}
私有列表=新列表（）；//住在别的地方
公共布尔检查（参数字符串[]arr）
{
返回（从列表中的s1返回）
选择s1.s进入s1
其中！string.IsNullOrEmpty（s1）
将s2连接到s1上的arr中。ToLowerInvariant（）等于s2。ToLowerInvariant（）选择s1）。任意（）；
}

---

简单地说，我只想实现StringComparison.InvariantCultureInogoreCase。这样做是否恰当？它有效吗？

最有效的方法是根据现有的结构集合创建字典

var dictionary = list.ToDictionary(item=>item.s.ToLowerInvariant(),item=>item);

然后您可以在字符串数组中循环（O（n））：

---

最有效的方法是根据现有的结构集合创建字典

var dictionary = list.ToDictionary(item=>item.s.ToLowerInvariant(),item=>item);

然后您可以在字符串数组中循环（O（n））：

---

最有效的方法是根据现有的结构集合创建字典

var dictionary = list.ToDictionary(item=>item.s.ToLowerInvariant(),item=>item);

然后您可以在字符串数组中循环（O（n））：

---

最有效的方法是根据现有的结构集合创建字典

var dictionary = list.ToDictionary(item=>item.s.ToLowerInvariant(),item=>item);

然后您可以在字符串数组中循环（O（n））：

---

你可以这样做

class Program
{
    struct MyStruct
    {
        public string Data { get; set; }
    }

    static void Main(string[] args)
    {
        var list = new List<MyStruct>();
        list.Add(new MyStruct { Data = "A" });
        list.Add(new MyStruct { Data = "B" });
        list.Add(new MyStruct { Data = "C" });


        var arr = new string[] { "a", "b" };

        var result = (from s in list
                      from a in arr
                      where s.Data.Equals(a, StringComparison.InvariantCultureIgnoreCase)
                      select s).ToArray();
    }
}

类程序
{
结构MyStruct
{
公共字符串数据{get；set；}
}
静态void Main（字符串[]参数）
{
var list=新列表（）；
添加（新的MyStruct{Data=“A”}）；
添加（新的MyStruct{Data=“B”}）；
添加（新的MyStruct{Data=“C”}）；
var arr=新字符串[]{“a”，“b”}；
var结果=（来自列表中的s）
从arr中的
其中s.Data.Equals（a，StringComparison.InvariantCultureInogoreCase）
选择s）.ToArray（）；
}
}

您可以这样做

class Program
{
    struct MyStruct
    {
        public string Data { get; set; }
    }

    static void Main(string[] args)
    {
        var list = new List<MyStruct>();
        list.Add(new MyStruct { Data = "A" });
        list.Add(new MyStruct { Data = "B" });
        list.Add(new MyStruct { Data = "C" });


        var arr = new string[] { "a", "b" };

        var result = (from s in list
                      from a in arr
                      where s.Data.Equals(a, StringComparison.InvariantCultureIgnoreCase)
                      select s).ToArray();
    }
}

类程序
{
结构MyStruct
{
公共字符串数据{get；set；}
}
静态void Main（字符串[]参数）
{
var list=新列表（）；
添加（新的MyStruct{Data=“A”}）；
添加（新的MyStruct{Data=“B”}）；
添加（新的MyStruct{Data=“C”}）；
var arr=新字符串[]{“a”，“b”}；
var结果=（来自列表中的s）
从arr中的
其中s.Data.Equals（a，StringComparison.InvariantCultureInogoreCase）
选择s）.ToArray（）；
}
}

您可以这样做

class Program
{
    struct MyStruct
    {
        public string Data { get; set; }
    }

    static void Main(string[] args)
    {
        var list = new List<MyStruct>();
        list.Add(new MyStruct { Data = "A" });
        list.Add(new MyStruct { Data = "B" });
        list.Add(new MyStruct { Data = "C" });


        var arr = new string[] { "a", "b" };

        var result = (from s in list
                      from a in arr
                      where s.Data.Equals(a, StringComparison.InvariantCultureIgnoreCase)
                      select s).ToArray();
    }
}

类程序
{
结构MyStruct
{
公共字符串数据{get；set；}
}
静态void Main（字符串[]参数）
{
var list=新列表（）；
添加（新的MyStruct{Data=“A”}）；
添加（新的MyStruct{Data=“B”}）；
添加（新的MyStruct{Data=“C”}）；
var arr=新字符串[]{“a”，“b”}；
var结果=（来自列表中的s）
从arr中的
其中s.Data.Equals（a，StringComparison.InvariantCultureInogoreCase）
选择s）.ToArray（）；
}
}

您可以这样做

class Program
{
    struct MyStruct
    {
        public string Data { get; set; }
    }

    static void Main(string[] args)
    {
        var list = new List<MyStruct>();
        list.Add(new MyStruct { Data = "A" });
        list.Add(new MyStruct { Data = "B" });
        list.Add(new MyStruct { Data = "C" });


        var arr = new string[] { "a", "b" };

        var result = (from s in list
                      from a in arr
                      where s.Data.Equals(a, StringComparison.InvariantCultureIgnoreCase)
                      select s).ToArray();
    }
}

类程序
{
结构MyStruct
{
公共字符串数据{get；set；}
}
静态void Main（字符串[]参数）
{
var list=新列表（）；
添加（新的MyStruct{Data=“A”}）；
添加（新的MyStruct{Data=“B”}）；
添加（新的MyStruct{Data=“C”}）；
var arr=新字符串[]{“a”，“b”}；
var结果=（来自列表中的s）
从arr中的
其中s.Data.Equals（a，StringComparison.InvariantCultureInogoreCase）
选择s）.ToArray（）；
}
}

您还可以使用一个

哈希集，它应该具有与
字典类似的性能：

var set = new HashSet<string>(
     List.Select(x => x.s),
     StringComparer.InvariantCultureIgnoreCase);

return arr.Any(set.Contains);

var set=新HashSet(
列表。选择（x=>x.s），
StringComparer.InvariantCultureInogoreCase）；
返回arr.Any（set.Contains）；
您还可以使用一个
哈希集，它应该具有与
字典类似的性能：

var set = new HashSet<string>(
     List.Select(x => x.s),
     StringComparer.InvariantCultureIgnoreCase);

return arr.Any(set.Contains);

var set=新HashSet(
列表。选择（x=>x.s），
StringComparer.InvariantCultureInogoreCase）；
返回arr.Any（set.Contains）；
您还可以使用一个
哈希集，它应该具有与
字典类似的性能：

var set = new HashSet<string>(
     List.Select(x => x.s),
     StringComparer.InvariantCultureIgnoreCase);

return arr.Any(set.Contains);

var set=新HashSet(
列表。选择（x=>x.s），
StringComparer.InvariantCultureInogoreCase）；
返回arr.Any（set.Contains）；
您还可以使用一个
哈希集，它应该具有与
字典类似的性能：

var set = new HashSet<string>(
     List.Select(x => x.s),
     StringComparer.InvariantCultureIgnoreCase);

return arr.Any(set.Contains);

var set=新HashSet(
列表。选择（x=>x.s），
StringComparer.InvariantCultureInogoreCase）；
返回arr.Any（set.Contains）；
这里的好处是告诉哈希使用哪个比较，而不是转换每个字符串。这里的好处是告诉哈希使用哪个比较，而不是转换每个字符串。这里的好处是告诉哈希使用哪个比较，而不是转换每个字符串。这里的好处是告诉哈希使用哪个比较，而不是转换每个字符串。@greenshade！然而，有一个微妙的区别，你应该意识到。请看这里。@greenshade正是！然而，有一个微妙的区别，你应该意识到。请看这里。@greenshade正是！然而，有一个微妙的区别，你应该意识到。请看这里。@greenshade正是！然而，有一个微妙的区别，你应该意识到。请看这里。