C# Cast Examples

Learn how to cast variables. Perform complex conversions between types.
Casts. Casting variables is complex. A set of rules resolves casts. In some cases data is lost and the cast cannot be reversed. In others an exception is provoked.Exception
Conversions, specified as methods or operators, are often required. Lists and arrays are similar, but not the same. To convert, we use ToList and ToArray.Convert
Is, as casts. We cast a double value to an int. This is an explicit numeric cast. Some casts may be implicit (not specified in the syntax).Cast, Int

Operators: With the is-operator we cast an object reference. Finally we cast that same reference with the as-operator.


So: The StringBuilder is converted to an object and then back into a StringBuilder reference.

C# program that uses casts using System; using System.Text; class Program { static void Main() { int value = (int)1.5; // Cast 1. Console.WriteLine(value); object val = new StringBuilder(); if (val is StringBuilder) // Cast 2. { StringBuilder builder = val as StringBuilder; // Cast 3. Console.WriteLine(builder.Length == 0); } } } Output 1 True
Implicit, explicit. Implicit casts are not visible in the source text. The explicit (int) on the left side of a variable or expression casts to an int.

Example: Here the integer cast succeeds. But we then try to cast to an invalid type.

Warning: If you incorrectly use a cast expression, you will cause an InvalidCastException to be thrown.


Implicit casts: Intended never to provoke an exception. These are used when a value is expanded to more bytes.

Explicit casts: Allowed to provoke an exception. Explicit casts are used when a value is reduced to fewer bytes.

C# program that uses cast expressions using System; class Program { static void Main() { // Assign an int and then cast it to an object implicitly. int value1 = 400; object value2 = value1; // Explicitly cast to an integer again. int value3 = (int)value2; Console.WriteLine(value3); // Try to cast it to a string. try { string value4 = (string)value2; } catch (Exception ex) { Console.WriteLine(ex); } } } Output 400 System.InvalidCastException: Unable to cast object of type 'System.Int32' to type 'System.String'. at Program.Main()
Convert. A List is not an array. This is no problem unless we need an array. Conversions are possible for both simple values and complex data types.

Examples: These examples show how to convert types. The provided conversions are more complex than casts.

Here: In this program, we use an extension from the System.Linq namespace to convert an array into a List.

C# program that converts array to List using System; using System.Collections.Generic; using System.Linq; class Program { static void Main() { int[] array = { 1, 2, 3 }; List<int> list = array.ToList(); Console.WriteLine(array[0] == list[0]); Console.WriteLine(array.Length == list.Count); } } Output True True
Strings, arrays, collections. With ToCharArray we convert a string into its equivalent char array. Custom methods, which often use Split, can parse more complex formats.Char to StringDictionary to String

ToCharArray: This method is provided on the string class. It returns the underlying buffer of a string as a char array.

C# program that converts string, array using System; class Program { static void Main() { // A string value. string value = "test"; // Convert the string into an array. char[] array = value.ToCharArray(); // Display parts of the array. Console.WriteLine(array[0]); Console.WriteLine(array.Length); } } Output t 4
Char. All chars have an underlying integer representation. A lowercase a, for example, is 97. We can implicitly cast a char to an int, as an int is larger.Char

However: To cast from an int to a char, a cast is needed. This is a narrowing conversion where data loss is possible.

Sizes: A char is only 2 bytes. But an int is 4 bytes—so larger numbers in an int cannot be safely turned into chars.

C# program that casts char using System; class Program { static void Main() { for (char c = 'a'; c <= 'e'; c++) { // Cast the char to an int. int code = c; // Cast the int to a char. // ... An int is larger than a char. // ... So an explicit cast is needed. char original = (char)c; Console.WriteLine(c + "..." + code + "..." + original); } } } Output a...97...a b...98...b c...99...c d...100...d e...101...e
Numeric promotion. C# uses numeric promotion when it needs to use smaller types as arguments to a method that receives a larger type. This occurs as part of an arithmetic expression.

So: To get an int from an addition, you have to use 2 ints. But sometimes a number can be implicitly cast.

Int, uint

Example: We try to add a short and a ushort. The program compiles and executes correctly.

short, ushort

But: In the addition expression, both variables are promoted to the int type. They can then fit into the binary operator for int addition.

C# program that shows numeric promotion using System; class Program { static void Main() { short a = 10; ushort b = 20; // Binary numeric promotion occurs here. // ... a and b become ints before they are added. int c = a + b; Console.WriteLine(c); } } Output 30
Errors, numeric promotion. Promotion only "expands" types—it cannot larger types to smaller ones. You cannot implicitly cast a long to an int—data loss would likely occur.
Numeric casts. Many casts apply to number types. We cast numeric values. We explore the intermediate language's casting instructions.Numeric Casts
Type hierarchy. This is used to specify behavior based on the structure of a program. We specify differences in methods called through the derivation chain.

Note: Type hierarchies are implemented with a matrix. In casts, this matrix determines if the cast succeeds. This is "transitive closure."

Operators. We can define conversion operators with method bodies. Implicit conversions require no special syntax. Explicit ones require a cast expression.Explicit, Implicit
In compiler textbooks, we learn that an implicit conversion is one done automatically. This kind of cast is called a "coercion." The C# compiler limits coercions to lossless operations.

Quote: Conversion from one type to another is said to be implicit if it is done automatically by the compiler. Implicit type conversions, also called coercions, are limited in many languages to widening conversions (Compilers: Principles, Techniques and Tools).

Cast expressions abound. We demonstrated explicit and implicit casts. An explicit cast expression can provoke a runtime exception. An implicit one does not.
A summary. Casting relies on the type hierarchy. With the "is" and "as" operators we safely cast. For complex conversions, custom methods are needed.
Dot Net Perls
© 2007-2020 Sam Allen. Every person is special and unique. Send bug reports to