Rune Struct

Definizione

Rappresenta un valore scalare Unicode ([ U+0000..U+D7FF ], inclusi; o [ U+E000..U+10FFFF ], inclusi).Represents a Unicode scalar value ([ U+0000..U+D7FF ], inclusive; or [ U+E000..U+10FFFF ], inclusive).

public value class Rune : IComparable, IComparable<System::Text::Rune>, IEquatable<System::Text::Rune>
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<System.Text.Rune>, IEquatable<System.Text.Rune>
type Rune = struct
Public Structure Rune
Implements IComparable, IComparable(Of Rune), IEquatable(Of Rune)
Public Structure Rune
Implements IComparable(Of Rune), IEquatable(Of Rune)
Ereditarietà
Implementazioni

Commenti

Un' Rune istanza rappresenta un valore scalare Unicode, ovvero qualsiasi punto di codice che esclude l'intervallo di surrogati (U + D800.. U + DFFF).A Rune instance represents a Unicode scalar value, which means any code point excluding the surrogate range (U+D800..U+DFFF). I costruttori e gli operatori di conversione del tipo convalidano l'input, in modo che i consumer possano chiamare le API presumendo che l' Rune istanza sottostante sia ben formato.The type's constructors and conversion operators validate the input, so consumers can call the APIs assuming that the underlying Rune instance is well formed.

Se non si ha familiarità con i termini valore scalare Unicode, punto di codice, intervallo di surrogati e ben formato, vedere Introduzione alla codifica dei caratteri in .NET.If you aren't familiar with the terms Unicode scalar value, code point, surrogate range, and well-formed, see Introduction to character encoding in .NET.

Le sezioni seguenti illustrano:The following sections explain:

Quando usare il tipo di RunaWhen to use the Rune type

Provare a usare il Rune tipo se il codice:Consider using the Rune type if your code:

  • Chiama le API che richiedono valori scalari UnicodeCalls APIs that require Unicode scalar values
  • Gestisce in modo esplicito le coppie di surrogatiExplicitly handles surrogate pairs

API che richiedono valori scalari UnicodeAPIs that require Unicode scalar values

Se il codice scorre le char istanze di in un oggetto string o ReadOnlySpan<char> , alcuni dei char metodi non funzioneranno correttamente nelle char istanze di che si trovano nell'intervallo di surrogati.If your code iterates through the char instances in a string or a ReadOnlySpan<char>, some of the char methods won't work correctly on char instances that are in the surrogate range. Per il corretto funzionamento delle API seguenti, ad esempio, è necessario un valore scalare char :For example, the following APIs require a scalar value char to work correctly:

Nell'esempio seguente viene illustrato il codice che non funzionerà correttamente se una delle istanze è costituita da char punti di codice surrogati:The following example shows code that won't work correctly if any of the char instances are surrogate code points:

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

Ecco il codice equivalente che funziona con un ReadOnlySpan<char> :Here's equivalent code that works with a ReadOnlySpan<char>:

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

Il codice precedente funziona correttamente con alcune lingue, ad esempio l'inglese:The preceding code works correctly with some languages such as English:

CountLettersInString("Hello")
// Returns 5

Ma non funzionerà correttamente per le lingue all'esterno del piano multilingue di base, ad esempio Osage:But it won't work correctly for languages outside the Basic Multilingual Plane, such as Osage:

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

Il motivo per cui questo metodo restituisce risultati non corretti per il testo Osage è che le char istanze di Osage lettere sono punti di codice surrogati.The reason this method returns incorrect results for Osage text is that the char instances for Osage letters are surrogate code points. Nessun singolo punto di codice surrogato ha informazioni sufficienti per determinare se si tratta di una lettera.No single surrogate code point has enough information to determine if it's a letter.

Se si modifica questo codice per usare Rune anziché char , il metodo funziona correttamente con i punti di codice all'esterno del piano multilingue di base:If you change this code to use Rune instead of char, the method works correctly with code points outside the Basic Multilingual Plane:

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

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

    return letterCount;
}

Ecco il codice equivalente che funziona con un ReadOnlySpan<char> :Here's equivalent code that works with a ReadOnlySpan<char>:

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

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

    return letterCount;
}

Il codice precedente conteggia correttamente le lettere Osage:The preceding code counts Osage letters correctly:

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

Codice che gestisce in modo esplicito le coppie di surrogatiCode that explicitly handles surrogate pairs

Provare a usare il Rune tipo se il codice chiama API che operano in modo esplicito su punti di codice surrogati, ad esempio i metodi seguenti:Consider using the Rune type if your code calls APIs that explicitly operate on surrogate code points, such as the following methods:

Il metodo seguente, ad esempio, ha una logica speciale per gestire le coppie di surrogati char :For example, the following method has special logic to deal with surrogate char pairs:

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.");
        }
    }
}

Tale codice è più semplice se usa Rune , come nell'esempio seguente:Such code is simpler if it uses Rune, as in the following example:

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

Quando non usare RuneWhen not to use Rune

Non è necessario usare il Rune tipo se il codice:You don't need to use the Rune type if your code:

  • Cerca char corrispondenze esatteLooks for exact char matches
  • Suddivide una stringa in un valore char notoSplits a string on a known char value

L'uso del Rune tipo può restituire risultati non corretti se il codice:Using the Rune type may return incorrect results if your code:

  • Conta il numero di caratteri visualizzati in un oggetto stringCounts the number of display characters in a string

Cerca char corrispondenze esatteLook for exact char matches

Il codice seguente esegue l'iterazione di una string ricerca di caratteri specifici, restituendo l'indice della prima corrispondenza.The following code iterates through a string looking for specific characters, returning the index of the first match. Non è necessario modificare questo codice per usare Rune , perché il codice cerca i caratteri rappresentati da un singolo char .There's no need to change this code to use Rune, as the code is looking for characters that are represented by a single char.

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
}

Suddivide una stringa in un oggetto noto charSplit a string on a known char

È comune chiamare string.Split e usare delimitatori, ad esempio ' ' (spazio) o ',' (virgola), come nell'esempio seguente:It's common to call string.Split and use delimiters such as ' ' (space) or ',' (comma), as in the following example:

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

Non è necessario usare Rune qui, perché il codice cerca i caratteri rappresentati da un singolo char .There is no need to use Rune here, because the code is looking for characters that are represented by a single char.

Contare il numero di caratteri visualizzati in un stringCount the number of display characters in a string

Il numero di Rune istanze in una stringa potrebbe non corrispondere al numero di caratteri percepibili dall'utente visualizzati durante la visualizzazione della stringa.The number of Rune instances in a string might not match the number of user-perceivable characters shown when displaying the string.

Poiché Rune le istanze rappresentano valori scalari Unicode, i componenti che seguono le linee guida per la segmentazione del testo Unicode possono utilizzare Rune come blocco predefinito per il conteggio dei caratteri di visualizzazione.Since Rune instances represent Unicode scalar values, components that follow the Unicode text segmentation guidelines can use Rune as a building block for counting display characters.

Il StringInfo tipo può essere utilizzato per conteggiare i caratteri visualizzati, ma in implementazioni di .NET diverse da .NET 5 non viene conteggiato correttamente in tutti gli scenari.The StringInfo type can be used to count display characters, but in implementations of .NET other than .NET 5 it doesn't count correctly in all scenarios.

Per altre informazioni, vedere cluster grafema.For more information, see Grapheme clusters.

Come creare un'istanza di un RuneHow to instantiate a Rune

Sono disponibili diversi modi per ottenere un' Rune istanza di.There are several ways to get a Rune instance. È possibile usare un costruttore per creare un oggetto Rune direttamente da:You can use a constructor to create a Rune directly from:

  • Un punto di codice.A code point.

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

    Rune c = new Rune('a');
    
  • Coppia di surrogati char .A surrogate char pair.

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

