Uso de Guid como String en .NET

En esta entrada me gustaría repasar el uso de Guid.

Muchos programadores de .NET conocen el uso de Guid, pero algunos no han usado un Guid más allá de su valor por defecto, dejando de lado el uso extensivo o particular de Guid, y que muchas veces podría ayudarnos en nuestros desarrollos.

Esta entrada por lo tanto, no pretende explicar Guid como tal, algo que se da por hecho, sino esos usos particulares que muchas veces dejamos de lado.

Si ejecutamos la siguiente instrucción en C#.

var guid = Guid.NewGuid();

Se generará un Guid.
El objeto es de tipo System.Guid y tendrá un aspecto similar a:

5a7939fd-59de-44bd-a092-f5d8434584de

Ahora bien, es posible de acuerdo a la documentación de MSDN que encontrarás en este enlace, convertir el tipo System.Guid a System.String con algunas características adicionales.

De esta forma, podremos convertir un System.Guid en:

• 32 dígitos separados por guiones, incluido entre llaves
• 32 dígitos separados por guiones
• 32 dígitos
• 32 dígitos separados por guiones, encerradas entre paréntesis
• Cuatro valores hexadecimales entre llaves, donde el cuarto valor es un subconjunto de ocho valores hexadecimales que también aparece encerrado entre llaves

Todo esto, convirtiendo el Guid en String con el parámetro B, D, N, P ó X, según corresponda.

De igual manera, una vez convertido un Guid en String, es posible convertir el String en Guid utilizando el método Parse de Guid, pero también podemos utilizar TryParse sino estamos seguros de que la cadena del supuesto Guid sea realmente válida, y evitar así una excepción controlando primero si es un Guid válido.

Llevado este camino de ida y vuelta al código, éste quedaría de la siguiente forma (por ejemplo):

public class Program
{
    public static void Main(string[] args)
    {
        Console.WriteLine();
        Console.WriteLine("Convert Guid to String");
        Console.WriteLine();

        var guid = Guid.NewGuid();
        var guidB = guid.ToString("B");
        var guidD = guid.ToString("D");
        var guidN = guid.ToString("N");
        var guidP = guid.ToString("P");
        var guidX = guid.ToString("X");

        Console.WriteLine($" {guid.GetType()} \t Guid.NewGuid() \t\t {guid}");
        Console.WriteLine($" {guidB.GetType()} \t Guid.NewGuid().ToString('B') \t {guidB}");
        Console.WriteLine($" {guidD.GetType()} \t Guid.NewGuid().ToString('D') \t {guidD}");
        Console.WriteLine($" {guidN.GetType()} \t Guid.NewGuid().ToString('N') \t {guidN}");
        Console.WriteLine($" {guidP.GetType()} \t Guid.NewGuid().ToString('P') \t {guidP}");
        Console.WriteLine($" {guidX.GetType()} \t Guid.NewGuid().ToString('X') \t {guidX}");


        Console.WriteLine();
        Console.WriteLine();
        Console.WriteLine("Convert Guid to String");
        Console.WriteLine();

        Console.WriteLine($" {Guid.Parse(guidB)}");
        Console.WriteLine($" {Guid.Parse(guidD)}");
        Console.WriteLine($" {Guid.Parse(guidN)}");
        Console.WriteLine($" {Guid.Parse(guidP)}");
        Console.WriteLine($" {Guid.Parse(guidX)}");

        Console.ReadKey();
    }
}

¿Y para qué es útil usar un Guid como String?.

En sí, trabajando con colecciones, el uso de Guid es normalmente más rápido que el uso de String.

En cuanto a espacio almacenado en fuentes de datos, es indudable que un String ocupará menos que un Guid si lo formateamos en alguna de sus posibilidades (N por ejemplo).

También hay circunstancias en las que almacenar el String y buscar por él, es más acertado para nuestros propósitos.

Siempre dependerá del contexto, pero es innegable que independientemente del contexto en el que nos podamos mover en un momento dado, conocer que podemos hacer uso de Guid o de un Guid convertido y almacenado en memoria, en la nube, en bases de datos relacionales o NoSQL, es un asunto a tener en cuenta, y cada caso requiere su análisis y estudio (no hay balas de plata).

Evidentemente, no me voy a decantar por un uso único de una u otra forma, ya que como siempre, todo depende.

¡Happy Coding!