C# Data Types with Examples

decimal myDecimal = 3.0;  // This will be treated as a decimal

decimal data types have a fixed size of 128 bits and can represent values in the range of approximately -7.9 x 10^28 to 7.9 x 10^28, with 28 to 29 significant digits. Therefore, it is more accurate and is a good choice for applications where accuracy is critical.

double

The double data type is a primitive data type in C# that is used to represent a double-precision floating-point number. A floating-point number is a type of number that has a decimal point and can represent values with a fractional part, such as 3.14 or 42.8.

The double data type can hold a wider range of values than the float data type.

double data types are often used to represent approximate values, such as measurements or calculations that may involve a certain degree of uncertainty. This is because double data types have a larger range of values and a higher precision than other primitive data types that can represent decimal numbers, such as float and decimal.

To declare a double variable in C#, you can use the following syntax:

double myDouble = 3.14;

You can also assign a double value to a variable using the following syntax:

myDouble = 42.8;

Here are some examples of using the double data type in C# code:

double pi = 3.14159;
double gravity = 9.8;
double price = 19.99;
double distance = 123.456;

In the first example, the double variable pi is assigned the value of 3.14159.

In the second example, the double variable gravity is assigned the value of 9.8. In the third example, the double variable price is assigned the value of 19.99.

And in the fourth example, the double variable distance is assigned the value of 123.456.

It is important to note that double values must be initialized with a decimal point and at least one digit after the decimal point. If you try to initialize a double value without a fractional part, it will be treated as an integer. For example:

double myDouble = 3;  // This will be treated as an integer

In this case, you would need to explicitly specify that the value is a double by including a decimal point and a digit after the decimal point, like this:

double myDouble = 3.0;  // This will be treated as a double

If you need a higher level of precision, you can use the decimal data type instead.

double data types have a fixed size of 64 bits and can represent values in the range of approximately -1.7 x 10^308 to 1.7 x 10^308, with 15 to 16 significant digits.

float

The float data type is a primitive data type in C# that is used to represent single-precision floating-point numbers. Floating-point numbers are numbers with a decimal point, such as 3.14 or 42.8.

float data types are typically used when a larger range of values is needed and when performance is important, as they are faster and require less memory than the other primitive data type that can represent decimal numbers, called decimal.

However, float data types have less precision than decimal data types, meaning that they can only represent a certain number of decimal places accurately.

To declare a float variable in C#, you can use the following syntax:

float myFloat = 3.14;

You can also assign a float value to a variable using the following syntax:

myFloat = 42.8;

Here are some examples of using the float data type in C# code:

float pi = 3.141592653589793238f;
float avogadro = 6.022140857f;
float myHeight = 5.5f;
float totalCost = 12.99f;

In the first example, the float variable pi is assigned the value of the mathematical constant pi.

In the second example, the float variable avogadro is assigned the value of the Avogadro constant.

In the third example, the float variable myHeight is assigned the value of 5.5, representing the height of an object in feet.

And in the fourth example, the float variable totalCost is assigned the value of 12.99, representing a monetary amount.

It is important to note that float values must be initialized with a decimal point and at least one digit after the decimal point. If you try to initialize a float value without a fractional part, it will be treated as an integer. For example:

float myFloat = 3;  // This will be treated as an integer

In this case, you would need to explicitly specify that the value is a float by including a decimal point and a digit after the decimal point, like this:

float myFloat = 3.0;  // This will be treated as a float

If you need a higher precision, you can use the double data type, which is a 64-bit value with a greater precision.

float data types have a fixed size of 32 bits and can represent values in the range of approximately -3.4 x 10^38 to 3.4 x 10^38, with 7 significant digits.

int (integer)

An int , short for integer, is a primitive data type in C# that is used to represent whole numbers. Whole numbers are numbers without a fractional part, such as 1, 2, or 42.

int data types are the most commonly used data type for representing whole numbers in C#, as they can hold a wide range of values and are efficient in terms of memory and performance.

To declare an int variable in C#, you can use the following syntax:

int myInt = 42;

You can also assign an int value to a variable using the following syntax:

myInt = 123;

Here are some examples of using the int data type in C# code:

int numEmployees = 50;
int numStudents = 100;
int total = numEmployees + numStudents;
int difference = numStudents - numEmployees;

In the first example, the int variable numEmployees is assigned the value of 50.

In the second example, the int variable numStudents is assigned the value of 100.

In the third example, the int variable total is assigned the result of adding numEmployees and numStudents together.

And in the fourth example, the int variable difference is assigned the result of subtracting numEmployees from numStudents.

It is important to note that int values can only represent whole numbers. If you try to initialize an int value with a decimal point or a fractional part, it will result in a compile-time error. For example:

int myInt = 3.14;  // This will result in a compile-time error

If you need to store a number with a decimal point, you should use the float or double data type.

int data types have a fixed size of 32 bits and can represent values in the range of approximately -2.1 x 10^9 to 2.1 x 10^9.

long

The long data type is a primitive data type in C# that is used to represent whole numbers. It is called a “long” integer because it can represent a wider range of values than the other integer data types in C#, such as int and short.

The long data type is used to store large whole numbers. It is a 64-bit signed integer, which means it can store values ranging from -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807. This makes the long data type suitable for storing large numbers that might not fit in the smaller int data type (which is a 32-bit signed integer).

Here are a few examples of when you might use the long data type in your C# code:

• When you need to store a very large whole number, such as the population of a country or the number of atoms in the observable universe
• When you need to perform arithmetic operations on large whole numbers, such as finding the sum or product of two large numbers
• When you need to compare large whole numbers to each other, such as determining which of two numbers is larger or smaller

To declare a long variable in C#, you can use the following syntax:

long myLong = 42;

You can also assign a long value to a variable using the following syntax:

myLong = 123456789;

Here are some examples of using the long data type in C# code:

long population = 1234567890;
long distance = 99999999999;
long maxValue = 9223372036854775807;
long minValue = -9223372036854775808;

In the first example, the long variable population is assigned the value of 1234567890.

In the second example, the long variable distance is assigned the value of 99999999999.

In the third example, the long variable maxValue is assigned the maximum value that a long can hold (9,223,372,036,854,775,807).

And in the fourth example, the long variable minValue is assigned the minimum value that a long can hold (-9,223,372,036,854,775,808).

It is important to note that long values must be integers. If you try to assign a decimal value to a long variable, it will result in a compile-time error. For example:

long myLong = 3.14;  // This will result in a compile-time error

In this case, you would need to use a different data type to represent the decimal value, such as decimal or double.

long data types have a fixed size of 64 bits and can represent values in the range of approximately -9.2 x 10^18 to 9.2 x 10^18. This is a much larger range of values than the int data type, which can only represent values in the range of -2,147,483,648 to 2,147,483,647.

sbyte

The sbyte data type is a primitive data type in C# that is used to represent signed 8-bit integers. An sbyte is a small integer value that can hold both positive and negative values (in the range of -128 to 127).

sbyte values are commonly used in C# when you need to represent a small integer value and you want to save memory, as sbyte variables take up less space in memory than larger integer data types such as int or long .

Here are some examples of sbyte values and their corresponding binary representations:

To declare an sbyte variable in C#, you can use the following syntax:

sbyte mySbyte = -128;

You can also assign an sbyte value to a variable using the following syntax:

mySbyte = 127;

Here are some examples of using the sbyte data type in C# code:

sbyte temperature = -5;
sbyte score = 15;
sbyte price = -50;
sbyte quantity = 100;

In the first example, the sbyte variable temperature is assigned the value of -5.

In the second example, the sbyte variable score is assigned the value of 15.

In the third example, the sbyte variable price is assigned the value of -50.

And in the fourth example, the sbyte variable quantity is assigned the value of 100.

It is important to note that the range of values that an sbyte can represent is from -128 to 127. If you try to assign a value outside of this range, you will get an overflow error. For example:

sbyte mySbyte = 128;  // This will cause an overflow error

If you need to store larger or negative integers, you should consider using a different data type such as short, int, or long.

short

A short data type is a primitive data type in C# that is used to represent an integer value with a smaller range than the int data type. A short data type is a 16-bit signed integer, which means it can represent values from -32,768 to 32,767.

Short data types are often used when memory is limited or when a smaller range of values is sufficient for the task at hand. For example, you might use a short data type to represent the number of students in a class, as it is unlikely that a class would have more than 32,767 students.

To declare a short variable in C#, you can use the following syntax:

short myShort = -32768;

You can also assign a short value to a variable using the following syntax:

myShort = 32767;

It is important to note that short values must be within the range of -32,768 to 32,767. If you try to assign a value outside of this range, you will get an error. For example:

short myShort = 32768;  // This will cause an error

In this case, you would need to use a different data type, such as int, to represent the larger value.

uint (unsigned integer)

In C#, one of the primitive data types is uint, which stands for “unsigned integer.”

An uint is a 32-bit integer data type that can hold a positive whole number value ranging from 0 to 4,294,967,295. It is called an “unsigned” data type because it only holds positive values and does not have a sign (positive or negative). This makes it useful for storing values that can never be negative, such as the number of items in a collection or the number of times a specific event has occurred.

To declare an uint variable in C#, you can use the following syntax:

uint myUint;

You can also assign a value to the uint variable when you declare it, like this:

uint myUint = 100;

Here are some examples of using the uint data type in C# code:

uint numItems = 15;
uint numVisitors = 200;
uint maxValue = uint.MaxValue;

In the first example, the uint variable numItems is assigned the value of 15.

In the second example, the uint variable numVisitors is assigned the value of 200.

And in the third example, the uint variable maxValue is assigned the maximum value that an uint variable can hold, which is 4,294,967,295.

Important to note: the uint data type is not suitable for storing negative numbers or numbers with decimal points. For these types of values, you should use other data types such as int or float.

ulong (unsigned long)

The ulong data type is another primitive data type in the C# programming language. It is used to represent unsigned long integers, which are whole numbers that can range from 0 to 18,446,744,073,709,551,615.

The ulong data type is a 64-bit integer, which means it requires 64 bits of memory to store a single value. It is larger than the uint (unsigned integer) data type, which is only 32 bits, and the long data type, which is also 64 bits but can represent both positive and negative values.

One common use for the ulong data type is when dealing with large counts or quantities that will not be negative. For example, if you are tracking the number of items in a warehouse, you could use a ulong to store the count because it is unlikely that the quantity will ever be negative.

To declare a ulong variable in C#, you can use the following syntax:

ulong myULong;

ulong myULong = 123456789;

ulong maxULong = 18446744073709551615;
ulong largeNumber = 9223372036854775807;
ulong zero = 0;

ushort myUShort;

ushort myUShort = 100;

ushort smallNumber = 50;
ushort largeNumber = 60000;
ushort maxValue = ushort.MaxValue;

string myString = "This is a string";

int num = 10;
string myString = $"The value of num is {num}";

string greeting = "   Hello World!   ";
string trimmedGreeting = greeting.Trim();
console.WriteLine(trimmedGreeting.ToUpper());

string concatenatedString = String.Concat("Hello", " ", "World");
console.WriteLine(concatenatedString);

HELLO WORLD!
Hello World

object obj = new object();

List<object> list = new List<object>();
list.Add(1);
list.Add("hello");
list.Add(true);

dynamic myVariable = "hello";
Console.WriteLine(myVariable.GetType());  // Outputs "System.String"

myVariable = 100;
Console.WriteLine(myVariable.GetType());  // Outputs "System.Int32"

myVariable = new List<int>();
Console.WriteLine(myVariable.GetType());  // Outputs "System.Collections.Generic.List`1[System.Int32]"

int[] numbers = new int[5]; // Declare an array of integers with 5 elements
numbers[0] = 10; // Assign a value to the first element of the array
numbers[1] = 20; // Assign a value to the second element of the array
// etc.

