C# Cast ExamplesLearn how to cast variables and perform complex conversions between types.
dot net perls
Casts. Casting variables is complex: in C# a set of rules resolves casts. In some cases data is lost and the cast cannot be reversed. In others an exception is provoked.
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.
Simple examples. 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); } } }
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); } } }
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); } }
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.
Convert Char, String
Convert Dictionary, 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); } }
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.
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); } } }
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); } }
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.
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
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.
© 2007-2021 sam allen. see site info on the changelog