As a C# developer, understanding the different simple data types in C# and when to use them is crucial for writing efficient and maintainable code. I’ve been trying to spend more time this year putting together some content aimed at really introductory level programming. There’s plenty of resources available online, but I want to do my part to ensure I can help break down some of the barriers for people getting started on their programming journey.
In this beginner’s guide, we will look at the basics of the most commonly used simple data types in C#, including int, float, double, byte, char, bool, and string. We will also look at how these data types differ from each other and when to use them in your C# programming!
Integer Data Types
The most commonly used integer data types in C# are int
and long
. An int
is a 32-bit integer that can store whole numbers between -2,147,483,648 and 2,147,483,647. A long
is a 64-bit integer that can store whole numbers between -9,223,372,036,854,775,808 and 9,223,372,036,854,775,807. You’ll notice that as the name suggests, these types can only support integers so there’s no decimal places in the numbers! It’s also important to note that a long
takes up twice as much storage as an int
.
Here’s an example of using the int
data type:
int x = 10;
int y = 20;
int z = x + y;
Console.WriteLine(z); // Output: 30
In this example, we declared three variables x
, y
, and z
of type int
and assigned values to them. We then used the +
operator to add the values of x
and y
and store the result in z
. We then print out the result which is our sum between these two integers x
and y
.
Floating Point Data Types
The most commonly used floating point data types in C# are float
and double
. A float
is a 32-bit floating point number that can store decimal numbers with a precision of 7 digits. A double
is a 64-bit floating point number that can store decimal numbers with a precision of 15-16 digits. Unlike the integer based types we saw above, these numbers do support decimals. Like the integer types above, we have several variations here that provide more accuracy and range at the cost of more size to store the data. A double is twice the size of a float. Double. Twice. Get it?
Here’s an example of using the double
data type:
double x = 10.5;
double y = 20.3;
double z = x + y;
Console.WriteLine(z); // Output: 30.8
In this example, we declared three variables x
, y
, and z
of type double
and assigned values to them. We then used the +
operator to add the values of x
and y
and store the result in z
.
Byte Data Type
The byte
data type in C# is an 8-bit unsigned integer that can store whole numbers between 0 and 255. It is commonly used to in a slightly more advanced structure called an Array to represent things such as file contents and other data.
Here’s an example of using the byte
data type:
byte age = 30;
byte numberOfImages = 10;
byte totalSize = age + numberOfImages;
Console.WriteLine(totalSize); // Output: 40
In this example, we declared three variables age
, numberOfImages
, and totalSize
of type byte
and assigned values to them. We then used the +
operator to add the values of age
and numberOfImages
and store the result in totalSize
.
It’s important to note that since byte is an unsigned integer the result of any operation that would result in a negative number will wrap around to a positive number. For example, the following code:
byte x = 250;
byte y = 20;
byte z = (byte)(y - x);
Console.WriteLine(z); // Output: 26
Here, the subtraction of x from y would have resulted in -230 which is not possible in byte data type, so it wraps around to 26. Try it out here!
Decoding Character Data Type
The char
data type in C# is used to store a single character, such as a letter, number, or symbol. A data type that often gets confused with the char
data type is called byte
. It’s outside the scope of this article, but
Here’s an example of using the char
data type:
char x = 'A';
char y = 'B';
Console.WriteLine(x); // Output: 'A'
Console.WriteLine(y); // Output: 'B'
In this example, we declared two variables x
and y
of type char
and assigned values to them. We then printed the values of x
and y
to the console.
Analyzing Boolean Data Type
The boolean data type in C# is bool
and can store only two possible values: true
or false
. A great way to think about a boolean is the result of yes or no decisions. If you need to compare things (like checking if numbers are the same, greater than, or less than) then you can store the result in a bool
.
Here’s an example of using the bool
data type:
bool isTrue = true;
bool isFalse = 10 < 5;
Console.WriteLine(isTrue); // Output: true
Console.WriteLine(isFalse); // Output: false
In this example, we declared two variables isTrue
and isFalse
of type bool
and assigned values to them. We then printed the values of isTrue
and isFalse
to the console and we could see the direct assignment of true and the calculated example of false get printed. That’s because 10 is not less than 5, so the result is false. See it in action!
String Data Type
The string data type in C# is string
. A string
can store a sequence of characters (remember that char
data type we were looking at?) , such as a word or a sentence. From a beginners perspective, perhaps the most simple way to think about strings are containing data that is easily human readable. While this isn’t a requirement of a string
, when you’re getting started it might help to think of it that way!
Here’s an example of using the string
data type:
string firstName = "John";
string lastName = "Doe";
string fullName = firstName + " " + lastName;
Console.WriteLine(fullName); // Output: "John Doe"
In this example, we declared three variables firstName
, lastName
, and fullName
of type string
and assigned values to them. We then used the +
operator to concatenate the values of firstName
and lastName
with a space in between and store the result in fullName
.
Choosing the Right Data Types in C#
When choosing a data type for your variables, it is important to consider the specific needs of your application. If you need to store whole numbers, you should use an integer data type like int
or long
. If you need to store numbers with decimal places, you should use a floating point data type like float
or double
. If you need to store a single character, you should use the char
data type or a string
data type if you need to store a sequence of them. If you need to store a true or false value, you should use the bool
data type.
Wrapping Up Simple Data Types in C#
In conclusion, understanding the different simple data types in C# and when to use them is crucial for writing efficient and maintainable code. By understanding the characteristics and limitations of each data type, you will be able to make informed decisions about how to design and implement your C# applications. Remember to choose the right data type for your specific needs, and always keep in mind the difference in memory and precision.
By mastering the simple data types in C#, you can take your coding skills to the next level and start building more complex data structures! Maybe structs and classes are the next thing for you to read up on 🙂
Is this code snippet have a typo?
byte x = 250;
byte y = 20;
byte z = (byte)(x – y);
Console.WriteLine(z); // Output: 230
x – y = 230 > 0
Ah yes, this was me literally in between trying to show two different examples and then clobbering the entire thing haha
Here’s the corrected code:
byte x = 250;
byte y = 20;
byte z = (byte)(y - x);
Console.WriteLine(z); // Output: 26
And a new fiddle, since I can’t seem to edit the old one: