C# 10.0 All-in-one


This course includes
Hand-on Lab

The C# 10.0 All-in-one Course is designed to take you from a beginner to an advanced C# developer. This course covers everything you need to know about C# programming, starting from the basics to more advanced topics. You'll learn the core principles of the C# language, explore Object-Oriented Programming (OOP), discover advanced language features, and see how to apply these skills in web development using ASP.NET Core.


39+ Lessons | 300+ Quizzes | 180+ Flashcards | 180+ Glossary of terms

Hand on lab

52+ LiveLab | 51+ Video tutorials | 01:28+ Hours

Here's what you will learn

Download Course Outline

Lessons 1: Introduction

  • About This Course
  • General Assumptions
  • Icons Used in This Course
  • Where to Go from Here

Lessons 2: Creating Your First C# Console Application

  • Getting a Handle on Computer Languages, C#, and .NET
  • Creating Your First Console Application
  • Making Your Console App Do Something
  • Reviewing Your Console Application
  • Replacing All that Ceremonial Code: Top-Level Statements
  • Introducing the Toolbox Trick
  • Interacting with C# Online
  • Working with Jupyter Notebook: The Short Version

Lessons 3: Living with Variability — Declaring Value-Type Variables

  • Declaring a Variable
  • What’s an int?
  • Representing Fractions
  • Handling Floating-Point Variables
  • Using the Decimal Type: Is It an Integer or a Float?
  • Examining the bool Type: Is It Logical?
  • Checking Out Character Types
  • What’s a Value Type?
  • Comparing string and char
  • Calculating Leap Years: DateTime
  • Declaring Numeric Constants
  • Changing Types: The Cast
  • Letting the C# Compiler Infer Data Types

Lessons 4: Pulling Strings

  • The Union Is Indivisible, and So Are Strings
  • Performing Common Operations on a String
  • Comparing Strings
  • What If I Want to Switch Case?
  • Looping through a String
  • Searching Strings
  • Getting Input from Users in Console Applications
  • Controlling Output Manually
  • Formatting Your Strings Precisely
  • StringBuilder: Manipulating Strings More Efficiently

Lessons 5: Smooth Operators

  • Performing Arithmetic
  • Performing Logical Comparisons — Is That Logical?
  • Matching Expression Types at TrackDownAMate.com

Lessons 6: Getting into the Program Flow

  • Branching Out with if and switch
  • Here We Go Loop-the-Loop
  • Looping a Specified Number of Times with for

Lessons 7: Lining Up Your Ducks with Collections

  • The C# Array
  • Processing Arrays by Using foreach
  • Sorting Arrays of Data
  • Using var for Arrays
  • Loosening Up with C# Collections
  • Understanding Collection Syntax
  • Using Lists
  • Using Dictionaries
  • Array and Collection Initializers
  • Using Sets

Lessons 8: Stepping through Collections

  • Iterating through a Directory of Files
  • Iterating foreach Collections: Iterators
  • Accessing Collections the Array Way: Indexers
  • Looping Around the Iterator Block

Lessons 9: Buying Generic

  • Writing a New Prescription: Generics
  • Classy Generics: Writing Your Own
  • Understanding Variance in Generics

Lessons 10: Some Exceptional Exceptions

  • Using an Exceptional Error-Reporting Mechanism
  • Can I Get an Exceptional Example?
  • Working with Custom Exceptions
  • Planning Your Exception-Handling Strategy
  • Grabbing Your Last Chance to Catch an Exception
  • Throwing Expressions

Lessons 11: Creating Lists of Items with Enumerations

  • Seeing Enumerations in the Real World
  • Working with Enumerations
  • Creating Enumerated Flags
  • Defining Enumerated Switches
  • Working with Enumeration Methods

Lessons 12: Showing Some Class

  • A Quick Overview of Object-Oriented Programming
  • Defining a Class and an Object
  • Accessing the Members of an Object
  • Working with Object-Based Code
  • Discriminating between Objects
  • Can You Give Me References?
  • Classes That Contain Classes Are the Happiest Classes in the World
  • Generating Static in Class Members
  • Defining const and readonly Data Members

Lessons 13: We Have Our Methods

  • Defining and Using a Method
  • Method Examples for Your Files
  • Having Arguments with Methods
  • Using the Call-by-Reference Feature
  • Defining a Method with No Return Value
  • Returning Multiple Values Using Tuples

Lessons 14: Let Me Say This about this

  • Passing an Object to a Method
  • Comparing Static and Instance Methods
  • Accessing the Current Object
  • Using Local Functions

Lessons 15: Holding a Class Responsible

  • Restricting Access to Class Members
  • Why You Should Worry about Access Control
  • Defining Class Properties
  • Using Target Typing for Your Convenience
  • Dealing with Covariant Return Types
  • Getting Your Objects Off to a Good Start — Constructors
  • Using Expression-Bodied Members

Lessons 16: Inheritance: Is That All I Get?

  • Why You Need Inheritance
  • Inheriting from a BankAccount Class (a More Complex Example)
  • IS_A versus HAS_A — I’m So Confused_A
  • Other Features That Support Inheritance

Lessons 17: Poly-what-ism?

  • Overloading an Inherited Method
  • Polymorphism
  • C# During Its Abstract Period
  • Sealing a Class

Lessons 18: Interfacing with the Interface

  • Introducing CAN_BE_USED_AS
  • Knowing What an Interface Is
  • Using an Interface
  • Using the C# Predefined Interface Types
  • Looking at a Program That CAN_BE_USED_AS an Example
  • Unifying Class Hierarchies
  • Hiding Behind an Interface
  • Inheriting an Interface
  • Using Interfaces to Manage Change in Object-Oriented Programs

Lessons 19: Delegating Those Important Events

  • E.T., Phone Home — The Callback Problem
  • Defining a Delegate
  • Pass Me the Code, Please — Examples
  • A More Real-World Example
  • Shh! Keep It Quiet — Anonymous Methods
  • Stuff Happens — C# Events

Lessons 20: Can I Use Your Namespace in the Library?

  • Dividing a Single Program into Multiple Source Files
  • Working with Global using Statements
  • Dividing a Single Program into Multiple Assemblies
  • Putting Your Classes into Class Libraries
  • Going Beyond Public and Private: More Access Keywords
  • Putting Classes into Namespaces
  • Working with Partial Methods

Lessons 21: Improving Productivity with Named and Optional Parameters

  • Exploring Optional Parameters
  • Looking at Named Parameters
  • Using Alternative Methods to Return Values
  • Dealing with null Parameters

Lessons 22: Interacting with Structures

  • Comparing Structures to Classes
  • Creating Structures
  • Working with Read-only Structures
  • Working with Reference Structures
  • Using Structures as Records
  • Using the New Record Type

Lessons 23: Writing Secure Code

  • Designing Secure Software
  • Building Secure Windows Applications
  • Using System.Security

Lessons 24: Accessing Data

  • Getting to Know System.Data
  • How the Data Classes Fit into the Framework
  • Getting to Your Data
  • Using the System.Data Namespace

Lessons 25: Fishing the File Stream

  • Going Where the Fish Are: The File Stream
  • StreamWriting for Old Walter
  • Pulling Them Out of the Stream: Using StreamReader
  • More Readers and Writers
  • Exploring More Streams than Lewis and Clark

Lessons 26: Accessing the Internet

  • Getting to Know System.Net
  • How Net Classes Fit into the Framework
  • Using the System.Net Namespace

Lessons 27: Creating Images

  • Getting to Know System.Drawing
  • How the Drawing Classes Fit into the Framework
  • Using the System.Drawing Namespace

Lessons 28: Programming Dynamically!

  • Shifting C# Toward Dynamic Typing
  • Employing Dynamic Programming Techniques
  • Putting Dynamic to Use
  • Running with the Dynamic Language Runtime
  • Using Static Anonymous Functions

Lessons 29: Getting Started with Visual Studio

  • Versioning the Versions
  • Installing Visual Studio
  • Breaking Down the Projects

Lessons 30: Using the Interface

  • Designing in the Designer
  • Paneling the Studio
  • Coding in the Code Editor
  • Using the Tools of the Trade
  • Using the Debugger as an Aid to Learning

Lessons 31: Customizing Visual Studio

  • Setting Options
  • Creating Your Own Templates

Lessons 32: Introducing WPF

  • Understanding What WPF Can Do
  • Introducing XAML
  • Diving In! Creating Your First WPF Application
  • Whatever XAML Can Do, C# Can Do Better!

Lessons 33: Understanding the Basics of WPF

  • Using WPF to Lay Out Your Application
  • Arranging Elements with Layout Panels
  • Exploring Common XAML Controls

Lessons 34: Data Binding in WPF

  • Getting to Know Dependency Properties
  • Exploring the Binding Modes
  • Investigating the Binding Object
  • Editing, Validating, Converting, and Visualizing Your Data
  • Finding Out More about WPF Data Binding

Lessons 35: Practical WPF

  • Commanding Attention
  • Using Built-In Commands
  • Using Custom Commands
  • Using Routed Commands

Lessons 36: Programming for Windows 10 and Above

  • What is the Universal Windows Platform (UWP)?
  • Devices Supported by the UWP
  • Creating Your Own UWP App
  • Working with .NET Core Applications

Lessons 37: Creating a Basic ASP.NET Core App

  • Understanding the ASP.NET Core Templates
  • Developing a Basic Web App

Lessons 38: Employing the Razor Markup Language

  • Avoiding Nicks from Razor
  • Creating Variables
  • Keeping Things Logical
  • Implementing Loops

Lessons 39: Generating and Consuming Data

  • Understanding Why These Projects Are Important
  • Serialized Data Isn’t for Breakfast
  • Developing a Data Generator and API
  • Creating a Consumer Website

Hands-on LAB Activities

Creating Your First C# Console Application

  • Creating a Source Program
  • Executing a Source Program

Pulling Strings

  • Executing the ModifyString Example Program
  • Building a Sentence
  • Using Advanced Pattern Matching
  • Parsing Numeric Input
  • Handling a Series of Numbers
  • Formatting Output Using Trim and Pad Methods

Smooth Operators

  • Demonstrating Operator Overloading

Getting into the Program Flow

  • Calculating the Interest Using the if Statement
  • Calculating the Amount of Principle Through Looping

Lining Up Your Ducks with Collections

  • Calculating the Average of Numbers
  • Processing Arrays by Using the foreach Loop
  • Sorting Arrays of Data

Stepping through Collections

  • Iterating Through a Directory of Files

Buying Generic

  • Creating a Priority Queue

Some Exceptional Exceptions

  • Demonstrating Exception Handling

Creating Lists of Items with Enumerations

  • Demonstrating the Working of Enumerations

Showing Some Class

  • Demostrating Working with Object-Based Code

We Have Our Methods

  • Implementing Default Arguments

Let Me Say This about this

  • Passing an Object to a Method
  • Employing Static Properties and Methods
  • Employing Instance Properties and Methods
  • Using Attributes with Local Functions

Holding a Class Responsible

  • Solving the Rounding Problem
  • Using Target Typing

Inheritance: Is That All I Get?

  • Inheriting from a BankAccount Class


  • Demonstrating the Polymorphic Nature of AbstractInheritance

Interfacing with the Interface

  • Demonstrating the Implementation of the Incomparable IComparable<T> Interface

Delegating Those Important Events

  • Demonstrating the Action, Func, and Predicate Delegate Types
  • Using Static Anonymous Methods

Can I Use Your Namespace in the Library?

  • Analyzing a Project with a Class Library

Interacting with Structures

  • Using Supplemental Struct Elements
  • Demonstrating a read-only Structure

Writing Secure Code

  • Creating a Windows Application

Accessing Data

  • Setting Up a Sample Database Schema

Fishing the File Stream

  • Using StreamWriter

Accessing the Internet

  • Demonstrating the Use of System.Net Namespace

Creating Images

  • Demonstrating the Use of System.Drawing Namespace

Customizing Visual Studio

  • Developing a Project Template
  • Developing an Item Template

Introducing WPF

  • Creating a WPF Application

Understanding the Basics of WPF

  • Creating a Canvas
  • Creating a Data Entry Form
  • Demonstrating Display-Only Controls

Data Binding in WPF

  • Binding a Data Object with XAML
  • Validating the Data

Practical WPF

  • Demonstrating the Use of Routed Commands

Programming for Windows 10 and Above

  • Analyzing a UWP Project

Creating a Basic ASP.NET Core App

  • Analyzing a Basic Web App

Employing the Razor Markup Language

  • Overviewing a Razor Page

Generating and Consuming Data

  • Developing a Data Generator and API