Skip to content
Home
Programs
Close Programs
Open Programs
Cybersecurity
Courses
Community
News
Knowledgebase
GIS
Courses
Community
News
Knowledgebase
Agile Methodologies
Courses
Community
News
Knowledgebase
Catalog
About
Contact Us
Login
Sign Up
$
0.00
0
Cart
Login
Sign Up
$
0.00
0
Cart
Login
Sign Up
$
0.00
0
Cart
Home
All Programs
Computers
Languages
C# 10.0
C# 10.0
Curriculum
45 Sections
199 Lessons
10 Weeks
Expand all sections
Collapse all sections
Introduction
5
1.1
About This Book
1.2
Foolish Assumptions
1.3
Icons Used in This Book
1.4
Beyond the Book
1.5
Where to Go from Here
Book 1: The Basics of C# Programming
0
Chapter 1: Creating Your First C# Console Application
8
3.1
Getting a Handle on Computer Languages, C#, and .NET
3.2
Creating Your First Console Application
3.3
Making Your Console App Do Something
3.4
Reviewing Your Console Application
3.5
Replacing All that Ceremonial Code: Top-Level Statements
3.6
Introducing the Toolbox Trick
3.7
Interacting with C# Online
3.8
Working with Jupyter Notebook: The Short Version
Chapter 2: Living with Variability — Declaring Value-Type Variables
13
4.1
Declaring a Variable
4.2
What’s an int?
4.3
Representing Fractions
4.4
Handling Floating-Point Variables
4.5
Using the Decimal Type: Is It an Integer or a Float?
4.6
Examining the bool Type: Is It Logical?
4.7
Checking Out Character Types
4.8
What’s a Value Type?
4.9
Comparing string and char
4.10
Calculating Leap Years: DateTime
4.11
Declaring Numeric Constants
4.12
Changing Types: The Cast
4.13
Letting the C# Compiler Infer Data Types
Chapter 3: Pulling Strings
10
5.1
The Union Is Indivisible, and So Are Strings
5.2
Performing Common Operations on a String
5.3
Comparing Strings
5.4
What If I Want to Switch Case?
5.5
Looping through a String
5.6
Searching Strings
5.7
Getting Input from Users in Console Applications
5.8
Controlling Output Manually
5.9
Formatting Your Strings Precisely
5.10
StringBuilder: Manipulating Strings More Efficiently
Chapter 4: Smooth Operators
3
6.1
Performing Arithmetic
6.2
Performing Logical Comparisons — Is That Logical?
6.3
Matching Expression Types at TrackDownAMate.com
Chapter 5: Getting into the Program Flow
3
7.1
Branching Out with if and switch
7.2
Here We Go Loop-the-Loop
7.3
Looping a Specified Number of Times with for
Chapter 6: Lining Up Your Ducks with Collections
10
8.1
The C# Array
8.2
Processing Arrays by Using foreach
8.3
Sorting Arrays of Data
8.4
Using var for Arrays
8.5
Loosening Up with C# Collections
8.6
Understanding Collection Syntax
8.7
Using Lists
8.8
Using Dictionaries
8.9
Array and Collection Initializers
8.10
Using Sets
Chapter 7: Stepping through Collections
4
9.1
Iterating through a Directory of Files
9.2
Iterating foreach Collections: Iterators
9.3
Accessing Collections the Array Way: Indexers
9.4
Looping Around the Iterator Block
Chapter 8: Buying Generic
3
10.1
Writing a New Prescription: Generics
10.2
Classy Generics: Writing Your Own
10.3
Understanding Variance in Generics
Chapter 9: Some Exceptional Exceptions
6
11.1
Using an Exceptional Error-Reporting Mechanism
11.2
Can I Get an Exceptional Example?
11.3
Working with Custom Exceptions
11.4
Planning Your Exception-Handling Strategy
11.5
Grabbing Your Last Chance to Catch an Exception
11.6
Throwing Expressions
Chapter 10: Creating Lists of Items with Enumerations
5
12.1
Seeing Enumerations in the Real World
12.2
Working with Enumerations
12.3
Creating Enumerated Flags
12.4
Defining Enumerated Switches
12.5
Working with Enumeration Methods
Book 2: Object-Oriented C# Programming
0
Chapter 1: Showing Some Class
9
14.1
A Quick Overview of Object-Oriented Programming
14.2
Defining a Class and an Object
14.3
Accessing the Members of an Object
14.4
Working with Object-Based Code
14.5
Discriminating between Objects
14.6
Can You Give Me References?
14.7
Classes That Contain Classes Are the Happiest Classes in the World
14.8
Generating Static in Class Members
14.9
Defining const and readonly Data Members
Chapter 2: We Have Our Methods
6
15.1
Defining and Using a Method
15.2
Method Examples for Your Files
15.3
Having Arguments with Methods
15.4
Using the Call-by-Reference Feature
15.5
Defining a Method with No Return Value
15.6
Returning Multiple Values Using Tuples
Chapter 3: Let Me Say This about this
4
16.1
Passing an Object to a Method
16.2
Comparing Static and Instance Methods
16.3
Accessing the Current Object
16.4
Using Local Functions
Chapter 4: Holding a Class Responsible
7
17.1
Restricting Access to Class Members
17.2
Why You Should Worry about Access Control
17.3
Defining Class Properties
17.4
Using Target Typing for Your Convenience
17.5
Dealing with Covariant Return Types
17.6
Getting Your Objects Off to a Good Start — Constructors
17.7
Using Expression-Bodied Members
Chapter 5: Inheritance: Is That All I Get?
4
18.1
Why You Need Inheritance
18.2
Inheriting from a BankAccount Class (a More Complex Example)
18.3
IS_A versus HAS_A — I’m So Confused_A
18.4
Other Features That Support Inheritance
Chapter 6: Poly-what-ism?
4
19.1
Overloading an Inherited Method
19.2
Polymorphism
19.3
C# During Its Abstract Period
19.4
Sealing a Class
Chapter 7: Interfacing with the Interface
9
20.1
Introducing CAN_BE_USED_AS
20.2
Knowing What an Interface Is
20.3
Using an Interface
20.4
Using the C# Predefined Interface Types
20.5
Looking at a Program That CAN_BE_USED_AS an Example
20.6
Unifying Class Hierarchies
20.7
Hiding Behind an Interface
20.8
Inheriting an Interface
20.9
Using Interfaces to Manage Change in Object-Oriented Programs
Chapter 8: Delegating Those Important Events
6
21.1
E.T., Phone Home — The Callback Problem
21.2
Defining a Delegate
21.3
Pass Me the Code, Please — Examples
21.4
A More Real-World Example
21.5
Shh! Keep It Quiet — Anonymous Methods
21.6
Stuff Happens — C# Events
Chapter 9: Can I Use Your Namespace in the Library?
7
22.1
Dividing a Single Program into Multiple Source Files
22.2
Working with Global using Statements
22.3
Dividing a Single Program into Multiple Assemblies
22.4
Putting Your Classes into Class Libraries
22.5
Going Beyond Public and Private: More Access Keywords
22.6
Putting Classes into Namespaces
22.7
Working with Partial Methods
Chapter 10: Improving Productivity with Named and Optional Parameters
4
23.1
Exploring Optional Parameters
23.2
Looking at Named Parameters
23.3
Using Alternative Methods to Return Values
23.4
Dealing with null Parameters
Chapter 11: Interacting with Structures
6
24.1
Comparing Structures to Classes
24.2
Creating Structures
24.3
Working with Read-only Structures
24.4
Working with Reference Structures
24.5
Using Structures as Records
24.6
Using the New Record Type
Book 3: Designing for C#
0
Chapter 1: Writing Secure Code
3
26.1
Designing Secure Software
26.2
Building Secure Windows Applications
26.3
Using System.Security
Chapter 2: Accessing Data
4
27.1
Getting to Know System.Data
27.2
How the Data Classes Fit into the Framework
27.3
Getting to Your Data
27.4
Using the System.Data Namespace
Chapter 3: Fishing the File Stream
5
28.1
Going Where the Fish Are: The File Stream
28.2
StreamWriting for Old Walter
28.3
Pulling Them Out of the Stream: Using StreamReader
28.4
More Readers and Writers
28.5
Exploring More Streams than Lewis and Clark
Chapter 4: Accessing the Internet
3
29.1
Getting to Know System.Net
29.2
How Net Classes Fit into the Framework
29.3
Using the System.Net Namespace
Chapter 5: Creating Images
3
30.1
Getting to Know System.Drawing
30.2
How the Drawing Classes Fit into the Framework
30.3
Using the System.Drawing Namespace
Chapter 6: Programming Dynamically!
5
31.1
Shifting C# Toward Dynamic Typing
31.2
Employing Dynamic Programming Techniques
31.3
Putting Dynamic to Use
31.4
Running with the Dynamic Language Runtime
31.5
Using Static Anonymous Functions
Book 4: A Tour of Visual Studio
0
Chapter 1: Getting Started with Visual Studio
3
33.1
Versioning the Versions
33.2
Installing Visual Studio
33.3
Breaking Down the Projects
Chapter 2: Using the Interface
5
34.1
Designing in the Designer
34.2
Paneling the Studio
34.3
Coding in the Code Editor
34.4
Using the Tools of the Trade
34.5
Using the Debugger as an Aid to Learning
Chapter 3: Customizing Visual Studio
2
35.1
Setting Options
35.2
Creating Your Own Templates
Book 5: Windows Development with WPF
0
Chapter 1: Introducing WPF
4
37.1
Understanding What WPF Can Do
37.2
Introducing XAML
37.3
Diving In! Creating Your First WPF Application
37.4
Whatever XAML Can Do, C# Can Do Better!
Chapter 2: Understanding the Basics of WPF
3
38.1
Using WPF to Lay Out Your Application
38.2
Arranging Elements with Layout Panels
38.3
Exploring Common XAML Controls
Chapter 3: Data Binding in WPF
5
39.1
Getting to Know Dependency Properties
39.2
Exploring the Binding Modes
39.3
Investigating the Binding Object
39.4
Editing, Validating, Converting, and Visualizing Your Data
39.5
Finding Out More about WPF Data Binding
Chapter 4: Practical WPF
4
40.1
Commanding Attention
40.2
Using Built-In Commands
40.3
Using Custom Commands
40.4
Using Routed Commands
Chapter 5: Programming for Windows 10 and Above
4
41.1
What is the Universal Windows Platform (UWP)?
41.2
Devices Supported by the UWP
41.3
Creating Your Own UWP App
41.4
Working with .NET Core Applications
Book 6: Web Development with ASP.NET
0
Chapter 1: Creating a Basic ASP.NET Core App
2
43.1
Understanding the ASP.NET Core Templates
43.2
Developing a Basic Web App
Chapter 2: Employing the Razor Markup Language
4
44.1
Avoiding Nicks from Razor
44.2
Creating Variables
44.3
Keeping Things Logical
44.4
Implementing Loops
Chapter 3: Generating and Consuming Data
4
45.1
Understanding Why These Projects Are Important
45.2
Serialized Data Isn’t for Breakfast
45.3
Developing a Data Generator and API
45.4
Creating a Consumer Website
This content is protected, please
login
and
enroll
in the course to view this content!
Login
or
Sign Up
Home
Programs
Close Programs
Open Programs
Cybersecurity
Courses
Community
News
Knowledgebase
GIS
Courses
Community
News
Knowledgebase
Agile Methodologies
Courses
Community
News
Knowledgebase
Cybersecurity
Courses
Community
News
Knowledgebase
Catalog
About
Contact Us
Linkedin
Instagram
Modal title
Main Content
