Before Unicode and ISO 10646 were merged, ISO 10646 defined a 31-bit form for the Universal Coded Character Set (UCS-4). Each code uses 4 bytes, and the space runs from 0x00000000 to 0x7FFFFFFF (more than 2 billion characters). UCS-4 has more than 2 billion code positions, but actual use does not go past 0x10FFFF. To stay compatible with Unicode, ISO also promised not to assign UCS-4 codes above 0x10FFFF. UTF-32 uses the same values as UCS-4, but its space is limited to 0 through 0x10FFFF. UTF-32 is a subset of UCS-4.

Besides UCS-4, ISO 10646 defined a 16-bit form (UCS-2). Each code uses 2 bytes and has 65,536 positions (enough for the 63K most common characters worldwide; 0xD800-0xDFFF is left unused for Unicode compatibility). For example, the UCS-2 code of “汉” is 6C49. Two bytes are not enough to be truly universal, so UTF-16 was created. Like UCS-2, it uses two bytes for the 63K most common characters. Unlike UCS-2, it uses 4 bytes for less common characters. UTF-16 is a variable-length encoding.

Unicode code points are divided into 17 planes, each with 2^16 (65,536) code points. The first plane is the Basic Multilingual Plane (BMP). The others are supplementary planes. In the BMP (0-0xFFFF), 0xD800-0xDFFF is reserved and unused. UCS-2 can encode only BMP characters. For those characters, UTF-16 and UCS-2 use the same values (the Unicode code point itself). For example, “汉” has code point 6C49 and UTF-16 code 6C49. UTF-16 can also use the reserved range 0xD800-0xDFFF to encode supplementary-plane characters, so it can encode every Unicode character.

How does UTF-16 encode a supplementary plane?
Unicode code points run from 0 to 0x10FFFF. Outside the BMP, 0xFFFFF code points remain, all greater than or equal to 0x10000. Subtract 0x10000 from a supplementary-plane code point and the result is in 0-0xFFFFF, which fits in 20 bits. Add 0xD800 to the high 10 bits to get the first two bytes of the UTF-16 code. Add 0xDC00 to the low 10 bits to get the last two bytes. For example: The character “𪺫” has Unicode code point 2AEAB. Subtract 0x10000 to get 1AEAB (binary 0001 1010 1110 1010 1011). The high 10 bits plus D800 give D86B, and the low 10 bits plus DC00 give DEAB. The UTF-16 code is D86BDEAB in big-endian order, or 6BD8ABDE in little-endian order.

string hex = "6BD8ABDE";
byte[] hexByteArr = Enumerable.Range(0, hex.Length)
                                    .Where(x => x % 2 == 0)
                                    .Select(x => Convert.ToByte(hex.Substring(x, 2), 16))
                                    .ToArray();
string word = UnicodeEncoding.Unicode.GetString(hexByteArr);

UTF-16, UTF-32, UCS-2, and UCS-4 all use more than one byte for every character, which wastes bandwidth for English text. UTF-8 avoids that. ASCII characters keep their ASCII values and use one byte. Other characters use 2, 3, or 4 bytes.

UTF-8 encoding rules:
(1) Symbols in ASCII use a single byte, and the value is the same as the ASCII value. ASCII values run from 0 to 0x7F, so the first bit of every one-byte code is 0. That bit separates one-byte codes from multi-byte codes.
(2) Other characters use several bytes (N bytes). The first N bits of the first byte are 1, bit N+1 is 0, and the first two bits of each of the remaining N-1 bytes are 10. The other bits store the Unicode code point.

Bytes	Unicode	Decimal	UTF-8
1	000000-00007F	0-127	0xxxxxxx
2	000080-0007FF	128-2047	110xxxxx 10xxxxxx
3	000800-00FFFF	2048-65535	1110xxxx 10xxxxxx 10xxxxxx
4	010000-10FFFF	65536-1114111	11110xxx 10xxxxxx 10xxxxxx 10xxxxxx

For values above ASCII, the leading 1 bits of the first byte tell how long the character is. 110xxxxx means a 2-byte character. 1110xxxx means a 3-byte character, and so on. The x bits are filled with the binary code point. In a multi-byte sequence, the number of leading 1s in the first byte is the number of bytes in the sequence.

• Unicode is just a 16-bit encoding. Some people think every character takes 16 bits, so there are only 65,536 possible characters. That is not true. It is the most common misunderstanding about Unicode.
• Can any unassigned code point be used internally? No. Unassigned positions will eventually be given to a character. Use private-use code points or noncharacter code points.
• Does every Unicode code point represent a character? No. There are noncharacter code points (FFFE, FFFF, 1FFFE, and so on), surrogate code points, private-use code points, unassigned code points, and control and format characters (RLM, ZWNJ, and so on).
• Is character mapping one-to-one? No. A mapping can also be:
  • One-to-many: (ß → SS)
  • Context-dependent: (…Σ ↔ …ς and …ΣΤ… ↔ …στ…)
  • Language-dependent: (I ↔ ı and İ ↔ i)