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).
So The StringBuilder is converted to an object and then back into a StringBuilder reference.
using System;
using System.Text;
// Numeric cast.
int value = (int)1.5;
Console.WriteLine(value);
object val = new StringBuilder();
// Is cast.
if (val is StringBuilder)
{
// As cast.
StringBuilder builder = val as StringBuilder;
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.
Detail 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.
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.
Detail 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.
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.
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.
Detail A char is only 2 bytes. But an int is 4 bytes—so larger numbers in an int cannot be safely turned into chars.
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.
But In the addition expression, both variables are promoted to the int type. They can then fit into the binary operator for int addition.
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);
}
}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.
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.
Dot Net Perls is a collection of tested code examples. Pages are continually updated to stay current, with code correctness a top priority.
Sam Allen is passionate about computer languages. In the past, his work has been recommended by Apple and Microsoft and he has studied computers at a selective university in the United States.
This page was last updated on Mar 1, 2023 (simplify).
