查看字典字符串值是否包含某种模式，同时又不包含'；在C#中不包含另一个？

假设我有一本字典。

我想看看这个字典的字符串值是否包含一些字符串模式，比如说“abc”，同时不包含模式“def”和“ghi”。此外，我希望此支票不区分大小写

我可以这样写：

var options = new Dictionary<string,string>();
        ...     
if (!options.Any(kvp1 => (kvp1.Value.Contains("def", StringComparison.InvariantCultureIgnoreCase))
&& !options.Any(kvp2 => kvp2.Value.Contains("ghi", StringComparison.InvariantCultureIgnoreCase))
&& options.Any(kvp3 => kvp3.Value.Contains("abc", StringComparison.InvariantCultureIgnoreCase))                               ))
        {
        Do Something...
        }

var options=newdictionary（）；
...     
if（！options.Any（kvp1=>（kvp1.Value.Contains（“def”，StringComparison.InvariantCultureIgnoreCase））
&&！options.Any（kvp2=>kvp2.Value.Contains（“ghi”，StringComparison.InvariantCultureIgnoreCase））
&&options.Any（kvp3=>kvp3.Value.Contains（“abc”，StringComparison.InvariantCultureIgnoreCase）））
{
做点什么。。。
}

所以我想知道，有没有更优雅的方式来执行这样的操作

UPD：这段代码肯定有一个bug。我想要检查的是，values列表中至少有一个元素包含“abc”，而没有任何元素包含“def”和“ghi”。所以编辑了一些代码。

试试这个

var options = new Dictionary<string, string>();
var includedValues = new[] { "abc", "dfg" };
var excludedValues = new[] { "hij", "klm" };

var cultureInf = CultureInfo.CurrentCulture;
var containsPredicate = new Func<string, string, bool>((s1, s2) => {
    return cultureInf.CompareInfo.IndexOf(s1, s2, CompareOptions.IgnoreCase)>=0;
}); 

if (
includedValues.All(v => options.Values.Any(kv =>containsPredicate(kv, v)))
&&
excludedValues.All(v => !options.Values.Any(kv =>containsPredicate(kv, v))))
{
    // do smthg
}

var options=newdictionary（）；
var includedValues=new[]{“abc”，“dfg”}；
var excludedValues=新[]{“hij”，“klm”}；
var cultureInf=CultureInfo.CurrentCulture；
var containsPredicate=新函数（（s1，s2）=>{
返回cultureInf.CompareInfo.IndexOf（s1，s2，CompareOptions.IgnoreCase）>=0；
}); 
如果(
includedValues.All（v=>options.Values.Any（kv=>containsPredicate（kv，v）））
&&
ExcludedValue.All（v=>！options.Values.Any（kv=>containsPredicate（kv，v）））
{
//做smthg
}

试试这个

var options = new Dictionary<string, string>();
var includedValues = new[] { "abc", "dfg" };
var excludedValues = new[] { "hij", "klm" };

var cultureInf = CultureInfo.CurrentCulture;
var containsPredicate = new Func<string, string, bool>((s1, s2) => {
    return cultureInf.CompareInfo.IndexOf(s1, s2, CompareOptions.IgnoreCase)>=0;
}); 

if (
includedValues.All(v => options.Values.Any(kv =>containsPredicate(kv, v)))
&&
excludedValues.All(v => !options.Values.Any(kv =>containsPredicate(kv, v))))
{
    // do smthg
}

var options=newdictionary（）；
var includedValues=new[]{“abc”，“dfg”}；
var excludedValues=新[]{“hij”，“klm”}；
var cultureInf=CultureInfo.CurrentCulture；
var containsPredicate=新函数（（s1，s2）=>{
返回cultureInf.CompareInfo.IndexOf（s1，s2，CompareOptions.IgnoreCase）>=0；
}); 
如果(
includedValues.All（v=>options.Values.Any（kv=>containsPredicate（kv，v）））
&&
ExcludedValue.All（v=>！options.Values.Any（kv=>containsPredicate（kv，v）））
{
//做smthg
}

有很多事情需要处理。基于区域性的不区分大小写比较和动态、非硬编码模式，例如：

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

namespace ConsoleApplication7
{
  internal static class Program
  {
    internal static void Main(string[] args)
    {
      var options = new Dictionary<string, string>();

      var compareCulture = CultureInfo.CurrentCulture;
      var patternsNeeded = new[] { "abc", "def" };
      var patternsForbidden = new[] { "ghi", "xxx" };

      Func<KeyValuePair<string, string>, bool> meetsCriteria =
        kvp => patternsNeeded.Any(p => compareCulture.CompareInfo.IndexOf(kvp.Value, p, CompareOptions.IgnoreCase) >= 0)
           && !patternsForbidden.Any(p => compareCulture.CompareInfo.IndexOf(kvp.Value, p, CompareOptions.IgnoreCase) >= 0);

      var dictionaryContainsHits = options.Any(meetsCriteria);
    }
  }
}

使用系统；
使用System.Collections.Generic；
使用System.Linq；
利用制度全球化；
命名空间控制台应用程序7
{
内部静态类程序
{
内部静态void Main（字符串[]args）
{
var options=newdictionary（）；
var compareCulture=CultureInfo.CurrentCulture；
var patternseeded=new[]{“abc”，“def”}；
var patternsForbidden=new[]{“ghi”，“xxx”}；
Func meetsCriteria=
kvp=>patternsNeeded.Any（p=>compareCulture.CompareInfo.IndexOf（kvp.Value，p，CompareOptions.IgnoreCase）>=0）
&&！patternsForbidden.Any（p=>compareCulture.CompareInfo.IndexOf（kvp.Value，p，CompareOptions.IgnoreCase）>=0）；
var dictionaryContainsHits=options.Any（MeetCriteria）；
}
}
}

如果你的字典很大，你可能想在这里或那里放一个

.aspallel（）

。因为这些都是读取操作，所以应该可以正常工作

---

不确定是否要对肯定列表中的模式使用

.Any（）

或

.All（）

。选择一个适合您的用例。

有很多事情需要处理。基于区域性的不区分大小写比较和动态、非硬编码模式，例如：

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

namespace ConsoleApplication7
{
  internal static class Program
  {
    internal static void Main(string[] args)
    {
      var options = new Dictionary<string, string>();

      var compareCulture = CultureInfo.CurrentCulture;
      var patternsNeeded = new[] { "abc", "def" };
      var patternsForbidden = new[] { "ghi", "xxx" };

      Func<KeyValuePair<string, string>, bool> meetsCriteria =
        kvp => patternsNeeded.Any(p => compareCulture.CompareInfo.IndexOf(kvp.Value, p, CompareOptions.IgnoreCase) >= 0)
           && !patternsForbidden.Any(p => compareCulture.CompareInfo.IndexOf(kvp.Value, p, CompareOptions.IgnoreCase) >= 0);

      var dictionaryContainsHits = options.Any(meetsCriteria);
    }
  }
}

使用系统；
使用System.Collections.Generic；
使用System.Linq；
利用制度全球化；
命名空间控制台应用程序7
{
内部静态类程序
{
内部静态void Main（字符串[]args）
{
var options=newdictionary（）；
var compareCulture=CultureInfo.CurrentCulture；
var patternseeded=new[]{“abc”，“def”}；
var patternsForbidden=new[]{“ghi”，“xxx”}；
Func meetsCriteria=
kvp=>patternsNeeded.Any（p=>compareCulture.CompareInfo.IndexOf（kvp.Value，p，CompareOptions.IgnoreCase）>=0）
&&！patternsForbidden.Any（p=>compareCulture.CompareInfo.IndexOf（kvp.Value，p，CompareOptions.IgnoreCase）>=0）；
var dictionaryContainsHits=options.Any（MeetCriteria）；
}
}
}

如果你的字典很大，你可能想在这里或那里放一个

.aspallel（）

。因为这些都是读取操作，所以应该可以正常工作

---

不确定是否要对肯定列表中的模式使用

.Any（）

或

.All（）

。选择一个适合您的用例。

您可以通过dictionary对象上的values属性直接访问值

那么，您可以创建自己的linq来实现这种方法：

public static class ExtendedLinq
{
    public static bool All<T>(this IEnumerable<T> source, params Func<T, bool>[] conditions)
    {
        foreach (var condition in conditions)
            if (!source.Any(condition))
                return false;

        return true;
    }
}

公共静态类ExtendedLinq
{
公共静态bool All（此IEnumerable源，参数Func[]条件）
{
foreach（条件中的var条件）
如果（！source.Any（条件））
返回false；
返回true；
}
}

然后是用法：

var options = new Dictionary<string, string>();
if (options.Values.All((t => t.Contains("abc")), (t => !t.Contains("def")), (t => !t.Contains("ghi"))))
{
    // Do something
}

var options=newdictionary（）；
if（options.Values.All（（t=>t.Contains（“abc”），（t=>！t.Contains（“def”），（t=>！t.Contains（“ghi”））
{
//做点什么
}

希望这最终是你想要的

顺便说一句，包含不区分大小写的内容不是框架的一部分，所以我没有包括它，因为您已经有了它

老（误解了问题）： var options=newdictionary（）； if（options.Values.Any（t=>t.Contains（“abc”）和&！t.Contains（“def”）和&！t.Contains（“ghi”）） { //做点什么 }

---

它取决于上下文，因为查看或类可能有用。

您可以通过dictionary对象上的values属性直接访问值

那么，您可以创建自己的linq来实现这种方法：

public static class ExtendedLinq
{
    public static bool All<T>(this IEnumerable<T> source, params Func<T, bool>[] conditions)
    {
        foreach (var condition in conditions)
            if (!source.Any(condition))
                return false;

        return true;
    }
}

公共静态类ExtendedLinq
{
公共静态bool All（此IEnumerable源，参数Func[]cond