Contents

• Getting Started With C#
  • Creating a new console application Visual Studio
  • Creating a new project in Visual Studio console application and Running it in Debug mode
  • Creating a new program using Mono
  • Creating a new program using .NET Core
  • Creating a new query using LinqPad
  • Creating a new project using Xamarin Studio
• Literals
  • bool literals
  • byte literals
  • sbyte literals
  • char literals
  • int literals
  • uint literals
  • ulong literal
  • long literals
  • string literals
  • short literal
  • ushort literal
  • float literals
  • double literals
  • decimal literals
• Operators
  • Operator Precedence
  • Overloadable Operators
  • Overloading equality operators
  • Relational Operators
  • Implicit Cast and Explicit Cast Operators
  • Short-circuiting Operators
  • ? : Ternary Operator
  • ?. (Null Conditional Operator)
  • "Exclusive or" Operator
  • default Operator
  • Assignment operator '='
  • sizeof
  • ?? Null-Coalescing Operator
  • Bit-Shifting Operators
  • ⇒ Lambda operator
  • Class Member Operators Null Conditional Member Access
  • Class Member Operators Null Conditional Indexing
  • Postfix and Prefix increment and decrement
  • typeof
  • Binary operators with assignment
  • nameof Operator
  • Class Member Operators Member Access
  • Class Member Operators Function Invocation
  • Class Member Operators Aggregate Object Indexing
• Conditional Statements
  • If-Else Statement
  • If statement conditions are standard boolean expressions and values
  • If-Else If-Else Statement
  • Switch statements
• Equality Operator
  • Equality kinds in C# and equality operator
• Equals and GetHashCode
  • Writing a good GetHashCode override
  • Default Equals behavior.
  • Override Equals and GetHashCode on custom types
  • Equals and GetHashCode in IEqualityComparator
• Null-Coalescing Operator
  • Null-Coalescing Operator
  • Basic usage
  • Null fall-through and chaining
  • Null coalescing operator with method calls
  • Use existing or create new
  • Lazy properties initialization with null coalescing operator
• Null-Conditional Operators
  • Null-conditional Operators
  • Null-Conditional Operator
  • The Null-Conditional Index
  • Avoiding NullReferenceExceptions
  • Null-conditional Operator can be used with Extension Method
• nameof Operator
  • nameof Operator
  • Basic usage Printing a variable name
  • Raising PropertyChanged event
  • Argument Checking and Guard Clauses
  • Strongly typed MVC action links
  • Handling PropertyChanged events
  • Applied to a generic type parameter
  • Applied to qualified identifiers
  • Printing a parameter name
• Verbatim String
• Common String Operations
  • Padding a string to a fixed length
  • Correctly reversing a string
  • Formatting a string
  • 0Checking for empty String using String.IsNullOrEmpty and String.IsNullOrWhiteSpace
  • Getting x characters from the right side of a string
  • Convert Decimal Number to BinaryOctal and Hexadecimal Format
  • Trimming Unwanted Characters Off the Start andor End of Strings
  • Construct a string from Array
  • Formatting using ToString
  • Splitting a String by specific character
  • Joining an array of strings into a new one
  • Getting a char at specific index and enumerating the string
  • Determine whether a string begins with a given sequence
  • Splitting a String by another string
  • Getting Substrings of a given string
  • Replacing a string within a string
  • Changing the case of characters within a String
  • Concatenate an array of strings into a single string
  • String Concatenation
• String Format
  • String.Format
  • Since C# 6.0
  • Places where String.Format is embedded in the framework
  • Create a custom format provider
  • Date Formatting
  • Currency Formatting
  • Using custom number format
  • Align left right pad with spaces
  • Numeric formats
  • Escaping curly brackets inside a String.Format expression
  • ToString
  • Relationship with ToString
• String Concatenate
• String Manipulation
  • Replacing a string within a string
  • Changing the case of characters within a String
  • Finding a string within a string
  • Removing Trimming white-space from a string
  • Splitting a string using a delimiter
  • Concatenate an array of strings into a single string
  • String Concatenation
• String Interpolation
• String Escape Sequences
  • String Escape Sequences
  • Escaping special symbols in string literals
  • Unicode character escape sequences
  • Escaping special symbols in character literals
  • Using escape sequences in identifiers
  • Unrecognized escape sequences produce compile-time errors
• StringBuilder
  • What a StringBuilder is and when to use one
  • Use StringBuilder to create string from a large number of records
• Regex
  • Regex Parsing
  • Single match
  • Multiple matches
• DateTime
  • DateTime Formating
  • DateTime.AddDaysDouble
  • DateTime.AddHoursDouble
  • DateTime.TryParseString DateTime
  • DateTime.ParseString
  • DateTime.CompareDateTime t1 DateTime t2
  • DateTime.DaysInMonthInt32Int32
  • DateTime.AddYearsInt32
  • Pure functions warning when dealing with DateTime
  • DateTime.AddMillisecondsDouble
  • DateTime.TryParseExactStringStringIFormatProviderDateTimeStylesDateTime
  • DateTime as initializer in for-loop
  • DateTime ToString ToShortDateString ToLongDateString and ToString formatted
  • Current Date
  • Parse and TryParse with culture info
  • DateTime.ParseExactStringStringIFormatProvider
  • DateTime.AddTimeSpan
• Arrays
  • Arrays
  • Declaring an array
  • Copying arrays
  • Initializing an array filled with a repeated non-default value
  • Comparing arrays for equality
  • Multi-dimensional arrays
  • Getting and setting array values
  • Iterate over an array
  • Creating an array of sequential numbers
  • Jagged arrays
  • Array covariance
  • Checking if one array contains another array
  • Arrays as IEnumerable instances
• On Algorithm for circular rotation of an array
  • On Algorithm for circular rotation of an array
  • Example of a generic method that rotates an array by a given shift
• Enum
  • Enum
  • Enum basics
  • Enum as flags
  • Using notation for flags
  • Test flags-style enum values with bitwise logic
  • Enum to string and back
  • Add and remove values from flagged enum
  • Default value for enum ZERO
  • Adding additional description information to an enum value
  • Enums can have unexpected values
  • Get all the members values of an enum
  • Bitwise Manipulation using enums
• Tuples
  • Accessing tuple elements
  • Creating tuples
  • Comparing and sorting Tuples
  • Return multiple values from a method
• Overview of C# collections
  • HashSetT
  • DictionaryTKey TValue
  • ListT
  • T Array of T
  • SortedSetT
  • StackT
  • LinkedList<T>
  • Queue
• GUID
  • Guid
  • Getting the string representation of a Guid
  • Creating a Guid
  • Declaring a nullable GUID
• BigInteger
  • BigInteger
  • Calculate the First 1000-Digit Fibonacci Number
• Collection Initializers
  • Collection initializers
  • C# 6 Index Initializers
  • Collection initializers in custom classes
  • Using collection initializer inside object initializer
  • Collection Initializers with Parameter Arrays
• Looping
  • Foreach Loop
  • For Loop
  • Do - While Loop
  • Looping styles
  • Nested loops
  • break
  • While loop
  • continue
• Iterators
  • Iterators
  • Creating Iterators Using Yield
  • Simple Numeric Iterator Example
• IEnumerable
  • IEnumerable
  • IEnumerable with custom Enumerator
  • IEnumerable int
• Value type vs Reference type
  • Value type vs Reference type
  • Passing by reference using ref keyword.
  • Changing values elsewhere
  • Passing by reference
  • Difference with method parameters ref and out
  • ref vs out parameters
  • Assignment
• Built-in Types
  • Conversion of boxed value types
  • Value type - char
  • Value type - short int long signed 16 bit 32 bit 64 bit integers
  • Value type - ushort uint ulong unsigned 16 bit 32 bit 64 bit integers
  • Value type - bool
  • Comparisons with boxed value types
  • Immutable reference type - string
• Aliases of built-in types
  • Built-In Types Table
• Anonymous types
  • Anonymous vs dynamic
  • Creating an anonymous type
  • Anonymous type equality
  • Generic methods with anonymous types
  • Instantiating generic types with anonymous types
  • Implicitly typed arrays
• Dynamic type
  • Dynamic type
  • Creating a dynamic object with properties
  • Creating a dynamic variable
  • Returning dynamic
  • Handling Specific Types Unknown at Compile Time
• Type Conversion
  • Type Conversion
  • Explicit Type Conversion
  • MSDN implicit operator example
