Fixed ShortGuid | C# Online Compiler

Fixed ShortGuid by Ryan@Stickman

using System;
#nullable enable

using System.Buffers.Text;
using System.Diagnostics;
using System.Runtime.InteropServices;


public class Program
{
	public static void Main()
	{
		Console.WriteLine("Hello World");
		
		Guid guid = new Guid("69190000-08DC-6C24-53B9-08DBBF25527F");
		Console.WriteLine(guid.ToString());
		
		ShortGuid shortGuid = new ShortGuid(guid);
		Console.WriteLine(shortGuid);
		
		Console.WriteLine();
		
		ShortGuid shortGuid2 = new ShortGuid("AAAZadwIJGxTuQjbvyVSfw");
		Console.WriteLine(shortGuid2);
		Console.WriteLine(shortGuid2.Guid);
		
		Console.WriteLine();
		
		Console.WriteLine(new ShortGuid(new Guid("69190000-08dc-6c24-53b9-08dbbf25527f")).ToString());
		Console.WriteLine(new ShortGuid(new Guid("69190000-08dc-6c24-5351-08dbbf25527f")).ToString());
		Console.WriteLine(new ShortGuid("AAAZadwIJGxTUQjbvyVSfw").Guid.ToString());
		
		int count;
        int testCount = 1000000; // setting total test count to 100,000

        for (count = 0; count < testCount; count++)
        {
            Guid originalGuid = Guid.NewGuid(); // Generate a new Guid
            shortGuid = new ShortGuid(originalGuid); // Convert to ShortGuid
            Guid convertedBackGuid = new ShortGuid(shortGuid.ToString()).Guid; // Convert back to Guid
			
            // Compare original Guid and converted-back Guid
            if (!originalGuid.Equals(convertedBackGuid))
            {
                // If they don't match, print the details
                Console.WriteLine($"Mismatch found on iteration {count + 1}!");
                Console.WriteLine($"Original Guid: {originalGuid}");
                Console.WriteLine($"ShortGuid: {shortGuid}");
                Console.WriteLine($"Converted Back Guid: {convertedBackGuid}");
                return;
            }
        }

        Console.WriteLine("Test completed successfully with {0} iterations", count);
	}
}

