Introduction to C#

C# (pronounced “C-Sharp”) is a modern, object-oriented programming language developed by Microsoft in the early 2000s as part of its .NET framework. It was designed by Anders Hejlsberg and combines the power of C++ with the simplicity of Visual Basic. C# is widely used for developing a variety of applications, including desktop software, web applications, cloud-based services, and mobile apps using technologies like Xamarin.

C# supports strong type checking, garbage collection, and modern programming concepts like encapsulation, inheritance, and polymorphism, making it reliable and easy to maintain. Its syntax is similar to C, C++, and Java, so it’s familiar to many programmers. Today, C# is one of the most popular programming languages, known for its versatility, performance, and extensive library support for building robust, scalable, and secure applications.

History of C#

using System; // Namespace
namespace MyProgram // Namespace Declaration
{
class Program // Class Declaration
{
static void Main(string[] args) // Main Method
{
Console.WriteLine("Hello, World!"); // Statement
}
}
}

1.  Namespace Declaration:
   A namespace in C# is like a container that holds related classes, interfaces, and other namespaces. It helps organize code and avoid naming conflicts between classes with the same name in large projects. For example, namespace myprogram means that all the code inside belongs to Myprogram and can be referred to by that name elsewhere in the project. The .NET framework also uses namespaces like System to provide built-in classes.

2. Class Declaration: A class is the building block of a C# program. It defines a blueprint for creating objects and contains code in the form of methods, variables, and properties. Every C# program must have at least one class because C# is an object-oriented language. For example, class Program creates a class named Program where we can write our methods and statements.

3. Main Method: The Main method is the entry point of every C# console application. When you run a C# program, the execution starts from the Main method. It is defined as static void Main(string[] args). Here, static means it belongs to the class itself (not an instance of it), void means it does not return any value, and string[] args is used to accept command-line arguments if needed.

4. Statements and Expressions: Statements are the actual instructions written inside methods, like Main, that tell the computer what to do. For example, Console.WriteLine(“Hello, World!”); is a statement that prints text to the screen. Expressions can be parts of statements that perform calculations or operations. Together, they make up the body of the program and define its behavior.

5. Comments: Comments are notes written in the code to explain what the code does. They are ignored by the compiler, so they don’t affect how the program runs. Comments help make the code easier to understand for yourself and others. In C#, you can write single-line comments using // and multi-line comments using /* */.

Compiling and Executing a C# Program

• Start the Visual Studio IDE.

• From the menu bar, choose File → New → Project.

• Select Console Application.

• Enter a name for your project and click the OK button.

• This will create a new project in the Solution Explorer.

• Write your code in the code editor.

• Click the Run button or press the F5 key to execute the project.

• A command prompt window will appear, showing the output.

Variables in C#

A variable is a name given to a storage location in memory where you can store data. Variables are used to hold values that your program can read and change during its execution.

In C# there are different types of  variables with different keywords

1. int (Integer):
   The int data type is used to store whole numbers without decimal points. It is very common for counting values like age, number of students, or quantity. It can store numbers from –2,147,483,648 to 2,147,483,647. Declaration example:

int age = 25;

2. float (Floating Point):
   The float type is used to store decimal numbers with single precision, which means it can handle small decimal values like temperature or marks with fractions. Its range is approximately ±1.5 × 10^−45 to ±3.4 × 10^38. When you declare a float, you must add f at the end. Declaration example:

float temperature = 36.6f;

3. double (Double Precision Floating Point):
   The double type is used when you need larger or more precise decimal numbers. It is double-precision and suitable for values like prices, distances, or scientific calculations. Its range is approximately ±5.0 × 10^−324 to ±1.7 × 10^308. Declaration example:

double price = 1999.99;

4. char (Character):
   The char data type stores a single character like a letter, digit, or symbol. It must be inside single quotes. It stores Unicode characters from U+0000 to U+FFFF. It is used for values like grades or gender. Declaration example:

char grade = ‘A’;

5. string (Text):
   The string type stores a group of characters, so it can hold words, sentences, or whole paragraphs. It is enclosed in double quotes and has no fixed size limit, depending on system memory. Declaration example:

string name = “Basant”;

6. bool (Boolean):
   The bool type stores only two values: true or false. It is mainly used in conditions, loops, and decision-making in programs. For example, it can check if a student passed or if a machine is on or off. Declaration example:

bool isPassed = true;

7. byte:
   The byte type stores small whole numbers from 0 to 255. It uses only 1 byte of memory and is useful when you are sure the number will not be negative and stays small. It is commonly used for raw data, images, or data transfer. Declaration example:

byte level = 100;

Data Types Overview

Example: 
using System;
namespace MyProgram
{
class Program
{
static void Main(string[] args)
{
int age = 25;
string city = "Kathmandu";
Console.WriteLine("Age: " + age);
Console.WriteLine("City: " + city);
}
}
}

Identifier in C#(C Sharp)

An identifier is the name given to elements in a C # program, such as variables, methods, classes, objects, functions, or namespaces. Identifiers allow you to refer to these elements in your code.

Examples of identifiers

• name variable

• CalculateSum method

• Student class

Rules for naming identifiers in C Sharp

• Must start with a letter or an underscore, but not with a number. Example: myVariable is correct, but 1variable is not correct
• Can contain letters, digits, and underscores only. Example: ageOne is correct, but first-name is not correct because hyphens are not allowed
• They are case-sensitive. Example: Age and age are two different identifiers
• Cannot be a C # keyword. For example, you cannot name a variable class or int
• Should be meaningful It is good practice to use descriptive names like total marks instead of tm

Data Types in C#:

• In C#, a data type is a classification that specifies which type of value a variable can hold, how much memory it needs, and what operations can be performed on it. Data types define the nature of data, such as numbers, text, or logical values, and help the compiler allocate the appropriate memory space and handle the data correctly during program execution.

