blocks|key|1518407|text|Regex.Replace("ThisIsMyCapsDelimitedString",+"(\\B[A-Z])",+"+$1")|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1518408|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>Regex.Replace("ThisIsMyCapsDelimitedString", "(\\B[A-Z])", " $1")
</code></pre>

blocks|key|1518574|text|回答得很好，MizardX！我稍微调整了一下，将数字作为单独的单词处理，这样"AddressLine1“就变成了"Address+Line1+1”，而不是"Address+Line1"：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1518575|Regex.Replace(s,+"([a-z](?=[A-Z0-9])%7C[A-Z](?=[A-Z][a-z]))",+"$1+")|code-block|syntax|javascript|1518576|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|$]]

Great answer, MizardX! I tweaked it slightly to treat numerals as separate words, so that "AddressLine1" would become "Address Line 1" instead of "Address Line1":

<pre><code>Regex.Replace(s, "([a-z](?=[A-Z0-9])|[A-Z](?=[A-Z][a-z]))", "$1 ")
</code></pre>

blocks|key|1518474|text|只是为了一点变化。下面是一个不使用正则表达式的扩展方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1518475|public+static+class+CamelSpaceExtensions
{
++++public+static+string+SpaceCamelCase(this+String+input)
++++{
++++++++return+new+string(Enumerable.Concat(
++++++++++++input.Take(1),+//+No+space+before+initial+cap
++++++++++++InsertSpacesBeforeCaps(input.Skip(1))
++++++++).ToArray());
++++}

++++private+static+IEnumerable<char>+InsertSpacesBeforeCaps(IEnumerable<char>+input)
++++{
++++++++foreach+(char+c+in+input)
++++++++{
++++++++++++if+(char.IsUpper(c))+
++++++++++++{+
++++++++++++++++yield+return+'+';+
++++++++++++}

++++++++++++yield+return+c;
++++++++}
++++}
}|code-block|syntax|javascript|1518476|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|$]]

Just for a little variety... Here's an extension method that doesn't use a regex.

<pre><code>public static class CamelSpaceExtensions
{
 public static string SpaceCamelCase(this String input)
 {
 return new string(Enumerable.Concat(
 input.Take(1), // No space before initial cap
 InsertSpacesBeforeCaps(input.Skip(1))
 ).ToArray());
 }

 private static IEnumerable&lt;char&gt; InsertSpacesBeforeCaps(IEnumerable&lt;char&gt; input)
 {
 foreach (char c in input)
 {
 if (char.IsUpper(c)) 
 { 
 yield return ' '; 
 }

 yield return c;
 }
 }
}
</code></pre>

blocks|key|1733369|text|抛开格兰特·瓦格纳的精彩评论不谈：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1733370|Dim+s+As+String+=+RegularExpressions.Regex.Replace("ThisIsMyCapsDelimitedString",+"([A-Z])",+"+$1")|code-block|syntax|javascript|1733371|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|$]]

Grant Wagner's excellent comment aside:

<pre><code>Dim s As String = RegularExpressions.Regex.Replace("ThisIsMyCapsDelimitedString", "([A-Z])", " $1")
</code></pre>

blocks|key|1518522|text|对于更多种类，使用普通的老式C#对象，下面的代码将产生与@MizardX的优秀正则表达式相同的输出。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1518523|public+string+FromCamelCase(string+camel)
{+++//+omitted+checking+camel+for+null
++++StringBuilder+sb+=+new+StringBuilder();
++++int+upperCaseRun+=+0;
++++foreach+(char+c+in+camel)
++++{+++//+append+a+space+only+if+we're+not+at+the+start
++++++++//+and+we're+not+already+in+an+all+caps+string.
++++++++if+(char.IsUpper(c))
++++++++{
++++++++++++if+(upperCaseRun+==+0+&&+sb.Length+!=+0)
++++++++++++{
++++++++++++++++sb.Append('+');
++++++++++++}
++++++++++++upperCaseRun%2B%2B;
++++++++}
++++++++else+if(+char.IsLower(c)+)
++++++++{
++++++++++++if+(upperCaseRun+>+1)+//The+first+new+word+will+also+be+capitalized.
++++++++++++{
++++++++++++++++sb.Insert(sb.Length+-+1,+'+');
++++++++++++}
++++++++++++upperCaseRun+=+0;
++++++++}
++++++++else
++++++++{
++++++++++++upperCaseRun+=+0;
++++++++}
++++++++sb.Append(c);
++++}

++++return+sb.ToString();
}|code-block|syntax|javascript|1518524|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|$]]