• Casting
  • Casting
  • Cast an object to a base type
  • Checking compatibility without casting
  • Explicit Casting
  • Implicit Casting
  • Explicit Numeric Conversions
  • Conversion Operators
  • LINQ Casting operations
  • Safe Explicit Casting as operator
• Nullable types
  • Nullable types
  • Getting a default value from a nullable
  • Initializing a nullable
  • Check if a Nullable has a value
  • Get the value of a nullable type
  • Check if a generic type parameter is a nullable type
  • Default value of nullable types is null
  • Effective usage of underlying NullableT argument
• Constructors and Finalizers
  • Static constructor
  • Singleton constructor pattern
  • Default Constructor
  • Forcing a static constructor to be called
  • Calling a constructor from another constructor
  • Calling the base class constructor
  • Finalizers on derived classes
  • Exceptions in static constructors
  • Calling virtual methods in constructor
  • Generic Static Constructors
  • Constructor and Property Initialization
• Access Modifiers
  • Access Modifiers
  • public
  • private
  • internal
  • protected
  • protected internal
• Interfaces
  • Implementing an interface
  • Explicit interface implementation
  • Implementing multiple interfaces
  • Interface Basics
  • IComparableT as an Example of Implementing an Interface
  • Why we use interfaces
  • Hiding members with Explicit Implementation
• Static Classes
  • Static Classes
  • Static keyword
  • Static class lifetime
• Singleton Implementation
  • Statically Initialized Singleton
  • Lazy thread-safe Singleton using LazyT
  • Lazy thread-safe Singleton using Double Checked Locking
  • Lazy thread safe singleton for .NET 3.5 or older alternate implementation
  • Disposing of the Singleton instance when it is no longer needed
• Dependency Injection
  • Dependency Injection
  • Dependency Injection C# and ASP.NET with Unity
  • Dependency injection using MEF
• Partial class and methods
  • Partial class and methods
  • Partial classes
  • Partial methods
  • Partial classes inheriting from a base class
• Object Initializers
  • Object initializers
  • Simple usage
  • Usage with non-default constructors
  • Usage with anonymous types
• Methods
  • Calling a Method
  • Anonymous method
  • Parameters and Arguments
  • Return Types
  • Default Parameters
  • Method overloading
  • Declaring a Method
  • Access rights
• Extension Methods
  • Extension Methods
  • Extension methods - overview
  • Null checking
  • Explicitly using an extension method
  • Generic Extension Methods
  • Extension methods can only see public or internal members of the extended class
  • Extension methods for chaining
  • Extension methods with Enumeration
  • Extension methods dispatch based on static type
  • Extension methods on Interfaces
  • Extension methods arent supported by dynamic code
  • Extension methods in combination with interfaces
  • Extensions and interfaces together enable DRY code and mixin-like functionality
  • IListT Extension Method Example Comparing 2 Lists
  • Extension methods as strongly typed wrappers
  • Using Extension methods to create mapper classes
  • Using Extension methods to build new collection types e.g. DictList
  • Extension methods for handling special cases
  • Using Extension methods with Static methods and Callbacks
• Named Arguments
  • Argument order is not necessary
  • Named Arguments can make your code more clear
  • Named arguments and optional paramaters
  • Named Arguments avoids bugs on optional parameters
• Named And Optional Arguments
  • Named and Optional Arguments
  • Optional Arguments
  • Named Arguments
• Data Annotation
  • Data Annotation Basics
  • Creating a custom validation attribute
  • Manually Execute Validation Attributes
  • EditableAttribute data modeling attribute
  • Validation Attributes
  • DisplayNameAttribute display attribute
• Keywords
  • as
  • goto
  • volatile
  • checked unchecked
  • virtual override new
  • stackalloc
  • break
  • const
  • for
  • async await
  • abstract
  • is
  • default
  • fixed
  • sealed
  • typeof
  • readonly
  • this
  • dynamic
  • foreach
  • try catch finally throw
  • namespace
  • void
  • ref out
  • float double decimal
  • char
  • params
  • base
  • operator
  • string
  • null
  • return
  • while
  • continue
  • using
  • ulong
  • uint
  • unsafe
  • int
  • var
  • lock
  • true false
  • internal
  • where
  • extern
  • switch
  • when
  • struct
  • static
  • if if...else if... else if
  • do
  • partial
  • unchecked
  • bool
  • interface
  • long
  • sizeof
  • in
  • enum
  • ushort
  • delegate
  • implicit
  • sbyte
  • event
