Problema con caratteri unicode surrogati in F #

Question

Sto lavorando con stringhe che potrebbero contenere caratteri unicode sostitutivi (non BMP, 4 byte per carattere).

Quando uso il formato "\ Uxxxxxxxxv" per specificare il carattere surrogato in F # - per alcuni caratteri dà risultati diversi rispetto a C#. Per esempio:

C#:

string s = "\U0001D11E"; 
bool c = Char.IsSurrogate(s, 0); 
Console.WriteLine(String.Format("Length: {0}, is surrogate: {1}", s.Length, c)); 

Dà: Length: 2, is surrogate: True

F #:

let s = "\U0001D11E" 
let c = Char.IsSurrogate(s, 0) 
printf "Length: %d, is surrogate: %b" s.Length c 

Dà: Length: 2, is surrogate: false

Nota: alcuni caratteri surrogati funzionano in F # ("\ U0010011", "\ U00100011"), ma alcuni di essi non funzionano.

D: È un errore in F #? Come posso maniglia permesso caratteri Unicode surrogati in stringhe con F # (fa F # ha formato diverso, o solo il modo è quello di utilizzareChar.ConvertFromUtf32 0x1D11E)

Aggiornamento:
s.ToCharArray() dà per F # [| 0xD800; 0xDF41 |]; per C# { 0xD834, 0xDD1E }

Answer 1

Ciò significa ovviamente che F # fa errore durante l'analisi di alcuni valori letterali stringa. Ciò è dimostrato dal fatto che il personaggio che hai menzionato non è BMP, e in UTF-16 dovrebbe essere rappresentato come una coppia di surrogati. I surrogati sono parole nell'intervallo 0xD800-0xDFFF, mentre nessuno dei caratteri nella stringa prodotta rientra in tale intervallo.

Ma l'elaborazione dei surrogati non cambia, poiché il quadro (ciò che è sotto il cofano) è lo stesso.Quindi hai già una risposta nella tua domanda - se hai bisogno di stringhe letterali con caratteri non BMP nel tuo codice, dovresti semplicemente usare Char.ConvertFromUtf32 invece della notazione \ UXXXXXXXX. E tutto il resto dell'elaborazione sarà lo stesso di sempre.

Answer 2

Mi sembra che questo sia qualcosa collegato a diverse forme di normalizzazione. Sia in C# e in F # s.IsNormalized() restituisce vero Ma in C#

s.ToCharArray() ci dà {55348, 56606} // 0xD834, 0xDD1E

e in F #

s.ToCharArray() ci dà {65533, 57422} // 0xFFFD, 0xE04E

E, come probabilmente sapete System.Char.IsSurrogate è implementato nel modo seguente:

public static bool IsSurrogate(char c) 
    { 
     return (c >= HIGH_SURROGATE_START && c <= LOW_SURROGATE_END); 
    } 

dove

HIGH_SURROGATE_START = 0x00d800; 
    LOW_SURROGATE_END = 0x00dfff; 

Quindi, in C# primo carattere (55348) è inferiore LOW_SURROGATE_END ma in F # primo carattere (65533) non è inferiore LOW_SURROGATE_END.

Spero che questo aiuti.

Answer 3

Questo è un bug noto nel compilatore F # fornito con VS2010 (e SP1); la correzione appare nei bit VS11, quindi se hai il VS11 Beta e usi il compilatore F # 3.0, vedrai questo comportamento come previsto.

(Se le altre risposte/commenti qui non forniscono una soluzione adatta, nel frattempo, fatemelo sapere.)