Tutorials – C#.Net

Chapter 2: C# Basics

Chapter 2 of our C# tutorial delves into the fundamental building blocks of the C# programming language. In this chapter, we will explore the core concepts that underpin C#, including syntax, data types, variables, operators, expressions, and input/output. Understanding these basics is essential for anyone looking to become proficient in C#.

2.1 C# Syntax and Structure

C# has a structured and readable syntax, making it a popular choice for developers. It uses a combination of keywords, identifiers, and punctuation to create code. Let’s explore some key aspects of C# syntax:

• Case Sensitivity: C# is case-sensitive, meaning that “example” and “Example” are treated as different identifiers.

• Statements and Expressions: C# code consists of statements and expressions. Statements are executed for their side effects, while expressions produce values. For example, int x = 5; is a statement, and int result = x + 3; is an expression.

• Semicolons: Statements in C# end with semicolons. It’s a key part of C# syntax, and forgetting it can lead to compilation errors.

• Blocks: Blocks of code are enclosed in curly braces {}. For example, the main method is enclosed in a block.

class Program
{
static void Main()
    {
// This is a block of code
int x = 5;
int result = x + 3;
    }
}

2.2 Data Types and Variables

In C#, data types are used to define the type of data that a variable can hold. Here are some common data types in C#:

• int: Represents integer numbers, e.g., 42, -10, 0.

• double: Represents floating-point numbers, e.g., 3.14, -0.001, 2.0.

• char: Represents a single character, e.g., ‘A’, ‘1’, ‘$’.

• bool: Represents a Boolean value, e.g., true, false.

• string: Represents a sequence of characters, e.g., “Hello, World!”

• var: Allows the compiler to infer the data type based on the value, e.g., var age = 25;.

To declare a variable in C#, you specify its data type followed by the variable name. For example:

int age; // Declaration
age = 25; // Initialization

You can also declare and initialize a variable in one step:

int age = 25; // Declaration and initialization

2.3 Operators and Expressions

Operators in C# are symbols that perform operations on variables and values. Here are some of the common operators in C#:

• Arithmetic Operators: Used for basic arithmetic operations, including addition (+), subtraction (-), multiplication (*), division (/), and remainder (%).

• Comparison Operators: Used to compare values, including equality (==), inequality (!=), greater than (>), less than (<), greater than or equal to (>=), and less than or equal to (<=).

• Logical Operators: Used for combining and negating conditions, including logical AND (&&), logical OR (||), and logical NOT (!).

• Assignment Operators: Used to assign values to variables, including simple assignment (=), addition and assignment (+=), subtraction and assignment (-=), and so on.

• Increment and Decrement Operators: Used to increase or decrease the value of a variable, including increment (++) and decrement (--).

• Ternary Operator: A shorthand way to write conditional expressions, e.g., result = (x > 5) ? "Yes" : "No";.

• Bitwise Operators: Used to manipulate individual bits in integers, including bitwise AND (&), bitwise OR (|), bitwise XOR (^), and bitwise NOT (~).

• Shift Operators: Used to shift the bits of an integer left or right, e.g., left shift (<<) and right shift (>>).

Example of Expressions:

int x = 10;
int y = 5;
int sum = x + y; // Arithmetic expression
bool isTrue = (x > y) && (y < 0); // Logical expression

2.4 Console Input and Output

The Console class in C# provides methods for interacting with the console, which allows input and output operations. Here are some commonly used methods:

• Console.WriteLine("Hello, World!");: Writes text to the console followed by a line break.

• Console.Write("Enter your name: ");: Writes text to the console without a line break.

• string name = Console.ReadLine();: Reads a line of text from the console and stores it in the variable name.

• int number = int.Parse(Console.ReadLine());: Reads a line of text from the console, converts it to an integer, and stores it in the variable number.

Here’s an example that demonstrates console input and output:

using System;
class Program
{
static void Main()
    {
        Console.Write("Enter your name: ");
string name = Console.ReadLine();
        Console.WriteLine($"Hello, {name}!");
    }
}

This program prompts the user to enter their name and then greets them.

2.5 Comments and Documentation

Comments are essential for documenting your code and making it more understandable for others (and your future self). In C#, you can use two types of comments:

• Single-line comments: These begin with // and continue to the end of the line. They are used for short comments and explanations.

// This is a single-line comment
int age = 25; // This variable stores the user's age

• Multi-line comments: These are enclosed between /* and */ and can span multiple lines. They are often used for longer explanations or comments.

/*
This is a multi-line comment
It provides detailed information about the code
*/
int result = 42; // This is another comment

In addition to regular comments, C# supports XML comments, which are used for documenting code to generate documentation files. They begin with ///. For example:

/// <summary>
/// This method adds two integers.
/// </summary>
/// <param name="a">The first integer.</param>
/// <param name="b">The second integer.</param>
/// <returns>The sum of the two integers.</returns>
int Add(int a, int b)
{
return a + b;
}

XML comments can be processed by documentation generators to create documentation for your code.

2.6 Conclusion of Chapter 2

In Chapter 2, we’ve delved into the core concepts of C# that form the foundation of your journey as a C# developer. You’ve learned about C# syntax, data types, variables, operators, expressions, input/output, and the importance of comments and documentation.

These fundamental building blocks are essential for writing clear, structured, and efficient C# code. As you continue through this tutorial, you’ll build on this knowledge and dive deeper into the world of C#, exploring more advanced features, object-oriented programming, and real-world application development. You’re well on your way to becoming a proficient C# developer.