Die Anleitung zu C# String und StringBuilder

View more categories:

1- Das Diagramm der Inheritance

Beim Umgang mit Textdaten bietet CSharp Ihnen 2 Klasse  String und  StringBuilder. Beim Umgang mit der großen Daten sollen Sie StringBuilder zur schnellsten Leistung erreichen. Auf der Natur haben die 2 Klasse viele Gleichheit.
  • String ist immutable,. Der Begriff wird detailiert im Dokument erwähnt und darf keine untergeordneten Klasse haben.
  • StringBuilder ist mutable

2- Der Begriff von mutable & immutable

Sehen Sie ein Beispiel
MutableClassExample.cs
namespace StringTutorial
{
    // Das ist ein Klasse mit einen Feld: 'Value'.
    // Wenn Sie ein Objekt der Klasse haben, 
    // können Sie die neue Wert für den Feld 'Value' 
    // durch die Methode SetNewValue(int) anweisen.
    // Deshalb ist das eine veränderbare (mutable) Klasse.
    class MutableClassExample
    {
        private int Value;

        public MutableClassExample(int value)
        {
            this.Value = value;
        }

        public void SetNewValue(int newValue)
        {
            this.Value = newValue;
        }
    }

}
ImmutableClassExample.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace StringTutorial
{
    // Das ist eine Klasse mit 2 Felder (field): 'Value' & 'Name'.
    // Wenn Sie ein Objekt der Klasse haben, 
    // können Sie die neue Wert für 'Value','Name' vom außen nicht anweisen.
    // D.h ist die Klasse unveränderbar (immutable)
    class ImmutableClassExample
    {
        private int Value;
        private String Name;

        public ImmutableClassExample(String name, int value)
        {
            this.Value = value;
            this.Name = name;
        }

        public String GetName()
        {
            return Name;
        }

        public int GetValue()
        {
            return Value;
        }
    }
}
String ist eine immutable Klasse.  String hat viele Attribute , wie Length,... Aber die Werte sind nicht veränderbar

3- String und string

Im C# werden String und  string parallel benutzt. In der Praxis gibt es keinen Unterschied zwischen ihnen.   string kann als einen Alias (alias) für  System.String gesehen werden (Der volle Name einschließend namespace der Klasse String).

Die folgende Tabelle bezeichnet die volle Liste des Alias für die üblichen Klassen
Alias Class
object System.Object
string System.String
bool System.Boolean
byte System.Byte
sbyte System.SByte
short System.Int16
ushort System.UInt16
int System.Int32
uint System.UInt32
long System.Int64
ulong System.UInt64
float System.Single
double System.Double
decimal System.Decimal
char System.Char

4- String

String ist eine wichtige Klasse im CSharp. Und irgendwer, der mit CSharp beginnt, benutzt den Befehl  Console.WriteLine() um einen String auf dem Bildschirm Console zu drücken. Viele Leuten kennen nicht, String ist immutabel und sealed (versiegelt, darf keine untergeordneten Klassen haben). Alle Änderungen auf String erstellen ein anderes String Objekt
** String **
[SerializableAttribute]
[ComVisibleAttribute(true)]
public sealed class String : IComparable, ICloneable, IConvertible,
    IEnumerable, IComparable<string>, IEnumerable<char>, IEquatable<string>

4.1- Die Methode vom String

Sie können die MEthode von String bei ... nachschlagen
Unten ist die Liste der üblichen Methode vom  String.
Some String methods
public bool EndsWith(string value)

public bool EndsWith(string value, StringComparison comparisonType)

public bool Equals(string value)

public int IndexOf(char value)

public int IndexOf(char value, int startIndex)

public int IndexOf(string value, int startIndex, int count)

public int IndexOf(string value, int startIndex, StringComparison comparisonType)

public int IndexOf(string value, StringComparison comparisonType)

public string Insert(int startIndex, string value)

public int LastIndexOf(char value)

public int LastIndexOf(char value, int startIndex)

public int LastIndexOf(char value, int startIndex, int count)

public int LastIndexOf(string value)

public int LastIndexOf(string value, int startIndex)

public int LastIndexOf(string value, int startIndex, int count)

public int LastIndexOf(string value, int startIndex, int count, StringComparison comparisonType)

public int LastIndexOf(string value, int startIndex, StringComparison comparisonType)

public int LastIndexOf(string value, StringComparison comparisonType)

public int LastIndexOfAny(char[] anyOf)

