## #1,111 – Converting an Integer to a String in a Different Base

You can convert an integer-based value to a string using the ToString method on the integer.  This results in a string representing the integer as a base 10 number.

```            int i = 42;
// ToString() called implicitly
Console.WriteLine(i);  // base 10
```

You can also convert integer-based values to strings that represent the number in base 2 (binary), 8 (octal), or 16 (hexadecimal).  You use the Convert.ToString method, passing it the number to convert and the base.

```            int i = 42;
int i2 = 1964;
int i3 = -128;

Console.WriteLine("{0} dec, {1} hex, {2} oct, {3} bin",
i,
Convert.ToString(i, 16),
Convert.ToString(i, 8),
Convert.ToString(i, 2));

Console.WriteLine("{0} dec, {1} hex, {2} oct, {3} bin",
i2,
Convert.ToString(i2, 16),
Convert.ToString(i2, 8),
Convert.ToString(i2, 2));

Console.WriteLine("{0} dec, {1} hex, {2} oct, {3} bin",
i3,
Convert.ToString(i3, 16),
Convert.ToString(i3, 8),
Convert.ToString(i3, 2));
```

## #1,015 – Rendering a Byte Array as a Series of Hex Characters

You can use the BitConverter class to get a hex representation of a string of bytes.

For example:

```            byte[] someBytes = { 0x83, 0xDF, 0x0A, 0xA3, 0x92 };

string hex = BitConverter.ToString(someBytes);
Console.WriteLine(hex);
```

## #1,001 – Representing Unicode Surrogate Pairs

UTF-16 encodes Unicode code points above U+FFFF using surrogate pairs that take up 4 bytes.

You can specify a surrogate pair within a string literal by inserting the character directly into the string (provided that you have a keyboard that can insert the character):

```            string myString = "𠈓";   // CJK Ideograph
```

You can also represent the surrogate pair within a string literal using the \Unnnnnnnn (4 byte) syntax to specify the Unicode code point or the \unnnn\unnnn syntax to specify the encoded surrogate pair value.

```            string s1 = "\U00020213";    // Codepoint E+20213
string s2 = "\uD840\uDE13";  // Surrogate pair
```

Note that because a surrogate pair requires more then 2 bytes, you cannot represent a surrogate pair within a single character (System.Char) literal.

## #320 – The Constant Expression for a Reference-Typed Constant Must Be Null

The declaration of a constant may use a reference type as the type of the constant.  However, reference types other than string are seldom seen.  The compiler needs to evaluate the value of the constant at compile time.  This means that the constant expression cannot invoke a method on a reference type.  The only valid value in the expression is therefore null.

```            // Marginally useful
const Dog TheNullDog = null;

// Not allowed - Compile-time ERROR
const Dog ConstantBob = new Dog("Bob");
```

One exception to this rule about only using null in a constant expression for a reference type is the string (System.String) class.  A constant of type string may be initialized with a string literal.

```            // string constants can be initialized, although they are reference types
const string MyDogsName = "Kirby";
```

## #98 – Using an Indexer to Get a Specific Character In a String

In C#, you can use the indexer operator [ ], to get a specified character in a string.

The indexer takes a zero-based integer as an index into the string.  0 returns the first character and n-1 (where n is the length of the string) returns the last character.

``` string s = "ABCDE";
char c = s[0];   // A
c = s[2];        // C (3rd char)
c = s[4];        // E
```

Using a negative value for the index will result in an IndexOutOfRangeException being thrown.

Note that indexers work to extract Unicode characters only if they are 2-byte UTF16 characters.  The indexer cannot retrieve a 4-byte surrogate pair.

``` string s = "A€C";
char c = s[1];         // Works: €

s = "A𠈓C";
c = s[1];       // Doesn't work: unprintable character
```