Tutti i costruttori generano un'espressione ArgumentException se l'input non rappresenta un valore scalare Unicode valido.All of the constructors throw an ArgumentException if the input doesn't represent a valid Unicode scalar value.

Sono Rune.TryCreate disponibili metodi per i chiamanti che non vogliono che vengano generate eccezioni in caso di errore.There are Rune.TryCreate methods available for callers who don't want exceptions to be thrown on failure.

Rune le istanze possono essere lette anche dalle sequenze di input esistenti.Rune instances can also be read from existing input sequences. Ad esempio, dato un oggetto ReadOnlySpan<char> che rappresenta i dati UTF-16, il Rune.DecodeFromUtf16 metodo restituisce la prima Rune istanza all'inizio dell'intervallo di input.For instance, given a ReadOnlySpan<char> that represents UTF-16 data, the Rune.DecodeFromUtf16 method returns the first Rune instance at the beginning of the input span. Il Rune.DecodeFromUtf8 metodo funziona in modo analogo, accettando un ReadOnlySpan<byte> parametro che rappresenta i dati UTF-8.The Rune.DecodeFromUtf8 method operates similarly, accepting a ReadOnlySpan<byte> parameter that represents UTF-8 data. Sono disponibili metodi equivalenti per la lettura dalla fine dell'intervallo anziché dall'inizio dell'intervallo.There are equivalent methods to read from the end of the span instead of the beginning of the span.

Eseguire query sulle proprietà di un RuneQuery properties of a Rune

Per ottenere il valore del punto di codice integer di un' Rune istanza, utilizzare la Rune.Value Proprietà.To get the integer code point value of a Rune instance, use the Rune.Value property.

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

Molte delle API statiche disponibili sul char tipo sono disponibili anche sul Rune tipo.Many of the static APIs available on the char type are also available on the Rune type. Ad esempio, Rune.IsWhiteSpace e Rune.GetUnicodeCategory sono equivalenti ai Char.IsWhiteSpace Char.GetUnicodeCategory metodi e.For instance, Rune.IsWhiteSpace and Rune.GetUnicodeCategory are equivalents to Char.IsWhiteSpace and Char.GetUnicodeCategory methods. I Rune metodi gestiscono correttamente le coppie di surrogati.The Rune methods correctly handle surrogate pairs.

Il codice di esempio seguente accetta ReadOnlySpan<char> come input e trim dall'inizio e dalla fine dell'intervallo ogni Rune che non è una lettera o una cifra.The following example code takes a ReadOnlySpan<char> as input and trims from both the start and the end of the span every Rune that isn't a letter or a digit.

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

Esistono alcune differenze tra le API char e Rune .There are some API differences between char and Rune. Esempio:For example:

Converte un oggetto Rune in UTF-8 o UTF-16Convert a Rune to UTF-8 or UTF-16

Poiché Rune è un valore scalare Unicode, può essere convertito nella codifica UTF-8, UTF-16 o UTF-32.Since a Rune is a Unicode scalar value, it can be converted to UTF-8, UTF-16, or UTF-32 encoding. Il Rune tipo dispone del supporto incorporato per la conversione in UTF-8 e UTF-16.The Rune type has built-in support for conversion to UTF-8 and UTF-16.

Rune.EncodeToUtf16Converte un' Rune istanza di in char istanze di.The Rune.EncodeToUtf16 converts a Rune instance to char instances. Per eseguire una query sul numero di char istanze risultante dalla conversione Rune di un'istanza in UTF-16, utilizzare la Rune.Utf16SequenceLength Proprietà.To query the number of char instances that would result from converting a Rune instance to UTF-16, use the Rune.Utf16SequenceLength property. Esistono metodi simili per la conversione UTF-8.Similar methods exist for UTF-8 conversion.

Nell'esempio seguente viene convertita un' Rune istanza in una char matrice.The following example converts a Rune instance to a char array. Il codice presuppone che sia presente un' Rune istanza nella rune variabile:The code assumes you have a Rune instance in the rune variable:

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

