blocks|key|310688|text|下面是它的一个示例扩展方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|310689|public+static+List<int>+AllIndexesOf(this+string+str,+string+value)+{
++++if+(String.IsNullOrEmpty(value))
++++++++throw+new+ArgumentException("the+string+to+find+may+not+be+empty",+"value");
++++List<int>+indexes+=+new+List<int>();
++++for+(int+index+=+0;;+index+%2B=+value.Length)+{
++++++++index+=+str.IndexOf(value,+index);
++++++++if+(index+==+-1)
++++++++++++return+indexes;
++++++++indexes.Add(index);
++++}
}|code-block|syntax|javascript|310690|如果您将其放入静态类中并使用using导入名称空间，则它将显示为任何字符串上的方法，您只需执行以下操作：|offset|length|style|CODE|310691|List<int>+indexes+=+"fooStringfooBar".AllIndexesOf("foo");|310692|有关扩展方法的更多信息，请参阅http://msdn.microsoft.com/en-us/library/bb383977.aspx|310693|使用迭代器也是一样的：|310694|public+static+IEnumerable<int>+AllIndexesOf(this+string+str,+string+value)+{
++++if+(String.IsNullOrEmpty(value))
++++++++throw+new+ArgumentException("the+string+to+find+may+not+be+empty",+"value");
++++for+(int+index+=+0;;+index+%2B=+value.Length)+{
++++++++index+=+str.IndexOf(value,+index);
++++++++if+(index+==+-1)
++++++++++++break;
++++++++yield+return+index;
++++}
}|310695|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/bb383977.aspx^0|0|0|E|5|0|0|F|1H|0|0|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|14|8|@$I|15|J|16|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|18|8|@]|9|@$I|19|J|1A|1|1B]]|A|$]]|$1|Q|3|R|5|6|7|1C|8|@]|9|@]|A|$]]|$1|S|3|T|5|D|7|1D|8|@]|9|@]|A|$E|F]]|$1|U|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]]|V|$W|$5|X|Y|Z|A|$10|11]]]]

Here's an example extension method for it:

<pre><code>public static List&lt;int&gt; AllIndexesOf(this string str, string value) {
 if (String.IsNullOrEmpty(value))
 throw new ArgumentException("the string to find may not be empty", "value");
 List&lt;int&gt; indexes = new List&lt;int&gt;();
 for (int index = 0;; index += value.Length) {
 index = str.IndexOf(value, index);
 if (index == -1)
 return indexes;
 indexes.Add(index);
 }
}
</code></pre>

If you put this into a static class and import the namespace with <code>using</code>, it appears as a method on any string, and you can just do:

<pre><code>List&lt;int&gt; indexes = "fooStringfooBar".AllIndexesOf("foo");
</code></pre>

For more information on extension methods, <a href="http://msdn.microsoft.com/en-us/library/bb383977.aspx" rel="noreferrer">http://msdn.microsoft.com/en-us/library/bb383977.aspx</a>

Also the same using an iterator:

<pre><code>public static IEnumerable&lt;int&gt; AllIndexesOf(this string str, string value) {
 if (String.IsNullOrEmpty(value))
 throw new ArgumentException("the string to find may not be empty", "value");
 for (int index = 0;; index += value.Length) {
 index = str.IndexOf(value, index);
 if (index == -1)
 break;
 yield return index;
 }
}
</code></pre>

blocks|key|313688|text|根据我用来在一个较大的字符串中查找一个字符串的多个实例的代码，您的代码将如下所示：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|313689|List<int>+inst+=+new+List<int>();
int+index+=+0;
while+(index+>=0)
{
++++index+=+source.IndexOf("extract\"(me,i-have+lots.+of]punctuation",+index);
++++inst.Add(index);
++++index%2B%2B;
}|code-block|syntax|javascript|313690|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Based on the code I've used for finding multiple instances of a string within a larger string, your code would look like:

<pre><code>List&lt;int&gt; inst = new List&lt;int&gt;();
int index = 0;
while (index &gt;=0)
{
 index = source.IndexOf("extract\"(me,i-have lots. of]punctuation", index);
 inst.Add(index);
 index++;
}
</code></pre>

blocks|key|311541|text|public+List<int>+GetPositions(string+source,+string+searchString)
{
++++List<int>+ret+=+new+List<int>();
++++int+len+=+searchString.Length;
++++int+start+=+-len;
++++while+(true)
++++{
++++++++start+=+source.IndexOf(searchString,+start+%2B+len);
++++++++if+(start+==+-1)
++++++++{
++++++++++++break;
++++++++}
++++++++else
++++++++{
++++++++++++ret.Add(start);
++++++++}
++++}
++++return+ret;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|311542|这样叫它：|unstyled|311543|List<int>+list+=+GetPositions("bob+is+a+chowder+head+bob+bob+sldfjl",+"bob");
//+list+will+contain+0,+22,+26|311544|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|L|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|I|3|-4|5|F|7|N|8|@]|9|@]|A|$]]]|J|$]]

<pre><code>public List&lt;int&gt; GetPositions(string source, string searchString)
{
 List&lt;int&gt; ret = new List&lt;int&gt;();
 int len = searchString.Length;
 int start = -len;
 while (true)
 {
 start = source.IndexOf(searchString, start + len);
 if (start == -1)
 {
 break;
 }
 else
 {
 ret.Add(start);
 }
 }
 return ret;
}
</code></pre>

Call it like this:

<pre><code>List&lt;int&gt; list = GetPositions("bob is a chowder head bob bob sldfjl", "bob");
// list will contain 0, 22, 26
</code></pre>

blocks|key|3263891|text|为什么不使用内置的RegEx类：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3263892|public+static+IEnumerable<int>+GetAllIndexes(this+string+source,+string+matchString)
{
+++matchString+=+Regex.Escape(matchString);
+++foreach+(Match+match+in+Regex.Matches(source,+matchString))
+++{
++++++yield+return+match.Index;
+++}
}|code-block|syntax|javascript|3263893|如果您确实需要重用表达式，那么编译它并将其缓存到某个地方。对于重用情况，在另一个重载中将matchString参数更改为正则表达式matchExpression。|3263894|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Why don't you use the built in RegEx class:

<pre><code>public static IEnumerable&lt;int&gt; GetAllIndexes(this string source, string matchString)
{
 matchString = Regex.Escape(matchString);
 foreach (Match match in Regex.Matches(source, matchString))
 {
 yield return match.Index;
 }
}
</code></pre>

If you do need to reuse the expression then compile it and cache it somewhere. Change the matchString param to a Regex matchExpression in another overload for the reuse case.

blocks|key|313700|text|使用LINQ|type|unstyled|depth|inlineStyleRanges|entityRanges|data|313701|public+static+IEnumerable<int>+IndexOfAll(this+string+sourceString,+string+subString)
{
++++return+Regex.Matches(sourceString,+subString).Cast<Match>().Select(m+=>+m.Index);
}|code-block|syntax|javascript|313702|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

using LINQ 

<pre><code>public static IEnumerable&lt;int&gt; IndexOfAll(this string sourceString, string subString)
{
 return Regex.Matches(sourceString, subString).Cast&lt;Match&gt;().Select(m =&gt; m.Index);
}
</code></pre>

blocks|key|310717|text|@csam在理论上是正确的，尽管他的代码不会被编译，并且可以被修改为|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|310718|public+static+IEnumerable<int>+IndexOfAll(this+string+sourceString,+string+matchString)
{
++++matchString+=+Regex.Escape(matchString);
++++return+from+Match+match+in+Regex.Matches(sourceString,+matchString)+select+match.Index;
}|code-block|syntax|javascript|310719|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/2642073/641833^0|0|5|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

<a href="https://stackoverflow.com/a/2642073/641833">@csam</a> is correct in theory, although his code will not complie and can be refractored to

<pre><code>public static IEnumerable&lt;int&gt; IndexOfAll(this string sourceString, string matchString)
{
 matchString = Regex.Escape(matchString);
 return from Match match in Regex.Matches(sourceString, matchString) select match.Index;
}
</code></pre>

blocks|key|310721|text|抛光版%2B+case忽略支持：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|310722|public+static+int[]+AllIndexesOf(string+str,+string+substr,+bool+ignoreCase+=+false)
{
++++if+(string.IsNullOrWhiteSpace(str)+%7C%7C
++++++++string.IsNullOrWhiteSpace(substr))
++++{
++++++++throw+new+ArgumentException("String+or+substring+is+not+specified.");
++++}

++++var+indexes+=+new+List<int>();
++++int+index+=+0;

++++while+((index+=+str.IndexOf(substr,+index,+ignoreCase+?+StringComparison.OrdinalIgnoreCase+:+StringComparison.Ordinal))+!=+-1)
++++{
++++++++indexes.Add(index%2B%2B);
++++}

++++return+indexes.ToArray();
}|code-block|syntax|javascript|310723|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Polished version + case ignoring support:

<pre><code>public static int[] AllIndexesOf(string str, string substr, bool ignoreCase = false)
{
 if (string.IsNullOrWhiteSpace(str) ||
 string.IsNullOrWhiteSpace(substr))
 {
 throw new ArgumentException("String or substring is not specified.");
 }

 var indexes = new List&lt;int&gt;();
 int index = 0;

 while ((index = str.IndexOf(substr, index, ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal)) != -1)
 {
 indexes.Add(index++);
 }

 return indexes.ToArray();
}
</code></pre>

blocks|key|3050236|text|public+static+Dictionary<string,+IEnumerable<int>>+GetWordsPositions(this+string+input,+string[]+Susbtrings)
{
++++Dictionary<string,+IEnumerable<int>>+WordsPositions+=+new+Dictionary<string,+IEnumerable<int>>();
++++IEnumerable<int>+IndexOfAll+=+null;
++++foreach+(string+st+in+Susbtrings)
++++{
++++++++IndexOfAll+=+Regex.Matches(input,+st).Cast<Match>().Select(m+=>+m.Index);
++++++++WordsPositions.Add(st,+IndexOfAll);

++++}
++++return+WordsPositions;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|3050237|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>public static Dictionary&lt;string, IEnumerable&lt;int&gt;&gt; GetWordsPositions(this string input, string[] Susbtrings)
{
 Dictionary&lt;string, IEnumerable&lt;int&gt;&gt; WordsPositions = new Dictionary&lt;string, IEnumerable&lt;int&gt;&gt;();
 IEnumerable&lt;int&gt; IndexOfAll = null;
 foreach (string st in Susbtrings)
 {
 IndexOfAll = Regex.Matches(input, st).Cast&lt;Match&gt;().Select(m =&gt; m.Index);
 WordsPositions.Add(st, IndexOfAll);

 }
 return WordsPositions;
}
</code></pre>

blocks|key|311579|text|嗨，@Matti+Virkkunen回答得很好|type|unstyled|depth|inlineStyleRanges|entityRanges|data|311580|public+static+List<int>+AllIndexesOf(this+string+str,+string+value)+{
++++if+(String.IsNullOrEmpty(value))
++++++++throw+new+ArgumentException("the+string+to+find+may+not+be+empty",+"value");
++++List<int>+indexes+=+new+List<int>();
++++for+(int+index+=+0;;+index+%2B=+value.Length)+{
++++++++index+=+str.IndexOf(value,+index);
++++++++if+(index+==+-1)
++++++++++++return+indexes;
++++++++indexes.Add(index);
++++++++index--;
++++}
}|code-block|syntax|javascript|311581|但这涵盖了像AOOAOOA这样的测试案例，其中substring|311582|是AOOA和AOOA|311583|输出0和3|311584|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Hi nice answer by @Matti Virkkunen

<pre><code>public static List&lt;int&gt; AllIndexesOf(this string str, string value) {
 if (String.IsNullOrEmpty(value))
 throw new ArgumentException("the string to find may not be empty", "value");
 List&lt;int&gt; indexes = new List&lt;int&gt;();
 for (int index = 0;; index += value.Length) {
 index = str.IndexOf(value, index);
 if (index == -1)
 return indexes;
 indexes.Add(index);
 index--;
 }
}
</code></pre>

But this covers tests cases like AOOAOOA
where substring 

are AOOA and AOOA

Output 0 and 3

blocks|key|3263932|text|不使用正则表达式，使用字符串比较类型：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3263933|string+search+=+"123aa456AA789bb9991AACAA";
string+pattern+=+"AA";
Enumerable.Range(0,+search.Length)
+++.Select(index+=>+{+return+new+{+Index+=+index,+Length+=+(index+%2B+pattern.Length)+>+search.Length+?+search.Length+-+index+:+pattern.Length+};+})
+++.Where(searchbit+=>+searchbit.Length+==+pattern.Length+&&+pattern.Equals(search.Substring(searchbit.Index,+searchbit.Length),StringComparison.OrdinalIgnoreCase))
+++.Select(searchbit+=>+searchbit.Index)|code-block|syntax|javascript|3263934|这将返回{3,8,19,22}。空模式将匹配所有位置。|3263935|对于多个模式：|3263936|string+search+=+"123aa456AA789bb9991AACAA";
string[]+patterns+=+new+string[]+{+"aa",+"99"+};
patterns.SelectMany(pattern+=>+Enumerable.Range(0,+search.Length)
+++.Select(index+=>+{+return+new+{+Index+=+index,+Length+=+(index+%2B+pattern.Length)+>+search.Length+?+search.Length+-+index+:+pattern.Length+};+})
+++.Where(searchbit+=>+searchbit.Length+==+pattern.Length+&&+pattern.Equals(search.Substring(searchbit.Index,+searchbit.Length),+StringComparison.OrdinalIgnoreCase))
+++.Select(searchbit+=>+searchbit.Index))|3263937|这将返回{3，8，19，22，15，16}|3263938|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|U|8|@]|9|@]|A|$E|F]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Without Regex, using string comparison type:

<pre><code>string search = "123aa456AA789bb9991AACAA";
string pattern = "AA";
Enumerable.Range(0, search.Length)
 .Select(index =&gt; { return new { Index = index, Length = (index + pattern.Length) &gt; search.Length ? search.Length - index : pattern.Length }; })
 .Where(searchbit =&gt; searchbit.Length == pattern.Length &amp;&amp; pattern.Equals(search.Substring(searchbit.Index, searchbit.Length),StringComparison.OrdinalIgnoreCase))
 .Select(searchbit =&gt; searchbit.Index)
</code></pre>

This returns {3,8,19,22}. Empty pattern would match all positions.

For multiple patterns:

<pre><code>string search = "123aa456AA789bb9991AACAA";
string[] patterns = new string[] { "aa", "99" };
patterns.SelectMany(pattern =&gt; Enumerable.Range(0, search.Length)
 .Select(index =&gt; { return new { Index = index, Length = (index + pattern.Length) &gt; search.Length ? search.Length - index : pattern.Length }; })
 .Where(searchbit =&gt; searchbit.Length == pattern.Length &amp;&amp; pattern.Equals(search.Substring(searchbit.Index, searchbit.Length), StringComparison.OrdinalIgnoreCase))
 .Select(searchbit =&gt; searchbit.Index))
