Rune Struktur

Definition

Stellt einen Unicode-Skalarwert dar ( [ U+0000..U+D7FF ], einschließlich; oder [ U+E000..U+10FFFF ], einschließlich).

public value class Rune : IComparable, IComparable<System::Text::Rune>, IEquatable<System::Text::Rune>
public value class Rune : IComparable, IComparable<System::Text::Rune>, IEquatable<System::Text::Rune>, ISpanFormattable
public value class Rune : IComparable<System::Text::Rune>, IEquatable<System::Text::Rune>
public struct Rune : IComparable, IComparable<System.Text.Rune>, IEquatable<System.Text.Rune>
public struct Rune : IComparable, IComparable<System.Text.Rune>, IEquatable<System.Text.Rune>, ISpanFormattable
public struct Rune : IComparable<System.Text.Rune>, IEquatable<System.Text.Rune>
type Rune = struct
type Rune = struct
    interface ISpanFormattable
    interface IFormattable
Public Structure Rune
Implements IComparable, IComparable(Of Rune), IEquatable(Of Rune)
Public Structure Rune
Implements IComparable, IComparable(Of Rune), IEquatable(Of Rune), ISpanFormattable
Public Structure Rune
Implements IComparable(Of Rune), IEquatable(Of Rune)
Vererbung
Implementiert

Hinweise

Eine -Instanz stellt einen Unicode-Skalarwert dar, was bedeutet, dass jeder Codepunkt den Ersatzbereich Rune (U+D800. U+DFFF). Die Konstruktoren und Konvertierungsoperatoren des Typs überprüfen die Eingabe, sodass Benutzer die APIs unter der Annahme aufrufen können, dass die zugrunde liegende Rune Instanz wohlgeformt ist.

Wenn Sie nicht mit den Begriffen Unicode-Skalarwert, Codepunkt, Ersatzzeichenbereich und wohlgeformt vertraut sind, finden Sie weitere Informationen unter Einführung in die Zeichencodierung in .NET.

In den folgenden Abschnitten wird Folgendes erläutert:

Verwendung des Rune-Typs

Ziehen Sie die Verwendung Rune des Typs in Betracht, wenn Ihr Code:

  • Aufrufe von APIs, die Unicode-Skalarwerte erfordern
  • Behandelt Ersatzzeichenpaare explizit

APIs, die Unicode-Skalarwerte erfordern

Wenn Ihr Code die Instanzen in einem oder einem durch iteriert, funktionieren einige der Methoden nicht ordnungsgemäß auf Instanzen, die sich im char string ReadOnlySpan<char> char char Ersatzzeichenbereich befinden. Beispielsweise erfordern die folgenden APIs einen Skalarwert, char damit sie ordnungsgemäß funktionieren:

Das folgende Beispiel zeigt Code, der nicht ordnungsgemäß funktioniert, wenn eine der -Instanzen char Ersatzcodepunkte ist:

// THE FOLLOWING METHOD SHOWS INCORRECT CODE.
// DO NOT DO THIS IN A PRODUCTION APPLICATION.
int CountLettersBadExample(string s)
{
    int letterCount = 0;

    foreach (char ch in s)
    {
        if (char.IsLetter(ch))
        { letterCount++; }
    }

    return letterCount;
}

Hier sehen Sie den entsprechenden Code, der mit einem ReadOnlySpan<char> funktioniert:

// THE FOLLOWING METHOD SHOWS INCORRECT CODE.
// DO NOT DO THIS IN A PRODUCTION APPLICATION.
static int CountLettersBadExample(ReadOnlySpan<char> span)
{
    int letterCount = 0;

    foreach (char ch in span)
    {
        if (char.IsLetter(ch))
        { letterCount++; }
    }

    return letterCount;
}

Der obige Code funktioniert ordnungsgemäß mit einigen Sprachen wie Englisch:

CountLettersInString("Hello")
// Returns 5

Es funktioniert jedoch nicht ordnungsgemäß für Sprachen außerhalb der mehrsprachigen Basic-Ebene, z. B. Osage:

CountLettersInString("𐓏𐓘𐓻𐓘𐓻𐓟 𐒻𐓟")
// Returns 0

Diese Methode gibt falsche Ergebnisse für Osage-Text zurück, da die Instanzen für char Osage-Buchstaben Ersatzcodepunkte sind. Kein einzelner Ersatzcodepunkt verfügt über genügend Informationen, um zu bestimmen, ob es sich um einen Buchstaben gibt.