public class Circle
{
    public double Radius { get; set; } // Property to store the radius of the circle

    public double CalculateArea() // Method to calculate the area of the circle
    {
        return Math.PI * Radius * Radius;
    }
}

// In another part of the program:
Circle circle = new Circle(); // Create an instance of the Circle class
circle.Radius = 10; // Set the radius of the circle
double area = circle.CalculateArea(); // Calculate the area of the circle

public interface IShape
{
    double CalculateArea(); // Method to calculate the area of a shape
    double CalculatePerimeter(); // Method to calculate the perimeter of a shape
}

public class Circle : IShape // Circle class implements the IShape interface
{
    public double Radius { get; set; } // Property to store the radius of the circle

    public double CalculateArea() // Method to calculate the area of the circle
    {
        return Math.PI * Radius * Radius;
    }

    public double CalculatePerimeter() // Method to calculate the perimeter of the circle
    {
        return 2 * Math.PI * Radius;
    }
}

public class Rectangle : IShape // Rectangle class also implements the IShape interface
{
    public double Width { get; set; } // Property to store the width of the rectangle
    public double Height { get; set; } // Property to store the height of the rectangle

    public double CalculateArea() // Method to calculate the area of the rectangle
    {
        return Width * Height;
    }

    public double CalculatePerimeter() // Method to calculate the perimeter of the rectangle
    {
        return 2 * (Width + Height);
    }
}

// In another part of the program:
IShape shape = new Circle(); // Create an instance of the Circle class that implements the IShape interface
double area = shape.CalculateArea(); // Calculate the area of the circle

public delegate void PrintMessage(string message); // Define a delegate type for a method that takes a string argument and returns void

public static void PrintToConsole(string message) // Method that takes a string argument and prints it to the console
{
    Console.WriteLine(message);
}

// In another part of the program:
PrintMessage printMessage = PrintToConsole; // Assign the PrintToConsole method to the delegate
printMessage("Hello, world!"); // Invoke the delegate, which will execute the PrintToConsole method

public enum DaysOfTheWeek
{
    Monday,
    Tuesday,
    Wednesday,
    Thursday,
    Friday,
    Saturday,
    Sunday
}

DaysOfTheWeek today = DaysOfTheWeek.Monday;

int num = 10;
long bigNum = num;

class Animal { }
class Dog : Animal { }

Animal animal = new Dog();

int number = 123;
long biggerNumber = (long)number;

In this example, the value of the int variable number is converted to a long and stored in the biggerNumber variable.

double pi = 3.14159;
int truncatedPi = (int)pi;

In this example, the value of the double variable pi is converted to an int and stored in the truncatedPi variable. Note that this will result in the loss of precision, as the decimal portion of the double value will be truncated.

string input = "12345";
int parsedInput = (int)input;

In this example, the value of the string variable input is converted to an int. However, this will result in a runtime error, as the string value must be parsed (converted to a numerical data type) before it can be explicitly converted.

string str = "123";
int num = int.Parse(str);

string str = "abc";
int num;
if (int.TryParse(str, out num))
{
    // Conversion was successful
}
else
{
    // Conversion was not successful
}

In conclusion, we have covered a wide range of topics related to data types in C#. We started by introducing the concept of data types and the different categories they fall into. We then delved into the various primitive data types, such as bool, byte, and int, and discussed their characteristics and differences.

We also explored reference data types, including strings and objects, and learned about the unique features of the string type. We also looked at enumerations and how they can be useful in certain situations. Finally, we covered type conversion and the various methods available in C# to convert between data types.

To sum it up, it is important to have a solid understanding of data types in C# in order to write efficient and effective code. We encourage you to try out the various data types and type conversion methods we have discussed in this article in your own C# projects.

Experimenting with these concepts and seeing how they work in practice can help you further cement your understanding of them. If you would like to learn more about data types and type conversion in C#, there are many resources available online that can provide additional information and examples. So, it is always a good idea to do more research and continue learning about these topics.