Data Types in C#

In C#, data types define the kind of values a variable can hold. Since C# is strongly typed, every variable or constant must be declared with a specific data type, such as int, char or float.

Data Types in C# is Mainly Divided into 3 Categories:

• Value Data Types
• Reference Data Types
• Pointer Data Type

1. Value Data Types

In C#, the Value Data Types will directly store the variable value in memory and it will also accept both signed and unsigned literals. The derived class for these data types are System.ValueType.

Following are different Value Data Types in C# programming language

1.1 Signed & Unsigned Integral Types

There are 8 integral types which provide support for 8-bit, 16-bit, 32-bit and 64-bit values in signed or unsigned form.

1.2 Floating Point Types

There are 2 floating point data types which contain the decimal point.

• Float: It is 32-bit single-precision floating point type. It has 7 digit Precision. To initialize a float variable, use the suffix f or F. Like, float x = 3.5F. If the suffix F or f will not use then it is treated as double.
• Double: It is 64-bit double-precision floating point type. It has 14 - 15 digit Precision. To initialize a double variable, use the suffix d or D. But it is not mandatory to use suffix because by default floating data types are the double type.

1.3 Decimal Types

The decimal type is a 128-bit data type suitable for financial and monetary calculations. It has 28-29 digit Precision. To initialize a decimal variable, use the suffix m or M. Like as, decimal x = 300.5m. If the suffix m or M will not use then it is treated as double.

1.4 Character Types

The character types represents a UTF-16 code unit or represents the 16-bit Unicode character.

Example 1: Program to demonstrate the above data types

using System;

namespace ValueTypeTest {
class GeeksforGeeks {
    
    static void Main()
    {
        // declaring character
        char a = 'G';

        // Integer data type is generally used for numeric values
        int i = 89;

        short s = 56;

        // long uses Integer values which may signed or unsingned
        long l = 4564;

        // UInt data type is generally used for unsingned integer values
        uint ui = 95;

        ushort us = 76;

        // ulong data type is generally for unsingned integer values
        ulong ul = 3624573;

        // by default fraction value is double in C#
        double d = 8.358674532;

        // for float use 'f' as suffix
        float f = 3.7330645f;

        // for float use 'm' as suffix
        decimal dec = 389.5m;

        Console.WriteLine("char: " + a);
        Console.WriteLine("integer: " + i);
        Console.WriteLine("short: " + s);
        Console.WriteLine("long: " + l);
        Console.WriteLine("float: " + f);
        Console.WriteLine("double: " + d);
        Console.WriteLine("decimal: " + dec);
        Console.WriteLine("Unsingned integer: " + ui);
        Console.WriteLine("Unsingned short: " + us);
        Console.WriteLine("Unsingned long: " + ul);
    }
}
}

char: G
integer: 89
short: 56
long: 4564
float: 3.733064
double: 8.358674532
decimal: 389.5
Unsinged integer: 95
Unsinged short: 76
Unsinged long: 3624573

Example 2: Sbyte signed integral data type

using System;

namespace ValueTypeTest {
class GeeksforGeeks {
  
    static void Main()
    {
        sbyte a = 126;

        // sbyte is 8 bit singned value
        Console.WriteLine(a);

        a++;
        Console.WriteLine(a);

        // It overflows here because byte can hold values from -128 to 127
        a++;
        Console.WriteLine(a);

        // Looping back within the range
        a++;
        Console.WriteLine(a);
    }
}
}

126
127
-128
-127

Example 3: Program to demonstrate the byte data type

using System;

namespace ValueTypeTest {
class GeeksforGeeks {
  
    static void Main()
    {
        byte a = 0;

        // byte is 8 bit unsigned value
        Console.WriteLine(a);

        a++;
        Console.WriteLine(a);

        a = 254;

        // It overflows here because byte can hold values from 0 to 255
        a++;
        Console.WriteLine(a);

        // Looping back within the range
        a++;
        Console.WriteLine(a);
    }
}
}

0
1
255
0

1.5 Boolean Types

It has to be assigned either true or false value. Values of type bool are not converted implicitly or explicitly (with casts) to any other type. But the programmer can easily write conversion code.

Example: Using Boolean data type

using System;

namespace ValueTypeTest {
class GeeksforGeeks {
    
    static void Main()
    {
        // boolean data type
        bool b = true;

        if (b == true)
            Console.WriteLine("Hi Geek");
    }
}
}

Hi Geek

2. Reference Data Types

Reference data types in C# store the memory address (reference) of the actual data, not the data itself. They are used for complex types like string, arrays, classes, interfaces and delegates.

2.1 String

It represents a sequence of Unicode characters and its type name is System.String. So, string and String are equivalent.

Example:

string s1 = "hello"; // creating through string keyword
String s2 = "welcome"; // creating through String class

2.2 Object

In C#, object is the base type from which all other types (value types and reference types) are derived. Converting a value type to an object is called boxing and converting it back is called unboxing.

Example:

using System;

namespace ValueTypeTest {

class Geeks {
    
    static void Main() 
    {
        // declaring string
        string a = "Geeks"; 
        
        // append in a
        a += "for";
        a = a + "Geeks"; 
        Console.WriteLine(a);
        
        // declare object obj
        object obj;
        obj = 20;
        Console.WriteLine(obj);
        
        // to show type of object using GetType()
        Console.WriteLine(obj.GetType()); 
    } 
}
}

GeeksforGeeks
20
System.Int32

3. Pointer Data Type

The Pointer Data Types will contain a memory address of the variable value. To get the pointer details we have a two symbols ampersand (&) and asterisk (*).

• ampersand (&): It is known as Address Operator. It is used to determine the address of a variable.
• asterisk (*): It also known as Indirection Operator. It is used to access the value of an address.

Syntax:

type* identifier;

// Valid syntax
int* p1, p;

// Invalid
int *p1, *p;

Example:

using System;

namespace Pointerprogram {
class GFG {

    static void Main()
    {
        unsafe
        {
            
            // declare variable
            int n = 10;
            
            // store variable n address location in pointer variable p
            int* p = &n;
            Console.WriteLine("Value :{0}", n);
            Console.WriteLine("Address :{0}", (int)p);
        }
    }
}
}

Output:

Value :10
Address :1988374520

Note:

This program will not work on online compiler.
Error: Unsafe code requires the `unsafe' command line option to be specified.
For its solution: Go to your project properties page and check under Build the checkbox Allow unsafe code.

GeeksforGeeks

Improve

Article Tags :

• C#
• CSharp-Basics
• CSharp-data-types