• Recursion
  • Recursion
  • Recursion in plain English
  • Fibonacci Sequence
  • Using Recursion to Get Directory Tree
  • Recursively describe an object structure
  • PowerOf calculation
  • Factorial calculation
• Naming Conventions
  • Naming Conventions
  • Capitalization conventions
  • Enums
  • Interfaces
  • Exceptions
  • Private fields
  • Namespaces
• XML Documentation Comments
  • XML Documentation Comments
  • Simple method annotation
  • Generating XML from documentation comments
  • Method documentation comment with param and returns elements
  • Interface and class documentation comments
  • Referencing another class in documentation
• Comments and regions
  • Comments
  • Regions
  • Documentation comments
• Inheritance
  • Inheritance
  • Implementing an interface
  • Inheritance. Constructors calls sequence
  • Explicit interface implementation
  • Inheriting from a class and implementing an interface
  • Implementing multiple interfaces
  • Inheriting from a base class
  • Inheriting from a class and implementing multiple interfaces
  • Testing and navigating inheritance
  • Extending an abstract base class
  • Constructors in a subclass
  • Inheritance Anti-patterns
  • Inheriting methods
  • Base class with recursive type specification
• Generics
  • Generics
  • Implicit type inference methods
  • Type inference classes
  • Using generic method with an interface as a constraint type
  • Type constraints new-keyword
  • Type constraints classes and interfaces
  • Variant interfaces
  • Covariance
  • Contravariance
  • Reflecting on type parameters
  • Checking equality of generic values.
  • Invariance
  • Variant delegates
  • Variant types as parameters and return values
  • Type Parameters Interfaces
  • Type Parameters Classes
  • Explicit type parameters
  • Type constraints class and struct
  • Type Parameters Methods
  • Generic type casting
  • Configuration reader with generic type casting
• Using Statement
  • Using Statement
  • Using Statement Basics
  • Gotcha returning the resource which you are disposing
  • Multiple using statements with one block
  • Gotcha Exception in Dispose method masking other errors in Using blocks
  • Using statements are null-safe
  • Using Dispose Syntax to define custom scope
  • Using Statements and Database Connections
  • Using alias directives
  • Executing code in constraint context
• Using Directive
  • Using Directive
  • Access Static Members of a Class
  • Associate an Alias to Resolve Conflicts
  • Using alias directives
  • Reference a Namespace
  • Associate an Alias with a Namespace
  • Basic Usage
• IDisposable interface
  • IDisposable interface
  • In a class that contains only managed resources
  • In a class with managed and unmanaged resources
  • IDisposable Dispose
  • using keyword
  • In an inherited class with managed resources
• Reflection
  • Reflection
  • Get the members of a type
  • Get a method and invoke it
  • Creating an instance of a Type
  • Get a Strongly-Typed Delegate to a Method or Property via Reflection
  • Get a generic method and invoke it
  • Get a System.Type
  • Custom Attributes
  • Create an instance of a Generic Type and invoke its method
  • Instantiating classes that implement an interface e.g. plugin activation
  • Getting and setting properties
  • Determining generic arguments of instances of generic types
  • Get a Type by name with namespace
  • Looping through all the properties of a class
• IQueryable interface
  • Translating a LINQ query to a SQL query
• LINQ to Objects
  • Linq to Objects
  • Using LINQ to Objects
  • How LINQ to Object executes queries
• LINQ Queries
  • LINQ Queries
  • Chaining methods
  • First FirstOrDefault Last LastOrDefault Single and SingleOrDefault
  • Except
  • SelectMany
  • Any
  • JOINS
  • 0Skip and Take
  • Zip
  • 09Defining a variable inside a Linq query let keyword
  • Range and Repeat
  • All
  • Basics
  • Aggregate
  • Distinct
  • SelectMany Flattening a sequence of sequences
  • Query collection by type cast elements to type
  • GroupBy
  • Enumerating the Enumerable
  • Where
  • Contains
  • Using SelectMany instead of nested loops
  • Using Range with various Linq methods
  • Sum
  • SkipWhile
  • ToDictionary
  • SequenceEqual
  • Query Ordering - OrderBy ThenBy OrderByDescending ThenByDescending
  • Any and FirstOrDefault - best practice
  • GroupBy one or multiple fields
  • OrderBy
  • ElementAt and ElementAtOrDefault
  • ToLookup
  • Joining multiple sequences
  • Joining on multiple keys
  • DefaultIfEmpty
  • GroupBy Sum and Count
  • Count and LongCount
  • Linq Quantifiers
  • Build your own Linq operators for IEnumerableT
  • GroupJoin with outer range variable
  • Incrementally building a query
  • Concat
  • Reverse
  • Union
  • Select - Transforming elements
  • OrderByDescending
  • TakeWhile
  • Select with FuncTSource int TResult selector - Use to get ranking of elements
• LINQ to XML
  • Read XML using LINQ to XML
• Parallel LINQ PLINQ
  • Parallel LINQ PLINQ
  • Simple example
  • WithDegreeOfParallelism
  • AsOrdered
  • AsUnordered
• XmlDocument
  • XmlDocument vs XDocument Example and comparison
  • Reading from XML document
  • Basic XML document interaction
• XDocument
  • Generate an XML document
  • Modify XML File
  • Generate an XML document using fluent syntax
• C# 7.0 Features
  • C# 7.0 Features
  • Language support for Tuples
  • Local functions
  • out var declaration
  • Pattern Matching
  • Digit separators
  • Binary literals
  • throw expressions
  • Extended expression bodied members list
  • ref return and ref local
  • ValueTaskT
• C# 6.0 Features
  • C# 6.0 Features
  • Exception filters
  • String interpolation
  • Auto-property initializers
  • Null propagation
  • Expression-bodied function members
  • Operator nameof
  • Using static type
  • Index initializers
  • Improved overload resolution
  • Await in catch and finally
  • Minor changes and bugfixes
  • Using an extension method for collection initialization
  • Disable Warnings Enhancements
• C# 5.0 Features
  • C# 5.0 Features
  • Async Await
  • Caller Information Attributes
• C# 4.0 Features
  • Optional parameters and named arguments
  • Variance
  • Dynamic member lookup
  • Optional ref keyword when using COM
• C# 3.0 Features
  • C# 3.0 Features
  • Implicitly typed variables var
  • Language Integrated Queries LINQ
  • Lambda expresions
  • Anonymous types
• Exception Handling
  • Creating Custom Exceptions
  • Finally block
  • Best Practices
  • Exception Anti-patterns
  • Handling specific exception types
  • Basic Exception Handling
  • Aggregate exceptions multiple exceptions from one method
  • Throwing an exception
  • Unhandled and Thread Exception
  • Using the exception object
  • Nesting of Exceptions try catch blocks.
• NullReferenceException
  • NullReferenceException explained
• Handling FormatException
  • Converting string to integer
• Read and Understand Stack trackes
  • Read Understand Stacktraces
  • Stack trace for a simple NullReferenceException in Windows Forms
• Diagnostics
  • Redirecting log output with TraceListeners
  • Debug.WriteLine
• Overflow
  • Integer overflow
  • Overflow during operation
  • Ordering matters
• JSON handling
  • Getting Started Json with C#
  • Simple Json Example
  • First things First Library to work with Json
  • C# Implementation
  • Serialization
  • Deserialization
  • Serialization De-Serialization Common Utilities function
• Using json.net
  • Using json.net
  • Using JsonConverter on simple values
  • Collect all fields of JSON object
• Lambda Expressions
  • Lambda Expressions
  • Using lambda syntax to create a closure
  • Basic lambda expressions
  • Basic lambda expressions with LINQ
  • Lambda syntax with statement block body
  • Lambda expressions with System.Linq.Expressions
• Lambda expressions
  • Lambda expressions
  • Lambda Expressions as Shorthand for Delegate Initialization
  • Lambda Expression as an Event Handler
  • Lambda Expressions with Multiple Parameters or No Parameters
  • Lambdas can be emitted both as Func and Expression
  • Put Multiple Statements in a Statement Lambda
  • Lambdas for both Func and Action
  • Passing a Lambda Expression as a Parameter to a Method
• Generic Lambda Query Builder
  • Generic Lambda Query Builder
  • QueryFilter class
  • GetExpression Method
  • GetExpression Private overload
  • ConstantExpression Method
  • Usage
• Properties
  • Properties
  • Auto-implemented properties
  • Public Get
  • Public Set
  • Accessing Properties
  • Default Values for Properties
  • Various Properties in Context
  • Read-only properties
• Initializing Properties
  • Initializing Properties
  • C# 6.0 Initialize an Auto-Implemented Property
  • Initializing Property with a Backing Field
  • Initializing Property in Constructor
  • Property Initialization during object instantiation
• INotifyPropertyChanged interface
  • INotifyPropertyChanged interface
  • Implementing INotifyPropertyChanged in C# 6
  • INotifyPropertyChanged With Generic Set Method
• Events
  • Events
  • Declaring and Raising Events
  • Creating cancelable event
  • Event Properties
  • Standard Event Declaration
  • Anonymous Event Handler Declaration
  • Non-Standard Event Declaration
  • Creating custom EventArgs containing additional data
• Expression Trees
  • Expression Trees
  • Create Expression Trees with a lambda expression
  • Creating Expression Trees by Using the API
  • Compiling Expression Trees
  • Parsing Expression Trees
  • Expression Tree Basic
  • Examining the Structure of an Expression using Visitor
  • Understanding the expressions API
• Overload Resolution
  • Overload Resolution
  • Basic Overloading Example
  • params is not expanded unless necessary.
  • Passing null as one of the arguments
• Preprocessor directives
  • Preprocessor directives
  • Conditional Expressions
  • Other Compiler Instructions
  • Defining and Undefining Symbols
  • Region Blocks
  • Disabling and Restoring Compiler Warnings
  • Generating Compiler Warnings and Errors
  • Using the Conditional attribute
  • Custom Preprocessors at project level
• Structs
  • Structs
  • Declaring a struct
  • Struct usage
  • Struct implementing interface
  • Structs are copied on assignment
• Attributes
  • Creating a custom attribute
  • Reading an attribute
  • Using an attribute
  • DebuggerDisplay Attribute
  • Caller info attributes
  • Reading an attribute from interface
  • Obsolete Attribute
• Delegates
  • Delegates
  • Declaring a delegate type
  • Combine Delegates Multicast Delegates
  • The FuncT TResult ActionT and PredicateT delegate types
  • Safe invoke multicast delegate
  • Delegate Equality
  • Assigning a named method to a delegate
  • Assigning to a delegate by lambda
  • Underlying references of named method delegates
  • Passing delegates as parameters
  • Encapsulating transformations in functions
  • Closure inside a delegate
• File and Stream IO
  • File and Stream IO
  • Reading from a file using the System.IO.File class
  • Lazily reading a file line-by-line via an IEnumerable
  • Copy File
  • 0Writing lines to a file using the System.IO.StreamWriter class
  • Async write text to a file using StreamWriter
  • Writing to a file using the System.IO.File class
  • Files and Directories
  • Create File
  • Move File
  • Delete File
• Networking
  • Networking
  • Basic TCP Communication Client
  • Download a file from a web server
  • Async TCP Client
  • Basic UDP Client
• Performing HTTP requests
  • Creating and sending an HTTP POST request
  • Creating and sending an HTTP GET request
  • Error handling of specific HTTP response codes such as 404 Not Found
  • Sending asynchronous HTTP POST request with JSON body
  • Retrieve HTML for Web Page Simple
  • Sending asynchronous HTTP GET request and reading JSON request
• Reading and writing .zip files
  • Reading and writing .zip files
  • Writing to a zip file
  • Writing Zip Files in-memory
  • Get files from a Zip file
  • The following example shows how to open a zip archive and extract all .txt files to a folder
• FileSystemWatcher
  • FileSystemWatcher
  • IsFileReady
  • Basic FileWatcher
• Asynchronous Socket
  • Asynchronous Socket
  • Asynchronous Socket Client Server example.
• Action Filters
  • Custom Action Filters
• Polymorphism
  • Types of Polymorphism
  • Another Polymorphism Example
• Immutability
  • Strings and immutability
  • System.String class
• Indexer
  • Indexer
  • A simple indexer
  • Overloading the indexer to create a SparseArray
  • Indexer with 2 arguments and interface
• Checked and Unchecked
  • Checked and Unchecked
  • Checked and Unchecked
  • Checked and Unchecked as a scope
• Stream
  • Using Streams
