So konvertieren Sie einen UTF-8-string in Unicode?

Also das Problem ist, dass UTF-8-code Einheit Werte gespeichert wurden, als eine Folge von 16-bit-code-Einheiten in einem C# -string. Sie müssen einfach nur sicherstellen, dass jeder code-Einheit ist innerhalb des Bereichs von einem byte, kopieren Sie diese Werte in Byte umwandeln und dann die neuen UTF-8-byte-Sequenz in UTF-16.

public static string DecodeFromUtf8(this string utf8String)
{
    //copy the string as UTF-8 bytes.
    byte[] utf8Bytes = new byte[utf8String.Length];
    for (int i=0;i<utf8String.Length;++i) {
        //Debug.Assert( 0 <= utf8String[i] && utf8String[i] <= 255, "the char must be in byte's range");
        utf8Bytes[i] = (byte)utf8String[i];
    }

    return Encoding.UTF8.GetString(utf8Bytes,0,utf8Bytes.Length);
}

DecodeFromUtf8("d\u00C3\u00A9j\u00C3\u00A0"); //déjà

Dies ist einfach, jedoch wäre es am besten, um die Ursache; der Ort, wo jemand kopieren UTF-8-code-Einheiten in 16-bit-code-Einheiten. Der wahrscheinliche Täter ist jemand Konvertierung von bytes in ein C# string mit der falschen Codierung. E. g. Encoding.Default.GetString(utf8Bytes, 0, utf8Bytes.Length).

Alternativ, wenn Sie sicher sind, dass Sie wissen, die falsche Codierung, die verwendet wurde, um zu produzieren die Zeichenfolge, und dass eine falsche Codierung transformation verlustfrei (in der Regel der Fall, wenn die falsche Codierung ist ein single-byte-Codierung), dann kann man einfach die inverse Codierung Schritt, um die ursprüngliche UTF-8-Daten, und dann können Sie die korrekte Konvertierung von UTF-8-bytes:

public static string UndoEncodingMistake(string mangledString, Encoding mistake, Encoding correction)
{
    //the inverse of `mistake.GetString(originalBytes);`
    byte[] originalBytes = mistake.GetBytes(mangledString);
    return correction.GetString(originalBytes);
}

UndoEncodingMistake("d\u00C3\u00A9j\u00C3\u00A0", Encoding(1252), Encoding.UTF8);

Wenn Sie eine UTF-8-Zeichenkette, wobei jedes byte richtig ist ('Ö' -> [195, 0] , [150, 0]), Sie können die folgenden:

public static string Utf8ToUtf16(string utf8String)
{
    /***************************************************************
     * Every .NET string will store text with the UTF-16 encoding, *
     * known as Encoding.Unicode. Other encodings may exist as     *
     * Byte-Array or incorrectly stored with the UTF-16 encoding.  *
     *                                                             *
     * UTF-8 = 1 bytes per char                                    *
     *    ["100" for the ansi 'd']                                 *
     *    ["206" and "186" for the russian '?']                    *
     *                                                             *
     * UTF-16 = 2 bytes per char                                   *
     *    ["100, 0" for the ansi 'd']                              *
     *    ["186, 3" for the russian '?']                           *
     *                                                             *
     * UTF-8 inside UTF-16                                         *
     *    ["100, 0" for the ansi 'd']                              *
     *    ["206, 0" and "186, 0" for the russian '?']              *
     *                                                             *
     * First we need to get the UTF-8 Byte-Array and remove all    *
     * 0 byte (binary 0) while doing so.                           *
     *                                                             *
     * Binary 0 means end of string on UTF-8 encoding while on     *
     * UTF-16 one binary 0 does not end the string. Only if there  *
     * are 2 binary 0, than the UTF-16 encoding will end the       *
     * string. Because of .NET we don't have to handle this.       *
     *                                                             *
     * After removing binary 0 and receiving the Byte-Array, we    *
     * can use the UTF-8 encoding to string method now to get a    *
     * UTF-16 string.                                              *
     *                                                             *
     ***************************************************************/

    //Get UTF-8 bytes and remove binary 0 bytes (filler)
    List<byte> utf8Bytes = new List<byte>(utf8String.Length);
    foreach (byte utf8Byte in utf8String)
    {
        //Remove binary 0 bytes (filler)
        if (utf8Byte > 0) {
            utf8Bytes.Add(utf8Byte);
        }
    }

    //Convert UTF-8 bytes to UTF-16 string
    return Encoding.UTF8.GetString(utf8Bytes.ToArray());
}

In meinem Fall die DLL Ergebnis ist ein UTF-8 string zu, aber leider ist die UTF-8-string interpretiert, wenn UTF-16-Codierung ('Ö' -> [195, 0], [19, 32]).
Also der ANSI '–' 150 konvertiert die UTF-16 -'–', was ist 8211. Wenn Sie dieser Fall zu, können Sie den folgenden statt:

public static string Utf8ToUtf16(string utf8String)
{
    //Get UTF-8 bytes by reading each byte with ANSI encoding
    byte[] utf8Bytes = Encoding.Default.GetBytes(utf8String);

    //Convert UTF-8 bytes to UTF-16 bytes
    byte[] utf16Bytes = Encoding.Convert(Encoding.UTF8, Encoding.Unicode, utf8Bytes);

    //Return UTF-16 bytes as UTF-16 string
    return Encoding.Unicode.GetString(utf16Bytes);
}

Oder die Native-Methode:

[DllImport("kernel32.dll")]
private static extern Int32 MultiByteToWideChar(UInt32 CodePage, UInt32 dwFlags, [MarshalAs(UnmanagedType.LPStr)] String lpMultiByteStr, Int32 cbMultiByte, [Out, MarshalAs(UnmanagedType.LPWStr)] StringBuilder lpWideCharStr, Int32 cchWideChar);

public static string Utf8ToUtf16(string utf8String)
{
    Int32 iNewDataLen = MultiByteToWideChar(Convert.ToUInt32(Encoding.UTF8.CodePage), 0, utf8String, -1, null, 0);
    if (iNewDataLen > 1)
    {
        StringBuilder utf16String = new StringBuilder(iNewDataLen);
        MultiByteToWideChar(Convert.ToUInt32(Encoding.UTF8.CodePage), 0, utf8String, -1, utf16String, utf16String.Capacity);

        return utf16String.ToString();
    }
    else
    {
        return String.Empty;
    }
}

Wenn Sie müssen es anders herum sehen Utf16ToUtf8.
Hoffe ich konnte helfen.