C# 10.0 All-in-one

(CSHARP-BASIC.AE1) / ISBN : 978-1-64459-478-0
This course includes
Lessons
Hands-On Labs
Get A Free Trial

About This Course

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.

Skills You’ll Get

Get the support you need. Enroll in our Instructor-Led Course.

Lessons

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

Hands-On Labs

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

1

Introduction

  • About This Course
  • General Assumptions
  • Icons Used in This Course
  • Where to Go from Here
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
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
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
5

Smooth Operators

  • Performing Arithmetic
  • Performing Logical Comparisons — Is That Logical?
  • Matching Expression Types at TrackDownAMate.com
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
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
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
9

Buying Generic

  • Writing a New Prescription: Generics
  • Classy Generics: Writing Your Own
  • Understanding Variance in Generics
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
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
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
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
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
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
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
17

Poly-what-ism?

  • Overloading an Inherited Method
  • Polymorphism
  • C# During Its Abstract Period
  • Sealing a Class
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
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
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
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
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
23

Writing Secure Code

  • Designing Secure Software
  • Building Secure Windows Applications
  • Using System.Security
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
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
26

Accessing the Internet

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

Creating Images

  • Getting to Know System.Drawing
  • How the Drawing Classes Fit into the Framework
  • Using the System.Drawing Namespace
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
29

Getting Started with Visual Studio

  • Versioning the Versions
  • Installing Visual Studio
  • Breaking Down the Projects
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
31

Customizing Visual Studio

  • Setting Options
  • Creating Your Own Templates
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!
33

Understanding the Basics of WPF

  • Using WPF to Lay Out Your Application
  • Arranging Elements with Layout Panels
  • Exploring Common XAML Controls
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
35

Practical WPF

  • Commanding Attention
  • Using Built-In Commands
  • Using Custom Commands
  • Using Routed Commands
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
37

Creating a Basic ASP.NET Core App

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

Employing the Razor Markup Language

  • Avoiding Nicks from Razor
  • Creating Variables
  • Keeping Things Logical
  • Implementing Loops
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

1

Creating Your First C# Console Application

  • Creating a Source Program
  • Executing a Source Program
3

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
4

Smooth Operators

  • Demonstrating Operator Overloading
5

Getting into the Program Flow

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

Lining Up Your Ducks with Collections

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

Stepping through Collections

  • Iterating Through a Directory of Files
8

Buying Generic

  • Creating a Priority Queue
9

Some Exceptional Exceptions

  • Demonstrating Exception Handling
10

Creating Lists of Items with Enumerations

  • Demonstrating the Working of Enumerations
11

Showing Some Class

  • Demostrating Working with Object-Based Code
12

We Have Our Methods

  • Implementing Default Arguments
13

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
14

Holding a Class Responsible

  • Solving the Rounding Problem
  • Using Target Typing
15

Inheritance: Is That All I Get?

  • Inheriting from a BankAccount Class
16

Poly-what-ism?

  • Demonstrating the Polymorphic Nature of AbstractInheritance
17

Interfacing with the Interface

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

Delegating Those Important Events

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

Can I Use Your Namespace in the Library?

  • Analyzing a Project with a Class Library
21

Interacting with Structures

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

Writing Secure Code

  • Creating a Windows Application
23

Accessing Data

  • Setting Up a Sample Database Schema
24

Fishing the File Stream

  • Using StreamWriter
25

Accessing the Internet

  • Demonstrating the Use of System.Net Namespace
26

Creating Images

  • Demonstrating the Use of System.Drawing Namespace
30

Customizing Visual Studio

  • Developing a Project Template
  • Developing an Item Template
31

Introducing WPF

  • Creating a WPF Application
32

Understanding the Basics of WPF

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

Data Binding in WPF

  • Binding a Data Object with XAML
  • Validating the Data
34

Practical WPF

  • Demonstrating the Use of Routed Commands
35

Programming for Windows 10 and Above

  • Analyzing a UWP Project
36

Creating a Basic ASP.NET Core App

  • Analyzing a Basic Web App
37

Employing the Razor Markup Language

  • Overviewing a Razor Page
38

Generating and Consuming Data

  • Developing a Data Generator and API

C# 10.0 All-in-one

$239.99

Buy Now

Related Courses

All Course
scroll to top