Conversion de RAW(16) d'Oracle en GUID de .NET

Si vous regardez les valeurs impliquées (par paires) de chiffres hexadécimaux, vous pouvez voir que les 7 derniers octets sont les mêmes dans les deux cas, mais les 9 premiers sont un peu inversés.

En partant de votre exemple, mais en réécrivant chaque paire dans le .NET en tant que 00, 11, 22, etc. et en changeant également l'octet pertinent d'Oracle, nous obtenons :

• .NET :

  00112233445566778899AABBCCDDEEFF
  

• Oracle :

  33221100554477668899AABBCCFFEEFF
  

Il devrait donc être assez facile d'écrire du code pour basculer entre les octets pertinents. (Je suis presque sûr d'avoir écrit du code pour faire cela dans un travail précédent, en fait.)

Pour basculer les octets, il vous suffit d'appeler Guid.ToByteArray() et new Guid(byte[]) pour revenir à un Guid .

EDIT :Il se trouve que l'interrupteur ci-dessus est exactement ce que le Guid constructeur fait quand vous lui passez un tableau d'octets :

using System;
using System.Linq;

class Test
{
    static void Main()
    {
        byte[] bytes = Enumerable.Range(0, 16)
                                 .Select(x => x * 16 + x)
                                 .Select(x => (byte) x)
                                 .ToArray();

        Console.WriteLine(BitConverter.ToString(bytes).Replace("-", ""));
        Console.WriteLine(new Guid(bytes).ToString().Replace("-", ""));
    }
}

Impressions :

00112233445566778899AABBCCDDEEFF
33221100554477668899aabbccddeeff

Cela pourrait bien simplifier considérablement l'exécution de la commutation... comment avez-vous obtenu les valeurs pour commencer ? Est-ce juste "comment ils sont affichés dans Oracle" ?

EDIT :Ok, voici quelques fonctions de conversion - si vous avez les données sous forme de texte, elles seront converties dans chaque sens...

using System;
using System.Linq;

class Test
{
    static void Main()
    {
        string oracle = "329DD817216CD6429B989F5201288DBF";
        string dotNet = "17D89D326C2142D69B989F5201288DBF";

        Console.WriteLine(oracle == DotNetToOracle(dotNet));
        Console.WriteLine(dotNet == OracleToDotNet(oracle));
    }

    static string OracleToDotNet(string text)
    {
        byte[] bytes = ParseHex(text);
        Guid guid = new Guid(bytes);
        return guid.ToString("N").ToUpperInvariant();
    }

    static string DotNetToOracle(string text)
    {
        Guid guid = new Guid(text);
        return BitConverter.ToString(guid.ToByteArray()).Replace("-", "");
    }

    static byte[] ParseHex(string text)
    {
        // Not the most efficient code in the world, but
        // it works...
        byte[] ret = new byte[text.Length / 2];
        for (int i = 0; i < ret.Length; i++)
        {
            ret[i] = Convert.ToByte(text.Substring(i * 2, 2), 16);
        }
        return ret;
    }

}