Poiché string è una sequenza di caratteri UTF-16, nell'esempio seguente viene anche convertita un' Rune istanza in UTF-16:Since a string is a sequence of UTF-16 chars, the following example also converts a Rune instance to UTF-16:

string theString = rune.ToString();

Nell'esempio seguente viene convertita un' Rune istanza in una UTF-8 matrice di byte:The following example converts a Rune instance to a UTF-8 byte array:

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

I Rune.EncodeToUtf16 Rune.EncodeToUtf8 metodi e restituiscono il numero effettivo di elementi scritti.The Rune.EncodeToUtf16 and Rune.EncodeToUtf8 methods return the actual number of elements written. Generano un'eccezione se il buffer di destinazione è troppo breve per contenere il risultato.They throw an exception if the destination buffer is too short to contain the result. TryEncodeToUtf8 EncodeToUtf16 Per i chiamanti che desiderano evitare eccezioni, sono disponibili anche metodi e non di generazione.There are non-throwing TryEncodeToUtf8 and EncodeToUtf16 methods as well for callers who want to avoid exceptions.

Rune in .NET rispetto ad altri linguaggiRune in .NET vs. other languages

Il termine "rune" non è definito nello standard Unicode.The term "rune" is not defined in the Unicode Standard. Il termine risale alla creazione di UTF-8.The term dates back to the creation of UTF-8. Rob Pike e Ken Thompson stavano cercando un termine per descrivere cosa sarebbe diventato noto come un punto di codice.Rob Pike and Ken Thompson were looking for a term to describe what would eventually become known as a code point. Si sono riferiti al termine "rune"e Rob Pike ha influenzato ulteriormente il linguaggio di programmazione go.They settled on the term "rune", and Rob Pike's later influence over the Go programming language helped popularize the term.

Tuttavia, il Rune tipo .NET non è equivalente al rune tipo go.However, the .NET Rune type is not the equivalent of the Go rune type. In go, il rune tipo è un alias per int32 .In Go, the rune type is an alias for int32. Una RunAs Go è progettata per rappresentare un punto di codice Unicode, ma può essere qualsiasi valore a 32 bit, inclusi i punti di codice surrogati e i valori che non sono punti di codice Unicode validi.A Go rune is intended to represent a Unicode code point, but it can be any 32-bit value, including surrogate code points and values that are not legal Unicode code points.

Per tipi simili in altri linguaggi di programmazione, vedere char tipo primitivo di Rust o Unicode.Scalar tipo Swift, che rappresentano entrambi valori scalari Unicode.For similar types in other programming languages, see Rust's primitive char type or Swift's Unicode.Scalar type, both of which represent Unicode scalar values. Forniscono funzionalità simili a. Rune Tipo di NET, che non consentono la creazione di un'istanza di valori non validi scalari Unicode.They provide functionality similar to .NET's Rune type, and they disallow instantiation of values that are not legal Unicode scalar values.

Costruttori

Rune(Char)

Crea un Rune dall'unità di codice UTF-16 specificata.Creates a Rune from the provided UTF-16 code unit.

Rune(Char, Char)

Crea un Rune dalla coppia di surrogati UTF-16 specificata.Creates a Rune from the provided UTF-16 surrogate pair.

Rune(Int32)

Crea un Rune dall'intero a 32 bit specificato che rappresenta un valore scalare Unicode.Creates a Rune from the specified 32-bit integer that represents a Unicode scalar value.

Rune(UInt32)

Crea un Rune dall'intero senza segno a 32 bit specificato che rappresenta un valore scalare Unicode.Creates a Rune from the specified 32-bit unsigned integer that represents a Unicode scalar value.

Proprietà

IsAscii

Ottiene un valore che indica se il valore scalare associato a questo oggetto Rune è compreso nell'intervallo di codifica ASCII.Gets a value that indicates whether the scalar value associated with this Rune is within the ASCII encoding range.

IsBmp

Ottiene un valore che indica se il valore scalare associato a questo oggetto Rune è compreso nell'intervallo di codifica BMP.Gets a value that indicates whether the scalar value associated with this Rune is within the BMP encoding range.

Plane

Ottiene il piano Unicode (compreso tra 0 e 16, inclusi) che contiene questo valore scalare.Gets the Unicode plane (0 to 16, inclusive) that contains this scalar.

ReplacementChar

Ottiene un'istanza di Rune che rappresenta il carattere di sostituzione Unicode U+FFFD.Gets a Rune instance that represents the Unicode replacement character U+FFFD.

Utf16SequenceLength

Restituisce la lunghezza in unità di codice (Char) della sequenza UTF-16 necessaria per rappresentare questo valore scalare.Gets the length in code units (Char) of the UTF-16 sequence required to represent this scalar value.

Utf8SequenceLength

Restituisce la lunghezza in unità di codice della sequenza UTF-8 necessaria per rappresentare questo valore scalare.Gets the length in code units of the UTF-8 sequence required to represent this scalar value.

Value

Restituisce il valore scalare Unicode come intero.Gets the Unicode scalar value as an integer.

Metodi

CompareTo(Rune)

Confronta l'istanza corrente con l'istanza di Rune specificata.Compares the current instance to the specified Rune instance.

DecodeFromUtf16(ReadOnlySpan<Char>, Rune, Int32)

Decodifica l'oggetto Rune all'inizio del buffer di origine UTF-16 specificato.Decodes the Rune at the beginning of the provided UTF-16 source buffer.

DecodeFromUtf8(ReadOnlySpan<Byte>, Rune, Int32)

Decodifica l'oggetto Rune all'inizio del buffer di origine UTF-8 specificato.Decodes the Rune at the beginning of the provided UTF-8 source buffer.

DecodeLastFromUtf16(ReadOnlySpan<Char>, Rune, Int32)

Decodifica l'oggetto Rune alla fine del buffer di origine UTF-16 specificato.Decodes the Rune at the end of the provided UTF-16 source buffer.

DecodeLastFromUtf8(ReadOnlySpan<Byte>, Rune, Int32)

Decodifica l'oggetto Rune alla fine del buffer di origine UTF-8 specificato.Decodes the Rune at the end of the provided UTF-8 source buffer.

EncodeToUtf16(Span<Char>)

Codifica questo oggetto Rune in un buffer di destinazione UTF-16.Encodes this Rune to a UTF-16 destination buffer.

EncodeToUtf8(Span<Byte>)

Codifica questo oggetto Rune in un buffer di destinazione UTF-8.Encodes this Rune to a UTF-8 destination buffer.

Equals(Object)

Restituisce un valore che indica se l'istanza corrente è uguale a un oggetto specificato.Returns a value that indicates whether the current instance and a specified object are equal.

Equals(Rune)

Restituisce un valore che indica se l'istanza corrente è uguale a una runa specificata.Returns a value that indicates whether the current instance and a specified rune are equal.

GetHashCode()

Restituisce il codice hash per l'istanza.Returns the hash code for this instance.

GetNumericValue(Rune)

Ottiene il valore numerico associato alla runa specificata.Gets the numeric value associated with the specified rune.

GetRuneAt(String, Int32)

Ottiene l'oggetto Rune che inizia in corrispondenza di una posizione specificata in una stringa.Gets the Rune that begins at a specified position in a string.

GetUnicodeCategory(Rune)

Ottiene la categoria Unicode associata alla runa specificata.Gets the Unicode category associated with the specified rune.

IsControl(Rune)

Restituisce un valore che indica se la runa specificata è stata categorizzata come carattere di controllo.Returns a value that indicates whether the specified rune is categorized as a control character.

IsDigit(Rune)

Restituisce un valore che indica se la runa specificata è stata categorizzata come cifra decimale.Returns a value that indicates whether the specified rune is categorized as a decimal digit.

IsLetter(Rune)

