Controlla se una stringa contiene uno dei 10 caratteri

Sto usando C # e voglio controllare se una stringa contiene uno dei dieci caratteri, *, &, # ecc ecc.

Qual è il modo migliore?

Il seguente sarebbe il metodo più semplice, a mio avviso:

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

O in una forma forse più facile da leggere:

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

A seconda del contesto e delle prestazioni richieste, potresti o meno voler memorizzare nella cache l'array di caratteri.

Come altri hanno già detto, usa IndexOfAny. Tuttavia, lo userei in questo modo:

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

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

In questo modo non finirai per creare un nuovo array a ogni chiamata. La stringa è anche più facile da analizzare rispetto a una serie di caratteri letterali, IMO.

Ovviamente se lo userai solo una volta, quindi la creazione sprecata non è un problema, potresti usare:

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

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

o

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

Dipende davvero da cosa trovi più leggibile, se vuoi usare i caratteri di punteggiatura altrove e con quale frequenza verrà chiamato il metodo.

EDIT: ecco un'alternativa al metodo di Reed Copsey per scoprire se una stringa contiene esattamente uno dei caratteri.

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 vuoi solo vedere se contiene caratteri, ti consiglio di usare string.IndexOfAny, come suggerito altrove.

Se vuoi verificare che una stringa contenga esattamente uno dei dieci caratteri e solo uno, diventa un po 'più complicato. Credo che il modo più veloce sarebbe quello di controllare contro un'intersezione, quindi controllare i duplicati.

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[])

Ecco la documentazione di Microsoft .

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

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

Grazie a tutti voi! (E principalmente Jon!): Questo mi ha permesso di scrivere questo:

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

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

poiché stavo cercando un buon modo per rilevare se una determinata stringa fosse effettivamente un prezzo o una frase, come "Troppo basso da visualizzare".