Wenn Sie diesen Code so ändern, dass anstelle von verwendet wird, funktioniert die -Methode ordnungsgemäß mit Rune char Codepunkten außerhalb der grundlegenden mehrsprachigen Ebene:

int CountLetters(string s)
{
    int letterCount = 0;

    foreach (Rune rune in s.EnumerateRunes())
    {
        if (Rune.IsLetter(rune))
        { letterCount++; }
    }

    return letterCount;
}

Hier sehen Sie den entsprechenden Code, der mit einem ReadOnlySpan<char> funktioniert:

static int CountLetters(ReadOnlySpan<char> span)
{
    int letterCount = 0;

    foreach (Rune rune in span.EnumerateRunes())
    {
        if (Rune.IsLetter(rune))
        { letterCount++; }
    }

    return letterCount;
}

Der vorangehende Code zählt Die Osage-Buchstaben richtig:

CountLettersInString("𐓏𐓘𐓻𐓘𐓻𐓟 𐒻𐓟")
// Returns 8

Code, der Ersatzzeichenpaare explizit behandelt

Erwägen Sie die Verwendung des -Typs, wenn Ihr Code APIs aufruft, die explizit auf Ersatzcodepunkten arbeiten, z. B. Rune die folgenden Methoden:

Die folgende Methode verfügt beispielsweise über eine spezielle Logik für den Umgang mit char Ersatzzeichenpaaren:

static void ProcessStringUseChar(string s)
{
    Console.WriteLine("Using char");

    for (int i = 0; i < s.Length; i++)
    {
        if (!char.IsSurrogate(s[i]))
        {
            Console.WriteLine($"Code point: {(int)(s[i])}");
        }
        else if (i + 1 < s.Length && char.IsSurrogatePair(s[i], s[i + 1]))
        {
            int codePoint = char.ConvertToUtf32(s[i], s[i + 1]);
            Console.WriteLine($"Code point: {codePoint}");
            i++; // so that when the loop iterates it's actually +2
        }
        else
        {
            throw new Exception("String was not well-formed UTF-16.");
        }
    }
}

Dieser Code ist einfacher, wenn er Rune verwendet, wie im folgenden Beispiel:

static void ProcessStringUseRune(string s)
{
    Console.WriteLine("Using Rune");

    for (int i = 0; i < s.Length;)
    {
        if (!Rune.TryGetRuneAt(s, i, out Rune rune))
        {
            throw new Exception("String was not well-formed UTF-16.");
        }

        Console.WriteLine($"Code point: {rune.Value}");
        i += rune.Utf16SequenceLength; // increment the iterator by the number of chars in this Rune
    }
}

Ungeeignete Fälle für Rune

Sie müssen den -Typ nicht Rune verwenden, wenn Ihr Code:

  • Sucht nach genauen char Übereinstimmungen
  • Teilt eine Zeichenfolge nach einem bekannten char-Wert auf.

Die Verwendung Rune des Typs kann falsche Ergebnisse zurückgeben, wenn Ihr Code:

  • Zählt die Anzahl der Anzeigezeichen in einem string

Suchen nach genauen char Übereinstimmungen

Der folgende Code durch iteriert eine nach bestimmten Zeichen string und gibt den Index der ersten Übereinstimmung zurück. Es ist nicht notwendig, diesen Code zu ändern, um zu verwenden, da der Code nach Zeichen Rune sucht, die durch eine einzelne dargestellt char werden.

int GetIndexOfFirstAToZ(string s)
{
    for (int i = 0; i < s.Length; i++)
    {
        char thisChar = s[i];
        if ('A' <= thisChar && thisChar <= 'Z')
        {
            return i; // found a match
        }
    }

    return -1; // didn't find 'A' - 'Z' in the input string
}

Aufteilen einer Zeichenfolge auf eine bekannte char

Es ist üblich, Trennzeichen wie string.Split ' ' (Leerzeichen) oder (Komma) auf- und zu verwenden, wie ',' im folgenden Beispiel:

string inputString = "🐂, 🐄, 🐆";
string[] splitOnSpace = inputString.Split(' ');
string[] splitOnComma = inputString.Split(',');

Hier muss nicht verwendet werden, da der Code nach Zeichen Rune sucht, die durch einen einzelnen dargestellt char werden.

Zählen der Anzahl von Anzeigezeichen in einem string

Die Anzahl der Instanzen in einer Zeichenfolge ist möglicherweise nicht mit der Anzahl der benutzererkennbaren Zeichen übereinstimmen, die beim Anzeigen Rune der Zeichenfolge angezeigt werden.

