C# Online Compiler | .NET Fiddle

<no name> by Anonymous

using System;
using System.Text;
using System.Text.RegularExpressions;
using System.Text.Json;
using System.Collections.Generic;
using System.Security.Cryptography;
					
public class Program
{
	public static void Main()
	{
		using (MD5 md5 = MD5.Create()) {
			var hash = md5.ComputeHash(Encoding.ASCII.GetBytes("lol"));
			Console.WriteLine($"Hash length: {BitConverter.ToString(hash).Length} - {BitConverter.ToString(hash)}");
			Guid guid = new Guid(hash);
			Console.WriteLine($"GUID length: {guid.ToString().Length} - {guid}");
			ShortGuid shorter = guid;
			Console.WriteLine($"ShortGUID length: {shorter.ToString().Length} - {shorter}");
			string converted = Convert.ToBase64String(guid.ToByteArray());
			Console.WriteLine($"Base64 length: {converted.Length} - {converted}");
			string fromHash = Convert.ToBase64String(hash);
			Console.WriteLine($"Base64 from hash length: {fromHash.Length} - {fromHash}");
			string offbase = Base32.ToBase32String(guid.ToByteArray());
			Console.WriteLine($"Base32 length: {offbase.Length} - {offbase}");
		}
	}
}

public static class Base32
{
  private static readonly char[] _digits = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567".ToCharArray();
  private const int _mask = 31;
  private const int _shift = 5;

  private static int CharToInt(char c)
  {
    switch (c)
    {
      case 'A': return 0;
      case 'B': return 1;
      case 'C': return 2;
      case 'D': return 3;
      case 'E': return 4;
      case 'F': return 5;
      case 'G': return 6;
      case 'H': return 7;
      case 'I': return 8;
      case 'J': return 9;
      case 'K': return 10;
      case 'L': return 11;
      case 'M': return 12;
      case 'N': return 13;
      case 'O': return 14;
      case 'P': return 15;
      case 'Q': return 16;
      case 'R': return 17;
      case 'S': return 18;
      case 'T': return 19;
      case 'U': return 20;
      case 'V': return 21;
      case 'W': return 22;
      case 'X': return 23;
      case 'Y': return 24;
      case 'Z': return 25;
      case '2': return 26;
      case '3': return 27;
      case '4': return 28;
      case '5': return 29;
      case '6': return 30;
      case '7': return 31;
    }
    return -1;
  }

  public static byte[] FromBase32String(string encoded)
  {
    if (encoded == null)
      throw new ArgumentNullException(nameof(encoded));

    // Remove whitespace and padding. Note: the padding is used as hint 
    // to determine how many bits to decode from the last incomplete chunk
    // Also, canonicalize to all upper case
    encoded = encoded.Trim().TrimEnd('=').ToUpper();
    if (encoded.Length == 0)
      return new byte[0];

    var outLength = encoded.Length * _shift / 8;
    var result = new byte[outLength];
    var buffer = 0;
    var next = 0;
    var bitsLeft = 0;
    var charValue = 0;
    foreach (var c in encoded)
    {
      charValue = CharToInt(c);
      if (charValue < 0)
        throw new FormatException("Illegal character: `" + c + "`");

      buffer <<= _shift;
      buffer |= charValue & _mask;
      bitsLeft += _shift;
      if (bitsLeft >= 8)
      {
        result[next++] = (byte)(buffer >> (bitsLeft - 8));
        bitsLeft -= 8;
      }
    }

    return result;
  }

  public static string ToBase32String(byte[] data, bool padOutput = false)
  {
    return ToBase32String(data, 0, data.Length, padOutput);
  }