• Timers
  • Timers
  • Multithreaded Timers
  • Creating an Instance of a Timer
  • Assigning the Tick event handler to a Timer
  • Example Using a Timer to perform a simple countdown.
• Stopwatches
  • Stopwatches
  • IsHighResolution
  • Creating an Instance of a Stopwatch
• Threading
  • Threading
  • Avoiding Reading and Writing Data Simultaneously
  • Parallel.ForEach Loop
  • Creating and Starting a Second Thread
  • Simple Complete Threading Demo
  • Deadlocks hold resource and wait
  • Creating One Thread Per Processor
  • Implicit Task Parallelism
  • Starting a thread with parameters
  • Simple Complete Threading Demo using Tasks
  • Explicit Task Parallism
  • Deadlocks two threads waiting on each other
• Async/Await, BackgroundWorker, Task and Thread examples
  • Async / Await BackgroundWorker Task and Thread Examples
  • ASP.NET Configure Await
  • Async / Await
  • BackgroundWorker
  • Task
  • Thread
  • Task run and forget extension
• Async Await
  • Async Await
  • Await operator and async keyword
  • Concurrent calls
  • TryCatchFinally
  • Returning a Task without await
  • Web.config setup to target 4.5 for correct async behavior
  • Async Await will only improve performance if it allows the machine to do additional work
  • Simple consecutive calls
  • Blocking on async code can cause deadlocks
• Synchronization Context in Async/Await
  • Pseudocode for async/await keywords
  • Disabling synchronization context
  • Why SynchronizationContext is so important
• BackgroundWorker
  • BackgroundWorker
  • Using a BackgroundWorker to complete a task.
  • Assigning Event Handlers to a BackgroundWorker
  • Creating a new BackgroundWorker instance
  • Assigning Properties to a BackgroundWorker
• Task Parallel Library
  • Parallel.ForEach
  • Parallel.For
  • Parallel.Invoke
  • Async version of PingUrl
  • A cancellable polling Task using CancellationTokenSource
  • An async cancellable polling Task that waits between iterations
• Making a variable thread safe
  • Controlling access to a variable in a Parallel.For loop
• Lock Statement
  • Lock Statement
  • Throwing exception in a lock statement
  • Simple usage
  • Return in a lock statement
  • Anti-Patterns and gotchas
  • Using instances of Object for lock
• Yield Keyword
  • Yield Keyword
  • Simple Usage
  • Correctly checking arguments
  • Early Termination
  • More Pertinent Usage
  • Lazy Evaluation
  • Try...finally
  • Using yield to create an IEnumeratorT when implementing IEnumerableT
  • Eager evaluation
  • Return another Enumerable within a method returning Enumerable
  • Lazy Evaluation Example Fibonacci Numbers
  • The difference between break and yield break
• Task Parallel Library TPL Dataflow Constructs
  • ActionBlockT
  • BroadcastBlockT
  • BufferBlockT
  • JoinBlockT1 T2
  • BatchedJoinBlockT1 T2
  • TransformBlockTInput TOutput
  • TransformManyBlockTInput TOutput
  • BatchBlockT
  • WriteOnceBlockT
• Functional Programming
  • Func and Action
  • Avoid Null References
  • Higher-Order Functions
  • Immutability
  • Immutable collections
• Func delegates
  • Func delegates
  • Without parameters
  • With multiple variables
  • Lambda anonymous methods
  • Covariant Contravariant Type Parameters
• Function with multiple return values
  • Function with multiple return values
  • anonymous object dynamic keyword solution
  • Tuple solution
  • Ref and Out Parameters
• Binary Serialization
  • Binary Serialization
  • Controlling serialization behavior with attributes
  • Serialization Binder
  • Some gotchas in backward compatibility
  • Making an object serializable
  • Serialization surrogates Implementing ISerializationSurrogate
  • Adding more control by implementing ISerializable
• ICloneable
  • ICloneable
  • Implementing ICloneable in a class
  • Implementing ICloneable in a struct
• IComparable
  • Sort versions
• Accessing Databases
  • Connection Strings
  • Entity Framework Connections
  • ADO.NET Connections
• Using SQLite
  • Creating simple CRUD using SQLite in C#
  • Executing Query
• Caching
  • MemoryCache
• Code Contracts
  • Code Contracts
  • Postconditions
  • Invariants
  • Defining Contracts on Interface
  • Preconditions
