Converting strings to PascalCase

If performance is your main concern, you might want to loop through the string just once, using a for loop, and appending substrings to the StringBuilder.

It will make your code a little longer and mebe a little harder to read.

Here is an example of what it might look like.

public static string ToPascalCase(this string s)
{
    StringBuilder sb = new StringBuilder(s.Length);
    int a = 1, b = 1;
    bool toUpper = true;

    for (int i = 0; i < s.Length; i++)
    {
        switch (s[i])
        {
            case '-':
            case '_':
                if (a != b)
                {
                    sb.Append(s.Substring(a, b - a));
                }
                a = b = i + 2;
                toUpper = true;
                break;

            default:
                if (toUpper)
                {
                    sb.Append(char.ToUpper(s[i]));
                    toUpper = false;
                }
                else
                {
                    b++;
                }
                break;
        }
    }

    if (a != b)
    {
        sb.Append(s.Substring(a, b - a));
    }

    return sb.ToString();
}

But as far as your code goes, it's short, readable, and unless you are performing millions of these all the time, I think your version is more than adequate.

I think you should use Concat instead of StringBuilder:

public static string ToPascalCase(this string s)
{
    var words = s.Split(new[] { '-', '_' }, StringSplitOptions.RemoveEmptyEntries)
                 .Select(word => word.Substring(0, 1).ToUpper() + 
                                 word.Substring(1).ToLower());

    var result = String.Concat(words);
    return result;
}

This solution should not be as fast as manually looping through the original string, but I think it is much easier to read and follow. Unless you do those convertions like 1000000 times per second, you should not complicate things.

Compared to the String, StringBuilder is mutable. Meaning you don't really need to Append multiple times, you could just replace the characters from the original string:

//that's just for the test
string s = "-asd_asd_asd-asd-";

if(s.Length == 0)
{
    return s;
}

var sb = new StringBuilder(s.ToLowerInvariant());
sb[0] = Char.ToUpper(sb[0]);

for (int i = 0; i < sb.Length; i++)
{
    if (sb[i] == '_' || sb[i] == '-')
    {
        sb.Remove(i, 1);
        if (i != sb.Length)
        {
            sb[i] = Char.ToUpper(sb[i]);
        }
    }
}

Using this technique you don't need to spit the string and do substrings. Obviously, there're more if involved :p But I think it would be faster.

Doing string concatenation to pass a string argument to the Append () method of the StringBuilder is the wrong way. Use instead multiple calls to prevent unneccessary creation of string objects. There are overloads for the different types so you could call it once for the starting uppercase char and another which takes the remaining string.

If by any chance there are some localized strings involved where the unicode textlength isn't 1 for a character, you won't get the expected results. See the accepted answer and mine here

While initializing a StringBuilder with a capacity is the way to go, I would like to suggest to just use the Length of the passed string s.

The passed in string s should be checked against null and if it is null throw an ArgumentNullException which would be more correct than the NullReferenceException you would get without the check.

This is my take on it, the akward part is that you need to convert the string to lower case before calling ToTitleCase because if all letters in a word are uppercase it will remain uppercased as it is identified as an acronym and preserved by the ToTitleCase implementation.

public static string ToPascalCase(this string text)
{
    return CultureInfo.InvariantCulture.TextInfo
        .ToTitleCase(text.ToLowerInvariant())
        .Replace("-", "")
        .Replace("_", "");
}

This version has got more readability using RegexReplace:

public static string ToPascalCase(this string text)
{
    const string pattern = @"(-|_)\w{1}|^\w";
    return Regex.Replace(text, pattern, match => match.Value.Replace("-", string.Empty).Replace("_", string.Empty).ToUpper());
}