</code></pre>

This returns {3, 8, 19, 22, 15, 16}

blocks|key|313729|text|我注意到至少有两个建议的解决方案不能处理重叠的搜索结果。我没有选中标有绿色复选标记的那个。这是一个处理重叠搜索命中的方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|313730|++++public+static+List<int>+GetPositions(this+string+source,+string+searchString)
++++{
++++++++List<int>+ret+=+new+List<int>();
++++++++int+len+=+searchString.Length;
++++++++int+start+=+-1;
++++++++while+(true)
++++++++{
++++++++++++start+=+source.IndexOf(searchString,+start+%2B1);
++++++++++++if+(start+==+-1)
++++++++++++{
++++++++++++++++break;
++++++++++++}
++++++++++++else
++++++++++++{
++++++++++++++++ret.Add(start);
++++++++++++}
++++++++}
++++++++return+ret;
++++}|code-block|syntax|javascript|313731|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I noticed that at least two proposed solutions don't handle overlapping search hits. I didn't check the one marked with the green checkmark. Here is one that handles overlapping search hits:

<pre><code> public static List&lt;int&gt; GetPositions(this string source, string searchString)
 {
 List&lt;int&gt; ret = new List&lt;int&gt;();
 int len = searchString.Length;
 int start = -1;
 while (true)
 {
 start = source.IndexOf(searchString, start +1);
 if (start == -1)
 {
 break;
 }
 else
 {
 ret.Add(start);
 }
 }
 return ret;
 }
</code></pre>

blocks|key|3264041|text|我找到了这个example并将其合并到一个函数中：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3264042|++++public+static+int+solution1(int+A,+int+B)
++++{
++++++++//+Check+if+A+and+B+are+in+[0...999,999,999]
++++++++if+(+(A+>=+0+&&+A+<=+999999999)+&&+(B+>=+0+&&+B+<=+999999999))
++++++++{
++++++++++++if+(A+==+0+&&+B+==+0)
++++++++++++{
++++++++++++++++return+0;
++++++++++++}
++++++++++++//+Make+sure+A+<+B
++++++++++++if+(A+<+B)
++++++++++++{++++++++++++++++++++
++++++++++++++++//+Convert+A+and+B+to+strings
++++++++++++++++string+a+=+A.ToString();
++++++++++++++++string+b+=+B.ToString();
++++++++++++++++int+index+=+0;

++++++++++++++++//+See+if+A+is+a+substring+of+B
++++++++++++++++if+(b.Contains(a))
++++++++++++++++{
++++++++++++++++++++//+Find+index+where+A+is
++++++++++++++++++++if+(b.IndexOf(a)+!=+-1)
++++++++++++++++++++{++++++++++++++++++++++++++++
++++++++++++++++++++++++while+((index+=+b.IndexOf(a,+index))+!=+-1)
++++++++++++++++++++++++{
++++++++++++++++++++++++++++Console.WriteLine(A+%2B+"+found+at+position+"+%2B+index);
++++++++++++++++++++++++++++index%2B%2B;
++++++++++++++++++++++++}
++++++++++++++++++++++++Console.ReadLine();
++++++++++++++++++++++++return+b.IndexOf(a);
++++++++++++++++++++}
++++++++++++++++++++else
++++++++++++++++++++++++return+-1;
++++++++++++++++}
++++++++++++++++else
++++++++++++++++{
++++++++++++++++++++Console.WriteLine(A+%2B+"+is+not+in+"+%2B+B+%2B+".");
++++++++++++++++++++Console.ReadLine();

++++++++++++++++++++return+-1;
++++++++++++++++}
++++++++++++}
++++++++++++else
++++++++++++{
++++++++++++++++Console.WriteLine(A+%2B+"+must+be+less+than+"+%2B+B+%2B+".");
+++++++++++++++//+Console.ReadLine();

++++++++++++++++return+-1;
++++++++++++}++++++++++++++++
++++++++}
++++++++else
++++++++{
++++++++++++Console.WriteLine("A+or+B+is+out+of+range.");
++++++++++++//Console.ReadLine();

++++++++++++return+-1;
++++++++}
++++}