For more variety, using plain old C# objects, the following produces the same output as @MizardX's excellent regular expression.

<pre><code>public string FromCamelCase(string camel)
{ // omitted checking camel for null
 StringBuilder sb = new StringBuilder();
 int upperCaseRun = 0;
 foreach (char c in camel)
 { // append a space only if we're not at the start
 // and we're not already in an all caps string.
 if (char.IsUpper(c))
 {
 if (upperCaseRun == 0 &amp;&amp; sb.Length != 0)
 {
 sb.Append(' ');
 }
 upperCaseRun++;
 }
 else if( char.IsLower(c) )
 {
 if (upperCaseRun &gt; 1) //The first new word will also be capitalized.
 {
 sb.Insert(sb.Length - 1, ' ');
 }
 upperCaseRun = 0;
 }
 else
 {
 upperCaseRun = 0;
 }
 sb.Append(c);
 }

 return sb.ToString();
}
</code></pre>

blocks|key|1733382|text|string+s+=+"ThisIsMyCapsDelimitedString";
string+t+=+Regex.Replace(s,+"([A-Z])",+"+$1").Substring(1);|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1733383|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>string s = "ThisIsMyCapsDelimitedString";
string t = Regex.Replace(s, "([A-Z])", " $1").Substring(1);
</code></pre>

blocks|key|1518780|text|正则表达式大约比简单的循环慢10-12倍：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1518781|++++public+static+string+CamelCaseToSpaceSeparated(this+string+str)
++++{
++++++++if+(string.IsNullOrEmpty(str))
++++++++{
++++++++++++return+str;
++++++++}

++++++++var+res+=+new+StringBuilder();

++++++++res.Append(str[0]);
++++++++for+(var+i+=+1;+i+<+str.Length;+i%2B%2B)
++++++++{
++++++++++++if+(char.IsUpper(str[i]))
++++++++++++{
++++++++++++++++res.Append('+');
++++++++++++}
++++++++++++res.Append(str[i]);

++++++++}
++++++++return+res.ToString();
++++}|code-block|syntax|javascript|1518782|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|$]]

Regex is about 10-12 times slower than a simple loop:

<pre><code> public static string CamelCaseToSpaceSeparated(this string str)
 {
 if (string.IsNullOrEmpty(str))
 {
 return str;
 }

 var res = new StringBuilder();

 res.Append(str[0]);
 for (var i = 1; i &lt; str.Length; i++)
 {
 if (char.IsUpper(str[i]))
 {
 res.Append(' ');
 }
 res.Append(str[i]);

 }
 return res.ToString();
 }
</code></pre>

blocks|key|1518445|text|朴素的正则表达式解决方案。将不会处理O‘’Conner，并在字符串的开头添加一个空格。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1518446|s+=+"ThisIsMyCapsDelimitedString"
split+=+Regex.Replace(s,+"[A-Z0-9]",+"+$&");|code-block|syntax|javascript|1518447|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|$]]

Naive regex solution. Will not handle O'Conner, and adds a space at the start of the string as well. 

<pre><code>s = "ThisIsMyCapsDelimitedString"
split = Regex.Replace(s, "[A-Z0-9]", " $&amp;");
</code></pre>

blocks|key|1518352|text|可能有一个更优雅的解决方案，但这是我突然想到的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1518353|string+myString+=+"ThisIsMyCapsDelimitedString";

for+(int+i+=+1;+i+<+myString.Length;+i%2B%2B)
{
+++++if+(myString[i].ToString().ToUpper()+==+myString[i].ToString())
+++++{
++++++++++myString+=+myString.Insert(i,+"+");
++++++++++i%2B%2B;
+++++}
}|code-block|syntax|javascript|1518354|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|$]]

There's probably a more elegant solution, but this is what I come up with off the top of my head:

<pre><code>string myString = "ThisIsMyCapsDelimitedString";

for (int i = 1; i &lt; myString.Length; i++)
{
 if (myString[i].ToString().ToUpper() == myString[i].ToString())
 {
 myString = myString.Insert(i, " ");
 i++;
 }
}
</code></pre>

blocks|key|1518616|text|试着使用|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1518617|"([A-Z]*[%5EA-Z]*)"|code-block|syntax|javascript|1518618|结果将适用于字母和数字混合|1518619|Regex.Replace("AbcDefGH123Weh",+"([A-Z]*[%5EA-Z]*)",+"$1+");
Abc+Def+GH123+Weh++

Regex.Replace("camelCase",+"([A-Z]*[%5EA-Z]*)",+"$1+");
camel+Case++|1518620|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Try to use

<pre><code>"([A-Z]*[^A-Z]*)"
</code></pre>

The result will fit for alphabet mix with numbers

<pre><code>Regex.Replace("AbcDefGH123Weh", "([A-Z]*[^A-Z]*)", "$1 ");
Abc Def GH123 Weh 

Regex.Replace("camelCase", "([A-Z]*[^A-Z]*)", "$1 ");
camel Case 
</code></pre>

blocks|key|1518681|text|从https://stackoverflow.com/a/5796394/4279201实现psudo代码|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1518682|++++private+static+StringBuilder+camelCaseToRegular(string+i_String)
++++{
++++++++StringBuilder+output+=+new+StringBuilder();
++++++++int+i+=+0;
++++++++foreach+(char+character+in+i_String)
++++++++{
++++++++++++if+(character+<=+'Z'+&&+character+>=+'A'+&&+i+>+0)
++++++++++++{
++++++++++++++++output.Append("+");
++++++++++++}
++++++++++++output.Append(character);
++++++++++++i%2B%2B;
++++++++}
++++++++return+output;
++++}|code-block|syntax|javascript|1518683|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/5796394/4279201^0|1|17|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]]]]

Implementing the psudo code from: <a href="https://stackoverflow.com/a/5796394/4279201">https://stackoverflow.com/a/5796394/4279201</a>

<pre><code> private static StringBuilder camelCaseToRegular(string i_String)
 {
 StringBuilder output = new StringBuilder();
 int i = 0;
 foreach (char character in i_String)
 {
 if (character &lt;= 'Z' &amp;&amp; character &gt;= 'A' &amp;&amp; i &gt; 0)
 {
 output.Append(" ");
 }
 output.Append(character);
 i++;
 }
 return output;
 }
</code></pre>

blocks|key|1733693|text|要在非大写和Uppercase+Letter+Unicode+Category之间进行匹配：(?<=\P{Lu})(?=\p{Lu})|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1733694|Dim+s+=+Regex.Replace("CorrectHorseBatteryStaple",+"(?<=\P{Lu})(?=\p{Lu})",+"+")|code-block|syntax|javascript|1733695|entityMap|0|LINK|mutability|MUTABLE|url|https://msdn.microsoft.com/en-us/library/20bw873z.aspx#SupportedUnicodeGeneralCategories|1|https://regex101.com/r/zahL4H/1^0|1A|L|6|X|0|1A|L|1|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@$9|X|A|Y|1|Z]|$9|10|A|11|1|12]]|E|$]]|$1|F|3|G|5|H|7|13|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|L|$M|$5|N|O|P|E|$Q|R]]|S|$5|N|O|P|E|$Q|T]]]]

To match between non-uppercase and <a href="https://msdn.microsoft.com/en-us/library/20bw873z.aspx#SupportedUnicodeGeneralCategories" rel="nofollow noreferrer">Uppercase Letter Unicode Category</a> : <a href="https://regex101.com/r/zahL4H/1" rel="nofollow noreferrer"><code>(?&lt;=\P{Lu})(?=\p{Lu})</code></a>

