CODEWITHSUNDEEP
c#performance
anon
anon

Reputation:

Make first letter of a string upper case (with maximum performance)

I have a DetailsView with a TextBox and I want the input data be saved always with the first letter in capital.

Example:

"red" --> "Red"
"red house" --> " Red house"

How can I achieve this maximizing performance?

Note:

Based on the answers and the comments under the answers, many people think this is asking about capitalizing all words in the string. E.g. => Red House It isn't, but if that is what you seek, look for one of the answers that uses TextInfo's ToTitleCase method. (Note: Those answers are incorrect for the question actually asked.) See TextInfo.ToTitleCase documentation for caveats (doesn't touch all-caps words - they are considered acronyms; may lowercase letters in middle of words that "shouldn't" be lowered, e.g., "McDonald" → "Mcdonald"; not guaranteed to handle all culture-specific subtleties re capitalization rules.)

Note:

The question is ambiguous as to whether letters after the first should be forced to lower case. The accepted answer assumes that only the first letter should be altered. If you want to force all letters in the string except the first to be lower case, look for an answer containing ToLower, and not containing ToTitleCase.

Upvotes: 646

Views: 797218

Answers (30)

BionicCode
BionicCode

Reputation: 28968

The key is to avoid string manipulations. Because string is immutable any manipulation results in a new copy.

Working on arrays is usually fast. Using Span<T>also allows for some improved memory management especially when passing and processing the string. The string should stay as long as possible a Span<T>. In other words, whenever possible, replace string with ReadOnlySpan<T> or Span<T>.

For example, define parameters as ReadOnlySpan<char> instead of string. Changing method parameters won't break the API as there is an implicit cast from string to ReadOnlySpan<char>. Whlie it doesn't break the API, it will improve the performance:

public static void Main()
{
  string someText = "Some text";

  // string is converted to ReadOnlySpan<char> implicitly
  ImplicitCastExample(someText); 
}

private static void ImplicitCastExample(ReadOnlySpan<char> stringContent)
{ 
  // Convert the span back to a string when necessary
  string stringValue = strngContent.ToString();
}

Implementation

The example requires .Net Standard 2.1, .NET Core 2.1 or .NET (in order to support the implicit cast from string to ReadOnlySpan<T>).

public static class StringHelper
{
  public static ReadOnlySpan<char> ToUpper(this string stringValue, int index)
  {
    Span<char> stringContent = stringValue.ToCharArray();
    stringContent[index] = char.ToUpper(stringContent[index]);
    return stringContent;
  }

  public static ReadOnlySpan<char> ToUpper(this ReadOnlySpan<char> stringValue, int index)
  {
    Span<char> stringContent = stringValue.ToArray();
    stringContent[index] = char.ToUpper(stringContent[index]);
    return stringContent;
  }

  public static void ToUpper(this Span<char> stringContent, int index)
    => stringContent[index] = char.ToUpper(stringContent[index]);
}

Usage example

string someText = "Some text";

// Capitalize the first character
ReadOnlySpan<char> capitalizedStringContent = someText.ToUpper(0);

// Capitalize the first character
ReadOnlySpan<char> stringContent = 
ReadOnlySpan<char> capitalizedStringContent = someText.ToUpper(0);

// Use ReadOnlySpan<char> (or Span<T>) as long as possible
// e.g. for manipulations, parsing or as method arguments
// to avoid creation of numerous string copies.
Span<char> replacedStringContent = new Span<char>();
capitalizedString.Replace(replacedStringContent, 'o', 'a');
      
// Finalize to string
replacedStringContent.ToString(); // "Same text"

Upvotes: 0

bo bac
bo bac

Reputation: 17

in addition to @Carlos Muñoz I'd say

public static string FirstCharToUpper(this string input) =>
   input switch
   {
      string s when string.IsNullOrWhiteSpace(s) => throw new ArgumentException($"{nameof(input)} cannot be null, empty or whitespace", nameof(input)),
      _ => string.Concat(input[0].ToString().ToUpper(), input.AsSpan(1))
   };

Upvotes: -2

Celso Jr
Celso Jr

Reputation: 295

Too late for the party, but either way, here is my 2 cents:

static string ToTitleCase(string str)
    => string.Concat((char)(str[0] & 0xDF), str[1..]);

Upvotes: -2

Diego
Diego

Reputation: 20194

public string FirstLetterToUpper(string str)
{
    if (str == null)
        return null;

    if (str.Length > 1)
        return char.ToUpper(str[0]) + str.Substring(1);

    return str.ToUpper();
}

this can also be written as

public string ToTitleCase(string str)
{
    var firstword = System.Globalization.CultureInfo.CurrentCulture.TextInfo.ToTitleCase(str.Split(' ')[0].ToLower());
    str = str.Replace(str.Split(' ')[0],firstword);
    return str;
}

Where it picks up the first word and converts it to title case then replaces it in the input string.

Upvotes: 408

OCP30pt1c1l1l43-X1z17
OCP30pt1c1l1l43-X1z17

Reputation: 232

This also works, using Take, Skip and Aggregate:

    public static string FirstCharToUpper(this string text) 
    {
      if (String.IsNullOrEmpty(text)) return String.Empty;
      var first = text.Take(1).ToArray()[0].ToString().ToUpper();
      var rest = text.Skip(1).Aggregate("", ((xs, x) => xs + x));
      return first + rest;
    }

Upvotes: -2

Carlos Mu&#241;oz
Carlos Mu&#241;oz

Reputation: 17804

Solution in different C# versions

C# 8 with at least .NET Core 3.0 or .NET Standard 2.1

public static class StringExtensions
{
    public static string FirstCharToUpper(this string input) =>
        input switch
        {
            null => throw new ArgumentNullException(nameof(input)),
            "" => throw new ArgumentException($"{nameof(input)} cannot be empty", nameof(input)),
            _ => string.Concat(input[0].ToString().ToUpper(), input.AsSpan(1))
        };
}

Since .NET Core 3.0 / .NET Standard 2.1 String.Concat() supports ReadonlySpan<char> which saves one allocation if we use .AsSpan(1) instead of .Substring(1).

C# 8

public static class StringExtensions
{
    public static string FirstCharToUpper(this string input) =>
        input switch
        {
            null => throw new ArgumentNullException(nameof(input)),
            "" => throw new ArgumentException($"{nameof(input)} cannot be empty", nameof(input)),
            _ => input[0].ToString().ToUpper() + input.Substring(1)
        };
}

C# 7

public static class StringExtensions
{
    public static string FirstCharToUpper(this string input)
    {
        switch (input)
        {
            case null: throw new ArgumentNullException(nameof(input));
            case "": throw new ArgumentException($"{nameof(input)} cannot be empty", nameof(input));
            default: return input[0].ToString().ToUpper() + input.Substring(1);
        }
    }
}

Really old answers

public static string FirstCharToUpper(string input)
{
    if (String.IsNullOrEmpty(input))
        throw new ArgumentException("ARGH!");
    return input.First().ToString().ToUpper() + String.Join("", input.Skip(1));
}

This version is shorter. For a faster solution, take a look at Diego's answer.

public static string FirstCharToUpper(string input)
{
    if (String.IsNullOrEmpty(input))
        throw new ArgumentException("ARGH!");
    return input.First().ToString().ToUpper() + input.Substring(1);
}

Probably the fastest solution is Darren's (There's even a benchmark) although I would change it's string.IsNullOrEmpty(s) validation to throw an exception since the original requirement expects for a first letter to exist so it can be uppercased. Note that this code works for a generic string and not particularly on valid values from the Textbox.

Upvotes: 842

Patrick Knott
Patrick Knott

Reputation: 1827

I wanted to provide a "maximum performance" answer. In my mind, a "maximum performance" answer catches all scenarios and provides the answer to the question accounting for those scenarios. So, here is my answer. With these reasons:

  1. IsNullOrWhiteSpace accounts for strings that are just spaces or null/empty.

  2. .Trim() removes white space from the front and back of the string.

  3. .First() takes the first element of an IEnumerable<TSource> (or string).

  4. We should check to see if it is a letter that can/should be uppercase.

  5. We then add the rest of the string, only if the length indicates we should.

  6. By .NET best practice, we should provide a culture under System.Globalization.CultureInfo.

  7. Providing them as optional parameters makes this method totally reusable, without having to type the chosen culture every time.

  8. I also noticed that my and most of these answers did not maintain the whitespace at the beginning of the string. This will also show how to maintain that whitespace.

    //Capitalize the first letter disregard all chars using regex.
public static string RegCapString(this string instring, string culture = "en-US", bool useSystem = false)
{
    if (string.IsNullOrWhiteSpace(instring))
    {
        return instring;
    }
    var m = Regex.Match(instring, "[A-Za-z]").Index;
    return instring.Substring(0, m) + instring[m].ToString().ToUpper(new CultureInfo(culture, useSystem)) + instring.Substring(m + 1);
}
//Capitalize first char if it is a letter disregard white space.
public static string CapString(this string instring, string culture = "en-US", bool useSystem = false)
{
    if (string.IsNullOrWhiteSpace(instring) ||
       !char.IsLetter(instring.Trim().First()))
    {
        return instring;
    }
    var whiteSpaces = instring.Length - instring.TrimStart().Length;
    return (new string(' ', whiteSpaces)) + 
        instring.Trim().First().ToString().ToUpper(new CultureInfo(culture, useSystem)) + 
        ((instring.TrimStart().Length > 1) ? instring.Substring(whiteSpaces + 1) : "");
}

