C# 检查字符串是否以列表中的任何字符开头

我想检查字符串是否以列表中的任何字符开头。我目前在C#中的实现如下：

char[] columnChars = new char[] { 'A', 'B', 'C', 'D', 'E' };
private bool startWithColumn(string toCheck)
{
   for(int i=0; i<columnChars.Length; i++)   
     if (toCheck.StartsWith(columnChars[i]+""))
     {
       return true;
     }

   return false;
}

char[]columnChars=新字符[]{'A'，'B'，'C'，'D'，'E'}；
private bool startWithColumn（字符串到检查）
{
对于（int i=0；i您可以很容易地从字符串中获取第一个字符：

char c = toCheck[0];

然后检查它是否在阵列中：

return columnChars.Contains(c);

我相信这个会更快：

char[] columnChars = new char[] { 'A', 'B', 'C', 'D', 'E' };
private bool startWithColumn(string toCheck)
{
   for(int i=0; i<columnChars.Length; i++)   
     if (toCheck.Length > 0 && toCheck[0] == columnChars[i]))
     {
       return true;
     }

   return false;
}

char[]columnChars=新字符[]{'A'，'B'，'C'，'D'，'E'}；
private bool startWithColumn（字符串到检查）
{
for（int i=0；i 0&&toCheck[0]==columnChars[i]））
{
返回true；
}
返回false；
}
检查第一个字符是否在允许范围内

 char[] columnChars = new char[] { 'A', 'B', 'C', 'D', 'E' };
 private bool startWithColumn(string toCheck)
 {
     return toCheck != null
                && toCheck.Length > 0
                && columnChars.Any( c => c == toCheck[0] );
 }

或者：

return toCheck.Length > 0 && columnChars.Contains(toCheck[0]);

显而易见的方法是在数组中线性搜索字符串的第一个字符：

private bool startWithColumn(string toCheck)
{
     return !string.IsNullOrEmpty(toCheck) 
           && Array.IndexOf(columnChars, toCheck[0]) != -1; 
}

如果你在寻找性能，考虑使用<代码> HasSET/<代码>或类似的，而不是一个数组，它应该给你一个恒定的时间查找。如果数组大得多，这可能是值得的。你必须测量一种或那种方式。
 < P>这里我所提出的：

    readonly char[] columnChars = new char[] { 'A', 'B', 'C', 'D', 'E' };
    private bool startWithColumn(string toCheck)
    {
        return columnChars.Contains(toCheck.Substring(0, 1).ToCharArray()[0]);
    }

编辑

没有看到减少转换的可能性：

    readonly char[] columnChars = new char[] { 'A', 'B', 'C', 'D', 'E' };
    private bool startWithColumn(string toCheck)
    {
        return columnChars.Contains(toCheck[0]);
    }

您可以使用Contains和ElementAt执行此操作：

char[] columnChars = new char[] { 'A', 'B', 'C', 'D', 'E' }; 
String testString = "This is test String";
var exists = columnChars.Contains(testString.ElementAt(0));

如果你的角色“列表”肯定是一个
char[]
，我想你最好是：

return toCheck.IndexOfAny(columnChars) == 0;

免责声明：我还没有对此进行基准测试。但该方法只是停留在那里。
我喜欢我的linq，因此：

        string str = "A quick brown fox";
        char[] chars = { 'A', 'B', 'C', 'D', 'E', 'F' };

        var query = from c in str.Substring(0, 1)
                    join c1 in chars on c equals c1
                    select c;

这将为您提供列表中与字符串的第一个字符匹配的所有字符。稍加修改，您甚至可以在正在搜索的字符列表中获得该字符的索引，在本例中为索引0

这是代码：

        string str = "A quick brown fox";
        char[] chars = { 'Z', 'X', 'A', 'B', 'C', 'D', 'E', 'F' };

        var query = from c in str.Substring(0, 1)
                    join c1 in chars on c equals c1
                    select new { Character = c, Index = chars.ToList().IndexOf(c) };

        var found = query.ToArray();

我需要类似的东西，但对于字符串：

我想知道我的字符串
subject
是否以以下任何字符串开头：

var qualent3s = new string[] { "D", "M", "H", "JUK"};

