C#

System.Text.StringBuilder sb = new System.Text.StringBuilder ( "ABCD" ) ;
sb.Insert ( 0 , "BLABLA" , 1 ) ;

shyagam wrote:

It is well known that when a string's length is already known or can be easily calculated, it is best to use StringBuilder instead of string.

shyagam wrote:

The reason I think it's the same is because to my understanding, when hardcoding the "BLABLA" string, memory is allocated for it anyway.

string s="";
foreach (char c in "abcdefghijklmnopqrstuvwxyz") s=s+c;
Console.WriteLine(s);

StringBuilder sb=new StringBuilder(100);  // large enough
foreach (char c in "abcdefghijklmnopqrstuvwxyz") sb.Append(c);
string s=sb.ToString();
Console.WriteLine(s);

haseebbutt007 wrote:

the windows installer automatically copy that DLL in System and System32 Folders

Well, actually, it doesn't hang. It just takes a really really long time, and you haven't waited long enough for it to finish. One of the pitfalls with regular expression is that you can write expressions which don't perform very well. In particular, you can end up with expressions whose search time grows exponentially with the length of the search string. I get bugs reporting that Regex hangs about once a month, and it always turns out to be an exponentially slow expression. Here's a simplified example of one of them:

([a-z]+)*=

There are two things interesting about this expression. First, notice that it has two quantifiers nested within each other. The inner one is the + quantifier for the character class, and the outer one is the *. Second, it has a character (the equals char) that must be matched at the end of the result. In English terms, this expression can be explained as

1. match any character a-z, one or more times
2. match step #1 zero or more times
3. match an equals

What will happen is that Regex will breeze through step 1 and 2 only to find that it can't match in step 3. That forces it to backtrack and try to match the first two steps differently. The trouble is that there are a lot of different ways that steps 1 and 2 can match, and Regex needs to try every single one before it can determine that the expression does not match the string.

dan neely wrote:

It's gargantuan, about the size of a large paragraph.

Scott Dorman wrote:

There isn't one.

(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])