Data Types Variables And Literals In C# Complete Guide

Data Types

In C#, data types define the kind of data that a variable can hold. C# has two main categories of data types: value types and reference types.

Value Types

Value types directly contain their data and are stored on the stack. They include:

• Numeric Types: int, float, double, decimal
• Integral Types: byte, sbyte, short, ushort, int, uint, long, ulong
• Floating Point Types: float, double
• Decimal Type: decimal
• Character Type: char
• Boolean Type: bool

Reference Types

Reference types don't store the data directly; instead, they store a referral to the location where the object's data is held on the heap. They include:

• Class
• Interface
• Array
• String
• Delegate

Variables

Variables are names given to memory locations where values are stored during program execution. You declare a variable by specifying its data type and name.

Declaring and Initializing Variables

Here's how you can declare and initialize variables of different data types:

using System;

class Program
{
    static void Main()
    {
        // Integral Types
        int age = 25;
        long population = 7894000000L;

        // Floating Point Types
        float length = 5.5f;
        double height = 6.1;

        // Decimal Type
        decimal accountBalance = 10000.50m;

        // Character Type
        char initial = 'J';

        // Boolean Type
        bool isStudent = true;

        // String Type (Reference Type)
        string name = "John Doe";

        // Output the values
        Console.WriteLine("Age: " + age);
        Console.WriteLine("Population: " + population);
        Console.WriteLine("Length: " + length);
        Console.WriteLine("Height: " + height);
        Console.WriteLine("Account Balance: " + accountBalance);
        Console.WriteLine("Initial: " + initial);
        Console.WriteLine("Is Student: " + isStudent);
        Console.WriteLine("Name: " + name);
    }
}

Literals

Literals are constants used to represent fixed values in your source code. They don't change during program execution.

Types of Literals

1. Integer Literals:

   • Example: 25, 7894000000L

2. Floating Point Literals:

   • Example: 5.5f, 6.1 (the suffix f is used for floats)

3. Decimal Literals:

   • Example: 10000.50m (the suffix m or M is used for decimals)

4. Character Literals:

   • Example: 'J'

5. String Literals:

   • Example: "John Doe"

6. Boolean Literals:

   • Example: true, false

Complete Example Including Literals

Let's modify our previous example to emphasize literals:

using System;

class Program
{
    static void Main()
    {
        // Integral Literals
        int intLiteral = 25;
        long longLiteral = 7894000000L;

        // Floating Point Literals
        float floatLiteral = 5.5f;
        double doubleLiteral = 6.1;

        // Decimal Literal
        decimal decimalLiteral = 10000.50m;

        // Character Literal
        char charLiteral = 'J';

        // Boolean Literal
        bool boolLiteral = true;

        // String Literal
        string stringLiteral = "John Doe";

        // Output the literals
        Console.WriteLine("Int Literal: " + intLiteral);
        Console.WriteLine("Long Literal: " + longLiteral);
        Console.WriteLine("Float Literal: " + floatLiteral);
        Console.WriteLine("Double Literal: " + doubleLiteral);
        Console.WriteLine("Decimal Literal: " + decimalLiteral);
        Console.WriteLine("Char Literal: " + charLiteral);
        Console.WriteLine("Bool Literal: " + boolLiteral);
        Console.WriteLine("String Literal: " + stringLiteral);

        // Implicit conversion
        int intFromDoubleLiteral = (int)doubleLiteral; // Explicit conversion required
        Console.WriteLine("Implicitly converted Double to Int: " + intFromDoubleLiteral);

        // Explicit conversion
        float floatFromStringLiteral = Single.Parse("5.5"); // Explicit conversion of string to float
        Console.WriteLine("Explicitly converted String to Float: " + floatFromStringLiteral);
    }
}

This example demonstrates declaration, initialization, and the output of various literals of different data types.

Summary

• Data Types classify the type of variable and the data it holds.
• Variables are memory locations identified by names to store data during execution.
• Literals are constant values used directly within the source code.

Exercises for Beginners

1. Exercise 1:

   • Write a program to declare and initialize a variable for each data type mentioned above.
   • Output the values of these variables to the console.

2. Exercise 2:

   • Initialize string literals for your first name, last name, and city.
   • Concatenate these strings into a single string with a comma separating each piece of information.
   • Output the concatenated string to the console.

3. Exercise 3:

   • Initialize a boolean literal representing whether it's raining outside.
   • Write an if-else statement to print a message depending on the value of the boolean literal.
   • Output the message to the console.