public int LastIndexOfAny(char[] anyOf, int startIndex)

public int LastIndexOfAny(char[] anyOf, int startIndex, int count)

public int IndexOf(string value, int startIndex, int count, StringComparison comparisonType)

public string Replace(char oldChar, char newChar)

public string Replace(string oldValue, string newValue)

public string[] Split(params char[] separator)

public string[] Split(char[] separator, int count)

public string[] Split(char[] separator, int count, StringSplitOptions options)

public string[] Split(char[] separator, StringSplitOptions options)

public string[] Split(string[] separator, StringSplitOptions options)

public bool StartsWith(string value)

public bool StartsWith(string value, bool ignoreCase, CultureInfo culture)

public bool StartsWith(string value, StringComparison comparisonType)

public string Substring(int startIndex)

public string Substring(int startIndex, int length)

public char[] ToCharArray()

public char[] ToCharArray(int startIndex, int length)

public string ToLower()

public string ToLower(CultureInfo culture)

public string ToLowerInvariant()

public override string ToString()

public string ToUpper()

public string ToUpper(CultureInfo culture)

public string ToUpperInvariant()

public string Trim()

public string Trim(params char[] trimChars)

public string TrimEnd(params char[] trimChars)

public string TrimStart(params char[] trimChars)

 

4.1.1- Length

Length ist eine Attribute vom string, Er gibt die Zeichen Unicode für String rück
LengthDemo.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace StringTutorial
{
    class LengthDemo
    {
        public static void Main(string[] args)
        {
            String str = "This is text";

            // Length ist ein Property (das Attribute) vom string.
            // Es ist die Länge des String  (die Anzahl des String).
            int len = str.Length;

            Console.WriteLine("String Length is : " + len);

            Console.Read();
        }
    }
}
Das Ergebis der Durchführung des Beispiel

4.1.2- Concat(...)

Concat ist eine static Methode um viele string mit einander zu binden (concatenate) und gibt einen neuen String rück.
ConcatDemo.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace StringTutorial
{
    class ConcatDemo
    {
        public static void Main(string[] args)
        {
            string s1 = "One";
            string s2 = "Two";
            string s3 = "Three";

            // Wie  s1 + s2;
            string s = String.Concat(s1, s2); 

            Console.WriteLine("Concat s1, s2 : " + s);

            // Wie s1 + s2 + s3;
            s = String.Concat(s1, s2, s3);

            Console.WriteLine("Concat s1, s2, s3 : " + s);

            Console.Read();
        }
    }


}
Das Ergebnis der Beispielsdurchführung

4.1.3- IndexOf(..)

IndexOf(..) ist eine Methode, die den Index zurückgibt, der zum ersten Mal ein bestimmtes Zeichen oder ein bestimmtes Sub-String des aktuellen String erscheint. Es gibt 8 IndexOf Methode aber sie unterscheiden sich die Parameter. Der Index beginnt mit 0 (nicht 1).
IndexOfDemo.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace StringTutorial
{
    class IndexOfDemo
    {
        public static void Main(string[] args)
        {
            String str = "This is text";

            // Die Index von dem ersten 'i' Zeichen finden.
            int idx = str.IndexOf('i'); // ==> 2
            Console.WriteLine("- IndexOf('i') = " + idx);

            // Die Index von dem ersten 'i' Zeichen finden, 
            // ab die vierte Index zum Ende des String.
            idx = str.IndexOf('i', 4); // ==> 5
            Console.WriteLine("- indexOf('i',4) = " + idx);

            // Die Index von dem ersten "te" Substring finden
            idx = str.IndexOf("te"); // ==> 8
            Console.WriteLine("- IndexOf('te') = " + idx);

            Console.Read();
        }
    }

}
Das Ergebnis der Beispieldurchführung

4.1.4- Substring(..)

SubstringDemo.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace StringTutorial
{
    class SubstringDemo
    {
        public static void Main(string[] args)
        {
            string str = "This is text";

            // Das Sub-String ab die dritten Index zum Ende des String zurückgeben.
            string substr = str.Substring(3);

            Console.WriteLine("- Substring(3)=" + substr);

            // Das Sub-String ab die zweite Index und die Länge von 7 zurückgeben
            substr = str.Substring(2, 7);

            Console.WriteLine("- Substring(2, 7) =" + substr);


            Console.Read();
        }
    }

}
Das Ergebnis der Beispieldurchführung

4.1.5- Replace(...)

Replace(..): der Ersatz eines untergeordneten String durch einen anderen untergeordneten String in der aktuellen String und einen neuen String rückgeben
ReplaceDemo.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace StringTutorial
{
    class ReplaceDemo
    {
        public static void Main(string[] args)
        {
            String str = "This is text";

            // Die 'i' Zeichen durch das Zeichen 'x' ersetzen.
            String s2 = str.Replace('i', 'x');

            Console.WriteLine("- s2=" + s2);// ==> "Thxs xs text".

            // Alle Sub-String "is" durch "abc" ersetzen.
            String s3 = str.Replace("is", "abc");

            Console.WriteLine("- s3=" + s3);// ==> "Thabc abc text".

            // Das "is" Sub-String zum ersten Auftreten durch "abc" ersetzen.
            String s4 = ReplaceFirst(str, "is", "abc");

            Console.WriteLine("- s4=" + s4);// ==> "Thabc is text".

            Console.Read();
        }

        // Das Sub-String zum ersten Auftreten durch ein neues Sub-String ersetzen
        static string ReplaceFirst(string text, string search, string replace)
        {
            int pos = text.IndexOf(search);
            if (pos < 0)
            {
                return text;
            }
            return text.Substring(0, pos) + replace + text.Substring(pos + search.Length);
        }
    }

}
Das Ergebnis der Beispieldurchführung

4.1.6- die anderen Beispiele

StringOtherDemo.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace StringTutorial
{
    class StringOtherDemo
    {
        public static void Main(string[] args)
        {
            String str = "This is text";

            Console.WriteLine("- str=" + str);

            // Das Kleine-Buchstabe String zurückgeben (lower case string).
            String s2 = str.ToLower();

            Console.WriteLine("- s2=" + s2);

            // Das Große-Buchstabe String zurückgeben (upper case string).
            String s3 = str.ToUpper();

            Console.WriteLine("- s3=" + s3);

            // Prüfen, ob das String mit dem Sub-String "This" beginnt oder nicht.
            bool swith = str.StartsWith("This");

            Console.WriteLine("- 'str' startsWith This ? " + swith);

            // Ein String mit dem leeren Zeichen vorne und hinter.
            // \t ist das TAB Zeichen.
            // \n ist das New-Line-zeichen.
            str = " \t CSharp is hot!  \t \n ";

            Console.WriteLine("- str=" + str);

            // Eine Kopue des String zurückgeben, 
            // das leere Zeichen am vorne und Ende des String entfernen
            String s4 = str.Trim();

            Console.WriteLine("- s4=" + s4);

            Console.Read();
        }
    }

}
Das Ergebnis der Beispieldurchführung

5- StringBuilder

Im C# ist das Ergebnis jeder Veränderung eines  String die Erstellung eines neuen String . Inszwischen enthaltet  StringBuilder einen Zeichenarray. Und dieser Array wird automatisch durch einen großen Array wenn notwendig ersetzt, und dann die Zeichen vom alten Array kopieren. Wenn Sie die String vielen Mal verbinden müssen, sollen Sie StringBuilder benutzen. Das macht die Leistung des Programms besser. Aber wenn Sie nur einigen String verbinden, ist es nicht notwendig, den  StringBuilder zu benutzen
StringBuilderDemo.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace StringTutorial
{
    class StringBuilderDemo
    {
        public static void Main(string[] args)
        {

            // Ein Objekt StringBuilder mit der Kapazität von 10 Zeichen erstellen
            StringBuilder sb = new StringBuilder(10);

            // Ein Sub-String einfügen.
            sb.Append("Hello...");
            Console.WriteLine("- sb after appends a string: " + sb);

            // Ein Zeichen einfügen.
            char c = '!';
            sb.Append(c);
            Console.WriteLine("- sb after appending a char: " + sb);

            // Ein String in der Index 5 einfügen.
            sb.Insert(8, " CSharp");
            Console.WriteLine("- sb after insert string: " + sb);

            // Ein Sub-String bei der Index 5 mit 3 Zeichen löschen.
            sb.Remove(5, 3);

            Console.WriteLine("- sb after remove: " + sb);

            // string im StringBuilder entnehmen.
            String s = sb.ToString();

            Console.WriteLine("- String of sb: " + s);

            Console.Read();
        }
    }

}
Das Ergebnis der Beispieldurchführung

View more categories: