Structure of a C# Program

A simple C# program consists of several components:

                    
using System; // Namespace declaration

namespace HelloWorldApp // Namespace definition
{
    class Program // Class declaration
    {
        static void Main(string[] args) // Main method (entry point of the program)
        {
            Console.WriteLine("Hello, World!"); // Output statement
        }
    }
}
                    
                

• using: Keyword used to include namespaces in the program.
• namespace: Logical container for classes and other types. Helps organize code.
• class: Defines the blueprint for creating objects. Every C# program has at least one class.
• Main method: The entry point of the program where execution starts.
• Console.WriteLine: Used to print output to the console.

Input and Output in C#

• What are Input and Output?

  In C#, Input refers to taking data from the user, while Output is used to display data back to the user. The Console class in C# provides methods for handling input and output operations in console applications.

• Reading Input from the User

  The Console.ReadLine() method is used to read input from the user as a string. Here's how you can take input:

                              
  using System;
  
  class Program
  {
      static void Main()
      {
          Console.WriteLine("Enter your name:");
          string name = Console.ReadLine();  // Reads input as a string
          Console.WriteLine("Hello, " + name + "!");
      }
  }
                              
                          

  In this example, the program asks the user to enter their name, stores the input in the name variable, and then displays a greeting.

  To read numeric input, you must convert the input string using methods like int.Parse() or Convert.ToInt32():

                              
  Console.WriteLine("Enter your age:");
  int age = int.Parse(Console.ReadLine());  // Converts string to integer
  Console.WriteLine("Your age is " + age + ".");
                              
                          

• Writing Output to the Console

  The Console.WriteLine() method is used to display output. You can use it in different ways:

  • Simple Text Output:

                                        
    Console.WriteLine("This is a simple message.");
                                    
                                

  • Variable and Text Concatenation: Use the + operator to combine variables and text.

                                        
    string name = "Alice";
    int age = 22;
    Console.WriteLine("Name: " + name + ", Age: " + age);
                                    
                                

  • String Interpolation: The preferred way to include variables in text. Use the $ symbol before the string.

                                        
    string name = "Alice";
    int age = 22;
    Console.WriteLine($"Name: {name}, Age: {age}");
                                        
                                    

    Explanation: The $ symbol allows you to directly embed variables within curly braces { }, making the code more readable.

  • Using Format Strings: Use placeholders to insert variables in the output.

                                        
    string name = "Alice";
    int age = 22;
    Console.WriteLine("Name: {0}, Age: {1}", name, age);
                                        
                                    

    Explanation: {0} and {1} are placeholders, replaced with the values of name and age respectively.

• Combining Input and Output

  Here's an example that combines input and output operations:

                              
  using System;
  
  class Program
  {
      static void Main()
      {
          // Taking input
          Console.WriteLine("Enter your name:");
          string name = Console.ReadLine();
  
          Console.WriteLine("Enter your age:");
          int age = int.Parse(Console.ReadLine());
  
          // Displaying output using interpolation
          Console.WriteLine($"Hello, {name}! You are {age} years old.");
      }
  }
                              
                          

  Explanation: The program asks the user to enter their name and age, stores the input in variables, and then displays a personalized message.

• Key Points:
  • Use Console.ReadLine() to take input as a string. Convert it if needed (e.g., int.Parse()).
  • Use Console.WriteLine() for displaying output.
  • String interpolation ($) is the cleanest and most modern way to include variables in output.
  • Ensure input is valid before converting it. Use error handling techniques like try-catch for robust programs.

Understanding Namespace

• Here’s a simple C# program that demonstrates the concept of namespaces by creating two namespaces, each containing a class with a method. One namespace's method calls the other namespace's method, helping to understand how namespaces work.

                        
using System;

namespace FirstNamespace
{
    // Class in the first namespace
    public class FirstClass
    {
        public void DisplayMessage()
        {
            Console.WriteLine("Hello from the First Namespace!");
        }
    }
}

namespace SecondNamespace
{
    // Class in the second namespace
    public class SecondClass
    {
        public void ShowMessage()
        {
            Console.WriteLine("Hello from the Second Namespace!");
        }

        // Method to call a method from FirstNamespace
        public void CallFirstNamespaceMethod()
        {
            FirstNamespace.FirstClass firstClassObj = new FirstNamespace.FirstClass();
            firstClassObj.DisplayMessage();
        }
    }
}

class Program
{
    static void Main(string[] args)
    {
        // Creating an object of the SecondClass
        SecondNamespace.SecondClass secondClassObj = new SecondNamespace.SecondClass();

        // Call method of SecondNamespace
        secondClassObj.ShowMessage();

        // Call method from FirstNamespace through SecondNamespace
        secondClassObj.CallFirstNamespaceMethod();

        Console.ReadLine(); // Keep the console open
    }
}
                        
                    

Variables and Data Types

Variables are used to store data in a program. C# is a strongly-typed language, meaning you must declare the type of data a variable will hold. Each variable is associated with a specific data type that determines the kind of values it can store and what operations can be performed on them.

    // Examples of variable declarations in C#
int age = 25; // Integer type
string name = "John"; // String type
double salary = 5000.50; // Double type for floating-point numbers
float temperature = 36.6f; // Float type for single-precision floating-point numbers
bool isEmployed = true; // Boolean type (true or false)

• int: Represents integer values (whole numbers). Example: int age = 25;
• string: Represents sequences of characters (text). Example: string name = "John";
• float: Represents single-precision floating-point numbers. A f suffix is required for float literals. Example: float temperature = 36.6f;
• double: Represents double-precision floating-point numbers (numbers with decimal points). Example: double salary = 5000.50;
• bool: Represents boolean values (true or false). Example: bool isEmployed = true;

Note: In C#, public methods and built-in method names (such as Console.WriteLine()) typically follow the PascalCase convention, where each word starts with a capital letter. However, not all function names are capitalized. Private or internal methods often follow the camelCase convention, where the first word starts with a lowercase letter and subsequent words are capitalized. This helps distinguish between public and private members in a class.

                    // Example of working with strings
string greeting = "Hello, World!";
string upperCaseGreeting = greeting.ToUpper(); // Converts string to uppercase
Console.WriteLine(upperCaseGreeting); // Output: HELLO, WORLD!
                

                        Console.Write("Enter a date (yyyy-mm-dd): ");
string dateInput = Console.ReadLine();
                            

                        string dateInput = "2024-10-04";
DateTime parsedDate = DateTime.Parse(dateInput);
Console.WriteLine("Parsed Date: " + parsedDate.ToString("yyyy-MM-dd"));

                        string dateInput = "2024-10-04";
DateTime userDate;
bool isDateValid = DateTime.TryParse(dateInput, out userDate);

if (isDateValid)
{
    Console.WriteLine("Valid Date: " + userDate.ToString("yyyy-MM-dd"));
}
else
{
    Console.WriteLine("Invalid date format.");
}

                        DateTime now = DateTime.Now;  // Current date and time
DateTime specificDate = new DateTime(2023, 10, 4);  // Year, Month, Day

Converting Between Data Types

Data type conversion allows transforming one data type into another. C# provides multiple ways to perform conversions, including implicit and explicit conversion, methods like Convert and Parse:

• Implicit Conversion: Happens automatically when there’s no risk of data loss. For example, converting an int to a double can happen implicitly.

                        // Implicit conversion example
int intNum = 10;
double doubleNum = intNum; // No need for casting, happens automatically
                    

• Explicit Conversion (Casting): Required when there’s potential for data loss. For example, converting a double to an int requires explicit casting because you might lose the fractional part.

                        // Explicit conversion example
double doubleNum = 10.5;
int intNum = (int)doubleNum; // Cast explicitly, results in 10 (fractional part lost)
                    

• Using Methods: C# provides methods for conversions, such as Convert.ToInt32(), ToString(), and Parse().

    // Example of using Convert methods
string strNum = "123";
int num = Convert.ToInt32(strNum); // Converts string to integer
double doubleValue = Convert.ToDouble(strNum); // Converts string to double
float floatValue = Convert.ToSingle(strNum); // Converts string to float
bool boolValue = Convert.ToBoolean("true"); // Converts string to boolean
long longValue = Convert.ToInt64(strNum); // Converts string to long

• Convert.ToInt32(): Converts a value to a 32-bit integer (int). Example: int num = Convert.ToInt32("123");
• Convert.ToDouble(): Converts a value to a double-precision floating-point number (double). Example: double num = Convert.ToDouble("123.45");
• Convert.ToSingle(): Converts a value to a single-precision floating-point number (float). Example: float num = Convert.ToSingle("123.45");
• Convert.ToBoolean(): Converts a value to a Boolean (true or false). Example: bool flag = Convert.ToBoolean("true");
• Convert.ToInt64(): Converts a value to a 64-bit integer (long). Example: long num = Convert.ToInt64("123456789");
• Convert.ToDecimal(): Converts a value to a decimal for precise financial calculations. Example: decimal num = Convert.ToDecimal("123.45");
• Convert.ToString(): Converts a value to a string. Example: string text = Convert.ToString(123);
• Convert.ToDateTime(): Converts a value to a DateTime object. Example: DateTime date = Convert.ToDateTime("2024-01-01");
• Using Parse Method: The Parse() method converts a string representation of a number into a specific data type (e.g., int, double). This method throws an exception if the format is incorrect.

                        // Example of using Parse method
string strNum = "456";
int num = int.Parse(strNum); // Converts string to integer
Console.WriteLine(num); // Output: 456

string strDecimal = "123.45";
double doubleValue = double.Parse(strDecimal); // Converts string to double
Console.WriteLine(doubleValue); // Output: 123.45
                    

• TryParse Method: Unlike Parse(), TryParse() does not throw an exception. It returns a boolean value indicating whether the conversion was successful.

                        // Example of using TryParse method
string strNum = "789";
int result;
bool isParsed = int.TryParse(strNum, out result); // Returns true if successful
Console.WriteLine(isParsed ? $"Parsed: {result}" : "Failed to parse"); // Output: Parsed: 789
                    

Comments

Comments are used to explain code and are ignored by the compiler. There are two types of comments in C#:

        // This is a single-line comment

/*
This is a
multi-line comment
*/
    

Operators in C#

C# supports various operators for performing calculations and comparisons.

• Arithmetic Operators: Used for basic arithmetic operations.
  • + (Addition)
  • - (Subtraction)
  • * (Multiplication)
  • / (Division)
  • % (Modulus)
• Comparison Operators: Used for comparing values.
  • == (Equal to)
  • != (Not equal to)
  • > (Greater than)
  • < (Less than)
  • >= (Greater than or equal to)
  • <= (Less than or equal to)
• Logical Operators: Used for logical operations.
  • && (Logical AND)
  • || (Logical OR)
  • ! (Logical NOT)

Control Statements in C#

Control statements are fundamental constructs in programming used to dictate the flow of execution based on certain conditions or to repeat blocks of code. Understanding these statements is crucial for developing effective and efficient code.

Functions (Methods)

Functions are reusable blocks of code that perform a specific task.

        void SayHello() // Function definition
{
    Console.WriteLine("Hello, World!");
}

SayHello(); // Function call
    

• void: Indicates that the method does not return a value.
• SayHello: The name of the function.
• Function call: The function is executed when it's called.

Classes and Objects

Classes are blueprints for creating objects, and objects are instances of classes.

        class Person // Class definition
{
    public string Name; // Field

    public void Greet() // Method
    {
        Console.WriteLine("Hello, my name is " + Name);
    }
}

Person person1 = new Person(); // Create object
person1.Name = "John"; // Assign value
person1.Greet(); // Call method
    

Declaring and Initializing Arrays

Before using arrays, you need to declare and initialize them. Here’s how:

• Declaration: Specifies the type of elements and the array name.

                    int[] numbers; // Declares an array of integers
                

• Initialization: Allocates memory for the array and assigns values.

                    numbers = new int[5]; // Initializes an array with 5 elements

// Alternatively, you can declare and initialize in one line:
int[] numbers = new int[] { 1, 2, 3, 4, 5 };
                

• Accessing Array Elements: Use the index to access or modify elements.

                    int firstNumber = numbers[0]; // Accesses the first element
numbers[1] = 10; // Modifies the second element
                

Looping Through Arrays

You can use loops to iterate through all elements of an array. The most common loop for this purpose is the for loop:

                int[] numbers = { 10, 20, 30, 40, 50 };
for (int i = 0; i < numbers.Length; i++)
{
    Console.WriteLine(numbers[i]);
}
            

Types of Arrays

C# supports several types of arrays:

• Single-Dimensional Arrays: The simplest type of array that stores data in a single line.

                    int[] singleDimArray = { 10, 20, 30, 40, 50 };
                

• Multi-Dimensional Arrays: Arrays with more than one dimension. Typically used for matrices.

                    int[,] multiDimArray = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };
                

• Jagged Arrays: Arrays of arrays, where each sub-array can have different lengths.

                    int[][] jaggedArray = new int[3][];
jaggedArray[0] = new int[] { 1, 2 };
jaggedArray[1] = new int[] { 3, 4, 5 };
jaggedArray[2] = new int[] { 6, 7, 8, 9 };
                

Advantages of Arrays

• Efficient Memory Access: Arrays provide efficient access to elements using indices. Accessing an element is fast and requires constant time, O(1).
• Contiguous Memory Allocation: Arrays are stored in contiguous memory locations, which improves cache performance and access speed.
• Fixed Size: The fixed size of an array can simplify the memory management and make it easier to predict and manage the memory usage.
• Simplicity: Arrays are straightforward and easy to use for storing and accessing multiple values of the same type.
• Direct Access: Arrays provide direct access to elements via index, which makes it easier to manipulate and access data.

Disadvantages of Arrays

• Fixed Size: Once an array is created, its size cannot be changed. This can lead to inefficient memory usage if the array is too large or if the number of elements exceeds the initial size.
• Memory Waste: If an array is allocated with a size larger than needed, the extra memory allocated can be wasted, leading to inefficient memory usage.
• Costly Resizing: To resize an array, a new array must be created and elements copied over, which can be costly in terms of performance and time.
• Limited Flexibility: Arrays can only store elements of the same type and do not provide methods for dynamically changing their size or structure.
• Index Out of Bounds: Accessing an element with an invalid index can lead to runtime errors, such as `IndexOutOfRangeException` in C#.

Basic Programs

Example 1: Sum of Array Elements

This program calculates the sum of all elements in an array.

                using System;

class Program
{
    static void Main()
    {
        int[] numbers = { 1, 2, 3, 4, 5 };
        int sum = 0;

        foreach (int number in numbers)
        {
            sum += number;
        }

        Console.WriteLine("Sum of array elements: " + sum);
    }
}
            

Example 2: Searching for an Element

This program searches for a specific element in the array and prints its index.

                using System;

class Program
{
    static void Main()
    {
        int[] numbers = { 10, 20, 30, 40, 50 };
        int searchElement = 30;
        int index = -1;

        for (int i = 0; i < numbers.Length; i++)
        {
            if (numbers[i] == searchElement)
            {
                index = i;
                break;
            }
        }

        if (index != -1)
        {
            Console.WriteLine("Element found at index: " + index);
        }
        else
        {
            Console.WriteLine("Element not found.");
        }
    }
}