C# Teaching Materials: Comprehensive Notes
1. String Formatting
String formatting is a way to create dynamic strings by embedding variables and
expressions. In C#, you can format strings using three common methods:
- **String Concatenation**: Combines strings using the `+` operator.
- **String.Format**: Uses placeholders (`{0}`, `{1}`) to format strings.
- **String Interpolation**: Embeds variables directly into a string using `$""`.
1.1 String Concatenation
String concatenation is the simplest way to combine strings. Use the `+` operator to join
literals and variables into a single string.
Example:
string name = "Alice";
int age = 30;
string message = "Hello, " + name + "! You are " + age + " years
old.";
Console.WriteLine(message);
1.2 String.Format
The `String.Format` method allows you to use placeholders in a template string.
Placeholders (`{0}`, `{1}`, etc.) are replaced with corresponding variables.
Example:
string name = "Alice";
int age = 30;
string message = String.Format("Hello, {0}! You are {1} years
old.", name, age);
Console.WriteLine(message);
1.3 String Interpolation
String interpolation is the most modern and readable way to format strings in C#. Variables
are embedded directly into the string using `$""`.
Example:
string name = "Alice";
int age = 30;
string message = $"Hello, {name}! You are {age} years old.";
Console.WriteLine(message);
String interpolation is preferred because it is concise and avoids the need for placeholders
or operators.
2. var and Type Inference
`var` is a C# keyword that allows the compiler to automatically determine the type of a
variable based on the value assigned to it. This makes code simpler while maintaining type
safety.
Key Points:
- `var` infers the type from the value assigned.
- Operations like addition, multiplication, or concatenation respect the inferred type.
- Once inferred, the type cannot change; this is still statically typed, not dynamic.
Examples:
// Simple Type Inference
var name = "Alice"; // inferred as string
var age = 30; // inferred as int
var price = 9.99; // inferred as double
// Operations with Inferred Types
var incrementedAge = age + 1; // inferred as int
var totalPrice = price * 1.2; // inferred as double
Console.WriteLine($"Name: {name}, Age: {incrementedAge}, Total
Price: {totalPrice}");
Important: If you need to parse user input, you must convert it explicitly (e.g., using
`int.Parse`).
3. Exception Handling
Exception handling is a way to manage runtime errors in your program, such as invalid
input or dividing by zero. In C#, this is done using `try-catch` blocks.
Key Points:
- Use `try-catch` to handle potential errors in a controlled way.
- Common exceptions include `FormatException` (invalid input) and
`DivideByZeroException` (division by zero).
- Use `finally` to run cleanup code, even if an exception occurs.
Examples:
try {
Console.WriteLine("Enter a number:");
int num = int.Parse(Console.ReadLine()); // May throw
FormatException
Console.WriteLine("Result: " + (10 / num)); // May throw
DivideByZeroException
} catch (FormatException) {
Console.WriteLine("Invalid input. Please enter a valid
number.");
} catch (DivideByZeroException) {
Console.WriteLine("Cannot divide by zero.");
} finally {
Console.WriteLine("End of program.");
}
Understanding int.TryParse
int.TryParse is a method used to safely convert a string into an integer without throwing an
exception if the conversion fails. Instead, it returns true if the conversion is successful or
false if it is not. This makes it a safer alternative to int.Parse, which throws an exception for
invalid input.
How int.TryParse Works
It takes two arguments:
The input string to be converted.
An out parameter to store the converted value if successful.
If the conversion fails, the out parameter is set to 0 (default for int), and the method
returns false.
Example
Console.WriteLine("Enter a number:");
string input = Console.ReadLine();
if (int.TryParse(input, out int number))
{
Console.WriteLine($"You entered: {number}");
}
else
{
Console.WriteLine("Invalid input. Please enter a valid
number.");
}
Explanation:
input: The string entered by the user.
number: The variable where the parsed value is stored if the conversion succeeds.
How It Handles Invalid Input:
If the user enters "abc", int.TryParse returns false, and the else block runs, displaying an
error message.
Key Points
Default Value Handling: If parsing fails, the out parameter is set to the default value (0 for
int).
No Exceptions: Unlike int.Parse, it does not throw exceptions, making it more robust for
user-facing applications.
4. Switch Statements
Switch statements are a clean way to handle multiple conditions based on a single variable.
They are often used as an alternative to multiple `if-else` statements.
Key Points:
- Each `case` checks a value of the variable.
- Use `break` to exit the `switch` after a case is executed.
- Include a `default` case to handle unmatched conditions.
Example:
Console.WriteLine("Enter a number (1-3):");
int choice = int.Parse(Console.ReadLine());
switch (choice) {
case 1:
Console.WriteLine("You selected Option 1.");
break;
case 2:
Console.WriteLine("You selected Option 2.");
break;
case 3:
Console.WriteLine("You selected Option 3.");
break;
default:
Console.WriteLine("Invalid option.");
break;
}
5. Logical Operators
Logical operators allow you to combine multiple conditions in an `if` statement. C# supports
three primary logical operators:
- `&&` (AND): True if both conditions are true.
- `||` (OR): True if at least one condition is true.
- `!` (NOT): Negates a condition.
Examples:
int age = 25;
if (age > 18 && age < 30) { // AND operator
Console.WriteLine("You are a young adult.");
}
if (age < 18 || age > 60) { // OR operator
Console.WriteLine("You qualify for special benefits.");
}
if (!(age > 18)) { // NOT operator
Console.WriteLine("You are underage.");
}
```