这样做的LINQ很简单：

qualent3s.Any(x => subject.StartsWith(x))

在这种情况下，我使用如下扩展方法：

public static bool StartsWithAny(this string Text, IEnumerable<string> Needles) {
            return Needles.Any(x => Text.StartsWith(x));
        }

public static class StringExtensions
{
    public static bool StartsWithAny(this string stack, params string[] needles) {
        return needles.Any(stack.StartsWith);
    }

    public static bool ContainsAny(this string stack, params string[] needles) {
        return needles.Any(stack.Contains);
    }

    public static bool IsOneOf<T>(this T value, params T[] items) {
        for (int i = 0; i < items.Length; ++i) {
            if (items[i].Equals(value))
                return true;
        }
        return false;
    }
}

public static bool StartsWithAny（此字符串文本，IEnumerable）{
返回指针.Any（x=>Text.StartsWith（x））；
}
使用字符串扩展名非常有用：

public static class StringExtensions
{
    public static bool StartsWithAny(this string stack, params string[] needles) {
        return needles.Any(stack.StartsWith);
    }
}

我的全班同学是这样的：

public static bool StartsWithAny(this string Text, IEnumerable<string> Needles) {
            return Needles.Any(x => Text.StartsWith(x));
        }

public static class StringExtensions
{
    public static bool StartsWithAny(this string stack, params string[] needles) {
        return needles.Any(stack.StartsWith);
    }

    public static bool ContainsAny(this string stack, params string[] needles) {
        return needles.Any(stack.Contains);
    }

    public static bool IsOneOf<T>(this T value, params T[] items) {
        for (int i = 0; i < items.Length; ++i) {
            if (items[i].Equals(value))
                return true;
        }
        return false;
    }
}

公共静态类StringExtensions
{
公共静态bool StartsWithAny（此字符串堆栈，参数字符串[]）{
回针。任何（堆叠。开始使用）；
}
公共静态bool ContainsAny（此字符串堆栈，参数字符串[]）{
返回针。任何（堆栈包含）；
}
公共静态bool IsOneOf（此T值，参数T[]项）{
对于（int i=0；i
可怜的正则表达式。通常是矫枉过正，往往不够强大：（无数的答案表明，在C#中肯定有很多方法可以做同样的事情。所以，你需要一点（多少？）为了解决OP的问题而进行的修改，最终得到了一个可怕的连接解决方案？对不起，LINQ不是金锤。正则表达式是：P@Martinho啊，另一个讨厌linq的人。说真的，正则表达式？那更容易维护，也更可读？我猜你是为一个人团队编写代码的。@Martinho这是对象linq，而不是linq to sql所以连接并没有那么昂贵。此外，自2005年以来，SQL server优化了所有执行路径，因此特别SQL（如linq生成）的运行速度与存储过程一样快，因此参数不存在。linq在许多企业应用程序中使用是有原因的。尽管我承认我在linq查询中使用的chars.ToList可以优化。我不确定linq编译器是否会对其进行优化并缓存该值，或者是否会在每次传递时调用它。最好创建一个局部变量并使用它。@SRM:我喜欢linq，并且我在开正则表达式的玩笑。不过，我更喜欢可读的代码。此外，
chars.Any（x=>x==str[0]）
是一种更具可读性的LINQ用法来解决这个问题。@Martinho Lol-老实说，你认为你是认真对待正则表达式的。你的例子肯定更简洁，它使用了lambdas，这值得一点赞扬。尽管它不会给你索引；）。您可能可以将匿名类型移动到其中，然后调用IndexOf并获得相同的功能。我无法+1您的评论，但我确实标记了它。做得好。您可以简化查询：
qualent3s.Any（subject.StartsWith）
public static class StringExtensions
{
    public static bool StartsWithAny(this string stack, params string[] needles) {
        return needles.Any(stack.StartsWith);
    }

    public static bool ContainsAny(this string stack, params string[] needles) {
        return needles.Any(stack.Contains);
    }

    public static bool IsOneOf<T>(this T value, params T[] items) {
        for (int i = 0; i < items.Length; ++i) {
            if (items[i].Equals(value))
                return true;
        }
        return false;
    }
}