Individuazione del nome del carattere Unicode in .Net

Question

C'è un modo in .Net per scoprire, quale nome Unicode ha un determinato carattere?

In caso contrario, esiste una libreria in grado di farlo?

Answer 1

E 'più facile che mai, in quanto c'è un pacchetto in NuGet nome Unicode Information

Con questa , puoi semplicemente chiamare:

UnicodeInfo.GetName(character) 

Answer 2

Penso che si sta cercando il Encoding.Unicode oggetto

Answer 3

Non credo che ci sia qualcosa di integrato in .NET per identificare questo ... ma c'è un Unicode character database.

Answer 4

Non è una funzionalità incorporata in .NET. È possibile trovare da Charmap.exe, visualizza il nome del punto di codice nella barra di stato. Se è necessario nel proprio programma, è possibile compilare lo Unicode Character Database nella propria app. Attenzione ai diritti d'autore.

Answer 5

Come affermato da NoBugz e MichaelBray .net Non fornire alcuna funzione incorporata per ottenere il nome Unicode dei caratteri.

E si deve utilizzare da Unicode Database caratteri che forniscono bUnicode.o a http://unicode.org/ucd oggi è contenere informazioni complete di tutte le informazioni Unicode 5.2 charcaters (allegato # 44)

Un'altra alternativa è quella di usi da Windows Mappa caratteri wicth È possibile accedervi tramite Start \ Programmi applicazioni \ Accessori \ Utilità di sistema \ Mappa caratteri (win + R => charmap)

E inoltre è possibile utilizzare da Unicode Converter Tools che è uno strumento Open Source a http://unicode.codeplex.com fornisce anche un Interfaccia utente per ottenere informazioni e anche il suo utilizzo da UCD Unicode (allegato # 44) la nota chiave di questo software per Te è che puoi aggiungere EnterPriseAppUnit dll di questa applicazione alla tua alleanza e utilizzo dall'API fornita.

questa Assemblea containsome metodo statico che dà un Char e ritorna nome, HexCode, codice decimale ed ecc

Answer 6

Ecco una soluzione si può attuare immediatamente, come copia/incolla/compilazione.

In primo luogo, scaricare il database Unicode (UCD) qui: http://www.unicode.org/Public/UNIDATA/UnicodeData.txt

Avanti, aggiungere questo codice al progetto per leggere l'UCD e creare un dizionario per la ricerca il nome di un valore .NET char:

string[] unicodedata = File.ReadAllLines("UnicodeData.txt", Encoding.UTF8); 
Dictionary<char,string> charname_map = new Dictionary<char,string>(65536); 
for (int i = 0; i < unicodedata.Length; i++) 
{ 
    string[] fields = unicodedata[i].Split(';'); 
    int char_code = int.Parse(fields[0], NumberStyles.HexNumber); 
    string char_name = fields[1]; 
    if (char_code >= 0 && char_code <= 0xFFFF) //UTF-16 BMP code points only 
    { 
     bool is_range = char_name.EndsWith(", First>"); 
     if (is_range) //add all characters within a specified range 
     { 
      char_name = char_name.Replace(", First", String.Empty); //remove range indicator from name 
      fields = unicodedata[++i].Split(';'); 
      int end_char_code = int.Parse(fields[0], NumberStyles.HexNumber); 
      if (!fields[1].EndsWith(", Last>")) 
       throw new Exception("Expected end-of-range indicator."); 
      for (int code_in_range = char_code; code_in_range <= end_char_code; code_in_range++) 
       charname_map.Add((char)code_in_range, char_name); 
     } 
     else 
      charname_map.Add((char)char_code, char_name); 
    } 
} 

Il file UnicodeData.txt è codificato in UTF-8 e consiste in una riga di informazioni per ciascun punto di codice Unicode. Ogni riga contiene un elenco di campi separati da punti e virgola, in cui il primo campo è il punto di codice Unicode in formato esadecimale (senza prefissi) e il secondo campo è il nome del carattere. Le informazioni sul file e sugli altri campi di ciascuna riga sono disponibili qui: Informazioni sul formato di UCD sono disponibili qui: http://www.unicode.org/reports/tr44/#Format_Conventions

Una volta che si utilizza il codice sopra riportato per creare una mappatura di caratteri ai nomi di caratteri, si basta recuperare dalla mappa con qualcosa di simile:

char c = 'Â'; 
string character_name; 
if (!charname_map.TryGetValue(c, out character_name)) 
    character_name = "<Character Name Missing>"; //character not found in map 
//character_name should now contain "LATIN CAPITAL LETTER A WITH CIRCUMFLEX"; 

suggerisco incorporare il file UnicodeData.txt nelle vostre risorse applicative, e avvolgendo questo codice in una classe, che carica ed analizza il file una volta in un inizializzatore statico . Per rendere il codice più leggibile, è possibile implementare un metodo di estensione in quella classe 'char' come 'GetUnicodeName'. Ho volutamente ristretto i valori all'intervallo da 0 a 0xFFFF, perché è tutto ciò che può contenere un carattere UTF-16 .NET. .NET char in realtà non rappresenta un vero "carattere" (chiamato anche punto di codice), ma piuttosto un'unità di codice Unicode UTF-16, poiché alcuni "caratteri" richiedono effettivamente due unità di codice. Tale coppia di unità di codice è chiamata surrogato alto e basso. I valori sopra 0xFFFF (il valore più grande che un char a 16 bit può memorizzare) sono al di fuori del Basic Multilingual Plane (BMP) e, in base alla codifica UTF-16, richiedono la codifica di due char s. I codici individuali che fanno parte di una coppia sostitutiva finiranno con nomi come "Non uso privato High Surrogate", "Private Use High Surrogate" e "Low Surrogate" con questa implementazione.

Answer 7

Se si utilizza Process Monitor per esaminare i file a cui si accede da charmap.exe, vedrete che apre un file denominato C:\Windows\system32\getuname.dll. Questo file contiene i nomi dei personaggi nelle sue risorse (in realtà le risorse stesse sono in un file .mui in una sottodirectory specifica della cultura).

Quindi tutto ciò che dovete fare è ottenere i nomi da questo file, usando l'API LoadString. Ho scritto una classe di supporto per farlo:

public class Win32ResourceReader : IDisposable 
{ 
    private IntPtr _hModule; 

    public Win32ResourceReader(string filename) 
    { 
     _hModule = LoadLibraryEx(filename, IntPtr.Zero, LoadLibraryFlags.AsDataFile | LoadLibraryFlags.AsImageResource); 
     if (_hModule == IntPtr.Zero) 
      throw Marshal.GetExceptionForHR(Marshal.GetHRForLastWin32Error()); 
    } 

    public string GetString(uint id) 
    { 
     var buffer = new StringBuilder(1024); 
     LoadString(_hModule, id, buffer, buffer.Capacity); 
     if (Marshal.GetLastWin32Error() != 0) 
      throw Marshal.GetExceptionForHR(Marshal.GetHRForLastWin32Error()); 
     return buffer.ToString(); 
    } 

    ~Win32ResourceReader() 
    { 
     Dispose(false); 
    } 

    public void Dispose() 
    { 
     Dispose(true); 
     GC.SuppressFinalize(this); 
    } 

    public void Dispose(bool disposing) 
    { 
     if (_hModule != IntPtr.Zero) 
      FreeLibrary(_hModule); 
     _hModule = IntPtr.Zero; 
    } 

    [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)] 
    static extern int LoadString(IntPtr hInstance, uint uID, StringBuilder lpBuffer, int nBufferMax); 

    [DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)] 
    static extern IntPtr LoadLibraryEx(string lpFileName, IntPtr hReservedNull, LoadLibraryFlags dwFlags); 

    [DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)] 
    static extern bool FreeLibrary(IntPtr hModule); 

    [Flags] 
    enum LoadLibraryFlags : uint 
    { 
     AsDataFile = 0x00000002, 
     AsImageResource = 0x00000020 
    } 
} 

è possibile utilizzarlo in questo modo:

string path = @"C:\Windows\System32\getuname.dll"; 
using (var reader = new Win32ResourceReader(path)) 
{ 
    string name = reader.GetString(0xA9); 
    Console.WriteLine(name); // Copyright Sign 
}