  public static string ToBase32String(byte[] data, int offset, int length, bool padOutput = false)
  {
    if (data == null)
      throw new ArgumentNullException(nameof(data));

    if (offset < 0)
      throw new ArgumentOutOfRangeException(nameof(offset));

    if (length < 0)
      throw new ArgumentOutOfRangeException(nameof(length));

    if ((offset + length) > data.Length)
      throw new ArgumentOutOfRangeException();

    if (length == 0)
      return "";

    // SHIFT is the number of bits per output character, so the length of the
    // output is the length of the input multiplied by 8/SHIFT, rounded up.
    // The computation below will fail, so don't do it.
    if (length >= (1 << 28))
      throw new ArgumentOutOfRangeException(nameof(data));

    var outputLength = (length * 8 + _shift - 1) / _shift;
    var result = new StringBuilder(outputLength);

    var last = offset + length;
    int buffer = data[offset++];
    var bitsLeft = 8;
    while (bitsLeft > 0 || offset < last)
    {
      if (bitsLeft < _shift)
      {
        if (offset < last)
        {
          buffer <<= 8;
          buffer |= (data[offset++] & 0xff);
          bitsLeft += 8;
        }
        else
        {
          int pad = _shift - bitsLeft;
          buffer <<= pad;
          bitsLeft += pad;
        }
      }
      int index = _mask & (buffer >> (bitsLeft - _shift));
      bitsLeft -= _shift;
      result.Append(_digits[index]);
    }
    if (padOutput)
    {
      int padding = 8 - (result.Length % 8);
      if (padding > 0) result.Append('=', padding == 8 ? 0 : padding);
    }
    return result.ToString();
  }
}

	/// <summary>
	/// Represents a globally unique identifier (GUID) with a 
	/// shorter string value. Sguid
	/// </summary>
	public struct ShortGuid
	{
		#region Static

		/// <summary>
		/// A read-only instance of the ShortGuid class whose value 
		/// is guaranteed to be all zeroes. 
		/// </summary>
		public static readonly ShortGuid Empty = new ShortGuid(Guid.Empty);

		#endregion

		#region Fields

		Guid _guid;
		string _value;

		#endregion

		#region Contructors

		/// <summary>
		/// Creates a ShortGuid from a base64 encoded string
		/// </summary>
		/// <param name="value">The encoded guid as a 
		/// base64 string</param>
		public ShortGuid(string value)
		{
			_value = value;
			_guid = Decode(value);
		}

		/// <summary>
		/// Creates a ShortGuid from a Guid
		/// </summary>
		/// <param name="guid">The Guid to encode</param>
		public ShortGuid(Guid guid)
		{
			_value = Encode(guid);
			_guid = guid;
		}

		#endregion

		#region Properties

		/// <summary>
		/// Gets/sets the underlying Guid
		/// </summary>
		public Guid Guid
		{
			get { return _guid; }
			set
			{
				if (value != _guid)
				{
					_guid = value;
					_value = Encode(value);
				}
			}
		}

		/// <summary>
		/// Gets/sets the underlying base64 encoded string
		/// </summary>
		public string Value
		{
			get { return _value; }
			set
			{
				if (value != _value)
				{
					_value = value;
					_guid = Decode(value);
				}
			}
		}

		#endregion

		#region ToString

		/// <summary>
		/// Returns the base64 encoded guid as a string
		/// </summary>
		/// <returns></returns>
		public override string ToString()
		{
			return _value;
		}

		#endregion

		#region Equals

		/// <summary>
		/// Returns a value indicating whether this instance and a 
		/// specified Object represent the same type and value.
		/// </summary>
		/// <param name="obj">The object to compare</param>
		/// <returns></returns>
		public override bool Equals(object obj)
		{
			if (obj is ShortGuid)
				return _guid.Equals(((ShortGuid)obj)._guid);
			if (obj is Guid)
				return _guid.Equals((Guid)obj);
			if (obj is string)
				return _guid.Equals(((ShortGuid)obj)._guid);
			return false;
		}

		#endregion

		#region GetHashCode

		/// <summary>
		/// Returns the HashCode for underlying Guid.
		/// </summary>
		/// <returns></returns>
		public override int GetHashCode()
		{
			return _guid.GetHashCode();
		}

		#endregion

		#region NewGuid

		/// <summary>
		/// Initialises a new instance of the ShortGuid class
		/// </summary>
		/// <returns></returns>
		public static ShortGuid NewGuid()
		{
			return new ShortGuid(Guid.NewGuid());
		}

		#endregion

		#region Encode

		/// <summary>
		/// Creates a new instance of a Guid using the string value, 
		/// then returns the base64 encoded version of the Guid.
		/// </summary>
		/// <param name="value">An actual Guid string (i.e. not a ShortGuid)</param>
		/// <returns></returns>
		public static string Encode(string value)
		{
			Guid guid = new Guid(value);
			return Encode(guid);
		}

		/// <summary>
		/// Encodes the given Guid as a base64 string that is 22 
		/// characters long.
		/// </summary>
		/// <param name="guid">The Guid to encode</param>
		/// <returns></returns>
		public static string Encode(Guid guid)
		{
			string encoded = Convert.ToBase64String(guid.ToByteArray());
			encoded = encoded
				.Replace("/", "_")
				.Replace("+", "-");
			return encoded.Substring(0, 22);
		}

		#endregion

		#region Decode

		/// <summary>
		/// Decodes the given base64 string
		/// </summary>
		/// <param name="value">The base64 encoded string of a Guid</param>
		/// <returns>A new Guid</returns>
		public static Guid Decode(string value)
		{
			value = value
				.Replace("_", "/")
				.Replace("-", "+");
			byte[] buffer = Convert.FromBase64String(value + "==");
			return new Guid(buffer);
		}

		#endregion

		#region Operators

		/// <summary>
		/// Determines if both ShortGuids have the same underlying 
		/// Guid value.
		/// </summary>
		/// <param name="x"></param>
		/// <param name="y"></param>
		/// <returns></returns>
		public static bool operator ==(ShortGuid x, ShortGuid y)
		{
			if ((object)x == null) return (object)y == null;
			return x._guid == y._guid;
		}

		/// <summary>
		/// Determines if both ShortGuids do not have the 
		/// same underlying Guid value.
		/// </summary>
		/// <param name="x"></param>
		/// <param name="y"></param>
		/// <returns></returns>
		public static bool operator !=(ShortGuid x, ShortGuid y)
		{
			return !(x == y);
		}

		/// <summary>
		/// Implicitly converts the ShortGuid to it's string equivilent
		/// </summary>
		/// <param name="shortGuid"></param>
		/// <returns></returns>
		public static implicit operator string(ShortGuid shortGuid)
		{
			return shortGuid._value;
		}

		/// <summary>
		/// Implicitly converts the ShortGuid to it's Guid equivilent
		/// </summary>
		/// <param name="shortGuid"></param>
		/// <returns></returns>
		public static implicit operator Guid(ShortGuid shortGuid)
		{
			return shortGuid._guid;
		}

		/// <summary>
		/// Implicitly converts the string to a ShortGuid
		/// </summary>
		/// <param name="shortGuid"></param>
		/// <returns></returns>
		public static implicit operator ShortGuid(string shortGuid)
		{
			return new ShortGuid(shortGuid);
		}

		/// <summary>
		/// Implicitly converts the Guid to a ShortGuid 
		/// </summary>
		/// <param name="guid"></param>
		/// <returns></returns>
		public static implicit operator ShortGuid(Guid guid)
		{
			return new ShortGuid(guid);
		}

		#endregion
	}

