c# - guid a base64, para URL

.net vb.net

Question

Pregunta: ¿hay una mejor manera de hacer eso?

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

DO#

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

Entiendo que la razón por la que está recortando == al final es porque puede estar seguro de que para GUID (de 16 bytes), la cadena codificada siempre terminará con ==. Por lo tanto, se pueden guardar 2 caracteres en cada conversión.

Además del punto @Skurmedal ya mencionado (debería lanzar una excepción en caso de una cadena inválida como entrada), creo que el código que publicaste es lo suficientemente bueno.

Answer 2

Es posible que desee visitar este sitio: http://prettycode.org/2009/11/12/short-guid/

Se ve muy cerca de lo que estás haciendo.

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

Si su método no puede convertir el Base64 pasado a un GUID, ¿no debería lanzar una excepción? Los datos pasados ​​al método son claramente erróneos.

Answer 4

Un problema con el uso de esta técnica para formatear un GUID para su uso en un URL o nombre de archivo es que dos GUID distintos pueden producir dos valores que difieren solo en el caso, por ejemplo:

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

Dado que las URL y los nombres de los archivos a menudo se interpretan como insensibles a las mayúsculas y minúsculas, esto podría provocar colisiones.