C# 10.0 All-in-one Programming Guide
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-0This course includes
Lessons
Hands-On Labs
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
Get the support you need. Enroll in our Instructor-Led Course.
Interactive Lessons
39+ Interactive 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
2
Creating Your First C# Console Application
- Creating a Source Program
- Executing a Source Program
4
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
5
Smooth Operators
- Demonstrating Operator Overloading
6
Getting into the Program Flow
- Calculating the Interest Using the if Statement
- Calculating the Amount of Principle Through Looping
7
Lining Up Your Ducks with Collections
- Calculating the Average of Numbers
- Processing Arrays by Using the foreach Loop
- Sorting Arrays of Data
8
Stepping through Collections
- Iterating Through a Directory of Files
9
Buying Generic
- Creating a Priority Queue
10
Some Exceptional Exceptions
- Demonstrating Exception Handling
11
Creating Lists of Items with Enumerations
- Demonstrating the Working of Enumerations
12
Showing Some Class
- Demostrating Working with Object-Based Code
13
We Have Our Methods
- Implementing Default Arguments
14
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
15
Holding a Class Responsible
- Solving the Rounding Problem
- Using Target Typing
16
Inheritance: Is That All I Get?
- Inheriting from a BankAccount Class
17
Poly-what-ism?
- Demonstrating the Polymorphic Nature of AbstractInheritance
18
Interfacing with the Interface
- Demonstrating the Implementation of the Incomparable IComparable<T> Interface
19
Delegating Those Important Events
- Demonstrating the Action, Func, and Predicate Delegate Types
- Using Static Anonymous Methods
20
Can I Use Your Namespace in the Library?
- Analyzing a Project with a Class Library
22
Interacting with Structures
- Using Supplemental Struct Elements
- Demonstrating a read-only Structure
23
Writing Secure Code
- Creating a Windows Application
24
Accessing Data
- Setting Up a Sample Database Schema
25
Fishing the File Stream
- Using StreamWriter
26
Accessing the Internet
- Demonstrating the Use of System.Net Namespace
27
Creating Images
- Demonstrating the Use of System.Drawing Namespace
31
Customizing Visual Studio
- Developing a Project Template
- Developing an Item Template
32
Introducing WPF
- Creating a WPF Application
33
Understanding the Basics of WPF
- Creating a Canvas
- Creating a Data Entry Form
- Demonstrating Display-Only Controls
34
Data Binding in WPF
- Binding a Data Object with XAML
- Validating the Data
35
Practical WPF
- Demonstrating the Use of Routed Commands
36
Programming for Windows 10 and Above
- Analyzing a UWP Project
37
Creating a Basic ASP.NET Core App
- Analyzing a Basic Web App
38
Employing the Razor Markup Language
- Overviewing a Razor Page
39
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 NowYou 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.