Upvotes: 1

Marcell Toth
Marcell Toth

Reputation: 3688

As this question is about maximizing performance, I adopted Darren's version to use Spans, which reduces garbage and improves speed by about 10%.

/// <summary>
/// Returns the input string with the first character converted to uppercase
/// </summary>
public static string ToUpperFirst(this string s)
{
    if (string.IsNullOrEmpty(s))
        throw new ArgumentException("There is no first letter");

    Span<char> a = stackalloc char[s.Length];
    s.AsSpan(1).CopyTo(a.Slice(1));
    a[0] = char.ToUpper(s[0]);
    return new string(a);
}

Performance

Method Data Mean Error StdDev
Carlos red 107.29 ns 2.2401 ns 3.9234 ns
Darren red 30.93 ns 0.9228 ns 0.8632 ns
Marcell red 26.99 ns 0.3902 ns 0.3459 ns
Carlos red house 106.78 ns 1.9713 ns 1.8439 ns
Darren red house 32.49 ns 0.4253 ns 0.3978 ns
Marcell red house 27.37 ns 0.3888 ns 0.3637 ns

Full test code

using System;
using System.Linq;

using BenchmarkDotNet.Attributes;

namespace CorePerformanceTest
{
    public class StringUpperTest
    {
        [Params("red", "red house")]
        public string Data;

        [Benchmark]
        public string Carlos() => Data.Carlos();

        [Benchmark]
        public string Darren() => Data.Darren();

        [Benchmark]
        public string Marcell() => Data.Marcell();
    }

    internal static class StringExtensions
    {
        public static string Carlos(this string input) =>
            input switch
            {
                null => throw new ArgumentNullException(nameof(input)),
                "" => throw new ArgumentException($"{nameof(input)} cannot be empty", nameof(input)),
                _ => input.First().ToString().ToUpper() + input.Substring(1)
            };

        public static string Darren(this string s)
        {
            if (string.IsNullOrEmpty(s))
                throw new ArgumentException("There is no first letter");

            char[] a = s.ToCharArray();
            a[0] = char.ToUpper(a[0]);
            return new string(a);
        }

        public static string Marcell(this string s)
        {
            if (string.IsNullOrEmpty(s))
                throw new ArgumentException("There is no first letter");

            Span<char> a = stackalloc char[s.Length];
            s.AsSpan(1).CopyTo(a.Slice(1));
            a[0] = char.ToUpper(s[0]);
            return new string(a);
        }
    }

}

Upvotes: 17

sayah imad
sayah imad

Reputation: 1553

Possible solution to resolve your problem:

   public static string FirstToUpper(this string lowerWord)
   {
       if (string.IsNullOrWhiteSpace(lowerWord) || string.IsNullOrEmpty(lowerWord))
            return lowerWord;
       return new StringBuilder(lowerWord.Substring(0, 1).ToUpper())
                 .Append(lowerWord.Substring(1))
                 .ToString();
   }

Upvotes: 1

mbadeveloper
mbadeveloper

Reputation: 1270

Check if the string is not null, convert the first character to upper case and the rest of them to lower case:

public static string FirstCharToUpper(string str)
{
    return str?.First().ToString().ToUpper() + str?.Substring(1).ToLower();
}

Upvotes: 8

D.JCode
D.JCode

Reputation: 406

I think the below method is the best solution.

class Program
{
    static string UppercaseWords(string value)
    {
        char[] array = value.ToCharArray();
        // Handle the first letter in the string.
        if (array.Length >= 1)
        {
            if (char.IsLower(array[0]))
            {
                array[0] = char.ToUpper(array[0]);
            }
        }
        // Scan through the letters, checking for spaces.
        // ... Uppercase the lowercase letters following spaces.
        for (int i = 1; i < array.Length; i++)
        {
            if (array[i - 1] == ' ')
            {
                if (char.IsLower(array[i]))
                {
                    array[i] = char.ToUpper(array[i]);
                }
            }
        }
        return new string(array);
    }

    static void Main()
    {
        // Uppercase words in these strings.
        const string value1 = "something in the way";
        const string value2 = "dot net PERLS";
        const string value3 = "String_two;three";
        const string value4 = " sam";
        // ... Compute the uppercase strings.
        Console.WriteLine(UppercaseWords(value1));
        Console.WriteLine(UppercaseWords(value2));
        Console.WriteLine(UppercaseWords(value3));
        Console.WriteLine(UppercaseWords(value4));
    }
}

Output

Something In The Way
Dot Net PERLS
String_two;three
 Sam

Reference

Upvotes: 1

Grimm
Grimm

Reputation: 791

Recently I had a similar requirement and remembered that the LINQ function Select() provides an index:

string input;
string output;

input = "red house";
output = String.Concat(input.Select((currentChar, index) => index == 0 ? Char.ToUpper(currentChar) : currentChar));
//output = "Red house"

Since I need that very often I made an extension method for the string type:

public static class StringExtensions
{
    public static string FirstLetterToUpper(this string input)
    {
        if (string.IsNullOrEmpty(input))
            return string.Empty;
        return String.Concat(input.Select((currentChar, index) => index == 0 ? Char.ToUpper(currentChar) : currentChar));
    }
}

Please note that only the first letter is converted to upper case - all remaining characters are not touched. If you need the other characters to be lower case you may also call Char.ToLower(currentChar) for index > 0 or call ToLower() on the whole string in the first place.

Regarding performance I compared the code with the solution from Darren. On my machine Darren's code is about two times faster which is no surprise since he's directly editing only the first letter within a char array.

So I suggest you take Darren's code if you need the fastest solution available. If you want to integrate other string manipulations as well it may be convenient to have the expressive power of a lambda function touching the characters of the input string - you can easily extend this function - so I leave this solution here.

Upvotes: -1

CheeseNPort
CheeseNPort

Reputation: 48

I use this to correct names. It basically works on the concept of changing a character to uppercase if it follows a specific pattern. In this case I've gone for space and dash of "Mc".

private String CorrectName(String name)
{
    List<String> StringsToCapitalizeAfter = new List<String>() { " ", "-", "Mc" };
    StringBuilder NameBuilder = new StringBuilder();
    name.Select(c => c.ToString()).ToList().ForEach(c =>
    {
        c = c.ToLower();
        StringsToCapitalizeAfter.ForEach(s =>
        {
            if(String.IsNullOrEmpty(NameBuilder.ToString()) ||
               NameBuilder.ToString().EndsWith(s))
            {
                c = c.ToUpper();
            }
        });
        NameBuilder.Append(c);
    });
    return NameBuilder.ToString();
}

Upvotes: -4

user4266998
user4266998

Reputation:

The following function is correct for all ways:

static string UppercaseWords(string value)
{
    char[] array = value.ToCharArray();
    // Handle the first letter in the string.
    if (array.Length >= 1)
    {
        if (char.IsLower(array[0]))
        {
            array[0] = char.ToUpper(array[0]);
        }
    }
    // Scan through the letters, checking for spaces.
    // ... Uppercase the lowercase letters following spaces.
    for (int i = 1; i < array.Length; i++)
    {
        if (array[i - 1] == ' ')
        {
            if (char.IsLower(array[i]))
            {
                array[i] = char.ToUpper(array[i]);
            }
        }
    }
    return new string(array);
}

I found that here.

Upvotes: 0

Александр Иванов
Александр Иванов

Reputation: 109

The fastest method:

private string Capitalize(string s){
    if (string.IsNullOrEmpty(s))
    {
        return string.Empty;
    }
    char[] a = s.ToCharArray();
    a[0] = char.ToUpper(a[0]);
    return new string(a);
}

Tests show the next results (string with 1,0000,000 symbols as input):

Test results

Upvotes: 9

V&#237;ctor Garc&#237;a
V&#237;ctor Garc&#237;a

Reputation: 81

If you only care about the first letter being capitalized and it does not matter the rest of the string, you can just select the first character, make it upper case and concatenate it with the rest of the string without the original first character.

