.indexOf for multiple results

Let's say I have a text and I want to locate the positions of each comma. The string开发者_开发知识库, a shorter version, would look like this:

string s = "A lot, of text, with commas, here and,there";

Ideally, I would use something like:

int[] i = s.indexOf(',');

but since indexOf only returns the first comma, I instead do:

List<int> list = new List<int>();
for (int i = 0; i < s.Length; i++)
{
   if (s[i] == ',')
      list.Add(i);
}

Is there an alternative, more optimized way of doing this?

---

Here I got a extension method for that, for the same use as IndexOf:

public static IEnumerable<int> AllIndexesOf(this string str, string searchstring)
{
    int minIndex = str.IndexOf(searchstring);
    while (minIndex != -1)
    {
        yield return minIndex;
        minIndex = str.IndexOf(searchstring, minIndex + searchstring.Length);
    }
}

so you can use

s.AllIndexesOf(","); // 5    14    27    37

https://dotnetfiddle.net/DZdQ0L

---

You could use Regex.Matches(string, string) method. This will return a MatchCollection and then you could determine the Match.Index. MSDN has a good example,

using System; using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b\w+es\b";
      string sentence = "Who writes these notes?";

      foreach (Match match in Regex.Matches(sentence, pattern))
         Console.WriteLine("Found '{0}' at position {1}", 
                           match.Value, match.Index);
   }
}
// The example displays the following output:
//       Found 'writes' at position 4
//       Found 'notes' at position 17

---

IndexOf also allows you to add another parameter for where to start looking. You can set that parameter to be the last known comma location +1. For example:

string s = "A lot, of text, with commas, here and, there";
int loc = s.IndexOf(',');
while (loc != -1) {
    Console.WriteLine(loc);
    loc = s.IndexOf(',', loc + 1);
}

---

You could use the overload of the IndexOf method that also takes a start index to get the following comma, but you would still have to do that in a loop, and it would perform pretty much the same as the code that you have.

You could use a regular expression to find all commas, but that produces quite some overhead, so that's not more optimised than what you have.

You could write a LINQ query to do it in a different way, but that also has some overhead so it's not more optimised than what you have.

So, there are many alternative ways, but not any way that is more optimised.

---

A bit unorthodox, but why not use a split? Might be less aggressive than iterating over the entire string

string longString = "Some, string, with, commas.";
string[] splitString = longString.Split(",");
int numSplits = splitString.Length - 1;
Debug.Log("number of commas "+numSplits);
Debug.Log("first comma index = "+GetIndex(splitString, 0)+" second comma index = "+GetIndex(splitString, 1));

public int GetIndex(string[] stringArray, int num)
{
    int charIndex = 0;
    for (int n = num; n >= 0; n--)
    {
        charIndex+=stringArray[n].Length;
    }
    return charIndex + num;
}