/// <summary>
/// A convenience wrapper struct for dealing with URL-safe Base64 encoded globally unique identifiers (GUID),
/// making a shorter string value (22 vs 36 characters long).
/// </summary>
/// <remarks>
/// What is URL-safe Base64? That's just a Base64 string with well known special characters replaced (/, +)
/// or removed (==).
///
/// <para>NB: As of version 2.0.0, <see cref="ShortGuid.Decode(ReadOnlySpan{Char})"/> performs a sanity check when decoding
/// strings to ensure they haven't been tampered with, i.e. allowing the end of a Base64 string to be tweaked
/// where it still produces that same byte array to create the underlying Guid. Effectively there is "unused
/// space" in the Base64 string which is ignored, but will now result in an <see cref="FormatException"/> being
/// thrown.</para>
///
/// <para>ShortGuid will never produce an invalid string, however if one is supplied it, could result in an
/// unintended collision where multiple URL-safe Base64 strings can point to the same Guid. To avoid this
/// uncertainty, a round-trip check is performed to ensure a 1-1 match with the input string.</para>
///
/// <para>Stick with version 1.1.0 if you require the old behaviour with opt-in strict parsing.</para>
/// </remarks>
[DebuggerDisplay("{Value}")]
public readonly struct ShortGuid : IEquatable<Guid>, IEquatable<ShortGuid>, IEquatable<string>
{
    private const char EqualsChar = '=';
    private const char HyphenChar = '-';
    private const char UnderscoreChar = '_';
    private const char SlashChar = '/';
    private const byte SlashByte = (byte)'/';
    private const char PlusChar = '+';
    private const byte PlusByte = (byte)'+';

#pragma warning disable IDE0032 // Use auto property
    private readonly Guid underlyingGuid;
    private readonly string encodedValue;
#pragma warning restore IDE0032 // Use auto property

    /// <summary>
    /// Initializes a new instance of the <see cref="ShortGuid"/> struct from the given
    /// <paramref name="value"/> URL-safe Base64 encoded string.
    /// <para>See also <seealso cref="TryParse(ReadOnlySpan{char}, out ShortGuid)" /> which will try to coerce the
    /// the value from URL-safe Base64 or normal Guid string.</para></summary>
    /// <param name="value">A 22 character URL-safe Base64 encoded string to decode.</param>
    public ShortGuid(string value)
    {
        encodedValue = value;
        underlyingGuid = Decode(value);
    }

    /// <summary>
    /// Initializes a new instance of the <see cref="ShortGuid"/> struct from the given <paramref name="guid"/>.
    /// </summary>
    /// <param name="guid">The <see cref="System.Guid" /> to encode.</param>
    public ShortGuid(Guid guid)
    {
        underlyingGuid = guid;
        encodedValue = Encode(underlyingGuid);
    }

    /// <summary>
    /// Gets the underlying <see cref="System.Guid" /> for the encoded ShortGuid.
    /// </summary>
    /// <value>
    /// The unique identifier.
    /// </value>
    public Guid Guid => underlyingGuid;

    /// <summary>
    /// Converts to string.
    /// </summary>
    /// <returns>
    /// A <see cref="string" /> that represents this instance.
    /// </returns>
    public override string ToString() => Value;

    /// <summary>
    /// Gets the encoded string value of the <see cref="Guid" /> as a URL-safe Base64 string.
    /// </summary>
    /// <value>
    /// The value.
    /// </value>
    public string Value => encodedValue;

    /// <summary>
    /// A read-only instance of the ShortGuid struct whose value is guaranteed to be all zeroes i.e. equivalent
    /// to <see cref="Guid.Empty" />.
    /// </summary>
    public static readonly ShortGuid Empty = new(Guid.Empty);

    /// <summary>
    /// Encodes the given <see cref="System.Guid" /> as an encoded ShortGuid string. The encoding is
    /// similar to Base64, with some non-URL safe characters replaced, and padding removed, resulting
    /// in a 22 character string.
    /// </summary>
    /// <param name="guid">The <see cref="System.Guid" /> to encode.</param>
    /// <returns>
    /// A 22 character ShortGuid URL-safe Base64 string.
    /// </returns>
    public static string Encode(Guid guid)
    {
        Span<byte> guidBytes = stackalloc byte[16];
        Span<byte> base64Bytes = stackalloc byte[24];

 #if NET8_0_OR_GREATER
        MemoryMarshal.TryWrite(guidBytes, in guid);
#else
        MemoryMarshal.TryWrite(guidBytes, ref guid);
#endif
		
        Base64.EncodeToUtf8(guidBytes, base64Bytes, out _, out _);

        Span<char> finalChars = stackalloc char[22];

        for (int i = 0; i < 22; i++)
        {
            finalChars[i] = base64Bytes[i] switch
            {
                SlashByte => UnderscoreChar,
                PlusByte => HyphenChar,
                _ => (char)base64Bytes[i]
            };
        }

        return new string(finalChars);
    }

    /// <summary>
    /// Encodes the given value as an encoded ShortGuid string. The encoding is similar to Base64, with
    /// some non-URL safe characters replaced, and padding removed, resulting in a 22 character string.
    /// </summary>
    /// <param name="value">Any valid <see cref="System.Guid" /> string.</param>
    /// <returns>
    /// A 22 character ShortGuid URL-safe Base64 string.
    /// </returns>
    public static ReadOnlySpan<char> Encode(ReadOnlySpan<char> value)
    {
        Guid guid = Guid.Parse(value);
        return Encode(guid);
    }

    /// <summary>
    /// Decodes the given value from a 22 character URL-safe Base64 string to a <see cref="System.Guid" />.
    /// <para>Supports: ShortGuid format only.</para><para>See also <seealso cref="TryDecode(ReadOnlySpan{char}, out Guid)" /> or <seealso cref="TryParse(ReadOnlySpan{char}, out Guid)" />.</para>
    /// </summary>
    /// <param name="value">A 22 character URL-safe Base64 encoded ReadOnlySpan of char to decode.</param>
    /// <returns>
    /// A new <see cref="System.Guid" /> instance from the parsed string.
    /// </returns>
    /// <exception cref="ArgumentException">A ShortGuid must be exactly 22 characters long. Received a {value.Length} character string.</exception>
    /// <exception cref="FormatException">Invalid strict ShortGuid encoded string. The string '{new string(value)}' " +
    ///                 $"but failed a round-trip test expecting '{new string(sanityCheck)}'.</exception>
    public static Guid Decode(ReadOnlySpan<char> value)
    {
        // avoid parsing larger strings/blobs
        if (value.Length != 22)
        {
            throw new ArgumentException($"A ShortGuid must be exactly 22 characters long. Received a {value.Length} character string.", paramName: nameof(value));
        }

        Span<char> base64Chars = stackalloc char[24];

        for (int i = 0; i < 22; i++)
        {
            base64Chars[i] = value[i] switch
            {
                HyphenChar => PlusChar,
                UnderscoreChar => SlashChar,
                _ => value[i]
            };
        }

        base64Chars[22] = EqualsChar;
        base64Chars[23] = EqualsChar;

        Span<byte> idBytes = stackalloc byte[16];
        Convert.TryFromBase64Chars(base64Chars, idBytes, out _);

        Guid guid = new(idBytes);
        string sanityCheck = Encode(guid);
        return !value.SequenceEqual(sanityCheck)
            ? throw new FormatException(
                $"Invalid strict ShortGuid encoded string. The string '{new string(value)}' " +
                $"but failed a round-trip test expecting '{new string(sanityCheck)}'.")
            : guid;
    }

    /// <summary>
    /// <para>Supports ShortGuid format only.</para>
    /// <para>Attempts to decode the given value from a 22 character URL-safe Base64 string to
    /// a <see cref="System.Guid"/>.</para>
    /// <para>The difference between TryParse and TryDecode:</para>
    /// <list type="number">
    ///     <item>
    ///         <term><see cref="TryParse(ReadOnlySpan{char}, out ShortGuid)"/></term>
    ///         <description>Supports: Guid &amp; ShortGuid;</description>
    ///         <description>Tries to parse first as a <see cref="ShortGuid"/>, then as a
    ///         <see cref="System.Guid"/>, outputs the <see cref="ShortGuid"/> instance.</description>
    ///     </item>
    ///     <item>
    ///         <term><see cref="TryParse(ReadOnlySpan{char}, out Guid)"/></term>
    ///         <description>Supports: Guid &amp; ShortGuid;</description>
    ///         <description>Tries to parse first as a <see cref="ShortGuid"/>, then as a
    ///         <see cref="System.Guid"/>, outputs the underlying <see cref="System.Guid"/>.</description>
    ///     </item>
    ///     <item>
    ///         <term><see cref="TryDecode(ReadOnlySpan{char}, out Guid)"/></term>
    ///         <description>Supports: ShortGuid;</description>
    ///         <description>Tries to decode a 22 character URL-safe Base64 string as a
    ///         <see cref="ShortGuid"/> only, but outputs the result as a <see cref="System.Guid"/> - this method.</description>
    ///     </item>
    /// </list>
    /// </summary>
    /// <param name="value">The ShortGuid encoded string to decode.</param>
    /// <param name="guid">A new <see cref="System.Guid"/> instance from the parsed string.</param>
    /// <returns>A boolean indicating if the decode was successful.</returns>
    public static bool TryDecode(ReadOnlySpan<char> value, out Guid guid)
    {
        try
        {
            guid = Decode(value);
            return true;
        }
        catch
        {
            guid = Guid.Empty;
            return false;
        }
    }

    /// <summary>
    /// <para>Tries to parse the value from either a 22 character URL-safe Base64 string or
    /// a <see cref="System.Guid"/> string, and outputs a <see cref="ShortGuid"/> instance.</para>
    /// <para>Supports ShortGuid &amp; Guid formats.</para>
    /// <para>The difference between TryParse and TryDecode:</para>
    /// <list type="number">
    ///     <item>
    ///         <term><see cref="TryParse(ReadOnlySpan{char}, out ShortGuid)"/></term>
    ///         <description>Supports: Guid &amp; ShortGuid; </description>
    ///         <description>Tries to parse first as a <see cref="ShortGuid"/>, then as a
    ///         <see cref="System.Guid"/>, outputs the <see cref="ShortGuid"/> instance - this method.</description>
    ///     </item>
    ///     <item>
    ///         <term><see cref="TryParse(ReadOnlySpan{char}, out Guid)"/></term>
    ///         <description>Supports: Guid &amp; ShortGuid;</description>
    ///         <description>Tries to parse first as a <see cref="ShortGuid"/>, then as a
    ///         <see cref="System.Guid"/>, outputs the <see cref="System.Guid"/>.</description>
    ///     </item>
    ///     <item>
    ///         <term><see cref="TryDecode(ReadOnlySpan{char}, out Guid)"/></term>
    ///         <description>Supports: ShortGuid;</description>
    ///         <description>Tries to decode a 22 character URL-safe Base64 string as a
    ///         <see cref="ShortGuid"/> only, but outputs the result as a <see cref="System.Guid"/>.</description>
    ///     </item>
    /// </list>
    /// </summary>
    /// <param name="value">The ShortGuid encoded string or string representation of a Guid.</param>
    /// <param name="shortGuid">A new <see cref="ShortGuid" /> instance from the parsed string.</param>
    /// <returns>
    ///   <c>true</c> if parsing was successful; otherwise, <c>false</c>.
    /// </returns>
    public static bool TryParse(ReadOnlySpan<char> value, out ShortGuid shortGuid)
    {
        switch (value)
        {
            case { Length: 22 } when TryDecode(value, out Guid sg):
                shortGuid = sg;
                return true;

            case { Length: 36 } when Guid.TryParse(value, out Guid guid):
                {
                    shortGuid = guid;
                    return true;
                }

            default:
                shortGuid = Empty;
                return false;
        }
    }

    /// <summary>
    /// <para>Supports ShortGuid &amp; Guid formats.</para>
    /// <para>Tries to parse the value either a 22 character URL-safe Base64 string or
    /// <see cref="System.Guid"/> string, and outputs the <see cref="Guid"/> value.</para>
    /// <para>The difference between TryParse and TryDecode:</para>
    /// <list type="number">
    ///     <item>
    ///         <term><see cref="TryParse(ReadOnlySpan{char}, out ShortGuid)"/></term>
    ///         <description>Supports: Guid &amp; ShortGuid;</description>
    ///         <description>Tries to parse first as a <see cref="ShortGuid"/>, then as a
    ///         <see cref="System.Guid"/>, outputs the <see cref="ShortGuid"/> instance.</description>
    ///     </item>
    ///     <item>
    ///         <term><see cref="TryParse(ReadOnlySpan{char}, out Guid)"/></term>
    ///         <description>Supports: Guid &amp; ShortGuid;</description>
    ///         <description>Tries to parse first as a <see cref="ShortGuid"/>, then as a
    ///         <see cref="System.Guid"/>, outputs the <see cref="System.Guid"/> - this method.</description>
    ///     </item>
    ///     <item>
    ///         <term><see cref="TryDecode(ReadOnlySpan{char}, out Guid)"/></term>
    ///         <description>Supports: ShortGuid;</description>
    ///         <description>Tries to decode a 22 character URL-safe Base64 string as a
    ///         <see cref="ShortGuid"/> only, outputting the result as a <see cref="System.Guid"/>.</description>
    ///     </item>
    /// </list>
    /// </summary>
    /// <param name="value">The ShortGuid encoded string or string representation of a Guid.</param>
    /// <param name="guid">A new <see cref="System.Guid"/> instance from the parsed string.</param>
    /// <returns>A boolean indicating if the parse was successful.</returns>
    public static bool TryParse(ReadOnlySpan<char> value, out Guid guid)
    {
        switch (value)
        {
            case { Length: 22 } when TryDecode(value, out guid):
            case { Length: 36 } when Guid.TryParse(value, out guid):
                return true;

            default:
                guid = Guid.Empty;
                return false;
        }
    }

    /// <summary>
    /// Indicates whether the current object is equal to another object of the same type.
    /// </summary>
    /// <param name="other">An object to compare with this object.</param>
    /// <returns>
    ///   <see langword="true" /> if the current object is equal to the <paramref name="other" /> parameter; otherwise, <see langword="false" />.
    /// </returns>
    public bool Equals(Guid other)
    {
        return Equals((object)other);
    }

    /// <summary>
    /// Indicates whether the current object is equal to another object of the same type.
    /// </summary>
    /// <param name="other">An object to compare with this object.</param>
    /// <returns>
    ///   <see langword="true" /> if the current object is equal to the <paramref name="other" /> parameter; otherwise, <see langword="false" />.
    /// </returns>
    public bool Equals(ShortGuid other)
    {
        return Equals((object)other);
    }

    /// <summary>
    /// Indicates whether the current object is equal to another object of the same type.
    /// </summary>
    /// <param name="other">An object to compare with this object.</param>
    /// <returns>
    ///   <see langword="true" /> if the current object is equal to the <paramref name="other" /> parameter; otherwise, <see langword="false" />.
    /// </returns>
    public bool Equals(string? other)
    {
        return other is not null && Equals((object)other);
    }

    /// <summary>
    /// Returns a value indicating whether this instance and a specified object represent the same type and value.
    /// <para>Compares for equality against other string, Guid and ShortGuid types.</para>
    /// </summary>
    /// <param name="obj">The <see cref="object" /> to compare with this instance.</param>
    /// <returns>
    ///   <c>true</c> if the specified <see cref="object" /> is equal to this instance; otherwise, <c>false</c>.
    /// </returns>
    public override bool Equals(object? obj)
    {
        if (obj is ShortGuid shortGuid)
        {
            return underlyingGuid.Equals(shortGuid.underlyingGuid);
        }

        if (obj is Guid guid)
        {
            return underlyingGuid.Equals(guid);
        }

        if (obj is string span)
        {
            // Try a ShortGuid string
            if (TryDecode(span, out guid))
            {
                return underlyingGuid.Equals(guid);
            }

            if (Guid.TryParse(span, out guid))
            {
                return underlyingGuid.Equals(guid);
            }
        }

        if (obj is char[] chars)
        {
            // Try a ShortGuid string
            if (TryDecode(chars, out guid))
            {
                return underlyingGuid.Equals(guid);
            }

            if (Guid.TryParse(chars, out guid))
            {
                return underlyingGuid.Equals(guid);
            }
        }

        return false;
    }

    /// <summary>
    /// Returns the hash code for the underlying <see cref="System.Guid" />.
    /// </summary>
    /// <returns>
    /// The hash code for the underlying <see cref="System.Guid" />.
    /// </returns>
    public override int GetHashCode() => underlyingGuid.GetHashCode();

    /// <summary>
    /// Initialises a new instance of a ShortGuid using <see cref="M:Guid.NewGuid()" />.
    /// <para>Equivalent of calling: <c>`new ShortGuid(Guid.NewGuid())`</c>.</para>
    /// </summary>
    /// <returns>
    /// A new <see cref="ShortGuid" /> instance initialized with a new <see cref="Guid" />.
    /// </returns>
    /// <remarks>
    /// NewId is designed to solve a specific problem. It's for when you want a unique ID,
    /// but you want them to generally be sortable, and semi-predictable.
    /// <see href="https://andrewlock.net/generating-sortable-guids-using-newid/" />.
    /// </remarks>
    public static ShortGuid NewGuid() => new(Guid.NewGuid());

    /// <summary>
    /// Implements the operator ==.
    /// </summary>
    /// <param name="a">a.</param>
    /// <param name="b">The b.</param>
    /// <returns>
    /// The result of the operator.
    /// </returns>
    public static bool operator ==(ShortGuid a, ShortGuid b)
        => a.underlyingGuid == b.underlyingGuid;

    /// <summary>
    /// Implements the operator ==.
    /// </summary>
    /// <param name="a">a.</param>
    /// <param name="b">The b.</param>
    /// <returns>
    /// The result of the operator.
    /// </returns>
    public static bool operator ==(ShortGuid a, Guid b)
        => a.underlyingGuid == b;

    /// <summary>
    /// Implements the operator ==.
    /// </summary>
    /// <param name="a">a.</param>
    /// <param name="b">The b.</param>
    /// <returns>
    /// The result of the operator.
    /// </returns>
    public static bool operator ==(Guid a, ShortGuid b)
        => b == a;

    /// <summary>
    /// Implements the operator !=.
    /// </summary>
    /// <param name="a">a.</param>
    /// <param name="b">The b.</param>
    /// <returns>
    /// The result of the operator.
    /// </returns>
    public static bool operator !=(ShortGuid a, ShortGuid b)
        => a.underlyingGuid != b.underlyingGuid;

    /// <summary>
    /// Implements the operator !=.
    /// </summary>
    /// <param name="a">a.</param>
    /// <param name="b">The b.</param>
    /// <returns>
    /// The result of the operator.
    /// </returns>
    public static bool operator !=(ShortGuid a, Guid b)
        => a.underlyingGuid != b;

    /// <summary>
    /// Implements the operator !=.
    /// </summary>
    /// <param name="a">a.</param>
    /// <param name="b">The b.</param>
    /// <returns>
    /// The result of the operator.
    /// </returns>
    public static bool operator !=(Guid a, ShortGuid b)
        => b != a;

    /// <summary>
    /// Performs an implicit conversion from <see cref="ShortGuid"/> to <see cref="ReadOnlySpan{char}"/>.
    /// </summary>
    /// <param name="shortGuid">The short unique identifier.</param>
    /// <returns>
    /// The result of the conversion.
    /// </returns>
    public static implicit operator ReadOnlySpan<char>(ShortGuid shortGuid) => shortGuid.Value;

    /// <summary>
    /// Performs an implicit conversion from <see cref="ShortGuid"/> to <see cref="string"/>.
    /// </summary>
    /// <param name="shortGuid">The short unique identifier.</param>
    /// <returns>
    /// The result of the conversion.
    /// </returns>
    public static implicit operator string(ShortGuid shortGuid) => shortGuid.Value;

    /// <summary>
    /// Performs an implicit conversion from <see cref="ShortGuid"/> to <see cref="Guid"/>.
    /// </summary>
    /// <param name="shortGuid">The short unique identifier.</param>
    /// <returns>
    /// The result of the conversion.
    /// </returns>
    public static implicit operator Guid(ShortGuid shortGuid) => shortGuid.underlyingGuid;

    /// <summary>
    /// Performs an implicit conversion from <see cref="Nullable{string}"/> to <see cref="ShortGuid"/>.
    /// </summary>
    /// <param name="value">The value.</param>
    /// <returns>
    /// The result of the conversion.
    /// </returns>
    /// <exception cref="FormatException">ShortGuid should contain 22 Base64 characters "
    ///                                   + "or 32 characters with 4 dashes (xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx).</exception>
    public static implicit operator ShortGuid(string? value)
    {
        if (!string.IsNullOrWhiteSpace(value) && TryParse(value, out ShortGuid shortGuid))
        {
            return shortGuid;
        }

#pragma warning disable S125 // Sections of code should not be commented out
        //throw new FormatException("ShortGuid should contain 22 Base64 characters " + "or 32 characters with 4 dashes (xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx).");
        return Empty;
#pragma warning restore S125 // Sections of code should not be commented out
    }

    /// <summary>
    /// Performs an implicit conversion from <see cref="Guid"/> to <see cref="ShortGuid"/>.
    /// </summary>
    /// <param name="guid">The unique identifier.</param>
    /// <returns>
    /// The result of the conversion.
    /// </returns>
    public static implicit operator ShortGuid(Guid guid)
        => guid == Guid.Empty
            ? Empty
            : new ShortGuid(guid);
}