++++static+void+Main(string[]+args)
++++{
++++++++int+A+=+53,+B+=+1953786;
++++++++int+C+=+78,+D+=+195378678;
++++++++int+E+=+57,+F+=+153786;

++++++++solution1(A,+B);
++++++++solution1(C,+D);
++++++++solution1(E,+F);

++++++++Console.WriteLine();
++++}|code-block|syntax|javascript|3264043|返回：|3264044|在位置2发现53|3264045|在位置4发现78|3264046|在位置7发现78|3264047|57不是153786|3264048|entityMap|0|LINK|mutability|MUTABLE|url|https://asp-net-example.blogspot.com/2013/10/c-example-string-find-all-occurrences.html^0|6|7|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@$A|11|B|12|1|13]]|C|$]]|$1|D|3|E|5|F|7|14|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|15|8|@]|9|@]|C|$]]|$1|K|3|L|5|6|7|16|8|@]|9|@]|C|$]]|$1|M|3|N|5|6|7|17|8|@]|9|@]|C|$]]|$1|O|3|P|5|6|7|18|8|@]|9|@]|C|$]]|$1|Q|3|R|5|6|7|19|8|@]|9|@]|C|$]]|$1|S|3|-4|5|6|7|1A|8|@]|9|@]|C|$]]]|T|$U|$5|V|W|X|C|$Y|Z]]]]

I found this <a href="https://asp-net-example.blogspot.com/2013/10/c-example-string-find-all-occurrences.html" rel="nofollow noreferrer">example</a> and incorporated it into a function:

<pre><code> public static int solution1(int A, int B)
 {
 // Check if A and B are in [0...999,999,999]
 if ( (A &gt;= 0 &amp;&amp; A &lt;= 999999999) &amp;&amp; (B &gt;= 0 &amp;&amp; B &lt;= 999999999))
 {
 if (A == 0 &amp;&amp; B == 0)
 {
 return 0;
 }
 // Make sure A &lt; B
 if (A &lt; B)
 { 
 // Convert A and B to strings
 string a = A.ToString();
 string b = B.ToString();
 int index = 0;

 // See if A is a substring of B
 if (b.Contains(a))
 {
 // Find index where A is
 if (b.IndexOf(a) != -1)
 { 
 while ((index = b.IndexOf(a, index)) != -1)
 {
 Console.WriteLine(A + " found at position " + index);
 index++;
 }
 Console.ReadLine();
 return b.IndexOf(a);
 }
 else
 return -1;
 }
 else
 {
 Console.WriteLine(A + " is not in " + B + ".");
 Console.ReadLine();

 return -1;
 }
 }
 else
 {
 Console.WriteLine(A + " must be less than " + B + ".");
 // Console.ReadLine();

 return -1;
 } 
 }
 else
 {
 Console.WriteLine("A or B is out of range.");
 //Console.ReadLine();

 return -1;
 }
 }

 static void Main(string[] args)
 {
 int A = 53, B = 1953786;
 int C = 78, D = 195378678;
 int E = 57, F = 153786;

 solution1(A, B);
 solution1(C, D);
 solution1(E, F);

 Console.WriteLine();
 }
</code></pre>

Returns:

53 found at position 2

78 found at position 4 
78 found at position 7

57 is not in 153786

