uCertify

C# 10.0 All-in-one

Boost your programming skills with the latest C# coding techniques in the ever-evolving world of coding. 

(CSHARP-BASIC.AE1) / ISBN : 978-1-64459-478-0
Lessons
Lab
Get A Free Trial

About This Course

This C# 10.0 online training course provides a comprehensive overview of C# programming language, its core concepts, object-oriented programming principles, and the latest features. Dive into the all-inclusive fundamentals, including syntax, data types, variables, operators, control flow statements, and methods. Learn the object-oriented programming (OOP) concepts such as classes, objects, inheritance, polymorphism, and encapsulation. Discover the latest C# 10.0 features like top-level statements, records, pattern matching, etc. and know how they function with our hands-on-training Labs. This C# Programming language course content has practice exercises that are ideal for both students and professionals.

Skills You’ll Get

  • Understanding of C# and .Net fundamentals
  • Grasping the core OCP concepts
  • Identifying and resolving coding errors
  • Using advanced C# features (generics, delegates, etc.) 
  • Learning latest features like top-level statements, records, pattern matching, and more
  • Expertise in creating console applications
  • Building web applications using ASP.NET
  • Knowledge of different phases of software development Lifecycle
Download Course Outline

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
2

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
3

Smooth Operators

  • Demonstrating Operator Overloading
4

Getting into the Program Flow

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

Lining Up Your Ducks with Collections

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

Stepping through Collections

  • Iterating Through a Directory of Files
7

Buying Generic

  • Creating a Priority Queue
8

Some Exceptional Exceptions

  • Demonstrating Exception Handling
9

Creating Lists of Items with Enumerations

  • Demonstrating the Working of Enumerations
10

Showing Some Class

  • Demostrating Working with Object-Based Code
11

We Have Our Methods

  • Implementing Default Arguments
12

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
13

Holding a Class Responsible

  • Solving the Rounding Problem
  • Using Target Typing
14

Inheritance: Is That All I Get?

  • Inheriting from a BankAccount Class
15

Poly-what-ism?

  • Demonstrating the Polymorphic Nature of AbstractInheritance
16

Interfacing with the Interface

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

Delegating Those Important Events

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

Can I Use Your Namespace in the Library?

  • Analyzing a Project with a Class Library
19

Interacting with Structures

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

Writing Secure Code

  • Creating a Windows Application
21

Accessing Data

  • Setting Up a Sample Database Schema
22

Fishing the File Stream

  • Using StreamWriter
23

Accessing the Internet

  • Demonstrating the Use of System.Net Namespace
24

Creating Images

  • Demonstrating the Use of System.Drawing Namespace
25

Customizing Visual Studio

  • Developing a Project Template
  • Developing an Item Template
26

Introducing WPF

  • Creating a WPF Application
27

Understanding the Basics of WPF

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

Data Binding in WPF

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

Practical WPF

  • Demonstrating the Use of Routed Commands
30

Programming for Windows 10 and Above

  • Analyzing a UWP Project
31

Creating a Basic ASP.NET Core App

  • Analyzing a Basic Web App
32

Employing the Razor Markup Language

  • Overviewing a Razor Page
33

Generating and Consuming Data

  • Developing a Data Generator and API

Any questions?
Check out the FAQs

Still have unanswered questions and need to get in touch?

Contact Us Now

You should have some basic programming experience using C or C++, understanding of operating systems and software, and an analytical mindset with good problem-solving skills.

Yes, you don’t need any prior experience of programming to join this course. It is designed to help you learn C# 10.0 fundamental concepts while introducing the specific and advanced features of the C# language.

As the name suggest, it is a C# 10.0 all-in-one guide that covers the core programming concepts like basic syntax, data type, variable and constant, and more; OOP concepts including classes and objects, inheritance, polymorphism, and more; and C# specific features like generics, anonymous functions, exception handling, and more.

Yes, you’ll get a certificate of completion.

Yes, uCertify is known for offering high-quality up-to-date courses with timely updates. You’ll find everything from latest course content to hands-on Labs, instructor access, and practice tests under one roof.

Stay Sharp With C# 

Decode the latest techniques of programming with C# 10.0 hands-on training.

$239.99

Buy Now

Related Courses

All Course