​x
 
using System;
#nullable enable
​
using System.Buffers.Text;
using System.Diagnostics;
using System.Runtime.InteropServices;
​
​
public class Program
{
    public static void Main()
    {
        Console.WriteLine("Hello World");
        
        Guid guid = new Guid("69190000-08DC-6C24-53B9-08DBBF25527F");
        Console.WriteLine(guid.ToString());
        
        ShortGuid shortGuid = new ShortGuid(guid);
        Console.WriteLine(shortGuid);
        
        Console.WriteLine();
        
        ShortGuid shortGuid2 = new ShortGuid("AAAZadwIJGxTuQjbvyVSfw");
        Console.WriteLine(shortGuid2);
        Console.WriteLine(shortGuid2.Guid);
        
        Console.WriteLine();
        
        Console.WriteLine(new ShortGuid(new Guid("69190000-08dc-6c24-53b9-08dbbf25527f")).ToString());
        Console.WriteLine(new ShortGuid(new Guid("69190000-08dc-6c24-5351-08dbbf25527f")).ToString());
        Console.WriteLine(new ShortGuid("AAAZadwIJGxTUQjbvyVSfw").Guid.ToString());
        
        int count;
        int testCount = 1000000; // setting total test count to 100,000
​
        for (count = 0; count < testCount; count++)
        {
            Guid originalGuid = Guid.NewGuid(); // Generate a new Guid
            shortGuid = new ShortGuid(originalGuid); // Convert to ShortGuid
            Guid convertedBackGuid = new ShortGuid(shortGuid.ToString()).Guid; // Convert back to Guid
            
            // Compare original Guid and converted-back Guid
            if (!originalGuid.Equals(convertedBackGuid))
            {
                // If they don't match, print the details
                Console.WriteLine($"Mismatch found on iteration {count + 1}!");
                Console.WriteLine($"Original Guid: {originalGuid}");
                Console.WriteLine($"ShortGuid: {shortGuid}");
                Console.WriteLine($"Converted Back Guid: {convertedBackGuid}");
                return;
            }
        }
​
        Console.WriteLine("Test completed successfully with {0} iterations", count);
    }
}
​
/// <summary>
/// A convenience wrapper struct for dealing with URL-safe Base64 encoded globally unique identifiers (GUID),
/// making a shorter string value (22 vs 36 characters long).
/// </summary>
/// <remarks>
/// What is URL-safe Base64? That's just a Base64 string with well known special characters replaced (/, +)
/// or removed (==).
///
/// <para>NB: As of version 2.0.0, <see cref="ShortGuid.Decode(ReadOnlySpan{Char})"/> performs a sanity check when decoding
/// strings to ensure they haven't been tampered with, i.e. allowing the end of a Base64 string to be tweaked
/// where it still produces that same byte array to create the underlying Guid. Effectively there is "unused
/// space" in the Base64 string which is ignored, but will now result in an <see cref="FormatException"/> being
/// thrown.</para>
///
/// <para>ShortGuid will never produce an invalid string, however if one is supplied it, could result in an
/// unintended collision where multiple URL-safe Base64 strings can point to the same Guid. To avoid this
/// uncertainty, a round-trip check is performed to ensure a 1-1 match with the input string.</para>
///
/// <para>Stick with version 1.1.0 if you require the old behaviour with opt-in strict parsing.</para>
/// </remarks>
[DebuggerDisplay("{Value}")]
public readonly struct ShortGuid : IEquatable<Guid>, IEquatable<ShortGuid>, IEquatable<string>
{
    private const char EqualsChar = '=';
    private const char HyphenChar = '-';
    private const char UnderscoreChar = '_';
    private const char SlashChar = '/';
    private const byte SlashByte = (byte)'/';
    private const char PlusChar = '+';
    private const byte PlusByte = (byte)'+';
​
#pragma warning disable IDE0032 // Use auto property
    private readonly Guid underlyingGuid;
    private readonly string encodedValue;
#pragma warning restore IDE0032 // Use auto property
​
    /// <summary>
    /// Initializes a new instance of the <see cref="ShortGuid"/> struct from the given
    /// <paramref name="value"/> URL-safe Base64 encoded string.
    /// <para>See also <seealso cref="TryParse(ReadOnlySpan{char}, out ShortGuid)" /> which will try to coerce the
    /// the value from URL-safe Base64 or normal Guid string.</para></summary>
    /// <param name="value">A 22 character URL-safe Base64 encoded string to decode.</param>
    public ShortGuid(string value)
    {
        encodedValue = value;
        underlyingGuid = Decode(value);
    }
​
    /// <summary>
    /// Initializes a new instance of the <see cref="ShortGuid"/> struct from the given <paramref name="guid"/>.
    /// </summary>
    /// <param name="guid">The <see cref="System.Guid" /> to encode.</param>
    public ShortGuid(Guid guid)
    {
        underlyingGuid = guid;
        encodedValue = Encode(underlyingGuid);
    }
​
    /// <summary>
    /// Gets the underlying <see cref="System.Guid" /> for the encoded ShortGuid.
    /// </summary>
    /// <value>
    /// The unique identifier.
    /// </value>
    public Guid Guid => underlyingGuid;
​
    /// <summary>
    /// Converts to string.
    /// </summary>
    /// <returns>
    /// A <see cref="string" /> that represents this instance.
    /// </returns>
    public override string ToString() => Value;
​
    /// <summary>
    /// Gets the encoded string value of the <see cref="Guid" /> as a URL-safe Base64 string.
    /// </summary>
    /// <value>
    /// The value.
    /// </value>
    public string Value => encodedValue;
​
    /// <summary>
    /// A read-only instance of the ShortGuid struct whose value is guaranteed to be all zeroes i.e. equivalent
    /// to <see cref="Guid.Empty" />.
    /// </summary>
    public static readonly ShortGuid Empty = new(Guid.Empty);
​
    /// <summary>
    /// Encodes the given <see cref="System.Guid" /> as an encoded ShortGuid string. The encoding is
    /// similar to Base64, with some non-URL safe characters replaced, and padding removed, resulting
    /// in a 22 character string.
    /// </summary>
    /// <param name="guid">The <see cref="System.Guid" /> to encode.</param>
    /// <returns>
    /// A 22 character ShortGuid URL-safe Base64 string.
    /// </returns>
    public static string Encode(Guid guid)
    {
        Span<byte> guidBytes = stackalloc byte[16];
        Span<byte> base64Bytes = stackalloc byte[24];
​
 #if NET8_0_OR_GREATER
        MemoryMarshal.TryWrite(guidBytes, in guid);
#else
        MemoryMarshal.TryWrite(guidBytes, ref guid);
#endif
        
        Base64.EncodeToUtf8(guidBytes, base64Bytes, out _, out _);
​
        Span<char> finalChars = stackalloc char[22];
​
        for (int i = 0; i < 22; i++)
        {
            finalChars[i] = base64Bytes[i] switch
            {
                SlashByte => UnderscoreChar,
                PlusByte => HyphenChar,
                _ => (char)base64Bytes[i]
            };
        }
​
        return new string(finalChars);
    }
​
    /// <summary>
    /// Encodes the given value as an encoded ShortGuid string. The encoding is similar to Base64, with
    /// some non-URL safe characters replaced, and padding removed, resulting in a 22 character string.
    /// </summary>
    /// <param name="value">Any valid <see cref="System.Guid" /> string.</param>
    /// <returns>
    /// A 22 character ShortGuid URL-safe Base64 string.
    /// </returns>
    public static ReadOnlySpan<char> Encode(ReadOnlySpan<char> value)
    {
        Guid guid = Guid.Parse(value);
        return Encode(guid);
    }
​
    /// <summary>
    /// Decodes the given value from a 22 character URL-safe Base64 string to a <see cref="System.Guid" />.
    /// <para>Supports: ShortGuid format only.</para><para>See also <seealso cref="TryDecode(ReadOnlySpan{char}, out Guid)" /> or <seealso cref="TryParse(ReadOnlySpan{char}, out Guid)" />.</para>
    /// </summary>
    /// <param name="value">A 22 character URL-safe Base64 encoded ReadOnlySpan of char to decode.</param>
    /// <returns>
    /// A new <see cref="System.Guid" /> instance from the parsed string.
    /// </returns>
    /// <exception cref="ArgumentException">A ShortGuid must be exactly 22 characters long. Received a {value.Length} character string.</exception>
    /// <exception cref="FormatException">Invalid strict ShortGuid encoded string. The string '{new string(value)}' " +
    ///                 $"but failed a round-trip test expecting '{new string(sanityCheck)}'.</exception>
    public static Guid Decode(ReadOnlySpan<char> value)
    {
        // avoid parsing larger strings/blobs
        if (value.Length != 22)
        {
            throw new ArgumentException($"A ShortGuid must be exactly 22 characters long. Received a {value.Length} character string.", paramName: nameof(value));
        }
​
        Span<char> base64Chars = stackalloc char[24];
​
        for (int i = 0; i < 22; i++)
        {
            base64Chars[i] = value[i] switch
            {
                HyphenChar => PlusChar,
                UnderscoreChar => SlashChar,
                _ => value[i]
            };
        }
​
        base64Chars[22] = EqualsChar;
        base64Chars[23] = EqualsChar;
​
        Span<byte> idBytes = stackalloc byte[16];
        Convert.TryFromBase64Chars(base64Chars, idBytes, out _);
​
        Guid guid = new(idBytes);
        string sanityCheck = Encode(guid);
        return !value.SequenceEqual(sanityCheck)
            ? throw new FormatException(
                $"Invalid strict ShortGuid encoded string. The string '{new string(value)}' " +
                $"but failed a round-trip test expecting '{new string(sanityCheck)}'.")
            : guid;
    }
​
    /// <summary>
    /// <para>Supports ShortGuid format only.</para>
    /// <para>Attempts to decode the given value from a 22 character URL-safe Base64 string to
    /// a <see cref="System.Guid"/>.</para>
    /// <para>The difference between TryParse and TryDecode:</para>
    /// <list type="number">
    ///     <item>
    ///         <term><see cref="TryParse(ReadOnlySpan{char}, out ShortGuid)"/></term>
    ///         <description>Supports: Guid &amp; ShortGuid;</description>
    ///         <description>Tries to parse first as a <see cref="ShortGuid"/>, then as a
    ///         <see cref="System.Guid"/>, outputs the <see cref="ShortGuid"/> instance.</description>
    ///     </item>
    ///     <item>
    ///         <term><see cref="TryParse(ReadOnlySpan{char}, out Guid)"/></term>
    ///         <description>Supports: Guid &amp; ShortGuid;</description>
    ///         <description>Tries to parse first as a <see cref="ShortGuid"/>, then as a
    ///         <see cref="System.Guid"/>, outputs the underlying <see cref="System.Guid"/>.</description>
    ///     </item>
    ///     <item>
    ///         <term><see cref="TryDecode(ReadOnlySpan{char}, out Guid)"/></term>
    ///         <description>Supports: ShortGuid;</description>
    ///         <description>Tries to decode a 22 character URL-safe Base64 string as a
    ///         <see cref="ShortGuid"/> only, but outputs the result as a <see cref="System.Guid"/> - this method.</description>
    ///     </item>
    /// </list>
    /// </summary>
    /// <param name="value">The ShortGuid encoded string to decode.</param>
    /// <param name="guid">A new <see cref="System.Guid"/> instance from the parsed string.</param>
    /// <returns>A boolean indicating if the decode was successful.</returns>
    public static bool TryDecode(ReadOnlySpan<char> value, out Guid guid)
    {
        try
        {
            guid = Decode(value);
            return true;
        }
        catch
        {
            guid = Guid.Empty;
            return false;
        }
    }
​
    /// <summary>
    /// <para>Tries to parse the value from either a 22 character URL-safe Base64 string or
    /// a <see cref="System.Guid"/> string, and outputs a <see cref="ShortGuid"/> instance.</para>
    /// <para>Supports ShortGuid &amp; Guid formats.</para>
    /// <para>The difference between TryParse and TryDecode:</para>
    /// <list type="number">
    ///     <item>
    ///         <term><see cref="TryParse(ReadOnlySpan{char}, out ShortGuid)"/></term>
    ///         <description>Supports: Guid &amp; ShortGuid; </description>
    ///         <description>Tries to parse first as a <see cref="ShortGuid"/>, then as a
    ///         <see cref="System.Guid"/>, outputs the <see cref="ShortGuid"/> instance - this method.</description>
    ///     </item>
    ///     <item>
    ///         <term><see cref="TryParse(ReadOnlySpan{char}, out Guid)"/></term>
    ///         <description>Supports: Guid &amp; ShortGuid;</description>
    ///         <description>Tries to parse first as a <see cref="ShortGuid"/>, then as a
    ///         <see cref="System.Guid"/>, outputs the <see cref="System.Guid"/>.</description>
    ///     </item>
    ///     <item>
    ///         <term><see cref="TryDecode(ReadOnlySpan{char}, out Guid)"/></term>
    ///         <description>Supports: ShortGuid;</description>
    ///         <description>Tries to decode a 22 character URL-safe Base64 string as a
    ///         <see cref="ShortGuid"/> only, but outputs the result as a <see cref="System.Guid"/>.</description>
    ///     </item>
    /// </list>
    /// </summary>
    /// <param name="value">The ShortGuid encoded string or string representation of a Guid.</param>
    /// <param name="shortGuid">A new <see cref="ShortGuid" /> instance from the parsed string.</param>
    /// <returns>
    ///   <c>true</c> if parsing was successful; otherwise, <c>false</c>.
    /// </returns>
    public static bool TryParse(ReadOnlySpan<char> value, out ShortGuid shortGuid)
    {
        switch (value)
        {
            case { Length: 22 } when TryDecode(value, out Guid sg):
                shortGuid = sg;
                return true;
​
            case { Length: 36 } when Guid.TryParse(value, out Guid guid):
                {
                    shortGuid = guid;
                    return true;
                }
​
            default:
                shortGuid = Empty;
                return false;
        }
    }
​
    /// <summary>
    /// <para>Supports ShortGuid &amp; Guid formats.</para>
    /// <para>Tries to parse the value either a 22 character URL-safe Base64 string or
    /// <see cref="System.Guid"/> string, and outputs the <see cref="Guid"/> value.</para>
    /// <para>The difference between TryParse and TryDecode:</para>
    /// <list type="number">
    ///     <item>
    ///         <term><see cref="TryParse(ReadOnlySpan{char}, out ShortGuid)"/></term>
    ///         <description>Supports: Guid &amp; ShortGuid;</description>
    ///         <description>Tries to parse first as a <see cref="ShortGuid"/>, then as a
    ///         <see cref="System.Guid"/>, outputs the <see cref="ShortGuid"/> instance.</description>
    ///     </item>
    ///     <item>
    ///         <term><see cref="TryParse(ReadOnlySpan{char}, out Guid)"/></term>
    ///         <description>Supports: Guid &amp; ShortGuid;</description>
    ///         <description>Tries to parse first as a <see cref="ShortGuid"/>, then as a
    ///         <see cref="System.Guid"/>, outputs the <see cref="System.Guid"/> - this method.</description>
    ///     </item>
    ///     <item>
    ///         <term><see cref="TryDecode(ReadOnlySpan{char}, out Guid)"/></term>
    ///         <description>Supports: ShortGuid;</description>
    ///         <description>Tries to decode a 22 character URL-safe Base64 string as a
    ///         <see cref="ShortGuid"/> only, outputting the result as a <see cref="System.Guid"/>.</description>
    ///     </item>
    /// </list>
    /// </summary>
    /// <param name="value">The ShortGuid encoded string or string representation of a Guid.</param>
    /// <param name="guid">A new <see cref="System.Guid"/> instance from the parsed string.</param>
    /// <returns>A boolean indicating if the parse was successful.</returns>
    public static bool TryParse(ReadOnlySpan<char> value, out Guid guid)
    {
        switch (value)
        {
            case { Length: 22 } when TryDecode(value, out guid):
            case { Length: 36 } when Guid.TryParse(value, out guid):
                return true;
​
            default:
                guid = Guid.Empty;
                return false;
        }
    }
​
    /// <summary>
    /// Indicates whether the current object is equal to another object of the same type.
    /// </summary>
    /// <param name="other">An object to compare with this object.</param>
    /// <returns>
    ///   <see langword="true" /> if the current object is equal to the <paramref name="other" /> parameter; otherwise, <see langword="false" />.
    /// </returns>
    public bool Equals(Guid other)
    {
        return Equals((object)other);
    }
​
    /// <summary>
    /// Indicates whether the current object is equal to another object of the same type.
    /// </summary>
    /// <param name="other">An object to compare with this object.</param>
    /// <returns>
    ///   <see langword="true" /> if the current object is equal to the <paramref name="other" /> parameter; otherwise, <see langword="false" />.
    /// </returns>
    public bool Equals(ShortGuid other)
    {
        return Equals((object)other);
    }
​
    /// <summary>
    /// Indicates whether the current object is equal to another object of the same type.
    /// </summary>
    /// <param name="other">An object to compare with this object.</param>
    /// <returns>
    ///   <see langword="true" /> if the current object is equal to the <paramref name="other" /> parameter; otherwise, <see langword="false" />.
    /// </returns>
    public bool Equals(string? other)
    {
        return other is not null && Equals((object)other);
    }
​
    /// <summary>
    /// Returns a value indicating whether this instance and a specified object represent the same type and value.
    /// <para>Compares for equality against other string, Guid and ShortGuid types.</para>
    /// </summary>
    /// <param name="obj">The <see cref="object" /> to compare with this instance.</param>
    /// <returns>
    ///   <c>true</c> if the specified <see cref="object" /> is equal to this instance; otherwise, <c>false</c>.
    /// </returns>
    public override bool Equals(object? obj)
    {
        if (obj is ShortGuid shortGuid)
        {
            return underlyingGuid.Equals(shortGuid.underlyingGuid);
        }
​
        if (obj is Guid guid)
        {
            return underlyingGuid.Equals(guid);
        }
​
        if (obj is string span)
        {
            // Try a ShortGuid string
            if (TryDecode(span, out guid))
            {
                return underlyingGuid.Equals(guid);
            }
​
            if (Guid.TryParse(span, out guid))
            {
                return underlyingGuid.Equals(guid);
            }
        }
​
        if (obj is char[] chars)
        {
            // Try a ShortGuid string
            if (TryDecode(chars, out guid))
            {
                return underlyingGuid.Equals(guid);
            }
​
            if (Guid.TryParse(chars, out guid))
            {
                return underlyingGuid.Equals(guid);
            }
        }
​
        return false;
    }
​
    /// <summary>
    /// Returns the hash code for the underlying <see cref="System.Guid" />.
    /// </summary>
    /// <returns>
    /// The hash code for the underlying <see cref="System.Guid" />.
    /// </returns>
    public override int GetHashCode() => underlyingGuid.GetHashCode();
​
    /// <summary>
    /// Initialises a new instance of a ShortGuid using <see cref="M:Guid.NewGuid()" />.
    /// <para>Equivalent of calling: <c>`new ShortGuid(Guid.NewGuid())`</c>.</para>
    /// </summary>
    /// <returns>
    /// A new <see cref="ShortGuid" /> instance initialized with a new <see cref="Guid" />.
    /// </returns>
    /// <remarks>
    /// NewId is designed to solve a specific problem. It's for when you want a unique ID,
    /// but you want them to generally be sortable, and semi-predictable.
    /// <see href="https://andrewlock.net/generating-sortable-guids-using-newid/" />.
    /// </remarks>
    public static ShortGuid NewGuid() => new(Guid.NewGuid());
​
    /// <summary>
    /// Implements the operator ==.
    /// </summary>
    /// <param name="a">a.</param>
    /// <param name="b">The b.</param>
    /// <returns>
    /// The result of the operator.
    /// </returns>
    public static bool operator ==(ShortGuid a, ShortGuid b)
        => a.underlyingGuid == b.underlyingGuid;
​
    /// <summary>
    /// Implements the operator ==.
    /// </summary>
    /// <param name="a">a.</param>
    /// <param name="b">The b.</param>
    /// <returns>
    /// The result of the operator.
    /// </returns>
    public static bool operator ==(ShortGuid a, Guid b)
        => a.underlyingGuid == b;
​
    /// <summary>
    /// Implements the operator ==.
    /// </summary>
    /// <param name="a">a.</param>
    /// <param name="b">The b.</param>
    /// <returns>
    /// The result of the operator.
    /// </returns>
    public static bool operator ==(Guid a, ShortGuid b)
        => b == a;
​
    /// <summary>
    /// Implements the operator !=.
    /// </summary>
    /// <param name="a">a.</param>
    /// <param name="b">The b.</param>
    /// <returns>
    /// The result of the operator.
    /// </returns>
    public static bool operator !=(ShortGuid a, ShortGuid b)
        => a.underlyingGuid != b.underlyingGuid;
​
    /// <summary>
    /// Implements the operator !=.
    /// </summary>
    /// <param name="a">a.</param>
    /// <param name="b">The b.</param>
    /// <returns>
    /// The result of the operator.
    /// </returns>
    public static bool operator !=(ShortGuid a, Guid b)
        => a.underlyingGuid != b;
​
    /// <summary>
    /// Implements the operator !=.
    /// </summary>
    /// <param name="a">a.</param>
    /// <param name="b">The b.</param>
    /// <returns>
    /// The result of the operator.
    /// </returns>
    public static bool operator !=(Guid a, ShortGuid b)
        => b != a;
​
    /// <summary>
    /// Performs an implicit conversion from <see cref="ShortGuid"/> to <see cref="ReadOnlySpan{char}"/>.
    /// </summary>
    /// <param name="shortGuid">The short unique identifier.</param>
    /// <returns>
    /// The result of the conversion.
    /// </returns>
    public static implicit operator ReadOnlySpan<char>(ShortGuid shortGuid) => shortGuid.Value;
​
    /// <summary>
    /// Performs an implicit conversion from <see cref="ShortGuid"/> to <see cref="string"/>.
    /// </summary>
    /// <param name="shortGuid">The short unique identifier.</param>
    /// <returns>
    /// The result of the conversion.
    /// </returns>
    public static implicit operator string(ShortGuid shortGuid) => shortGuid.Value;
​
    /// <summary>
    /// Performs an implicit conversion from <see cref="ShortGuid"/> to <see cref="Guid"/>.
    /// </summary>
    /// <param name="shortGuid">The short unique identifier.</param>
    /// <returns>
    /// The result of the conversion.
    /// </returns>
    public static implicit operator Guid(ShortGuid shortGuid) => shortGuid.underlyingGuid;
​
    /// <summary>
    /// Performs an implicit conversion from <see cref="Nullable{string}"/> to <see cref="ShortGuid"/>.
    /// </summary>
    /// <param name="value">The value.</param>
    /// <returns>
    /// The result of the conversion.
    /// </returns>
    /// <exception cref="FormatException">ShortGuid should contain 22 Base64 characters "
    ///                                   + "or 32 characters with 4 dashes (xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx).</exception>
    public static implicit operator ShortGuid(string? value)
    {
        if (!string.IsNullOrWhiteSpace(value) && TryParse(value, out ShortGuid shortGuid))
        {
            return shortGuid;
        }
​
#pragma warning disable S125 // Sections of code should not be commented out
        //throw new FormatException("ShortGuid should contain 22 Base64 characters " + "or 32 characters with 4 dashes (xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx).");
        return Empty;
#pragma warning restore S125 // Sections of code should not be commented out
    }
​
    /// <summary>
    /// Performs an implicit conversion from <see cref="Guid"/> to <see cref="ShortGuid"/>.
    /// </summary>
    /// <param name="guid">The unique identifier.</param>
    /// <returns>
    /// The result of the conversion.
    /// </returns>
    public static implicit operator ShortGuid(Guid guid)
        => guid == Guid.Empty
            ? Empty
            : new ShortGuid(guid);
}
​

AccountOwnerName
AccountOwnerNumber
AccountOwnerDouble
AccountOwnerInt

Cached Result
Last Run:	8:22:41 am
Compile:	0.152s
Execute:	0.004s
Memory:	8kb
CPU:	0s

View IL Code