<pre><code>Dim s = Regex.Replace("CorrectHorseBatteryStaple", "(?&lt;=\P{Lu})(?=\p{Lu})", " ")
</code></pre>

blocks|key|1518839|text|程序化和快速实施：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1518840|++///+<summary>
++///+Get+the+words+in+a+code+<paramref+name="identifier"/>.
++///+</summary>
++///+<param+name="identifier">The+code+<paramref+name="identifier"/></param>+to+extract+words+from.
++public+static+string[]+GetWords(this+string+identifier)+{
+++++Contract.Ensures(Contract.Result<string[]>()+!=+null,+"returned+array+of+string+is+not+null+but+can+be+empty");
+++++if+(identifier+==+null)+{+return+new+string[0];+}
+++++if+(identifier.Length+==+0)+{+return+new+string[0];+}

+++++const+int+MIN_WORD_LENGTH+=+2;++//++Ignore+one+letter+or+one+digit+words

+++++var+length+=+identifier.Length;
+++++var+list+=+new+List<string>(1+%2B+length/2);+//+Set+capacity,+not+possible+more+words+since+we+discard+one+char+words
+++++var+sb+=+new+StringBuilder();
+++++CharKind+cKindCurrent+=+GetCharKind(identifier[0]);+//+length+is+not+zero+here
+++++CharKind+cKindNext+=+length+==+1+?+CharKind.End+:+GetCharKind(identifier[1]);

+++++for+(var+i+=+0;+i+<+length;+i%2B%2B)+{
++++++++var+c+=+identifier[i];
++++++++CharKind+cKindNextNext+=+(i+>=+length+-+2)+?+CharKind.End+:+GetCharKind(identifier[i+%2B+2]);

++++++++//+Process+cKindCurrent
++++++++switch+(cKindCurrent)+{
+++++++++++case+CharKind.Digit:
+++++++++++case+CharKind.LowerCaseLetter:
++++++++++++++sb.Append(c);+//+Append+digit+or+lowerCaseLetter+to+sb
++++++++++++++if+(cKindNext+==+CharKind.UpperCaseLetter)+{
+++++++++++++++++goto+TURN_SB_INTO_WORD;+//+Finish+word+if+next+char+is+upper
++++++++++++++}
++++++++++++++goto+CHAR_PROCESSED;
+++++++++++case+CharKind.Other:
++++++++++++++goto+TURN_SB_INTO_WORD;
+++++++++++default:++//+charCurrent+is+never+Start+or+End
++++++++++++++Debug.Assert(cKindCurrent+==+CharKind.UpperCaseLetter);
++++++++++++++break;
++++++++}

++++++++//+Here+cKindCurrent+is+UpperCaseLetter
++++++++//+Append+UpperCaseLetter+to+sb+anyway
++++++++sb.Append(c);+

++++++++switch+(cKindNext)+{
+++++++++++default:
++++++++++++++goto+CHAR_PROCESSED;

+++++++++++case+CharKind.UpperCaseLetter:+
++++++++++++++//++"SimpleHTTPServer"++when+we+are+at+'P'+we+need+to+see+that+NextNext+is+'e'+to+get+the+word!
++++++++++++++if+(cKindNextNext+==+CharKind.LowerCaseLetter)+{
+++++++++++++++++goto+TURN_SB_INTO_WORD;
++++++++++++++}
++++++++++++++goto+CHAR_PROCESSED;

+++++++++++case+CharKind.End:
+++++++++++case+CharKind.Other:
++++++++++++++break;+//+goto+TURN_SB_INTO_WORD;
++++++++}

++++++++//------------------------------------------------

+++++TURN_SB_INTO_WORD:
++++++++string+word+=+sb.ToString();
++++++++sb.Length+=+0;
++++++++if+(word.Length+>=+MIN_WORD_LENGTH)+{++
+++++++++++list.Add(word);
++++++++}

+++++CHAR_PROCESSED:
++++++++//+Shift+left+for+next+iteration!
++++++++cKindCurrent+=+cKindNext;
++++++++cKindNext+=+cKindNextNext;
+++++}

+++++string+lastWord+=+sb.ToString();
+++++if+(lastWord.Length+>=+MIN_WORD_LENGTH)+{
++++++++list.Add(lastWord);
+++++}
+++++return+list.ToArray();
++}
++private+static+CharKind+GetCharKind(char+c)+{
+++++if+(char.IsDigit(c))+{+return+CharKind.Digit;+}
+++++if+(char.IsLetter(c))+{
++++++++if+(char.IsUpper(c))+{+return+CharKind.UpperCaseLetter;+}
++++++++Debug.Assert(char.IsLower(c));
++++++++return+CharKind.LowerCaseLetter;
+++++}
+++++return+CharKind.Other;
++}
++enum+CharKind+{
+++++End,+//+For+end+of+string
+++++Digit,
+++++UpperCaseLetter,
+++++LowerCaseLetter,
+++++Other
++}|code-block|syntax|javascript|1518841|测试：|1518842|++[TestCase((string)null,+"")]
++[TestCase("",+"")]

++//+Ignore+one+letter+or+one+digit+words
++[TestCase("A",+"")]
++[TestCase("4",+"")]
++[TestCase("_",+"")]
++[TestCase("Word_m_Field",+"Word+Field")]
++[TestCase("Word_4_Field",+"Word+Field")]

++[TestCase("a4",+"a4")]
++[TestCase("ABC",+"ABC")]
++[TestCase("abc",+"abc")]
++[TestCase("AbCd",+"Ab+Cd")]
++[TestCase("AbcCde",+"Abc+Cde")]
++[TestCase("ABCCde",+"ABC+Cde")]

++[TestCase("Abc42Cde",+"Abc42+Cde")]
++[TestCase("Abc42cde",+"Abc42cde")]
++[TestCase("ABC42Cde",+"ABC42+Cde")]
++[TestCase("42ABC",+"42+ABC")]
++[TestCase("42abc",+"42abc")]

++[TestCase("abc_cde",+"abc+cde")]
++[TestCase("Abc_Cde",+"Abc+Cde")]
++[TestCase("_Abc__Cde_",+"Abc+Cde")]
++[TestCase("ABC_CDE_FGH",+"ABC+CDE+FGH")]
++[TestCase("ABC+CDE+FGH",+"ABC+CDE+FGH")]+//+Should+not+happend+(white+char)+anything+that+is+not+a+letter/digit/'_'+is+considered+as+a+separator
++[TestCase("ABC,CDE;FGH",+"ABC+CDE+FGH")]+//+Should+not+happend+(,;)+anything+that+is+not+a+letter/digit/'_'+is+considered+as+a+separator
++[TestCase("abc<cde",+"abc+cde")]
++[TestCase("abc<>cde",+"abc+cde")]
++[TestCase("abc<D>cde",+"abc+cde")]++//+Ignore+one+letter+or+one+digit+words
++[TestCase("abc<Da>cde",+"abc+Da+cde")]
++[TestCase("abc<cde>",+"abc+cde")]

++[TestCase("SimpleHTTPServer",+"Simple+HTTP+Server")]
++[TestCase("SimpleHTTPS2erver",+"Simple+HTTPS2erver")]
++[TestCase("camelCase",+"camel+Case")]
++[TestCase("m_Field",+"Field")]
++[TestCase("mm_Field",+"mm+Field")]
++public+void+Test_GetWords(string+identifier,+string+expectedWordsStr)+{
+++++var+expectedWords+=+expectedWordsStr.Split('+');
+++++if+(identifier+==+null+%7C%7C+identifier.Length+<=+1)+{
++++++++expectedWords+=+new+string[0];
+++++}

+++++var+words+=+identifier.GetWords();
+++++Assert.IsTrue(words.SequenceEqual(expectedWords));
++}|1518843|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Procedural and fast impl:

<pre><code> /// &lt;summary&gt;
 /// Get the words in a code &lt;paramref name="identifier"/&gt;.
 /// &lt;/summary&gt;
 /// &lt;param name="identifier"&gt;The code &lt;paramref name="identifier"/&gt;&lt;/param&gt; to extract words from.
 public static string[] GetWords(this string identifier) {
 Contract.Ensures(Contract.Result&lt;string[]&gt;() != null, "returned array of string is not null but can be empty");
 if (identifier == null) { return new string[0]; }
 if (identifier.Length == 0) { return new string[0]; }

 const int MIN_WORD_LENGTH = 2; // Ignore one letter or one digit words

 var length = identifier.Length;
 var list = new List&lt;string&gt;(1 + length/2); // Set capacity, not possible more words since we discard one char words
 var sb = new StringBuilder();
 CharKind cKindCurrent = GetCharKind(identifier[0]); // length is not zero here
 CharKind cKindNext = length == 1 ? CharKind.End : GetCharKind(identifier[1]);

 for (var i = 0; i &lt; length; i++) {
 var c = identifier[i];
 CharKind cKindNextNext = (i &gt;= length - 2) ? CharKind.End : GetCharKind(identifier[i + 2]);

 // Process cKindCurrent
 switch (cKindCurrent) {
 case CharKind.Digit:
 case CharKind.LowerCaseLetter:
 sb.Append(c); // Append digit or lowerCaseLetter to sb
 if (cKindNext == CharKind.UpperCaseLetter) {
 goto TURN_SB_INTO_WORD; // Finish word if next char is upper
 }
 goto CHAR_PROCESSED;
 case CharKind.Other:
 goto TURN_SB_INTO_WORD;
 default: // charCurrent is never Start or End
 Debug.Assert(cKindCurrent == CharKind.UpperCaseLetter);
 break;
 }

 // Here cKindCurrent is UpperCaseLetter
 // Append UpperCaseLetter to sb anyway
 sb.Append(c); 

 switch (cKindNext) {
 default:
 goto CHAR_PROCESSED;

 case CharKind.UpperCaseLetter: 
 // "SimpleHTTPServer" when we are at 'P' we need to see that NextNext is 'e' to get the word!
 if (cKindNextNext == CharKind.LowerCaseLetter) {
 goto TURN_SB_INTO_WORD;
 }
 goto CHAR_PROCESSED;

 case CharKind.End:
 case CharKind.Other:
 break; // goto TURN_SB_INTO_WORD;
 }

 //------------------------------------------------

 TURN_SB_INTO_WORD:
 string word = sb.ToString();
 sb.Length = 0;
 if (word.Length &gt;= MIN_WORD_LENGTH) { 
 list.Add(word);
 }

 CHAR_PROCESSED:
 // Shift left for next iteration!
 cKindCurrent = cKindNext;
 cKindNext = cKindNextNext;
 }

 string lastWord = sb.ToString();
 if (lastWord.Length &gt;= MIN_WORD_LENGTH) {
 list.Add(lastWord);
 }
 return list.ToArray();
 }
 private static CharKind GetCharKind(char c) {
 if (char.IsDigit(c)) { return CharKind.Digit; }
 if (char.IsLetter(c)) {
 if (char.IsUpper(c)) { return CharKind.UpperCaseLetter; }
 Debug.Assert(char.IsLower(c));
 return CharKind.LowerCaseLetter;
 }
 return CharKind.Other;
 }
 enum CharKind {
 End, // For end of string
 Digit,
 UpperCaseLetter,
 LowerCaseLetter,
 Other
 }
</code></pre>

Tests:

<pre><code> [TestCase((string)null, "")]
 [TestCase("", "")]

 // Ignore one letter or one digit words
 [TestCase("A", "")]
 [TestCase("4", "")]
 [TestCase("_", "")]
 [TestCase("Word_m_Field", "Word Field")]
 [TestCase("Word_4_Field", "Word Field")]

 [TestCase("a4", "a4")]
 [TestCase("ABC", "ABC")]
 [TestCase("abc", "abc")]
 [TestCase("AbCd", "Ab Cd")]
 [TestCase("AbcCde", "Abc Cde")]
 [TestCase("ABCCde", "ABC Cde")]

 [TestCase("Abc42Cde", "Abc42 Cde")]
 [TestCase("Abc42cde", "Abc42cde")]
 [TestCase("ABC42Cde", "ABC42 Cde")]
 [TestCase("42ABC", "42 ABC")]
 [TestCase("42abc", "42abc")]

 [TestCase("abc_cde", "abc cde")]
 [TestCase("Abc_Cde", "Abc Cde")]
 [TestCase("_Abc__Cde_", "Abc Cde")]
 [TestCase("ABC_CDE_FGH", "ABC CDE FGH")]
 [TestCase("ABC CDE FGH", "ABC CDE FGH")] // Should not happend (white char) anything that is not a letter/digit/'_' is considered as a separator
 [TestCase("ABC,CDE;FGH", "ABC CDE FGH")] // Should not happend (,;) anything that is not a letter/digit/'_' is considered as a separator
 [TestCase("abc&lt;cde", "abc cde")]
 [TestCase("abc&lt;&gt;cde", "abc cde")]
 [TestCase("abc&lt;D&gt;cde", "abc cde")] // Ignore one letter or one digit words
 [TestCase("abc&lt;Da&gt;cde", "abc Da cde")]
 [TestCase("abc&lt;cde&gt;", "abc cde")]

 [TestCase("SimpleHTTPServer", "Simple HTTP Server")]
 [TestCase("SimpleHTTPS2erver", "Simple HTTPS2erver")]
 [TestCase("camelCase", "camel Case")]
 [TestCase("m_Field", "Field")]
 [TestCase("mm_Field", "mm Field")]
 public void Test_GetWords(string identifier, string expectedWordsStr) {
 var expectedWords = expectedWordsStr.Split(' ');
 if (identifier == null || identifier.Length &lt;= 1) {
 expectedWords = new string[0];
 }

 var words = identifier.GetWords();
 Assert.IsTrue(words.SequenceEqual(expectedWords));
 }
</code></pre>

blocks|key|1733932|text|一个简单的解决方案，它应该比正则表达式解决方案快几个数量级(基于我对此线程中的顶级解决方案运行的测试)，特别是在输入字符串的大小增长时：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1733933|string+s1+=+"ThisIsATestStringAbcDefGhiJklMnoPqrStuVwxYz";
string+s2;
StringBuilder+sb+=+new+StringBuilder();

foreach+(char+c+in+s1)
++++sb.Append(char.IsUpper(c)
++++++++?+"+"+%2B+c.ToString()
++++++++:+c.ToString());

s2+=+sb.ToString();|code-block|syntax|javascript|1733934|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|$]]

A simple solution, which should be order(s) of magnitude faster than a regex solution (based on the tests I ran against the top solutions in this thread), especially as the size of the input string grows:

<pre><code>string s1 = "ThisIsATestStringAbcDefGhiJklMnoPqrStuVwxYz";
string s2;
StringBuilder sb = new StringBuilder();

foreach (char c in s1)
 sb.Append(char.IsUpper(c)
 ? " " + c.ToString()
 : c.ToString());

s2 = sb.ToString();
</code></pre>

How do I go from this string: "ThisIsMyCapsDelimitedString"

...to this string: "This Is My Caps Delimited String"

Fewest lines of code in VB.net is preferred but C# is also welcome.

Cheers!

.NET - How can you split a "caps" delimited string into an array?

如何从这个字符串开始："ThisIsMyCapsDelimitedString“此字符串："This Is My Caps ...to String“最好使用最少的VB.net代码行，但也欢迎使用C#。干杯!

问.NET -如何将"caps“分隔的字符串拆分成数组？
EN

回答 14

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问.NET -如何将"caps“分隔的字符串拆分成数组？EN

回答 14

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问.NET -如何将"caps“分隔的字符串拆分成数组？
EN