Data Type and Type Conversion in C# .

NET
In this article I will explain about one of the main topics in C# - Data Types. You will
also learn about the value and reference types, type conversions and other features
related to data types.

C# is a strongly typed language; therefore every variable and object must have a
declared type.

Proper utilization of correct data types allows developers to make the most of the
language

Data type in C#
There are two types of data type in C#:

1. Primitive (Predefine)dNon-Primitive (User Defined)

Primitive data types are further divided as,

• byte
• short
• int
• float
• double
• long
• char
• bool
• datetime
• string
• object
etc

Non-primitive data types are further divided as,

• class
• struct
• enum
• interface
• delegate
• array
Encoding Scheme To represent coding scheme.
ASCII 8 bits 28 = 256
8
ANSI 7 bits 7 = 128
16
Unicode character sets 16 bits 2 = 65000

UTF (Unicode text file) can be,

• UTF 7
• UTF 8
• UTF 16
• UTF 32
Integer Type
C# supports eight predefined integer types,

Name CTS Type Description Range

sbyte System.SByte 8-bit signed integer -128 to 127 (-27 to 27-1)
short System.Int16 16-bit signed integer -32768 to 32767 (-215 to 215-1)
-2147483648 to
int System.Int32 32-bit signed integer
2147483647 (-231 to 231-1)
-9223372036854775808 to
long System.Int64 64-bit signed integer
9223372036854775807 (-263 to 263-1)
byte System.Byte 8-bit unsigned integer 0 to 255 (0 to 28-1)
ushort System.UInt16 16-bit unsigned integer 0 to 65535 (0 to 216-1)
uint System. UInt32 32-bit unsigned integer 0 to 4294967295 (0 to 232-1)
ulong System. UInt64 64-bit unsigned integer 0 to 18446744073709551615 (0 to 264-1)
Floating Point Type
Significant
Name CTS Type Description Range (approx.)
Figures
32-bit single precision plus & minus 1.5 X 10-
float System.Single 7 45
floating point to ±3.4 X 1038
32-bit single precision plus & minus 5.0 X 10-
double System.Double 15/16 3245
floating point to ±3.4 X 10308
Decimal Type
Significant
Name CTS Type Description Range (approx.)
Figures
128-bit high precision plus & minus 1.0 X
decimal System.Decimal 28
decimal notation 10-28 to ±7.9 X 1028
Boolean Type
Name CTS Type Values
bool System.Boolean true and false
Character Type
Name CTS Type Values
char System.Char Represents a single 16-bit (Unicode) character)
C# supports two predefined Reference Type
Name CTS Type Values
The root type, from which all other types in the CTS derive
object System.Object
(including value type)
string System.String Unicode character string

In .NET Microsoft has divided data types in two parts,

1. Value Type (Fixed in size)

2. Reference Type (Not fixed in size)

In application context, value types are stored in stack but reference types are
stored in managed heap.

Value Type
• Value types are fixed in size.
• Value types are made in system stack.
• Actual values of data are stored in stack.
• If you assign a value of a variable to another it will create two copies.

All primitive data type except string and object are example of value types.

Object is a super type. It can store any type and any size of data. Object is called
super type because it helps in inheritance.

struct and enum are value type.

Note
Stack is an operation entity (LIFO) i.e. it is fixed in size.
Reference Type
• Reference types are not fixed in size.
• They are maintained in system managed heap but it also uses stack to
store reference of heap.
• Two primitive types (string and object) and non-primitive data types
(class, interface & delegate) are examples of reference type.
CLR manages heap (large memory area). Heap address is accessed from stack. In
reference type reference is used for processing using both managed heap and
stack (operational entity).

Type Conversions
Conversion is based on type compatibility and data compatibility.

There are two types of conversions:

1. Implicit Conversion
2. Explicit Conversion
Implicit Conversion

In implicit conversion the compiler will make conversion for us without asking.

char -> int -> float is an example of data compatibility.

Complier checks for type compatibility at compilation.

Practical demonstration of implicit conversion,

1. using System;
2. namespace implicit_conversion
3. {
4. class Program
5. {
6. static void Main(string[] args)
7. {
8. int num1 =20000;
9. int num2 =50000;
10. long total;
11. // In this the int values are implicitly convert
ed to long data type;
12. //you need not to tell compiler to do the conver
sion, it automatically does.
13. total = num1 + num2;
14. Console.WriteLine($"Total is : {total}");
15. Console.ReadLine();
16. }
17. }
18. }