​x
 
using System;
using System.Text;
using System.Text.RegularExpressions;
using System.Text.Json;
using System.Collections.Generic;
using System.Security.Cryptography;
                    
public class Program
{
    public static void Main()
    {
        using (MD5 md5 = MD5.Create()) {
            var hash = md5.ComputeHash(Encoding.ASCII.GetBytes("lol"));
            Console.WriteLine($"Hash length: {BitConverter.ToString(hash).Length} - {BitConverter.ToString(hash)}");
            Guid guid = new Guid(hash);
            Console.WriteLine($"GUID length: {guid.ToString().Length} - {guid}");
            ShortGuid shorter = guid;
            Console.WriteLine($"ShortGUID length: {shorter.ToString().Length} - {shorter}");
            string converted = Convert.ToBase64String(guid.ToByteArray());
            Console.WriteLine($"Base64 length: {converted.Length} - {converted}");
            string fromHash = Convert.ToBase64String(hash);
            Console.WriteLine($"Base64 from hash length: {fromHash.Length} - {fromHash}");
            string offbase = Base32.ToBase32String(guid.ToByteArray());
            Console.WriteLine($"Base32 length: {offbase.Length} - {offbase}");
        }
    }
}
​
public static class Base32
{
  private static readonly char[] _digits = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567".ToCharArray();
  private const int _mask = 31;
  private const int _shift = 5;
​
  private static int CharToInt(char c)
  {
    switch (c)
    {
      case 'A': return 0;
      case 'B': return 1;
      case 'C': return 2;
      case 'D': return 3;
      case 'E': return 4;
      case 'F': return 5;
      case 'G': return 6;
      case 'H': return 7;
      case 'I': return 8;
      case 'J': return 9;
      case 'K': return 10;
      case 'L': return 11;
      case 'M': return 12;
      case 'N': return 13;
      case 'O': return 14;
      case 'P': return 15;
      case 'Q': return 16;
      case 'R': return 17;
      case 'S': return 18;
      case 'T': return 19;
      case 'U': return 20;
      case 'V': return 21;
      case 'W': return 22;
      case 'X': return 23;
      case 'Y': return 24;
      case 'Z': return 25;
      case '2': return 26;
      case '3': return 27;
      case '4': return 28;
      case '5': return 29;
      case '6': return 30;
      case '7': return 31;
    }
    return -1;
  }
​
  public static byte[] FromBase32String(string encoded)
  {
    if (encoded == null)
      throw new ArgumentNullException(nameof(encoded));
​
    // Remove whitespace and padding. Note: the padding is used as hint 
    // to determine how many bits to decode from the last incomplete chunk
    // Also, canonicalize to all upper case
    encoded = encoded.Trim().TrimEnd('=').ToUpper();
    if (encoded.Length == 0)
      return new byte[0];
​
    var outLength = encoded.Length * _shift / 8;
    var result = new byte[outLength];
    var buffer = 0;
    var next = 0;
    var bitsLeft = 0;
    var charValue = 0;
    foreach (var c in encoded)
    {
      charValue = CharToInt(c);
      if (charValue < 0)
        throw new FormatException("Illegal character: `" + c + "`");
​
      buffer <<= _shift;
      buffer |= charValue & _mask;
      bitsLeft += _shift;
      if (bitsLeft >= 8)
      {
        result[next++] = (byte)(buffer >> (bitsLeft - 8));
        bitsLeft -= 8;
      }
    }
​
    return result;
  }
​
  public static string ToBase32String(byte[] data, bool padOutput = false)
  {
    return ToBase32String(data, 0, data.Length, padOutput);
  }
​
  public static string ToBase32String(byte[] data, int offset, int length, bool padOutput = false)
  {
    if (data == null)
      throw new ArgumentNullException(nameof(data));
​
    if (offset < 0)
      throw new ArgumentOutOfRangeException(nameof(offset));
​
    if (length < 0)
      throw new ArgumentOutOfRangeException(nameof(length));
​
    if ((offset + length) > data.Length)
      throw new ArgumentOutOfRangeException();
​
    if (length == 0)
      return "";
​
    // SHIFT is the number of bits per output character, so the length of the
    // output is the length of the input multiplied by 8/SHIFT, rounded up.
    // The computation below will fail, so don't do it.
    if (length >= (1 << 28))
      throw new ArgumentOutOfRangeException(nameof(data));
​
    var outputLength = (length * 8 + _shift - 1) / _shift;
    var result = new StringBuilder(outputLength);
​
    var last = offset + length;
    int buffer = data[offset++];
    var bitsLeft = 8;
    while (bitsLeft > 0 || offset < last)
    {
      if (bitsLeft < _shift)
      {
        if (offset < last)
        {
          buffer <<= 8;
          buffer |= (data[offset++] & 0xff);
          bitsLeft += 8;
        }
        else
        {
          int pad = _shift - bitsLeft;
          buffer <<= pad;
          bitsLeft += pad;
        }
      }
      int index = _mask & (buffer >> (bitsLeft - _shift));
      bitsLeft -= _shift;
      result.Append(_digits[index]);
    }
    if (padOutput)
    {
      int padding = 8 - (result.Length % 8);
      if (padding > 0) result.Append('=', padding == 8 ? 0 : padding);
    }
    return result.ToString();
  }
}
​
    /// <summary>
    /// Represents a globally unique identifier (GUID) with a 
    /// shorter string value. Sguid
    /// </summary>
    public struct ShortGuid
    {
        #region Static
​
        /// <summary>
        /// A read-only instance of the ShortGuid class whose value 
        /// is guaranteed to be all zeroes. 
        /// </summary>
        public static readonly ShortGuid Empty = new ShortGuid(Guid.Empty);
​
        #endregion
​
        #region Fields
​
        Guid _guid;
        string _value;
​
        #endregion
​
        #region Contructors
​
        /// <summary>
        /// Creates a ShortGuid from a base64 encoded string
        /// </summary>
        /// <param name="value">The encoded guid as a 
        /// base64 string</param>
        public ShortGuid(string value)
        {
            _value = value;
            _guid = Decode(value);
        }
​
        /// <summary>
        /// Creates a ShortGuid from a Guid
        /// </summary>
        /// <param name="guid">The Guid to encode</param>
        public ShortGuid(Guid guid)
        {
            _value = Encode(guid);
            _guid = guid;
        }
​
        #endregion
​
        #region Properties
​
        /// <summary>
        /// Gets/sets the underlying Guid
        /// </summary>
        public Guid Guid
        {
            get { return _guid; }
            set
            {
                if (value != _guid)
                {
                    _guid = value;
                    _value = Encode(value);
                }
            }
        }
​
        /// <summary>
        /// Gets/sets the underlying base64 encoded string
        /// </summary>
        public string Value
        {
            get { return _value; }
            set
            {
                if (value != _value)
                {
                    _value = value;
                    _guid = Decode(value);
                }
            }
        }
​
        #endregion
​
        #region ToString
​
        /// <summary>
        /// Returns the base64 encoded guid as a string
        /// </summary>
        /// <returns></returns>
        public override string ToString()
        {
            return _value;
        }
​
        #endregion
​
        #region Equals
​
        /// <summary>
        /// Returns a value indicating whether this instance and a 
        /// specified Object represent the same type and value.
        /// </summary>
        /// <param name="obj">The object to compare</param>
        /// <returns></returns>
        public override bool Equals(object obj)
        {
            if (obj is ShortGuid)
                return _guid.Equals(((ShortGuid)obj)._guid);
            if (obj is Guid)
                return _guid.Equals((Guid)obj);
            if (obj is string)
                return _guid.Equals(((ShortGuid)obj)._guid);
            return false;
        }
​
        #endregion
​
        #region GetHashCode
​
        /// <summary>
        /// Returns the HashCode for underlying Guid.
        /// </summary>
        /// <returns></returns>
        public override int GetHashCode()
        {
            return _guid.GetHashCode();
        }
​
        #endregion
​
        #region NewGuid
​
        /// <summary>
        /// Initialises a new instance of the ShortGuid class
        /// </summary>
        /// <returns></returns>
        public static ShortGuid NewGuid()
        {
            return new ShortGuid(Guid.NewGuid());
        }
​
        #endregion
​
        #region Encode
​
        /// <summary>
        /// Creates a new instance of a Guid using the string value, 
        /// then returns the base64 encoded version of the Guid.
        /// </summary>
        /// <param name="value">An actual Guid string (i.e. not a ShortGuid)</param>
        /// <returns></returns>
        public static string Encode(string value)
        {
            Guid guid = new Guid(value);
            return Encode(guid);
        }
​
        /// <summary>
        /// Encodes the given Guid as a base64 string that is 22 
        /// characters long.
        /// </summary>
        /// <param name="guid">The Guid to encode</param>
        /// <returns></returns>
        public static string Encode(Guid guid)
        {
            string encoded = Convert.ToBase64String(guid.ToByteArray());
            encoded = encoded
                .Replace("/", "_")
                .Replace("+", "-");
            return encoded.Substring(0, 22);
        }
​
        #endregion
​
        #region Decode
​
        /// <summary>
        /// Decodes the given base64 string
        /// </summary>
        /// <param name="value">The base64 encoded string of a Guid</param>
        /// <returns>A new Guid</returns>
        public static Guid Decode(string value)
        {
            value = value
                .Replace("_", "/")
                .Replace("-", "+");
            byte[] buffer = Convert.FromBase64String(value + "==");
            return new Guid(buffer);
        }
​
        #endregion
​
        #region Operators
​
        /// <summary>
        /// Determines if both ShortGuids have the same underlying 
        /// Guid value.
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <returns></returns>
        public static bool operator ==(ShortGuid x, ShortGuid y)
        {
            if ((object)x == null) return (object)y == null;
            return x._guid == y._guid;
        }
​
        /// <summary>
        /// Determines if both ShortGuids do not have the 
        /// same underlying Guid value.
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <returns></returns>
        public static bool operator !=(ShortGuid x, ShortGuid y)
        {
            return !(x == y);
        }
​
        /// <summary>
        /// Implicitly converts the ShortGuid to it's string equivilent
        /// </summary>
        /// <param name="shortGuid"></param>
        /// <returns></returns>
        public static implicit operator string(ShortGuid shortGuid)
        {
            return shortGuid._value;
        }
​
        /// <summary>
        /// Implicitly converts the ShortGuid to it's Guid equivilent
        /// </summary>
        /// <param name="shortGuid"></param>
        /// <returns></returns>
        public static implicit operator Guid(ShortGuid shortGuid)
        {
            return shortGuid._guid;
        }
​
        /// <summary>
        /// Implicitly converts the string to a ShortGuid
        /// </summary>
        /// <param name="shortGuid"></param>
        /// <returns></returns>
        public static implicit operator ShortGuid(string shortGuid)
        {
            return new ShortGuid(shortGuid);
        }
​
        /// <summary>
        /// Implicitly converts the Guid to a ShortGuid 
        /// </summary>
        /// <param name="guid"></param>
        /// <returns></returns>
        public static implicit operator ShortGuid(Guid guid)
        {
            return new ShortGuid(guid);
        }
​
        #endregion
    }

Compilation error (line 9, col 2): Invalid expression term '}'
Compilation error (line 9, col 3): ; expected

Last Run:	11:37:04 pm
Compile:	0s
Execute:	0.095s
Memory:	0b
CPU:	0s

View IL Code