• Code Contracts and Assertions
  • Assertions to check logic should always be true
• Structural Design Patterns
  • Structural Design Patterns
  • Adapter Design Pattern
• Creational Design Patterns
  • Creational Design Patterns
  • Singleton Pattern
  • Factory Method pattern
  • Abstract Factory Pattern
  • Builder Pattern
  • Prototype Pattern
• Implementing Decorating Design Pattern
  • Implementing Decorator Design Pattern
  • Simulating cafeteria
• Implementing Flyweight Design Pattern
  • Implementing map in RPG game
• System.Management.Automation
  • System.Management.Automation
  • Invoke simple synchronous pipeline
• Pointers
  • Pointers
  • Pointers for array access
  • Pointer arithmetic
  • The asterisk is part of the type
  • void
  • Member access using →
  • Generic pointers
• Pointers and Unsafe Code
  • Introduction to unsafe code
  • Accessing Array Elements Using a Pointer
  • Compiling Unsafe Code
  • Retrieving the Data Value Using a Pointer
  • Passing Pointers as Parameters to Methods
• Simulating C Unions with C# Structs
  • How to use C# Structs to create a Union type Similar to C Unions
  • C-Style Unions in C#
  • Union Types in C can also contain Struct fields
• Reactive Extensions Rx
  • Observing TextChanged event on a TextBox
  • Streaming Data from Database with Observable
• AsseblyInfo.cs examples
  • AssemblyInfo.cs Examples
  • Global and local AssemblyInfo
  • AssemblyVersion
  • AssemblyProduct
  • Automated versioning
  • Common fields
  • AssemblyTitle
  • InternalsVisibleTo
  • Reading Assembly Attributes
  • AssemblyConfiguration
  • AssemblyKeyFile
• Creating Console Application
  • Creating a Console application using a Plain-Text Editor and the C Compiler
• CLSCompliantAttribute
  • CLSCompliantAttribute
  • Access Modifier to which CLS rules apply
  • Violation of CLS rule Unsigned types sbyte
  • Violation of CLS rule Same naming
  • Violation of CLS rule Identifier
  • Violation of CLS rule Inherit from non CLSComplaint class
• ObservableCollection<T>
  • Initialize ObservableCollection<T>
• Hash Functions
  • Hash Functions
  • MD5
  • SHA1
  • SHA256
  • SHA384
  • SHA512
  • PBKDF2 for Password Hashing
  • Complete Password Hashing Solution using Pbkdf2
• Generating Random Numbers
  • Generating Random Numbers in C#
  • Generate a random int
  • Generate a random int in a given range
  • Generating the same sequence of random numbers over and over again
  • Create multiple random class with different seeds simultaneously
  • Generate a Random double
  • Generate a random character
  • Generate a number that is a percentage of a max value
• Cryptography
  • Modern Examples of Symmetric Authenticated Encryption of a string
  • Introduction to Symmetric and Asymmetric Encryption
  • Password Hashing
  • Simple Symmetric File Encryption
  • Cryptographically Secure Random Data
  • Fast Asymmetric File Encryption
• Unsafe Code in .NET
  • Unsafe Code in .NET
  • Using unsafe with arrays
  • Using unsafe with strings
  • Unsafe Array Index
• C# Script
  • Simple code evaluation
• Runtime Compile
  • RoslynScript
  • CSharpCodeProvider
• Interoperability
  • Interoperability
  • Import function from unmanaged C++ DLL
  • Calling conventions
  • C++ name mangling
  • Dynamic loading and unloading of unmanaged DLLs
  • Dealing with Win32 Errors
  • Reading structures with Marshal
  • Pinned Object
  • Simple code to expose class for com
• .NET Compiler Platform Roslyn
  • Semantic model
  • Syntax tree
  • Create workspace from MSBuild project
• Creating Own MessageBox in Windows Form Application
  • Creating Own MessageBox in Windows Form Application
  • Creating Own MessageBox Control
  • How to use own created MessageBox control in another Windows Form application
• Including Font Resources
  • Instantiate Fontfamily from Resources
  • Integration method
  • Usage with a Button
• Garbage Collector
  • Weak References
  • Large Object Heap compaction
• Windows Communication Foundation
  • Windows Communication Foundation
  • Getting started sample
• Contributors