Restituisce un valore che indica se la runa specificata è stata categorizzata come lettera.Returns a value that indicates whether the specified rune is categorized as a letter.

IsLetterOrDigit(Rune)

Restituisce un valore che indica la runa specificata è stata categorizzata come lettera o cifra decimale.Returns a value that indicates whether the specified rune is categorized as a letter or a decimal digit.

IsLower(Rune)

Restituisce un valore che indica se la runa specificata è stata categorizzata come lettera minuscola.Returns a value that indicates whether the specified rune is categorized as a lowercase letter.

IsNumber(Rune)

Restituisce un valore che indica se la runa specificata è stata categorizzata come numero.Returns a value that indicates whether the specified rune is categorized as a number.

IsPunctuation(Rune)

Restituisce un valore che indica se la runa specificata è stata categorizzata come segno di punteggiatura.Returns a value that indicates whether the specified rune is categorized as a punctuation mark.

IsSeparator(Rune)

Restituisce un valore che indica se la runa specificata è stata categorizzata come carattere separatore.Returns a value that indicates whether the specified rune is categorized as a separator character.

IsSymbol(Rune)

Restituisce un valore che indica se la runa specificata è stata categorizzata come carattere simbolo.Returns a value that indicates whether the specified rune is categorized as a symbol character.

IsUpper(Rune)

Restituisce un valore che indica se la runa specificata è stata categorizzata come lettera maiuscola.Returns a value that indicates whether the specified rune is categorized as an uppercase letter.

IsValid(Int32)

Restituisce un valore che indica se un intero con segno a 32 bit rappresenta un valore scalare Unicode valido, ovvero è compreso nell'intervallo [ U+0000..U+D7FF ], inclusi; o [ U+E000..U+10FFFF ], inclusi.Returns a value that indicates whether a 32-bit signed integer represents a valid Unicode scalar value; that is, it is in the range [ U+0000..U+D7FF ], inclusive; or [ U+E000..U+10FFFF ], inclusive.

IsValid(UInt32)

Restituisce un valore che indica se un intero senza segno a 32 bit rappresenta un valore scalare Unicode valido, ovvero è compreso nell'intervallo [ U+0000..U+D7FF ], inclusi; o [ U+E000..U+10FFFF ], inclusi.Returns a value that indicates whether a 32-bit unsigned integer represents a valid Unicode scalar value; that is, it is in the range [ U+0000..U+D7FF ], inclusive, or [ U+E000..U+10FFFF ], inclusive.

IsWhiteSpace(Rune)

Restituisce un valore che indica se la runa specificata è stata categorizzata come carattere spazio vuoto.Returns a value that indicates whether the specified rune is categorized as a white space character.

ToLower(Rune, CultureInfo)

Restituisce una copia dell'oggetto Rune specificato convertita in caratteri minuscoli, usando le regole relative all'uso di maiuscole e minuscole proprie delle impostazioni cultura specificate.Returns a copy of the specified Rune converted to lowercase, using the casing rules of the specified culture.

ToLowerInvariant(Rune)

Restituisce una copia dell'oggetto Rune specificato convertito in caratteri minuscoli mediante le regole relative all'uso di maiuscole e minuscole proprie delle impostazioni cultura inglese non dipendenti da paese/area geografica.Returns a copy of the specified Rune converted to lowercase using the casing rules of the invariant culture.

ToString()

Restituisce la rappresentazione di stringa di questa istanza di Rune.Returns the string representation of this Rune instance.

ToUpper(Rune, CultureInfo)

Restituisce una copia dell'oggetto Rune specificato convertito in caratteri maiuscoli mediante le regole relative all'uso di maiuscole e minuscole proprie delle impostazioni cultura specificate.Returns a copy of the specified Rune converted to uppercase, using the casing rules of the specified culture.

ToUpperInvariant(Rune)

Restituisce una copia dell'oggetto Rune specificato convertito in caratteri maiuscoli mediante le regole relative all'uso di maiuscole e minuscole proprie delle impostazioni cultura inglese non dipendenti da paese/area geografica.Returns a copy of the specified Rune converted to uppercase using the casing rules of the invariant culture.

TryCreate(Char, Char, Rune)

Tenta di creare un oggetto Rune dalla coppia di surrogati UTF-16 specificata e restituisce un valore che indica se l'operazione è riuscita.Attempts to create a Rune from the specified UTF-16 surrogate pair and returns a value that indicates whether the operation was successful.

TryCreate(Char, Rune)

Tenta di creare un oggetto Rune da un carattere specificato e restituisce un valore che indica se l'operazione è riuscita.Attempts to create a Rune from a specified character and returns a value that indicates whether the operation succeeded.

TryCreate(Int32, Rune)

Tenta di creare un oggetto Rune da un intero con segno specificato che rappresenta un valore scalare Unicode.Attempts to create a Rune from a specified signed integer that represents a Unicode scalar value.

TryCreate(UInt32, Rune)

Tenta di creare un oggetto Rune dall'intero senza segno a 32 bit specificato che rappresenta un valore scalare Unicode.Attempts to create a Rune from the specified 32-bit unsigned integer that represents a Unicode scalar value.

TryEncodeToUtf16(Span<Char>, Int32)

Codifica questo oggetto Rune in un buffer di destinazione con codifica UTF-16.Encodes this Rune to a UTF-16 encoded destination buffer.

TryEncodeToUtf8(Span<Byte>, Int32)

Codifica questo oggetto Rune in un buffer di destinazione con codifica UTF-8.Encodes this Rune to a UTF-8 encoded destination buffer.

TryGetRuneAt(String, Int32, Rune)

Tenta di ottenere l'oggetto Rune che inizia in corrispondenza di una posizione specificata in una stringa e restituisce un valore che indica se l'operazione è riuscita.Attempts to get the Rune that begins at a specified position in a string, and return a value that indicates whether the operation succeeded.

Operatori

Equality(Rune, Rune)

Restituisce un valore che indica se due istanze di Rune sono uguali.Returns a value that indicates whether two Rune instances are equal.

Explicit(Char to Rune)

Definisce una conversione esplicita di un carattere Unicode a 16 bit in Rune.Defines an explicit conversion of a 16-bit Unicode character to a Rune.

Explicit(Int32 to Rune)

Definisce una conversione esplicita di un intero con segno a 32 bit in Rune.Defines an explicit conversion of a 32-bit signed integer to a Rune.

Explicit(UInt32 to Rune)

Definisce una conversione esplicita di un intero senza segno a 32 bit in Rune.Defines an explicit conversion of a 32-bit unsigned integer to a Rune.

GreaterThan(Rune, Rune)

Restituisce un valore che indica se l'oggetto Rune specificato è maggiore di un altro oggetto Rune specificato.Returns a value indicating whether a specified Rune is greater than another specified Rune.

GreaterThanOrEqual(Rune, Rune)

Restituisce un valore che indica se l'oggetto Rune specificato è maggiore o uguale a un altro Rune specificato.Returns a value indicating whether a specified Rune is greater than or equal to another specified Rune.

Inequality(Rune, Rune)

Restituisce un valore che indica se due istanze di Rune hanno valori diversi.Returns a value that indicates whether two Rune instances have different values.

LessThan(Rune, Rune)

Restituisce un valore che indica se l'oggetto Rune specificato è minore di un altro oggetto Rune specificato.Returns a value indicating whether a specified Rune is less than another specified Rune.

LessThanOrEqual(Rune, Rune)

Restituisce un valore che indica se l'oggetto Rune specificato è minore o uguale a un altro oggetto Rune specificato.Returns a value indicating whether a specified Rune is less than or equal to another specified Rune.

Implementazioni dell'interfaccia esplicita

IComparable.CompareTo(Object)

Confronta l'istanza corrente con l'oggetto specificato.Compares the current instance to the specified object.

Si applica a