Developer.com content material and product suggestions are editorially unbiased. We might earn a living once you click on on hyperlinks to our companions. Study Extra.

Knowledge sorts in C# are primary programming ideas that outline what sort of information a variable can maintain. C# is a statistically-typed language, and, as such, each variable must be declared with a particular knowledge sort previous to getting used. On this programming tutorial, we’ll focus on the completely different knowledge sorts that C# has to supply, together with the built-in knowledge sorts and reference sorts. We may even cowl the idea of sort conversion and showcase some code examples exhibiting their utilization.

Bounce to:

What are Knowledge Varieties in C#?

As famous in our introduction, knowledge sorts denote the kind of data a variable can maintain, comparable to a string or numeric worth. Additional, additionally they outline the vary of values the variable can maintain and the sorts of operations that may be carried out on the variable. As an example, you wouldn’t carry out calculations on a textual content worth, nor would you capitalize a quantity.

C# knowledge sorts are roughly categorised into two fundamental classes: worth sorts and reference sorts

. We are going to focus on every of those knowledge sorts within the sections under. However first, let’s focus on the advantages of utilizing knowledge sorts in our C# applications.

Learn: JetBrains ReSharper IDE Evaluation

Advantages of Utilizing Knowledge Varieties

Except for being a essential ingredient to any utility a developer builds, knowledge sorts additionally provide the next advantages:

• Enhances reminiscence effectivity: By allocating the right reminiscence for variables based mostly upon their knowledge sort, we make our reminiscence utilization extra environment friendly, leading to higher efficiency
• Sort security: Utilizing knowledge sorts permits programmers to catch type-related errors at compile-time versus runtime
• Higher code readability: Defining our knowledge sorts helps make clear their meant use and goal, mitigating the possibilities of misuse.

Now that we perceive among the core advantages of utilizing C# knowledge sorts, we are able to focus on the different sorts out there to make use of.

Constructed-in C# Knowledge Varieties

C# has a number of types of built-in sorts, together with:

• Numeric sorts
• Character sorts
• Boolean sorts
• Integer sorts
• Structs

Numeric Varieties in C#

C# gives a wide range of numeric sorts. They embrace:

• byte and sbyte: Used for 8-bit signed and unsigned integers.
• quick and ushort: Used for 16-bit signed and unsigned integers
• int and uint: Used for 32-bit signed and unsigned integers. Holds values from -2,147,483,648 to 2,147,483,647.
• lengthy and ulong: Used for 64-bit signed and unsigned integers. Holds values from -9,223,372,036,854,775,808 to 9,223,372,036,854,775,808
• float: Used for 32-bit floating-point numbers. Holds values as much as 7 decimals.
• double: Used for 64-bit double-precision floating-point numbers. Holds values as much as 15 decimals.
• decimal: 128-bit decimal floating-point numbers

For starters, integer knowledge sorts are used to symbolize complete numbers. There are a number of sorts of integers, together with byte, quick, int,, and lengthy. Every sort of integer holds a sure sort of numeric worth, proven in our record above. To outline a primary int and assign it a worth, we use the next syntax:

int age = 20;

If we needed to create an extended and assign it a worth, we may use the next code instance:

lengthy earthAge = 400000000L;

Floating-point sorts, in the meantime, symbolize numbers with decimal factors or which are fractional. Floating level sorts embrace float, double, and decimal. If we needed to create a floating level sort of float, we may accomplish that within the following method

:
float myHeight = 6.5F;

Character and String Varieties in C#

For single unicode characters, C# depends on the char. The syntax to declare a char variable may be seen within the following code instance:

char take a look at;

To assign a worth to a char, merely enclose the worth in citation marks, as proven under:

char take a look at = ‘A’;

If you wish to create a variable able to holding greater than a single unicode character, you’ll want to create a string sort. string sorts can maintain anyplace from 1 to a billion characters. They’re sometimes used to carry phrases, sentences, and even paragraphs of text-based knowledge. Right here is the syntax for making a string in C#:

string identify =”Nicholas”;

You may also create a string utilizing the System.String class. The syntax is barely completely different – it’s a must to use an uppercase String versus the lowercase model:

String name2 = “Nick”;

Which you select to make use of is as much as the programmer – neither selection is flawed. We are going to focus on strings in larger element in an upcoming tutorial.

Learn: Rider IDE Evaluation

