Chapters
22 Enum
25 GUID
107 Stream
108 Timers
Table Of Contents
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
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
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
If-Else Statement
If statement conditions are standard boolean expressions and values
If-Else If-Else Statement
Switch statements
Equality kinds in C# and equality operator
Writing a good GetHashCode override
Default Equals behavior.
Override Equals and GetHashCode on custom types
Equals and GetHashCode in IEqualityComparator
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 Operator
The Null-Conditional Index
Avoiding NullReferenceExceptions
Null-conditional Operator can be used with Extension Method
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
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
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
Operator
Concatenate strings using System.Text.StringBuilder
Concat string array elements using String.Join
Concatenation of two strings using
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 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
What a StringBuilder is and when to use one
Use StringBuilder to create string from a large number of records
Regex Parsing
Single match
Multiple matches
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
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
Example of a generic method that rotates an array by a given shift
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
Accessing tuple elements
Creating tuples
Comparing and sorting Tuples
Return multiple values from a method
HashSetT
DictionaryTKey TValue
ListT
T Array of T
SortedSetT
StackT
LinkedList<T>
Queue
Guid
Getting the string representation of a Guid
Creating a Guid
Declaring a nullable GUID
BigInteger
Calculate the First 1000-Digit Fibonacci Number
Collection initializers
C# 6 Index Initializers
Collection initializers in custom classes
Using collection initializer inside object initializer
Collection Initializers with Parameter Arrays
Foreach Loop
For Loop
Do - While Loop
Looping styles
Nested loops
break
While loop
continue
Iterators
Creating Iterators Using Yield
Simple Numeric Iterator Example
IEnumerable
IEnumerable with custom Enumerator
IEnumerable int
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
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
Built-In Types Table
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
Creating a dynamic object with properties
Creating a dynamic variable
Returning dynamic
Handling Specific Types Unknown at Compile Time
Type Conversion
Explicit Type Conversion
MSDN implicit operator example
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
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
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
public
private
internal
protected
protected internal
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 keyword
Static class lifetime
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 C# and ASP.NET with Unity
Dependency injection using MEF
Partial class and methods
Partial classes
Partial methods
Partial classes inheriting from a base class
Object initializers
Simple usage
Usage with non-default constructors
Usage with anonymous types
Calling a Method
Anonymous method
Parameters and Arguments
Return Types
Default Parameters
Method overloading
Declaring a Method
Access rights
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
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
Optional Arguments
Named Arguments
Data Annotation Basics
Creating a custom validation attribute
Manually Execute Validation Attributes
EditableAttribute data modeling attribute
Validation Attributes
DisplayNameAttribute display attribute
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 in plain English
Fibonacci Sequence
Using Recursion to Get Directory Tree
Recursively describe an object structure
PowerOf calculation
Factorial calculation
Naming Conventions
Capitalization conventions
Enums
Interfaces
Exceptions
Private fields
Namespaces
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
Regions
Documentation comments
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
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 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
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
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
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
Translating a LINQ query to a SQL query
Linq to Objects
Using LINQ to Objects
How LINQ to Object executes 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
Read XML using LINQ to XML
Parallel LINQ PLINQ
Simple example
WithDegreeOfParallelism
AsOrdered
AsUnordered
XmlDocument vs XDocument Example and comparison
Reading from XML document
Basic XML document interaction
Generate an XML document
Modify XML File
Generate an XML document using fluent syntax
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
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
Async Await
Caller Information Attributes
Optional parameters and named arguments
Variance
Dynamic member lookup
Optional ref keyword when using COM
C# 3.0 Features
Implicitly typed variables var
Language Integrated Queries LINQ
Lambda expresions
Anonymous types
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 explained
Converting string to integer
Read Understand Stacktraces
Stack trace for a simple NullReferenceException in Windows Forms
Redirecting log output with TraceListeners
Debug.WriteLine
Integer overflow
Overflow during operation
Ordering matters
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 JsonConverter on simple values
Collect all fields of JSON object
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 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
QueryFilter class
GetExpression Method
GetExpression Private overload
ConstantExpression Method
Usage
Properties
Auto-implemented properties
Public Get
Public Set
Accessing Properties
Default Values for Properties
Various Properties in Context
Read-only 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
Implementing INotifyPropertyChanged in C# 6
INotifyPropertyChanged With Generic Set Method
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
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
Basic Overloading Example
params is not expanded unless necessary.
Passing null as one of the arguments
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
Declaring a struct
Struct usage
Struct implementing interface
Structs are copied on assignment
Creating a custom attribute
Reading an attribute
Using an attribute
DebuggerDisplay Attribute
Caller info attributes
Reading an attribute from interface
Obsolete Attribute
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
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
Basic TCP Communication Client
Download a file from a web server
Async TCP Client
Basic UDP Client
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
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
IsFileReady
Basic FileWatcher
Asynchronous Socket
Asynchronous Socket Client Server example.
Custom Action Filters
Types of Polymorphism
Another Polymorphism Example
Strings and immutability
System.String class
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 as a scope
Using Streams
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
IsHighResolution
Creating an Instance of a Stopwatch
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
ASP.NET Configure Await
Async / Await
BackgroundWorker
Task
Thread
Task run and forget extension
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
Pseudocode for async/await keywords
Disabling synchronization context
Why SynchronizationContext is so important
BackgroundWorker
Using a BackgroundWorker to complete a task.
Assigning Event Handlers to a BackgroundWorker
Creating a new BackgroundWorker instance
Assigning Properties to a BackgroundWorker
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
Controlling access to a variable in a Parallel.For loop
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
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
ActionBlockT
BroadcastBlockT
BufferBlockT
JoinBlockT1 T2
BatchedJoinBlockT1 T2
TransformBlockTInput TOutput
TransformManyBlockTInput TOutput
BatchBlockT
WriteOnceBlockT
Func and Action
Avoid Null References
Higher-Order Functions
Immutability
Immutable collections
Func delegates
Without parameters
With multiple variables
Lambda anonymous methods
Covariant Contravariant Type Parameters
Function with multiple return values
anonymous object dynamic keyword solution
Tuple solution
Ref and Out Parameters
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
Implementing ICloneable in a class
Implementing ICloneable in a struct
Sort versions
Connection Strings
Entity Framework Connections
ADO.NET Connections
Creating simple CRUD using SQLite in C#
Executing Query
MemoryCache
Code Contracts
Postconditions
Invariants
Defining Contracts on Interface
Preconditions
Assertions to check logic should always be true
Structural Design Patterns
Adapter Design Pattern
Creational Design Patterns
Singleton Pattern
Factory Method pattern
Abstract Factory Pattern
Builder Pattern
Prototype Pattern
Implementing Decorator Design Pattern
Simulating cafeteria
Implementing map in RPG game
System.Management.Automation
Invoke simple synchronous pipeline
Pointers
Pointers for array access
Pointer arithmetic
The asterisk is part of the type
void
Member access using →
Generic pointers
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
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
Observing TextChanged event on a TextBox
Streaming Data from Database with Observable
AssemblyInfo.cs Examples
Global and local AssemblyInfo
AssemblyVersion
AssemblyProduct
Automated versioning
Common fields
AssemblyTitle
InternalsVisibleTo
Reading Assembly Attributes
AssemblyConfiguration
AssemblyKeyFile
Creating a Console application using a Plain-Text Editor and the C Compiler
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
Initialize ObservableCollection<T>
Hash Functions
MD5
SHA1
SHA256
SHA384
SHA512
PBKDF2 for Password Hashing
Complete Password Hashing Solution using Pbkdf2
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
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
Using unsafe with arrays
Using unsafe with strings
Unsafe Array Index
Simple code evaluation
RoslynScript
CSharpCodeProvider
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
Semantic model
Syntax tree
Create workspace from MSBuild project
Creating Own MessageBox in Windows Form Application
Creating Own MessageBox Control
How to use own created MessageBox control in another Windows Form application
Instantiate Fontfamily from Resources
Integration method
Usage with a Button
Weak References
Large Object Heap compaction
Windows Communication Foundation
Getting started sample
  ↑ ↓ to navigate     ↵ to select     Esc to close