Da Rune -Instanzen Unicode-Skalarwerte darstellen, können Komponenten, die den Unicode-Textsegmentierungsrichtlinien entsprechen, als Baustein zum Zählen Rune von Anzeigezeichen verwenden.

Der -Typ kann verwendet werden, um Anzeigezeichen zu zählen, aber er zählt nicht ordnungsgemäß in allen Szenarien für .NET-Implementierungen ab StringInfo .NET 5 oder höher.

Weitere Informationen finden Sie unter Grapheme-Cluster.

Instanziieren eines Rune

Es gibt mehrere Möglichkeiten, eine -Instanz Rune zu erhalten. Sie können einen Konstruktor verwenden, um direkt Rune aus:

  • Ein Codepunkt.

    Rune a = new Rune(0x0061); // LATIN SMALL LETTER A
    Rune b = new Rune(0x10421); // DESERET CAPITAL LETTER ER
    
  • Eine einzelne char.

    Rune c = new Rune('a');
    
  • Ein char Ersatzzeichenpaar.

    Rune d = new Rune('\ud83d', '\udd2e'); // U+1F52E CRYSTAL BALL
    

Alle Konstruktoren auslösen eine , ArgumentException wenn die Eingabe keinen gültigen Unicode-Skalarwert repräsentiert.

Es gibt Methoden für Aufrufer, die nicht möchten, dass Rune.TryCreate Ausnahmen bei einem Fehler ausgelöst werden.

Rune -Instanzen können auch aus vorhandenen Eingabesequenzen gelesen werden. Wenn beispielsweise ein -Wert angegeben ist, der ReadOnlySpan<char> UTF-16-Daten darstellt, gibt die Methode die erste Instanz am Anfang Rune.DecodeFromUtf16 Rune der Eingabespanne zurück. Die Rune.DecodeFromUtf8 -Methode funktioniert ähnlich und akzeptiert einen Parameter, ReadOnlySpan<byte> der UTF-8-Daten darstellt. Es gibt äquivalente Methoden zum Lesen vom Ende der Spanne anstelle des Beginns der Spanne.

Abfrageeigenschaften eines Rune

Verwenden Sie die -Eigenschaft, um den ganzzahligen Codepunktwert Rune einer -Instanz Rune.Value zu erhalten.

Rune rune = new Rune('\ud83d', '\udd2e'); // U+1F52E CRYSTAL BALL
int codePoint = rune.Value; // = 128302 decimal (= 0x1F52E)

Viele der statischen APIs, die für den Typ verfügbar char sind, sind auch für den Typ Rune verfügbar. Beispielsweise sind Rune.IsWhiteSpace und Rune.GetUnicodeCategory Äquivalente zu Char.IsWhiteSpace den Methoden und Char.GetUnicodeCategory . Die Rune Methoden verarbeiten Ersatzzeichenpaare ordnungsgemäß.

Im folgenden Beispielcode wird ein als Eingabe verwendet und sowohl vom Anfang als auch vom Ende der Spanne entfernt, bei dem es sich nicht um einen Buchstaben oder ReadOnlySpan<char> Rune eine Ziffer handelt.

static ReadOnlySpan<char> TrimNonLettersAndNonDigits(ReadOnlySpan<char> span)
{
    // First, trim from the front.
    // If any Rune can't be decoded
    // (return value is anything other than "Done"),
    // or if the Rune is a letter or digit,
    // stop trimming from the front and
    // instead work from the end.
    while (Rune.DecodeFromUtf16(span, out Rune rune, out int charsConsumed) == OperationStatus.Done)
    {
        if (Rune.IsLetterOrDigit(rune))
        { break; }
        span = span[charsConsumed..];
    }

    // Next, trim from the end.
    // If any Rune can't be decoded,
    // or if the Rune is a letter or digit,
    // break from the loop, and we're finished.
    while (Rune.DecodeLastFromUtf16(span, out Rune rune, out int charsConsumed) == OperationStatus.Done)
    {
        if (Rune.IsLetterOrDigit(rune))
        { break; }
        span = span[..^charsConsumed];
    }

    return span;
}

Es gibt einige API-Unterschiede zwischen char und Rune . Beispiel:

Konvertieren eines Rune in UTF-8 oder UTF-16

Da ein Rune ein Unicode-Skalarwert ist, kann er in UTF-8-, UTF-16- oder UTF-32-Codierung konvertiert werden. Der Rune Typ verfügt über integrierte Unterstützung für die Konvertierung in UTF-8 und UTF-16.

Konvertiert Rune.EncodeToUtf16 eine Rune -Instanz in char -Instanzen. Verwenden Sie zum Abfragen der Anzahl von Instanzen, die sich aus der Konvertierung einer -Instanz char Rune in UTF-16 ergeben würden, die Rune.Utf16SequenceLength -Eigenschaft. Ähnliche Methoden sind für die UTF-8-Konvertierung vorhanden.

Im folgenden Beispiel wird eine Rune -Instanz in ein -Array char konvertiert. Im Code wird davon ausgegangen, dass Sie über Rune eine -Instanz in der Variablen rune verfügen:

char[] chars = new char[rune.Utf16SequenceLength];
int numCharsWritten = rune.EncodeToUtf16(chars);

Da ein eine Sequenz von UTF-16-Zeichen ist, konvertiert das folgende Beispiel auch eine -Instanz string Rune in UTF-16:

string theString = rune.ToString();

Im folgenden Beispiel wird eine Rune -Instanz in ein UTF-8 Bytearray konvertiert:

byte[] bytes = new byte[rune.Utf8SequenceLength];
int numBytesWritten = rune.EncodeToUtf8(bytes);

Die Rune.EncodeToUtf16 Methoden und geben die tatsächliche Anzahl der Rune.EncodeToUtf8 geschriebenen Elemente zurück. Sie löst eine Ausnahme aus, wenn der Zielpuffer zu kurz ist, um das Ergebnis zu enthalten. Es gibt auch nicht auslösende TryEncodeToUtf8 - und EncodeToUtf16 -Methoden für Aufrufer, die Ausnahmen vermeiden möchten.

Rune in .NET im Vergleich zu anderen Sprachen

Der Begriff "rune" ist im Unicode-Standard nicht definiert. Der Begriff geht auf die Erstellung von UTF-8 zurück. Rob Pike und Ken Pic suchten nach einem Begriff, um zu beschreiben, was schließlich als Codepunkt bezeichnet werden würde. Sie haben sich auf den Begriff "Rune"besingt, und der spätere Einfluss von Rob Pike auf die Programmiersprache Go hat dazu beigetragen, den Begriff zu popularisieren.

Der .NET-Typ Rune entspricht jedoch nicht dem Go-Typ. rune In Go ist der rune Typ ein Alias int32 für . Eine Go-Rune soll einen Unicode-Codepunkt darstellen, kann aber ein beliebiger 32-Bit-Wert sein, einschließlich Ersatzcodepunkten und Werten, die keine rechtlichen Unicode-Codepunkte sind.

Informationen zu ähnlichen Typen in anderen Programmiersprachen finden Sie unter Primitiver Typ von Primitiven char oder Swift-Typ von Swift, Unicode.Scalar die beide Unicode-Skalarwerte darstellen. Sie bieten ähnliche Funktionen wie . DER NET-Typ, und die Instanziierung von Werten, die keine rechtlichen Rune Unicode-Skalarwerte sind, wird nicht unterstützt.

Konstruktoren

Rune(Char)

Erstellt eine Rune-Struktur aus der bereitgestellten UTF-16-Codeeinheit.

Rune(Char, Char)

Erstellt eine Rune-Struktur aus dem bereitgestellten UTF-16-Ersatzzeichenpaar.

Rune(Int32)

Erstellt eine Rune-Struktur aus der angegebenen 32-Bit-Ganzzahl, die einen Unicode-Skalarwert darstellt.

Rune(UInt32)

Erstellt eine Rune-Struktur aus der angegebenen 32-Bit-Ganzzahl ohne Vorzeichen, die einen Unicode-Skalarwert darstellt.

Eigenschaften

IsAscii

Ruft einen Wert ab, der angibt, ob der Rune zugeordnete Skalarwert innerhalb des ASCII-Codierungsbereichs liegt.

IsBmp

Ruft einen Wert ab, der angibt, ob der Rune zugeordnete Skalarwert innerhalb des BMP-Codierungsbereichs liegt.

Plane

Ruft die Unicode-Ebene (0 bis einschließlich 16) ab, die diesen Skalar enthält.

ReplacementChar

Ruft eine Rune-Instanz ab, die das Unicode-Ersatzzeichen U+FFFD darstellt.

Utf16SequenceLength

Ruft die Länge in Codeeinheiten (Char) der UTF-16-Sequenz ab, die zur Darstellung dieses Skalarwerts erforderlich ist.

Utf8SequenceLength

Ruft die Länge in Codeeinheiten der UTF-8-Sequenz ab, die zur Darstellung dieses Skalarwerts erforderlich ist.

Value

Ruft den Unicode-Skalarwert als ganze Zahl ab.

Methoden

CompareTo(Rune)

Vergleicht die aktuelle Instanz mit dem angegebenen Rune-Objekt.

DecodeFromUtf16(ReadOnlySpan<Char>, Rune, Int32)

Decodiert das Rune-Element am Anfang des bereitgestellten UTF-16-Quellpuffers.

DecodeFromUtf8(ReadOnlySpan<Byte>, Rune, Int32)

Decodiert das Rune-Element am Anfang des bereitgestellten UTF-8-Quellpuffers.

DecodeLastFromUtf16(ReadOnlySpan<Char>, Rune, Int32)

Decodiert das Rune-Element am Ende des bereitgestellten UTF-16-Quellpuffers.

DecodeLastFromUtf8(ReadOnlySpan<Byte>, Rune, Int32)

Decodiert das Rune-Element am Ende des bereitgestellten UTF-8-Quellpuffers.

EncodeToUtf16(Span<Char>)

Codiert diese Rune-Struktur in einen Zielpuffer im UTF-16-Format.

EncodeToUtf8(Span<Byte>)

Codiert diese Rune-Struktur in einen Zielpuffer im UTF-8-Format.

Equals(Object)

Gibt einen Wert zurück, der angibt, ob die aktuelle Instanz und ein angegebenes Objekt gleich sind.

Equals(Rune)

Gibt einen Wert zurück, der angibt, ob die aktuelle Instanz und eine angegebene Rune gleich sind.

GetHashCode()

Gibt den Hashcode für diese Instanz zurück.

GetNumericValue(Rune)

Ruft den numerischen Wert ab, der der angegebenen Rune zugeordnet ist.

GetRuneAt(String, Int32)

Ruft die Rune-Struktur ab, die an der angegebenen Position in einer Zeichenfolge beginnt.

GetUnicodeCategory(Rune)

Ruft die Unicode-Kategorie ab, die der angegebenen Rune zugeordnet ist.

IsControl(Rune)

Gibt einen Wert zurück, der angibt, ob die angegebene Rune als Steuerzeichen kategorisiert ist.

IsDigit(Rune)

Gibt einen Wert zurück, der angibt, ob die angegebene Rune als Dezimalzahl kategorisiert ist.

IsLetter(Rune)

Gibt einen Wert zurück, der angibt, ob die angegebene Rune als Buchstabe kategorisiert ist.

IsLetterOrDigit(Rune)

Gibt einen Wert zurück, der angibt, ob die angegebene Rune als Buchstabe oder Dezimalzahl kategorisiert ist.

IsLower(Rune)

Gibt einen Wert zurück, der angibt, ob die angegebene Rune als Kleinbuchstabe kategorisiert ist.

IsNumber(Rune)

Gibt einen Wert zurück, der angibt, ob die angegebene Rune als Zahl kategorisiert ist.

IsPunctuation(Rune)

Gibt einen Wert zurück, der angibt, ob die angegebene Rune als Satzzeichen kategorisiert ist.

IsSeparator(Rune)

Gibt einen Wert zurück, der angibt, ob die angegebene Rune als Trennzeichen kategorisiert ist.

IsSymbol(Rune)

Gibt einen Wert zurück, der angibt, ob die angegebene Rune als Symbolzeichen kategorisiert ist.

IsUpper(Rune)

Gibt einen Wert zurück, der angibt, ob die angegebene Rune als Großbuchstabe kategorisiert ist.

IsValid(Int32)

Gibt einen Wert zurück, der angibt, ob eine 32-Bit-Ganzzahl mit Vorzeichen einen gültigen Unicode-Skalarwert darstellt. Dieser liegt im Bereich [ U+0000..U+D7FF ], einschließlich; oder [ U+E000..U+10FFFF ], einschließlich.

IsValid(UInt32)

Gibt einen Wert zurück, der angibt, ob eine 32-Bit-Ganzzahl ohne Vorzeichen einen gültigen Unicode-Skalarwert darstellt. Dieser liegt im Bereich [ U+0000..U+D7FF ], einschließlich; oder [ U+E000..U+10FFFF ], einschließlich.

IsWhiteSpace(Rune)

Gibt einen Wert zurück, der angibt, ob die angegebene Rune als Leerzeichen kategorisiert ist.

ToLower(Rune, CultureInfo)

Gibt eine in Kleinbuchstaben konvertierte Kopie der angegebenen Rune zurück, wobei die Regeln der Groß- und Kleinschreibung der angegebenen Kultur verwendet werden.

ToLowerInvariant(Rune)

Gibt eine in Kleinbuchstaben konvertierte Kopie der angegebenen Rune zurück, wobei die Regeln der Groß- und Kleinschreibung der invarianten Kultur verwendet werden.

ToString()

Gibt die Zeichenfolgendarstellung dieser Rune-Instanz zurück.

ToUpper(Rune, CultureInfo)

Gibt eine in Großbuchstaben konvertierte Kopie der angegebenen Rune zurück, wobei die Regeln der Groß- und Kleinschreibung der angegebenen Kultur verwendet werden.

ToUpperInvariant(Rune)

Gibt eine in Großbuchstaben konvertierte Kopie der angegebenen Rune zurück, wobei die Regeln der Groß- und Kleinschreibung der invarianten Kultur verwendet werden.

TryCreate(Char, Char, Rune)

Versucht, eine Rune-Struktur aus einem angegebenen UTF-16-Ersatzzeichenpaar zu erstellen, und gibt einen Wert zurück, der angibt, ob der Vorgang erfolgreich war.

TryCreate(Char, Rune)

Versucht, eine Rune-Struktur aus einem angegebenen Zeichen zu erstellen, und gibt einen Wert zurück, der angibt, ob der Vorgang erfolgreich war.

TryCreate(Int32, Rune)

Versucht, eine Rune-Struktur aus der angegebenen ganzen Zahl mit Vorzeichen zu erstellen, die einen Unicode-Skalarwert darstellt.

TryCreate(UInt32, Rune)

Versucht, eine Rune-Struktur aus der angegebenen 32-Bit-Ganzzahl ohne Vorzeichen zu erstellen, die einen Unicode-Skalarwert darstellt.

TryEncodeToUtf16(Span<Char>, Int32)

Codiert diese Rune-Struktur in einen verschlüsselten Zielpuffer im UTF-16-Format.

TryEncodeToUtf8(Span<Byte>, Int32)

Codiert diese Rune-Struktur in einen Zielpuffer im UTF-8-Format.

TryGetRuneAt(String, Int32, Rune)

Versucht, die Rune-Klasse abzurufen, die an der angegebenen Position in einer Zeichenfolge beginnt und einen Wert zurückgibt, der angibt, ob der Vorgang erfolgreich war.

Operatoren

Equality(Rune, Rune)

Gibt einen Wert zurück, der angibt, ob zwei Rune-Instanzen gleich sind.

Explicit(Char to Rune)

Definiert eine explizite Konvertierung eines 16-Bit-Unicode-Zeichens in eine Rune.

Explicit(Int32 to Rune)

Definiert eine explizite Konvertierung einer 32-Bit-Ganzzahl mit Vorzeichen in den Wert einer Rune.

Explicit(UInt32 to Rune)

Definiert eine explizite Konvertierung einer 32-Bit-Ganzzahl ohne Vorzeichen in den Wert einer Rune.

GreaterThan(Rune, Rune)

Gibt einen Wert zurück, der angibt, ob ein angegebenes Rune größer als eine anderes angegebenes Rune ist.

GreaterThanOrEqual(Rune, Rune)

Gibt einen Wert zurück, der angibt, ob ein angegebenes Rune größer oder gleich einem anderen angegebenen Rune ist.

Inequality(Rune, Rune)

Gibt einen Wert zurück, der angibt, ob zwei Rune-Instanzen über unterschiedliche Werte verfügen.

LessThan(Rune, Rune)

Gibt einen Wert zurück, der angibt, ob ein angegebenes Rune kleiner als ein anderes angegebenes Rune ist.

LessThanOrEqual(Rune, Rune)

Gibt einen Wert zurück, der angibt, ob ein angegebenes Rune kleiner oder gleich einem anderen angegebenen Rune ist.

Explizite Schnittstellenimplementierungen

IComparable.CompareTo(Object)

Vergleicht die aktuelle Instanz mit dem angegebenen Objekt.

IFormattable.ToString(String, IFormatProvider)

Formatiert den Wert der aktuellen Instanz mit dem angegebenen Format.

ISpanFormattable.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)

Versucht, den Wert der aktuellen Instanz in die angegebene Zeichenspanne zu formatieren.

Gilt für