Introduction
Part 1: Beginner Guide
.NET Framework
.NET Common Language Runtime (CLR)
.NET Framework Class Library
.NET Framework Class Library Namespaces
.NET Framework Base Class Library
Installing Visual Studio
Modifying Your Project
Compiling and Running Your Project
Namespaces β A Brief Introduction
Class and Method Declarations
Whatβs Next?
C# Comments
C# Keywords
Modifier Keywords
Access Modifier Keywords
Statement Keywords
Method Parameter Keywords
Namespace Keywords
Operator Keywords
Access Keywords
Literal Keywords
Type Keywords
Contextual Keywords
Query Keywords
Whatβs Next?
Variables
Creating Variables
Assigning a Value to a Variable
Types of Variables
Writing a Good Variable Name
Quick Primer
What's Next?
Basic Math
Addition, Subtraction, Multiplication, and Division
Modulus Operator
The Unary "+" and "-" Operators
Parentheses and Order of Operations
Compound Assignment Operators
Quick Primer
Whatβs Next?
User Input
User Input from the Console
Converting
Whatβs Next?
Math Part 2
Integer Division
Typecasting
Division By Zero
Overflow and Underflow
Incrementing and Decrementing
Quick Primer
What's Next?
Decision-making
The if Statement
The else-statement
else-if-statements
Relational Operators
Using bool in Decision-making
The ! Operator
Conditional Operators: && and ||
Nesting if Statements
Quick Primer
What's Next?
Switch Statements
Switch Statement Basics
Types Used with Switch Statements
Implicit Fall-Through
Quick Primer
What's Next?
Looping
The While Loop
The Do-While Loop
The For Loop
Breaking Out of Loops
The Next Loop Iteration
Nesting Loops and Some Practice
Quick Primer
What's Next?
Arrays
What is an Array?
Working with Arrays
Average Value in an Array
Arrays of Arrays and Multi-Dimensional Arrays
The Foreach Loop
Quick Primer
What's Next?
Enumerations
The Basics of Enumerations
Why Enumerations are Useful
Quick Primer
What's Next?
Part 2: Intermediate Guide
Methods
Creating a Method
Calling Methods
Returning Something From a Method
Handing Something Off to a Method
Passing in Multiple Parameters
Method Overloading
Convert and Console Classes
A Brief Look at Recursion
Quick Primer
What's Next?
Classes Part 1
What is an Object?
What is a Class?
Creating an Object
Using an Object
Constructors
Stack vs. Heap
Stack vs. Heap: What's the difference?
What Goes On The Stack and Heap?
Passing by Reference and by Value
Garbage Collection
Memory Facts
How Does GC Work?
Cleaning up Unmanaged Resources
Quick Primer
What's Next?
Classes Part 2
Creating a New Class
Adding Instance Variables
Access Modifiers: Private and Public
Adding Constructors
Variable Scope
Name Hiding
The this Keyword
Adding Methods
Static Methods, Variables, and Classes
Quick Primer
What's Next?
Properties
Why Properties?
Creating Properties
Accessibility Levels
Auto-Implemented Properties
Setting Properties at Object Creation
Quick Primer
What's Next?
Structs
Creating a struct
What's the Difference?
Quick Primer
What's Next?
Inheritance
Base Classes
Derived Classes
Using Derived Classes
Checking Type and Casting for Objects
Constructors and Inheritance
Protected Access Modifier
The Base Class of Everything
Preventing Inheritance
Quick Primer
What's Next?
Polymorphism, Virtual Methods, and Abstract Classes
What is Polymorphism and Why Do We Need it?
Virtual Methods and Overriding
Back to the Base Keyword
Abstract Base Classes
Abstract Methods
The new Keyword with Methods
Quick Primer
What's Next?
Interfaces
What is an Interface?
How to Create an Interface
Multiple Inheritance
Quick Primer
What's Next?
Generics: Part 1
Why Generics?
What are Generics?
The List Class
The Dictionary Class
Quick Primer
Whatβs Next?
Generics: Part 2
Creating a Generic Class
Using Generic Types in Classes
Generic Constraints
Quick Primer
What's Next?
Part 3: Advanced Guide
File I/O
The Easy Method
Reading Text-Based Files
Reading and Writing Binary Files
The File Class
Quick Primer
What's Next?
Error Handling: Exceptions
"Catching" Exceptions
Not Naming the Exception Variable
Different Ways to Handle Different Exceptions
Throwing Exceptions
The finally Keyword
Quick Primer
What's Next?
Delegates
Delegates in C#
Declaring a Delegate
Using Delegates
Methods as First-Class Citizens
A Better Example
Quick Primer
What's Next?
Events
Defining an Event
Raising an Event
Attaching and Detaching Events
Quick Primer
What's Next?
Threading
Threading Tasks
Pulling the Work Out for Threading
Starting the Thread
Thread-safety
Quick Primer
What's Next?
Operator Overloading
Overloading Operators
Quick Primer
What's Next?
Indexers
Making an Indexer
Quick Primer
What's Next?
User-Defined Conversions
Implicit vs. Explicit Conversions
Creating a User-Defined Conversion
Quick Primer
What's Next?
Extension Methods
Creating an Extension Method
Quick Primer
Quick Quiz
Part 4: More Advanced Section
C# Reflection
C# Type Class
C# Type Methods
Anonymous Functions
Using Lambda Expressions with Anonymous Types
Anonymous Methods
Lambda Expressions
Asynchronous Programming
Async
Await
LINQ
Query Operators
LINQ and SQL
Retrieve and delete XML data
Parallel Class and PLINQ
The ParallelEnumerable Class
The Opt-in Model
Execution Modes
Degree of Parallelism
Ordered vs. Unordered Parallel Queries
Parallel vs. Sequential Queries
The ForAll Operator
Cancellation
Exceptions
Custom Partitioners
Measuring PLINQ Performance
Understanding PLINQ Speedup
What Can Impact PLINQ Query Performance?
When Sequential Mode is Chosen
PLINQ Order Preservation
Query Operators and Ordering
Using Unsafe Code
Unsafe Contexts
Pointer Types
Fixed And Moveable Variables
Pointer Conversions
Pointer Arrays
Pointers In Expressions
Pointer Increment and Decrement
Pointer Arithmetic
Pointer Comparison
The sizeof Operator
The Fixed Statement
Fixed-Size Buffers
Definite Assignment Checking
Stack Allocation
Dynamic Memory Allocation
An Introduction to Windows Forms
Understanding Windows Forms
Using Forms as Dialog Boxes
Using Forms as Views
A Simple Windows Forms Project
Executing Windows Forms Projects
Adding a New Form to a Project
Modal Forms vs. Modeless Forms
The DialogResult Value
Passing Values to Forms
Using Message Boxes to Display Information
Controlling a Windows Forms Application
Application Path Information
Performing Idle Work
Closing an Application
Using Form Properties To Change Form Behavior
Defining Other Form Properties
Conclusion
Answers