C# Fundamentals

0%Certificate0/439

Join the Community

Setting Up Environment

First C# Program

Variables & Data Types

Exercise: Variables & Data Types

Exercise: Value Types

Reference Types

Exercise: Reference Types

Exercise: Nullable Types

Type Casting & Conversion

Exercise: Type Casting & Conversion

Exercise: var Keyword

Exercise: Operators

Exercise: Input & Output

Exercise: Comments

Naming Conventions

Exercise: Naming Conventions

If-Else Statements

Exercise: If-Else Statements

Switch Statement

Exercise: Switch Statement

Switch Expressions

Exercise: Switch Expressions

Exercise: For Loop

Exercise: While Loop

Exercise: Foreach Loop

Break & Continue

Exercise: Break & Continue

Exercise: Goto Statement

Exercise: Arrays Basics

Array Operations

Exercise: Array Operations

Multidimensional Arrays

Exercise: Multidimensional Arrays

Exercise: Jagged Arrays

Exercise: Array Class

Exercise: Span & Arrays

Exercise: String Basics

Exercise: String Methods

String Immutability

Exercise: String Immutability

Exercise: StringBuilder

String Interpolation

Exercise: String Interpolation

Verbatim & Raw Strings

Exercise: Verbatim & Raw Strings

String Formatting

Exercise: String Formatting

String Comparison

Exercise: String Comparison

Regular Expressions

Exercise: Regular Expressions

Exercise: Methods Basics

Method Parameters

Exercise: Method Parameters

ref, out & in Parameters

Exercise: ref, out & in Parameters

Exercise: Return Types

Method Overloading

Exercise: Method Overloading

Exercise: params Keyword

Exercise: Recursion

Local Functions

Exercise: Local Functions

Classes & Objects

Exercise: Classes & Objects

Exercise: Constructors

Exercise: this Keyword

Exercise: Properties

Access Modifiers

Exercise: Access Modifiers

Exercise: static Keyword

const & readonly

Exercise: const & readonly

Partial Classes

Exercise: Partial Classes

Anonymous Types

Exercise: Anonymous Types

Exercise: Record Types

Exercise: Nested Classes

Object Initializers

Exercise: Object Initializers

Extension Methods

Exercise: Extension Methods

Inheritance Basics

Exercise: Inheritance Basics

Exercise: base Keyword

Method Overriding

Exercise: Method Overriding

new Keyword & Hiding

Exercise: new Keyword & Hiding

Constructor Chaining

Exercise: Constructor Chaining

Exercise: Sealed Classes

Exercise: Object Class

is & as Operators

Exercise: is & as Operators

Equals & GetHashCode

Exercise: Equals & GetHashCode

Polymorphism Basics

Exercise: Polymorphism Basics

Compile-Time Polymorphism

Exercise: Compile-Time Polymorphism

Runtime Polymorphism

Exercise: Runtime Polymorphism

virtual, override & new

Exercise: virtual, override & new

Covariant Return Types

Exercise: Covariant Return Types

Abstract Classes

Exercise: Abstract Classes

Abstract Methods

Exercise: Abstract Methods

Exercise: Interfaces

Default Interface Methods

Exercise: Default Interface Methods

Explicit Interface Implementation

Exercise: Explicit Interface Implementation

Multiple Interfaces

Exercise: Multiple Interfaces

Abstract vs Interface

Exercise: Abstract vs Interface

Encapsulation Basics

Exercise: Encapsulation Basics

Properties & Access Control

Exercise: Properties & Access Control

Immutable Types

Exercise: Immutable Types

Exercise: Struct Basics

readonly Struct

Exercise: readonly Struct

Exercise: ref Struct

Exercise: Record Struct

Exercise: Enum Basics

Flags Attribute

Exercise: Flags Attribute

Struct vs Class

Exercise: Struct vs Class

Delegate Basics

Exercise: Delegate Basics

Multicast Delegates

Exercise: Multicast Delegates

Func, Action & Predicate

Exercise: Func, Action & Predicate

Lambda Expressions

Exercise: Lambda Expressions

Exercise: Events Basics

EventHandler Pattern

Exercise: EventHandler Pattern

Custom EventArgs

Exercise: Custom EventArgs

Delegates vs Events

Exercise: Delegates vs Events

Exception Basics

Exercise: Exception Basics

Exercise: try-catch

Multiple catch Blocks

Exercise: Multiple catch Blocks

Exercise: finally Block

Throw & Rethrow

Exercise: Throw & Rethrow

Exception Filters

Exercise: Exception Filters

Custom Exceptions

Exercise: Custom Exceptions

Inner Exceptions

Exercise: Inner Exceptions

Exception Best Practices

Exercise: Exception Best Practices

Collections Overview

Exercise: Collections Overview

IEnumerable & ICollection

Exercise: IEnumerable & ICollection

Exercise: LinkedList

Exercise: Dictionary

SortedDictionary & SortedList

Exercise: SortedDictionary & SortedList

Exercise: HashSet

Exercise: SortedSet

Exercise: Queue

Exercise: Stack

Exercise: PriorityQueue

Non-Generic Collections

Exercise: Non-Generic Collections

Concurrent Collections

Exercise: Concurrent Collections

Immutable Collections

Exercise: Immutable Collections

Read-Only Collections

Exercise: Read-Only Collections

IComparer & IEqualityComparer

Exercise: IComparer & IEqualityComparer

Iterator Pattern & yield

Exercise: Iterator Pattern & yield

Collection Expressions

Exercise: Collection Expressions

Generics Basics

Exercise: Generics Basics

Generic Classes

Exercise: Generic Classes

Generic Methods

Exercise: Generic Methods

Generic Interfaces

Exercise: Generic Interfaces

Generic Constraints

Exercise: Generic Constraints

Covariance & Contravariance

Exercise: Covariance & Contravariance

Generic Delegates

Exercise: Generic Delegates

default Keyword

Exercise: default Keyword

Exercise: LINQ Basics

Exercise: Query Syntax

Exercise: Method Syntax

Filtering & Ordering

Exercise: Filtering & Ordering

Projection & Grouping

Exercise: Projection & Grouping

Exercise: Joins

Aggregation Operators

Exercise: Aggregation Operators

Deferred Execution

Exercise: Deferred Execution

Custom LINQ Operators

Exercise: Custom LINQ Operators

Exercise: PLINQ

Exercise: Async Basics

Exercise: async & await

Exercise: Task Class

Exercise: ValueTask

Task Combinators

Exercise: Task Combinators

Cancellation Tokens

Exercise: Cancellation Tokens

SynchronizationContext

Exercise: SynchronizationContext

IAsyncEnumerable

Exercise: IAsyncEnumerable

Exercise: Channels

Async Best Practices

Exercise: Async Best Practices

File & Directory Classes

Exercise: File & Directory Classes

Reading & Writing Files

Exercise: Reading & Writing Files

Exercise: Streams

StreamReader & StreamWriter

Exercise: StreamReader & StreamWriter

BinaryReader & BinaryWriter

Exercise: BinaryReader & BinaryWriter

Exercise: Path Class

JSON Serialization

Exercise: JSON Serialization

XML Serialization

Exercise: XML Serialization

Exercise: Namespaces

File-Scoped Namespaces

Exercise: File-Scoped Namespaces

Exercise: Global Usings

Exercise: Assemblies

Exercise: NuGet Packages

internal Access

Exercise: internal Access

Memory Model Basics

Exercise: Memory Model Basics

Garbage Collection

Exercise: Garbage Collection

IDisposable & using

Exercise: IDisposable & using

Exercise: Finalizers

Exercise: Span & Memory

Exercise: stackalloc

Weak References

Exercise: Weak References

Exercise: Object Pooling

Attributes Basics

Exercise: Attributes Basics

Built-In Attributes

Exercise: Built-In Attributes

Custom Attributes

Exercise: Custom Attributes

Reflection Basics

Exercise: Reflection Basics

Inspecting Types

Exercise: Inspecting Types

dynamic Keyword

Exercise: dynamic Keyword

Source Generators

Exercise: Source Generators

Pattern Matching Basics

Exercise: Pattern Matching Basics

Exercise: Type Patterns

Property Patterns

Exercise: Property Patterns

Positional Patterns

Exercise: Positional Patterns

Relational & Logical Patterns

Exercise: Relational & Logical Patterns

Exercise: List Patterns

Networking Basics

Exercise: Networking Basics

Exercise: HttpClient

HttpClientFactory

Exercise: HttpClientFactory

Exercise: TCP Sockets

Exercise: UDP Sockets

Exercise: WebSockets

Exercise: gRPC Basics

Exercise: EF Core Basics

Exercise: DbContext

Code-First Approach

Exercise: Code-First Approach

Exercise: Migrations

Exercise: Relationships

LINQ to Entities

Exercise: LINQ to Entities

Performance Optimization

Exercise: Performance Optimization

Exercise: Dapper

Exercise: Records

Init-Only Properties

Exercise: Init-Only Properties

Top-Level Statements

Exercise: Top-Level Statements

File-Scoped Types

Exercise: File-Scoped Types

Required Members

Exercise: Required Members

Raw String Literals

Exercise: Raw String Literals

Primary Constructors

Exercise: Primary Constructors

Collection Expressions

Exercise: Collection Expressions

Exercise: Alias Any Type

params Collections

Exercise: params Collections

Exercise: Lock Object

ref readonly Parameters

Exercise: ref readonly Parameters

Coding Standards

Effective C# Tips

Clean Code Principles

Common Pitfalls

Performance Optimization

Logging Best Practices

Analyzers & Code Fixes

Debugging Techniques

C# Fundamentals

Welcome

Course Roadmap
Course Setup
Join the Community

Introduction to C#

What is C#?
History of C#
C# Features
.NET Ecosystem
Setting Up Environment
First C# Program
How C# Works

Basic Syntax

Variables & Data Types
Exercise: Variables & Data Types
Value Types
Exercise: Value Types
Reference Types
Exercise: Reference Types
Nullable Types
Exercise: Nullable Types
Type Casting & Conversion
Exercise: Type Casting & Conversion
var Keyword
Exercise: var Keyword
Operators
Exercise: Operators
Input & Output
Exercise: Input & Output
Comments
Exercise: Comments
Naming Conventions
Exercise: Naming Conventions

Control Flow

If-Else Statements
Exercise: If-Else Statements
Switch Statement
Exercise: Switch Statement
Switch Expressions
Exercise: Switch Expressions
For Loop
Exercise: For Loop
While Loop
Exercise: While Loop
Foreach Loop
Exercise: Foreach Loop
Break & Continue
Exercise: Break & Continue
Goto Statement
Exercise: Goto Statement

Arrays

Arrays Basics
Exercise: Arrays Basics
Array Operations
Exercise: Array Operations
Multidimensional Arrays
Exercise: Multidimensional Arrays
Jagged Arrays
Exercise: Jagged Arrays
Array Class
Exercise: Array Class
Span & Arrays
Exercise: Span & Arrays

Strings

String Basics
Exercise: String Basics
String Methods
Exercise: String Methods
String Immutability
Exercise: String Immutability
StringBuilder
Exercise: StringBuilder
String Interpolation
Exercise: String Interpolation
Verbatim & Raw Strings
Exercise: Verbatim & Raw Strings
String Formatting
Exercise: String Formatting
String Comparison
Exercise: String Comparison
Regular Expressions
Exercise: Regular Expressions

Methods

Methods Basics
Exercise: Methods Basics
Method Parameters
Exercise: Method Parameters
ref, out & in Parameters
Exercise: ref, out & in Parameters
Return Types
Exercise: Return Types
Method Overloading
Exercise: Method Overloading
params Keyword
Exercise: params Keyword
Recursion
Exercise: Recursion
Local Functions
Exercise: Local Functions

Object-Oriented Programming

Classes & Objects
Exercise: Classes & Objects
Constructors
Exercise: Constructors
this Keyword
Exercise: this Keyword
Properties
Exercise: Properties
Access Modifiers
Exercise: Access Modifiers
static Keyword
Exercise: static Keyword
const & readonly
Exercise: const & readonly
Partial Classes
Exercise: Partial Classes
Anonymous Types
Exercise: Anonymous Types
Record Types
Exercise: Record Types
Nested Classes
Exercise: Nested Classes
Object Initializers
Exercise: Object Initializers
Extension Methods
Exercise: Extension Methods

Inheritance

Inheritance Basics
Exercise: Inheritance Basics
base Keyword
Exercise: base Keyword
Method Overriding
Exercise: Method Overriding
new Keyword & Hiding
Exercise: new Keyword & Hiding
Constructor Chaining
Exercise: Constructor Chaining
Sealed Classes
Exercise: Sealed Classes
Object Class
Exercise: Object Class
is & as Operators
Exercise: is & as Operators
Equals & GetHashCode
Exercise: Equals & GetHashCode

Polymorphism

Polymorphism Basics
Exercise: Polymorphism Basics
Compile-Time Polymorphism
Exercise: Compile-Time Polymorphism
Runtime Polymorphism
Exercise: Runtime Polymorphism
virtual, override & new
Exercise: virtual, override & new
Covariant Return Types
Exercise: Covariant Return Types

Abstraction

Abstract Classes
Exercise: Abstract Classes
Abstract Methods
Exercise: Abstract Methods
Interfaces
Exercise: Interfaces
Default Interface Methods
Exercise: Default Interface Methods
Explicit Interface Implementation
Exercise: Explicit Interface Implementation
Multiple Interfaces
Exercise: Multiple Interfaces
Abstract vs Interface
Exercise: Abstract vs Interface

Encapsulation

Encapsulation Basics
Exercise: Encapsulation Basics
Properties & Access Control
Exercise: Properties & Access Control
Immutable Types
Exercise: Immutable Types

Structs & Enums

Struct Basics
Exercise: Struct Basics
readonly Struct
Exercise: readonly Struct
ref Struct
Exercise: ref Struct
Record Struct
Exercise: Record Struct
Enum Basics
Exercise: Enum Basics
Flags Attribute
Exercise: Flags Attribute
Struct vs Class
Exercise: Struct vs Class

Delegates & Events

Delegate Basics
Exercise: Delegate Basics
Multicast Delegates
Exercise: Multicast Delegates
Func, Action & Predicate
Exercise: Func, Action & Predicate
Lambda Expressions
Exercise: Lambda Expressions
Events Basics
Exercise: Events Basics
EventHandler Pattern
Exercise: EventHandler Pattern
Custom EventArgs
Exercise: Custom EventArgs
Delegates vs Events
Exercise: Delegates vs Events

Exception Handling

Exception Basics
Exercise: Exception Basics
try-catch
Exercise: try-catch
Multiple catch Blocks
Exercise: Multiple catch Blocks
finally Block
Exercise: finally Block
Throw & Rethrow
Exercise: Throw & Rethrow
Exception Filters
Exercise: Exception Filters
Custom Exceptions
Exercise: Custom Exceptions
Inner Exceptions
Exercise: Inner Exceptions
Exception Best Practices
Exercise: Exception Best Practices

Collections & Data Structures

Generics

Generics Basics
Exercise: Generics Basics
Generic Classes
Exercise: Generic Classes
Generic Methods
Exercise: Generic Methods
Generic Interfaces
Exercise: Generic Interfaces
Generic Constraints
Exercise: Generic Constraints
Covariance & Contravariance
Exercise: Covariance & Contravariance
Generic Delegates
Exercise: Generic Delegates
default Keyword
Exercise: default Keyword

LINQ

LINQ Basics
Exercise: LINQ Basics
Query Syntax
Exercise: Query Syntax
Method Syntax
Exercise: Method Syntax
Filtering & Ordering
Exercise: Filtering & Ordering
Projection & Grouping
Exercise: Projection & Grouping
Joins
Exercise: Joins
Aggregation Operators
Exercise: Aggregation Operators
Deferred Execution
Exercise: Deferred Execution
Custom LINQ Operators
Exercise: Custom LINQ Operators
PLINQ
Exercise: PLINQ

Async Programming

Async Basics
Exercise: Async Basics
async & await
Exercise: async & await
Task Class
Exercise: Task Class
ValueTask
Exercise: ValueTask
Task Combinators
Exercise: Task Combinators
Cancellation Tokens
Exercise: Cancellation Tokens
SynchronizationContext
Exercise: SynchronizationContext
IAsyncEnumerable
Exercise: IAsyncEnumerable
Channels
Exercise: Channels
Async Best Practices
Exercise: Async Best Practices

File I/O

File & Directory Classes
Exercise: File & Directory Classes
Reading & Writing Files
Exercise: Reading & Writing Files
Streams
Exercise: Streams
StreamReader & StreamWriter
Exercise: StreamReader & StreamWriter
BinaryReader & BinaryWriter
Exercise: BinaryReader & BinaryWriter
Path Class
Exercise: Path Class
JSON Serialization
Exercise: JSON Serialization
XML Serialization
Exercise: XML Serialization

Namespaces & Assemblies

Namespaces
Exercise: Namespaces
File-Scoped Namespaces
Exercise: File-Scoped Namespaces
Global Usings
Exercise: Global Usings
Assemblies
Exercise: Assemblies
NuGet Packages
Exercise: NuGet Packages
internal Access
Exercise: internal Access

Memory Management

Memory Model Basics
Exercise: Memory Model Basics
Garbage Collection
Exercise: Garbage Collection
IDisposable & using
Exercise: IDisposable & using
Finalizers
Exercise: Finalizers
Span & Memory
Exercise: Span & Memory
stackalloc
Exercise: stackalloc
Weak References
Exercise: Weak References
Object Pooling
Exercise: Object Pooling

Reflection & Attributes

Attributes Basics
Exercise: Attributes Basics
Built-In Attributes
Exercise: Built-In Attributes
Custom Attributes
Exercise: Custom Attributes
Reflection Basics
Exercise: Reflection Basics
Inspecting Types
Exercise: Inspecting Types
dynamic Keyword
Exercise: dynamic Keyword
Source Generators
Exercise: Source Generators

Pattern Matching

Pattern Matching Basics
Exercise: Pattern Matching Basics
Type Patterns
Exercise: Type Patterns
Property Patterns
Exercise: Property Patterns
Positional Patterns
Exercise: Positional Patterns
Relational & Logical Patterns
Exercise: Relational & Logical Patterns
List Patterns
Exercise: List Patterns

Networking

Networking Basics
Exercise: Networking Basics
HttpClient
Exercise: HttpClient
HttpClientFactory
Exercise: HttpClientFactory
TCP Sockets
Exercise: TCP Sockets
UDP Sockets
Exercise: UDP Sockets
WebSockets
Exercise: WebSockets
gRPC Basics
Exercise: gRPC Basics

Entity Framework & Data

EF Core Basics
Exercise: EF Core Basics
DbContext
Exercise: DbContext
Code-First Approach
Exercise: Code-First Approach
Migrations
Exercise: Migrations
Relationships
Exercise: Relationships
LINQ to Entities
Exercise: LINQ to Entities
Performance Optimization
Exercise: Performance Optimization
Dapper
Exercise: Dapper

Modern C#

Records
Exercise: Records
Init-Only Properties
Exercise: Init-Only Properties
Top-Level Statements
Exercise: Top-Level Statements
File-Scoped Types
Exercise: File-Scoped Types
Required Members
Exercise: Required Members
Raw String Literals
Exercise: Raw String Literals
Primary Constructors
Exercise: Primary Constructors
Collection Expressions
Exercise: Collection Expressions
Alias Any Type
Exercise: Alias Any Type
params Collections
Exercise: params Collections
Lock Object
Exercise: Lock Object
ref readonly Parameters
Exercise: ref readonly Parameters

Best Practices

Coding Standards
Effective C# Tips
Clean Code Principles
Common Pitfalls
Performance Optimization
Logging Best Practices
Testing Basics
Analyzers & Code Fixes
Debugging Techniques

Debugging Techniques

Low Priority

Premium Content

Subscribe to unlock full access to this content and more premium articles.

Analyzers & Code Fix...