blocks|key|310785|text|在O(N+%2B+M)中使用KMP算法可以在有效的时间复杂度内完成这一过程，其中N是text的长度，M是pattern的长度。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|310786|具体实现和用法如下：|310787|static+class+StringExtensions
{
++++public+static+IEnumerable<int>+AllIndicesOf(this+string+text,+string+pattern)
++++{
++++++++if+(string.IsNullOrEmpty(pattern))
++++++++{
++++++++++++throw+new+ArgumentNullException(nameof(pattern));
++++++++}
++++++++return+Kmp(text,+pattern);
++++}

++++private+static+IEnumerable<int>+Kmp(string+text,+string+pattern)
++++{
++++++++int+M+=+pattern.Length;
++++++++int+N+=+text.Length;

++++++++int[]+lps+=+LongestPrefixSuffix(pattern);
++++++++int+i+=+0,+j+=+0;+

++++++++while+(i+<+N)
++++++++{
++++++++++++if+(pattern[j]+==+text[i])
++++++++++++{
++++++++++++++++j%2B%2B;
++++++++++++++++i%2B%2B;
++++++++++++}
++++++++++++if+(j+==+M)
++++++++++++{
++++++++++++++++yield+return+i+-+j;
++++++++++++++++j+=+lps[j+-+1];
++++++++++++}

++++++++++++else+if+(i+<+N+&&+pattern[j]+!=+text[i])
++++++++++++{
++++++++++++++++if+(j+!=+0)
++++++++++++++++{
++++++++++++++++++++j+=+lps[j+-+1];
++++++++++++++++}
++++++++++++++++else
++++++++++++++++{
++++++++++++++++++++i%2B%2B;
++++++++++++++++}
++++++++++++}
++++++++}
++++}

++++private+static+int[]+LongestPrefixSuffix(string+pattern)
++++{
++++++++int[]+lps+=+new+int[pattern.Length];
++++++++int+length+=+0;
++++++++int+i+=+1;

++++++++while+(i+<+pattern.Length)
++++++++{
++++++++++++if+(pattern[i]+==+pattern[length])
++++++++++++{
++++++++++++++++length%2B%2B;
++++++++++++++++lps[i]+=+length;
++++++++++++++++i%2B%2B;
++++++++++++}
++++++++++++else
++++++++++++{
++++++++++++++++if+(length+!=+0)
++++++++++++++++{
++++++++++++++++++++length+=+lps[length+-+1];
++++++++++++++++}
++++++++++++++++else
++++++++++++++++{
++++++++++++++++++++lps[i]+=+length;
++++++++++++++++++++i%2B%2B;
++++++++++++++++}
++++++++++++}
++++++++}
++++++++return+lps;
++++}|code-block|syntax|javascript|310788|这是一个如何使用它的示例：|310789|static+void+Main(string[]+args)
++++{
++++++++string+text+=+"this+is+a+test";
++++++++string+pattern+=+"is";
++++++++foreach+(var+index+in+text.AllIndicesOf(pattern))
++++++++{
++++++++++++Console.WriteLine(index);+//+2+5
++++++++}
++++}|310790|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/Knuth%25E2%2580%2593Morris%25E2%2580%2593Pratt_algorithm^0|14|4|1E|7|C|3|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]|$9|11|A|12|B|C]]|D|@$9|13|A|14|1|15]]|E|$]]|$1|F|3|G|5|6|7|16|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|17|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|18|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|19|8|@]|D|@]|E|$K|L]]|$1|Q|3|-4|5|6|7|1A|8|@]|D|@]|E|$]]]|R|$S|$5|T|U|V|E|$W|X]]]]

It could be done in efficient time complexity using <a href="https://en.wikipedia.org/wiki/Knuth%E2%80%93Morris%E2%80%93Pratt_algorithm" rel="nofollow noreferrer">KMP</a> algorithm in O(N + M) where N is the length of <code>text</code> and M is the length of the <code>pattern</code>.

This is the implementation and usage:

<pre><code>static class StringExtensions
{
 public static IEnumerable&lt;int&gt; AllIndicesOf(this string text, string pattern)
 {
 if (string.IsNullOrEmpty(pattern))
 {
 throw new ArgumentNullException(nameof(pattern));
 }
 return Kmp(text, pattern);
 }

 private static IEnumerable&lt;int&gt; Kmp(string text, string pattern)
 {
 int M = pattern.Length;
 int N = text.Length;

 int[] lps = LongestPrefixSuffix(pattern);
 int i = 0, j = 0; 

 while (i &lt; N)
 {
 if (pattern[j] == text[i])
 {
 j++;
 i++;
 }
 if (j == M)
 {
 yield return i - j;
 j = lps[j - 1];
 }

 else if (i &lt; N &amp;&amp; pattern[j] != text[i])
 {
 if (j != 0)
 {
 j = lps[j - 1];
 }
 else
 {
 i++;
 }
 }
 }
 }

 private static int[] LongestPrefixSuffix(string pattern)
 {
 int[] lps = new int[pattern.Length];
 int length = 0;
 int i = 1;

 while (i &lt; pattern.Length)
 {
 if (pattern[i] == pattern[length])
 {
 length++;
 lps[i] = length;
 i++;
 }
 else
 {
 if (length != 0)
 {
 length = lps[length - 1];
 }
 else
 {
 lps[i] = length;
 i++;
 }
 }
 }
 return lps;
 }
</code></pre>

and this is an example of how to use it:

<pre><code>static void Main(string[] args)
 {
 string text = "this is a test";
 string pattern = "is";
 foreach (var index in text.AllIndicesOf(pattern))
 {
 Console.WriteLine(index); // 2 5
 }
 }
</code></pre>

blocks|key|3264063|text|这种替代实现是如何实现的？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3264064|+public+static+class+MyExtensions
++++{
++++++++public+static+int+HowMany(this+string+str,+char+needle)
++++++++{
++++++++++++int+counter+=+0;
++++++++++++int+nextIndex+=+0;
++++++++++++for+(;+nextIndex+!=+-1;+)
++++++++++++{
++++++++++++++++nextIndex+=+str.IndexOf(needle,+nextIndex);
++++++++++++++++if+(nextIndex+!=+-1)
++++++++++++++++{
++++++++++++++++++++counter%2B%2B;
++++++++++++++++++++//step+over+to+the+next+char
++++++++++++++++++++nextIndex%2B%2B;
++++++++++++++++}
++++++++++++}
++++++++++++return+counter;
++++++++}
++++}|code-block|syntax|javascript|3264065|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

How is this alternative implementation?
<pre><code> public static class MyExtensions
 {
 public static int HowMany(this string str, char needle)
 {
 int counter = 0;
 int nextIndex = 0;
 for (; nextIndex != -1; )
 {
 nextIndex = str.IndexOf(needle, nextIndex);
 if (nextIndex != -1)
 {
 counter++;
 //step over to the next char
 nextIndex++;
 }
 }
 return counter;
 }
 }
</code></pre>

I have a large string I need to parse, and I need to find all the instances of <code>extract"(me,i-have lots. of]punctuation</code>, and store the index of each to a list. 

So say this piece of string was in the beginning and middle of the larger string, both of them would be found, and their indexes would be added to the <code>List</code>. and the <code>List</code> would contain <code>0</code> and the other index whatever it would be.

I've been playing around, and the <code>string.IndexOf</code> does almost what I'm looking for, and I've written some code - but it's not working and I've been unable to figure out exactly what is wrong:

<pre><code>List&lt;int&gt; inst = new List&lt;int&gt;();
int index = 0;
while (index &lt; source.LastIndexOf("extract\"(me,i-have lots. of]punctuation", 0) + 39)
{
 int src = source.IndexOf("extract\"(me,i-have lots. of]punctuation", index);
 inst.Add(src);
 index = src + 40;
}
</code></pre>

<ul>
<li><code>inst</code> = The list</li>
<li><code>source</code> = The large string</li>
</ul>

Any better ideas?

Finding all positions of substring in a larger string in C#

我有一个很大的字符串需要解析，我需要找到extract"(me,i-have lots. of]punctuation的所有实例，并将每个实例的索引存储到一个列表中。假设这段字符串位于较大字符串的开头和中间，这两个字符串都会被找到，它们的索引将被添加到List中。List将包含0和其他索引，不管它是什么。我一直在尝试，...

问在C#中查找较大字符串中子字符串的所有位置
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在C#中查找较大字符串中子字符串的所有位置EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在C#中查找较大字符串中子字符串的所有位置
EN