Boolean Varieties

The bool sort is used to symbolize a boolean worth, both true or false in C# . They’re generally used when you should carry out an motion relying upon whether or not one assertion or one other is true or false.

For instance, let’s say we need to determine if one quantity is larger than one other. We will accomplish that utilizing a bool expression. First, we create two integers, then use Console.WriteLine to print the results of our analysis to the display. Right here is a few pattern code demonstrating this:

int age1 = 20;
int age2 = 50;
Console.Writeline(age1 > age2); //returns False as a result of ag1 IS NOT larger than age 2

On this instance, we assign the age1 variable a worth of 20 and our age2 variable the worth of 50. We then ask if age1 is larger than age2. Since it’s not, our bool expression will return a false worth.

Integer Knowledge Varieties and Floating Level Varieties

We briefly seen the integer and floating level sorts in our record of the completely different numeric sorts. Right here, we focus on them in larger element. For starters, integer knowledge sorts are used to symbolize complete numbers. There are a number of sorts of integers, together with byte, quick, int,, and lengthy.

Enumerations and Enums

In C#, enum defines named constants, that are values that can’t be modified or which are read-only. Builders use fixed after they intend for his or her knowledge to by no means change and stay constant. Enum values are in a listing format and start with the primary entry beginning at worth 0 by default. The second merchandise within the record could be worth 1, and so forth. For instance, let’s say you will have an enum that holds the times of week. You’ll outline it on this method:

enum Days { 
Sunday, //  index 0
Monday, // index 1
Tuesday, // index 2
Wednesday, index 3
Thursday, index 4
Friday, index 5
Saturday index 6
}

As soon as the values are assigned to an Enum, we are able to then assign the person values to a variable. To take action, we might use code much like the next:

Days right this moment = Days.Monday;
Console.WriteLine(right this moment);

This is able to print “Monday” to the display.

Structs

Structs may be considered knowledge constructions that teams knowledge. They’re much like courses however are worth sorts that may maintain constructors, constants, fields, strategies, operators, indexers, and extra. They’re helpful if you happen to want a construction to carry knowledge values that don’t depend on inheritance, comparable to key-value pairs. For instance, let’s say we needed to carry the situation of a constructing based mostly on its longitude and latitude. We may accomplish that in a Struct within the following method:

struct Location
{
    public int x;
    public int y;
}

Reference Varieties in C#

References sorts retailer a “reference” to precise knowledge versus the precise worth itself. The reference shops the handle the place a worth is saved, which may be considered a pointer to a reminiscence location. References sorts are in a position to retailer references to courses, strings, arrays, and delegates
Reference sorts retailer references to the precise knowledge on the heap. They embrace courses, strings, arrays, and delegates.

Sort Conversion in C#

There are two types of sort conversion in C#: implicit and specific. Implicit sort conversion allows you to mechanically convert from suitable knowledge sorts, comparable to changing an int worth to a lengthy. Specific sort conversion is required once you need to convert incompatible knowledge sorts.

For instance, let’s say we need to go a smaller worth to a worth sort that holds a bigger worth. In our instance under, we’ll use implicit sort conversion (or casting) to go an int to a double:

int myWeight = 200;
double myDoubleWeight = myWeight;

Since each knowledge sorts are suitable, the conversion from int to double is computerized and we don’t want to put in writing any additional code to drive the conversion.

Nevertheless, if we needed to carry out the reverse operation and assign a double to an int, we would want to handbook forged the worth, as an int doesn’t settle for decimal values. When this conversion occurs, the numbers after the decimal level are eliminated and the floating level worth turns into an integer worth or complete quantity as a substitute. Right here is how that appears in code:

double myDoubleWeight = 200.58;
int myWeight = (int) myDoubleWeight;
Console.WriteLine(myDoubleWeight);
Console.WriteLine(myWeight);

Discover how we place (int) earlier than myDoubleWeight. This code is the place we drive the conversion from a double to an int. If we run this program, we get the next output:

200.58
200

Ultimate Ideas on C# Knowledge Varieties

Understanding the completely different knowledge sorts and the way they work is essential for creating environment friendly and error-free C# functions. This programming tutorial coated the fundamental built-in knowledge sorts C# has to supply, in addition to its reference sorts. We additionally mentioned each implicit and specific sort conversions and sort casting.

Learn: Greatest Instruments for Distant Builders