Learn C# in One Day and Learn It Well

1. C# Basics: Syntax, Variables, and Data Types

"Variables are names given to data that we need to store and manipulate in our programs."

Fundamental building blocks. C# is a strongly-typed language, meaning each variable must have a declared data type. Common types include int (integers), float and double (decimal numbers), char (single characters), string (text), and bool (true/false values). Variables are declared using the syntax: dataType variableName = value;

Type safety and conversion. C# enforces type safety, preventing unintended operations between incompatible types. However, it allows for explicit type conversion (casting) when needed. For example:

• int x = (int)20.9; // Result: x = 20 (decimal part truncated)
• float y = (float)10; // Converting integer to float

2. Object-Oriented Programming: Classes, Objects, and Inheritance

"Inheritance allows us to create a new class from an existing class so that we can effectively reuse existing code."

Encapsulation and abstraction. Classes in C# bundle related data (fields) and behaviors (methods) into a single unit. This encapsulation helps in organizing code and hiding unnecessary implementation details. Objects are instances of classes, created using the new keyword.

Inheritance hierarchy. C# supports single inheritance, where a derived class (child) inherits properties and methods from a base class (parent). Key concepts include:

• virtual methods in base classes can be overridden in derived classes
• protected members are accessible within the class and its derivatives
• Constructors in derived classes can call base class constructors using the base keyword

3. Control Structures: Loops, Conditionals, and Exception Handling

"The try-catch-finally statement controls how the program proceeds when an error occurs."

Decision making. C# offers several constructs for controlling program flow:

• if-else statements for conditional execution
• switch statements for multi-way branching
• ternary operator (?:) for inline conditionals

Iteration. Loops allow repetitive execution of code blocks:

• for loops for known number of iterations
• while loops for conditional iterations
• do-while loops for at least one execution
• foreach loops for iterating over collections

Error management. Exception handling in C# uses try-catch blocks to gracefully manage runtime errors, preventing crashes and providing meaningful feedback.

4. Advanced Data Types: Arrays, Lists, and LINQ

"LINQ stands for Language-Integrated Query and is an interesting feature of C# that allows you to query data in your program."

Collections. C# provides several ways to work with groups of data:

• Arrays: Fixed-size collections of same-type elements
• Lists: Dynamic-size collections with built-in methods for manipulation
• Dictionaries: Key-value pair collections for fast lookups

LINQ power. Language Integrated Query (LINQ) enables SQL-like querying of in-memory data:

• Simplifies filtering, sorting, and transforming data
• Works with various data sources (arrays, lists, XML, databases)
• Uses a declarative syntax that's often more readable than imperative code

5. File Handling: Reading and Writing to External Files

"C# provides us with a number of classes to work with files."

StreamReader and StreamWriter. These classes facilitate reading from and writing to text files:

• StreamReader: Reads characters from byte streams
• StreamWriter: Writes characters to streams

File management. The File class offers static methods for common file operations:

• File.Exists(): Check if a file exists
• File.Create(): Create a new file
• File.Delete(): Remove a file

Best practices:

• Use using statements to ensure proper resource disposal
• Handle potential exceptions (e.g., FileNotFoundException)
• Consider asynchronous operations for large files or network resources

6. Methods and Parameters: Defining and Using Functions

"A method is a code block that performs a certain task."

Method anatomy. Methods in C# consist of:

• Access modifier (e.g., public, private)
• Return type (or void for no return)
• Name
• Parameters (optional)
• Method body

Parameter passing. C# supports different ways to pass arguments:

• By value: A copy of the argument is passed (default for value types)
• By reference: The memory address of the argument is passed (using ref or out keywords)
• Params keyword: Allows a variable number of arguments

Method overloading. C# allows multiple methods with the same name but different parameter lists, enabling flexible function definitions.

7. Polymorphism and Interfaces: Flexible Code Design

"Polymorphism refers to a program's ability to use the correct method for an object based on its run-time type."

Runtime type determination. Polymorphism allows objects of different types to be treated as objects of a common base type, with the appropriate method being called based on the actual type at runtime.

Interfaces. These define a contract of methods and properties that implementing classes must adhere to:

• Enable multiple inheritance of behavior
• Promote loose coupling between components
• Facilitate unit testing and mocking

Abstract classes. These combine aspects of interfaces and concrete classes:

• Can contain both abstract (unimplemented) and concrete methods
• Cannot be instantiated directly
• Provide a common base for related classes

8. Structs and Enums: Custom Value Types

"An enum (which stands for enumerated type) is a special data type that allows programmers to provide meaningful names for a set of integral constants."

Struct benefits. Structs are value types that can contain methods and properties:

• More memory-efficient than classes for small data structures
• Automatically implement value semantics
• Cannot participate in inheritance

Enum usage. Enums improve code readability and type safety:

• Define a set of named constants
• Can be used in switch statements for cleaner code
• Underlying type can be specified (default is int)

9. Practical Application: Building a Simple Payroll System

"This application consists of six classes as shown below: Staff, Manager : Staff, Admin : Staff, FileReader, PaySlip, Program"

Object model design. The payroll system demonstrates practical application of OOP concepts:

• Inheritance hierarchy with Staff as base class
• Specialized classes (Manager, Admin) with overridden methods
• Utility classes (FileReader, PaySlip) for specific tasks

Integration of concepts. The project combines various C# features:

• File I/O for reading employee data
• LINQ for data manipulation
• Polymorphism for pay calculation
• Exception handling for robust operation

Real-world considerations. The example highlights important software design principles:

• Separation of concerns (e.g., file reading separate from pay calculation)
• Extensibility (easy to add new employee types)
• Maintainability through modular design

Last updated: September 8, 2024