The most common data Types are described below:

•  int: The int data type in C# stores whole numbers without decimals. It is commonly used for counting and basic calculations.

Example: int age = 20; — Here, the variable age stores the whole number 20.

• Float: The float type stores numbers with a fractional part (decimals) but with single precision. It is useful when you need to save memory and don’t need very high accuracy.

Example: float price = 19.99f; — The f at the end shows it’s a float.

•  Double: The double type also stores decimal numbers but with double precision, making it more accurate than float. It is often used in scientific or engineering calculations.

Example: double distance = 12345.67; — This stores a distance value.

•  char: The char type stores a single character like a letter, number, or symbol. It must be written inside single quotes.

Example: char grade = ‘A’; — This stores the letter A as a grade.

•  bool: The bool type stores only true or false values. It is used for conditions and decisions in programs.

Example: bool isPassed = true; — This shows a student has passed.

•  Byte: The byte type stores small numbers from 0 to 255 and is useful for working with binary data or files.

Example: byte level = 200; — This could store a game level or data byte.

• Short: The short type stores small whole numbers in a smaller range than int. It saves memory when the values are known to be small.

Example: short temperature = -5; — This stores a small temperature value.

•  Long: The long type stores large whole numbers. It is used when int is not enough to hold the value.

Example: long population = 7896543210; — This could store a country’s population.

• Decimal: The decimal type is used for precise decimal numbers, especially in financial calculations to avoid rounding errors.

Example: decimal salary = 15200.50m; — The m shows it’s a decimal value.

•  String: The string type stores text, which is a sequence of characters. It is very common for names, addresses, and messages.

Example: string name = “Alice”; — This stores the name Alice.

•  Object: The object type can store any kind of data — numbers, strings, or custom types. It is the base type for all other data types.

Example: object data = 25; — Here, data stores an integer but could later hold other types too.

• Dynamic: The dynamic type lets you store any data type, and the actual type is determined at runtime. It is useful when you don’t know the exact type in advance.

Example: dynamic value = “Hello”; — value stores a string now, but you can assign a number later.

Type Casting in C#:

Type casting is the process of converting one data type into another. In C#, it is used when you need to store a value of one type into a variable of another type. There are two main types of type casting: Implicit Casting and Explicit Casting.

1. Implicit Casting (Automatic)

Implicit casting happens automatically when you convert a smaller type to a larger type — there is no data loss, so C# does it for you.
Example:

int num = 100;

double value = num;  // int to double (automatic)

2. Explicit Casting (Manual)

Explicit casting must be done manually when you convert a larger type to a smaller type — because there is a risk of data loss. You use parentheses to tell the compiler to do this conversion.
Example:

double salary = 12345.67;

int wholeSalary = (int) salary;  // double to int (decimal part is lost)

C# program that shows both implicit and explicit type casting in action:

using System;
class TypeCastingExample
{
static void Main()
{
// Implicit Casting (Automatic)
int num = 50;
double doubleNum = num; // int automatically converted to double
Console.WriteLine("Implicit Casting:");
Console.WriteLine("Integer value: " + num);
Console.WriteLine("Converted to double: " + doubleNum);
Console.WriteLine(); // Blank line for clarity
// Explicit Casting (Manual)
double salary = 12345.67;
int wholeSalary = (int)salary; // double manually converted to int
Console.WriteLine("Explicit Casting:");
Console.WriteLine("Double value: " + salary);
Console.WriteLine("Converted to int (decimal removed): " + wholeSalary);
Console.WriteLine(); // Blank line for clarity
// Using Convert Class
string strNumber = "100";
int parsedNumber = Convert.ToInt32(strNumber);
Console.WriteLine("Using Convert:");
Console.WriteLine("String value: " + strNumber);
Console.WriteLine("Converted to int: " + parsedNumber);
}
}

User Input in C#:
In C#, you can read user input from the keyboard using the Console.ReadLine() method. By default, it reads the input as a string, so if you want to work with numbers, you need to convert the input to the desired type (like int or double).

Example Program: Taking User Input

using System;
class UserInputExample
{
static void Main()
{
// Take a string input
Console.Write("Enter your name: ");
string name = Console.ReadLine();
Console.WriteLine("Hello, " + name + "!");
// Take an integer input
Console.Write("Enter your age: ");
string ageInput = Console.ReadLine();
int age = Convert.ToInt32(ageInput);
Console.WriteLine("You are " + age + " years old.");

// Take a double input
Console.Write("Enter your salary: ");
double salary = Convert.ToDouble(Console.ReadLine());
Console.WriteLine("Your salary is: " + salary);
}
}

# program to add two numbers entered by the user:

using System;
class AddTwoNumbers
{
static void Main()
{
// Ask the user to enter the first number
Console.Write("Enter the first number: ");
int num1 = Convert.ToInt32(Console.ReadLine());
// Ask the user to enter the second number
Console.Write("Enter the second number: ");
int num2 = Convert.ToInt32(Console.ReadLine());
// Add the two numbers
int sum = num1 + num2;
// Display the result
Console.WriteLine("The sum of " + num1 + " and " + num2 + " is: " + sum);
}
}

Operator in C#:

In C#, an operator is a special symbol that performs an operation on one, two, or more operands (variables or values) and produces a result. Operators are used to perform calculations, compare values, assign values, and perform logical operations in a program.

Types of Operators in C#:

Operators in C# are mainly divided into the following types:

1. Arithmetic Operators:
   These operators are used to perform basic mathematical operations like addition, subtraction, multiplication, division, and finding the remainder. Examples: + (Addition), – (Subtraction), * (Multiplication), / (Division), % (Modulus).
   Example: