How to convert a byte array to a hex string in C#

using System.Security.Cryptography;
using System.Text;

byte[] bytes = [0x00, 0x0F, 0xA5, 0xFF, 0x10];

// .NET 5+: uppercase, two characters per byte, no separators
string hex = Convert.ToHexString(bytes);
Console.WriteLine(hex);

// .NET 9+: lowercase without an extra ToLower() call
Console.WriteLine(Convert.ToHexStringLower(bytes));

// And back again: FromHexString accepts either case
byte[] back = Convert.FromHexString("000fa5ff10");
Console.WriteLine(back.SequenceEqual(bytes));
Console.WriteLine(string.Join(", ", back));

// Only part of an array: offset and length, or a span slice
Console.WriteLine(Convert.ToHexString(bytes, 2, 2));
Console.WriteLine(Convert.ToHexString(bytes.AsSpan(1, 3)));

// The usual real-world case: show a hash as hex
byte[] hash = SHA256.HashData(Encoding.UTF8.GetBytes("hello"));
Console.WriteLine(hash.Length);
Console.WriteLine(Convert.ToHexStringLower(hash));

byte[] bytes = [0x00, 0x0F, 0xA5, 0xFF, 0x10];

// Every .NET version: uppercase pairs joined by dashes
string dashed = BitConverter.ToString(bytes);
Console.WriteLine(dashed);

// The classic pre-.NET 5 one-liner: drop the dashes
Console.WriteLine(BitConverter.ToString(bytes).Replace("-", ""));
Console.WriteLine(BitConverter.ToString(bytes).Replace("-", "").ToLowerInvariant());

// Offset and length work here too
Console.WriteLine(BitConverter.ToString(bytes, 1, 2));

// There is no BitConverter.FromString; dashes break FromHexString
try
{
    Convert.FromHexString(dashed);
}
catch (FormatException e)
{
    Console.WriteLine($"{e.GetType().Name}: {e.Message}");
}

// Remove them first, or split on them
Console.WriteLine(Convert.FromHexString(dashed.Replace("-", "")).Length);
byte[] parsed = dashed.Split('-').Select(p => Convert.ToByte(p, 16)).ToArray();
Console.WriteLine(string.Join(", ", parsed));

using System.Text;

byte[] bytes = [0x00, 0x0F, 0xA5, 0xFF, 0x10];

// "x2" = lowercase hex, padded to 2 digits ("X2" for uppercase)
var sb = new StringBuilder(bytes.Length * 2);
foreach (byte b in bytes)
{
    sb.Append(b.ToString("x2"));
}
Console.WriteLine(sb.ToString());

// The same thing with LINQ
Console.WriteLine(string.Concat(bytes.Select(b => b.ToString("X2"))));

// Without the 2, small bytes lose their leading zero
Console.WriteLine(string.Concat(bytes.Select(b => b.ToString("x"))));

// A loop is the way to get your own layout
Console.WriteLine(string.Join(" ", bytes.Select(b => $"{b:X2}")));
Console.WriteLine(string.Join(", ", bytes.Select(b => $"0x{b:X2}")));
Console.WriteLine(string.Join(":", bytes.Select(b => $"{b:x2}")));

using System.Buffers;

// FromHexString wants an even number of hex digits and nothing else
string[] inputs = ["48656C6C6F", "48656c6c6f", "ABC", "0x4865", "48 65 6C", "zz"];
foreach (string s in inputs)
{
    try
    {
        byte[] data = Convert.FromHexString(s);
        Console.WriteLine($"\"{s}\" -> [{string.Join(", ", data)}]");
    }
    catch (FormatException e)
    {
        Console.WriteLine($"\"{s}\" -> FormatException: {e.Message}");
    }
}

// Clean up the input you expect, then parse
string pasted = "0x48 65 6C 6C 6F";
string clean = pasted.Replace("0x", "").Replace(" ", "");
Console.WriteLine(Convert.FromHexString(clean).Length);

// .NET 9+: a non-throwing overload that writes into a buffer
Span<byte> buffer = stackalloc byte[16];
OperationStatus status = Convert.FromHexString("48656C6C6F", buffer, out _, out int written);
Console.WriteLine($"{status}: {written} bytes");
status = Convert.FromHexString("4865zz", buffer, out _, out written);
Console.WriteLine($"{status}: {written} bytes");

// Older frameworks (.NET Framework, .NET Core 3.1): two characters at a time
Console.WriteLine(string.Join(", ", HexToBytes("48656C6C6F")));

static byte[] HexToBytes(string hex)
{
    if (hex.Length % 2 != 0) throw new FormatException("Odd number of hex digits.");
    var result = new byte[hex.Length / 2];
    for (int i = 0; i < result.Length; i++)
    {
        result[i] = Convert.ToByte(hex.Substring(i * 2, 2), 16);
    }
    return result;
}

using System.Buffers.Binary;

int n = 2748;

// "X" = uppercase, "x" = lowercase; a number pads with zeros
Console.WriteLine(n.ToString("X"));
Console.WriteLine(n.ToString("x"));
Console.WriteLine(n.ToString("X8"));
Console.WriteLine($"0x{n:X4}");

// Convert.ToString takes a base: 2, 8, 10 or 16 (lowercase)
Console.WriteLine(Convert.ToString(n, 16));
Console.WriteLine(Convert.ToString(n, 2));

// Negative numbers print their two's-complement bits
Console.WriteLine((-1).ToString("X"));
Console.WriteLine((-2748).ToString("X"));
Console.WriteLine((-1L).ToString("X"));
Console.WriteLine(((byte)200).ToString("X"));

// An int's bytes: BitConverter uses the machine's order (little-endian here)
int value = 0x12345678;
Console.WriteLine(BitConverter.IsLittleEndian);
Console.WriteLine(Convert.ToHexString(BitConverter.GetBytes(value)));

// BinaryPrimitives picks the order explicitly
byte[] big = new byte[4];
BinaryPrimitives.WriteInt32BigEndian(big, value);
Console.WriteLine(Convert.ToHexString(big));

using System.Globalization;

// int.Parse with NumberStyles.HexNumber: digits only, no 0x prefix
Console.WriteLine(int.Parse("ABC", NumberStyles.HexNumber));
Console.WriteLine(int.Parse("abc", NumberStyles.HexNumber));

// Convert.ToInt32(s, 16) also accepts a leading 0x
Console.WriteLine(Convert.ToInt32("ABC", 16));
Console.WriteLine(Convert.ToInt32("0xABC", 16));

try
{
    int.Parse("0xABC", NumberStyles.HexNumber);
}
catch (FormatException e)
{
    Console.WriteLine($"{e.GetType().Name}: {e.Message}");
}

// TryParse for input you don't control
foreach (string s in new[] { "ff", "0xff", "fg", "" })
{
    string digits = s.StartsWith("0x", StringComparison.OrdinalIgnoreCase) ? s[2..] : s;
    bool ok = int.TryParse(digits, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out int v);
    Console.WriteLine($"\"{s}\" -> {ok} {v}");
}

// Eight hex digits fill all 32 bits, so the top bit is the sign
Console.WriteLine(int.Parse("FFFFFFFF", NumberStyles.HexNumber));
Console.WriteLine(uint.Parse("FFFFFFFF", NumberStyles.HexNumber));
Console.WriteLine(long.Parse("FFFFFFFF", NumberStyles.HexNumber));

// Nine digits don't fit in an int
try
{
    int.Parse("1FFFFFFFF", NumberStyles.HexNumber);
}
catch (OverflowException e)
{
    Console.WriteLine($"{e.GetType().Name}: {e.Message}");
}