C# 10.0 All-in-one
(CSHARP-BASIC.AE1)/ISBN:978-1-64459-478-0
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.
Lessons
39+ Lessons | 300+ Quizzes | 180+ Flashcards | 180+ Glossary of terms
Hands-On Labs
52+ LiveLab | 51+ Video tutorials | 01:28+ Hours
Need guidance and support? Click here to check our Instructor Led Course.
Here's what you will learn
Download Course OutlineLessons 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
Poly-what-ism?
- 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