Below table shows the implicitly type conversions that are supported by C#,
From To
sbyte short, int, long, float, double, decimal
byte short, ushort, int, uint, long, ulong, float, double, decimal
short int, long, float, double, decimal
ushort int, uint, long, ulong, float, double, decimal
int long, float, double, decimal
uint long, ulong, float, double, decimal
long float, double, decimal
ulong float, double, decimal
float double
char ushort, int, uint, long, ulong, float, double, decimal
Explicit Conversion

In explicit conversion we specifically ask the compiler to convert the value into
another data type.

CLR checks for data compatibility at runtime.

Explicit conversion is carried out using casts. When we cast one type to another, we
deliberately force the compiler to make the transformation.

You should never expect that the cast would give you best or correct result. Casts
are potentially unsafe. Casting of big data type into small may lead to loosing of
data.
Practical demonstration of explicit conversion,

1. using System;
2. namespace explicit_conversion
3. {
4. class Program
5. {
6. static void Main(string[] args)
7. {
8. int num = 65;
9. char alpha;
10. alpha = (char)num;
11. // In this the int values are explicitly convert
ed to char data type;
12. //you have to tell compiler to do the conversion
, it uses casting.
13. Console.WriteLine($"alphabet is: {alpha}");
14. Console.ReadLine();
15. }
16. }
17. }
Note
You can also use Explicit Cast Operator () and unboxing for explicit conversion.

Microsoft .NET provides three ways of type conversion:

1. Parsing
2. Convert Class
3. Explicit Cast Operator ()
Parsing
Parsing is used to convert string type data to primitive value type. For this we use
parse methods with value types.

Practical demonstration of parsing

1. using System;
2. namespace parsing
3. {
4. class Program
5. {
6. static void Main(string[] args)
7. {
8. //using parsing
9. int number;
10. float weight;
11. Console.Write("Enter any number : ");
12. number = int.Parse(Console.ReadLine());
13. Console.Write("Enter your weight : ");
14. weight = float.Parse(Console.ReadLine());
15. Console.WriteLine($"You have entered : {number}"
);
16. Console.WriteLine($"You weight is : {weight}");

17. Console.ReadLine();
18. }
19. }
20. }
Convert Class
One primitive type to another primitive type.

This class contains different static methods like ToInt32(), ToInt16(), ToString(),
ToDateTime() etc used in type conversion.

Practical demonstration of Convert class

1. using System;
2. namespace convert_conversion
3. {
4. class Program
5. {
6. static void Main(string[] args)
7. {
8. // example of using convert class
9. string num = "23";
10. int number = Convert.ToInt32(num);
11. int age = 24;
12. string vote = Convert.ToString(age);
13. Console.WriteLine($"Your number is : {number}");

14. Console.WriteLine($"Your voting age is : {age}")

;
15. Console.ReadLine();
16. }
17. }
18. }
Explicit Cast Operator ()
In general this operator is used with non-primitive types to up level or down level
casting. But it can also used with any type having type compatibility and data type
compatibility.

1. using System;
2. namespace explicit_cast_conversion
3. {
4. class Program
5. {
6. static void Main(string[] args)
7. {
8. int num1, num2;
9. float avg;
10. num1 = 10;
11. num2 = 21;
12. avg = (float)(num1 + num2) / 2;
13. Console.WriteLine($"average is : {avg}");
14. Console.ReadLine();
15. }
16. }
17. }

Boxing and unboxing

Boxing and unboxing is an important concept in C# type system. With Boxing and
unboxing one can link between value-types and reference-types by allowing any
value of a value-type to be converted to and from type object.

Boxing
• Boxing is a mechanism in which value type is converted into reference
type.
• It is implicit conversion process in which object type (super type) is used.
• In this process type and value both are stored in object type
Unboxing
• Unboxing is a mechanism in which reference type is converted into
value.
• It is explicit conversion process.
Program to show boxing and unboxing:

1. using System;
2. namespace boxing
3. {
4. class Program
5. {
6. static void Main(string[] args)
7. {
8. int i = 10;
9. object o = i; // boxing
10. int j = (int)o; // unboxing
11. Console.WriteLine("value of o object : " + o);
12. Console.WriteLine("Value of j : " + j);
13. Console.ReadLine();
14. }
15. }
16. }
Hope you have got some idea about data types, value type and reference type and
boxing and unboxing. Your feedback and constructive contributions are
welcome. Please feel free to contact me for feedback or comments you may have
about this article.