Verifique se uma string contém um de 10 caracteres

Estou usando C # e quero verificar se uma string contém um de dez caracteres, *, &, # etc etc.

Qual é a melhor maneira?

O seguinte seria o método mais simples, na minha opinião:

var match = str.IndexOfAny(new char[] { '*', '&', '#' }) != -1

Ou de uma forma possivelmente mais fácil de ler:

var match = str.IndexOfAny("*&#".ToCharArray()) != -1

Dependendo do contexto e do desempenho necessários, você pode ou não querer armazenar em cache o array char.

Como já foi dito, use IndexOfAny. No entanto, eu o usaria desta forma:

private static readonly char[] Punctuation = "*&#...".ToCharArray();

public static bool ContainsPunctuation(string text)
{
    return text.IndexOfAny(Punctuation) >= 0;
}

Dessa forma, você não acaba criando um novo array a cada chamada. A string também é mais fácil de digitalizar do que uma série de literais de caracteres, IMO.

Claro, se você vai usar isso apenas uma vez, para que a criação desperdiçada não seja um problema, você pode usar:

private const string Punctuation = "*&#...";

public static bool ContainsPunctuation(string text)
{
    return text.IndexOfAny(Punctuation.ToCharArray()) >= 0;
}

ou

public static bool ContainsPunctuation(string text)
{
    return text.IndexOfAny("*&#...".ToCharArray()) >= 0;
}

Realmente depende de qual você achar mais legível, se deseja usar os caracteres de pontuação em outro lugar e com que freqüência o método será chamado.

EDIT: Aqui está uma alternativa ao método de Reed Copsey para descobrir se uma string contém exatamente um dos caracteres.

private static readonly HashSet<char> Punctuation = new HashSet<char>("*&#...");

public static bool ContainsOnePunctuationMark(string text)
{
    bool seenOne = false;

    foreach (char c in text)
    {
        // TODO: Experiment to see whether HashSet is really faster than
        // Array.Contains. If all the punctuation is ASCII, there are other
        // alternatives...
        if (Punctuation.Contains(c))
        {
            if (seenOne)
            {
                return false; // This is the second punctuation character
            }
            seenOne = true;
        }
    }
    return seenOne;
}

Se você deseja apenas ver se contém algum caractere, recomendo usar string.IndexOfAny, conforme sugerido em outro lugar.

Se você quiser verificar se uma string contém exatamente um dos dez caracteres, e apenas um, fica um pouco mais complicado. Acredito que a maneira mais rápida seria verificar uma interseção e, em seguida, verificar se há duplicatas.

private static char[] characters = new char [] { '*','&',... };

public static bool ContainsOneCharacter(string text)
{
    var intersection = text.Intersect(characters).ToList();
    if( intersection.Count != 1)
        return false; // Make sure there is only one character in the text

    // Get a count of all of the one found character
    if (1 == text.Count(t => t == intersection[0]) )
        return true;

    return false;
}

String.IndexOfAny(Char[])

Aqui está a documentação da Microsoft .

var specialChars = new[] {'\\', '/', ':', '*', '<', '>', '|', '#', '{', '}', '%', '~', '&'};

foreach (var specialChar in specialChars.Where(str.Contains))
{
    Console.Write(string.Format("string must not contain {0}", specialChar));
}

Obrigado a todos vocês! (E principalmente Jon!): Isso me permitiu escrever isto:

    private static readonly char[] Punctuation = "$€£".ToCharArray();

    public static bool IsPrice(this string text)
    {
        return text.IndexOfAny(Punctuation) >= 0;
    }

porque estava procurando uma boa maneira de detectar se uma determinada string era realmente um preço ou uma frase, como 'Muito baixo para exibir'.