.NET Framework
strängar

Anmärkningar

public static class StringExtensions
{
    public static IEnumerable<string> EnumerateCharacters(this string s)
    {
        if (s == null)
            return Enumerable.Empty<string>();

        var enumerator = StringInfo.GetTextElementEnumerator(s.Normalize());
        while (enumerator.MoveNext())
            yield return (string)enumerator.Value;
    }
}

Räkna olika karaktärer

Om du behöver räkna distinkta karaktärer då de skäl som anges i Anmärkningar avsnittet kan du inte bara använda Length egendom eftersom det är längden på rad System.Char som inte är tecken men code-enheter (ej Unicode code-poäng inte heller grafem). Om du till exempel bara skriver text.Distinct().Count() får du felaktiga resultat, rätt kod:

int distinctCharactersCount = text.EnumerateCharacters().Count();

Ett steg längre är att räkna förekomster av varje karaktär , om prestanda inte är ett problem kan du helt enkelt göra det så här (i det här exemplet oavsett fall):

var frequencies = text.EnumerateCharacters()
    .GroupBy(x => x, StringComparer.CurrentCultureIgnoreCase)
    .Select(x => new { Character = x.Key, Count = x.Count() };

Räkna tecken

Om du behöver räkna tecken då, av de skäl som förklaras i avsnittet Kommentarer , kan du inte bara använda Längdegenskapen eftersom det är längden på arrayen System.Char som inte är tecken utan kodenheter (inte Unicode-kodpunkter eller grafem). Rätt kod är då:

int length = text.EnumerateCharacters().Count();

En liten optimering kan skriva om förlängningsmetoden EnumerateCharacters() specifikt för detta ändamål:

public static class StringExtensions
{
    public static int CountCharacters(this string text)
    {
        if (String.IsNullOrEmpty(text))
            return 0;

        int count = 0;
        var enumerator = StringInfo.GetTextElementEnumerator(text);
        while (enumerator.MoveNext())
            ++count;

        return count;
    }
}

Räkna förekomster av en karaktär

På grund av de skäl som anges i Anmärkningar avsnittet kan du inte bara göra det (om du inte vill räkna förekomster av en specifik kod-enhet):

int count = text.Count(x => x == ch);

Du behöver en mer komplex funktion:

public static int CountOccurrencesOf(this string text, string character)
{
    return text.EnumerateCharacters()
        .Count(x => String.Equals(x, character, StringComparer.CurrentCulture));
}

Observera att strängjämförelse (i motsats till teckenjämförelse som är kulturinvariant) alltid måste utföras enligt regler för en specifik kultur.

Dela strängen i block med fast längd

Vi kan inte bryta en sträng i godtyckliga punkter (eftersom ett System.Char kan inte vara giltigt enbart eftersom det är en kombinerande karaktär eller del av en surrogat) då måste kod ta hänsyn till det (notera att med längd menar jag antalet grafema inte antal kodenheter ):

public static IEnumerable<string> Split(this string value, int desiredLength)
{
    var characters = StringInfo.GetTextElementEnumerator(value);
    while (characters.MoveNext())
        yield return String.Concat(Take(characters, desiredLength));
}

private static IEnumerable<string> Take(TextElementEnumerator enumerator, int count)
{
    for (int i = 0; i < count; ++i)
    {
        yield return (string)enumerator.Current;

        if (!enumerator.MoveNext())
            yield break;
    }
}

Konvertera sträng till / från en annan kodning

.NET-strängar innehåller System.Char (UTF-16 kodenheter). Om du vill spara (eller hantera) text med en annan kodning måste du arbeta med en rad System.Byte .

Omvandlingar utförs av klasser härrörande från System.Text.Encoder och System.Text.Decoder som tillsammans kan konvertera till / från en annan kodning (från en byte X- kodad matrisbyte byte[] till en UTF-16-kodad System.String och vice -versa).

Eftersom kodaren / avkodaren vanligtvis fungerar mycket nära varandra grupperas de i en klass härrörande från System.Text.Encoding , härledda klasser erbjuder konverteringar till / från populära kodningar (UTF-8, UTF-16 och så vidare).

Exempel:

Konvertera en sträng till UTF-8

byte[] data = Encoding.UTF8.GetBytes("This is my text");

Konvertera UTF-8-data till en sträng

var text = Encoding.UTF8.GetString(data);

Ändra kodning av en befintlig textfil

Den här koden läser innehållet i en UTF-8-kodad textfil och sparar den tillbaka kodad som UTF-16. Observera att den här koden inte är optimal om filen är stor eftersom den kommer att läsa allt innehåll i minnet:

var content = File.ReadAllText(path, Encoding.UTF8);
File.WriteAllText(content, Encoding.UTF16);

Object.ToString () virtuell metod

Allt i NET är ett objekt, därav varje typ har ToString() metod som definieras i Object som kan åsidosättas. Standardimplementering av denna metod returnerar bara namnet på typen:

public class Foo
{
}

var foo = new Foo();
Console.WriteLine(foo); // outputs Foo

ToString() kallas implicit när man koncentrerar värdet med en sträng:

public class Foo
{
    public override string ToString()
    {
        return "I am Foo";
    }
}

var foo = new Foo();
Console.WriteLine("I am bar and "+foo);// outputs I am bar and I am Foo

Resultatet av denna metod används också i stor utsträckning av felsökningsverktyg. Om du av någon anledning inte vill åsidosätta den här metoden utan vill anpassa hur felsökare visar värdet på din typ använder du DebuggerDisplay Attribute ( MSDN ):

// [DebuggerDisplay("Person = FN {FirstName}, LN {LastName}")]
[DebuggerDisplay("Person = FN {"+nameof(Person.FirstName)+"}, LN {"+nameof(Person.LastName)+"}")]
public class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set;}
    // ...
}

Strängarnas oföränderlighet

Strängar är oföränderliga. Du kan bara inte ändra befintlig sträng. Varje operation på strängen raderar en ny instans av strängen med nytt värde. Det betyder att om du behöver ersätta ett enda tecken i en mycket lång sträng, kommer minnet att allokeras för ett nytt värde.

string veryLongString = ...
// memory is allocated
string newString = veryLongString.Remove(0,1); // removes first character of the string.

Om du behöver utföra många operationer med strängvärde använder du StringBuilder klassen som är utformad för effektiv stränghantering:

var sb = new StringBuilder(someInitialString);
foreach(var str in manyManyStrings)
{
    sb.Append(str);
} 
var finalString = sb.ToString();

Omp Jämföra strängar

Trots String är en referenstyp == operatör jämför jämförvärden snarare än referenser.

Som ni kanske vet är string bara en rad tecken. Men om du tror att strängar jämställdhetskontroll och jämförelse görs karaktär för karaktär, tar du fel. Denna operation är kulturspecifik (se anmärkningar nedan): vissa karaktärsekvenser kan behandlas som lika beroende på kulturen .

Tänka två gånger innan kortslutning kontroll jämlikhet genom att jämföra Length egenskaper av två strängar!

Använd överbelastning av String.Equals metoden som accepterar ytterligare StringComparison uppräkningsvärde om du behöver ändra standardbeteendet.