Comments in C# , Variables, Data Types

C# Fundamentals Masterclass: Comments, Variables, and Strongly-Typed Data Types Explained

Build robust code foundations. Learn how to document your scripts, allocate memory using variables, and master the primitive data types of C#.

1. Documenting Code: Comments in C#

Comments are non-executable text annotations written directly inside your source code. When you build your application, the C# compiler completely ignores these blocks. Their sole purpose is to make your code understandable for humans—whether that is your future self, a team member, or a peer code reviewer.

The Three Types of Comments in C#

C# supports three distinct variations of comments, each serving a unique structural purpose:

• Single-Line Comments (//): Used for short, quick explanations on a single line or inline next to a statement.
• Multi-Line Comments (/* ... */): Used when your explanation requires paragraphs, complex logic documentation, or when temporarily disabling massive structural blocks of code during debugging.
• XML Documentation Comments (///): Advanced comments used above classes, methods, or properties. Modern IDEs like Visual Studio read these to generate pop-up documentation tooltips automatically while typing elsewhere in the solution.

// This is a single-line comment explaining the namespace
namespace FundamentalsBlog
{
    /* This is a multi-line comment.
       It allows us to write detailed explanations
       spanning across multiple separate rows. */
    class CommentDemo
    {
        /// <summary>
        /// This method serves as the calculation core wrapper.
        /// </summary>
        static void Calculate()
        {
            int testRunCount = 100; // Inline comment tracking tests
        }
    }
}

2. Understanding Variables: System Data Storage

A Variable is simply a named storage location in your computer's memory (RAM). Think of a variable as a labeled storage box. You can put data inside the box, look at the data inside without changing it, or swap the contents out for entirely new data as the application executes.

The Syntax of Variable Declaration

Because C# is a strongly-typed language, you must explicitly state what kind of data your "box" can hold before you can use it. The core syntax pattern looks like this:

DataType variableName = initialValue;

Naming Rules for Variables (Identifiers)

When picking names for your variables, C# enforces strict rules to avoid compilation errors:

• Names can contain letters, numbers, and underscores (_).
• Names must begin with a letter or an underscore; they cannot start with a number.
• C# is strictly case-sensitive. This means userAge, UserAge, and USERAGE are treated as three entirely different, distinct variables.
• Names cannot be reserved C# keywords (you cannot name a variable int, class, or static).

3. C# Data Types Deep-Dive

C# breaks down data types into various distinct classifications. The most vital ones to learn first are Primitive Types (Value types built directly into the compiler engine framework).

Here is a detailed breakdown of the primary data types you will utilize daily in C# programming:

Data Type	Size in Memory	Value Range / Description	Example Literal Syntax
int	4 bytes	Stores whole numbers from -2,147,483,648 to 2,147,483,647. No decimals.	45000
long	8 bytes	Used for massive whole numbers. Requires an L suffix.	9876543210L
double	8 bytes	Sufficient for storing 15 decimal digits. Standard floating-point default.	19.99
decimal	16 bytes	Ultra-precise fractional data type. Mandatory for financial apps. Requires an M suffix.	1500.75M
char	2 bytes	Stores a single character enclosed within single quotes.	'A'
string	Dynamic	Stores a sequence of characters enclosed within double quotes.	"Way2Testing"
bool	1 byte	Conditional boolean execution states. Can only hold true or false.	true

Practical Code Implementation: Variables & Data Types Put Together

Let's look at a comprehensive program showcasing all these elements operating together within a real code ecosystem:

using System;

namespace VariablesMasterclass
{
    class Program
    {
        static void Main(string[] args)
        {
            // 1. Textual Representation Data Types
            string channelName = "Way2Testing Tutorials";
            char rankGrade = 'A';

            // 2. Numeric Representation Data Types
            int subscriberCount = 25000;
            double performanceIndex = 98.45;
            decimal serverCost = 145.75M; // Notice the 'M' suffix for decimal

            // 3. Logical/State Data Type
            bool isServerActive = true;

            // Printing outputs via String Concatenation (+)
            Console.WriteLine("Welcome to: " + channelName);
            Console.WriteLine("Channel Tier Grade: " + rankGrade);
            Console.WriteLine("Active Subscribers: " + subscriberCount);
            Console.WriteLine("System Efficiency: " + performanceIndex + "%");
            Console.WriteLine("Monthly Maintenance Cost: $" + serverCost);
            Console.WriteLine("Is System Online? " + isServerActive);

            Console.ReadLine();
        }
    }
}

⚠️ Common Mistake Alert: Suffix Literals

In C#, when you write a number with a decimal point (like 75.50), the compiler automatically assumes it is a double. If you try to save that number directly into a decimal or a float variable, your code will fail to compile. You must explicitly append the correct suffix to the end of the number:

• Use M or m for decimals: decimal payment = 99.95M;
• Use F or f for floats: float radius = 5.75F;
• Use L or l for longs: long globalId = 999999999L;

What's Next in Your Coding Journey? 🚀

Now that you have mastered memory storage and data classification fundamentals, you are ready to learn how to manipulate this data with operators, expressions, and user input interfaces!

Visit our Practice Automation Sandbox