# Einen String formatieren
Verwenden Sie den String.Format() Methode zum Ersetzen eines oder mehrerer Elemente in der Zeichenfolge durch die Zeichenfolgendarstellung eines angegebenen Objekts:
String.Format("Hello {0} Foo {1}", "World", "Bar") //Hello World Foo Bar
# Einen String auf eine feste Länge auffüllen
string s = "Foo";
string paddedLeft = s.PadLeft(5); // paddedLeft = " Foo" (pads with spaces by default)
string paddedRight = s.PadRight(6, '+'); // paddedRight = "Foo+++"
string noPadded = s.PadLeft(2); // noPadded = "Foo" (original string is never shortened)
# Einen String korrekt umkehren
Meistens, wenn Leute einen String umkehren müssen, machen sie das mehr oder weniger so:
char[] a = s.ToCharArray();
System.Array.Reverse(a);
string r = new string(a);
Was diese Leute jedoch nicht erkennen, ist, dass dies eigentlich falsch ist.
Und ich meine nicht wegen der fehlenden NULL-Prüfung.
Es ist eigentlich falsch, weil ein Glyph/GraphemeCluster aus mehreren Codepoints (auch bekannt als Zeichen) bestehen kann.
Um zu verstehen, warum das so ist, müssen wir uns zunächst darüber im Klaren sein, was der Begriff "Charakter" eigentlich bedeutet.
Referenz:
Charakter ist ein überladener Begriff, der viele Dinge bedeuten kann.
Ein Codepunkt ist die atomare Informationseinheit. Text ist eine Folge von Codepunkten. Jeder Codepunkt ist eine Zahl, die durch den Unicode-Standard eine Bedeutung erhält.
Ein Graphem ist eine Folge von einem oder mehreren Codepunkten, die als einzelne grafische Einheit angezeigt werden, die ein Leser als einzelnes Element des Schriftsystems erkennt. Zum Beispiel sind sowohl a als auch ä Grapheme, aber sie können aus mehreren Codepunkten bestehen (z. B. kann ä zwei Codepunkte sein, einer für das Basiszeichen a, gefolgt von einem für die Diarese; aber es gibt auch einen alternativen, älteren, einzelnen Codepunkt, der dieses Graphem darstellt ). Einige Codepunkte sind niemals Teil eines Graphems (z. B. der Non-Joiner mit Nullbreite oder Richtungsüberschreibungen).
Eine Glyphe ist ein Bild, das normalerweise in einer Schriftart (einer Sammlung von Glyphen) gespeichert ist und zur Darstellung von Graphemen oder Teilen davon verwendet wird. Schriften können mehrere Glyphen zu einer einzigen Darstellung zusammensetzen, wenn beispielsweise das obige ä ein einzelner Codepunkt ist, kann eine Schrift wählen, dieses als zwei getrennte, räumlich überlagerte Glyphen wiederzugeben. Für OTF enthalten die GSUB- und GPOS-Tabellen der Schriftart Ersetzungs- und Positionierungsinformationen, damit dies funktioniert. Eine Schriftart kann auch mehrere alternative Glyphen für dasselbe Graphem enthalten.
In C# ist ein Zeichen also tatsächlich ein CodePoint.
Das heißt, wenn Sie einfach einen gültigen String wie Les Misérables umkehren , die so aussehen kann
string s = "Les Mise\u0301rables";
als Folge von Zeichen erhalten Sie:
selbaŕesiM seL
Wie Sie sehen können, liegt der Akzent auf dem R-Zeichen anstelle des e-Zeichens.
Obwohl string.reverse.reverse den ursprünglichen String liefert, wenn Sie beide Male das char-Array umkehren, ist diese Art der Umkehrung definitiv NICHT die Umkehrung des ursprünglichen Strings.
Sie müssen nur jeden GraphemeCluster umkehren.
Wenn Sie es also richtig gemacht haben, kehren Sie einen String wie diesen um:
private static System.Collections.Generic.List<string> GraphemeClusters(string s)
{
System.Collections.Generic.List<string> ls = new System.Collections.Generic.List<string>();
System.Globalization.TextElementEnumerator enumerator = System.Globalization.StringInfo.GetTextElementEnumerator(s);
while (enumerator.MoveNext())
{
ls.Add((string)enumerator.Current);
}
return ls;
}
// this
private static string ReverseGraphemeClusters(string s)
{
if(string.IsNullOrEmpty(s) || s.Length == 1)
return s;
System.Collections.Generic.List<string> ls = GraphemeClusters(s);
ls.Reverse();
return string.Join("", ls.ToArray());
}
public static void TestMe()
{
string s = "Les Mise\u0301rables";
// s = "noël";
string r = ReverseGraphemeClusters(s);
// This would be wrong:
// char[] a = s.ToCharArray();
// System.Array.Reverse(a);
// string r = new string(a);
System.Console.WriteLine(r);
}
Und - oh Freude - Sie werden feststellen, wenn Sie es so richtig machen, funktioniert es auch für asiatische/südasiatische/ostasiatische Sprachen (und Französisch/Schwedisch/Norwegisch usw.)...
# Hole x Zeichen von der rechten Seite eines Strings
Visual Basic verfügt über Left-, Right- und Mid-Funktionen, die Zeichen von Links, Rechts und Mitte einer Zeichenfolge zurückgeben. Diese Methoden sind in C# nicht vorhanden, können aber mit Substring() implementiert werden . Sie können als Erweiterungsmethoden wie folgt implementiert werden:
public static class StringExtensions
{
/// <summary>
/// VB Left function
/// </summary>
/// <param name="stringparam"></param>
/// <param name="numchars"></param>
/// <returns>Left-most numchars characters</returns>
public static string Left( this string stringparam, int numchars )
{
// Handle possible Null or numeric stringparam being passed
stringparam += string.Empty;
// Handle possible negative numchars being passed
numchars = Math.Abs( numchars );
// Validate numchars parameter
if (numchars > stringparam.Length)
numchars = stringparam.Length;
return stringparam.Substring( 0, numchars );
}
/// <summary>
/// VB Right function
/// </summary>
/// <param name="stringparam"></param>
/// <param name="numchars"></param>
/// <returns>Right-most numchars characters</returns>
public static string Right( this string stringparam, int numchars )
{
// Handle possible Null or numeric stringparam being passed
stringparam += string.Empty;
// Handle possible negative numchars being passed
numchars = Math.Abs( numchars );
// Validate numchars parameter
if (numchars > stringparam.Length)
numchars = stringparam.Length;
return stringparam.Substring( stringparam.Length - numchars );
}
/// <summary>
/// VB Mid function - to end of string
/// </summary>
/// <param name="stringparam"></param>
/// <param name="startIndex">VB-Style startindex, 1st char startindex = 1</param>
/// <returns>Balance of string beginning at startindex character</returns>
public static string Mid( this string stringparam, int startindex )
{
// Handle possible Null or numeric stringparam being passed
stringparam += string.Empty;
// Handle possible negative startindex being passed
startindex = Math.Abs( startindex );
// Validate numchars parameter
if (startindex > stringparam.Length)
startindex = stringparam.Length;
// C# strings are zero-based, convert passed startindex
return stringparam.Substring( startindex - 1 );
}
/// <summary>
/// VB Mid function - for number of characters
/// </summary>
/// <param name="stringparam"></param>
/// <param name="startIndex">VB-Style startindex, 1st char startindex = 1</param>
/// <param name="numchars">number of characters to return</param>
/// <returns>Balance of string beginning at startindex character</returns>
public static string Mid( this string stringparam, int startindex, int numchars)
{
// Handle possible Null or numeric stringparam being passed
stringparam += string.Empty;
// Handle possible negative startindex being passed
startindex = Math.Abs( startindex );
// Handle possible negative numchars being passed
numchars = Math.Abs( numchars );
// Validate numchars parameter
if (startindex > stringparam.Length)
startindex = stringparam.Length;
// C# strings are zero-based, convert passed startindex
return stringparam.Substring( startindex - 1, numchars );
}
}
Diese Erweiterungsmethode kann wie folgt verwendet werden:
string myLongString = "Hello World!";
string myShortString = myLongString.Right(6); // "World!"
string myLeftString = myLongString.Left(5); // "Hello"
string myMidString1 = myLongString.Left(4); // "lo World"
string myMidString2 = myLongString.Left(2,3); // "ell"
# Prüfung auf leeren String mit String.IsNullOrEmpty() und String.IsNullOrWhiteSpace()
string nullString = null;
string emptyString = "";
string whitespaceString = " ";
string tabString = "\t";
string newlineString = "\n";
string nonEmptyString = "abc123";
bool result;
result = String.IsNullOrEmpty(nullString); // true
result = String.IsNullOrEmpty(emptyString); // true
result = String.IsNullOrEmpty(whitespaceString); // false
result = String.IsNullOrEmpty(tabString); // false
result = String.IsNullOrEmpty(newlineString); // false
result = String.IsNullOrEmpty(nonEmptyString); // false
result = String.IsNullOrWhiteSpace(nullString); // true
result = String.IsNullOrWhiteSpace(emptyString); // true
result = String.IsNullOrWhiteSpace(tabString); // true
result = String.IsNullOrWhiteSpace(newlineString); // true
result = String.IsNullOrWhiteSpace(whitespaceString); // true
result = String.IsNullOrWhiteSpace(nonEmptyString); // false
# Trimmen unerwünschter Zeichen am Anfang und/oder Ende von Strings.
# String.Trim()
string x = " Hello World! ";
string y = x.Trim(); // "Hello World!"
string q = "{(Hi!*";
string r = q.Trim( '(', '*', '{' ); // "Hi!"
# String.TrimStart() und String.TrimEnd()
string q = "{(Hi*";
string r = q.TrimStart( '{' ); // "(Hi*"
string s = q.TrimEnd( '*' ); // "{(Hi"
# Konstruiere einen String aus Array
Die String.Join -Methode hilft uns, eine Zeichenfolge aus einem Array/einer Liste von Zeichen oder einer Zeichenfolge zu erstellen. Diese Methode akzeptiert zwei Parameter. Das erste ist das Trennzeichen oder Trennzeichen, das Ihnen hilft, jedes Element im Array zu trennen. Und der zweite Parameter ist das Array selbst.
String von char array :
string delimiter=",";
char[] charArray = new[] { 'a', 'b', 'c' };
string inputString = String.Join(delimiter, charArray);
Ausgabe :a,b,c wenn wir den delimiter ändern als "" dann wird die Ausgabe zu abc .
String von List of char :
string delimiter = "|";
List<char> charList = new List<char>() { 'a', 'b', 'c' };
string inputString = String.Join(delimiter, charList);
Ausgabe :a|b|c
String von List of Strings :
string delimiter = " ";
List<string> stringList = new List<string>() { "Ram", "is", "a","boy" };
string inputString = String.Join(delimiter, stringList);
Ausgabe :Ram is a boy
String von array of strings :
string delimiter = "_";
string[] stringArray = new [] { "Ram", "is", "a","boy" };
string inputString = String.Join(delimiter, stringArray);
Ausgabe :Ram_is_a_boy
# Formatierung mit ToString
Normalerweise verwenden wir String.Format Methode für Formatierungszwecke, die.ToString wird normalerweise zum Konvertieren anderer Typen in Zeichenfolgen verwendet. Wir können das Format zusammen mit der ToString-Methode während der Konvertierung angeben, sodass wir eine zusätzliche Formatierung vermeiden können. Lassen Sie mich erklären, wie es mit verschiedenen Typen funktioniert;
Integer zu formatierter Zeichenfolge:
int intValue = 10;
string zeroPaddedInteger = intValue.ToString("000"); // Output will be "010"
string customFormat = intValue.ToString("Input value is 0"); // output will be "Input value is 10"
Double to formated string:
double doubleValue = 10.456;
string roundedDouble = doubleValue.ToString("0.00"); // output 10.46
string integerPart = doubleValue.ToString("00"); // output 10
string customFormat = doubleValue.ToString("Input value is 0.0"); // Input value is 10.5
DateTime mit ToString formatieren
DateTime currentDate = DateTime.Now; // {7/21/2016 7:23:15 PM}
string dateTimeString = currentDate.ToString("dd-MM-yyyy HH:mm:ss"); // "21-07-2016 19:23:15"
string dateOnlyString = currentDate.ToString("dd-MM-yyyy"); // "21-07-2016"
string dateWithMonthInWords = currentDate.ToString("dd-MMMM-yyyy HH:mm:ss"); // "21-July-2016 19:23:15"
# Dezimalzahl in Binär-, Oktal- und Hexadezimalformat konvertieren
Int32 Number = 15;
Console.WriteLine(Convert.ToString(Number, 2)); //OUTPUT : 1111
int Number = 15;
Console.WriteLine(Convert.ToString(Number, 8)); //OUTPUT : 17
var Number = 15;
Console.WriteLine(Convert.ToString(Number, 16)); //OUTPUT : f
# Einen String nach einem bestimmten Zeichen aufteilen
string helloWorld = "hello world, how is it going?";
string[] parts1 = helloWorld.Split(',');
//parts1: ["hello world", " how is it going?"]
string[] parts2 = helloWorld.Split(' ');
//parts2: ["hello", "world,", "how", "is", "it", "going?"]
# Abrufen von Teilstrings eines gegebenen Strings
string helloWorld = "Hello World!";
string world = helloWorld.Substring(6); //world = "World!"
string hello = helloWorld.Substring(0,5); // hello = "Hello"
Substring gibt die Zeichenfolge ab einem bestimmten Index oder zwischen zwei Indizes (beide einschließlich) zurück.
# Bestimme, ob ein String mit einer gegebenen Sequenz beginnt
string HelloWorld = "Hello World";
HelloWorld.StartsWith("Hello"); // true
HelloWorld.StartsWith("Foo"); // false
Einen String innerhalb eines Strings finden
Mit System.String.Contains Sie können herausfinden, ob eine bestimmte Zeichenfolge in einer Zeichenfolge vorhanden ist. Die Methode gibt einen booleschen Wert zurück, wahr, wenn der String existiert, sonst falsch.
string s = "Hello World";
bool stringExists = s.Contains("ello"); //stringExists =true as the string contains the substring
# Verbinden eines Arrays von Strings zu einem neuen
var parts = new[] { "Foo", "Bar", "Fizz", "Buzz"};
var joined = string.Join(", ", parts);
//joined = "Foo, Bar, Fizz, Buzz"
# Ein Zeichen an einem bestimmten Index abrufen und die Zeichenfolge aufzählen
Sie können den Substring verwenden Methode, um eine beliebige Anzahl von Zeichen aus einer Zeichenfolge an einer bestimmten Stelle abzurufen. Wenn Sie jedoch nur ein einzelnes Zeichen möchten, können Sie den String-Indexer verwenden, um ein einzelnes Zeichen an einem beliebigen Index zu erhalten, wie Sie es mit einem Array tun:
string s = "hello";
char c = s[1]; //Returns 'e'
Beachten Sie, dass der Rückgabetyp char ist , im Gegensatz zu Substring Methode, die ein string zurückgibt Typ.
Sie können auch den Indexer verwenden, um die Zeichen der Zeichenfolge zu durchlaufen:
string s = "hello";
foreach (char c in s)
Console.WriteLine(c);
/********* This will print each character on a new line:
h
e
l
l
o
**********/
# Einen String durch einen anderen String teilen
string str = "this--is--a--complete--sentence";
string[] tokens = str.Split(new[] { "--" }, StringSplitOptions.None);
Ergebnis:
[ "dies", "ist", "ein", "vollständig", "Satz" ]
# Ersetzen einer Zeichenfolge innerhalb einer Zeichenfolge
Verwenden Sie den System.String.Replace Methode können Sie einen Teil einer Zeichenfolge durch eine andere Zeichenfolge ersetzen.
string s = "Hello World";
s = s.Replace("World", "Universe"); // s = "Hello Universe"
Alle Vorkommen der Suchzeichenfolge werden ersetzt.
Diese Methode kann auch verwendet werden, um einen Teil einer Zeichenfolge zu entfernen, indem der String.Empty verwendet wird Feld:
string s = "Hello World";
s = s.Replace("ell", String.Empty); // s = "Ho World"
# Ändern der Groß-/Kleinschreibung von Zeichen innerhalb eines Strings
Der System.String -Klasse unterstützt eine Reihe von Methoden zum Konvertieren zwischen Groß- und Kleinbuchstaben in einem String.
-
System.String.ToLowerInvariantwird verwendet, um ein in Kleinbuchstaben konvertiertes String-Objekt zurückzugeben. -
System.String.ToUpperInvariantwird verwendet, um ein in Großbuchstaben konvertiertes String-Objekt zurückzugeben.
Hinweis: Der Grund für die Verwendung der Invariante Versionen dieser Methoden soll die Erzeugung unerwarteter kulturspezifischer Buchstaben verhindern. Dies wird hier im Detail erklärt .
Beispiel:
string s = "My String";
s = s.ToLowerInvariant(); // "my string"
s = s.ToUpperInvariant(); // "MY STRING"
Beachten Sie, dass Sie können Wählen Sie eine bestimmte Kultur aus beim Konvertieren in Klein- und Großbuchstaben, indem die Methoden String.ToLower(CultureInfo) und String.ToUpper(CultureInfo) entsprechend verwendet werden.
# Verkettet ein Array von Strings zu einem einzigen String
Der System.String.Join -Methode ermöglicht es, alle Elemente in einem String-Array zu verketten, wobei zwischen jedem Element ein bestimmtes Trennzeichen verwendet wird:
string[] words = {"One", "Two", "Three", "Four"};
string singleString = String.Join(",", words); // singleString = "One,Two,Three,Four"
# Zeichenfolgenverkettung
Die Zeichenfolgenverkettung kann mit System.String.Concat erfolgen Methode oder (viel einfacher) mit + Betreiber:
string first = "Hello ";
string second = "World";
string concat = first + second; // concat = "Hello World"
concat = String.Concat(first, second); // concat = "Hello World"
In C# 6 geht das wie folgt:
string concat = $"{first},{second}";