- Accessing Private Members with Reflection
- Accessing and Using Custom Attributes with Reflection
- Advanced Collection Operations: LINQ and Custom Comparers
- Anonymous Method Event Handling
- Applying Custom Attributes to Enhance Code Metadata
- Array vs List<T>: A Practical Comparison
- Basic Delegate Declaration and Usage
- Basic try-catch-finally Example
- Collection Initializers: Simplifying Collection Creation
- Custom Attribute for Dependency Injection
- Custom Attribute for Validating String Length
- Custom Collection with IEnumerable and IEnumerator
- Custom Comparer for LINQ Ordering
- Custom Event Declaration and Handling in C#
- Custom Exception Class with Logging
- Custom Exception with Contextual Information
- Custom Exception: InsufficientFundsException
- Deferred vs. Immediate Execution in LINQ: Filtering Even Numbers
- Dynamic Type Creation with Attributes and Reflection
- Dynamically Invoking Methods Using Reflection
- Exception Filters for Specific Exception Handling
- Exception Filters: Logging and Conditional Handling
- Exception Handling with StackTrace and InnerException
- Filtering and Transforming Data with LINQ Method Syntax
- Generic Class with Type Constraint
- Generic Method for Finding an Item in a Collection
- LINQ Aggregation with Grouping: Summing Grouped Data
- LINQ Aggregation: Sum, Average, and Count Operations
- LINQ Join with Anonymous Types
- LINQ Ordering and Grouping with Multiple Criteria
- LINQ Query Syntax: Filtering and Projection
- LINQ Query Syntax: Grouping and Aggregation
- LINQ with Anonymous Types: Grouping and Projection
- LINQ with Anonymous Types: Simple Projection
- LINQ: Combining `Where` with Indexed `Select` for Complex Transformations
- LINQ: Filtering and Projection with `Where` and `Select`
- Lambda Expression with Event Handling
- Left Outer Join with LINQ Query Syntax
- Multicast Delegates
- Multicast Delegates with Return Values
- Reading Custom Attributes using Reflection in C#
- Simple Lambda Expression with Delegate
- Simple Multicast Delegate Example
- Simulating a Message Queue with Queue<T>
- Throwing Exceptions with Exception Filters
- Understanding Capacity and Count in List<T>
- Using Built-in Delegates (Func, Action, Predicate) for Flexible Operations
- Using Exception Filters
- Using ReadOnlyCollection to Protect Internal Data
- Using Stack<T> for Undo/Redo Functionality
- Working with Collections: List, Dictionary, and HashSet
- Async Exception Handling with Try-Catch
- Asynchronous Data Processing with Task<T>
- Asynchronous Processing with Task.Run and Task.FromResult
- Asynchronous Task with CancellationToken
- Basic async/await Example: Downloading Data
- ConfigureAwait(false) for Library Code
- ConfigureAwait(true) - Explicitly Resuming on the Context
- Exception Handling with Task.WhenAll and AggregateException
- Locking for Thread Safety
- Parallel ForEach with Degree of Parallelism using TPL Dataflow
- Parallel LINQ (PLINQ) for Asynchronous Data Processing
- Parallel.For and Parallel.ForEach Demonstration
- Parallel.ForEach with CancellationToken
- Processing Data Pipeline with TPL Dataflow
- Returning Multiple Values Asynchronously
- Using Interlocked for Atomic Operations
- Using Task.WhenAll to Process Multiple Web Requests Concurrently
- Using Task.WhenAny to Process the First Available Result
- Using ValueTask for Performance Optimization in Asynchronous Operations
- Basic Blazor Component: Counter
- Basic Blazor Routing Example
- Basic Dependency Injection in a Blazor Component
- Component with Parameters: Displaying a Message
- Injecting Configuration Options into a Blazor Component
- Passing Data from Child to Parent Component using EventCallback
- Passing Data to Blazor Components with Parameters
- Routing with Parameters
- Basic Arithmetic Operations in C#
- Basic For Loop Example
- Basic Goto Example
- Basic Null-Conditional Operator Usage
- Basic Switch Statement Example
- Basic Ternary Operator Usage
- Basic Type Conversion using Convert Class
- Basic While Loop Example
- Basic foreach Loop Example
- Basic if-else if-else Example
- Bitwise AND Operator Example
- Bitwise Compound Assignment Operators
- Bitwise OR and XOR Operators Example
- Boxing and Unboxing Example
- Checked and Unchecked Arithmetic Operations in C#
- Comparing Floating-Point Numbers
- Compound Assignment Operators in C#
- Conditional Operator (Ternary Operator) Example
- Conditional Operator Precedence
- Constants and Readonly Fields in C#
- Converting Dates and Times Using Convert Class
- Declaring and Initializing Primitive Data Types
- Early Exit with <code>return</code> in <code>void</code> Methods
- Goto for Switching Logic (Anti-Pattern)
- Implicit and Explicit Type Casting in C#
- Implicitly Typed Local Variables with 'var'
- Local Function for Input Validation
- Logical AND and OR Operators
- Logical NOT Operator
- Method Overloading: Calculating Areas
- Method with Parameters and Return Value in C#
- Nested For Loop Example
- Null-Conditional Operator with Indexers
- Nullable Integer Example
- Operator Precedence and Associativity Example
- Optional and Named Parameters in C#
- Pattern Matching with `switch` in C#
- Recursive Calculation with Local Function
- Recursive Factorial Calculation
- Recursive Fibonacci Sequence
- Reference Type Assignment and Equality
- Relational Operators in C#
- Returning a Value from a Method
- Simple Method Declaration and Calling in C#
- Simple do-while Loop Example
- Switch Statement with Pattern Matching (C# 7.0 and later)
- Ternary Operator with Null-Conditional Operator
- Understanding Reference Types in C#
- Using 'break' to Exit a Loop
- Using 'continue' to Skip to the Next Iteration
- Using 'params' for Flexible Argument Lists in C#
- Using Type Inference with 'var'
- Using `out` Parameters to Return Multiple Values
- Using `ref` Parameters to Modify Original Values
- Using the Null-Coalescing Operator (??) for Default Values
- While Loop with Break Statement
- do-while Loop with Break Statement
- foreach Loop with List of Objects
- ADO.NET: Connecting to a Database and Retrieving Data
- ADO.NET: Executing Non-Query Commands (INSERT, UPDATE, DELETE)
- Asynchronous File Reading and Writing
- Asynchronous File Reading and Writing with StreamReader and StreamWriter
- Basic ADO.NET Transaction
- Basic Database Query with SqlConnection, SqlCommand, and SqlDataReader
- Copying a File using FileStream and BufferedStream
- Creating a DbContext in Entity Framework Core
- Defining a Model with Entity Framework Core
- FileStream vs. MemoryStream: Basic Usage
- LINQ to Entities with Grouping and Aggregation
- Parameterized SQL Queries in C#
- Reading and Writing Primitive Data to a Binary File
- Reading and Writing Text Files with Encoding
- Reading and Writing Text Files with StreamReader and StreamWriter
- Reading and Writing Text to a File in C#
- Simple LINQ to Entities Query
- Transaction with Multiple Commands Using Try-Catch-Finally
- Writing and Reading a Custom Object to/from a Binary File
- Basic Stopwatch Usage: Measuring Execution Time
- Creating and Reading a Custom Performance Counter
- Memory Usage Analysis with `DiagnosticSource`
- Monitoring CPU Usage with Performance Counters
- Using Stopwatch in a Using Statement: Ensuring Proper Resource Management
- Using `GC.GetTotalMemory` to Monitor Memory Usage
- Building and Compiling Expression Trees for Dynamic Filtering
- Closure Example: Counter with Encapsulation
- Closure Example: Event Handler with Captured State
- Creating and Modifying Immutable Records with 'with' Expressions in C#
- Func and Action Delegates: Basic Examples
- Immutable Data with C# Records: A Functional Approach
- Immutable Person Class
- Lambda Expressions: Basic Syntax and Usage
- Pattern Matching with Relational and Logical Patterns in C#
- Positional Pattern Matching with Tuples in C#
- Property Patterns in C#
- Switch Expression with Pattern Matching in C#
- Using 'is' pattern matching for type checking and conversion
- Using `record` to Create Immutable Classes
- Accessing Native Structures with P/Invoke
- Basic Pointer Usage in C#
- Direct Memory Manipulation with the `unsafe` Keyword
- Marshaling Data Types with Arrays in C# Interop
- Marshaling Data Types with Structs in C# Interop
- P/Invoke: Calling Native DLL Functions in C#
- Using DllImport to Access Native Functions
- Using stackalloc to Allocate Memory on the Stack
- Using the 'fixed' keyword to pin memory for direct access
- Working with Pointers and Arrays
- Expression-bodied Members in C# 6: A Concise Syntax for Methods and Properties
- Global using Directives in C# 10
- Init-Only Properties in C# 9
- Nullable Reference Types Introduction
- Nullable Reference Types and Collections
- Positional Pattern Matching with Tuples
- Positional and Property-Based Records
- Primary Constructors and Inheritance
- Primary Constructors in C# 12: Basic Example
- Record Type Declaration and Usage
- Required Members in C# 11: Ensuring Object Initialization
- String Interpolation in C# 6: A Concise Guide
- Top-Level Statements in C# 9: Simplifying Main Programs
- Tuples and Deconstruction in C# 7: Enhanced Data Handling
- Type and Property Pattern Matching with Enhanced 'when' Clauses
- Advanced ArrayPool<T> Usage with Try...Finally
- ArrayPool<T> for Reusable Buffers
- Finalizer Example: Resource Cleanup
- Forcing Garbage Collection and Preventing Finalization
- Garbage Collection Demonstration with WeakReference
- Managing Unmanaged Resources with IDisposable and GC.SuppressFinalize
- Memory Leaks and Resource Management with `IDisposable`
- Resource Management with IDisposable and using Statement
- Using Span<T> for Efficient String Processing
- Value vs. Reference Type Performance: A Practical Comparison
- Working with Memory<T> for Array Segmentation and Asynchronous Operations
- Downloading a File Asynchronously using WebClient
- Downloading a Web Page using WebClient
- HTTP POST Request with JSON Payload
- Reading HTTP Headers using HttpWebRequest and HttpWebResponse
- Sending GET and POST Requests using HttpClient in C#
- Sending HTTP Requests with HttpClient
- Simple HTTP GET Request with HttpClient
- Simple TCP Server and Client with TcpListener and TcpClient
- Simple UDP Client and Server Communication
- Abstract Class Example: Shape Hierarchy
- Abstract Class and Polymorphic Methods Example
- Abstract Class with Abstract Methods: Shape Example
- Access Modifiers in C#
- Auto-Implemented Properties in C#
- Auto-Implemented Property with Private Set
- Basic Class Declaration in C#
- Basic Constructor and Destructor Example
- Basic Inheritance Example: Animal and Dog
- Basic Object Instantiation in C#
- Class with Properties in C#
- Constructor Chaining and Explicit Destructor Call (IDisposable)
- Defining and Using Fields and Properties in C#
- Demonstrating Inheritance and the 'base' Keyword in C#
- Demonstrating Static Members in C#
- Dynamic Binding with Virtual Methods in C#
- Encapsulation Example: Bank Account
- Encapsulation with Access Modifiers in C#
- Encapsulation with Expression-Bodied Properties and Private Setters
- Encapsulation with Properties: Person Class
- Encapsulation with Property Accessors: A Simple `Person` Class
- Generic Interface Implementation: Repository Pattern
- Implementing Equals and GetHashCode for Object Comparison
- Inheriting from the Object Class in C#
- Interfaces vs. Abstract Classes: Defining Vehicle Behavior
- Method Overloading: Calculating Area
- Method Overloading: Performing Arithmetic Operations
- More Encapsulation with Access Modifiers
- Object Instantiation with Initialization
- Polymorphism with Interfaces and Abstract Classes
- Polymorphism with Interfaces: Shape Area Calculation
- Runtime Polymorphism with Method Overriding in C#
- Sealed Class Example
- Sealed Method Example
- Virtual and Override: Extending Functionality Through Inheritance
- AES Symmetric Encryption Example
- Creating and Verifying Digital Signatures with ECDSA in C#
- Creating and Verifying Digital Signatures with RSA in C#
- RSA Encryption and Decryption
- SHA256 Hashing Example
- SHA256 with Salt Example
- Salting and Hashing Passwords with BCrypt
- Securely Store and Use Passwords with SecureString
- Using Rfc2898DeriveBytes for Key Derivation
- Attribute-Driven Property Generator
- Generating Dapper Mapping Classes
- Hello World Source Generator
- Implementing the INotifyPropertyChanged Interface
- Simple Analyzer and Code Fix Provider
- Simple Source Generator for Creating a Hello World Class
- Source Generator Performance: Incremental vs. Full Syntax Analysis
- Asserting Exceptions with `Assert.Throws`
- Basic Assertion Example in Unit Testing
- Calling Functions and Methods from the Immediate Window
- Debugging Asynchronous Code with Step Into/Over/Out
- Inspecting Variables in the Immediate Window
- MSTest Example: Testing String Manipulation
- Mocking Properties with Moq
- NUnit Example: Testing a Simple Calculator Class
- Simple Logging with `Debug.WriteLine`
- Simple Unit Test with NUnit
- Step Into, Step Over, and Step Out: A Debugging Primer in C#
- TestFixture Setup and Teardown (One-Time Setup/Teardown)
- Testing Exception Handling
- Unit Testing with Mocking using Moq
- Unit Testing with Setup and Teardown using NUnit
- Using Breakpoints and Watch Windows in C#
- Using `Trace.WriteLine` for Conditional Logging
- Adding a TextBlock and Styling in XAML
- Applying Dynamic Resources for Theming in WPF
- Button Click Event Handler in Windows Forms
- Creating a Simple Windows Form
- Defining and Applying a Simple Style in WPF
- FlowLayoutPanel Example: Dynamically Arranging Buttons
- Showing a Dialog with User Input (InputDialog)
- Showing a Simple MessageBox
- Simple Command Binding in WPF
- Simple One-Way Data Binding in WPF
- Simple WPF MVVM Example: Data Binding and Command Execution
- Simple WPF Window with a Button
- Simple Windows Forms Application with Button, TextBox, and Label
- TableLayoutPanel Example: Creating a Grid Layout
- Two-Way Data Binding with INotifyPropertyChanged
- WPF MVVM Example: List Binding and Item Selection