.NET Framework
strings

Opmerkingen

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

Tel afzonderlijke karakters

Als u afzonderlijke tekens moet tellen, kunt u om de redenen die in het gedeelte Opmerkingen worden uitgelegd, niet eenvoudigweg de eigenschap Length gebruiken omdat dit de lengte is van de array van System.Char die geen tekens zijn maar code-eenheden (geen Unicode-codepunten) noch grafemen). Als u bijvoorbeeld gewoon tekst schrijft.Distinct text.Distinct().Count() krijgt u onjuiste resultaten, juiste code:

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

Een stap verder is het tellen van het aantal keren dat elk personage voorkomt , als prestaties geen probleem zijn, kunt u het gewoon zo doen (in dit voorbeeld ongeacht het geval):

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

Tekens tellen

Als u tekens moet tellen, kunt u om de redenen die worden uitgelegd in het gedeelte Opmerkingen niet eenvoudigweg de eigenschap Lengte gebruiken, omdat dit de lengte is van de array van System.Char die geen tekens zijn, maar code-eenheden (geen Unicode-codepunten of fonemen). De juiste code is dan:

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

Een kleine optimalisatie kan de uitbreidingsmethode EnumerateCharacters() specifiek voor dit doel herschrijven:

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

Tel exemplaren van een personage

Vanwege de redenen die in de sectie Opmerkingen worden uitgelegd, kunt u dit niet eenvoudigweg doen (tenzij u exemplaren van een specifieke code-eenheid wilt tellen):

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

U hebt een complexere functie nodig:

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

Merk op dat stringvergelijking (in tegenstelling tot karaktervergelijking die cultuurinvariant is) altijd moet worden uitgevoerd volgens regels voor een specifieke cultuur.

Splitstring in blokken met een vaste lengte

We kunnen een string niet in willekeurige punten splitsen (omdat een System.Char mogelijk niet alleen geldig is omdat het een combinerend karakter of een deel van een surrogaat is), dan moet de code daar rekening mee houden (merk op dat ik met lengte het aantal grafemen bedoel, niet de aantal code-eenheden ):

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

Converteer string naar / van een andere codering

.NET-strings bevatten System.Char (UTF-16 code-eenheden). Als u tekst met een andere codering wilt opslaan (of beheren), moet u met een reeks System.Byte .

Conversies worden uitgevoerd door klassen afgeleid van System.Text.Encoder en System.Text.Decoder die samen kunnen converteren naar / van een andere codering (van een byte X gecodeerde array- byte[] naar een UTF-16 gecodeerd System.String en vice -versa).

Omdat de encoder / decoder meestal heel dicht bij elkaar werkt, zijn ze gegroepeerd in een klasse die is afgeleid van System.Text.Encoding , afgeleide klassen bieden conversies van / naar populaire coderingen (UTF-8, UTF-16 enzovoort).

Voorbeelden:

Converteer een string naar UTF-8

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

Converteer UTF-8-gegevens naar een string

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

Wijzig de codering van een bestaand tekstbestand

Deze code leest de inhoud van een UTF-8 gecodeerd tekstbestand en slaat het terug gecodeerd op als UTF-16. Merk op dat deze code niet optimaal is als het bestand groot is, omdat het alle inhoud in het geheugen leest:

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

Virtuele methode Object.ToString ()

Alles NET is een object, waardoor elk type heeft ToString() methode gedefinieerd Object klasse die kan worden overschreven. Standaardimplementatie van deze methode retourneert alleen de naam van het type:

public class Foo
{
}

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

ToString() wordt impliciet aangeroepen bij het samenvoegen van een waarde met een tekenreeks:

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

Het resultaat van deze methode wordt ook uitgebreid gebruikt door hulpprogramma's voor foutopsporing. Als u om een of andere reden deze methode niet wilt overschrijven, maar wilt aanpassen hoe debugger de waarde van uw type toont, gebruikt u 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;}
    // ...
}

Onveranderlijkheid van strings

Strings zijn onveranderlijk. Je kunt de bestaande string niet veranderen. Elke bewerking op de string maakt een nieuwe instantie van de string met een nieuwe waarde. Het betekent dat als u een enkel teken in een zeer lange reeks moet vervangen, geheugen wordt toegewezen voor een nieuwe waarde.

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

Als u veel bewerkingen met tekenreekswaarde moet uitvoeren, gebruikt u de klasse StringBuilder die is ontworpen voor efficiënte manipulatie van tekenreeksen:

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

Snaren vergelijken

Ondanks String is een referentietype == operator vergelijkt stringwaarden in plaats van verwijzingen.

Zoals je misschien weet is string alleen maar een reeks tekens. Maar als u denkt dat tekenreeksen gelijkheid controleren en vergelijken karakter per karakter wordt gemaakt, vergist u zich. Deze bewerking is cultuurspecifiek (zie opmerkingen hieronder): sommige tekenreeksen kunnen als gelijk worden behandeld, afhankelijk van de cultuur .

Denk twee keer na voordat kortsluiting gelijkheidstest door het vergelijken van Length eigenschappen van twee strings!

Gebruik overbelastingen van de String.Equals methode die extra StringComparison opsommingswaarde accepteert als u het standaardgedrag moet wijzigen.