StringInfo.ParseCombiningCharacters(String) Metodo
Definizione
Importante
Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.
Restituisce gli indici di ciascun carattere base, surrogato alto o carattere di controllo all'interno della stringa specificata.
public:
static cli::array <int> ^ ParseCombiningCharacters(System::String ^ str);
public static int[] ParseCombiningCharacters (string str);
static member ParseCombiningCharacters : string -> int[]
Public Shared Function ParseCombiningCharacters (str As String) As Integer()
Parametri
- str
- String
Stringa in cui effettuare la ricerca.
Restituisce
Matrice di interi che contiene gli indici in base zero di ciascun carattere base, surrogato alto o carattere di controllo all'interno della stringa specificata.
Eccezioni
str
è null
.
Esempio
Nel codice riportato di seguito viene illustrata la chiamata al metodo ParseCombiningCharacters. Questo esempio di codice fa parte di un esempio più grande fornito per la StringInfo classe.
using namespace System;
using namespace System::Text;
using namespace System::Globalization;
// Show how to enumerate each real character (honoring surrogates)
// in a string.
void EnumTextElements(String^ combiningChars)
{
// This StringBuilder holds the output results.
StringBuilder^ sb = gcnew StringBuilder();
// Use the enumerator returned from GetTextElementEnumerator
// method to examine each real character.
TextElementEnumerator^ charEnum =
StringInfo::GetTextElementEnumerator(combiningChars);
while (charEnum->MoveNext())
{
sb->AppendFormat("Character at index {0} is '{1}'{2}",
charEnum->ElementIndex, charEnum->GetTextElement(),
Environment::NewLine);
}
// Show the results.
Console::WriteLine("Result of GetTextElementEnumerator:");
Console::WriteLine(sb);
}
// Show how to discover the index of each real character
// (honoring surrogates) in a string.
void EnumTextElementIndexes(String^ combiningChars)
{
// This StringBuilder holds the output results.
StringBuilder^ sb = gcnew StringBuilder();
// Use the ParseCombiningCharacters method to
// get the index of each real character in the string.
array <int>^ textElemIndex =
StringInfo::ParseCombiningCharacters(combiningChars);
// Iterate through each real character showing the character
// and the index where it was found.
for (int i = 0; i < textElemIndex->Length; i++)
{
sb->AppendFormat("Character {0} starts at index {1}{2}",
i, textElemIndex[i], Environment::NewLine);
}
// Show the results.
Console::WriteLine("Result of ParseCombiningCharacters:");
Console::WriteLine(sb);
}
int main()
{
// The string below contains combining characters.
String^ combiningChars = L"a\u0304\u0308bc\u0327";
// Show each 'character' in the string.
EnumTextElements(combiningChars);
// Show the index in the string where each 'character' starts.
EnumTextElementIndexes(combiningChars);
};
// This code produces the following output.
//
// Result of GetTextElementEnumerator:
// Character at index 0 is 'a-"'
// Character at index 3 is 'b'
// Character at index 4 is 'c,'
//
// Result of ParseCombiningCharacters:
// Character 0 starts at index 0
// Character 1 starts at index 3
// Character 2 starts at index 4
using System;
using System.Text;
using System.Globalization;
public sealed class App {
static void Main() {
// The string below contains combining characters.
String s = "a\u0304\u0308bc\u0327";
// Show each 'character' in the string.
EnumTextElements(s);
// Show the index in the string where each 'character' starts.
EnumTextElementIndexes(s);
}
// Show how to enumerate each real character (honoring surrogates) in a string.
static void EnumTextElements(String s) {
// This StringBuilder holds the output results.
StringBuilder sb = new StringBuilder();
// Use the enumerator returned from GetTextElementEnumerator
// method to examine each real character.
TextElementEnumerator charEnum = StringInfo.GetTextElementEnumerator(s);
while (charEnum.MoveNext()) {
sb.AppendFormat(
"Character at index {0} is '{1}'{2}",
charEnum.ElementIndex, charEnum.GetTextElement(),
Environment.NewLine);
}
// Show the results.
Console.WriteLine("Result of GetTextElementEnumerator:");
Console.WriteLine(sb);
}
// Show how to discover the index of each real character (honoring surrogates) in a string.
static void EnumTextElementIndexes(String s) {
// This StringBuilder holds the output results.
StringBuilder sb = new StringBuilder();
// Use the ParseCombiningCharacters method to
// get the index of each real character in the string.
Int32[] textElemIndex = StringInfo.ParseCombiningCharacters(s);
// Iterate through each real character showing the character and the index where it was found.
for (Int32 i = 0; i < textElemIndex.Length; i++) {
sb.AppendFormat(
"Character {0} starts at index {1}{2}",
i, textElemIndex[i], Environment.NewLine);
}
// Show the results.
Console.WriteLine("Result of ParseCombiningCharacters:");
Console.WriteLine(sb);
}
}
// This code produces the following output:
//
// Result of GetTextElementEnumerator:
// Character at index 0 is 'ā̈'
// Character at index 3 is 'b'
// Character at index 4 is 'ç'
//
// Result of ParseCombiningCharacters:
// Character 0 starts at index 0
// Character 1 starts at index 3
// Character 2 starts at index 4
Imports System.Text
Imports System.Globalization
Public Module Example
Public Sub Main()
' The string below contains combining characters.
Dim s As String = "a" + ChrW(&h0304) + ChrW(&h0308) + "bc" + ChrW(&h0327)
' Show each 'character' in the string.
EnumTextElements(s)
' Show the index in the string where each 'character' starts.
EnumTextElementIndexes(s)
End Sub
' Show how to enumerate each real character (honoring surrogates) in a string.
Sub EnumTextElements(s As String)
' This StringBuilder holds the output results.
Dim sb As New StringBuilder()
' Use the enumerator returned from GetTextElementEnumerator
' method to examine each real character.
Dim charEnum As TextElementEnumerator = StringInfo.GetTextElementEnumerator(s)
Do While charEnum.MoveNext()
sb.AppendFormat("Character at index {0} is '{1}'{2}",
charEnum.ElementIndex,
charEnum.GetTextElement(),
Environment.NewLine)
Loop
' Show the results.
Console.WriteLine("Result of GetTextElementEnumerator:")
Console.WriteLine(sb)
End Sub
' Show how to discover the index of each real character (honoring surrogates) in a string.
Sub EnumTextElementIndexes(s As String)
' This StringBuilder holds the output results.
Dim sb As New StringBuilder()
' Use the ParseCombiningCharacters method to
' get the index of each real character in the string.
Dim textElemIndex() As Integer = StringInfo.ParseCombiningCharacters(s)
' Iterate through each real character showing the character and the index where it was found.
For i As Int32 = 0 To textElemIndex.Length - 1
sb.AppendFormat("Character {0} starts at index {1}{2}",
i, textElemIndex(i), Environment.NewLine)
Next
' Show the results.
Console.WriteLine("Result of ParseCombiningCharacters:")
Console.WriteLine(sb)
End Sub
End Module
' The example displays the following output:
'
' Result of GetTextElementEnumerator:
' Character at index 0 is 'ā̈'
' Character at index 3 is 'b'
' Character at index 4 is 'ç'
'
' Result of ParseCombiningCharacters:
' Character 0 starts at index 0
' Character 1 starts at index 3
' Character 2 starts at index 4
Commenti
Unicode Standard definisce una coppia surrogata come rappresentazione di caratteri codificati per un singolo carattere astratto costituito da una sequenza di due unità di codice, dove la prima unità della coppia è un surrogato elevato e la seconda è un surrogato basso. Un surrogato elevato è un punto di codice Unicode nell'intervallo U+D800 tramite U+DBFF e un surrogato basso è un punto di codice Unicode nell'intervallo U+DC00 tramite U+DFFF.
Un carattere di controllo è un carattere per il quale il valore Unicode è U+007F o nell'intervallo U+0000 a U+001F o U+0080 a U+009F.
.NET definisce un elemento di testo come unità di testo visualizzato come singolo carattere, ovvero un grapheme. Un elemento di testo può essere un carattere di base, una coppia surrogata o una sequenza di caratteri combinata. Unicode Standard definisce una sequenza di caratteri combinata come combinazione di un carattere di base e uno o più caratteri di combinazione. Una coppia surrogata può rappresentare un carattere di base o un carattere di combinazione.
Se una sequenza di caratteri combinata non è valida, viene restituito anche ogni carattere di combinazione in tale sequenza.
Ogni indice nella matrice risultante è l'inizio di un elemento di testo, ovvero l'indice del carattere di base o il surrogato elevato.
La lunghezza di ogni elemento viene facilmente calcolata come differenza tra indici successivi. La lunghezza della matrice sarà sempre minore o uguale alla lunghezza della stringa. Ad esempio, data la stringa "\u4f00\u302a\ud800\udc00\u4f01", questo metodo restituisce gli indici 0, 2 e 4.
Membri equivalenti
A partire dalla versione 2.0 di .NET Framework, il metodo e LengthInTextElements la SubstringByTextElements proprietà offrono un'implementazione facile da usare della funzionalità offerta dal ParseCombiningCharacters metodo .
Si applica a
Vedi anche
Commenti e suggerimenti
https://aka.ms/ContentUserFeedback.
Presto disponibile: Nel corso del 2024 verranno gradualmente disattivati i problemi di GitHub come meccanismo di feedback per il contenuto e ciò verrà sostituito con un nuovo sistema di feedback. Per altre informazioni, vedereInvia e visualizza il feedback per