Obtenez de l'Index du Premier Caractère non-blanc en C# String

Un string est bien sûr un IEnumerable<char> de sorte que vous pouvez utiliser Linq:

int offset = someString.TakeWhile(c => char.IsWhiteSpace(c)).Count();

var match = Regex.Match(" \t test  ", @"\S"); //\S means all characters that are not whitespace
if (match.Success)
{
    int index = match.Index;
    //do something with index
}
else
{
    //there were no non-whitespace characters, handle appropriately
}

Si vous allez faire cela souvent, pour des raisons de performances, vous devriez cache la compilation des Regex pour ce motif, par exemple:

static readonly Regex nonWhitespace = new Regex(@"\S");

De l'utiliser ensuite comme:

nonWhitespace.Match(" \t test  ");

Puisqu'il existe plusieurs solutions ici, j'ai décidé de faire des tests de performance pour voir comment chacun fonctionne. Décidé de partager ces résultats pour ceux qui sont intéressés...

    int iterations = 1000000;
int result = 0;
string s= "   \t  Test";
System.Diagnostics.Stopwatch watch = new Stopwatch();
//Convert to char array and use FindIndex
watch.Start();
for (int i = 0; i < iterations; i++)
result = Array.FindIndex(s.ToCharArray(), x => !char.IsWhiteSpace(x)); 
watch.Stop();
Console.WriteLine("Convert to char array and use FindIndex: " + watch.ElapsedMilliseconds);
//Trim spaces and get index of first character
watch.Restart();
for (int i = 0; i < iterations; i++)
result = s.IndexOf(s.TrimStart().Substring(0,1));
watch.Stop();
Console.WriteLine("Trim spaces and get index of first character: " + watch.ElapsedMilliseconds);
//Use extension method
watch.Restart();
for (int i = 0; i < iterations; i++)
result = s.IndexOf<char>(c => !char.IsWhiteSpace(c));
watch.Stop();
Console.WriteLine("Use extension method: " + watch.ElapsedMilliseconds);
//Loop
watch.Restart();
for (int i = 0; i < iterations; i++)
{   
result = 0;
foreach (char c in s)
{
if (!char.IsWhiteSpace(c))
break;
result++;
}
}
watch.Stop();
Console.WriteLine("Loop: " + watch.ElapsedMilliseconds);

Résultats sont en millisecondes....

Où s = "\t Test"

Convertir en char tableau et utiliser FindIndex: 154

Garniture d'espaces et d'obtenir l'indice du premier caractère: 189

L'utilisation de la méthode d'extension: 234

Boucle: 146

Où s = "Test"

Convertir en char tableau et utiliser FindIndex: 39

Garniture d'espaces et d'obtenir l'indice du premier caractère: 155

L'utilisation de la méthode d'extension: 57

Boucle: 15

Où s = (1000 chaîne de caractères sans les espaces)

Convertir en char tableau et utiliser FindIndex: 506

Garniture d'espaces et d'obtenir l'indice du premier caractère: 534

L'utilisation de la méthode d'extension: 51

Boucle: 15

Où s = (1000 chaîne de caractères qui commence par "\t Test")

Convertir en char tableau et utiliser FindIndex: 609

Garniture d'espaces et d'obtenir l'indice du premier caractère: 1103

L'utilisation de la méthode d'extension: 226

Boucle: 146

En tirer vos propres conclusions, mais ma conclusion est d'utiliser celui qui
vous aimez le mieux, car les différences de performances est négligeable dans
monde réel scenerios.

Il y a une solution très simple

string test = "    hello world";
int pos = test.ToList<char>().FindIndex(x => char.IsWhiteSpace(x) == false);

pos sera de 4

vous pouvez avoir plus de conditions complexes comme:

pos = test.ToList<char>().FindIndex((x) =>
{
if (x == 's') //Your complex conditions go here
return true;
else 
return false;
}
);

Chose va être en boucle quelque part. Pour un contrôle total sur ce qui est et n'est pas l'espace que vous pourriez utiliser linq to objects pour faire de votre boucle:

int index = Array.FindIndex(
s.ToCharArray(), 
x => !(new [] { '\t', '\r', '\n', ' '}.Any(c => c == x)));