guid zu base64, für URL

Question

Frage: Gibt es einen besseren Weg, dies zu tun

?

VB.Net

Function GuidToBase64(ByVal guid As Guid) As String
    Return Convert.ToBase64String(guid.ToByteArray).Replace("/", "-").Replace("+", "_").Replace("=", "")
End Function

Function Base64ToGuid(ByVal base64 As String) As Guid
    Dim guid As Guid
    base64 = base64.Replace("-", "/").Replace("_", "+") & "=="

    Try
        guid = New Guid(Convert.FromBase64String(base64))
    Catch ex As Exception
        Throw New Exception("Bad Base64 conversion to GUID", ex)
    End Try

    Return guid
End Function

C #

public string GuidToBase64(Guid guid)
{
    return Convert.ToBase64String(guid.ToByteArray()).Replace("/", "-").Replace("+", "_").Replace("=", "");
}

public Guid Base64ToGuid(string base64)
{
   Guid guid = default(Guid);
   base64 = base64.Replace("-", "/").Replace("_", "+") + "==";

   try {
       guid = new Guid(Convert.FromBase64String(base64));
   }
   catch (Exception ex) {
       throw new Exception("Bad Base64 conversion to GUID", ex);
   }

   return guid;
}

Answer 1

Ich verstehe, dass der Grund, warum Sie == am Ende sind Clipping ist, dass, weil Sie sicher sein können, dass für GUID (von 16 Bytes), codierte Zeichenfolge wird immer Ende mit ==. So 2 Zeichen können in jeder Umwandlung gespeichert werden.

Neben dem Punkt bereits erwähnt @Skurmedal (sollte eine Ausnahme im Falle einer ungültigen Zeichenfolge als Eingabe werfen), ich glaube, der Code, den Sie geschrieben gerade gut genug ist.

Answer 2

Sie können diese Website überprüfen: http://prettycode.org/2009/11/12/short-guid/

Es sieht ganz in der Nähe zu dem, was Sie tun.

public class ShortGuid
{
    private readonly Guid guid;
    private readonly string value;

    /// <summary>Create a 22-character case-sensitive short GUID.</summary>
    public ShortGuid(Guid guid)
    {
        if (guid == null)
        {
            throw new ArgumentNullException("guid");
        }

        this.guid = guid;
        this.value = Convert.ToBase64String(guid.ToByteArray())
            .Substring(0, 22)
            .Replace("/", "_")
            .Replace("+", "-");
    }

    /// <summary>Get the short GUID as a string.</summary>
    public override string ToString()
    {
        return this.value;
    }

    /// <summary>Get the Guid object from which the short GUID was created.</summary>
    public Guid ToGuid()
    {
        return this.guid;
    }

    /// <summary>Get a short GUID as a Guid object.</summary>
    /// <exception cref="System.ArgumentNullException"></exception>
    /// <exception cref="System.FormatException"></exception>
    public static ShortGuid Parse(string shortGuid)
    {
        if (shortGuid == null)
        {
            throw new ArgumentNullException("shortGuid");
        }
        else if (shortGuid.Length != 22)
        {
            throw new FormatException("Input string was not in a correct format.");
        }

        return new ShortGuid(new Guid(Convert.FromBase64String
            (shortGuid.Replace("_", "/").Replace("-", "+") + "==")));
    }

    public static implicit operator String(ShortGuid guid)
    {
        return guid.ToString();
    }

    public static implicit operator Guid(ShortGuid shortGuid)
    {
        return shortGuid.guid;
    }
}

Answer 3

Ein Problem bei dieser Technik eine GUID formatiert wird für die Verwendung in einer URL oder Dateinamen ist, dass zwei unterschiedliche GUIDs zwei Werte erzeugen können, die nur im Fall unterscheiden, z.

    var b1 = GuidToBase64(new Guid("c9d045f3-e21c-46d0-971d-b92ebc2ab83c"));
    var b2 = GuidToBase64(new Guid("c9d045f3-e21c-46d0-971d-b92ebc2ab8a4"));
    Console.WriteLine(b1);  // 80XQyRzi0EaXHbkuvCq4PA
    Console.WriteLine(b2);  // 80XQyRzi0EaXHbkuvCq4pA

Da URLs manchmal als Groß- und Kleinschreibung interpretiert werden und in Windows-Dateipfade und Dateinamen Groß- und Kleinschreibung. dies zu Kollisionen führen kann.

Answer 4

Wenn Ihre Methode kann die Base64 nicht konvertieren, um sie auf eine GUID übergeben, sollten Sie nicht eine Ausnahme auslösen? Die Daten werden an die Methode übergeben ist eindeutig falsch empfangenen.