Ich habe eine DetailsViewmit einem , TextBox und ich möchte , dass die Eingangsdaten werden immer gespeichert mit dem ersten Buchstaben CAPITAL.

Beispiel:

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

Wie kann ich diese maximale Leistung erreichen ?

HINWEIS :
Basierend auf den Antworten und den Kommentaren unter den Antworten denken viele Leute, dass hier nach der Großschreibung aller Wörter in der Zeichenfolge gefragt wird . ZB => Red House ist es nicht, aber wenn Sie danach suchen , suchen Sie nach einer der Antworten, die TextInfodie ToTitleCaseMethode von verwenden. (HINWEIS: Diese Antworten sind für die tatsächlich gestellte Frage falsch .) Informationen finden
Sie im TextInfo.ToTitleCase-Dokument (berührt keine Wörter mit Großbuchstaben - sie werden als Akronyme betrachtet; möglicherweise werden Kleinbuchstaben in der Mitte von Wörtern verwendet, die "nicht" sein sollten gesenkt, zB "McDonald" => "Mcdonald"; es wird nicht garantiert, dass alle kulturspezifischen Feinheiten bezüglich der Kapitalisierungsregeln behandelt werden.)

HINWEIS :
Die Frage ist nicht eindeutig , ob Buchstaben nach dem ersten werden sollten gezwungen zu Fall zu senken . Bei der akzeptierten Antwort wird davon ausgegangen, dass nur der erste Buchstabe geändert werden sollte . Wenn Sie alle Buchstaben in der Zeichenfolge außer dem ersten in Kleinbuchstaben erzwingen möchten , suchen Sie nach einer Antwort mitToLower , die ToTitleCase und nicht enthält .

Auf C # 8 aktualisiert

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.First().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.First().ToString().ToUpper() + input.Substring(1);
        }
    }
}

Wirklich alte Antworten

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

EDIT : Diese Version ist kürzer. Für eine schnellere Lösung werfen Sie einen Blick auf die Antwort von Equiso

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

EDIT 2 : Die wahrscheinlich schnellste Lösung ist die von Darren (es gibt sogar einen Benchmark), obwohl ich die string.IsNullOrEmpty(s)Validierung ändern würde, um eine Ausnahme auszulösen, da die ursprüngliche Anforderung erwartet, dass ein erster Buchstabe vorhanden ist, damit er in Großbuchstaben geschrieben werden kann. Beachten Sie, dass dieser Code für eine generische Zeichenfolge funktioniert und nicht speziell für gültige Werte aus dem Textbox.

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();
}

Alte Antwort: Dies macht jeden ersten Buchstaben in Großbuchstaben

public string ToTitleCase(string str)
{
    return CultureInfo.CurrentCulture.TextInfo.ToTitleCase(str.ToLower());
}

Der richtige Weg ist, Kultur zu nutzen:

System.Globalization.CultureInfo.CurrentCulture.TextInfo.ToTitleCase(word.ToLower())

Hinweis: Dadurch wird jedes Wort in einer Zeichenfolge groß geschrieben, z. B. "Rotes Haus" -> "Rotes Haus". Die Lösung wird auch Großbuchstaben in Worten verwenden, z. B. "alter McDonald" -> "alter Mcdonald".

Ich habe die schnellste Methode von http://www.dotnetperls.com/uppercase-first-letter übernommen und in die Erweiterungsmethode konvertiert:

    /// <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);
    }

ANMERKUNG: Der Grund für die Verwendung ToCharArrayist schneller als die Alternative char.ToUpper(s[0]) + s.Substring(1), da nur eine Zeichenfolge zugewiesen wird, während der SubstringAnsatz eine Zeichenfolge für die Teilzeichenfolge und dann eine zweite Zeichenfolge zum Erstellen des Endergebnisses zuweist.

EDIT : So sieht dieser Ansatz aus, kombiniert mit dem ersten Test von Carlos Muñoz akzeptierte Antwort :

    /// <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);
    }

Sie können die "ToTitleCase-Methode" verwenden.

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

Diese Erweiterungsmethode löst jedes Titelfallproblem.

einfach zu bedienen

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

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

die Erweiterungsmethode

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
    }
}

Für den ersten Buchstaben mit Fehlerprüfung:

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);
}

Und hier ist das gleiche wie eine praktische Erweiterung

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);
    }

public static string ToInvarianTitleCase(this string self)
{
    if (string.IsNullOrWhiteSpace(self))
    {
        return self;
    }

    return CultureInfo.InvariantCulture.TextInfo.ToTitleCase(self);
}

Wenn die Leistung / Speichernutzung ein Problem darstellt, erstellt dieser nur einen (1) StringBuilder und einen (1) neuen String mit der gleichen Größe wie der 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;
}

Schnellste Methode.

  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 zeigen die nächsten Ergebnisse (Zeichenfolge mit 10000000 Symbolen als Eingabe): Testergebnisse

Versuche dies:

static public string UpperCaseFirstCharacter(this string text) {
    return Regex.Replace(text, "^[a-z]", m => m.Value.ToUpper());
}

Wenn Sie sich nur dafür interessieren, dass der erste Buchstabe groß geschrieben wird und der Rest der Zeichenfolge keine Rolle spielt, können Sie einfach das erste Zeichen auswählen, es in Großbuchstaben schreiben und es mit dem Rest der Zeichenfolge ohne das ursprüngliche erste Zeichen verketten.

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

Wir müssen das erste Zeichen ToString () konvertieren, da wir es als Char-Array lesen und der Char-Typ keine ToUpper () -Methode hat.

Hier ist eine Möglichkeit, dies als Erweiterungsmethode zu tun:

static public string UpperCaseFirstCharacter(this string text)
{
    if (!string.IsNullOrEmpty(text))
    {
        return string.Format(
            "{0}{1}",
            text.Substring(0, 1).ToUpper(),
            text.Substring(1));
    }

    return text;
}

Kann dann wie folgt aufgerufen werden:

//yields "This is Brian's test.":
"this is Brian's test.".UpperCaseFirstCharacter(); 

Und hier sind einige Unit-Tests dafür:

[Test]
public void UpperCaseFirstCharacter_ZeroLength_ReturnsOriginal()
{
    string orig = "";
    string result = orig.UpperCaseFirstCharacter();

    Assert.AreEqual(orig, result);
}

[Test]
public void UpperCaseFirstCharacter_SingleCharacter_ReturnsCapital()
{
    string orig = "c";
    string result = orig.UpperCaseFirstCharacter();

    Assert.AreEqual("C", result);
}

[Test]
public void UpperCaseFirstCharacter_StandardInput_CapitalizeOnlyFirstLetter()
{
    string orig = "this is Brian's test.";
    string result = orig.UpperCaseFirstCharacter();

    Assert.AreEqual("This is Brian's test.", result);
}

Da ich zufällig auch daran gearbeitet habe und mich nach Ideen umgesehen habe, ist dies die Lösung, zu der ich gekommen bin. Es verwendet LINQ und kann den ersten Buchstaben einer Zeichenfolge groß schreiben, auch wenn das erste Vorkommen kein Buchstabe ist. Hier ist die Erweiterungsmethode, die ich am Ende gemacht habe.

public static string CaptalizeFirstLetter(this string data)
{
    var chars = data.ToCharArray();

    // Find the Index of the first letter
    var charac = data.First(char.IsLetter);
    var i = data.IndexOf(charac);

    // capitalize that letter
    chars[i] = char.ToUpper(chars[i]);

    return new string(chars);
}

Ich bin sicher, es gibt eine Möglichkeit, dies ein wenig zu optimieren oder zu bereinigen.

Ich habe hier etwas gefunden http://www.dotnetperls.com/uppercase-first-letter :

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);
}

vielleicht hilft das!!

Überprüfen Sie, ob die Zeichenfolge nicht null ist, und konvertieren Sie das erste Zeichen in Großbuchstaben und den Rest in Kleinbuchstaben:

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

Dies wird es tun, obwohl es auch sicherstellen wird, dass es keine fehlerhaften Großbuchstaben gibt, die nicht am Anfang des Wortes stehen.

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);
}

Hier scheint es viel Komplexität zu geben, wenn Sie nur Folgendes benötigen:

    /// <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);
    }

Bemerkenswerte Punkte:

1. Es ist eine Erweiterungsmethode.

2. Wenn die Eingabe null, leer oder Leerzeichen ist, wird die Eingabe unverändert zurückgegeben.

3. String.IsNullOrWhiteSpace wurde mit .NET Framework 4 eingeführt. Dies funktioniert nicht mit älteren Frameworks.

string emp="TENDULKAR";
string output;
output=emp.First().ToString().ToUpper() + String.Join("", emp.Skip(1)).ToLower();

Ich wollte eine "MAXIMALE LEISTUNG" -Antwort geben. In meinen Augen erfasst eine Antwort mit "MAXIMAL PERFORMANCE" alle Szenarien und liefert die Antwort auf die Frage, die diese Szenarien berücksichtigt. Also, hier ist meine Antwort. Mit diesen Gründen:

1. IsNullOrWhiteSpace berücksichtigt Zeichenfolgen, die nur Leerzeichen oder null / leer sind.
2. .Trim () entfernt Leerzeichen von der Vorder- und Rückseite der Zeichenfolge.
3. .First () nimmt das erste Zeichen einer ienumerable (oder Zeichenfolge).
4. Wir sollten prüfen, ob es sich um einen Buchstaben handelt, der in Großbuchstaben geschrieben werden kann / sollte.
5. Wir fügen dann den Rest der Zeichenfolge nur hinzu, wenn die Länge angibt, dass wir sollten.
6. Mit .Net Best Practice sollten wir eine Kultur unter System.Globalization.CultureInfo bereitstellen.

7. Wenn Sie sie als optionale Parameter angeben, kann diese Methode vollständig wiederverwendet werden, ohne jedes Mal die ausgewählte Kultur eingeben zu müssen.

   public static string capString(string instring, string culture = "en-US", bool useSystem = false)
   {
       string outstring;
       if (String.IsNullOrWhiteSpace(instring))
       {
           return "";
       }
       instring = instring.Trim();
       char thisletter = instring.First();
       if (!char.IsLetter(thisletter))
       {
           return instring;   
       }
       outstring = thisletter.ToString().ToUpper(new CultureInfo(culture, useSystem));
       if (instring.Length > 1)
       {
           outstring += instring.Substring(1);
       }
       return outstring;
   }

Kürzlich hatte ich eine ähnliche Anforderung und erinnerte mich, dass die LINQ-Funktion Select () einen Index bereitstellt:

string input;
string output;

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

Da ich das sehr oft brauche, habe ich eine Erweiterungsmethode für den String-Typ erstellt:

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));
    }
}

Bitte beachten Sie, dass nur der erste Buchstabe in Großbuchstaben umgewandelt wird - alle verbleibenden Zeichen werden nicht berührt. Wenn die anderen Zeichen in Kleinbuchstaben geschrieben werden müssen, können Sie auch Char.ToLower (currentChar) für Index> 0 oder ToLower () für die gesamte Zeichenfolge aufrufen.

In Bezug auf die Leistung habe ich den Code mit der Lösung von Darren verglichen. Auf meinem Computer ist Darrens Code ungefähr zweimal schneller, was keine Überraschung ist, da er nur den ersten Buchstaben innerhalb eines char-Arrays direkt bearbeitet. Ich schlage vor, Sie nehmen Darrens Code, wenn Sie die schnellste verfügbare Lösung benötigen. Wenn Sie auch andere Zeichenfolgenmanipulationen integrieren möchten, kann es praktisch sein, die Ausdruckskraft einer Lambda-Funktion zu haben, die die Zeichen der Eingabezeichenfolge berührt - Sie können diese Funktion leicht erweitern -, daher lasse ich diese Lösung hier.

Ich denke, die folgende Methode ist die beste Lösung

    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

ref

Da es bei dieser Frage um die Maximierung der Leistung geht, habe ich Darrens Version für die Verwendung von Spans übernommen, wodurch der Müll reduziert und die Geschwindigkeit um etwa 10% verbessert wird.

        /// <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 |

Vollständiger Testcode

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);
        }
    }

}

Bearbeiten: Es gab einen Tippfehler anstelle von s [0], war ein [0] - dies führt dazu, dass der leere Wert a auf den zugewiesenen Bereich a übertragen wird.

Dadurch wird dieser erste Buchstabe und jeder Buchstabe nach einem Leerzeichen großgeschrieben und jeder andere Buchstabe in Kleinbuchstaben geschrieben.

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;
        }
    }
}

Verwenden Sie den folgenden Code:

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

Es scheint, als würde keine der hier angegebenen Lösungen einen Leerraum vor der Zeichenfolge behandeln.

Fügen Sie dies nur als Gedanken hinzu:

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);
}   

Es sollte behandelt werden this won't work on other answers(dieser Satz hat am Anfang ein Leerzeichen), und wenn Sie das Leerzeichen-Trimmen nicht mögen, übergeben Sie einfach einen falseals zweiten Parameter (oder ändern Sie die Standardeinstellung in falseund übergeben trueSie, wenn Sie mit Leerzeichen umgehen möchten).

FluentSharp hat die lowerCaseFirstLetterMethode, die dies tut

https://github.com/o2platform/FluentSharp/blob/700dc35759db8e2164771a71f73a801aa9379074/FluentSharp.CoreLib/ExtensionMethods/System/String_ExtensionMethods.cs#L575

Der einfachste Weg, den ersten Brief zu kapitalisieren, ist:

1- Verwenden von Sytem.Globalization;

  // Creates a TextInfo based on the "en-US" culture.
  TextInfo myTI = new CultureInfo("en-US",false).

  myTI.ToTitleCase(textboxname.Text)

`

Die folgende Funktion ist in jeder Hinsicht korrekt:

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);
}

Das habe ich hier gefunden

Wenn Sie die obige Frage von Carlos erweitern und mehrere Sätze groß schreiben möchten, können Sie diesen Code verwenden:

    /// <summary>
    /// Capitalize first letter of every sentence. 
    /// </summary>
    /// <param name="inputSting"></param>
    /// <returns></returns>
    public string CapitalizeSentences (string inputSting)
    {
        string result = string.Empty;
        if (!string.IsNullOrEmpty(inputSting))
        {
            string[] sentences = inputSting.Split('.');

            foreach (string sentence in sentences)
            {
                result += string.Format ("{0}{1}.", sentence.First().ToString().ToUpper(), sentence.Substring(1)); 
            }
        }

        return result; 
    }

Mögliche Lösung zur Lösung Ihres Problems.

   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();
   }