String word ="red house";
word = word[0].ToString().ToUpper() + word.Substring(1, word.length -1);
//result: word = "Red house"

We need to convert the first character ToString(), because we are reading it as a Char array, and the Char type does not have a ToUpper() method.

Upvotes: 6

Anonymous
Anonymous

Reputation: 51

This is the fastest way:

public static unsafe void ToUpperFirst(this string str)
{
    if (str == null)
        return;
    fixed (char* ptr = str)
        *ptr = char.ToUpper(*ptr);
}

Without changing the original string:

public static unsafe string ToUpperFirst(this string str)
{
    if (str == null)
        return null;
    string ret = string.Copy(str);
    fixed (char* ptr = ret)
        *ptr = char.ToUpper(*ptr);
    return ret;
}

Upvotes: 1

Dinis Cruz
Dinis Cruz

Reputation: 4269

FluentSharp has the lowerCaseFirstLetter method which does this.

Upvotes: 0

Darren
Darren

Reputation: 9499

I took the fastest method from C# Uppercase First Letter - Dot Net Perls and converted to an extension method:

    /// <summary>
    /// Returns the input string with the first character converted to uppercase, or mutates any nulls passed into string.Empty
    /// </summary>
    public static string FirstLetterToUpperCaseOrConvertNullToEmptyString(this string s)
    {
        if (string.IsNullOrEmpty(s))
            return string.Empty;

        char[] a = s.ToCharArray();
        a[0] = char.ToUpper(a[0]);
        return new string(a);
    }

NOTE: The reason using ToCharArray is faster than the alternative char.ToUpper(s[0]) + s.Substring(1), is that only one string is allocated, whereas the Substring approach allocates a string for the substring, and then a second string to compose the final result.

Here is what this approach looks like, combined with the initial test from CarlosMuñoz's accepted answer:

    /// <summary>
    /// Returns the input string with the first character converted to uppercase
    /// </summary>
    public static string FirstLetterToUpperCase(this string s)
    {
        if (string.IsNullOrEmpty(s))
            throw new ArgumentException("There is no first letter");

        char[] a = s.ToCharArray();
        a[0] = char.ToUpper(a[0]);
        return new string(a);
    }

Upvotes: 94

Stephen Kennedy
Stephen Kennedy

Reputation: 21548

There seems to be a lot of complexity here when all you need is:

/// <summary>
/// Returns the input string with the first character converted to uppercase if a letter
/// </summary>
/// <remarks>Null input returns null</remarks>
public static string FirstLetterToUpperCase(this string s)
{
    if (string.IsNullOrWhiteSpace(s))
        return s;

    return char.ToUpper(s[0]) + s.Substring(1);
}

Noteworthy points:

  1. It's an extension method.

  2. If the input is null, empty or white space the input is returned as is.

  3. String.IsNullOrWhiteSpace was introduced with .NET Framework 4. This won't work with older frameworks.

Upvotes: 1

Noctis
Noctis

Reputation: 11763

It seems like none of the solutions given here will deal with a white space before the string.

Just adding this as a thought:

public static string SetFirstCharUpper2(string aValue, bool aIgonreLeadingSpaces = true)
{
    if (string.IsNullOrWhiteSpace(aValue))
        return aValue;

    string trimmed = aIgonreLeadingSpaces
           ? aValue.TrimStart()
           : aValue;

    return char.ToUpper(trimmed[0]) + trimmed.Substring(1);
}

It should handle this won't work on other answers (that sentence has a space in the beginning), and if you don't like the space trimming, just pass a false as the second parameter (or change the default to false, and pass true if you want to deal with space)).

Upvotes: 0

Xameer
Xameer

Reputation: 31237

I found something in C# Uppercase First Letter - Dot Net Perls:

static string UppercaseFirst(string s)
{
    // Check for empty string.
    if (string.IsNullOrEmpty(s))
    {
        return string.Empty;
    }

    // Return char and concat substring.
    return char.ToUpper(s[0]) + s.Substring(1);
}

Upvotes: 5

sebacipo
sebacipo

Reputation: 810

With this method you can upper the first character of every word.

Example

"HeLlo wOrld" => "Hello World"

public static string FirstCharToUpper(string input)
{
    if (String.IsNullOrEmpty(input))
        throw new ArgumentException("Error");
    return string.Join(" ", input.Split(' ').Select(d => d.First().ToString().ToUpper() +  d.ToLower().Substring(1)));
}

Upvotes: -4

Sudipta Mukherjee
Sudipta Mukherjee

Reputation: 111

The simplest and fastest way is to replace the first character of the string by making it an upper case character:

string str = "test";<br>
str = str.Replace(str[0], char.ToUpper(str[0]));

Upvotes: -7

Prashant Banavali
Prashant Banavali

Reputation: 13

Use the following code:

string strtest ="PRASHANT";
strtest.First().ToString().ToUpper() + strtest.Remove(0, 1).ToLower();

Upvotes: -2

İbrahim &#214;zb&#246;l&#252;k
İbrahim &#214;zb&#246;l&#252;k

Reputation: 3192

You can use the "ToTitleCase method":

string s = new CultureInfo("en-US").TextInfo.ToTitleCase("red house");
//result : Red House

This extension method solves every titlecase problem.

It is easy to use:

string str = "red house";
str.ToTitleCase();
//result : Red house

string str = "red house";
str.ToTitleCase(TitleCase.All);
//result : Red House

The extension method:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Globalization;

namespace Test
{
    public static class StringHelper
    {
        private static CultureInfo ci = new CultureInfo("en-US");
        //Convert all first latter
        public static string ToTitleCase(this string str)
        {
            str = str.ToLower();
            var strArray = str.Split(' ');
            if (strArray.Length > 1)
            {
                strArray[0] = ci.TextInfo.ToTitleCase(strArray[0]);
                return string.Join(" ", strArray);
            }
            return ci.TextInfo.ToTitleCase(str);
        }

        public static string ToTitleCase(this string str, TitleCase tcase)
        {
            str = str.ToLower();
            switch (tcase)
            {
                case TitleCase.First:
                    var strArray = str.Split(' ');
                    if (strArray.Length > 1)
                    {
                        strArray[0] = ci.TextInfo.ToTitleCase(strArray[0]);
                        return string.Join(" ", strArray);
                    }
                    break;
                case TitleCase.All:
                    return ci.TextInfo.ToTitleCase(str);
                default:
                    break;
            }
            return ci.TextInfo.ToTitleCase(str);
        }
    }

    public enum TitleCase
    {
        First,
        All
    }
}

Upvotes: 53

Daniel Halan
Daniel Halan

Reputation: 584

If performance/memory usage is an issue then, this one only creates one (1) StringBuilder and one (1) new String of the same size as the original string.

public static string ToUpperFirst(this string str) {
  if(!string.IsNullOrEmpty(str)) {
    StringBuilder sb = new StringBuilder(str);
    sb[0] = char.ToUpper(sb[0]);

    return sb.ToString();

  } else return str;
}

Upvotes: 7

thattolleyguy
thattolleyguy

Reputation: 813

This capitalizes the first letter and every letter following a space and lower cases any other letter.

public string CapitalizeFirstLetterAfterSpace(string input)
{
    System.Text.StringBuilder sb = new System.Text.StringBuilder(input);
    bool capitalizeNextLetter = true;
    for(int pos = 0; pos < sb.Length; pos++)
    {
        if(capitalizeNextLetter)
        {
            sb[pos]=System.Char.ToUpper(sb[pos]);
            capitalizeNextLetter = false;
        }
        else
        {
            sb[pos]=System.Char.ToLower(sb[pos]);
        }

        if(sb[pos]=' ')
        {
            capitalizeNextLetter=true;
        }
    }
}

Upvotes: -2

Jeff Hornby
Jeff Hornby

Reputation: 13640

This will do it although it will also make sure that there are no errant capitals that are not at the beginning of the word.

public string(string s)
{
    System.Globalization.CultureInfo c = new System.Globalization.CultureInfo("en-us", false)
    System.Globalization.TextInfo t = c.TextInfo;

    return t.ToTitleCase(s);
}

Upvotes: 3

Kobi
Kobi

Reputation: 138017

For the first letter, with error checking:

public string CapitalizeFirstLetter(string s)
{
    if (String.IsNullOrEmpty(s))
        return s;
    if (s.Length == 1)
        return s.ToUpper();
    return s.Remove(1).ToUpper() + s.Substring(1);
}

And here's the same as a handy extension

public static string CapitalizeFirstLetter(this string s)
{
    if (String.IsNullOrEmpty(s))
        return s;
    if (s.Length == 1)
        return s.ToUpper();
    return s.Remove(1).ToUpper() + s.Substring(1);
}

Upvotes: 42

Related Questions