diff --git "a/ASP.NET/DotNETFrameworkNotesForProfessionals.pdf.txt" "b/ASP.NET/DotNETFrameworkNotesForProfessionals.pdf.txt"
new file mode 100644--- /dev/null
+++ "b/ASP.NET/DotNETFrameworkNotesForProfessionals.pdf.txt"
@@ -0,0 +1,11781 @@
+.NET Framework
+Notes for Professionals
+
+.NET
+Framework
+
+Notes for Professionals
+
+100+ pages
+
+of professional hints and tricks
+
+GoalKicker.com
+Free Programming Books
+
+Disclaimer
+This is an unocial free book created for educational purposes and is
+not aliated with ocial .NET Framework group(s) or company(s).
+All trademarks and registered trademarks are
+the property of their respective owners
+
+Contents
+
+About 
+
+ ................................................................................................................................................................................... 
+
+1
+
+Chapter 1: Getting started with .NET Framework 
+
+ ........................................................................................ 
+
+2
+
+Section 1.1: Hello World in C# 
+Section 1.2: Hello World in F# 
+Section 1.3: Hello World in Visual Basic .NET 
+Section 1.4: Hello World in C++/CLI 
+Section 1.5: Hello World in IL 
+Section 1.6: Hello World in PowerShell 
+Section 1.7: Hello World in Nemerle 
+Section 1.8: Hello World in Python (IronPython) 
+Section 1.9: Hello World in Oxygene 
+Section 1.10: Hello World in Boo 
+
+ ........................................................................................................................................ 
+
+ ....................................................................................................................................... 
+
+ .............................................................................................................. 
+
+ .............................................................................................................................. 
+
+ ......................................................................................................................................... 
+
+ ......................................................................................................................... 
+
+ ............................................................................................................................. 
+
+ ......................................................................................................... 
+
+4
+
+ ............................................................................................................................ 
+
+ ................................................................................................................................... 
+
+Chapter 2: Strings 
+
+ ......................................................................................................................................................... 
+
+5
+
+Section 2.1: Count characters 
+Section 2.2: Count distinct characters 
+Section 2.3: Convert string to/from another encoding 
+Section 2.4: Comparing strings 
+Section 2.5: Count occurrences of a character 
+Section 2.6: Split string into fixed length blocks 
+Section 2.7: Object.ToString() virtual method 
+Section 2.8: Immutability of strings 
+
+ ....................................................................................................................................... 
+
+ ......................................................................................................................... 
+
+ .................................................................................................................................... 
+
+ ............................................................................................. 
+
+5
+
+ .......................................................................................................... 
+
+ ......................................................................................................... 
+
+ ............................................................................................................ 
+
+ ............................................................................................................................. 
+
+Chapter 3: DateTime parsing 
+
+ ................................................................................................................................. 
+
+9
+
+Section 3.1: ParseExact 
+Section 3.2: TryParse 
+Section 3.3: TryParseExact 
+
+ .................................................................................................................................................. 
+
+9
+
+ .................................................................................................................................................. 
+
+10
+
+ ......................................................................................................................................... 
+
+12
+
+Chapter 4: Dictionaries 
+
+ ............................................................................................................................................ 
+
+13
+
+ .............................................................................. 
+
+ ........................................................................................................................... 
+
+Section 4.1: Initializing a Dictionary with a Collection Initializer 
+Section 4.2: Adding to a Dictionary 
+Section 4.3: Getting a value from a dictionary 
+Section 4.4: Make a Dictionary<string, T> with Case-Insensivitve keys 
+Section 4.5: IEnumerable to Dictionary (≥ .NET 3.5) 
+Section 4.6: Enumerating a Dictionary 
+Section 4.7: ConcurrentDictionary<TKey, TValue> (from .NET 4.0) 
+Section 4.8: Dictionary to List 
+Section 4.9: Removing from a Dictionary 
+Section 4.10: ContainsKey(TKey) 
+Section 4.11: ConcurrentDictionary augmented with Lazy'1 reduces duplicated computation 
+
+ ......................................................................................................... 
+
+ ................................................................. 
+
+ ................................................................................................ 
+
+ ................................................................................................................. 
+
+ ............................................................................................................................... 
+
+ ..................................................................................................................................... 
+
+ ...................................................................................................................... 
+
+ ...................................................................... 
+
+ ........................... 
+
+17
+
+Chapter 5: Collections 
+
+ .............................................................................................................................................. 
+
+19
+
+ ........................................................................................................................................................ 
+
+ ...................................................................................................................... 
+
+Section 5.1: Using collection initializers 
+Section 5.2: Stack 
+Section 5.3: Creating an initialized List with Custom Types 
+Section 5.4: Queue 
+
+ ....................................................................................................................................................... 
+
+22
+
+ .................................................................................... 
+
+20
+
+Chapter 6: ReadOnlyCollections 
+
+ ......................................................................................................................... 
+
+24
+
+Section 6.1: Creating a ReadOnlyCollection 
+Section 6.2: Updating a ReadOnlyCollection 
+Section 6.3: Warning: Elements in a ReadOnlyCollection are not inherently read-only 
+
+ .............................................................................................................. 
+
+ ........................................................................................................... 
+
+ ...................................... 
+
+24
+
+2
+
+3
+
+3
+
+3
+
+3
+
+4
+
+4
+
+4
+
+4
+
+5
+
+5
+
+6
+
+6
+
+6
+
+7
+
+8
+
+13
+
+13
+
+13
+
+14
+
+14
+
+14
+
+15
+
+16
+
+16
+
+17
+
+19
+
+19
+
+24
+
+24
+
+Chapter 7: Stack and Heap 
+Section 7.1: Value types in use 
+Section 7.2: Reference types in use 
+
+ ................................................................................................................................... 
+
+ ................................................................................................................................... 
+
+ ........................................................................................................................... 
+
+26
+
+Chapter 8: LINQ 
+
+ ........................................................................................................................................................... 
+
+28
+
+Section 8.1: SelectMany (flat map) 
+Section 8.2: Where (filter) 
+Section 8.3: Any 
+Section 8.4: GroupJoin 
+Section 8.5: Except 
+Section 8.6: Zip 
+Section 8.7: Aggregate (fold) 
+Section 8.8: ToLookup 
+Section 8.9: Intersect 
+Section 8.10: Concat 
+Section 8.11: All 
+Section 8.12: Sum 
+Section 8.13: SequenceEqual 
+Section 8.14: Min 
+Section 8.15: Distinct 
+Section 8.16: Count 
+Section 8.17: Cast 
+Section 8.18: Range 
+Section 8.19: ThenBy 
+Section 8.20: Repeat 
+Section 8.21: Empty 
+Section 8.22: Select (map) 
+Section 8.23: OrderBy 
+Section 8.24: OrderByDescending 
+Section 8.25: Contains 
+Section 8.26: First (find) 
+Section 8.27: Single 
+Section 8.28: Last 
+Section 8.29: LastOrDefault 
+Section 8.30: SingleOrDefault 
+Section 8.31: FirstOrDefault 
+Section 8.32: Skip 
+Section 8.33: Take 
+Section 8.34: Reverse 
+Section 8.35: OfType 
+Section 8.36: Max 
+Section 8.37: Average 
+Section 8.38: GroupBy 
+Section 8.39: ToDictionary 
+Section 8.40: Union 
+Section 8.41: ToArray 
+Section 8.42: ToList 
+Section 8.43: ElementAt 
+Section 8.44: ElementAtOrDefault 
+Section 8.45: SkipWhile 
+Section 8.46: TakeWhile 
+
+ ............................................................................................................................ 
+
+28
+
+ ........................................................................................................................................... 
+
+ ........................................................................................................................................................... 
+
+ ................................................................................................................................................ 
+
+ ...................................................................................................................................................... 
+
+ ............................................................................................................................................................ 
+
+ ..................................................................................................................................... 
+
+ ................................................................................................................................................ 
+
+ ................................................................................................................................................... 
+
+ .................................................................................................................................................... 
+
+ ............................................................................................................................................................. 
+
+ ......................................................................................................................................................... 
+
+ ...................................................................................................................................... 
+
+ ........................................................................................................................................................... 
+
+ .................................................................................................................................................... 
+
+ ...................................................................................................................................................... 
+
+ ......................................................................................................................................................... 
+
+ ..................................................................................................................................................... 
+
+ ................................................................................................................................................... 
+
+ ................................................................................................................................................... 
+
+ ..................................................................................................................................................... 
+
+ .......................................................................................................................................... 
+
+ ................................................................................................................................................. 
+
+ ............................................................................................................................. 
+
+ ................................................................................................................................................. 
+
+ .............................................................................................................................................. 
+
+ ..................................................................................................................................................... 
+
+ ........................................................................................................................................................ 
+
+ ....................................................................................................................................... 
+
+ .................................................................................................................................... 
+
+ ........................................................................................................................................ 
+
+ ......................................................................................................................................................... 
+
+ ....................................................................................................................................................... 
+
+ .................................................................................................................................................. 
+
+ ................................................................................................................................................... 
+
+ ......................................................................................................................................................... 
+
+ ................................................................................................................................................. 
+
+ ................................................................................................................................................. 
+
+ .......................................................................................................................................... 
+
+ ...................................................................................................................................................... 
+
+ .................................................................................................................................................. 
+
+ ..................................................................................................................................................... 
+
+ .............................................................................................................................................. 
+
+ ............................................................................................................................. 
+
+ ............................................................................................................................................... 
+
+ .............................................................................................................................................. 
+
+26
+
+26
+
+29
+
+29
+
+30
+
+31
+
+31
+
+31
+
+32
+
+32
+
+32
+
+32
+
+33
+
+33
+
+33
+
+34
+
+34
+
+34
+
+34
+
+35
+
+35
+
+35
+
+35
+
+36
+
+36
+
+36
+
+36
+
+37
+
+37
+
+37
+
+38
+
+38
+
+38
+
+39
+
+39
+
+39
+
+39
+
+39
+
+40
+
+40
+
+41
+
+42
+
+42
+
+42
+
+42
+
+42
+
+43
+
+Section 8.47: DefaultIfEmpty 
+Section 8.48: Join 
+Section 8.49: Left Outer Join 
+
+ ...................................................................................................................................... 
+
+43
+
+ ........................................................................................................................................................ 
+
+43
+
+ ...................................................................................................................................... 
+
+44
+
+Chapter 9: ForEach 
+
+ .................................................................................................................................................... 
+
+46
+
+Section 9.1: Extension method for IEnumerable 
+Section 9.2: Calling a method on an object in a list 
+
+ ....................................................................................................... 
+
+46
+
+ ................................................................................................. 
+
+46
+
+Chapter 10: Reflection 
+
+ .............................................................................................................................................. 
+
+47
+
+ ........................................................................................................................... 
+
+Section 10.1: What is an Assembly? 
+Section 10.2: Compare two objects with reflection 
+Section 10.3: Creating Object and setting properties using reflection 
+Section 10.4: How to create an object of T using Reflection 
+Section 10.5: Getting an attribute of an enum with reflection (and caching it) 
+
+ ................................................................... 
+
+ .................................................................................. 
+
+ .................................................... 
+
+48
+
+ .................................................................................................. 
+
+Chapter 11: Expression Trees 
+
+ ................................................................................................................................. 
+
+50
+
+Section 11.1: building a predicate of form field == value 
+Section 11.2: Simple Expression Tree Generated by the C# Compiler 
+Section 11.3: Expression for retrieving a static field 
+Section 11.4: InvocationExpression Class 
+
+ .......................................................................................... 
+
+50
+
+ .................................................................... 
+
+50
+
+ .................................................................................................. 
+
+ ................................................................................................................... 
+
+Chapter 12: Custom Types 
+Section 12.1: Struct Definition 
+Section 12.2: Class Definition 
+Chapter 13: Code Contracts 
+
+ ...................................................................................................................................... 
+
+ ...................................................................................................................................... 
+
+ ...................................................................................................................................... 
+
+Section 13.1: Contracts for Interfaces 
+Section 13.2: Installing and Enabling Code Contracts 
+Section 13.3: Preconditions 
+Section 13.4: Postconditions 
+
+ ................................................................................................................................... 
+
+56
+
+ ........................................................................................................................ 
+
+56
+
+ .............................................................................................. 
+
+56
+
+ ......................................................................................................................................... 
+
+ ........................................................................................................................................ 
+
+Chapter 14: Settings 
+
+ .................................................................................................................................................. 
+
+60
+
+Section 14.1: AppSettings from ConfigurationSettings in .NET 1.x 
+Section 14.2: Reading AppSettings from ConfigurationManager in .NET 2.0 and later 
+Section 14.3: Introduction to strongly-typed application and user settings support from Visual Studio
+
+ ........................................................................... 
+
+ ....................................... 
+
+60
+
+60
+
+ ................................................................................................................................................................................ 
+
+61
+
+Section 14.4: Reading strongly-typed settings from custom section of configuration file 
+
+ ................................. 
+
+62
+
+Chapter 15: Regular Expressions (System.Text.RegularExpressions) 
+
+ .............................................. 
+
+65
+
+ ............................................................................................................ 
+
+65
+
+Section 15.1: Check if pattern matches input 
+Section 15.2: Remove non alphanumeric characters from string 
+Section 15.3: Passing Options 
+Section 15.4: Match into groups 
+Section 15.5: Find all matches 
+Section 15.6: Simple match and replace 
+
+ ..................................................................................................................................... 
+
+ ................................................................................................................................. 
+
+ .................................................................................................................................... 
+
+ ................................................................................................................... 
+
+ .......................................................................... 
+
+65
+
+Chapter 16: File Input/Output 
+Section 16.1: C# File.Exists() 
+Section 16.2: VB WriteAllText 
+Section 16.3: VB StreamWriter 
+Section 16.4: C# StreamWriter 
+Section 16.5: C# WriteAllText() 
+
+ ............................................................................................................................... 
+
+67
+
+ ......................................................................................................................................... 
+
+ ...................................................................................................................................... 
+
+ .................................................................................................................................... 
+
+ ................................................................................................................................... 
+
+ ................................................................................................................................... 
+
+Chapter 17: System.IO 
+
+ .............................................................................................................................................. 
+
+69
+
+Section 17.1: Reading a text file using StreamReader 
+Section 17.2: Serial Ports using System.IO.SerialPorts 
+Section 17.3: Reading/Writing Data Using System.IO.File 
+
+ .............................................................................................. 
+
+ ............................................................................................. 
+
+ ....................................................................................... 
+
+70
+
+Chapter 18: System.IO.File class 
+
+ .......................................................................................................................... 
+
+72
+
+47
+
+47
+
+48
+
+48
+
+51
+
+51
+
+54
+
+54
+
+54
+
+58
+
+59
+
+65
+
+65
+
+65
+
+66
+
+67
+
+67
+
+67
+
+67
+
+68
+
+69
+
+69
+
+Section 18.1: Delete a file 
+Section 18.2: Strip unwanted lines from a text file 
+Section 18.3: Convert text file encoding 
+Section 18.4: Enumerate files older than a specified amount 
+Section 18.5: Move a File from one location to another 
+
+ ............................................................................................................................................. 
+
+ ................................................................................................... 
+
+ .................................................................................................................... 
+
+72
+
+73
+
+73
+
+ ................................................................................. 
+
+74
+
+ .......................................................................................... 
+
+74
+
+Chapter 19: Reading and writing Zip files 
+
+ ...................................................................................................... 
+
+76
+
+Section 19.1: Listing ZIP contents 
+Section 19.2: Extracting files from ZIP files 
+Section 19.3: Updating a ZIP file 
+
+ ................................................................................................................................ 
+
+76
+
+ ............................................................................................................... 
+
+76
+
+ ................................................................................................................................. 
+
+76
+
+Chapter 20: Managed Extensibility Framework 
+
+ .......................................................................................... 
+
+78
+
+Section 20.1: Connecting (Basic) 
+Section 20.2: Exporting a Type (Basic) 
+Section 20.3: Importing (Basic) 
+
+ ................................................................................................................................ 
+
+78
+
+ ..................................................................................................................... 
+
+78
+
+ .................................................................................................................................. 
+
+79
+
+Chapter 21: SpeechRecognitionEngine class to recognize speech 
+
+ .................................................... 
+
+80
+
+Section 21.1: Asynchronously recognizing speech based on a restricted set of phrases 
+Section 21.2: Asynchronously recognizing speech for free text dictation 
+
+ ............................................................. 
+
+80
+
+ .................................... 
+
+80
+
+Chapter 22: System.Runtime.Caching.MemoryCache (ObjectCache) 
+
+ .............................................. 
+
+81
+
+Section 22.1: Adding Item to Cache (Set) 
+Section 22.2: System.Runtime.Caching.MemoryCache (ObjectCache) 
+
+ .................................................................................................................. 
+
+81
+
+ ................................................................. 
+
+81
+
+Chapter 23: System.Reflection.Emit namespace 
+
+ ....................................................................................... 
+
+83
+
+Section 23.1: Creating an assembly dynamically 
+
+ ..................................................................................................... 
+
+83
+
+Chapter 24: .NET Core 
+
+ ............................................................................................................................................. 
+
+86
+
+Section 24.1: Basic Console App 
+
+ ................................................................................................................................. 
+
+86
+
+Chapter 25: ADO.NET 
+
+ ................................................................................................................................................ 
+
+87
+
+Section 25.1: Best Practices - Executing Sql Statements 
+Section 25.2: Executing SQL statements as a command 
+Section 25.3: Using common interfaces to abstract away vendor specific classes 
+
+ ......................................................................................... 
+
+ ....................................................................................... 
+
+ ............................................ 
+
+89
+
+Chapter 26: Dependency Injection 
+
+ ..................................................................................................................... 
+
+90
+
+Section 26.1: How Dependency Injection Makes Unit Testing Easier 
+Section 26.2: Dependency Injection - Simple example 
+Section 26.3: Why We Use Dependency Injection Containers (IoC Containers) 
+
+ ..................................................................... 
+
+ ........................................................................................... 
+
+ .................................................. 
+
+91
+
+Chapter 27: Platform Invoke 
+Section 27.1: Marshaling structs 
+Section 27.2: Marshaling unions 
+Section 27.3: Calling a Win32 dll function 
+Section 27.4: Using Windows API 
+Section 27.5: Marshalling arrays 
+
+ ................................................................................................................................ 
+
+ ................................................................................................................................. 
+
+ ................................................................................................................................ 
+
+ ................................................................................................................. 
+
+96
+
+ ............................................................................................................................... 
+
+ ................................................................................................................................ 
+
+Chapter 28: NuGet packaging system 
+
+ ............................................................................................................. 
+
+98
+
+Section 28.1: Uninstalling a package from one project in a solution 
+Section 28.2: Installing a specific version of a package 
+Section 28.3: Adding a package source feed (MyGet, Klondike, ect) 
+Section 28.4: Installing the NuGet Package Manager 
+Section 28.5: Managing Packages through the UI 
+Section 28.6: Managing Packages through the console 
+Section 28.7: Updating a package 
+Section 28.8: Uninstalling a package 
+Section 28.9: Uninstall a specific version of package 
+
+ ..................................................................... 
+
+ ......................................................................................... 
+
+ .................................................................... 
+
+98
+
+ ............................................................................................. 
+
+ .................................................................................................. 
+
+ ......................................................................................... 
+
+ ............................................................................................................................ 
+
+ ...................................................................................................................... 
+
+ ........................................................................................... 
+
+87
+
+88
+
+90
+
+90
+
+94
+
+94
+
+95
+
+97
+
+97
+
+98
+
+98
+
+98
+
+99
+
+99
+
+99
+
+100
+
+100
+
+Chapter 29: Globalization in ASP.NET MVC using Smart internationalization for ASP.NET
+ ............................................................................................................................................................................................ 
+
+101
+
+Section 29.1: Basic configuration and setup 
+
+ ........................................................................................................... 
+
+101
+
+Chapter 30: System.Net.Mail 
+Section 30.1: MailMessage 
+Section 30.2: Mail with Attachment 
+
+ .............................................................................................................................. 
+
+ ........................................................................................................................................ 
+
+ ......................................................................................................................... 
+
+104
+
+Chapter 31: Using Progress<T> and IProgress<T> 
+
+ ................................................................................... 
+
+105
+
+Section 31.1: Simple Progress reporting 
+Section 31.2: Using IProgress<T> 
+Chapter 32: JSON Serialization 
+
+ .................................................................................................................. 
+
+105
+
+ ............................................................................................................................. 
+
+ ......................................................................................................................... 
+
+Section 32.1: Deserialization using System.Web.Script.Serialization.JavaScriptSerializer 
+Section 32.2: Serialization using Json.NET 
+Section 32.3: Serialization-Deserialization using Newtonsoft.Json 
+Section 32.4: Deserialization using Json.NET 
+Section 32.5: Dynamic binding 
+Section 32.6: Serialization using Json.NET with JsonSerializerSettings 
+
+ ......................................................................................................... 
+
+ ...................................................................... 
+
+ ................................................................................................................................ 
+
+ ............................................................................................................. 
+
+ .............................................................. 
+
+ ................................. 
+
+107
+
+Chapter 33: JSON in .NET with Newtonsoft.Json 
+Section 33.1: Deserialize an object from JSON text 
+Section 33.2: Serialize object into JSON 
+
+ ............................................................................................... 
+
+ ................................................................................................................. 
+
+ ..................................................................................... 
+
+110
+
+Chapter 34: XmlSerializer 
+
+ .................................................................................................................................... 
+
+111
+
+ .................................................................................................................................... 
+
+Section 34.1: Formatting: Custom DateTime format 
+Section 34.2: Serialize object 
+Section 34.3: Deserialize object 
+Section 34.4: Behaviour: Map array name to property (XmlArray) 
+Section 34.5: Behaviour: Map Element name to Property 
+Section 34.6: Eciently building multiple serializers with derived types specified dynamically 
+
+ .................................................................... 
+
+ .................................................................................... 
+
+ ............................................................................................................................... 
+
+ ............................................................................................. 
+
+ ...................... 
+
+112
+
+Chapter 35: VB Forms 
+
+ ............................................................................................................................................ 
+
+115
+
+Section 35.1: Hello World in VB.NET Forms 
+Section 35.2: For Beginners 
+Section 35.3: Forms Timer 
+Chapter 36: JIT compiler 
+
+ ...................................................................................................................................... 
+
+ ........................................................................................................................................ 
+
+ ....................................................................................................................................... 
+
+ ............................................................................................................. 
+
+115
+
+Section 36.1: IL compilation sample 
+
+ ......................................................................................................................... 
+
+118
+
+Chapter 37: CLR 
+
+ ......................................................................................................................................................... 
+
+121
+
+Section 37.1: An introduction to Common Language Runtime 
+
+ ............................................................................. 
+
+121
+
+Chapter 38: TPL Dataflow 
+
+ .................................................................................................................................... 
+
+122
+
+Section 38.1: Asynchronous Producer Consumer With A Bounded BuerBlock 
+Section 38.2: Posting to an ActionBlock and waiting for completion 
+Section 38.3: Linking blocks to create a pipeline 
+Section 38.4: Synchronous Producer/Consumer with BuerBlock<T> 
+
+ ................................................................................................... 
+
+ ............................................................... 
+
+ ................................................ 
+
+122
+
+ .................................................................. 
+
+Chapter 39: Threading 
+
+ ........................................................................................................................................... 
+
+125
+
+Section 39.1: Accessing form controls from other threads 
+Chapter 40: Process and Thread anity setting 
+
+ ................................................................................... 
+
+125
+
+ .................................................................................... 
+
+Section 40.1: Get process anity mask 
+Section 40.2: Set process anity mask 
+
+ .................................................................................................................. 
+
+ .................................................................................................................. 
+
+127
+
+Chapter 41: Parallel processing using .Net framework 
+
+ ........................................................................ 
+
+129
+
+Section 41.1: Parallel Extensions 
+
+ ............................................................................................................................... 
+
+129
+
+Chapter 42: Task Parallel Library (TPL) 
+
+ ....................................................................................................... 
+
+130
+
+Section 42.1: Basic producer-consumer loop (BlockingCollection) 
+Section 42.2: Parallel.Invoke 
+Section 42.3: Task: Returning a value 
+
+ ..................................................................................................................................... 
+
+ ..................................................................................................................... 
+
+ ...................................................................... 
+
+130
+
+103
+
+103
+
+105
+
+107
+
+107
+
+108
+
+108
+
+108
+
+109
+
+110
+
+110
+
+111
+
+111
+
+111
+
+111
+
+112
+
+115
+
+115
+
+118
+
+122
+
+122
+
+123
+
+127
+
+127
+
+130
+
+131
+
+ .................................................................................................................................. 
+
+ .......................................................................................................................................... 
+
+ ....................................................................................................................................... 
+
+ .................................................................................................... 
+
+ .................................................................................... 
+
+ ................................................................................................................ 
+
+ .............................................................................................. 
+
+ .................................................................................................................................... 
+
+Section 42.4: Parallel.ForEach 
+Section 42.5: Parallel.For 
+Section 42.6: Task: basic instantiation and Wait 
+Section 42.7: Task.WhenAll 
+Section 42.8: Flowing execution context with AsyncLocal 
+Section 42.9: Parallel.ForEach in VB.NET 
+Section 42.10: Task: WaitAll and variable capturing 
+Section 42.11: Task: WaitAny 
+Section 42.12: Task: handling exceptions (using Wait) 
+Section 42.13: Task: handling exceptions (without using Wait) 
+Section 42.14: Task: cancelling using CancellationToken 
+Section 42.15: Task.WhenAny 
+
+ .......................................................................................... 
+
+ ............................................................................ 
+
+134
+
+ ..................................................................................... 
+
+ ................................................................................................................................... 
+
+Chapter 43: Task Parallel Library (TPL) API Overviews 
+
+ ....................................................................... 
+
+137
+
+Section 43.1: Perform work in response to a button click and update the UI 
+
+ ..................................................... 
+
+137
+
+Chapter 44: Synchronization Contexts 
+
+ ......................................................................................................... 
+
+138
+
+Section 44.1: Execute code on the UI thread after performing background work 
+
+ ............................................. 
+
+138
+
+Chapter 45: Memory management 
+
+ ................................................................................................................ 
+
+139
+
+Section 45.1: Use SafeHandle when wrapping unmanaged resources 
+Section 45.2: Unmanaged Resources 
+Chapter 46: Garbage Collection 
+
+ ..................................................................................................................... 
+
+ ....................................................................................................................... 
+
+ ............................................................... 
+
+139
+
+Section 46.1: A basic example of (garbage) collection 
+Section 46.2: Live objects and dead objects - the basics 
+Section 46.3: Multiple dead objects 
+Section 46.4: Weak References 
+Section 46.5: Dispose() vs. finalizers 
+Section 46.6: Proper disposal and finalization of objects 
+
+ ......................................................................................................................... 
+
+ ............................................................................................................................... 
+
+ ....................................................................................................................... 
+
+ ..................................................................................... 
+
+144
+
+ ......................................................................................... 
+
+ ..................................................................................... 
+
+141
+
+Chapter 47: Exceptions 
+
+ ......................................................................................................................................... 
+
+146
+
+ ................................................................................... 
+
+ ........................................................................................................................... 
+
+ .................................................................................................................................. 
+
+Section 47.1: Catching and rethrowing caught exceptions 
+Section 47.2: Using a finally block 
+Section 47.3: Exception Filters 
+Section 47.4: Rethrowing an exception within a catch block 
+Section 47.5: Throwing an exception from a dierent method while preserving its information 
+Section 47.6: Catching an exception 
+Chapter 48: System.Diagnostics 
+Section 48.1: Run shell commands 
+Section 48.2: Send Command to CMD and Receive Output 
+Section 48.3: Stopwatch 
+
+ ........................................................................................................................................... 
+
+ .......................................................................................................................... 
+
+ ....................................................................................................................... 
+
+ ...................................................................................................................... 
+
+ ................................................................................. 
+
+ ................................................................................ 
+
+ .................... 
+
+148
+
+Chapter 49: Encryption / Cryptography 
+
+ ..................................................................................................... 
+
+153
+
+Section 49.1: Encryption and Decryption using Cryptography (AES) 
+Section 49.2: RijndaelManaged 
+Section 49.3: Encrypt and decrypt data using AES (in C#) 
+Section 49.4: Create a Key from a Password / Random SALT (in C#) 
+
+ ............................................................................................................................... 
+
+ .................................................................. 
+
+ .................................................................................. 
+
+ ............................................................... 
+
+158
+
+Chapter 50: Work with SHA1 in C# 
+
+ ................................................................................................................... 
+
+161
+
+Section 50.1: #Generate SHA1 checksum of a file 
+Section 50.2: #Generate hash of a text 
+
+ .................................................................................................. 
+
+161
+
+ .................................................................................................................. 
+
+161
+
+Chapter 51: Unit testing 
+
+ ......................................................................................................................................... 
+
+162
+
+Section 51.1: Adding MSTest unit testing project to an existing solution 
+Section 51.2: Creating a sample test method 
+
+ ......................................................................................................... 
+
+162
+
+ ............................................................. 
+
+162
+
+Chapter 52: Write to and read from StdErr stream 
+
+ ............................................................................... 
+
+163
+
+131
+
+131
+
+132
+
+132
+
+132
+
+133
+
+133
+
+134
+
+134
+
+135
+
+136
+
+139
+
+141
+
+141
+
+142
+
+142
+
+143
+
+146
+
+147
+
+147
+
+148
+
+149
+
+150
+
+150
+
+150
+
+152
+
+153
+
+154
+
+155
+
+Section 52.1: Write to standard error output using Console 
+Section 52.2: Read from standard error of child process 
+Chapter 53: Upload file and POST data to webserver 
+
+ ................................................................................. 
+
+ .................................................................................... 
+
+163
+
+163
+
+ .......................................................................... 
+
+164
+
+Section 53.1: Upload file with WebRequest 
+
+ ............................................................................................................. 
+
+164
+
+Chapter 54: Networking 
+
+ ....................................................................................................................................... 
+
+166
+
+Section 54.1: Basic TCP chat (TcpListener, TcpClient, NetworkStream) 
+Section 54.2: Basic SNTP client (UdpClient) 
+
+ ........................................................................................................... 
+
+167
+
+ .............................................................. 
+
+166
+
+Chapter 55: HTTP servers 
+
+ .................................................................................................................................... 
+
+169
+
+Section 55.1: Basic read-only HTTP file server (ASP.NET Core) 
+Section 55.2: Basic read-only HTTP file server (HttpListener) 
+
+ ........................................................................... 
+
+169
+
+ ............................................................................. 
+
+170
+
+Chapter 56: HTTP clients 
+
+ ...................................................................................................................................... 
+
+173
+
+Section 56.1: Reading GET response as string using System.Net.HttpClient 
+Section 56.2: Basic HTTP downloader using System.Net.Http.HttpClient 
+Section 56.3: Reading GET response as string using System.Net.HttpWebRequest 
+Section 56.4: Reading GET response as string using System.Net.WebClient 
+Section 56.5: Sending a POST request with a string payload using System.Net.HttpWebRequest 
+Section 56.6: Sending a POST request with a string payload using System.Net.WebClient 
+Section 56.7: Sending a POST request with a string payload using System.Net.HttpClient 
+
+ ....................................................... 
+
+ ........................................................... 
+
+ ......................................... 
+
+ ..................................................... 
+
+ ............................. 
+
+ .............................. 
+
+ ................. 
+
+174
+
+Chapter 57: Serial Ports 
+
+ ........................................................................................................................................ 
+
+176
+
+Section 57.1: Basic operation 
+Section 57.2: List available port names 
+Section 57.3: Asynchronous read 
+Section 57.4: Synchronous text echo service 
+Section 57.5: Asynchronous message receiver 
+
+ .................................................................................................................................... 
+
+ .................................................................................................................. 
+
+ ............................................................................................................................ 
+
+ ......................................................................................................... 
+
+ ...................................................................................................... 
+
+177
+
+Appendix A: Acronym Glossary 
+Section A.1: .Net Related Acronyms 
+
+ ......................................................................................................................... 
+
+180
+
+ ........................................................................................................................ 
+
+180
+
+Credits 
+
+ ............................................................................................................................................................................ 
+
+181
+
+You may also like 
+
+ ...................................................................................................................................................... 
+
+184
+
+173
+
+173
+
+174
+
+174
+
+175
+
+175
+
+176
+
+176
+
+176
+
+176
+
+About
+
+Please feel free to share this PDF with anyone for free,
+
+latest version of this book can be downloaded from:
+
+https://goalkicker.com/DotNETFrameworkBook
+
+This .NET Framework Notes for Professionals book is compiled from Stack Overflow
+
+Documentation, the content is written by the beautiful people at Stack Overflow.
+
+Text content is released under Creative Commons BY-SA, see credits at the end
+
+of this book whom contributed to the various chapters. Images may be copyright
+
+of their respective owners unless otherwise specified
+
+This is an unofficial free book created for educational purposes and is not
+
+affiliated with official .NET Framework group(s) or company(s) nor Stack
+
+Overflow. All trademarks and registered trademarks are the property of their
+
+respective company owners
+
+The information presented in this book is not guaranteed to be correct nor
+
+accurate, use at your own risk
+
+Please send feedback and corrections to web@petercv.com
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+1
+
+Chapter 1: Getting started with .NET
+Framework
+
+.NET
+Version Release Date
+1.0
+
+2002-02-13
+
+1.1
+
+2.0
+
+3.0
+
+3.5
+
+2003-04-24
+
+2005-11-07
+
+2006-11-06
+
+2007-11-19
+
+3.5 SP1 2008-08-11
+
+4.0
+
+4.5
+
+4.5.1
+
+4.5.2
+
+4.6
+
+4.6.1
+
+4.6.2
+
+4.7
+
+2010-04-12
+
+2012-08-15
+
+2013-10-17
+
+2014-05-05
+
+2015-07-20
+
+2015-11-17
+
+2016-08-02
+
+2017-04-05
+
+4.7.1
+
+2017-10-17
+
+Compact Framework
+Version Release Date
+1.0
+
+2000-01-01
+
+2.0
+
+3.5
+
+3.7
+
+3.9
+
+2005-10-01
+
+2007-11-19
+
+2009-01-01
+
+2013-06-01
+
+Micro Framework
+Version Release Date
+4.2
+
+2011-10-04
+
+4.3
+
+4.4
+
+2012-12-04
+
+2015-10-20
+
+Section 1.1: Hello World in C#
+
+using System;
+
+class Program
+{
+    // The Main() function is the first function to be executed in a program
+    static void Main()
+    {
+        // Write the string "Hello World to the standard out
+        Console.WriteLine("Hello World");
+    }
+}
+
+Console.WriteLine has several overloads. In this case, the string "Hello World" is the parameter, and it will output
+
+the "Hello World" to the standard out stream during execution. Other overloads may call the .ToString of the
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+2
+
+argument before writing to the stream. See the .NET Framework Documentation for more information.
+
+Live Demo in Action at .NET Fiddle
+
+Introduction to C#
+
+Section 1.2: Hello World in F#
+
+open System
+
+[<EntryPoint>]
+let main argv =
+    printfn "Hello World"
+    0
+
+Live Demo in Action at .NET Fiddle
+
+Introduction to F#
+
+Section 1.3: Hello World in Visual Basic .NET
+
+Imports System
+
+Module Program
+    Public Sub Main()
+        Console.WriteLine("Hello World")
+    End Sub
+End Module
+
+Live Demo in Action at .NET Fiddle
+
+Introduction to Visual Basic .NET
+
+Section 1.4: Hello World in C++/CLI
+
+using namespace System;
+
+int main(array<String^>^ args)
+{
+    Console::WriteLine("Hello World");
+}
+
+Section 1.5: Hello World in IL
+
+.class public auto ansi beforefieldinit Program
+       extends [mscorlib]System.Object
+{
+  .method public hidebysig static void  Main() cil managed
+  {
+    .maxstack  8
+    IL_0000:  nop
+    IL_0001:  ldstr      "Hello World"
+    IL_0006:  call       void [mscorlib]System.Console::WriteLine(string)
+    IL_000b:  nop
+    IL_000c:  ret
+  }
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+3
+
+  .method public hidebysig specialname rtspecialname
+          instance void  .ctor() cil managed
+  {
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       instance void [mscorlib]System.Object::.ctor()
+    IL_0006:  ret
+  }
+
+}
+
+Section 1.6: Hello World in PowerShell
+
+Write-Host "Hello World"
+
+Introduction to PowerShell
+
+Section 1.7: Hello World in Nemerle
+
+System.Console.WriteLine("Hello World");
+
+Section 1.8: Hello World in Python (IronPython)
+
+print "Hello World"
+
+import clr
+from System import Console
+Console.WriteLine("Hello World")
+
+Section 1.9: Hello World in Oxygene
+
+namespace HelloWorld;
+
+interface
+
+type
+  App = class
+  public
+    class method Main(args: array of String);
+  end;
+
+implementation
+
+class method App.Main(args: array of String);
+begin
+  Console.WriteLine('Hello World');
+end;
+
+end.
+
+Section 1.10: Hello World in Boo
+
+print "Hello World"
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+4
+
+Chapter 2: Strings
+
+Section 2.1: Count characters
+
+If you need to count characters then, for the reasons explained in Remarks section, you can't simply use Length
+
+property because it's the length of the array of System.Char which are not characters but code-units (not Unicode
+
+code-points nor graphemes). Correct code is then:
+
+int length = text.EnumerateCharacters().Count();
+
+A small optimization may rewrite EnumerateCharacters() extension method specifically for this purpose:
+
+public static class StringExtensions
+{
+    public static int CountCharacters(this string text)
+    {
+        if (String.IsNullOrEmpty(text))
+            return 0;
+
+        int count = 0;
+        var enumerator = StringInfo.GetTextElementEnumerator(text);
+        while (enumerator.MoveNext())
+            ++count;
+
+        return count;
+    }
+}
+
+Section 2.2: Count distinct characters
+
+If you need to count distinct characters then, for the reasons explained in Remarks section, you can't simply use
+
+Length property because it's the length of the array of System.Char which are not characters but code-units (not
+
+Unicode code-points nor graphemes). If, for example, you simply write text.Distinct().Count() you will get
+
+incorrect results, correct code:
+
+int distinctCharactersCount = text.EnumerateCharacters().Count();
+
+One step further is to count occurrences of each character, if performance aren't an issue you may simply do it
+like this (in this example regardless of case):
+
+var frequencies = text.EnumerateCharacters()
+    .GroupBy(x => x, StringComparer.CurrentCultureIgnoreCase)
+    .Select(x => new { Character = x.Key, Count = x.Count() };
+
+Section 2.3: Convert string to/from another encoding
+
+.NET strings contain System.Char (UTF-16 code-units). If you want to save (or manage) text with another encoding
+
+you have to work with an array of System.Byte.
+
+Conversions are performed by classes derived from System.Text.Encoder and System.Text.Decoder which,
+together, can convert to/from another encoding (from a byte X encoded array byte[] to an UTF-16 encoded
+
+System.String and vice-versa).
+
+Because the encoder/decoder usually works very close to each other they're grouped together in a class derived
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+5
+
+from System.Text.Encoding, derived classes offer conversions to/from popular encodings (UTF-8, UTF-16 and so
+
+on).
+
+Examples:
+
+Convert a string to UTF-8
+
+byte[] data = Encoding.UTF8.GetBytes("This is my text");
+
+Convert UTF-8 data to a string
+
+var text = Encoding.UTF8.GetString(data);
+
+Change encoding of an existing text file
+
+This code will read content of an UTF-8 encoded text file and save it back encoded as UTF-16. Note that this code is
+
+not optimal if file is big because it will read all its content into memory:
+
+var content = File.ReadAllText(path, Encoding.UTF8);
+File.WriteAllText(content, Encoding.UTF16);
+
+Section 2.4: Comparing strings
+
+Despite String is a reference type == operator compares string values rather than references.
+
+As you may know string is just an array of characters. But if you think that strings equality check and comparison
+
+is made character by character, you are mistaken. This operation is culture specific (see Remarks below): some
+
+character sequences can be treated as equal depending on the culture.
+
+Think twice before short circuiting equality check by comparing Length properties of two strings!
+
+Use overloads of String.Equals method which accept additional StringComparison enumeration value, if you
+
+need to change default behavior.
+
+Section 2.5: Count occurrences of a character
+
+Because of the reasons explained in Remarks section you can't simply do this (unless you want to count occurrences
+
+of a specific code-unit):
+
+int count = text.Count(x => x == ch);
+
+You need a more complex function:
+
+public static int CountOccurrencesOf(this string text, string character)
+{
+    return text.EnumerateCharacters()
+        .Count(x => String.Equals(x, character, StringComparer.CurrentCulture));
+}
+
+Note that string comparison (in contrast to character comparison which is culture invariant) must always be
+
+performed according to rules to a specific culture.
+
+Section 2.6: Split string into fixed length blocks
+
+We cannot break a string into arbitrary points (because a System.Char may not be valid alone because it's a
+combining character or part of a surrogate) then code must take that into account (note that with length I mean the
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+6
+
+number of graphemes not the number of code-units):
+
+public static IEnumerable<string> Split(this string value, int desiredLength)
+{
+    var characters = StringInfo.GetTextElementEnumerator(value);
+    while (characters.MoveNext())
+        yield return String.Concat(Take(characters, desiredLength));
+}
+
+private static IEnumerable<string> Take(TextElementEnumerator enumerator, int count)
+{
+    for (int i = 0; i < count; ++i)
+    {
+        yield return (string)enumerator.Current;
+
+        if (!enumerator.MoveNext())
+            yield break;
+    }
+}
+
+Section 2.7: Object.ToString() virtual method
+
+Everything in .NET is an object, hence every type has ToString() method defined in Object class which can be
+
+overridden. Default implementation of this method just returns the name of the type:
+
+public class Foo
+{
+}
+
+var foo = new Foo();
+Console.WriteLine(foo); // outputs Foo
+
+ToString() is implicitly called when concatinating value with a string:
+
+public class Foo
+{
+    public override string ToString()
+    {
+        return "I am Foo";
+    }
+}
+
+var foo = new Foo();
+Console.WriteLine("I am bar and "+foo);// outputs I am bar and I am Foo
+
+The result of this method is also extensively used by debugging tools. If, for some reason, you do not want to
+
+override this method, but want to customize how debugger shows the value of your type, use DebuggerDisplay
+
+Attribute (MSDN):
+
+// [DebuggerDisplay("Person = FN {FirstName}, LN {LastName}")]
+[DebuggerDisplay("Person = FN {"+nameof(Person.FirstName)+"}, LN {"+nameof(Person.LastName)+"}")]
+public class Person
+{
+    public string FirstName { get; set; }
+    public string LastName { get; set;}
+    // ...
+}
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+7
+
+Section 2.8: Immutability of strings
+
+Strings are immutable. You just cannot change existing string. Any operation on the string crates a new instance of
+
+the string having new value. It means that if you need to replace a single character in a very long string, memory will
+
+be allocated for a new value.
+
+string veryLongString = ...
+// memory is allocated
+string newString = veryLongString.Remove(0,1); // removes first character of the string.
+
+If you need to perform many operations with string value, use StringBuilder class which is designed for efficient
+
+strings manipulation:
+
+var sb = new StringBuilder(someInitialString);
+foreach(var str in manyManyStrings)
+{
+    sb.Append(str);
+}
+var finalString = sb.ToString();
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+8
+
+Chapter 3: DateTime parsing
+
+Section 3.1: ParseExact
+
+var dateString = "2015-11-24";
+
+var date = DateTime.ParseExact(dateString, "yyyy-MM-dd", null);
+Console.WriteLine(date);
+
+11/24/2015 12:00:00 AM
+
+Note that passing CultureInfo.CurrentCulture as the third parameter is identical to passing null. Or, you can
+
+pass a specific culture.
+
+Format Strings
+
+Input string can be in any format that matches the format string
+
+var date = DateTime.ParseExact("24|201511", "dd|yyyyMM", null);
+Console.WriteLine(date);
+
+11/24/2015 12:00:00 AM
+
+Any characters that are not format specifiers are treated as literals
+
+var date = DateTime.ParseExact("2015|11|24", "yyyy|MM|dd", null);
+Console.WriteLine(date);
+
+11/24/2015 12:00:00 AM
+
+Case matters for format specifiers
+
+var date = DateTime.ParseExact("2015-01-24 11:11:30", "yyyy-mm-dd hh:MM:ss", null);
+Console.WriteLine(date);
+
+11/24/2015 11:01:30 AM
+
+Note that the month and minute values were parsed into the wrong destinations.
+
+Single-character format strings must be one of the standard formats
+
+var date = DateTime.ParseExact("11/24/2015", "d", new CultureInfo("en-US"));
+var date = DateTime.ParseExact("2015-11-24T10:15:45", "s", null);
+var date = DateTime.ParseExact("2015-11-24 10:15:45Z", "u", null);
+
+Exceptions
+
+ArgumentNullException
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+9
+
+var date = DateTime.ParseExact(null, "yyyy-MM-dd", null);
+var date = DateTime.ParseExact("2015-11-24", null, null);
+
+FormatException
+
+var date = DateTime.ParseExact("", "yyyy-MM-dd", null);
+var date = DateTime.ParseExact("2015-11-24", "", null);
+var date = DateTime.ParseExact("2015-0C-24", "yyyy-MM-dd", null);
+var date = DateTime.ParseExact("2015-11-24", "yyyy-QQ-dd", null);
+
+// Single-character format strings must be one of the standard formats
+var date = DateTime.ParseExact("2015-11-24", "q", null);
+
+// Format strings must match the input exactly* (see next section)
+var date = DateTime.ParseExact("2015-11-24", "d", null); // Expects 11/24/2015 or 24/11/2015 for
+most cultures
+
+Handling multiple possible formats
+
+var date = DateTime.ParseExact("2015-11-24T10:15:45",
+  new [] { "s", "t", "u", "yyyy-MM-dd" }, // Will succeed as long as input matches one of these
+  CultureInfo.CurrentCulture, DateTimeStyles.None);
+
+Handling culture differences
+
+var dateString = "10/11/2015";
+var date = DateTime.ParseExact(dateString, "d", new CultureInfo("en-US"));
+Console.WriteLine("Day: {0}; Month: {1}", date.Day, date.Month);
+
+Day: 11; Month: 10
+
+date = DateTime.ParseExact(dateString, "d", new CultureInfo("en-GB"));
+Console.WriteLine("Day: {0}; Month: {1}", date.Day, date.Month);
+
+Day: 10; Month: 11
+
+Section 3.2: TryParse
+
+This method accepts a string as input, attempts to parse it into a DateTime, and returns a Boolean result indicating
+
+success or failure. If the call succeeds, the variable passed as the out parameter is populated with the parsed result.
+
+If the parse fails, the variable passed as the out parameter is set to the default value, DateTime.MinValue.
+
+TryParse(string, out DateTime)
+
+DateTime parsedValue;
+
+if (DateTime.TryParse("monkey", out parsedValue))
+{
+   Console.WriteLine("Apparently, 'monkey' is a date/time value. Who knew?");
+}
+
+This method attempts to parse the input string based on the system regional settings and known formats such as
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+10
+
+ISO 8601 and other common formats.
+
+DateTime.TryParse("11/24/2015 14:28:42", out parsedValue); // true
+DateTime.TryParse("2015-11-24 14:28:42", out parsedValue); // true
+DateTime.TryParse("2015-11-24T14:28:42", out parsedValue); // true
+DateTime.TryParse("Sat, 24 Nov 2015 14:28:42", out parsedValue); // true
+
+Since this method does not accept culture info, it uses the system locale. This can lead to unexpected results.
+
+// System set to en-US culture
+bool result = DateTime.TryParse("24/11/2015", out parsedValue);
+Console.WriteLine(result);
+
+False
+
+// System set to en-GB culture
+bool result = DateTime.TryParse("11/24/2015", out parsedValue);
+Console.WriteLine(result);
+
+False
+
+// System set to en-GB culture
+bool result = DateTime.TryParse("10/11/2015", out parsedValue);
+Console.WriteLine(result);
+
+True
+
+Note that if you are in the US, you might be surprised that the parsed result is November 10, not October 11.
+
+TryParse(string, IFormatProvider, DateTimeStyles, out DateTime)
+
+if (DateTime.TryParse(" monkey ", new CultureInfo("en-GB"),
+    DateTimeStyles.AllowLeadingWhite | DateTimeStyles.AllowTrailingWhite, out parsedValue)
+{
+    Console.WriteLine("Apparently, ' monkey ' is a date/time value. Who knew?");
+}
+
+Unlike its sibling method, this overload allows a specific culture and style(s) to be specified. Passing null for the
+
+IFormatProvider parameter uses the system culture.
+
+Exceptions
+
+Note that it is possible for this method to throw an exception under certain conditions. These relate to the
+
+parameters introduced for this overload: IFormatProvider and DateTimeStyles.
+
+NotSupportedException: IFormatProvider specifies a neutral culture
+
+ArgumentException: DateTimeStyles is not a valid option, or contains incompatible flags such as
+
+AssumeLocal and AssumeUniversal.
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+11
+
+Section 3.3: TryParseExact
+
+This method behaves as a combination of TryParse and ParseExact: It allows custom format(s) to be specified, and
+
+returns a Boolean result indicating success or failure rather than throwing an exception if the parse fails.
+
+TryParseExact(string, string, IFormatProvider, DateTimeStyles, out DateTime)
+
+This overload attempts to parse the input string against a specific format. The input string must match that format
+
+in order to be parsed.
+
+DateTime.TryParseExact("11242015", "MMddyyyy", null, DateTimeStyles.None, out parsedValue); // true
+
+TryParseExact(string, string[], IFormatProvider, DateTimeStyles, out DateTime)
+
+This overload attempts to parse the input string against an array of formats. The input string must match at least
+
+one format in order to be parsed.
+
+DateTime.TryParseExact("11242015", new [] { "yyyy-MM-dd", "MMddyyyy" }, null, DateTimeStyles.None,
+out parsedValue); // true
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+12
+
+Chapter 4: Dictionaries
+
+Section 4.1: Initializing a Dictionary with a Collection Initializer
+
+// Translates to `dict.Add(1, "First")` etc.
+var dict = new Dictionary<int, string>()
+{
+    { 1, "First" },
+    { 2, "Second" },
+    { 3, "Third" }
+};
+
+// Translates to `dict[1] = "First"` etc.
+// Works in C# 6.0.
+var dict = new Dictionary<int, string>()
+{
+    [1] = "First",
+    [2] = "Second",
+    [3] = "Third"
+};
+
+Section 4.2: Adding to a Dictionary
+
+Dictionary<int, string> dict = new Dictionary<int, string>();
+dict.Add(1, "First");
+dict.Add(2, "Second");
+
+// To safely add items (check to ensure item does not already exist - would throw)
+if(!dict.ContainsKey(3))
+{
+   dict.Add(3, "Third");
+}
+
+Alternatively they can be added/set via the an indexer. (An indexer internally looks like a property, having a get and
+
+set, but takes a parameter of any type which is specified between the brackets) :
+
+Dictionary<int, string> dict = new Dictionary<int, string>();
+dict[1] = "First";
+dict[2] = "Second";
+dict[3] = "Third";
+
+Unlike the Add method which throws an exception, if a key is already contained in the dictionary, the indexer just
+
+replaces the existing value.
+
+For thread-safe dictionary use ConcurrentDictionary<TKey, TValue>:
+
+var dict = new ConcurrentDictionary<int, string>();
+dict.AddOrUpdate(1, "First", (oldKey, oldValue) => "First");
+
+Section 4.3: Getting a value from a dictionary
+
+Given this setup code:
+
+var dict = new Dictionary<int, string>()
+{
+    { 1, "First" },
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+13
+
+    { 2, "Second" },
+    { 3, "Third" }
+};
+
+You may want to read the value for the entry with key 1. If key doesn't exist getting a value will throw
+
+KeyNotFoundException, so you may want to first check for that with ContainsKey:
+
+if (dict.ContainsKey(1))
+    Console.WriteLine(dict[1]);
+
+This has one disadvantage: you will search through your dictionary twice (once to check for existence and one to
+
+read the value). For a large dictionary this can impact performance. Fortunately both operations can be performed
+
+together:
+
+string value;
+if (dict.TryGetValue(1, out value))
+    Console.WriteLine(value);
+
+Section 4.4: Make a Dictionary<string, T> with Case-
+Insensivitve keys
+
+var MyDict = new Dictionary<string,T>(StringComparison.InvariantCultureIgnoreCase)
+
+Section 4.5: IEnumerable to Dictionary (≥ .NET 3.5)
+
+Create a Dictionary<TKey, TValue> from an IEnumerable<T>:
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+public class Fruits
+{
+    public int Id { get; set; }
+    public string Name { get; set; }
+}
+
+var fruits = new[]
+{
+    new Fruits { Id = 8 , Name = "Apple" },
+    new Fruits { Id = 3 , Name = "Banana" },
+    new Fruits { Id = 7 , Name = "Mango" },
+};
+
+// Dictionary<int, string>                  key      value
+var dictionary = fruits.ToDictionary(x => x.Id, x => x.Name);
+
+Section 4.6: Enumerating a Dictionary
+
+You can enumerate through a Dictionary in one of 3 ways:
+
+Using KeyValue pairs
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+14
+
+Dictionary<int, string> dict = new Dictionary<int, string>();
+foreach(KeyValuePair<int, string> kvp in dict)
+{
+   Console.WriteLine("Key : " + kvp.Key.ToString() + ", Value : " + kvp.Value);
+}
+
+Using Keys
+
+Dictionary<int, string> dict = new Dictionary<int, string>();
+foreach(int key in dict.Keys)
+{
+    Console.WriteLine("Key : " + key.ToString() + ", Value : " + dict[key]);
+}
+
+Using Values
+
+Dictionary<int, string> dict = new Dictionary<int, string>();
+foreach(string s in dict.Values)
+{
+    Console.WriteLine("Value : " + s);
+}
+
+Section 4.7: ConcurrentDictionary<TKey, TValue> (from .NET
+4.0)
+
+Represents a thread-safe collection of key/value pairs that can be accessed by multiple threads
+
+concurrently.
+
+Creating an instance
+
+Creating an instance works pretty much the same way as with Dictionary<TKey, TValue>, e.g.:
+
+var dict = new ConcurrentDictionary<int, string>();
+
+Adding or Updating
+
+You might be surprised, that there is no Add method, but instead there is AddOrUpdate with 2 overloads:
+
+(1) AddOrUpdate(TKey key, TValue, Func<TKey, TValue, TValue> addValue) - Adds a key/value pair if the key does
+not already exist, or updates a key/value pair by using the specified function if the key already exists.
+
+(2) AddOrUpdate(TKey key, Func<TKey, TValue> addValue, Func<TKey, TValue, TValue> updateValueFactory)
+- Uses the specified functions to add a key/value pair to the if the key does not already exist, or to update a key/value pair
+if the key already exists.
+
+Adding or updating a value, no matter what was the value if it was already present for given key (1):
+
+string addedValue = dict.AddOrUpdate(1, "First", (updateKey, valueOld) => "First");
+
+Adding or updating a value, but now altering the value in update, based on the previous value (1):
+
+string addedValue2 = dict.AddOrUpdate(1, "First", (updateKey, valueOld) => $"{valueOld} Updated");
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+15
+
+Using the overload (2) we can also add new value using a factory:
+
+string addedValue3 = dict.AddOrUpdate(1, (key) => key == 1 ? "First" : "Not First", (updateKey,
+valueOld) => $"{valueOld} Updated");
+
+Getting value
+
+Getting a value is the same as with the Dictionary<TKey,TValue>:
+
+string value = null;
+bool success = dict.TryGetValue(1, out value);
+
+Getting or Adding a value
+
+There are two mehod overloads, that will get or add a value in a thread-safe manner.
+
+Get value with key 2, or add value "Second" if the key is not present:
+
+string theValue = dict.GetOrAdd(2, "Second");
+
+Using a factory for adding a value, if value is not present:
+
+string theValue2 = dict.GetOrAdd(2, (key) => key == 2 ? "Second" : "Not Second." );
+
+Section 4.8: Dictionary to List
+
+Creating a list of KeyValuePair:
+
+Dictionary<int, int> dictionary = new Dictionary<int, int>();
+List<KeyValuePair<int, int>> list = new List<KeyValuePair<int, int>>();
+list.AddRange(dictionary);
+
+Creating a list of keys:
+
+Dictionary<int, int> dictionary = new Dictionary<int, int>();
+List<int> list = new List<int>();
+list.AddRange(dictionary.Keys);
+
+Creating a list of values:
+
+Dictionary<int, int> dictionary = new Dictionary<int, int>();
+List<int> list = new List<int>();
+list.AddRange(dictionary.Values);
+
+Section 4.9: Removing from a Dictionary
+
+Given this setup code:
+
+var dict = new Dictionary<int, string>()
+{
+    { 1, "First" },
+    { 2, "Second" },
+    { 3, "Third" }
+};
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+16
+
+Use the Remove method to remove a key and its associated value.
+
+bool wasRemoved = dict.Remove(2);
+
+Executing this code removes the key 2 and it's value from the dictionary. Remove returns a boolean value indicating
+
+whether the specified key was found and removed from the dictionary. If the key does not exist in the dictionary,
+
+nothing is removed from the dictionary, and false is returned (no exception is thrown).
+
+It's incorrect to try and remove a key by setting the value for the key to null.
+
+dict[2] = null; // WRONG WAY TO REMOVE!
+
+This will not remove the key. It will just replace the previous value with a value of null.
+
+To remove all keys and values from a dictionary, use the Clear method.
+
+dict.Clear();
+
+After executing Clear the dictionary's Count will be 0, but the internal capacity remains unchanged.
+
+Section 4.10: ContainsKey(TKey)
+
+To check if a Dictionary has an specifique key, you can call the method ContainsKey(TKey) and provide the key of
+
+TKey type. The method returns a bool value when the key exists on the dictionary. For sample:
+
+var dictionary = new Dictionary<string, Customer>()
+{
+   {"F1", new Customer() { FirstName = "Felipe", ... } },
+   {"C2", new Customer() { FirstName = "Carl", ... } },
+   {"J7", new Customer() { FirstName = "John", ... } },
+   {"M5", new Customer() { FirstName = "Mary", ... } },
+};
+
+And check if a C2 exists on the Dictionary:
+
+if (dictionary.ContainsKey("C2"))
+{
+   // exists
+}
+
+The ContainsKey method is available on the generic version Dictionary<TKey, TValue>.
+
+Section 4.11: ConcurrentDictionary augmented with Lazy'1
+reduces duplicated computation
+
+Problem
+
+ConcurrentDictionary shines when it comes to instantly returning of existing keys from cache, mostly lock free, and
+
+contending on a granular level. But what if the object creation is really expensive, outweighing the cost of context
+
+switching, and some cache misses occur?
+
+If the same key is requested from multiple threads, one of the objects resulting from colliding operations will be
+
+eventually added to the collection, and the others will be thrown away, wasting the CPU resource to create the
+
+object and memory resource to store the object temporarily. Other resources could be wasted as well. This is really
+
+bad.
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+17
+
+Solution
+
+We can combine ConcurrentDictionary<TKey, TValue> with Lazy<TValue>. The idea is that ConcurrentDictionary
+
+GetOrAdd method can only return the value which was actually added to the collection. The loosing Lazy objects
+
+could be wasted in this case too, but that's not much problem, as the Lazy object itself is relatively unexpensive. The
+
+Value property of the losing Lazy is never requested, because we are smart to only request the Value property of
+
+the one actually added to the collection - the one returned from the GetOrAdd method:
+
+public static class ConcurrentDictionaryExtensions
+{
+    public static TValue GetOrCreateLazy<TKey, TValue>(
+        this ConcurrentDictionary<TKey, Lazy<TValue>> d,
+        TKey key,
+        Func<TKey, TValue> factory)
+    {
+        return
+            d.GetOrAdd(
+                key,
+                key1 =>
+                    new Lazy<TValue>(() => factory(key1),
+                    LazyThreadSafetyMode.ExecutionAndPublication)).Value;
+    }
+}
+
+Caching of XmlSerializer objects can be particularly expensive, and there is a lot of contention at the application
+
+startup too. And there is more to this: if those are custom serializers, there will be a memory leak too for the rest of
+
+the process lifecycle. The only benefit of the ConcurrentDictionary in this case is that for the rest of the process
+
+lifecycle there will be no locks, but application startup and memory usage would be inacceptable. This is a job for
+
+our ConcurrentDictionary, augmented with Lazy:
+
+private ConcurrentDictionary<Type, Lazy<XmlSerializer>> _serializers =
+    new ConcurrentDictionary<Type, Lazy<XmlSerializer>>();
+
+public XmlSerializer GetSerialier(Type t)
+{
+    return _serializers.GetOrCreateLazy(t, BuildSerializer);
+}
+
+private XmlSerializer BuildSerializer(Type t)
+{
+    throw new NotImplementedException("and this is a homework");
+}
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+18
+
+Chapter 5: Collections
+
+Section 5.1: Using collection initializers
+
+Some collection types can be initialized at the declaration time. For example, the following statement creates and
+
+initializes the numbers with some integers:
+
+List<int> numbers = new List<int>(){10, 9, 8, 7, 7, 6, 5, 10, 4, 3, 2, 1};
+
+Internally, the C# compiler actually converts this initialization to a series of calls to the Add method. Consequently,
+
+you can use this syntax only for collections that actually support the Add method.
+
+The Stack<T> and Queue<T> classes do not support it.
+
+For complex collections such as the Dictionary<TKey, TValue> class, that take key/value pairs, you can specify
+
+each key/value pair as an anonymous type in the initializer list.
+
+Dictionary<int, string> employee = new Dictionary<int, string>()
+     {{44, "John"}, {45, "Bob"}, {47, "James"}, {48, "Franklin"}};
+
+The first item in each pair is the key, and the second is the value.
+
+Section 5.2: Stack
+
+There is a collection in .Net used to manage values in a Stack that uses the LIFO (last-in first-out) concept. The
+
+basics of stacks is the method Push(T item) which is used to add elements in the stack and Pop() which is used to
+
+get the last element added and remove it from the stack. The generic version can be used like the following code
+
+for a queue of strings.
+
+First, add the namespace:
+
+using System.Collections.Generic;
+
+and use it:
+
+Stack<string> stack = new Stack<string>();
+stack.Push("John");
+stack.Push("Paul");
+stack.Push("George");
+stack.Push("Ringo");
+
+string value;
+value = stack.Pop(); // return Ringo
+value = stack.Pop(); // return George
+value = stack.Pop(); // return Paul
+value = stack.Pop(); // return John
+
+There is a non generic version of the type, which works with objects.
+
+The namespace is:
+
+using System.Collections;
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+19
+
+And a code sample of non generic stack:
+
+Stack stack = new Stack();
+stack.Push("Hello World"); // string
+stack.Push(5); // int
+stack.Push(1d); // double
+stack.Push(true); // bool
+stack.Push(new Product()); // Product object
+
+object value;
+value = stack.Pop(); // return Product (Product type)
+value = stack.Pop(); // return true (bool)
+value = stack.Pop(); // return 1d (double)
+value = stack.Pop(); // return 5 (int)
+value = stack.Pop(); // return Hello World (string)
+
+There is also a method called Peek() which returns the last element added but without removing it from the Stack.
+
+Stack<int> stack = new Stack<int>();
+stack.Push(10);
+stack.Push(20);
+
+var lastValueAdded = stack.Peek(); // 20
+
+It is possible to iterate on the elements on the stack and it will respect the order of the stack (LIFO).
+
+Stack<int> stack = new Stack<int>();
+stack.Push(10);
+stack.Push(20);
+stack.Push(30);
+stack.Push(40);
+stack.Push(50);
+
+foreach (int element in stack)
+{
+   Console.WriteLine(element);
+}
+
+The output (without removing):
+
+50
+40
+30
+20
+10
+
+Section 5.3: Creating an initialized List with Custom Types
+
+public class Model
+{
+    public string Name { get; set; }
+    public bool? Selected { get; set; }
+}
+
+Here we have a Class with no constructor with two properties: Name and a nullable boolean property Selected. If we
+
+wanted to initialize a List<Model>, there are a few different ways to execute this.
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+20
+
+var SelectedEmployees = new List<Model>
+ {
+      new Model() {Name = "Item1", Selected = true},
+      new Model() {Name = "Item2", Selected = false},
+      new Model() {Name = "Item3", Selected = false},
+      new Model() {Name = "Item4"}
+ };
+
+Here, we are creating several new instances of our Model class, and initializing them with data. What if we added a
+
+constructor?
+
+public class Model
+{
+
+    public Model(string name, bool? selected = false)
+    {
+        Name = name;
+        selected = Selected;
+    }
+    public string Name { get; set; }
+    public bool? Selected { get; set; }
+}
+
+This allows us to initialize our List a little differently.
+
+var SelectedEmployees = new List<Model>
+{
+    new Model("Mark", true),
+    new Model("Alexis"),
+    new Model("")
+};
+
+What about a Class where one of the properties is a class itself?
+
+public class Model
+{
+    public string Name { get; set; }
+    public bool? Selected { get; set; }
+}
+
+public class ExtendedModel : Model
+{
+    public ExtendedModel()
+    {
+        BaseModel = new Model();
+    }
+
+    public Model BaseModel { get; set; }
+    public DateTime BirthDate { get; set; }
+}
+
+Notice we reverted the constructor on the Model class to simplify the example a little bit.
+
+var SelectedWithBirthDate = new List<ExtendedModel>
+{
+    new ExtendedModel()
+    {
+        BaseModel = new Model { Name = "Mark", Selected = true},
+        BirthDate = new DateTime(2015, 11, 23)
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+21
+
+    },
+                    new ExtendedModel()
+    {
+        BaseModel = new Model { Name = "Random"},
+        BirthDate = new DateTime(2015, 11, 23)
+    }
+};
+
+Note that we can interchange our List<ExtendedModel> with Collection<ExtendedModel>, ExtendedModel[],
+
+object[], or even simply [].
+
+Section 5.4: Queue
+
+There is a collection in .Net used to manage values in a Queue that uses the FIFO (first-in first-out) concept. The
+
+basics of queues is the method Enqueue(T item) which is used to add elements in the queue and Dequeue() which
+
+is used to get the first element and remove it from the queue. The generic version can be used like the following
+
+code for a queue of strings.
+
+First, add the namespace:
+
+using System.Collections.Generic;
+
+and use it:
+
+Queue<string> queue = new Queue<string>();
+queue.Enqueue("John");
+queue.Enqueue("Paul");
+queue.Enqueue("George");
+queue.Enqueue("Ringo");
+
+string dequeueValue;
+dequeueValue = queue.Dequeue(); // return John
+dequeueValue = queue.Dequeue(); // return Paul
+dequeueValue = queue.Dequeue(); // return George
+dequeueValue = queue.Dequeue(); // return Ringo
+
+There is a non generic version of the type, which works with objects.
+
+The namespace is:
+
+using System.Collections;
+
+Adn a code sample fo non generic queue:
+
+Queue queue = new Queue();
+queue.Enqueue("Hello World"); // string
+queue.Enqueue(5); // int
+queue.Enqueue(1d); // double
+queue.Enqueue(true); // bool
+queue.Enqueue(new Product()); // Product object
+
+object dequeueValue;
+dequeueValue = queue.Dequeue(); // return Hello World (string)
+dequeueValue = queue.Dequeue(); // return 5 (int)
+dequeueValue = queue.Dequeue(); // return 1d (double)
+dequeueValue = queue.Dequeue(); // return true (bool)
+dequeueValue = queue.Dequeue(); // return Product (Product type)
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+22
+
+There is also a method called Peek() which returns the object at the beginning of the queue without removing it the
+
+elements.
+
+Queue<int> queue = new Queue<int>();
+queue.Enqueue(10);
+queue.Enqueue(20);
+queue.Enqueue(30);
+queue.Enqueue(40);
+queue.Enqueue(50);
+
+foreach (int element in queue)
+{
+    Console.WriteLine(i);
+}
+
+The output (without removing):
+
+10
+20
+30
+40
+50
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+23
+
+Chapter 6: ReadOnlyCollections
+
+Section 6.1: Creating a ReadOnlyCollection
+
+Using the Constructor
+
+A ReadOnlyCollection is created by passing an existing IList object into the constructor:
+
+var groceryList = new List<string> { "Apple", "Banana" };
+var readOnlyGroceryList = new ReadOnlyCollection<string>(groceryList);
+
+Using LINQ
+
+Additionaly, LINQ provides an AsReadOnly() extension method for IList objects:
+
+var readOnlyVersion = groceryList.AsReadOnly();
+
+Note
+
+Typically, you want to maintain the source collection privately and allow public access to the ReadOnlyCollection.
+
+While you could create a ReadOnlyCollection from an in-line list, you would be unable to modify the collection
+
+after you created it.
+
+var readOnlyGroceryList = new List<string> {"Apple", "Banana"}.AsReadOnly();
+// Great, but you will not be able to update the grocery list because
+//  you do not have a reference to the source list anymore!
+
+If you find yourself doing this, you may want to consider using another data structure, such as an
+
+ImmutableCollection.
+
+Section 6.2: Updating a ReadOnlyCollection
+
+A ReadOnlyCollection cannot be edited directly. Instead, the source collection is updated and the
+
+ReadOnlyCollection will reflect these changes. This is the key feature of the ReadOnlyCollection.
+
+var groceryList = new List<string> { "Apple", "Banana" };
+
+var readOnlyGroceryList = new ReadOnlyCollection<string>(groceryList);
+
+var itemCount = readOnlyGroceryList.Count;  // There are currently 2 items
+
+//readOnlyGroceryList.Add("Candy");         // Compiler Error - Items cannot be added to a
+ReadOnlyCollection object
+groceryList.Add("Vitamins");                // ..but they can be added to the original collection
+
+itemCount = readOnlyGroceryList.Count;      // Now there are 3 items
+var lastItem = readOnlyGroceryList.Last();  // The last item on the read only list is now "Vitamins"
+
+View Demo
+
+Section 6.3: Warning: Elements in a ReadOnlyCollection are
+not inherently read-only
+
+If the source collection is of a type that is not immutable, elements accessed through a ReadOnlyCollection can be
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+24
+
+modified.
+
+public class Item
+{
+    public string Name { get; set; }
+    public decimal Price { get; set; }
+}
+
+public static void FillOrder()
+{
+    // An order is generated
+    var order = new List<Item>
+    {
+        new Item { Name = "Apple", Price = 0.50m },
+        new Item { Name = "Banana", Price = 0.75m },
+        new Item { Name = "Vitamins", Price = 5.50m }
+    };
+
+    // The current sub total is $6.75
+    var subTotal = order.Sum(item => item.Price);
+
+    // Let the customer preview their order
+    var customerPreview = new ReadOnlyCollection<Item>(order);
+
+    // The customer can't add or remove items, but they can change
+    //   the price of an item, even though it is a ReadOnlyCollection
+    customerPreview.Last().Price = 0.25m;
+
+    // The sub total is now only $1.50!
+    subTotal = order.Sum(item => item.Price);
+}
+
+View Demo
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+25
+
+Chapter 7: Stack and Heap
+
+Section 7.1: Value types in use
+
+Value types simply contain a value.
+
+All value types are derived from the System.ValueType class, and this includes most of the built in types.
+
+When creating a new value type, the an area of memory called the stack is used.
+The stack will grow accordingly, by the size the declared type. So for example, an int will always be allocated 32 bits
+
+of memory on the stack. When the value type is no longer in scope, the space on the stack will be deallocated.
+
+The code below demonstrates a value type being assigned to a new variable. A struct is being used as a convenient
+
+way to create a custom value type (the System.ValueType class cannot be otherwise extended).
+
+The important thing to understand is that when assigning a value type, the value itself copied to the new variable,
+meaning we have two distinct instances of the object, that cannot affect each other.
+
+struct PersonAsValueType
+{
+    public string Name;
+}
+
+class Program
+{
+    static void Main()
+    {
+        PersonAsValueType personA;
+
+        personA.Name = "Bob";
+
+        var personB = personA;
+
+        personA.Name = "Linda";
+
+        Console.WriteLine(                // Outputs 'False' - because
+            object.ReferenceEquals(       // personA and personB are referencing
+                personA,                  // different areas of memory
+                personB));                
+
+        Console.WriteLine(personA.Name);  // Outputs 'Linda'
+        Console.WriteLine(personB.Name);  // Outputs 'Bob'
+    }
+}
+
+Section 7.2: Reference types in use
+
+Reference types are comprised of both a reference to a memory area, and a value stored within that area.
+This is analogous to pointers in C/C++.
+
+All reference types are stored on what is known as the heap.
+The heap is simply a managed area of memory where objects are stored. When a new object is instantiated, a part
+
+of the heap will be allocated for use by that object, and a reference to that location of the heap will be returned. The
+heap is managed and maintained by the garbage collector, and does not allow for manual intervention.
+
+In addition to the memory space required for the instance itself, additional space is required to store the reference
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+26
+
+itself, along with additional temporary information required by the .NET CLR.
+
+The code below demonstrates a reference type being assigned to a new variable. In this instance, we are using a
+
+class, all classes are reference types (even if static).
+
+When a reference type is assigned to another variable, it is the reference to the object that is copied over, not the
+value itself. This is an important distinction between value types and reference types.
+
+The implications of this are that we now have two references to the same object.
+
+Any changes to the values within that object will be reflected by both variables.
+
+class PersonAsReferenceType
+{
+    public string Name;
+}
+
+class Program
+{
+    static void Main()
+    {
+        PersonAsReferenceType personA;
+
+        personA = new PersonAsReferenceType { Name = "Bob" };
+
+        var personB = personA;
+
+        personA.Name = "Linda";
+
+        Console.WriteLine(               // Outputs 'True' - because
+            object.ReferenceEquals(      // personA and personB are referencing
+                personA,                 // the *same* memory location
+                personB));
+
+        Console.WriteLine(personA.Name); // Outputs 'Linda'
+        Console.WriteLine(personB.Name); // Outputs 'Linda'
+    }
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+27
+
+Chapter 8: LINQ
+
+LINQ (Language Integrated Query) is an expression that retrieves data from a data source. LINQ simplifies this
+
+situation by offering a consistent model for working with data across various kinds of data sources and formats. In
+
+a LINQ query, you are always working with objects. You use the same basic coding patterns to query and transform
+
+data in XML documents, SQL databases, ADO.NET Datasets, .NET collections, and any other format for which a
+
+provider is available. LINQ can be used in C# and VB.
+
+Section 8.1: SelectMany (flat map)
+
+Enumerable.Select returns an output element for every input element. Whereas Enumerable.SelectMany
+
+produces a variable number of output elements for each input element. This means that the output sequence may
+
+contain more or fewer elements than were in the input sequence.
+
+Lambda expressions passed to Enumerable.Select must return a single item. Lambda expressions passed to
+
+Enumerable.SelectMany must produce a child sequence. This child sequence may contain a varying number of
+
+elements for each element in the input sequence.
+
+Example
+
+class Invoice
+{
+    public int Id { get; set; }
+}
+
+class Customer
+{
+    public Invoice[] Invoices {get;set;}
+}
+
+var customers = new[] {
+    new Customer {
+        Invoices = new[] {
+            new Invoice {Id=1},
+            new Invoice {Id=2},
+        }
+    },
+    new Customer {
+        Invoices = new[] {
+            new Invoice {Id=3},
+            new Invoice {Id=4},
+        }
+    },
+    new Customer {
+        Invoices = new[] {
+            new Invoice {Id=5},
+            new Invoice {Id=6},
+        }
+    }
+};
+
+var allInvoicesFromAllCustomers = customers.SelectMany(c => c.Invoices);
+
+Console.WriteLine(
+    string.Join(",", allInvoicesFromAllCustomers.Select(i => i.Id).ToArray()));
+
+Output:
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+28
+
+1,2,3,4,5,6
+
+View Demo
+
+Enumerable.SelectMany can also be achieved with a syntax-based query using two consecutive from clauses:
+
+var allInvoicesFromAllCustomers
+    = from customer in customers
+      from invoice in customer.Invoices
+      select invoice;
+
+Section 8.2: Where (filter)
+
+This method returns an IEnumerable with all the elements that meets the lambda expression
+
+Example
+
+var personNames = new[]
+{
+    "Foo", "Bar", "Fizz", "Buzz"
+};
+
+var namesStartingWithF = personNames.Where(p => p.StartsWith("F"));
+Console.WriteLine(string.Join(",", namesStartingWithF));
+
+Output:
+
+Foo,Fizz
+
+View Demo
+
+Section 8.3: Any
+
+Returns true if the collection has any elements that meets the condition in the lambda expression:
+
+var numbers = new[] {1,2,3,4,5};
+
+var isNotEmpty = numbers.Any();
+Console.WriteLine(isNotEmpty); //True
+
+var anyNumberIsOne = numbers.Any(n => n == 1);
+Console.WriteLine(anyNumberIsOne); //True
+
+var anyNumberIsSix = numbers.Any(n => n == 6);
+Console.WriteLine(anyNumberIsSix); //False    
+
+var anyNumberIsOdd = numbers.Any(n => (n & 1) == 1);
+Console.WriteLine(anyNumberIsOdd); //True
+
+var anyNumberIsNegative = numbers.Any(n => n < 0);
+Console.WriteLine(anyNumberIsNegative); //False
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+29
+
+Section 8.4: GroupJoin
+
+class Developer
+{
+    public int Id { get; set; }
+    public string Name { get; set; }
+}
+
+class Project
+{
+    public int DeveloperId { get; set; }
+    public string Name { get; set; }
+}
+
+var developers = new[] {
+    new Developer {
+        Id = 1,
+        Name = "Foobuzz"
+    },
+    new Developer {
+        Id = 2,
+        Name = "Barfizz"
+    }
+};
+
+var projects = new[] {
+    new Project {
+        DeveloperId = 1,
+        Name = "Hello World 3D"
+    },
+    new Project {
+        DeveloperId = 1,
+        Name = "Super Fizzbuzz Maker"
+    },
+    new Project {
+        DeveloperId = 2,
+        Name = "Citizen Kane - The action game"
+    },
+    new Project {
+        DeveloperId = 2,
+        Name = "Pro Pong 2016"
+    }
+};
+
+var grouped = developers.GroupJoin(
+    inner: projects,
+    outerKeySelector: dev => dev.Id,
+    innerKeySelector: proj => proj.DeveloperId,
+    resultSelector:
+        (dev, projs) => new {
+            DeveloperName = dev.Name,
+            ProjectNames = projs.Select(p => p.Name).ToArray()});
+
+foreach(var item in grouped)
+{
+    Console.WriteLine(
+        "{0}'s projects: {1}",
+        item.DeveloperName,
+        string.Join(", ", item.ProjectNames));
+}
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+30
+
+   
+//Foobuzz's projects: Hello World 3D, Super Fizzbuzz Maker
+//Barfizz's projects: Citizen Kane - The action game, Pro Pong 2016
+
+Section 8.5: Except
+
+var numbers = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
+var evenNumbersBetweenSixAndFourteen = new[] { 6, 8, 10, 12 };
+
+var result = numbers.Except(evenNumbersBetweenSixAndFourteen);
+
+Console.WriteLine(string.Join(",", result));
+
+//1, 2, 3, 4, 5, 7, 9
+
+Section 8.6: Zip
+
+.NET Version ≥ 4.0
+
+var tens = new[] {10,20,30,40,50};
+var units = new[] {1,2,3,4,5};
+
+var sums = tens.Zip(units, (first, second) => first + second);
+
+Console.WriteLine(string.Join(",", sums));
+
+//11,22,33,44,55
+
+Section 8.7: Aggregate (fold)
+
+Generating a new object in each step:
+
+var elements = new[] {1,2,3,4,5};
+
+var commaSeparatedElements = elements.Aggregate(
+    seed: "",
+    func: (aggregate, element) => $"{aggregate}{element},");
+
+Console.WriteLine(commaSeparatedElements);  //1,2,3,4,5,
+
+Using the same object in all steps:
+
+var commaSeparatedElements2 = elements.Aggregate(
+    seed: new StringBuilder(),
+    func: (seed, element) => seed.Append($"{element},"));
+
+Console.WriteLine(commaSeparatedElements2.ToString());  //1,2,3,4,5,
+
+Using a result selector:
+
+var commaSeparatedElements3 = elements.Aggregate(
+    seed: new StringBuilder(),
+    func: (seed, element) => seed.Append($"{element},"),
+    resultSelector: (seed) => seed.ToString());
+Console.WriteLine(commaSeparatedElements3);  //1,2,3,4,5,
+
+If a seed is omitted, the first element becomes the seed:
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+31
+
+   
+   
+var seedAndElements = elements.Select(n=>n.ToString());
+var commaSeparatedElements4 = seedAndElements.Aggregate(
+    func: (aggregate, element) => $"{aggregate}{element},");
+
+Console.WriteLine(commaSeparatedElements4);  //12,3,4,5,
+
+Section 8.8: ToLookup
+
+var persons = new[] {
+    new { Name="Fizz", Job="Developer"},
+    new { Name="Buzz", Job="Developer"},
+    new { Name="Foo", Job="Astronaut"},
+    new { Name="Bar", Job="Astronaut"},
+};
+
+var groupedByJob = persons.ToLookup(p => p.Job);
+
+foreach(var theGroup in groupedByJob)
+{
+    Console.WriteLine(
+        "{0} are {1}s",
+        string.Join(",", theGroup.Select(g => g.Name).ToArray()),
+        theGroup.Key);
+}
+
+//Fizz,Buzz are Developers
+//Foo,Bar are Astronauts
+
+Section 8.9: Intersect
+
+var numbers1to10 = new[] {1,2,3,4,5,6,7,8,9,10};
+var numbers5to15 = new[] {5,6,7,8,9,10,11,12,13,14,15};
+
+var numbers5to10 = numbers1to10.Intersect(numbers5to15);
+
+Console.WriteLine(string.Join(",", numbers5to10));
+
+//5,6,7,8,9,10
+
+Section 8.10: Concat
+
+var numbers1to5 = new[] {1, 2, 3, 4, 5};
+var numbers4to8 = new[] {4, 5, 6, 7, 8};
+
+var numbers1to8 = numbers1to5.Concat(numbers4to8);
+
+Console.WriteLine(string.Join(",", numbers1to8));
+
+//1,2,3,4,5,4,5,6,7,8
+
+Note that duplicates are kept in the result. If this is undesirable, use Union instead.
+
+Section 8.11: All
+
+var numbers = new[] {1,2,3,4,5};
+
+var allNumbersAreOdd = numbers.All(n => (n & 1) == 1);
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+32
+
+Console.WriteLine(allNumbersAreOdd); //False
+
+var allNumbersArePositive = numbers.All(n => n > 0);
+Console.WriteLine(allNumbersArePositive); //True
+
+Note that the All method functions by checking for the first element to evaluate as false according to the
+predicate. Therefore, the method will return true for any predicate in the case that the set is empty:
+
+var numbers = new int[0];
+var allNumbersArePositive = numbers.All(n => n > 0);
+Console.WriteLine(allNumbersArePositive); //True
+
+Section 8.12: Sum
+
+var numbers = new[] {1,2,3,4};
+
+var sumOfAllNumbers = numbers.Sum();
+Console.WriteLine(sumOfAllNumbers); //10
+
+var cities = new[] {
+    new {Population = 1000},
+    new {Population = 2500},
+    new {Population = 4000}
+};
+
+var totalPopulation = cities.Sum(c => c.Population);
+Console.WriteLine(totalPopulation); //7500
+
+Section 8.13: SequenceEqual
+
+var numbers = new[] {1,2,3,4,5};
+var sameNumbers = new[] {1,2,3,4,5};
+var sameNumbersInDifferentOrder = new[] {5,1,4,2,3};
+
+var equalIfSameOrder = numbers.SequenceEqual(sameNumbers);
+Console.WriteLine(equalIfSameOrder); //True
+
+var equalIfDifferentOrder = numbers.SequenceEqual(sameNumbersInDifferentOrder);
+Console.WriteLine(equalIfDifferentOrder); //False
+
+Section 8.14: Min
+
+var numbers = new[] {1,2,3,4};
+
+var minNumber = numbers.Min();
+Console.WriteLine(minNumber); //1
+
+var cities = new[] {
+    new {Population = 1000},
+    new {Population = 2500},
+    new {Population = 4000}
+};
+
+var minPopulation = cities.Min(c => c.Population);
+Console.WriteLine(minPopulation); //1000
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+33
+
+Section 8.15: Distinct
+
+var numbers = new[] {1, 1, 2, 2, 3, 3, 4, 4, 5, 5};
+var distinctNumbers = numbers.Distinct();
+
+Console.WriteLine(string.Join(",", distinctNumbers));
+
+//1,2,3,4,5
+
+Section 8.16: Count
+
+IEnumerable<int> numbers = new[] {1,2,3,4,5,6,7,8,9,10};
+
+var numbersCount = numbers.Count();
+Console.WriteLine(numbersCount); //10
+
+var evenNumbersCount = numbers.Count(n => (n & 1) == 0);
+Console.WriteLine(evenNumbersCount); //5
+
+Section 8.17: Cast
+
+Cast is different from the other methods of Enumerable in that it is an extension method for IEnumerable, not for
+
+IEnumerable<T>. Thus it can be used to convert instances of the former into instances of the later.
+
+This does not compile since ArrayList does not implement IEnumerable<T>:
+
+var numbers = new ArrayList() {1,2,3,4,5};
+Console.WriteLine(numbers.First());
+
+This works as expected:
+
+var numbers = new ArrayList() {1,2,3,4,5};
+Console.WriteLine(numbers.Cast<int>().First()); //1
+
+Cast does not perform conversion casts. The following compiles but throws InvalidCastException at runtime:
+
+var numbers = new int[] {1,2,3,4,5};
+decimal[] numbersAsDecimal = numbers.Cast<decimal>().ToArray();
+
+The proper way to perform a converting cast to a collection is as follows:
+
+var numbers= new int[] {1,2,3,4,5};
+decimal[] numbersAsDecimal = numbers.Select(n => (decimal)n).ToArray();
+
+Section 8.18: Range
+
+The two parameters to Range are the first number and the count of elements to produce (not the last number).
+
+// prints 1,2,3,4,5,6,7,8,9,10
+Console.WriteLine(string.Join(",", Enumerable.Range(1, 10)));
+
+// prints 10,11,12,13,14
+Console.WriteLine(string.Join(",", Enumerable.Range(10, 5)));
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+34
+
+Section 8.19: ThenBy
+
+ThenBy can only be used after a OrderBy clause allowing to order using multiple criteria
+
+var persons = new[]
+{
+    new {Id = 1, Name = "Foo", Order = 1},
+    new {Id = 1, Name = "FooTwo", Order = 2},
+    new {Id = 2, Name = "Bar", Order = 2},
+    new {Id = 2, Name = "BarTwo", Order = 1},
+    new {Id = 3, Name = "Fizz", Order = 2},
+    new {Id = 3, Name = "FizzTwo", Order = 1},  
+};
+
+var personsSortedByName = persons.OrderBy(p => p.Id).ThenBy(p => p.Order);
+
+Console.WriteLine(string.Join(",", personsSortedByName.Select(p => p.Name)));
+//This will display :
+//Foo,FooTwo,BarTwo,Bar,FizzTwo,Fizz
+
+Section 8.20: Repeat
+
+Enumerable.Repeat generates a sequence of a repeated value. In this example it generates "Hello" 4 times.
+
+var repeats = Enumerable.Repeat("Hello", 4);
+
+foreach (var item in repeats)
+{
+    Console.WriteLine(item);
+}
+
+/* output:
+    Hello
+    Hello
+    Hello
+    Hello
+*/
+
+Section 8.21: Empty
+
+To create an empty IEnumerable of int:
+
+IEnumerable<int> emptyList = Enumerable.Empty<int>();
+
+This empty IEnumerable is cached for each Type T, so that:
+
+Enumerable.Empty<decimal>() == Enumerable.Empty<decimal>(); // This is True
+Enumerable.Empty<int>() == Enumerable.Empty<decimal>();     // This is False
+
+Section 8.22: Select (map)
+
+var persons = new[]
+{
+    new {Id = 1, Name = "Foo"},
+    new {Id = 2, Name = "Bar"},
+    new {Id = 3, Name = "Fizz"},
+    new {Id = 4, Name = "Buzz"}
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+35
+
+   
+};
+
+var names = persons.Select(p => p.Name);
+Console.WriteLine(string.Join(",", names.ToArray()));
+
+//Foo,Bar,Fizz,Buzz
+
+This type of function is usually called map in functional programming languages.
+
+Section 8.23: OrderBy
+
+var persons = new[]
+{
+    new {Id = 1, Name = "Foo"},
+    new {Id = 2, Name = "Bar"},
+    new {Id = 3, Name = "Fizz"},
+    new {Id = 4, Name = "Buzz"}
+};
+
+var personsSortedByName = persons.OrderBy(p => p.Name);
+
+Console.WriteLine(string.Join(",", personsSortedByName.Select(p => p.Id).ToArray()));
+
+//2,4,3,1
+
+Section 8.24: OrderByDescending
+
+var persons = new[]
+{
+    new {Id = 1, Name = "Foo"},
+    new {Id = 2, Name = "Bar"},
+    new {Id = 3, Name = "Fizz"},
+    new {Id = 4, Name = "Buzz"}
+};
+
+var personsSortedByNameDescending = persons.OrderByDescending(p => p.Name);
+
+Console.WriteLine(string.Join(",", personsSortedByNameDescending.Select(p => p.Id).ToArray()));
+
+//1,3,4,2
+
+Section 8.25: Contains
+
+var numbers = new[] {1,2,3,4,5};
+Console.WriteLine(numbers.Contains(3)); //True
+Console.WriteLine(numbers.Contains(34)); //False
+
+Section 8.26: First (find)
+
+var numbers = new[] {1,2,3,4,5};
+
+var firstNumber = numbers.First();
+Console.WriteLine(firstNumber); //1
+
+var firstEvenNumber = numbers.First(n => (n & 1) == 0);
+Console.WriteLine(firstEvenNumber); //2
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+36
+
+The following throws InvalidOperationException with message "Sequence contains no matching element":
+
+var firstNegativeNumber = numbers.First(n => n < 0);
+
+Section 8.27: Single
+
+var oneNumber = new[] {5};
+var theOnlyNumber = oneNumber.Single();
+Console.WriteLine(theOnlyNumber);  //5
+
+var numbers = new[] {1,2,3,4,5};
+
+var theOnlyNumberSmallerThanTwo = numbers.Single(n => n < 2);
+Console.WriteLine(theOnlyNumberSmallerThanTwo);  //1
+
+The following throws InvalidOperationException since there is more than one element in the sequence:
+
+var theOnlyNumberInNumbers = numbers.Single();
+var theOnlyNegativeNumber = numbers.Single(n => n < 0);
+
+Section 8.28: Last
+
+var numbers = new[] {1,2,3,4,5};
+
+var lastNumber = numbers.Last();
+Console.WriteLine(lastNumber); //5
+
+var lastEvenNumber = numbers.Last(n => (n & 1) == 0);
+Console.WriteLine(lastEvenNumber); //4
+
+The following throws InvalidOperationException:
+
+var lastNegativeNumber = numbers.Last(n => n < 0);
+
+Section 8.29: LastOrDefault
+
+var numbers = new[] {1,2,3,4,5};
+
+var lastNumber = numbers.LastOrDefault();
+Console.WriteLine(lastNumber); //5
+
+var lastEvenNumber = numbers.LastOrDefault(n => (n & 1) == 0);
+Console.WriteLine(lastEvenNumber); //4
+
+var lastNegativeNumber = numbers.LastOrDefault(n => n < 0);
+Console.WriteLine(lastNegativeNumber); //0
+
+var words = new[] { "one", "two", "three", "four", "five" };
+
+var lastWord = words.LastOrDefault();
+Console.WriteLine(lastWord); // five
+
+var lastLongWord = words.LastOrDefault(w => w.Length > 4);
+Console.WriteLine(lastLongWord); // three
+
+var lastMissingWord = words.LastOrDefault(w => w.Length > 5);
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+37
+
+Console.WriteLine(lastMissingWord); // null
+
+Section 8.30: SingleOrDefault
+
+var oneNumber = new[] {5};
+var theOnlyNumber = oneNumber.SingleOrDefault();
+Console.WriteLine(theOnlyNumber);  //5
+
+var numbers = new[] {1,2,3,4,5};
+
+var theOnlyNumberSmallerThanTwo = numbers.SingleOrDefault(n => n < 2);
+Console.WriteLine(theOnlyNumberSmallerThanTwo);  //1
+
+var theOnlyNegativeNumber = numbers.SingleOrDefault(n => n < 0);
+Console.WriteLine(theOnlyNegativeNumber);  //0
+
+The following throws InvalidOperationException:
+
+var theOnlyNumberInNumbers = numbers.SingleOrDefault();
+
+Section 8.31: FirstOrDefault
+
+var numbers = new[] {1,2,3,4,5};
+
+var firstNumber = numbers.FirstOrDefault();
+Console.WriteLine(firstNumber); //1
+
+var firstEvenNumber = numbers.FirstOrDefault(n => (n & 1) == 0);
+Console.WriteLine(firstEvenNumber); //2
+
+var firstNegativeNumber = numbers.FirstOrDefault(n => n < 0);
+Console.WriteLine(firstNegativeNumber); //0
+
+var words = new[] { "one", "two", "three", "four", "five" };
+
+var firstWord = words.FirstOrDefault();
+Console.WriteLine(firstWord); // one
+
+var firstLongWord = words.FirstOrDefault(w => w.Length > 3);
+Console.WriteLine(firstLongWord); // three
+
+var firstMissingWord = words.FirstOrDefault(w => w.Length > 5);
+Console.WriteLine(firstMissingWord); // null
+
+Section 8.32: Skip
+
+Skip will enumerate the first N items without returning them. Once item number N+1 is reached, Skip starts
+
+returning every enumerated item:
+
+var numbers = new[] {1,2,3,4,5};
+
+var allNumbersExceptFirstTwo = numbers.Skip(2);
+Console.WriteLine(string.Join(",", allNumbersExceptFirstTwo.ToArray()));
+
+//3,4,5
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+38
+
+Section 8.33: Take
+
+This method takes the first n elements from an enumerable.
+
+var numbers = new[] {1,2,3,4,5};
+
+var threeFirstNumbers = numbers.Take(3);
+Console.WriteLine(string.Join(",", threeFirstNumbers.ToArray()));
+
+//1,2,3
+
+Section 8.34: Reverse
+
+var numbers = new[] {1,2,3,4,5};
+var reversed = numbers.Reverse();
+
+Console.WriteLine(string.Join(",", reversed.ToArray()));
+
+//5,4,3,2,1
+
+Section 8.35: OfType
+
+var mixed = new object[] {1,"Foo",2,"Bar",3,"Fizz",4,"Buzz"};
+var numbers = mixed.OfType<int>();
+
+Console.WriteLine(string.Join(",", numbers.ToArray()));
+
+//1,2,3,4
+
+Section 8.36: Max
+
+var numbers = new[] {1,2,3,4};
+
+var maxNumber = numbers.Max();
+Console.WriteLine(maxNumber); //4
+
+var cities = new[] {
+    new {Population = 1000},
+    new {Population = 2500},
+    new {Population = 4000}
+};
+
+var maxPopulation = cities.Max(c => c.Population);
+Console.WriteLine(maxPopulation); //4000
+
+Section 8.37: Average
+
+var numbers = new[] {1,2,3,4};
+
+var averageNumber = numbers.Average();
+Console.WriteLine(averageNumber);
+// 2,5
+
+This method calculates the average of enumerable of numbers.
+
+var cities = new[] {
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+39
+
+    new {Population = 1000},
+    new {Population = 2000},
+    new {Population = 4000}
+};
+
+var averagePopulation = cities.Average(c => c.Population);
+Console.WriteLine(averagePopulation);
+// 2333,33
+
+This method calculates the average of enumerable using delegated function.
+
+Section 8.38: GroupBy
+
+var persons = new[] {
+    new { Name="Fizz", Job="Developer"},
+    new { Name="Buzz", Job="Developer"},
+    new { Name="Foo", Job="Astronaut"},
+    new { Name="Bar", Job="Astronaut"},
+};
+
+var groupedByJob = persons.GroupBy(p => p.Job);
+
+foreach(var theGroup in groupedByJob)
+{
+    Console.WriteLine(
+        "{0} are {1}s",
+        string.Join(",", theGroup.Select(g => g.Name).ToArray()),
+        theGroup.Key);
+}
+
+//Fizz,Buzz are Developers
+//Foo,Bar are Astronauts
+
+Group invoices by country, generating a new object with the number of record, total paid, and average paid
+
+var a = db.Invoices.GroupBy(i => i.Country)
+          .Select(g => new { Country = g.Key,
+                             Count = g.Count(),
+                             Total = g.Sum(i => i.Paid),
+                             Average = g.Average(i => i.Paid) });
+
+If we want only the totals, no group
+
+var a = db.Invoices.GroupBy(i => 1)
+          .Select(g => new { Count = g.Count(),
+                             Total = g.Sum(i => i.Paid),
+                             Average = g.Average(i => i.Paid) });
+
+If we need several counts
+
+var a = db.Invoices.GroupBy(g => 1)
+          .Select(g => new { High = g.Count(i => i.Paid >= 1000),
+                             Low = g.Count(i => i.Paid < 1000),
+                             Sum = g.Sum(i => i.Paid) });
+
+Section 8.39: ToDictionary
+
+Returns a new dictionary from the source IEnumerable using the provided keySelector function to determine keys.
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+40
+
+Will throw an ArgumentException if keySelector is not injective(returns a unique value for each member of the
+
+source collection.) There are overloads which allow one to specify the value to be stored as well as the key.
+
+var persons = new[] {
+    new { Name="Fizz", Id=1},
+    new { Name="Buzz", Id=2},
+    new { Name="Foo", Id=3},
+    new { Name="Bar", Id=4},
+};
+
+Specifying just a key selector function will create a Dictionary<TKey,TVal> with TKey the return Type of the key
+
+selector, TVal the original object Type, and the original object as the stored value.
+
+var personsById = persons.ToDictionary(p => p.Id);
+// personsById is a Dictionary<int,object>
+
+Console.WriteLine(personsById[1].Name); //Fizz
+Console.WriteLine(personsById[2].Name); //Buzz
+
+Specifying a value selector function as well will create a Dictionary<TKey,TVal> with TKey still the return type of
+
+the key selector, but TVal now the return type of the value selector function, and the returned value as the stored
+
+value.
+
+var namesById = persons.ToDictionary(p => p.Id, p => p.Name);
+//namesById is a Dictionary<int,string>
+
+Console.WriteLine(namesById[3]); //Foo
+Console.WriteLine(namesById[4]); //Bar
+
+As stated above, the keys returned by the key selector must be unique. The following will throw an exception.
+
+var persons = new[] {
+    new { Name="Fizz", Id=1},
+    new { Name="Buzz", Id=2},
+    new { Name="Foo", Id=3},
+    new { Name="Bar", Id=4},
+    new { Name="Oops", Id=4}
+};
+
+var willThrowException = persons.ToDictionary(p => p.Id)
+
+If a unique key can not be given for the source collection, consider using ToLookup instead. On the surface,
+
+ToLookup behaves similarly to ToDictionary, however, in the resulting Lookup each key is paired with a collection of
+
+values with matching keys.
+
+Section 8.40: Union
+
+var numbers1to5 = new[] {1,2,3,4,5};
+var numbers4to8 = new[] {4,5,6,7,8};
+
+var numbers1to8 = numbers1to5.Union(numbers4to8);
+
+Console.WriteLine(string.Join(",", numbers1to8));
+
+//1,2,3,4,5,6,7,8
+
+Note that duplicates are removed from the result. If this is undesirable, use Concat instead.
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+41
+
+Section 8.41: ToArray
+
+var numbers = new[] {1,2,3,4,5,6,7,8,9,10};
+var someNumbers = numbers.Where(n => n < 6);
+
+Console.WriteLine(someNumbers.GetType().Name);
+//WhereArrayIterator`1
+
+var someNumbersArray = someNumbers.ToArray();
+
+Console.WriteLine(someNumbersArray.GetType().Name);
+//Int32[]
+
+Section 8.42: ToList
+
+var numbers = new[] {1,2,3,4,5,6,7,8,9,10};
+var someNumbers = numbers.Where(n => n < 6);
+
+Console.WriteLine(someNumbers.GetType().Name);
+//WhereArrayIterator`1
+
+var someNumbersList = someNumbers.ToList();
+
+Console.WriteLine(
+    someNumbersList.GetType().Name + " - " +
+    someNumbersList.GetType().GetGenericArguments()[0].Name);
+//List`1 - Int32
+
+Section 8.43: ElementAt
+
+var names = new[] {"Foo","Bar","Fizz","Buzz"};
+
+var thirdName = names.ElementAt(2);
+Console.WriteLine(thirdName); //Fizz
+
+//The following throws ArgumentOutOfRangeException
+
+var minusOnethName = names.ElementAt(-1);
+var fifthName = names.ElementAt(4);
+
+Section 8.44: ElementAtOrDefault
+
+var names = new[] {"Foo","Bar","Fizz","Buzz"};
+
+var thirdName = names.ElementAtOrDefault(2);
+Console.WriteLine(thirdName); //Fizz
+
+var minusOnethName = names.ElementAtOrDefault(-1);
+Console.WriteLine(minusOnethName); //null
+
+var fifthName = names.ElementAtOrDefault(4);
+Console.WriteLine(fifthName); //null
+
+Section 8.45: SkipWhile
+
+var numbers = new[] {2,4,6,8,1,3,5,7};
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+42
+
+var oddNumbers = numbers.SkipWhile(n => (n & 1) == 0);
+
+Console.WriteLine(string.Join(",", oddNumbers.ToArray()));
+
+//1,3,5,7
+
+Section 8.46: TakeWhile
+
+var numbers = new[] {2,4,6,1,3,5,7,8};
+
+var evenNumbers = numbers.TakeWhile(n => (n & 1) == 0);
+
+Console.WriteLine(string.Join(",", evenNumbers.ToArray()));
+
+//2,4,6
+
+Section 8.47: DefaultIfEmpty
+
+var numbers = new[] {2,4,6,8,1,3,5,7};
+
+var numbersOrDefault = numbers.DefaultIfEmpty();
+Console.WriteLine(numbers.SequenceEqual(numbersOrDefault)); //True
+
+var noNumbers = new int[0];
+
+var noNumbersOrDefault = noNumbers.DefaultIfEmpty();
+Console.WriteLine(noNumbersOrDefault.Count()); //1
+Console.WriteLine(noNumbersOrDefault.Single()); //0
+
+var noNumbersOrExplicitDefault = noNumbers.DefaultIfEmpty(34);
+Console.WriteLine(noNumbersOrExplicitDefault.Count()); //1
+Console.WriteLine(noNumbersOrExplicitDefault.Single()); //34
+
+Section 8.48: Join
+
+class Developer
+{
+    public int Id { get; set; }
+    public string Name { get; set; }
+}
+
+class Project
+{
+    public int DeveloperId { get; set; }
+    public string Name { get; set; }
+}
+
+var developers = new[] {
+    new Developer {
+        Id = 1,
+        Name = "Foobuzz"
+    },
+    new Developer {
+        Id = 2,
+        Name = "Barfizz"
+    }
+};
+
+var projects = new[] {
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+43
+
+    new Project {
+        DeveloperId = 1,
+        Name = "Hello World 3D"
+    },
+    new Project {
+        DeveloperId = 1,
+        Name = "Super Fizzbuzz Maker"
+    },
+    new Project {
+        DeveloperId = 2,
+        Name = "Citizen Kane - The action game"
+    },
+    new Project {
+        DeveloperId = 2,
+        Name = "Pro Pong 2016"
+    }
+};
+
+var denormalized = developers.Join(
+    inner: projects,
+    outerKeySelector: dev => dev.Id,
+    innerKeySelector: proj => proj.DeveloperId,
+    resultSelector:
+        (dev, proj) => new {
+            ProjectName = proj.Name,
+            DeveloperName = dev.Name});
+
+foreach(var item in denormalized)
+{
+    Console.WriteLine("{0} by {1}", item.ProjectName, item.DeveloperName);
+}
+
+//Hello World 3D by Foobuzz
+//Super Fizzbuzz Maker by Foobuzz
+//Citizen Kane - The action game by Barfizz
+//Pro Pong 2016 by Barfizz
+
+Section 8.49: Left Outer Join
+
+class Person
+{
+    public string FirstName { get; set; }
+    public string LastName { get; set; }
+}
+
+class Pet
+{
+    public string Name { get; set; }
+    public Person Owner { get; set; }
+}
+
+public static void Main(string[] args)
+{
+    var magnus = new Person { FirstName = "Magnus", LastName = "Hedlund" };
+    var terry = new Person { FirstName = "Terry", LastName = "Adams" };
+
+    var barley = new Pet { Name = "Barley", Owner = terry };
+
+    var people = new[] { magnus, terry };
+    var pets = new[] { barley };
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+44
+
+   
+    var query =
+        from person in people
+        join pet in pets on person equals pet.Owner into gj
+        from subpet in gj.DefaultIfEmpty()
+        select new
+        {
+            person.FirstName,
+            PetName = subpet?.Name ?? "-" // Use - if he has no pet
+        };
+
+    foreach (var p in query)
+        Console.WriteLine($"{p.FirstName}: {p.PetName}");
+}
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+45
+
+Chapter 9: ForEach
+
+Section 9.1: Extension method for IEnumerable
+
+ForEach() is defined on the List<T> class, but not on IQueryable<T> or IEnumerable<T>. You have two choices in
+
+those cases:
+
+ToList first
+
+The enumeration (or query) will be evaluated, copying the results into a new list or calling the database. The
+
+method is then called on each item.
+
+IEnumerable<Customer> customers = new List<Customer>();
+
+customers.ToList().ForEach(c => c.SendEmail());
+
+This method has obvious memory usage overhead, as an intermediate list is created.
+
+Extension method
+
+Write an extension method:
+
+public static void ForEach<T>(this IEnumerable<T> enumeration, Action<T> action)
+{
+    foreach(T item in enumeration)
+    {
+        action(item);
+    }
+}
+
+Use:
+
+IEnumerable<Customer> customers = new List<Customer>();
+
+customers.ForEach(c => c.SendEmail());
+
+Caution: The Framework's LINQ methods have been designed with the intention of being pure, which means they
+
+do not produce side effects. The ForEach method's only purpose is to produce side effects, and deviates from the
+
+other methods in this aspect. You may consider just using a plain foreach loop instead.
+
+Section 9.2: Calling a method on an object in a list
+
+public class Customer {
+   public void SendEmail()
+   {
+       // Sending email code here
+   }
+}
+
+List<Customer> customers = new List<Customer>();
+
+customers.Add(new Customer());
+customers.Add(new Customer());
+
+customers.ForEach(c => c.SendEmail());
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+46
+
+Chapter 10: Reflection
+
+Section 10.1: What is an Assembly?
+
+Assemblies are the building block of any Common Language Runtime (CLR) application. Every type you define,
+
+together with its methods, properties and their bytecode, is compiled and packaged inside an Assembly.
+
+using System.Reflection;
+
+Assembly assembly = this.GetType().Assembly;  
+
+Assemblies are self-documenting: they do not only contain types, methods and their IL code, but also the Metadata
+
+necessary to inspect and consume them, both at compile and runtime:
+
+Assembly assembly = Assembly.GetExecutingAssembly();
+
+foreach (var type in assembly.GetTypes())
+{
+    Console.WriteLine(type.FullName);
+}
+
+Assemblies have names which describes their full, unique identity:
+
+Console.WriteLine(typeof(int).Assembly.FullName);
+// Will print: "mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"
+
+If this name includes a PublicKeyToken, it is called a strong name. Strong-naming an assembly is the process of
+
+creating a signature by using the private key that corresponds to the public key distributed with the assembly. This
+
+signature is added to the Assembly manifest, which contains the names and hashes of all the files that make up the
+
+assembly, and its PublicKeyToken becomes part of the name. Assemblies that have the same strong name should
+
+be identical; strong names are used in versioning and to prevent assembly conflicts.
+
+Section 10.2: Compare two objects with reflection
+
+public class Equatable
+{
+    public string field1;
+
+    public override bool Equals(object obj)
+    {
+        if (ReferenceEquals(null, obj)) return false;
+        if (ReferenceEquals(this, obj)) return true;
+
+        var type = obj.GetType();
+        if (GetType() != type)
+            return false;
+
+        var fields = type.GetFields(BindingFlags.Instance | BindingFlags.NonPublic |
+BindingFlags.Public);
+        foreach (var field in fields)
+            if (field.GetValue(this) != field.GetValue(obj))
+                return false;
+
+        return true;
+    }
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+47
+
+    public override int GetHashCode()
+    {
+        var accumulator = 0;
+        var fields = GetType().GetFields(BindingFlags.Instance | BindingFlags.NonPublic |
+BindingFlags.Public);
+        foreach (var field in fields)
+            accumulator = unchecked ((accumulator * 937) ^ field.GetValue(this).GetHashCode());
+
+        return accumulator;
+    }
+}
+
+Note: this example do a field based comparasion (ignore static fields and properties) for simplicity
+
+Section 10.3: Creating Object and setting properties using
+reflection
+
+Lets say we have a class Classy that has property Propertua
+
+public class Classy
+{
+    public string Propertua {get; set;}
+}
+
+to set Propertua using reflection:
+
+var typeOfClassy = typeof (Classy);
+var classy = new Classy();
+var prop = typeOfClassy.GetProperty("Propertua");
+prop.SetValue(classy, "Value");
+
+Section 10.4: How to create an object of T using Reflection
+
+Using the default constructor
+
+T variable = Activator.CreateInstance(typeof(T));
+
+Using parameterized constructor
+
+T variable = Activator.CreateInstance(typeof(T), arg1, arg2);
+
+Section 10.5: Getting an attribute of an enum with reflection
+(and caching it)
+
+Attributes can be useful for denoting metadata on enums. Getting the value of this can be slow, so it is important to
+
+cache results.
+
+    private static Dictionary<object, object> attributeCache = new Dictionary<object, object>();
+
+    public static T GetAttribute<T, V>(this V value)
+        where T : Attribute
+        where V : struct
+    {
+        object temp;
+
+        // Try to get the value from the static cache.
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+48
+
+        if (attributeCache.TryGetValue(value, out temp))
+        {
+            return (T) temp;
+        }
+        else
+        {
+            // Get the type of the struct passed in.
+            Type type = value.GetType();  
+            FieldInfo fieldInfo = type.GetField(value.ToString());
+
+            // Get the custom attributes of the type desired found on the struct.
+            T[] attribs = (T[])fieldInfo.GetCustomAttributes(typeof(T), false);
+
+            // Return the first if there was a match.
+            var result = attribs.Length > 0 ? attribs[0] : null;
+
+            // Cache the result so future checks won't need reflection.
+            attributeCache.Add(value, result);
+
+            return result;
+        }
+    }
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+49
+
+Chapter 11: Expression Trees
+
+Section 11.1: building a predicate of form field == value
+
+To build up an expression like _ => _.Field == "VALUE" at runtime.
+
+Given a predicate _ => _.Field and a string value "VALUE", create an expression that tests whether or not the
+
+predicate is true.
+
+The expression is suitable for:
+
+IQueryable<T>, IEnumerable<T> to test the predicate.
+
+entity framework or Linq to SQL to create a Where clause that tests the predicate.
+
+This method will build an appropriate Equal expression that tests whether or not Field equals "VALUE".
+
+public static Expression<Func<T, bool>> BuildEqualPredicate<T>(
+    Expression<Func<T, string>> memberAccessor,
+    string term)
+{
+    var toString = Expression.Convert(Expression.Constant(term), typeof(string));
+    Expression expression = Expression.Equal(memberAccessor.Body, toString);
+    var predicate = Expression.Lambda<Func<T, bool>>(
+        expression,
+        memberAccessor.Parameters);
+    return predicate;
+}
+
+The predicate can be used by including the predicate in a Where extension method.
+
+var predicate = PredicateExtensions.BuildEqualPredicate<Entity>(
+    _ => _.Field,
+    "VALUE");
+var results = context.Entity.Where(predicate).ToList();
+
+Section 11.2: Simple Expression Tree Generated by the C#
+Compiler
+
+Consider the following C# code
+
+Expression<Func<int, int>> expression = a => a + 1;
+
+Because the C# compiler sees that the lambda expression is assigned to an Expression type rather than a delegate
+
+type it generates an expression tree roughly equivalent to this code
+
+ParameterExpression parameterA = Expression.Parameter(typeof(int), "a");
+var expression = (Expression<Func<int, int>>)Expression.Lambda(
+                                                 Expression.Add(
+                                                     parameterA,
+                                                     Expression.Constant(1)),
+                                                 parameterA);
+
+The root of the tree is the lambda expression which contains a body and a list of parameters. The lambda has 1
+
+parameter called "a". The body is a single expression of CLR type BinaryExpression and NodeType of Add. This
+
+expression represents addition. It has two subexpressions denoted as Left and Right. Left is the
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+50
+
+ParameterExpression for the parameter "a" and Right is a ConstantExpression with the value 1.
+
+The simplest usage of this expression is printing it:
+
+Console.WriteLine(expression); //prints a => (a + 1)
+
+Which prints the equivalent C# code.
+
+The expression tree can be compiled into a C# delegate and executed by the CLR
+
+Func<int, int> lambda = expression.Compile();
+Console.WriteLine(lambda(2)); //prints 3
+
+Usually expressions are translated to other languages like SQL, but can be also used to invoke private, protected
+
+and internal members of public or non-public types as alternative to Reflection.
+
+Section 11.3: Expression for retrieving a static field
+
+Having example type like this:
+
+public TestClass
+{
+    public static string StaticPublicField = "StaticPublicFieldValue";
+}
+
+We can retrieve value of StaticPublicField:
+
+var fieldExpr = Expression.Field(null, typeof(TestClass), "StaticPublicField");
+var labmda = Expression.Lambda<Func<string>>(fieldExpr);
+
+It can be then i.e. compiled into a delegate for retrieving field value.
+
+Func<string> retriever = lambda.Compile();
+var fieldValue = retriever();
+
+//fieldValue result is StaticPublicFieldValue
+
+Section 11.4: InvocationExpression Class
+
+InvocationExpression class allows invocation of other lambda expressions that are parts of the same Expression
+
+tree.
+
+You create them with static Expression.Invoke method.
+
+Problem We want to get on the items which have "car" in their description. We need to check it for null before
+
+searching for a string inside but we don't want it to be called excessively, as the computation could be expensive.
+
+using System;
+using System.Linq;
+using System.Linq.Expressions;
+
+public class Program
+{
+    public static void Main()
+    {
+        var elements = new[] {
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+51
+
+                   
+            new Element { Description = "car" },
+            new Element { Description = "cargo" },
+            new Element { Description = "wheel" },
+            new Element { Description = null },
+            new Element { Description = "Madagascar" },
+        };
+
+        var elementIsInterestingExpression = CreateSearchPredicate(
+            searchTerm: "car",
+            whereToSearch: (Element e) => e.Description);
+
+        Console.WriteLine(elementIsInterestingExpression.ToString());
+
+        var elementIsInteresting = elementIsInterestingExpression.Compile();
+        var interestingElements = elements.Where(elementIsInteresting);
+        foreach (var e in interestingElements)
+        {
+            Console.WriteLine(e.Description);
+        }
+
+        var countExpensiveComputations = 0;
+        Action incCount = () => countExpensiveComputations++;
+        elements
+            .Where(
+                CreateSearchPredicate(
+                    "car",
+                    (Element e) => ExpensivelyComputed(
+                        e, incCount
+                    )
+                ).Compile()
+            )
+            .Count();
+
+        Console.WriteLine("Property extractor is called {0} times.", countExpensiveComputations);
+    }
+
+    private class Element
+    {
+        public string Description { get; set; }
+    }
+
+    private static string ExpensivelyComputed(Element source, Action count)
+    {
+        count();
+        return source.Description;
+    }
+
+    private static Expression<Func<T, bool>> CreateSearchPredicate<T>(
+            string searchTerm,
+            Expression<Func<T, string>> whereToSearch)
+    {
+        var extracted = Expression.Parameter(typeof(string), "extracted");
+
+        Expression<Func<string, bool>> coalesceNullCheckWithSearch =
+            Expression.Lambda<Func<string, bool>>(
+                Expression.AndAlso(
+                    Expression.Not(
+                        Expression.Call(typeof(string), "IsNullOrEmpty", null, extracted)
+                    ),
+                    Expression.Call(extracted, "Contains", null, Expression.Constant(searchTerm))
+                ),
+                extracted);
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+52
+
+   
+           
+           
+       
+                   
+   
+   
+   
+   
+        var elementParameter = Expression.Parameter(typeof(T), "element");
+
+        return Expression.Lambda<Func<T, bool>>(
+            Expression.Invoke(
+                coalesceNullCheckWithSearch,
+                Expression.Invoke(whereToSearch, elementParameter)
+            ),
+            elementParameter
+        );
+    }
+}
+
+Output
+
+element => Invoke(extracted => (Not(IsNullOrEmpty(extracted)) AndAlso extracted.Contains("car")),
+Invoke(e => e.Description, element))
+car
+cargo
+Madagascar
+Predicate is called 5 times.
+
+First thing to note is how the actual propery access, wrapped in an Invoke:
+
+Invoke(e => e.Description, element)
+
+, and this is the only part that touches e.Description, and in place of it, extracted parameter of type string is
+
+passed to the next one:
+
+(Not(IsNullOrEmpty(extracted)) AndAlso extracted.Contains("car"))
+
+Another important thing to note here is AndAlso. It computes only the left part, if the first part returns 'false'. It's a
+
+common mistake to use the bitwise operator 'And' instead of it, which always computes both parts, and would fail
+
+with a NullReferenceException in this example.
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+53
+
+               
+               
+Chapter 12: Custom Types
+
+Section 12.1: Struct Definition
+
+Structs inherit from System.ValueType, are value types, and live on the stack. When value types are passed
+
+as a parameter, they are passed by value.
+
+Struct MyStruct
+{
+    public int x;
+    public int y;
+}
+
+Passed by value means that the value of the parameter is copied for the method, and any changes made to the
+parameter in the method are not reflected outside of the method. For instance, consider the following code, which
+
+calls a method named AddNumbers, passing in the variables a and b, which are of type int, which is a Value type.
+
+int a = 5;
+int b = 6;
+
+AddNumbers(a,b);
+
+public AddNumbers(int x, int y)
+{
+    int z = x + y; // z becomes 11
+    x = x + 5; // now we changed x to be 10
+    z = x + y; // now z becomes 16
+}
+
+Even though we added 5 to x inside the method, the value of a remains unchanged, because it's a Value type, and
+that means x was a copy of a's value, but not actually a.
+
+Remember, Value types live on the stack, and are passed by value.
+
+Section 12.2: Class Definition
+
+Classes inherit from System.Object, are reference types, and live on the heap. When reference types are
+
+passed as a parameter, they are passed by reference.
+
+public Class MyClass
+{
+    public int a;
+    public int b;
+}
+
+Passed by reference means that a reference to the parameter is passed to the method, and any changes to the
+parameter will be reflected outside of the method when it returns, because the reference is to the exact same object
+in memory. Let's use the same example as before, but we'll "wrap" the ints in a class first.
+
+MyClass instanceOfMyClass = new MyClass();
+instanceOfMyClass.a = 5;
+instanceOfMyClass.b = 6;
+
+AddNumbers(instanceOfMyClass);
+
+public AddNumbers(MyClass sample)
+{
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+54
+
+    int z = sample.a + sample.b; // z becomes 11
+    sample.a = sample.a + 5; // now we changed a to be 10
+    z = sample.a + sample.b; // now z becomes 16
+}
+
+This time, when we changed sample.a to 10, the value of instanceOfMyClass.a also changes, because it was passed
+by reference. Passed by reference means that a reference (also sometimes called a pointer) to the object was passed
+
+into the method, instead of a copy of the object itself.
+
+Remember, Reference types live on the heap, and are passed by reference.
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+55
+
+Chapter 13: Code Contracts
+
+Section 13.1: Contracts for Interfaces
+
+Using Code Contracts it is possible to apply a contract to an interface. This is done by declaring an abstract class
+
+that implments the interfaces. The interface should be tagged with the ContractClassAttribute and the contract
+
+definition (the abstract class) should be tagged with the ContractClassForAttribute
+
+C# Example...
+
+[ContractClass(typeof(MyInterfaceContract))]
+public interface IMyInterface
+{
+    string DoWork(string input);
+}
+//Never inherit from this contract defintion class
+[ContractClassFor(typeof(IMyInterface))]
+internal abstract class MyInterfaceContract : IMyInterface
+{
+    private MyInterfaceContract() { }
+
+    public string DoWork(string input)
+    {
+        Contract.Requires(!string.IsNullOrEmpty(input));
+        Contract.Ensures(!string.IsNullOrEmpty(Contract.Result<string>()));
+        throw new NotSupportedException();
+    }
+}
+public class MyInterfaceImplmentation : IMyInterface
+{
+    public string DoWork(string input)
+    {
+        return input;
+    }
+}
+
+Static Analysis Result...
+
+Section 13.2: Installing and Enabling Code Contracts
+
+While System.Diagnostics.Contracts is included within the .Net Framework. To use Code Contracts you must
+
+install the Visual Studio extensions.
+
+Under Extensions and Updates search for Code Contracts then install the Code Contracts Tools
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+56
+
+After the tools are installed you must enable Code Contracts within your Project solution. At the minimum you
+
+probably want to enable the Static Checking (check after build). If you are implementing a library that will be used
+
+by other solutions you may want to consider also enabling Runtime Checking.
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+57
+
+Section 13.3: Preconditions
+
+Preconditions allows methods to provide minimum required values for input parameters
+
+Example...
+
+void DoWork(string input)
+{
+    Contract.Requires(!string.IsNullOrEmpty(input));
+
+    //do work
+}
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+58
+
+Static Analysis Result...
+
+Section 13.4: Postconditions
+
+Postconditions ensure that the returned results from a method will match the provided definition. This provides the
+
+caller with a definition of the expected result. Postconditions may allowed for simplied implmentations as some
+
+possible outcomes can be provided by the static analyizer.
+
+Example...
+
+string GetValue()
+{
+    Contract.Ensures(Contract.Result<string>() != null);
+
+    return null;
+}
+
+Static Analyis Result...
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+59
+
+Chapter 14: Settings
+
+Section 14.1: AppSettings from ConfigurationSettings in .NET
+1.x
+
+Deprecated usage
+
+The ConfigurationSettings class was the original way to retrieve settings for an assembly in .NET 1.0 and 1.1. It has
+
+been superseded by the ConfigurationManager class and the WebConfigurationManager class.
+
+If you have two keys with the same name in the appSettings section of the configuration file, the last one is used.
+
+app.config
+
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+  <appSettings>
+    <add key="keyName" value="anything, as a string"/>
+    <add key="keyNames" value="123"/>
+    <add key="keyNames" value="234"/>
+  </appSettings>
+</configuration>
+
+Program.cs
+
+using System;
+using System.Configuration;
+using System.Diagnostics;
+
+namespace ConsoleApplication1
+{
+    class Program
+    {
+        static void Main()
+        {
+            string keyValue = ConfigurationSettings.AppSettings["keyName"];
+            Debug.Assert("anything, as a string".Equals(keyValue));
+
+            string twoKeys = ConfigurationSettings.AppSettings["keyNames"];
+            Debug.Assert("234".Equals(twoKeys));
+
+            Console.ReadKey();
+        }
+    }
+}
+
+Section 14.2: Reading AppSettings from
+ConfigurationManager in .NET 2.0 and later
+
+The ConfigurationManager class supports the AppSettings property, which allows you to continue reading settings
+
+from the appSettings section of a configuration file the same way as .NET 1.x supported.
+
+app.config
+
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+60
+
+  <appSettings>
+    <add key="keyName" value="anything, as a string"/>
+    <add key="keyNames" value="123"/>
+    <add key="keyNames" value="234"/>
+  </appSettings>
+</configuration>
+
+Program.cs
+
+using System;
+using System.Configuration;
+using System.Diagnostics;
+
+namespace ConsoleApplication1
+{
+    class Program
+    {
+        static void Main()
+        {
+            string keyValue = ConfigurationManager.AppSettings["keyName"];
+            Debug.Assert("anything, as a string".Equals(keyValue));
+
+            var twoKeys = ConfigurationManager.AppSettings["keyNames"];
+            Debug.Assert("234".Equals(twoKeys));
+
+            Console.ReadKey();
+        }
+    }
+}
+
+Section 14.3: Introduction to strongly-typed application and
+user settings support from Visual Studio
+
+Visual Studio helps manage user and application settings. Using this approach has these benefits over using the
+
+appSettings section of the configuration file.
+
+1.
+
+Settings can be made strongly typed. Any type which can be serialized can be used for a settings value.
+
+2.
+
+Application settings can be easily separated from user settings. Application settings are stored in a single
+
+configuration file: web.config for Web sites and Web applications, and app.config, renamed as
+assembly.exe.config, where assembly is the name of the executable. User settings (not used by Web projects)
+
+are stored in a user.config file in the user's Application Data folder (which varies with the operating system
+
+version).
+
+3.
+
+Application settings from class libraries can be combined into a single configuration file without risk of name
+
+collisions, since each class library can have its own custom settings section.
+
+In most project types, the Project Properties Designer has a Settings tab which is the starting point for creating
+
+custom application and user settings. Initially, the Settings tab will be blank, with a single link to create a default
+
+settings file. Clicking the link results in these changes:
+
+1.
+
+If a configuration file (app.config or web.config) does not exist for the project, one will be created.
+
+2.
+
+The Settings tab will be replaced with a grid control which enables you to create, edit, and delete individual
+
+settings entries.
+
+3.
+
+In Solution Explorer, a Settings.settings item is added under the Properties special folder. Opening this
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+61
+
+item will open the Settings tab.
+
+4.
+
+A new file with a new partial class is added under the Properties folder in the project folder. This new file is
+
+named Settings.Designer.__ (.cs, .vb, etc.), and the class is named Settings. The class is code-generated,
+
+so it should not be edited, but the class is a partial class, so you can extend the class by putting additional
+
+members in a separate file. Furthermore, the class is implemented using the Singleton Pattern, exposing the
+
+singleton instance with the property named Default.
+
+As you add each new entry to the Settings tab, Visual Studio does these two things:
+
+1.
+
+Saves the setting in the configuration file, in a custom configuration section designed to be managed by the
+
+Settings class.
+
+2.
+
+Creates a new member in the Settings class to read, write, and present the setting in the specific type
+
+selected from the Settings tab.
+
+Section 14.4: Reading strongly-typed settings from custom
+section of configuration file
+
+Starting from a new Settings class and custom configuration section:
+
+Add an application setting named ExampleTimeout, using the time System.Timespan, and set the value to 1 minute:
+
+Save the Project Properties, which saves the Settings tab entries, as well as re-generates the custom Settings class
+
+and updates the project configuration file.
+
+Use the setting from code (C#):
+
+Program.cs
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+62
+
+using System;
+using System.Diagnostics;
+using ConsoleApplication1.Properties;
+
+namespace ConsoleApplication1
+{
+    class Program
+    {
+        static void Main()
+        {
+            TimeSpan exampleTimeout = Settings.Default.ExampleTimeout;
+            Debug.Assert(TimeSpan.FromMinutes(1).Equals(exampleTimeout));
+
+            Console.ReadKey();
+        }
+    }
+}
+
+Under the covers
+
+Look in the project configuration file to see how the application setting entry has been created:
+
+app.config (Visual Studio updates this automatically)
+
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+  <configSections>
+    <sectionGroup name="applicationSettings" type="System.Configuration.ApplicationSettingsGroup,
+System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" >
+      <section name="ConsoleApplication1.Properties.Settings"
+type="System.Configuration.ClientSettingsSection, System, Version=4.0.0.0, Culture=neutral,
+PublicKeyToken=b77a5c561934e089" requirePermission="false" />
+    </sectionGroup>
+  </configSections>
+  <appSettings />
+  <applicationSettings>
+    <ConsoleApplication1.Properties.Settings>
+      <setting name="ExampleTimeout" serializeAs="String">
+        <value>00:01:00</value>
+      </setting>
+    </ConsoleApplication1.Properties.Settings>
+  </applicationSettings>
+</configuration>
+
+Notice that the appSettings section is not used. The applicationSettings section contains a custom namespace-
+
+qualified section that has a setting element for each entry. The type of the value is not stored in the configuration
+
+file; it is only known by the Settings class.
+
+Look in the Settings class to see how it uses the ConfigurationManager class to read this custom section.
+
+Settings.designer.cs (for C# projects)
+
+...
+    [global::System.Configuration.ApplicationScopedSettingAttribute()]
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    [global::System.Configuration.DefaultSettingValueAttribute("00:01:00")]
+    public global::System.TimeSpan ExampleTimeout {
+        get {
+            return ((global::System.TimeSpan)(this["ExampleTimeout"]));
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+63
+
+        }
+    }
+...
+
+Notice that a DefaultSettingValueAttribute was created to stored the value entered in the Settings tab of the
+
+Project Properties Designer. If the entry is missing from the configuration file, this default value is used instead.
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+64
+
+Chapter 15: Regular Expressions
+(System.Text.RegularExpressions)
+
+Section 15.1: Check if pattern matches input
+
+public bool Check()
+{
+    string input = "Hello World!";
+    string pattern = @"H.ll. W.rld!";
+
+    // true
+    return Regex.IsMatch(input, pattern);
+}
+
+Section 15.2: Remove non alphanumeric characters from
+string
+
+public string Remove()
+{
+    string input = "Hello./!";
+
+    return Regex.Replace(input, "[^a-zA-Z0-9]", "");
+}
+
+Section 15.3: Passing Options
+
+public bool Check()
+{
+    string input = "Hello World!";
+    string pattern = @"H.ll. W.rld!";
+
+    // true
+    return Regex.IsMatch(input, pattern, RegexOptions.IgnoreCase | RegexOptions.Singleline);
+}
+
+Section 15.4: Match into groups
+
+public string Check()
+{
+    string input = "Hello World!";
+    string pattern = @"H.ll. (?<Subject>W.rld)!";
+
+    Match match = Regex.Match(input, pattern);
+
+    // World
+    return match.Groups["Subject"].Value;
+}
+
+Section 15.5: Find all matches
+
+Using
+
+using System.Text.RegularExpressions;
+
+Code
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+65
+
+   
+static void Main(string[] args)
+{
+    string input = "Carrot Banana Apple Cherry Clementine Grape";
+    // Find words that start with uppercase 'C'
+    string pattern = @"\bC\w*\b";
+
+    MatchCollection matches = Regex.Matches(input, pattern);
+    foreach (Match m in matches)
+        Console.WriteLine(m.Value);
+}
+
+Output
+
+Carrot
+Cherry
+Clementine
+
+Section 15.6: Simple match and replace
+
+public string Check()
+{
+    string input = "Hello World!";
+    string pattern = @"W.rld";
+
+    // Hello Stack Overflow!
+    return Regex.Replace(input, pattern, "Stack Overflow");
+}
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+66
+
+Chapter 16: File Input/Output
+
+Parameter
+string path Path of the file to check. (relative or fully qualified)
+
+Details
+
+Section 16.1: C# File.Exists()
+
+using System;
+using System.IO;
+
+public class Program
+{
+    public static void Main()
+    {
+        string filePath = "somePath";
+
+        if(File.Exists(filePath))
+        {
+            Console.WriteLine("Exists");
+        }
+        else
+        {
+            Console.WriteLine("Does not exist");    
+        }
+    }
+}
+
+Can also be used in a ternary operator.
+
+Console.WriteLine(File.Exists(pathToFile) ? "Exists" : "Does not exist");
+
+Section 16.2: VB WriteAllText
+
+Imports System.IO
+
+Dim filename As String = "c:\path\to\file.txt"
+File.WriteAllText(filename, "Text to write" & vbCrLf)
+
+Section 16.3: VB StreamWriter
+
+Dim filename As String = "c:\path\to\file.txt"
+If System.IO.File.Exists(filename) Then
+    Dim writer As New System.IO.StreamWriter(filename)
+    writer.Write("Text to write" & vbCrLf) 'Add a newline
+    writer.close()
+End If
+
+Section 16.4: C# StreamWriter
+
+using System.Text;
+using System.IO;
+
+string filename = "c:\path\to\file.txt";
+//'using' structure allows for proper disposal of stream.
+using (StreamWriter writer = new StreamWriter(filename"))
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+67
+
+               
+   
+{
+    writer.WriteLine("Text to Write\n");
+}
+
+Section 16.5: C# WriteAllText()
+
+using System.IO;
+using System.Text;
+
+string filename = "c:\path\to\file.txt";
+File.writeAllText(filename, "Text to write\n");
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+68
+
+Chapter 17: System.IO
+
+Section 17.1: Reading a text file using StreamReader
+
+string fullOrRelativePath = "testfile.txt";
+
+string fileData;
+
+using (var reader = new StreamReader(fullOrRelativePath))
+{
+    fileData = reader.ReadToEnd();
+}
+
+Note that this StreamReader constructor overload does some auto encoding detection, which may or may not
+
+conform to the actual encoding used in the file.
+
+Please note that there are some convenience methods that read all text from file available on the System.IO.File
+
+class, namely File.ReadAllText(path) and File.ReadAllLines(path).
+
+Section 17.2: Serial Ports using System.IO.SerialPorts
+
+Iterating over connected serial ports
+
+using System.IO.Ports;
+string[] ports = SerialPort.GetPortNames();
+for (int i = 0; i < ports.Length; i++)
+{
+    Console.WriteLine(ports[i]);
+}
+
+Instantiating a System.IO.SerialPort object
+
+using System.IO.Ports;
+SerialPort port = new SerialPort();
+SerialPort port = new SerialPort("COM 1"); ;
+SerialPort port = new SerialPort("COM 1", 9600);
+
+NOTE: Those are just three of the seven overloads of the constructor for the SerialPort type.
+
+Reading/Writing data over the SerialPort
+
+The simplest way is to use the SerialPort.Read and SerialPort.Write methods. However you can also retrieve a
+
+System.IO.Stream object which you can use to stream data over the SerialPort. To do this, use
+
+SerialPort.BaseStream.
+
+Reading
+
+int length = port.BytesToRead;
+//Note that you can swap out a byte-array for a char-array if you prefer.
+byte[] buffer = new byte[length];
+port.Read(buffer, 0, length);
+
+You can also read all data available:
+
+string curData = port.ReadExisting();
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+69
+
+Or simply read to the first newline encountered in the incoming data:
+
+string line = port.ReadLine();
+
+Writing
+
+The easiest way to write data over the SerialPort is:
+
+port.Write("here is some text to be sent over the serial port.");
+
+However you can also send data over like this when needed:
+
+//Note that you can swap out the byte-array with a char-array if you so choose.
+byte[] data = new byte[1] { 255 };
+port.Write(data, 0, data.Length);
+
+Section 17.3: Reading/Writing Data Using System.IO.File
+
+First, let's see three different ways of extracting data from a file.
+
+string fileText = File.ReadAllText(file);
+string[] fileLines = File.ReadAllLines(file);
+byte[] fileBytes = File.ReadAllBytes(file);
+
+On the first line, we read all the data in the file as a string.
+
+On the second line, we read the data in the file into a string-array. Each line in the file becomes an element in
+
+the array.
+
+On the third we read the bytes from the file.
+
+Next, let's see three different methods of appending data to a file. If the file you specify doesn't exist, each method
+will automatically create the file before attempting to append the data to it.
+
+ File.AppendAllText(file, "Here is some data that is\nappended to the file.");
+ File.AppendAllLines(file, new string[2] { "Here is some data that is", "appended to the file." });
+ using (StreamWriter stream = File.AppendText(file))
+ {
+     stream.WriteLine("Here is some data that is");
+     stream.Write("appended to the file.");
+ }
+
+On the first line we simply add a string to the end of the specified file.
+
+On the second line we add each element of the array onto a new line in the file.
+
+Finally on the third line we use File.AppendText to open up a streamwriter which will append whatever data
+
+is written to it.
+
+And lastly, let's see three different methods of writing data to a file. The difference between appending and writing
+
+being that writing over-writes the data in the file while appending adds to the data in the file. If the file you specify
+doesn't exist, each method will automatically create the file before attempting to write the data to it.
+
+File.WriteAllText(file, "here is some data\nin this file.");
+File.WriteAllLines(file, new string[2] { "here is some data", "in this file" });
+File.WriteAllBytes(file, new byte[2] { 0, 255 });
+
+The first line writes a string to the file.
+
+The second line writes each string in the array on it's own line in the file.
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+70
+
+And the third line allows you to write a byte array to the file.
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+71
+
+Chapter 18: System.IO.File class
+
+Parameter
+source
+
+The file that is to be moved to another location.
+
+Details
+
+destination
+
+The directory in which you would like to move source to (this variable should also contain the name
+(and file extension) of the file.
+
+Section 18.1: Delete a file
+
+To delete a file (if you have required permissions) is as simple as:
+
+File.Delete(path);
+
+However many things may go wrong:
+
+You do not have required permissions (UnauthorizedAccessException is thrown).
+
+File may be in use by someone else (IOException is thrown).
+
+File cannot be deleted because of low level error or media is read-only (IOException is thrown).
+
+File does not exist anymore (IOException is thrown).
+
+Note that last point (file does not exist) is usually circumvented with a code snippet like this:
+
+if (File.Exists(path))
+    File.Delete(path);
+
+However it's not an atomic operation and file may be delete by someone else between the call to File.Exists()
+
+and before File.Delete(). Right approach to handle I/O operation requires exception handling (assuming an
+
+alternative course of actions may be taken when operation fails):
+
+if (File.Exists(path))
+{
+    try
+    {
+        File.Delete(path);
+    }
+    catch (IOException exception)
+    {
+        if (!File.Exists(path))
+            return; // Someone else deleted this file
+
+        // Something went wrong...
+    }
+    catch (UnauthorizedAccessException exception)
+    {
+        // I do not have required permissions
+    }
+}
+
+Note that this I/O errors sometimes are transitory (file in use, for example) and if a network connection is involved
+then it may automatically recover without any action from our side. It's then common to retry an I/O operation few
+
+times with a small delay between each attempt:
+
+public static void Delete(string path)
+{
+    if (!File.Exists(path))
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+72
+
+        return;
+
+    for (int i=1; ; ++i)
+    {
+        try
+        {
+            File.Delete(path);
+            return;
+        }
+        catch (IOException e)
+        {
+            if (!File.Exists(path))
+                return;
+
+            if (i == NumberOfAttempts)
+                throw;
+
+            Thread.Sleep(DelayBetweenEachAttempt);
+        }
+
+        // You may handle UnauthorizedAccessException but this issue
+        // will probably won't be fixed in few seconds...
+    }
+}
+
+private const int NumberOfAttempts = 3;
+private const int DelayBetweenEachAttempt = 1000; // ms
+
+Note: in Windows environment file will not be really deleted when you call this function, if someone else open the
+
+file using FileShare.Delete then file can be deleted but it will effectively happen only when owner will close the
+
+file.
+
+Section 18.2: Strip unwanted lines from a text file
+
+To change a text file is not easy because its content must be moved around. For small files easiest method is to
+
+read its content in memory and then write back modified text.
+
+In this example we read all lines from a file and drop all blank lines then we write back to original path:
+
+File.WriteAllLines(path,
+    File.ReadAllLines(path).Where(x => !String.IsNullOrWhiteSpace(x)));
+
+If file is too big to load it in memory and output path is different from input path:
+
+File.WriteAllLines(outputPath,
+    File.ReadLines(inputPath).Where(x => !String.IsNullOrWhiteSpace(x)));
+
+Section 18.3: Convert text file encoding
+
+Text is saved encoded (see also Strings topic) then sometimes you may need to change its encoding, this example
+
+assumes (for simplicity) that file is not too big and it can be entirely read in memory:
+
+public static void ConvertEncoding(string path, Encoding from, Encoding to)
+{
+    File.WriteAllText(path, File.ReadAllText(path, from), to);
+}
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+73
+
+When performing conversions do not forget that file may contain BOM (Byte Order Mark), to better understand
+
+how it's managed refer to Encoding.UTF8.GetString doesn't take into account the Preamble/BOM.
+
+Section 18.4: Enumerate files older than a specified amount
+
+This snippet is an helper function to enumerate all files older than a specified age, it's useful - for example - when
+
+you have to delete old log files or old cached data.
+
+static IEnumerable<string> EnumerateAllFilesOlderThan(
+                               TimeSpan maximumAge,
+                               string path,
+                               string searchPattern = "*.*",
+                               SearchOption options = SearchOption.TopDirectoryOnly)
+{
+    DateTime oldestWriteTime = DateTime.Now - maximumAge;
+
+    return Directory.EnumerateFiles(path, searchPattern, options)
+        .Where(x => Directory.GetLastWriteTime(x) < oldestWriteTime);
+}
+
+Used like this:
+
+var oldFiles = EnumerateAllFilesOlderThan(TimeSpan.FromDays(7), @"c:\log", "*.log");
+
+Few things to note:
+
+Search is performed using Directory.EnumerateFiles() instead of Directory.GetFiles(). Enumeration is
+alive then you won't need to wait until all file system entries have been fetched.
+
+We're checking for last write time but you may use creation time or last access time (for example to delete
+unused cached files, note that access time may be disabled).
+
+Granularity isn't uniform for all those properties (write time, access time, creation time), check MSDN for
+
+details about this.
+
+Section 18.5: Move a File from one location to another
+
+File.Move
+
+In order to move a file from one location to another, one simple line of code can achieve this:
+
+File.Move(@"C:\TemporaryFile.txt", @"C:\TemporaryFiles\TemporaryFile.txt");
+
+However, there are many things that could go wrong with this simple operation. For instance, what if the user
+
+running your program does not have a Drive that is labelled 'C'? What if they did - but they decided to rename it to
+
+'B', or 'M'?
+
+What if the Source file (the file in which you would like to move) has been moved without your knowing - or what if
+
+it simply doesn't exist.
+
+This can be circumvented by first checking to see whether the source file does exist:
+
+string source = @"C:\TemporaryFile.txt", destination = @"C:\TemporaryFiles\TemporaryFile.txt";
+if(File.Exists("C:\TemporaryFile.txt"))
+{
+    File.Move(source, destination);
+}
+
+This will ensure that at that very moment, the file does exist, and can be moved to another location. There may be
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+74
+
+times where a simple call to File.Exists won't be enough. If it isn't, check again, convey to the user that the
+
+operation failed - or handle the exception.
+
+A FileNotFoundException is not the only exception you are likely to encounter.
+
+See below for possible exceptions:
+
+Exception Type
+
+Description
+
+IOException
+
+The file already exists or the source file could not be found.
+
+ArgumentNullException
+
+The value of the Source and/or Destination parameters is null.
+
+ArgumentException
+
+The value of the Source and/or Destination parameters are empty, or contain
+invalid characters.
+
+UnauthorizedAccessException You do not have the required permissions in order to perform this action.
+
+PathTooLongException
+
+The Source, Destination or specified path(s) exceed the maximum length. On
+Windows, a Path's length must be less than 248 characters, while File names must
+be less than 260 characters.
+
+DirectoryNotFoundException The specified directory could not be found.
+
+NotSupportedException
+
+The Source or Destination paths or file names are in an invalid format.
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+75
+
+Chapter 19: Reading and writing Zip files
+
+The ZipFile class lives in the System.IO.Compression namespace. It can be used to read from, and write to Zip
+files.
+
+Section 19.1: Listing ZIP contents
+
+This snippet will list all the filenames of a zip archive. The filenames are relative to the zip root.
+
+using (FileStream fs = new FileStream("archive.zip", FileMode.Open))
+using (ZipArchive archive = new ZipArchive(fs, ZipArchiveMode.Read))
+{
+    for (int i = 0; i < archive.Entries.Count; i++)
+    {
+        Console.WriteLine($"{i}: {archive.Entries[i]}");
+    }
+}
+
+Section 19.2: Extracting files from ZIP files
+
+Extracting all the files into a directory is very easy:
+
+using (FileStream fs = new FileStream("archive.zip", FileMode.Open))
+using (ZipArchive archive = new ZipArchive(fs, ZipArchiveMode.Read))
+{
+    archive.ExtractToDirectory(AppDomain.CurrentDomain.BaseDirectory);
+}
+
+When the file already exists, a System.IO.IOException will be thrown.
+
+Extracting specific files:
+
+using (FileStream fs = new FileStream("archive.zip", FileMode.Open))
+using (ZipArchive archive = new ZipArchive(fs, ZipArchiveMode.Read))
+{
+    // Get a root entry file
+    archive.GetEntry("test.txt").ExtractToFile("test_extracted_getentries.txt", true);
+
+    // Enter a path if you want to extract files from a subdirectory
+    archive.GetEntry("sub/subtest.txt").ExtractToFile("test_sub.txt", true);
+
+    // You can also use the Entries property to find files
+    archive.Entries.FirstOrDefault(f => f.Name ==
+"test.txt")?.ExtractToFile("test_extracted_linq.txt", true);
+
+    // This will throw a System.ArgumentNullException because the file cannot be found
+    archive.GetEntry("nonexistingfile.txt").ExtractToFile("fail.txt", true);
+}
+
+Any of these methods will produce the same result.
+
+Section 19.3: Updating a ZIP file
+
+To update a ZIP file, the file has to be opened with ZipArchiveMode.Update instead.
+
+using (FileStream fs = new FileStream("archive.zip", FileMode.Open))
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+76
+
+using (ZipArchive archive = new ZipArchive(fs, ZipArchiveMode.Update))
+{
+    // Add file to root
+    archive.CreateEntryFromFile("test.txt", "test.txt");
+
+    // Add file to subfolder
+    archive.CreateEntryFromFile("test.txt", "symbols/test.txt");
+}
+
+There is also the option to write directly to a file within the archive:
+
+var entry = archive.CreateEntry("createentry.txt");
+using(var writer = new StreamWriter(entry.Open()))
+{
+    writer.WriteLine("Test line");
+}
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+77
+
+Chapter 20: Managed Extensibility
+Framework
+
+Section 20.1: Connecting (Basic)
+
+See the other (Basic) examples above.
+
+using System.ComponentModel.Composition;
+using System.ComponentModel.Composition.Hosting;
+
+namespace Demo
+{
+    public static class Program
+    {
+        public static void Main()
+        {
+            using (var catalog = new ApplicationCatalog())
+            using (var exportProvider = new CatalogExportProvider(catalog))
+            using (var container = new CompositionContainer(exportProvider))
+            {
+                exportProvider.SourceProvider = container;
+
+                UserWriter writer = new UserWriter();
+
+                // at this point, writer's userProvider field is null
+                container.ComposeParts(writer);
+
+                // now, it should be non-null (or an exception will be thrown).
+                writer.PrintAllUsers();
+            }
+        }
+    }
+}
+
+As long as something in the application's assembly search path has [Export(typeof(IUserProvider))],
+
+UserWriter's corresponding import will be satisfied and the users will be printed.
+
+Other types of catalogs (e.g., DirectoryCatalog) can be used instead of (or in addition to) ApplicationCatalog, to
+
+look in other places for exports that satisfy the imports.
+
+Section 20.2: Exporting a Type (Basic)
+
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.ComponentModel.Composition;
+
+namespace Demo
+{
+    [Export(typeof(IUserProvider))]
+    public sealed class UserProvider : IUserProvider
+    {
+        public ReadOnlyCollection<User> GetAllUsers()
+        {
+            return new List<User>
+            {
+                new User(0, "admin"),
+                new User(1, "Dennis"),
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+78
+
+                new User(2, "Samantha"),
+            }.AsReadOnly();
+        }
+    }
+}
+
+This could be defined virtually anywhere; all that matters is that the application knows where to look for it (via the
+
+ComposablePartCatalogs it creates).
+
+Section 20.3: Importing (Basic)
+
+using System;
+using System.ComponentModel.Composition;
+
+namespace Demo
+{
+    public sealed class UserWriter
+    {
+        [Import(typeof(IUserProvider))]
+        private IUserProvider userProvider;
+
+        public void PrintAllUsers()
+        {
+            foreach (User user in this.userProvider.GetAllUsers())
+            {
+                Console.WriteLine(user);
+            }
+        }
+    }
+}
+
+This is a type that has a dependency on an IUserProvider, which could be defined anywhere. Like the previous
+
+example, all that matters is that the application knows where to look for the matching export (via the
+
+ComposablePartCatalogs it creates).
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+79
+
+Chapter 21: SpeechRecognitionEngine class
+to recognize speech
+
+LoadGrammar: Parameters
+
+grammar
+
+Details
+The grammar to load. For example, a DictationGrammar object to allow free
+text dictation.
+
+RecognizeAsync: Parameters
+
+Details
+
+mode
+
+The RecognizeMode for the current recognition: Single for just one
+recognition, Multiple to allow multiple.
+
+GrammarBuilder.Append: Parameters Details
+
+choices
+
+Appends some choices to the grammar builder. This means that, when the
+user inputs speech, the recognizer can follow different "branches" from a
+grammar.
+
+Choices constructor: Parameters
+
+Details
+
+choices
+
+An array of choices for the grammar builder. See GrammarBuilder.Append.
+
+Grammar constructor: Parameter
+
+Details
+
+builder
+
+The GrammarBuilder to construct a Grammar from.
+
+Section 21.1: Asynchronously recognizing speech based on a
+restricted set of phrases
+
+SpeechRecognitionEngine recognitionEngine = new SpeechRecognitionEngine();
+GrammarBuilder builder = new GrammarBuilder();
+builder.Append(new Choices("I am", "You are", "He is", "She is", "We are", "They are"));
+builder.Append(new Choices("friendly", "unfriendly"));
+recognitionEngine.LoadGrammar(new Grammar(builder));
+recognitionEngine.SpeechRecognized += delegate(object sender, SpeechRecognizedEventArgs e)
+{
+    Console.WriteLine("You said: {0}", e.Result.Text);
+};
+recognitionEngine.SetInputToDefaultAudioDevice();
+recognitionEngine.RecognizeAsync(RecognizeMode.Multiple);
+
+Section 21.2: Asynchronously recognizing speech for free text
+dictation
+
+using System.Speech.Recognition;
+
+// ...
+
+SpeechRecognitionEngine recognitionEngine = new SpeechRecognitionEngine();
+recognitionEngine.LoadGrammar(new DictationGrammar());
+recognitionEngine.SpeechRecognized += delegate(object sender, SpeechRecognizedEventArgs e)
+{
+    Console.WriteLine("You said: {0}", e.Result.Text);
+};
+recognitionEngine.SetInputToDefaultAudioDevice();
+recognitionEngine.RecognizeAsync(RecognizeMode.Multiple);
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+80
+
+Chapter 22:
+System.Runtime.Caching.MemoryCache
+(ObjectCache)
+
+Section 22.1: Adding Item to Cache (Set)
+
+Set function inserts a cache entry into the cache by using a CacheItem instance to supply the key and value for the
+
+cache entry.
+
+This function Overrides ObjectCache.Set(CacheItem, CacheItemPolicy)
+
+private static bool SetToCache()
+{
+    string key = "Cache_Key";
+    string value = "Cache_Value";
+
+    //Get a reference to the default MemoryCache instance.
+    var cacheContainer = MemoryCache.Default;
+
+    var policy = new CacheItemPolicy()
+    {
+        AbsoluteExpiration = DateTimeOffset.Now.AddMinutes(DEFAULT_CACHE_EXPIRATION_MINUTES)
+     };
+     var itemToCache = new CacheItem(key, value); //Value is of type object.
+     cacheContainer.Set(itemToCache, policy);                
+}
+
+Section 22.2: System.Runtime.Caching.MemoryCache
+(ObjectCache)
+
+This function gets existing item form cache, and if the item don't exist in cache, it will fetch item based on the
+
+valueFetchFactory function.
+
+    public static TValue GetExistingOrAdd<TValue>(string key, double minutesForExpiration,
+Func<TValue> valueFetchFactory)
+    {            
+        try
+        {
+            //The Lazy class provides Lazy initialization which will evaluate
+            //the valueFetchFactory only if item is not in the cache.
+            var newValue = new Lazy<TValue>(valueFetchFactory);
+
+            //Setup the cache policy if item will be saved back to cache.
+            CacheItemPolicy policy = new CacheItemPolicy()
+            {
+                AbsoluteExpiration = DateTimeOffset.Now.AddMinutes(minutesForExpiration)
+            };
+
+            //returns existing item form cache or add the new value if it does not exist.
+            var cachedItem = _cacheContainer.AddOrGetExisting(key, newValue, policy) as
+Lazy<TValue>;
+
+            return (cachedItem ?? newValue).Value;
+        }
+        catch (Exception excep)
+        {
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+81
+
+            return default(TValue);
+        }
+    }
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+82
+
+Chapter 23: System.Reflection.Emit
+namespace
+
+Section 23.1: Creating an assembly dynamically
+
+using System;
+using System.Reflection;
+using System.Reflection.Emit;
+
+class DemoAssemblyBuilder
+{
+    public static void Main()
+    {
+        // An assembly consists of one or more modules, each of which
+        // contains zero or more types. This code creates a single-module
+        // assembly, the most common case. The module contains one type,
+        // named "MyDynamicType", that has a private field, a property
+        // that gets and sets the private field, constructors that
+        // initialize the private field, and a method that multiplies
+        // a user-supplied number by the private field value and returns
+        // the result. In C# the type might look like this:
+        /*
+        public class MyDynamicType
+        {
+            private int m_number;
+
+            public MyDynamicType() : this(42) {}
+            public MyDynamicType(int initNumber)
+            {
+                m_number = initNumber;
+            }
+
+            public int Number
+            {
+                get { return m_number; }
+                set { m_number = value; }
+            }
+
+            public int MyMethod(int multiplier)
+            {
+                return m_number * multiplier;
+            }
+        }
+        */
+
+        AssemblyName aName = new AssemblyName("DynamicAssemblyExample");
+        AssemblyBuilder ab =
+            AppDomain.CurrentDomain.DefineDynamicAssembly(
+                aName,
+                AssemblyBuilderAccess.RunAndSave);
+
+        // For a single-module assembly, the module name is usually
+        // the assembly name plus an extension.
+        ModuleBuilder mb =
+            ab.DefineDynamicModule(aName.Name, aName.Name + ".dll");
+
+        TypeBuilder tb = mb.DefineType(
+            "MyDynamicType",
+             TypeAttributes.Public);
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+83
+
+        // Add a private field of type int (Int32).
+        FieldBuilder fbNumber = tb.DefineField(
+            "m_number",
+            typeof(int),
+            FieldAttributes.Private);
+
+        // Next, we make a simple sealed method.
+        MethodBuilder mbMyMethod = tb.DefineMethod(
+            "MyMethod",
+            MethodAttributes.Public,
+            typeof(int),
+            new[] { typeof(int) });
+
+        ILGenerator il = mbMyMethod.GetILGenerator();
+        il.Emit(OpCodes.Ldarg_0); // Load this - always the first argument of any instance method
+        il.Emit(OpCodes.Ldfld, fbNumber);
+        il.Emit(OpCodes.Ldarg_1); // Load the integer argument
+        il.Emit(OpCodes.Mul); // Multiply the two numbers with no overflow checking
+        il.Emit(OpCodes.Ret); // Return
+
+        // Next, we build the property. This involves building the property itself, as well as the
+        // getter and setter methods.
+        PropertyBuilder pbNumber = tb.DefineProperty(
+            "Number", // Name
+            PropertyAttributes.None,
+            typeof(int), // Type of the property
+            new Type[0]); // Types of indices, if any
+
+        MethodBuilder mbSetNumber = tb.DefineMethod(
+            "set_Number", // Name - setters are set_Property by convention
+            // Setter is a special method and we don't want it to appear to callers from C#
+            MethodAttributes.PrivateScope | MethodAttributes.HideBySig | MethodAttributes.Public |
+MethodAttributes.SpecialName,
+            typeof(void), // Setters don't return a value
+            new[] { typeof(int) }); // We have a single argument of type System.Int32
+
+        // To generate the body of the method, we'll need an IL generator
+        il = mbSetNumber.GetILGenerator();
+        il.Emit(OpCodes.Ldarg_0); // Load this
+        il.Emit(OpCodes.Ldarg_1); // Load the new value
+        il.Emit(OpCodes.Stfld, fbNumber); // Save the new value to this.m_number
+        il.Emit(OpCodes.Ret); // Return
+
+        // Finally, link the method to the setter of our property
+        pbNumber.SetSetMethod(mbSetNumber);
+
+        MethodBuilder mbGetNumber = tb.DefineMethod(
+            "get_Number",
+            MethodAttributes.PrivateScope | MethodAttributes.HideBySig | MethodAttributes.Public |
+MethodAttributes.SpecialName,
+            typeof(int),
+            new Type[0]);
+
+        il = mbGetNumber.GetILGenerator();
+        il.Emit(OpCodes.Ldarg_0); // Load this
+        il.Emit(OpCodes.Ldfld, fbNumber); // Load the value of this.m_number
+        il.Emit(OpCodes.Ret); // Return the value
+
+        pbNumber.SetGetMethod(mbGetNumber);
+
+        // Finally, we add the two constructors.
+        // Constructor needs to call the constructor of the parent class, or another constructor in
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+84
+
+       
+the same class
+        ConstructorBuilder intConstructor = tb.DefineConstructor(
+            MethodAttributes.Public, CallingConventions.Standard | CallingConventions.HasThis,
+new[] { typeof(int) });
+        il = intConstructor.GetILGenerator();
+        il.Emit(OpCodes.Ldarg_0); // this
+        il.Emit(OpCodes.Call, typeof(object).GetConstructor(new Type[0])); // call parent's
+constructor
+        il.Emit(OpCodes.Ldarg_0); // this
+        il.Emit(OpCodes.Ldarg_1); // our int argument
+        il.Emit(OpCodes.Stfld, fbNumber); // store argument in this.m_number
+        il.Emit(OpCodes.Ret);
+
+        var parameterlessConstructor = tb.DefineConstructor(
+            MethodAttributes.Public, CallingConventions.Standard | CallingConventions.HasThis, new
+Type[0]);
+        il = parameterlessConstructor.GetILGenerator();
+        il.Emit(OpCodes.Ldarg_0); // this
+        il.Emit(OpCodes.Ldc_I4_S, (byte)42); // load 42 as an integer constant
+        il.Emit(OpCodes.Call, intConstructor); // call this(42)
+        il.Emit(OpCodes.Ret);
+
+        // And make sure the type is created
+        Type ourType = tb.CreateType();
+
+        // The types from the assembly can be used directly using reflection, or we can save the
+assembly to use as a reference
+        object ourInstance = Activator.CreateInstance(ourType);
+        Console.WriteLine(ourType.GetProperty("Number").GetValue(ourInstance)); // 42
+
+        // Save the assembly for use elsewhere. This is very useful for debugging - you can use e.g.
+ILSpy to look at the equivalent IL/C# code.
+        ab.Save(@"DynamicAssemblyExample.dll");
+        // Using newly created type
+        var myDynamicType = tb.CreateType();
+        var myDynamicTypeInstance = Activator.CreateInstance(myDynamicType);
+
+        Console.WriteLine(myDynamicTypeInstance.GetType()); // MyDynamicType
+
+        var numberField = myDynamicType.GetField("m_number", BindingFlags.NonPublic |
+BindingFlags.Instance);
+        numberField.SetValue (myDynamicTypeInstance, 10);
+
+        Console.WriteLine(numberField.GetValue(myDynamicTypeInstance)); // 10
+    }
+}
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+85
+
+       
+Chapter 24: .NET Core
+
+.NET Core is a general purpose development platform maintained by Microsoft and the .NET community on GitHub.
+
+It is cross-platform, supporting Windows, macOS and Linux, and can be used in device, cloud, and embedded/IoT
+
+scenarios.
+
+When you think of .NET Core the following should come to mind (flexible deployment, cross-platform, command-
+
+line tools, open source).
+
+Another great thing is that even if it's open source Microsoft is actively supporting it.
+
+Section 24.1: Basic Console App
+
+public class Program
+{
+    public static void Main(string[] args)
+    {
+        Console.WriteLine("\nWhat is your name? ");
+        var name = Console.ReadLine();
+        var date = DateTime.Now;
+        Console.WriteLine("\nHello, {0}, on {1:d} at {1:t}", name, date);
+        Console.Write("\nPress any key to exit...");
+        Console.ReadKey(true);
+    }
+}
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+86
+
+Chapter 25: ADO.NET
+
+ADO(ActiveX Data Objects).Net is a tool provided by Microsoft which provides access to data sources such as SQL
+
+Server, Oracle, and XML through its components. .Net front-end applications can retrieve, create, and manipulate
+
+data, once they are connected to a data source through ADO.Net with appropriate privileges.
+
+ADO.Net provides a connection-less architecture. It is a secure approach to interact with a database, since, the
+
+connection doesn't have to be maintained during the entire session.
+
+Section 25.1: Best Practices - Executing Sql Statements
+
+public void SaveNewEmployee(Employee newEmployee)
+{
+    // best practice - wrap all database connections in a using block so they are always closed &
+disposed even in the event of an Exception
+    // best practice - retrieve the connection string by name from the app.config or web.config
+(depending on the application type) (note, this requires an assembly reference to
+System.configuration)
+    using(SqlConnection con = new
+SqlConnection(System.Configuration.ConfigurationManager.ConnectionStrings["MyConnectionName"].Conne
+ctionString))
+    {
+        // best practice - use column names in your INSERT statement so you are not dependent on the
+sql schema column order
+        // best practice - always use parameters to avoid sql injection attacks and errors if
+malformed text is used like including a single quote which is the sql equivalent of escaping or
+starting a string (varchar/nvarchar)
+        // best practice - give your parameters meaningful names just like you do variables in your
+code
+        using(SqlCommand sc = new SqlCommand("INSERT INTO employee (FirstName, LastName,
+DateOfBirth /*etc*/) VALUES (@firstName, @lastName, @dateOfBirth /*etc*/)", con))
+        {
+            // best practice - always specify the database data type of the column you are using
+            // best practice - check for valid values in your code and/or use a database constraint,
+if inserting NULL then use System.DbNull.Value
+            sc.Parameters.Add(new SqlParameter("@firstName", SqlDbType.VarChar, 200){Value =
+newEmployee.FirstName ?? (object) System.DBNull.Value});
+            sc.Parameters.Add(new SqlParameter("@lastName", SqlDbType.VarChar, 200){Value =
+newEmployee.LastName ?? (object) System.DBNull.Value});
+
+            // best practice - always use the correct types when specifying your parameters, Value
+is assigned to a DateTime instance and not a string representation of a Date
+            sc.Parameters.Add(new SqlParameter("@dateOfBirth", SqlDbType.Date){ Value =
+newEmployee.DateOfBirth });
+
+            // best practice - open your connection as late as possible unless you need to verify
+that the database connection is valid and won't fail and the proceeding code execution takes a long
+time (not the case here)
+            con.Open();
+            sc.ExecuteNonQuery();
+        }
+
+        // the end of the using block will close and dispose the SqlConnection
+        // best practice - end the using block as soon as possible to release the database connection
+    }
+}
+
+// supporting class used as parameter for example
+public class Employee
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+87
+
+{
+    public string FirstName { get; set; }
+    public string LastName { get; set; }
+    public DateTime DateOfBirth { get; set; }
+}
+
+Best practice for working with ADO.NET
+
+Rule of thumb is to open connection for minimal time. Close the connection explicitly once your procedure
+
+execution is over this will return the connection object back to connection pool. Default connection pool max
+
+size = 100. As connection pooling enhances the performance of physical connection to SQL
+
+Server.Connection Pooling in SQL Server
+
+Wrap all database connections in a using block so they are always closed & disposed even in the event of an
+
+Exception. See using Statement (C# Reference) for more information on using statements
+
+Retrieve the connection strings by name from the app.config or web.config (depending on the application
+
+type)
+
+This requires an assembly reference to System.configuration
+
+See Connection Strings and Configuration Files for additional information on how to structure your
+
+configuration file
+
+Always use parameters for incoming values to
+
+Avoid sql injection attacks
+
+Avoid errors if malformed text is used like including a single quote which is the sql equivalent of
+
+escaping or starting a string (varchar/nvarchar)
+
+Letting the database provider reuse query plans (not supported by all database providers) which
+
+increases efficiency
+
+When working with parameters
+
+Sql parameters type and size mismatch is a common cause of insert/ updated/ select failure
+
+Give your Sql parameters meaningful names just like you do variables in your code
+
+Specify the database data type of the column you are using, this ensures the wrong parameter types is
+
+not used which could lead to unexpected results
+
+Validate your incoming parameters before you pass them into the command (as the saying goes,
+
+"garbage in, garbage out"). Validate incoming values as early as possible in the stack
+
+Use the correct types when assigning your parameter values, example: do not assign the string value
+
+of a DateTime, instead assign an actual DateTime instance to the value of the parameter
+
+Specify the size of string-type parameters. This is because SQL Server can re-use execution plans if the
+parameters match in type and size. Use -1 for MAX
+
+Do not use the method AddWithValue, the main reason is it is very easy to forget to specify the
+
+parameter type or the precision/scale when needed. For additional information see Can we stop using
+
+AddWithValue already?
+
+When using database connections
+
+Open the connection as late as possible and close it as soon as possible. This is a general guideline
+
+when working with any external resource
+
+Never share database connection instances (example: having a singleton host a shared instance of
+
+type SqlConnection). Have your code always create a new database connection instance when needed
+
+and then have the calling code dispose of it and "throw it away" when it is done. The reason for this is
+
+Most database providers have some sort of connection pooling so creating new managed
+
+connections is cheap
+
+It eliminates any future errors if the code starts working with multiple threads
+
+Section 25.2: Executing SQL statements as a command
+
+// Uses Windows authentication. Replace the Trusted_Connection parameter with
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+88
+
+// User Id=...;Password=...; to use SQL Server authentication instead. You may
+// want to find the appropriate connection string for your server.
+string connectionString =
+@"Server=myServer\myInstance;Database=myDataBase;Trusted_Connection=True;"
+
+string sql = "INSERT INTO myTable (myDateTimeField, myIntField) " +
+    "VALUES (@someDateTime, @someInt);";
+
+// Most ADO.NET objects are disposable and, thus, require the using keyword.
+using (var connection = new SqlConnection(connectionString))
+using (var command = new SqlCommand(sql, connection))
+{
+    // Use parameters instead of string concatenation to add user-supplied
+    // values to avoid SQL injection and formatting issues. Explicitly supply datatype.
+
+    // System.Data.SqlDbType is an enumeration. See Note1
+    command.Parameters.Add("@someDateTime", SqlDbType.DateTime).Value = myDateTimeVariable;
+    command.Parameters.Add("@someInt", SqlDbType.Int).Value = myInt32Variable;
+
+    // Execute the SQL statement. Use ExecuteScalar and ExecuteReader instead
+    // for query that return results (or see the more specific examples, once
+    // those have been added).
+
+    connection.Open();
+    command.ExecuteNonQuery();
+}
+
+Note 1: Please see SqlDbType Enumeration for the MSFT SQL Server-specific variation.
+
+Note 2: Please see MySqlDbType Enumeration for the MySQL-specific variation.
+
+Section 25.3: Using common interfaces to abstract away
+vendor specific classes
+
+var providerName = "System.Data.SqlClient";    //Oracle.ManagedDataAccess.Client, IBM.Data.DB2
+var connectionString = "{your-connection-string}";
+//you will probably get the above two values in the ConnectionStringSettings object from .config file
+
+var factory = DbProviderFactories.GetFactory(providerName);
+using(var connection = factory.CreateConnection()) {    //IDbConnection
+    connection.ConnectionString = connectionString;
+    connection.Open();
+
+    using(var command = connection.CreateCommand()) {    //IDbCommand
+        command.CommandText = "{query}";
+
+        using(var reader = command.ExecuteReader()) {    //IDataReader
+            while(reader.Read()) {
+                ...
+            }
+        }
+    }
+}
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+89
+
+   
+       
+Chapter 26: Dependency Injection
+
+Section 26.1: How Dependency Injection Makes Unit Testing
+Easier
+
+This builds on the previous example of the Greeter class which has two dependencies, IGreetingProvider and
+
+IGreetingWriter.
+
+The actual implementation of IGreetingProvider might retrieve a string from an API call or a database. The
+
+implementation of IGreetingWriter might display the greeting in the console. But because Greeter has its
+
+dependencies injected into its constructor, it's easy to write a unit test that injects mocked versions of those
+
+interfaces. In real life we might use a framework like Moq, but in this case I'll write those mocked implementations.
+
+public class TestGreetingProvider : IGreetingProvider
+{
+    public const string TestGreeting = "Hello!";
+
+    public string GetGreeting()
+    {
+        return TestGreeting;
+    }
+}
+
+public class TestGreetingWriter : List<string>, IGreetingWriter
+{
+    public void WriteGreeting(string greeting)
+    {
+        Add(greeting);
+    }
+}
+
+[TestClass]
+public class GreeterTests
+{
+    [TestMethod]
+    public void Greeter_WritesGreeting()
+    {
+        var greetingProvider = new TestGreetingProvider();
+        var greetingWriter = new TestGreetingWriter();
+        var greeter = new Greeter(greetingProvider, greetingWriter);
+        greeter.Greet();
+        Assert.AreEqual(greetingWriter[0], TestGreetingProvider.TestGreeting);
+    }
+}
+
+The behavior of IGreetingProvider and IGreetingWriter are not relevant to this test. We want to test that
+
+Greeter gets a greeting and writes it. The design of Greeter (using dependency injection) allows us to inject mocked
+
+dependencies without any complicated moving parts. All we're testing is that Greeter interacts with those
+
+dependencies as we expect it to.
+
+Section 26.2: Dependency Injection - Simple example
+
+This class is called Greeter. Its responsibility is to output a greeting. It has two dependencies. It needs something
+
+that will give it the greeting to output, and then it needs a way to output that greeting. Those dependencies are
+
+both described as interfaces, IGreetingProvider and IGreetingWriter. In this example, those two dependencies
+
+are "injected" into Greeter. (Further explanation following the example.)
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+90
+
+public class Greeter
+{
+    private readonly IGreetingProvider _greetingProvider;
+    private readonly IGreetingWriter _greetingWriter;
+
+    public Greeter(IGreetingProvider greetingProvider, IGreetingWriter greetingWriter)
+    {
+        _greetingProvider = greetingProvider;
+        _greetingWriter = greetingWriter;
+    }
+
+    public void Greet()
+    {
+        var greeting = _greetingProvider.GetGreeting();
+        _greetingWriter.WriteGreeting(greeting);
+    }
+}
+
+public interface IGreetingProvider
+{
+    string GetGreeting();
+}
+
+public interface IGreetingWriter
+{
+    void WriteGreeting(string greeting);
+}
+
+The Greeting class depends on both IGreetingProvider and IGreetingWriter, but it is not responsible for
+
+creating instances of either. Instead it requires them in its constructor. Whatever creates an instance of Greeting
+
+must provide those two dependencies. We can call that "injecting" the dependencies.
+
+Because dependencies are provided to the class in its constructor, this is also called "constructor injection."
+
+A few common conventions:
+
+The constructor saves the dependencies as private fields. As soon as the class is instantiated, those
+
+dependencies are available to all other non-static methods of the class.
+
+The private fields are readonly. Once they are set in the constructor they cannot be changed. This indicates
+
+that those fields should not (and cannot) be modified outside of the constructor. That further ensures that
+
+those dependencies will be available for the lifetime of the class.
+
+The dependencies are interfaces. This is not strictly necessary, but is common because it makes it easier to
+
+substitute one implementation of the dependency with another. It also allows providing a mocked version of
+
+the interface for unit testing purposes.
+
+Section 26.3: Why We Use Dependency Injection Containers
+(IoC Containers)
+
+Dependency injection means writing classes so that they do not control their dependencies - instead, their
+
+dependencies are provided to them ("injected.")
+
+This is not the same thing as using a dependency injection framework (often called a "DI container", "IoC container",
+
+or just "container") like Castle Windsor, Autofac, SimpleInjector, Ninject, Unity, or others.
+
+A container just makes dependency injection easier. For example, suppose you write a number of classes that rely
+
+on dependency injection. One class depends on several interfaces, the classes that implement those interfaces
+
+depend on other interfaces, and so on. Some depend on specific values. And just for fun, some of those classes
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+91
+
+implement IDisposable and need to be disposed.
+
+Each individual class is well-written and easy to test. But now there's a different problem: Creating an instance of a
+
+class has become much more complicated. Suppose we're creating an instance of a CustomerService class. It has
+
+dependencies and its dependencies have dependencies. Constructing an instance might look something like this:
+
+public CustomerData GetCustomerData(string customerNumber)
+{
+    var customerApiEndpoint = ConfigurationManager.AppSettings["customerApi:customerApiEndpoint"];
+    var logFilePath = ConfigurationManager.AppSettings["logwriter:logFilePath"];
+    var authConnectionString =
+ConfigurationManager.ConnectionStrings["authorization"].ConnectionString;
+    using(var logWriter = new LogWriter(logFilePath ))
+    {
+        using(var customerApiClient = new CustomerApiClient(customerApiEndpoint))
+        {
+            var customerService = new CustomerService(
+                new SqlAuthorizationRepository(authorizationConnectionString, logWriter),
+                new CustomerDataRepository(customerApiClient, logWriter),
+                logWriter
+            );  
+
+            // All this just to create an instance of CustomerService!        
+            return customerService.GetCustomerData(string customerNumber);
+        }
+    }
+}
+
+You might wonder, why not put the whole giant construction in a separate function that just returns
+
+CustomerService? One reason is that because the dependencies for each class are injected into it, a class isn't
+
+responsible for knowing whether those dependencies are IDisposable or disposing them. It just uses them. So if a
+
+we had a GetCustomerService() function that returned a fully-constructed CustomerService, that class might
+
+contain a number of disposable resources and no way to access or dispose them.
+
+And aside from disposing IDisposable, who wants to call a series of nested constructors like that, ever? That's a
+
+short example. It could get much, much worse. Again, that doesn't mean that we wrote the classes the wrong way.
+
+The classes might be individually perfect. The challenge is composing them together.
+
+A dependency injection container simplifies that. It allows us to specify which class or value should be used to fulfill
+
+each dependency. This slightly oversimplified example uses Castle Windsor:
+
+var container = new WindsorContainer()
+container.Register(
+    Component.For<CustomerService>(),
+    Component.For<ILogWriter, LogWriter>()
+        .DependsOn(Dependency.OnAppSettingsValue("logFilePath", "logWriter:logFilePath")),
+    Component.For<IAuthorizationRepository, SqlAuthorizationRepository>()
+        .DependsOn(Dependency.OnValue(connectionString,
+ConfigurationManager.ConnectionStrings["authorization"].ConnectionString)),
+    Component.For<ICustomerDataProvider, CustomerApiClient>()
+         .DependsOn(Dependency.OnAppSettingsValue("apiEndpoint",
+"customerApi:customerApiEndpoint"))  
+);
+
+We call this "registering dependencies" or "configuring the container." Translated, this tells our WindsorContainer:
+
+If a class requires ILogWriter, create an instance of LogWriter. LogWriter requires a file path. Use this value
+
+from AppSettings.
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+92
+
+           
+If a class requires IAuthorizationRepository, create an instance of SqlAuthorizationRepository. It
+
+requires a connection string. Use this value from the ConnectionStrings section.
+
+If a class requires ICustomerDataProvider, create a CustomerApiClient and provide the string it needs from
+
+AppSettings.
+
+When we request a dependency from the container we call that "resolving" a dependency. It's bad practice to do
+
+that directly using the container, but that's a different story. For demonstration purposes, we could now do this:
+
+var customerService = container.Resolve<CustomerService>();
+var data = customerService.GetCustomerData(customerNumber);
+container.Release(customerService);
+
+The container knows that CustomerService depends on IAuthorizationRepository and ICustomerDataProvider.
+
+It knows what classes it needs to create to fulfill those requirements. Those classes, in turn, have more
+
+dependencies, and the container knows how to fulfill those. It will create every class it needs to until it can return an
+
+instance of CustomerService.
+
+If it gets to a point where a class requires a dependency that we haven't registered, like IDoesSomethingElse, then
+
+when we try to resolve CustomerService it will throw a clear exception telling us that we haven't registered
+
+anything to fulfill that requirement.
+
+Each DI framework behaves a little differently, but typically they give us some control over how certain classes are
+
+instantiated. For example, do we want it to create one instance of LogWriter and provide it to every class that
+
+depends on ILogWriter, or do we want it to create a new one every time? Most containers have a way to specify
+
+that.
+
+What about classes that implement IDisposable? That's why we call container.Release(customerService); at the
+
+end. Most containers (including Windsor) will step back through all of the dependencies created and Dispose the
+
+ones that need disposing. If CustomerService is IDisposable it will dispose that too.
+
+Registering dependencies as seen above might just look like more code to write. But when we have lots of classes
+with lots of dependencies then it really pays off. And if we had to write those same classes without using
+
+dependency injection then that same application with lots of classes would become difficult to maintain and test.
+
+This scratches the surface of why we use dependency injection containers. How we configure our application to use
+
+one (and use it correctly) is not just one topic - it's a number of topics, as the instructions and examples vary from
+
+one container to the next.
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+93
+
+Chapter 27: Platform Invoke
+
+Section 27.1: Marshaling structs
+
+Simple struct
+
+C++ signature:
+
+typedef struct _PERSON
+{
+    int age;
+    char name[32];
+} PERSON, *LP_PERSON;
+
+void GetSpouse(PERSON person, LP_PERSON spouse);
+
+C# definition
+
+[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
+public struct PERSON
+{
+    public int age;
+    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
+    public string name;
+}
+
+[DllImport("family.dll", CharSet = CharSet.Auto)]
+public static extern bool GetSpouse(PERSON person, ref PERSON spouse);
+
+Struct with unknown size array fields. Passing in
+
+C++ signature
+
+typedef struct
+{
+    int length;
+    int *data;
+} VECTOR;
+
+void SetVector(VECTOR &vector);
+
+When passed from managed to unmanaged code, this
+
+The data array should be defined as IntPtr and memory should be explicitly allocated with
+
+Marshal.AllocHGlobal() (and freed with Marshal.FreeHGlobal() afterwords):
+
+[StructLayout(LayoutKind.Sequential)]
+public struct VECTOR : IDisposable
+{
+    int length;
+    IntPtr dataBuf;
+
+    public int[] data
+    {
+        set
+        {
+            FreeDataBuf();
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+94
+
+            if (value != null && value.Length > 0)
+            {
+                dataBuf = Marshal.AllocHGlobal(value.Length * Marshal.SizeOf(value[0]));
+                Marshal.Copy(value, 0, dataBuf, value.Length);
+                length = value.Length;
+            }
+        }
+    }
+    void FreeDataBuf()
+    {
+        if (dataBuf != IntPtr.Zero)
+        {
+            Marshal.FreeHGlobal(dataBuf);
+            dataBuf = IntPtr.Zero;
+        }
+    }
+    public void Dispose()
+    {
+        FreeDataBuf();
+    }
+}
+
+[DllImport("vectors.dll")]
+public static extern void SetVector([In]ref VECTOR vector);
+
+Struct with unknown size array fields. Receiving
+
+C++ signature:
+
+typedef struct
+{
+    char *name;
+} USER;
+
+bool GetCurrentUser(USER *user);
+
+When such data is passed out of unmanaged code and memory is allocated by the unmanaged functions, the
+
+managed caller should receive it into an IntPrt variable and convert the buffer to a managed array. In case of
+
+strings there is a convenient Marshal.PtrToStringAnsi() method:
+
+[StructLayout(LayoutKind.Sequential)]
+public struct USER
+{
+    IntPtr nameBuffer;
+    public string name { get { return Marshal.PtrToStringAnsi(nameBuffer); } }
+}
+
+[DllImport("users.dll")]
+public static extern bool GetCurrentUser(out USER user);
+
+Section 27.2: Marshaling unions
+
+Value-type fields only
+
+C++ declaration
+
+typedef union
+{
+    char c;
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+95
+
+    int i;
+} CharOrInt;
+
+C# declaration
+
+[StructLayout(LayoutKind.Explicit)]
+public struct CharOrInt
+{
+    [FieldOffset(0)]
+    public byte c;
+    [FieldOffset(0)]
+    public int i;
+}
+
+Mixing value-type and reference fields
+
+Overlapping a reference value with a value type one is not allowed so you cannot simply use the FieldOffset(0)
+text; FieldOffset(0) i; will not compile for
+
+typedef union
+{
+    char text[128];
+    int i;
+} TextOrInt;
+
+and generally you would have to employ custom marshaling. However, in particular cases like this simpler technics
+
+may be used:
+
+[StructLayout(LayoutKind.Sequential)]
+public struct TextOrInt
+{
+    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 128)]
+    public byte[] text;
+    public int i { get { return BitConverter.ToInt32(text, 0); } }
+}
+
+Section 27.3: Calling a Win32 dll function
+
+using System.Runtime.InteropServices;
+
+class PInvokeExample
+{
+    [DllImport("user32.dll", CharSet = CharSet.Auto)]
+    public static extern uint MessageBox(IntPtr hWnd, String text, String caption, int options);
+
+    public static void test()
+    {
+        MessageBox(IntPtr.Zero, "Hello!", "Message", 0);
+    }
+}
+
+Declare a function as static extern stting DllImportAttribute with its Value property set to .dll name. Don't
+
+forget to use System.Runtime.InteropServices namespace. Then call it as an regular static method.
+
+The Platform Invocation Services will take care of loading the .dll and finding the desired finction. The P/Invoke in
+
+most simple cases will also marshal parameters and return value to and from the .dll (i.e. convert from .NET
+
+datatypes to Win32 ones and vice versa).
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+96
+
+Section 27.4: Using Windows API
+
+Use pinvoke.net.
+
+Before declaring an extern Windows API function in your code, consider looking for it on pinvoke.net. They most
+
+likely already have a suitable declaration with all supporting types and good examples.
+
+Section 27.5: Marshalling arrays
+
+Arrays of simple type
+
+[DllImport("Example.dll")]
+static extern void SetArray(
+    [MarshalAs(UnmanagedType.LPArray, SizeConst = 128)]
+    byte[] data);
+
+Arrays of string
+
+[DllImport("Example.dll")]
+static extern void SetStrArray(string[] textLines);
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+97
+
+Chapter 28: NuGet packaging system
+
+Section 28.1: Uninstalling a package from one project in a
+solution
+
+PM> Uninstall-Package -ProjectName MyProjectB EntityFramework
+
+Section 28.2: Installing a specific version of a package
+
+PM> Install-Package EntityFramework -Version 6.1.2  
+
+Section 28.3: Adding a package source feed (MyGet, Klondike,
+ect)
+
+nuget sources add -name feedname -source http://sourcefeedurl
+
+Section 28.4: Installing the NuGet Package Manager
+
+In order to be able to manage your projects' packages, you need the NuGet Package Manager. This is a Visual
+
+Studio Extension, explained in the official docs: Installing and Updating NuGet Client.
+
+Starting with Visual Studio 2012, NuGet is included in every edition, and can be used from: Tools -> NuGet Package
+
+Manager -> Package Manager Console.
+
+You do so through the Tools menu of Visual Studio, clicking Extensions and Updates:
+
+This installs both the GUI:
+
+Available through clicking "Manage NuGet Packages..." on a project or its References folder
+
+And the Package Manager Console:
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+98
+
+Tools -> NuGet Package Manager -> Package Manager Console.
+
+Section 28.5: Managing Packages through the UI
+
+When you right-click a project (or its References folder), you can click the "Manage NuGet Packages..." option. This
+
+shows the Package Manager Dialog.
+
+Section 28.6: Managing Packages through the console
+
+Click the menus Tools -> NuGet Package Manager -> Package Manager Console to show the console in your IDE.
+
+Official documentation here.
+
+Here you can issue, amongst others, install-package commands which installs the entered package into the
+
+currently selected "Default project":
+
+Install-Package Elmah
+
+You can also provide the project to install the package to, overriding the selected project in the "Default project"
+
+dropdown:
+
+Install-Package Elmah -ProjectName MyFirstWebsite
+
+Section 28.7: Updating a package
+
+To update a package use the following command:
+
+PM> Update-Package EntityFramework
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+99
+
+where EntityFramework is the name of the package to be updated. Note that update will run for all projects, and so
+
+is different from Install-Package EntityFramework which would install to "Default project" only.
+
+You can also specify a single project explicitly:
+
+PM> Update-Package EntityFramework -ProjectName MyFirstWebsite
+
+Section 28.8: Uninstalling a package
+
+PM> Uninstall-Package EntityFramework  
+
+Section 28.9: Uninstall a specific version of package
+
+PM> uninstall-Package EntityFramework -Version 6.1.2
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+100
+
+Chapter 29: Globalization in ASP.NET MVC
+using Smart internationalization for
+ASP.NET
+
+Section 29.1: Basic configuration and setup
+
+1.
+
+2.
+
+Add the I18N nuget package to your MVC project.
+
+In web.config, add the i18n.LocalizingModule to your <httpModules> or <modules> section.
+
+<!-- IIS 6 -->
+<httpModules>
+  <add name="i18n.LocalizingModule" type="i18n.LocalizingModule, i18n" />
+</httpModules>
+
+<!-- IIS 7 -->
+<system.webServer>
+  <modules>
+    <add name="i18n.LocalizingModule" type="i18n.LocalizingModule, i18n" />
+  </modules>
+</system.webServer>
+
+3.
+
+Add a folder named "locale" to the root of your site. Create a subfolder for each culture you wish to support.
+
+For example, /locale/fr/.
+
+4.
+
+5.
+
+In each culture-specific folder, create a text file named messages.po.
+
+For testing purposes, enter the following lines of text in your messages.po file:
+
+#: Translation test
+msgid "Hello, world!"
+msgstr "Bonjour le monde!"
+
+6.
+
+Add a controller to your project which returns some text to translate.
+
+using System.Web.Mvc;
+
+namespace I18nDemo.Controllers
+{
+    public class DefaultController : Controller
+    {
+        public ActionResult Index()
+        {
+            // Text inside [[[triple brackets]]] must precisely match
+            // the msgid in your .po file.
+            return Content("[[[Hello, world!]]]");
+        }
+    }
+}
+
+7.
+
+Run your MVC application and browse to the route corresponding to your controller action, such as
+
+http://localhost:[yourportnumber]/default.
+
+Observe that the URL is changed to reflect your default culture, such as
+
+http://localhost:[yourportnumber]/en/default.
+
+8.
+
+Replace /en/ in the URL with /fr/ (or whatever culture you've selected.) The page should now display the
+
+translated version of your text.
+
+9.
+
+Change your browser's language setting to prefer your alternate culture and browse to /default again.
+
+Observe that the URL is changed to reflect your alternate culture and the translated text appears.
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+101
+
+10.
+
+In web.config, add handlers so that users cannot browse to your locale folder.
+
+<!-- IIS 6 -->
+<system.web>
+  <httpHandlers>
+    <add path="*" verb="*" type="System.Web.HttpNotFoundHandler"/>
+  </httpHandlers>
+</system.web>
+
+<!-- IIS 7 -->
+<system.webServer>
+  <handlers>
+    <remove name="BlockViewHandler"/>
+   <add name="BlockViewHandler" path="*" verb="*" preCondition="integratedMode"
+type="System.Web.HttpNotFoundHandler"/>
+  </handlers>
+</system.webServer>
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+102
+
+Chapter 30: System.Net.Mail
+
+Section 30.1: MailMessage
+
+Here is the example of creating of mail message with attachments. After creating we send this message with the
+
+help of SmtpClient class. Default 25 port is used here.
+
+public class clsMail
+{
+    private static bool SendMail(string mailfrom, List<string>replytos, List<string> mailtos,
+List<string> mailccs, List<string> mailbccs, string body, string subject, List<string> Attachment)
+    {
+        try
+        {
+            using(MailMessage MyMail = new MailMessage())
+            {
+                MyMail.From = new MailAddress(mailfrom);
+                foreach (string mailto in mailtos)
+                    MyMail.To.Add(mailto);
+
+                if (replytos != null && replytos.Any())
+                {
+                    foreach (string replyto in replytos)
+                        MyMail.ReplyToList.Add(replyto);
+                }
+
+                if (mailccs != null && mailccs.Any())
+                {
+                    foreach (string mailcc in mailccs)
+                        MyMail.CC.Add(mailcc);
+                }
+
+                if (mailbccs != null && mailbccs.Any())
+                {
+                    foreach (string mailbcc in mailbccs)
+                        MyMail.Bcc.Add(mailbcc);
+                }                        
+
+                MyMail.Subject = subject;
+                MyMail.IsBodyHtml = true;
+                MyMail.Body = body;
+                MyMail.Priority = MailPriority.Normal;
+
+                if (Attachment != null && Attachment.Any())
+                {
+                    System.Net.Mail.Attachment attachment;
+                    foreach (var item in Attachment)
+                    {
+                        attachment = new System.Net.Mail.Attachment(item);
+                        MyMail.Attachments.Add(attachment);
+                    }
+                }
+
+                SmtpClient smtpMailObj = new SmtpClient();
+                smtpMailObj.Host = "your host";
+                smtpMailObj.Port = 25;
+                smtpMailObj.Credentials = new System.Net.NetworkCredential("uid", "pwd");
+
+                smtpMailObj.Send(MyMail);
+                return true;
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+103
+
+            }
+        }
+        catch
+        {
+            return false;
+        }
+    }
+}
+
+Section 30.2: Mail with Attachment
+
+MailMessage represents mail message which can be sent further using SmtpClient class. Several attachments (files)
+
+can be added to mail message.
+
+using System.Net.Mail;
+
+using(MailMessage myMail = new MailMessage())
+{
+     Attachment attachment = new Attachment(path);
+     myMail.Attachments.Add(attachment);
+
+     // further processing to send the mail message
+
+}
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+104
+
+Chapter 31: Using Progress<T> and
+IProgress<T>
+
+Section 31.1: Simple Progress reporting
+
+IProgress<T> can be used to report progress of some procedure to another procedure. This example shows how
+
+you can create a basic method that reports its progress.
+
+void Main()
+{
+    IProgress<int> p = new Progress<int>(progress =>
+    {
+        Console.WriteLine("Running Step: {0}", progress);
+    });
+    LongJob(p);
+}
+
+public void LongJob(IProgress<int> progress)
+{
+    var max = 10;
+    for (int i = 0; i < max; i++)
+    {
+        progress.Report(i);
+    }
+}
+
+Output:
+
+Running Step: 0
+Running Step: 3
+Running Step: 4
+Running Step: 5
+Running Step: 6
+Running Step: 7
+Running Step: 8
+Running Step: 9
+Running Step: 2
+Running Step: 1
+
+Note that when you this code runs, you may see numbers be output out of order. This is because the
+
+IProgress<T>.Report() method is run asynchronously, and is therefore not as suitable for situations where the
+
+progress must be reported in order.
+
+Section 31.2: Using IProgress<T>
+
+It's important to note that the System.Progress<T> class does not have the Report() method available on it. This
+
+method was implemented explicitly from the IProgress<T> interface, and therefore must be called on a
+
+Progress<T> when it's cast to an IProgress<T>.
+
+var p1 = new Progress<int>();
+p1.Report(1); //compiler error, Progress does not contain method 'Report'
+
+IProgress<int> p2 = new Progress<int>();
+p2.Report(2); //works
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+105
+
+var p3 = new Progress<int>();
+((IProgress<int>)p3).Report(3); //works
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+106
+
+Chapter 32: JSON Serialization
+
+Section 32.1: Deserialization using
+System.Web.Script.Serialization.JavaScriptSerializer
+
+The JavaScriptSerializer.Deserialize<T>(input) method attempts to deserialize a string of valid JSON into an
+
+object of the specified type <T>, using the default mappings natively supported by JavaScriptSerializer.
+
+using System.Collections;
+using System.Web.Script.Serialization;
+
+// ...
+
+string rawJSON = "{\"Name\":\"Fibonacci Sequence\",\"Numbers\":[0, 1, 1, 2, 3, 5, 8, 13]}";
+
+JavaScriptSerializer JSS = new JavaScriptSerializer();
+Dictionary<string, object> parsedObj = JSS.Deserialize<Dictionary<string, object>>(rawJSON);
+
+string name = parsedObj["Name"].toString();
+ArrayList numbers = (ArrayList)parsedObj["Numbers"]
+
+Note: The JavaScriptSerializer object was introduced in .NET version 3.5
+
+Section 32.2: Serialization using Json.NET
+
+[JsonObject("person")]
+public class Person
+{
+    [JsonProperty("name")]
+    public string PersonName { get; set; }
+    [JsonProperty("age")]
+    public int PersonAge { get; set; }
+    [JsonIgnore]
+    public string Address { get; set; }
+}
+
+Person person = new Person { PersonName = "Andrius", PersonAge = 99, Address = "Some address" };
+string rawJson = JsonConvert.SerializeObject(person);
+
+Console.WriteLine(rawJson); // {"name":"Andrius","age":99}
+
+Notice how properties (and classes) can be decorated with attributes to change their appearance in resulting json
+
+string or to remove them from json string at all (JsonIgnore).
+
+More information about Json.NET serialization attributes can be found here.
+
+In C#, public identifiers are written in PascalCase by convention. In JSON, the convention is to use camelCase for all
+
+names. You can use a contract resolver to convert between the two.
+
+using Newtonsoft.Json;
+using Newtonsoft.Json.Serialization;
+
+public class Person
+{
+    public string Name { get; set; }
+    public int Age { get; set; }
+    [JsonIgnore]
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+107
+
+    public string Address { get; set; }
+}
+
+public void ToJson() {
+    Person person = new Person { Name = "Andrius", Age = 99, Address = "Some address" };
+    var resolver = new CamelCasePropertyNamesContractResolver();
+    var settings = new JsonSerializerSettings { ContractResolver = resolver };
+    string json = JsonConvert.SerializeObject(person, settings);
+
+    Console.WriteLine(json); // {"name":"Andrius","age":99}
+}
+
+Section 32.3: Serialization-Deserialization using
+Newtonsoft.Json
+
+Unlike the other helpers, this one uses static class helpers to serialize and deserialize, hence it is a little bit easier
+
+than the others to use.
+
+using Newtonsoft.Json;
+
+var rawJSON      = "{\"Name\":\"Fibonacci Sequence\",\"Numbers\":[0, 1, 1, 2, 3, 5, 8, 13]}";
+var fibo         = JsonConvert.DeserializeObject<Dictionary<string, object>>(rawJSON);
+var rawJSON2     = JsonConvert.SerializeObject(fibo);
+
+Section 32.4: Deserialization using Json.NET
+
+internal class Sequence{
+    public string Name;
+    public List<int> Numbers;
+}    
+
+// ...
+
+string rawJSON = "{\"Name\":\"Fibonacci Sequence\",\"Numbers\":[0, 1, 1, 2, 3, 5, 8, 13]}";
+
+Sequence sequence = JsonConvert.DeserializeObject<Sequence>(rawJSON);
+
+For more information, refer to the Json.NET official site.
+
+Note: Json.NET supports .NET version 2 and higher.
+
+Section 32.5: Dynamic binding
+
+Newtonsoft's Json.NET allows you to bind json dynamically (using ExpandoObject / Dynamic objects) without the
+
+need to create the type explicitly.
+
+Serialization
+
+dynamic jsonObject = new ExpandoObject();
+jsonObject.Title   = "Merchent of Venice";
+jsonObject.Author  = "William Shakespeare";
+Console.WriteLine(JsonConvert.SerializeObject(jsonObject));
+
+De-serialization
+
+var rawJson = "{\"Name\":\"Fibonacci Sequence\",\"Numbers\":[0, 1, 1, 2, 3, 5, 8, 13]}";
+dynamic parsedJson = JObject.Parse(rawJson);
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+108
+
+Console.WriteLine("Name: " + parsedJson.Name);
+Console.WriteLine("Name: " + parsedJson.Numbers.Length);
+
+Notice that the keys in the rawJson object have been turned into member variables in the dynamic object.
+
+This is useful in cases where an application can accept/ produce varying formats of JSON. It is however suggested to
+
+use an extra level of validation for the Json string or to the dynamic object generated as a result of serialization/ de-
+
+serialization.
+
+Section 32.6: Serialization using Json.NET with
+JsonSerializerSettings
+
+This serializer has some nice features that the default .net json serializer doesn't have, like Null value handling, you
+
+just need to create the JsonSerializerSettings :
+
+public static string Serialize(T obj)
+{
+   string result = JsonConvert.SerializeObject(obj, new JsonSerializerSettings { NullValueHandling
+= NullValueHandling.Ignore});
+   return result;
+}
+
+Another serious serializer issue in .net is the self referencing loop. In the case of a student that is enrolled in a
+
+course, its instance has a course property and a course has a collection of students that means a List<Student>
+
+which will create a reference loop. You can handle this with JsonSerializerSettings :
+
+public static string Serialize(T obj)
+{
+   string result = JsonConvert.SerializeObject(obj, new JsonSerializerSettings {
+ReferenceLoopHandling = ReferenceLoopHandling.Ignore});
+   return result;
+}
+
+You can put various serializations option like this:
+
+public static string Serialize(T obj)
+{
+   string result = JsonConvert.SerializeObject(obj, new JsonSerializerSettings { NullValueHandling
+= NullValueHandling.Ignore, ReferenceLoopHandling = ReferenceLoopHandling.Ignore});
+   return result;
+}
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+109
+
+Chapter 33: JSON in .NET with
+Newtonsoft.Json
+
+The NuGet package Newtonsoft.Json has become the defacto standard for using and manipulating JSON formatted
+
+text and objects in .NET. It is a robust tool that is fast, and easy to use.
+
+Section 33.1: Deserialize an object from JSON text
+
+var json = "{\"Name\":\"Joe Smith\",\"Age\":21}";
+var person = JsonConvert.DeserializeObject<Person>(json);
+
+This yields a Person object with Name "Joe Smith" and Age 21.
+
+Section 33.2: Serialize object into JSON
+
+using Newtonsoft.Json;
+
+var obj = new Person
+{
+    Name = "Joe Smith",
+    Age = 21
+};
+var serializedJson = JsonConvert.SerializeObject(obj);
+
+This results in this JSON: {"Name":"Joe Smith","Age":21}
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+110
+
+Chapter 34: XmlSerializer
+
+Section 34.1: Formatting: Custom DateTime format
+
+public class Dog
+{
+    private const string _birthStringFormat = "yyyy-MM-dd";
+
+    [XmlIgnore]
+    public DateTime Birth {get; set;}
+
+    [XmlElement(ElementName="Birth")]
+    public string BirthString
+    {
+        get { return Birth.ToString(_birthStringFormat); }
+        set { Birth = DateTime.ParseExact(value, _birthStringFormat, CultureInfo.InvariantCulture);
+}
+    }
+}
+
+Section 34.2: Serialize object
+
+public void SerializeFoo(string fileName, Foo foo)
+{
+    var serializer = new XmlSerializer(typeof(Foo));
+    using (var stream = File.Open(fileName, FileMode.Create))
+    {
+        serializer.Serialize(stream, foo);
+    }
+}
+
+Section 34.3: Deserialize object
+
+public Foo DeserializeFoo(string fileName)
+{
+    var serializer = new XmlSerializer(typeof(Foo));
+    using (var stream = File.OpenRead(fileName))
+    {
+        return (Foo)serializer.Deserialize(stream);
+    }
+}
+
+Section 34.4: Behaviour: Map array name to property
+(XmlArray)
+
+<Store>
+    <Articles>
+        <Product/>
+        <Product/>
+    </Articles>
+</Store>
+
+public class Store
+{
+    [XmlArray("Articles")]
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+111
+
+    public List<Product> Products {get; set; }
+}
+
+Section 34.5: Behaviour: Map Element name to Property
+
+<Foo>
+    <Dog/>
+</Foo>
+
+public class Foo
+{
+    // Using XmlElement
+    [XmlElement(Name="Dog")]
+    public Animal Cat { get; set; }
+}
+
+Section 34.6: Eciently building multiple serializers with
+derived types specified dynamically
+
+Where we came from
+
+Sometimes we can't provide all of the required metadata needed for the XmlSerializer framework in attribute.
+
+Suppose we have a base class of serialized objects, and some of the derived classes are unknown to the base class.
+
+We can't place an attribute for all of the classes which are not know at the design time of the base type. We could
+
+have another team developing some of the derived classes.
+
+What can we do
+
+We can use new XmlSerializer(type, knownTypes), but that would be a O(N^2) operation for N serializers, at least
+
+to discover all of the types supplied in arguments:
+
+// Beware of the N^2 in terms of the number of types.
+var allSerializers = allTypes.Select(t => new XmlSerializer(t, allTypes));
+var serializerDictionary = Enumerable.Range(0, allTypes.Length)
+    .ToDictionary (i => allTypes[i], i => allSerializers[i])
+
+In this example, the the Base type is not aware of it's derived types, which is normal in OOP.
+
+Doing it efficiently
+
+Luckily, there is a method which addresses this particular problem - supplying known types for multiple serializers
+
+efficiently:
+
+System.Xml.Serialization.XmlSerializer.FromTypes Method (Type[])
+
+The FromTypes method allows you to efficiently create an array of XmlSerializer objects for processing an
+
+array of Type objects.
+
+var allSerializers = XmlSerializer.FromTypes(allTypes);
+var serializerDictionary = Enumerable.Range(0, allTypes.Length)
+    .ToDictionary(i => allTypes[i], i => allSerializers[i]);
+
+Here is a complete code sample:
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+112
+
+using System;
+using System.Collections.Generic;
+using System.Xml.Serialization;
+using System.Linq;
+using System.Linq;
+
+public class Program
+{
+    public class Container
+    {
+        public Base Base { get; set; }
+    }
+
+    public class Base
+    {
+        public int JustSomePropInBase { get; set; }
+    }
+
+    public class Derived : Base
+    {
+        public int JustSomePropInDerived { get; set; }
+    }
+
+    public void Main()
+    {
+        var sampleObject = new Container { Base = new Derived() };
+        var allTypes = new[] { typeof(Container), typeof(Base), typeof(Derived) };
+
+        Console.WriteLine("Trying to serialize without a derived class metadata:");
+        SetupSerializers(allTypes.Except(new[] { typeof(Derived) }).ToArray());
+        try
+        {
+            Serialize(sampleObject);
+        }
+        catch (InvalidOperationException e)
+        {
+            Console.WriteLine();
+            Console.WriteLine("This error was anticipated,");
+            Console.WriteLine("we have not supplied a derived class.");
+            Console.WriteLine(e);
+        }
+        Console.WriteLine("Now trying to serialize with all of the type information:");
+        SetupSerializers(allTypes);
+        Serialize(sampleObject);
+        Console.WriteLine();
+        Console.WriteLine("Slides down well this time!");
+    }
+
+    static void Serialize<T>(T o)
+    {
+        serializerDictionary[typeof(T)].Serialize(Console.Out, o);
+    }
+
+    private static Dictionary<Type, XmlSerializer> serializerDictionary;
+
+    static void SetupSerializers(Type[] allTypes)
+    {
+        var allSerializers = XmlSerializer.FromTypes(allTypes);
+        serializerDictionary = Enumerable.Range(0, allTypes.Length)
+            .ToDictionary(i => allTypes[i], i => allSerializers[i]);
+    }
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+113
+
+                   
+   
+   
+   
+       
+   
+}
+
+Output:
+
+Trying to serialize without a derived class metadata:
+<?xml version="1.0" encoding="utf-16"?>
+ System.InvalidOperationException: The type Program+Derived was not expected. Use the XmlInclude
+or SoapInclude attribute to specify types that are not known statically.
+at Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializationWriter1.Write2_Base(String n,
+String ns, Base o, Boolean isNullable, Boolean needType)
+at Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializationWriter1.Write3_Container(String
+n, String ns, Container o, Boolean isNullable, Boolean needType)
+at Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializationWriter1.Write4_Container(Object
+o)
+at System.Xml.Serialization.XmlSerializer.Serialize(XmlWriter xmlWriter, Object o,
+XmlSerializerNamespaces namespaces, String encodingStyle, String id)
+--- End of inner exception stack trace ---
+at System.Xml.Serialization.XmlSerializer.Serialize(XmlWriter xmlWriter, Object o,
+XmlSerializerNamespaces namespaces, String encodingStyle, String id)
+at System.Xml.Serialization.XmlSerializer.Serialize(XmlWriter xmlWriter, Object o,
+XmlSerializerNamespaces namespaces, String encodingStyle)
+at System.Xml.Serialization.XmlSerializer.Serialize(XmlWriter xmlWriter, Object o,
+XmlSerializerNamespaces namespaces)
+at Program.Serialize[T](T o)
+at Program.Main()
+Now trying to serialize with all of the type information:
+<?xml version="1.0" encoding="utf-16"?>
+
+0
+0
+
+Slides down well this time!
+
+What's in the output
+
+This error message recommends what we tried to avoid (or what we can not do in some scenarios) - referencing
+
+derived types from base class:
+
+Use the XmlInclude or SoapInclude attribute to specify types that are not known statically.
+
+This is how we get our derived class in the XML:
+
+<Base xsi:type="Derived">
+
+Base corresponds to the property type declared in the Container type, and Derived being the type of the instance
+
+actually supplied.
+
+Here is a working example fiddle
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+114
+
+Chapter 35: VB Forms
+
+Section 35.1: Hello World in VB.NET Forms
+
+To show a message box when the form has been shown:
+
+Public Class Form1
+    Private Sub Form1_Shown(sender As Object, e As EventArgs) Handles MyBase.Shown
+        MessageBox.Show("Hello, World!")
+    End Sub
+End Class
+To show a message box before the form has been shown:
+
+Public Class Form1
+    Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
+        MessageBox.Show("Hello, World!")
+    End Sub
+End Class
+
+Load() will be called first, and only once, when the form first loads. Show() will be called every time the user
+
+launches the form. Activate() will be called every time the user makes the form active.
+
+Load() will execute before Show() is called, but be warned: calling msgBox() in show can cause that msgBox() to
+
+execute before Load() is finished. It is generally a bad idea to depend on event ordering between Load(),
+
+Show(), and similar.
+
+Section 35.2: For Beginners
+
+Some things all beginners should know / do that will help them have a good start with VB .Net:
+
+Set the following Options:
+
+'can be permanently set
+' Tools / Options / Projects and Soluntions / VB Defaults
+Option Strict On
+Option Explicit On
+Option Infer Off
+
+Public Class Form1
+
+End Class
+
+Use &, not + for string concatenation. Strings should be studied in some detail as they are widely used.
+
+Spend some time understanding Value and Reference Types.
+
+Never use Application.DoEvents. Pay attention to the 'Caution'. When you reach a point where this seems like
+
+something you must use, ask.
+
+The documentation is your friend.
+
+Section 35.3: Forms Timer
+
+The Windows.Forms.Timer component can be used to provide the user information that is not time critical. Create
+a form with one button, one label, and a Timer component.
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+115
+
+For example it could be used to show the user the time of day periodically.
+
+'can be permanently set
+' Tools / Options / Projects and Soluntions / VB Defaults
+Option Strict On
+Option Explicit On
+Option Infer Off
+
+Public Class Form1
+
+    Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
+        Button1.Enabled = False
+        Timer1.Interval = 60 * 1000 'one minute intervals
+        'start timer
+        Timer1.Start()
+        Label1.Text = DateTime.Now.ToLongTimeString
+    End Sub
+
+    Private Sub Timer1_Tick(sender As Object, e As EventArgs) Handles Timer1.Tick
+        Label1.Text = DateTime.Now.ToLongTimeString
+    End Sub
+End Class
+
+But this timer is not suited for timing. An example would be using it for a countdown. In this example we will
+
+simulate a countdown to three minutes. This may very well be one of the most boringly important examples here.
+
+'can be permanently set
+' Tools / Options / Projects and Soluntions / VB Defaults
+Option Strict On
+Option Explicit On
+Option Infer Off
+
+Public Class Form1
+
+    Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
+        Button1.Enabled = False
+        ctSecs = 0 'clear count
+        Timer1.Interval = 1000 'one second in ms.
+        'start timers
+        stpw.Reset()
+        stpw.Start()
+        Timer1.Start()
+    End Sub
+
+    Dim stpw As New Stopwatch
+    Dim ctSecs As Integer
+
+    Private Sub Timer1_Tick(sender As Object, e As EventArgs) Handles Timer1.Tick
+        ctSecs += 1
+        If ctSecs = 180 Then 'about 2.5 seconds off on my PC!
+            'stop timing
+            stpw.Stop()
+            Timer1.Stop()
+            'show actual elapsed time
+            'Is it near 180?
+            Label1.Text = stpw.Elapsed.TotalSeconds.ToString("n1")
+        End If
+    End Sub
+End Class
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+116
+
+After button1 is clicked, about three minutes pass and label1 shows the results. Does label1 show 180? Probably
+
+not. On my machine it showed 182.5!
+
+The reason for the discrepancy is in the documentation, "The Windows Forms Timer component is single-threaded,
+
+and is limited to an accuracy of 55 milliseconds." This is why it shouldn't be used for timing.
+
+By using the timer and stopwatch a little differently we can obtain better results.
+
+'can be permanently set
+' Tools / Options / Projects and Soluntions / VB Defaults
+Option Strict On
+Option Explicit On
+Option Infer Off
+
+Public Class Form1
+
+    Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
+        Button1.Enabled = False
+        Timer1.Interval = 100 'one tenth of a second in ms.
+        'start timers
+        stpw.Reset()
+        stpw.Start()
+        Timer1.Start()
+    End Sub
+
+    Dim stpw As New Stopwatch
+    Dim threeMinutes As TimeSpan = TimeSpan.FromMinutes(3)
+
+    Private Sub Timer1_Tick(sender As Object, e As EventArgs) Handles Timer1.Tick
+        If stpw.Elapsed >= threeMinutes Then '0.1 off on my PC!
+            'stop timing
+            stpw.Stop()
+            Timer1.Stop()
+            'show actual elapsed time
+            'how close?
+            Label1.Text = stpw.Elapsed.TotalSeconds.ToString("n1")
+        End If
+    End Sub
+End Class
+
+There are other timers that can be used as needed. This search should help in that regard.
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+117
+
+Chapter 36: JIT compiler
+
+JIT compilation, or just-in-time compilation, is an alternative approach to interpretation of code or ahead-of-time
+
+compilation. JIT compilation is used in the .NET framework. The CLR code (C#, F#, Visual Basic, etc.) is first compiled
+
+into something called Interpreted Language, or IL. This is lower level code that is closer to machine code, but is not
+
+platform specific. Rather, at runtime, this code is compiled into machine code for the relevant system.
+
+Section 36.1: IL compilation sample
+
+Simple Hello World Application:
+
+using System;
+
+namespace HelloWorld
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            Console.WriteLine("Hello World");
+        }
+    }
+}
+
+Equivalent IL Code (which will be JIT compiled)
+
+//  Microsoft (R) .NET Framework IL Disassembler.  Version 4.6.1055.0
+//  Copyright (c) Microsoft Corporation.  All rights reserved.
+
+// Metadata version: v4.0.30319
+.assembly extern mscorlib
+{
+.publickeytoken = (B7 7A 5C 56 19 34 E0 89 )                         // .z\V.4..
+.ver 4:0:0:0
+}
+.assembly HelloWorld
+{
+.custom instance void
+[mscorlib]System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(int32) = ( 01 00
+08 00 00 00 00 00 )
+.custom instance void
+[mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00
+54 02 16 57 72 61 70 4E 6F 6E 45 78   // ....T..WrapNonEx
+63 65 70 74 69 6F 6E 54 68 72 6F 77 73 01 )       // ceptionThrows.
+
+// --- The following custom attribute is added automatically, do not uncomment -------
+//  .custom instance void [mscorlib]System.Diagnostics.DebuggableAttribute::.ctor(valuetype
+[mscorlib]System.Diagnostics.DebuggableAttribute/DebuggingModes) = ( 01 00 07 01 00 00 00 00 )
+
+.custom instance void [mscorlib]System.Reflection.AssemblyTitleAttribute::.ctor(string) = ( 01 00
+0A 48 65 6C 6C 6F 57 6F 72 6C 64 00 00 )    // ...HelloWorld..
+.custom instance void [mscorlib]System.Reflection.AssemblyDescriptionAttribute::.ctor(string) = (
+01 00 00 00 00 )
+.custom instance void [mscorlib]System.Reflection.AssemblyConfigurationAttribute::.ctor(string) =
+( 01 00 00 00 00 )
+.custom instance void [mscorlib]System.Reflection.AssemblyCompanyAttribute::.ctor(string) = ( 01
+00 00 00 00 )
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+118
+
+.custom instance void [mscorlib]System.Reflection.AssemblyProductAttribute::.ctor(string) = ( 01
+00 0A 48 65 6C 6C 6F 57 6F 72 6C 64 00 00 )    // ...HelloWorld..
+.custom instance void [mscorlib]System.Reflection.AssemblyCopyrightAttribute::.ctor(string) = ( 01
+00 12 43 6F 70 79 72 69 67 68 74 20 C2 A9 20   // ...Copyright ..
+20 32 30 31 37 00 00 )                            //  2017..
+.custom instance void [mscorlib]System.Reflection.AssemblyTrademarkAttribute::.ctor(string) = ( 01
+00 00 00 00 )
+.custom instance void [mscorlib]System.Runtime.InteropServices.ComVisibleAttribute::.ctor(bool) =
+( 01 00 00 00 00 )
+.custom instance void [mscorlib]System.Runtime.InteropServices.GuidAttribute::.ctor(string) = ( 01
+00 24 33 30 38 62 33 64 38 36 2D 34 31 37 32   // ..$308b3d86-4172
+2D 34 30 32 32 2D 61 66 63 63 2D 33 66 38 65 33   // -4022-afcc-3f8e3
+32 33 33 63 35 62 30 00 00 )                      // 233c5b0..
+.custom instance void [mscorlib]System.Reflection.AssemblyFileVersionAttribute::.ctor(string) = (
+01 00 07 31 2E 30 2E 30 2E 30 00 00 )             // ...1.0.0.0..
+.custom instance void [mscorlib]System.Runtime.Versioning.TargetFrameworkAttribute::.ctor(string)
+= ( 01 00 1C 2E 4E 45 54 46 72 61 6D 65 77 6F 72 6B   // ....NETFramework
+2C 56 65 72 73 69 6F 6E 3D 76 34 2E 35 2E 32 01   // ,Version=v4.5.2.
+00 54 0E 14 46 72 61 6D 65 77 6F 72 6B 44 69 73   // .T..FrameworkDis
+70 6C 61 79 4E 61 6D 65 14 2E 4E 45 54 20 46 72   // playName..NET Fr
+61 6D 65 77 6F 72 6B 20 34 2E 35 2E 32 )          // amework 4.5.2
+.hash algorithm 0x00008004
+.ver 1:0:0:0
+}
+.module HelloWorld.exe
+// MVID: {2A7E1D59-1272-4B47-85F6-D7E1ED057831}
+.imagebase 0x00400000
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       // WINDOWS_CUI
+.corflags 0x00020003    //  ILONLY 32BITPREFERRED
+// Image base: 0x0000021C70230000
+
+// =============== CLASS MEMBERS DECLARATION ===================
+
+.class private auto ansi beforefieldinit HelloWorld.Program
+extends [mscorlib]System.Object
+{
+.method private hidebysig static void  Main(string[] args) cil managed
+{
+.entrypoint
+// Code size       13 (0xd)
+.maxstack  8
+IL_0000:  nop
+IL_0001:  ldstr      "Hello World"
+IL_0006:  call       void [mscorlib]System.Console::WriteLine(string)
+IL_000b:  nop
+IL_000c:  ret
+} // end of method Program::Main
+
+.method public hidebysig specialname rtspecialname
+instance void  .ctor() cil managed
+{
+// Code size       8 (0x8)
+.maxstack  8
+IL_0000:  ldarg.0
+IL_0001:  call       instance void [mscorlib]System.Object::.ctor()
+IL_0006:  nop
+IL_0007:  ret
+} // end of method Program::.ctor
+
+} // end of class HelloWorld.Program
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+119
+
+Generated with MS ILDASM tool (IL disassembler)
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+120
+
+Chapter 37: CLR
+
+Section 37.1: An introduction to Common Language Runtime
+
+The Common Language Runtime (CLR) is a virtual machine environment and part of the .NET Framework. It
+contains:
+
+A portable bytecode language called Common Intermediate Language (abbreviated CIL, or IL)
+A Just-In-Time compiler that generates machine code
+
+A tracing garbage collector that provides automatic memory management
+
+Support for lightweight sub-processes called AppDomains
+
+Security mechanisms through the concepts of verifiable code and trust levels
+
+Code that runs in the CLR is referred to as managed code to distinguish it from code running outside the CLR
+(usually native code) which is referred to as unmanaged code. There are various mechanisms that facilitate
+
+interoperability between managed and unmanaged code.
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+121
+
+Chapter 38: TPL Dataflow
+
+Section 38.1: Asynchronous Producer Consumer With A
+Bounded BuerBlock
+
+var bufferBlock = new BufferBlock<int>(new DataflowBlockOptions
+{
+    BoundedCapacity = 1000
+});
+
+var cancellationToken = new CancellationTokenSource(TimeSpan.FromSeconds(10)).Token;
+
+var producerTask = Task.Run(async () =>
+{
+    var random = new Random();
+
+    while (!cancellationToken.IsCancellationRequested)
+    {
+        var value = random.Next();
+        await bufferBlock.SendAsync(value, cancellationToken);
+    }
+});
+
+var consumerTask = Task.Run(async () =>
+{
+    while (await bufferBlock.OutputAvailableAsync())
+    {
+        var value = bufferBlock.Receive();
+        Console.WriteLine(value);
+    }
+});
+
+await Task.WhenAll(producerTask, consumerTask);
+
+Section 38.2: Posting to an ActionBlock and waiting for
+completion
+
+// Create a block with an asynchronous action
+var block = new ActionBlock<string>(async hostName =>
+{
+    IPAddress[] ipAddresses = await Dns.GetHostAddressesAsync(hostName);
+    Console.WriteLine(ipAddresses[0]);
+});
+
+block.Post("google.com"); // Post items to the block's InputQueue for processing
+block.Post("reddit.com");
+block.Post("stackoverflow.com");
+
+block.Complete(); // Tell the block to complete and stop accepting new items
+await block.Completion; // Asynchronously wait until all items completed processingu
+
+Section 38.3: Linking blocks to create a pipeline
+
+var httpClient = new HttpClient();
+
+// Create a block the accepts a uri and returns its contents as a string
+var downloaderBlock = new TransformBlock<string, string>(
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+122
+
+    async uri => await httpClient.GetStringAsync(uri));
+
+// Create a block that accepts the content and prints it to the console
+var printerBlock = new ActionBlock<string>(
+    contents => Console.WriteLine(contents));
+
+// Make the downloaderBlock complete the printerBlock when its completed.
+var dataflowLinkOptions = new DataflowLinkOptions {PropagateCompletion = true};
+
+// Link the block to create a pipeline
+downloaderBlock.LinkTo(printerBlock, dataflowLinkOptions);
+
+// Post urls to the first block which will pass their contents to the second one.
+downloaderBlock.Post("http://youtube.com");
+downloaderBlock.Post("http://github.com");
+downloaderBlock.Post("http://twitter.com");
+
+downloaderBlock.Complete(); // Completion will propagate to printerBlock
+await printerBlock.Completion; // Only need to wait for the last block in the pipeline
+
+Section 38.4: Synchronous Producer/Consumer with
+BuerBlock<T>
+
+public class Producer
+{
+    private static Random random = new Random((int)DateTime.UtcNow.Ticks);
+    //produce the value that will be posted to buffer block
+    public double Produce ( )
+    {
+        var value = random.NextDouble();
+        Console.WriteLine($"Producing value: {value}");
+        return value;
+    }
+}
+
+public class Consumer
+{
+    //consume the value that will be received from buffer block
+    public void Consume (double value) => Console.WriteLine($"Consuming value: {value}");
+}
+
+class Program
+{
+    private static BufferBlock<double> buffer = new BufferBlock<double>();
+    static void Main (string[] args)
+    {
+        //start a task that will every 1 second post a value from the producer to buffer block
+        var producerTask = Task.Run(async () =>
+        {
+            var producer = new Producer();
+            while(true)
+            {
+                buffer.Post(producer.Produce());
+                await Task.Delay(1000);
+            }
+        });
+        //start a task that will recieve values from bufferblock and consume it
+        var consumerTask = Task.Run(() =>
+        {
+            var consumer = new Consumer();
+            while(true)
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+123
+
+            {
+                consumer.Consume(buffer.Receive());
+            }
+        });
+
+        Task.WaitAll(new[] { producerTask, consumerTask });
+    }
+}
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+124
+
+Chapter 39: Threading
+
+Section 39.1: Accessing form controls from other threads
+
+If you want to change an attribute of a control such as a textbox or label from another thread than the GUI thread
+
+that created the control, you will have to invoke it or else you might get an error message stating:
+
+"Cross-thread operation not valid: Control 'control_name' accessed from a thread other than the thread it
+
+was created on."
+
+Using this example code on a system.windows.forms form will cast an exception with that message:
+
+private void button4_Click(object sender, EventArgs e)
+{
+    Thread thread = new Thread(updatetextbox);
+    thread.Start();
+}
+
+private void updatetextbox()
+{
+    textBox1.Text = "updated"; // Throws exception
+}
+
+Instead when you want to change a textbox's text from within a thread that doesn't own it use Control.Invoke or
+
+Control.BeginInvoke. You can also use Control.InvokeRequired to check if invoking the control is necessary.
+
+private void updatetextbox()
+{
+    if (textBox1.InvokeRequired)
+        textBox1.BeginInvoke((Action)(() => textBox1.Text = "updated"));
+    else
+        textBox1.Text = "updated";
+}
+
+If you need to do this often, you can write an extension for invokeable objects to reduce the amount of code
+
+necessary to make this check:
+
+public static class Extensions
+{
+    public static void BeginInvokeIfRequired(this ISynchronizeInvoke obj, Action action)
+    {
+        if (obj.InvokeRequired)
+            obj.BeginInvoke(action, new object[0]);
+        else
+            action();
+    }
+}
+
+And updating the textbox from any thread becomes a bit simpler:
+
+private void updatetextbox()
+{
+    textBox1.BeginInvokeIfRequired(() => textBox1.Text = "updated");
+}
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+125
+
+Be aware that Control.BeginInvoke as used in this example is asynchronous, meaning that code coming after a call
+
+to Control.BeginInvoke can be run immedeately after, whether or not the passed delegate has been executed yet.
+
+If you need to be sure that textBox1 is updated before continuing, use Control.Invoke instead, which will block the
+
+calling thread until your delegate has been executed. Do note that this approach can slow your code down
+
+significantly if you make many invoke calls and note that it will deadlock your application if your GUI thread is
+
+waiting for the calling thread to complete or release a held resource.
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+126
+
+Chapter 40: Process and Thread anity
+setting
+
+Parameter
+
+affinity
+
+Details
+integer that describes the set of processors on which the process is allowed to run. For example, on a 8
+processor system if you want your process to be executed only on processors 3 and 4 than you choose
+affinity like this : 00001100 which equals 12
+
+Section 40.1: Get process anity mask
+
+    public static int GetProcessAffinityMask(string processName = null)
+    {
+        Process myProcess = GetProcessByName(ref processName);
+
+        int processorAffinity = (int)myProcess.ProcessorAffinity;
+        Console.WriteLine("Process {0} Affinity Mask is : {1}", processName,
+FormatAffinity(processorAffinity));
+
+        return processorAffinity;
+    }
+
+    public static Process GetProcessByName(ref string processName)
+    {
+        Process myProcess;
+        if (string.IsNullOrEmpty(processName))
+        {
+            myProcess = Process.GetCurrentProcess();
+            processName = myProcess.ProcessName;
+        }
+        else
+        {
+            Process[] processList = Process.GetProcessesByName(processName);
+            myProcess = processList[0];
+        }
+        return myProcess;
+    }
+
+    private static string FormatAffinity(int affinity)
+    {
+        return Convert.ToString(affinity, 2).PadLeft(Environment.ProcessorCount, '0');
+    }
+}
+
+Example of usage :
+
+private static void Main(string[] args)
+{
+    GetProcessAffinityMask();
+
+    Console.ReadKey();
+}
+// Output:
+// Process Test.vshost Affinity Mask is : 11111111
+
+Section 40.2: Set process anity mask
+
+    public static void SetProcessAffinityMask(int affinity, string processName = null)
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+127
+
+    {
+        Process myProcess = GetProcessByName(ref processName);
+
+        Console.WriteLine("Process {0} Old Affinity Mask is : {1}", processName,
+FormatAffinity((int)myProcess.ProcessorAffinity));
+
+        myProcess.ProcessorAffinity = new IntPtr(affinity);
+        Console.WriteLine("Process {0} New Affinity Mask is : {1}", processName,
+FormatAffinity((int)myProcess.ProcessorAffinity));
+    }
+
+Example of usage :
+
+private static void Main(string[] args)
+{
+    int newAffinity = Convert.ToInt32("10101010", 2);
+    SetProcessAffinityMask(newAffinity);
+
+    Console.ReadKey();
+}
+// Output :
+// Process Test.vshost Old Affinity Mask is : 11111111
+// Process Test.vshost New Affinity Mask is : 10101010
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+128
+
+Chapter 41: Parallel processing using .Net
+framework
+
+This Topic is about Multi core programming using Task Parallel Library with .NET framework. The task parallel
+
+library allows you to write code which is human readable and adjusts itself with the number of Cores available. So
+
+you can be sure that your software would auto-upgrade itself with the upgrading environment.
+
+Section 41.1: Parallel Extensions
+
+Parallel extensions have been introduced along with the Task Parallel Library to achieve data Parallelism. Data
+
+parallelism refers to scenarios in which the same operation is performed concurrently (that is, in parallel) on
+
+elements in a source collection or array. The .NET provides new constructs to achieve data parallelism by using
+
+Parallel.For and Parallel.Foreach constructs.
+
+//Sequential version
+
+foreach (var item in sourcecollection){
+
+Process(item);
+
+}
+
+// Parallel equivalent
+
+Parallel.foreach(sourcecollection, item => Process(item));
+
+The above mentioned Parallel.ForEach construct utilizes the multiple cores and thus enhances the performance in
+
+the same fashion.
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+129
+
+Chapter 42: Task Parallel Library (TPL)
+
+Section 42.1: Basic producer-consumer loop
+(BlockingCollection)
+
+var collection = new BlockingCollection<int>(5);
+var random = new Random();
+
+var producerTask = Task.Run(() => {
+    for(int item=1; item<=10; item++)
+    {
+        collection.Add(item);
+        Console.WriteLine("Produced: " + item);
+        Thread.Sleep(random.Next(10,1000));
+    }
+    collection.CompleteAdding();
+    Console.WriteLine("Producer completed!");
+});
+
+It is worth noting that if you do not call collection.CompleteAdding();, you are able to keep adding to the
+
+collection even if your consumer task is running. Just call collection.CompleteAdding(); when you are sure there
+
+are no more additions. This functionality can be used to make a Multiple Producer to a Single Consumer pattern
+
+where you have multiple sources feeding items into the BlockingCollection and a single consumer pulling items out
+
+and doing something with them. If your BlockingCollection is empty before you call complete adding, the
+
+Enumerable from collection.GetConsumingEnumerable() will block until a new item is added to the collection or
+
+BlockingCollection.CompleteAdding(); is called and the queue is empty.
+
+var consumerTask = Task.Run(() => {
+    foreach(var item in collection.GetConsumingEnumerable())
+    {
+        Console.WriteLine("Consumed: " + item);
+        Thread.Sleep(random.Next(10,1000));
+    }
+    Console.WriteLine("Consumer completed!");
+});
+
+Task.WaitAll(producerTask, consumerTask);
+
+Console.WriteLine("Everything completed!");
+
+Section 42.2: Parallel.Invoke
+
+var actions = Enumerable.Range(1, 10).Select(n => new Action(() =>
+{
+    Console.WriteLine("I'm task " + n);
+    if((n & 1) == 0)
+        throw new Exception("Exception from task " + n);
+})).ToArray();
+
+try
+{
+    Parallel.Invoke(actions);
+}
+catch(AggregateException ex)
+{
+    foreach(var inner in ex.InnerExceptions)
+        Console.WriteLine("Task failed: " + inner.Message);
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+130
+
+ 
+       
+}
+
+Section 42.3: Task: Returning a value
+
+Task that return a value has return type of Task< TResult > where TResult is the type of value that needs to be
+
+returned. You can query the outcome of a Task by its Result property.
+
+Task<int> t = Task.Run(() =>
+    {
+        int sum = 0;
+
+        for(int i = 0; i < 500; i++)
+            sum += i;
+
+        return sum;
+    });
+
+Console.WriteLine(t.Result); // Outuput 124750
+
+If the Task execute asynchronously than awaiting the Task returns it's result.
+
+public async Task DoSomeWork()
+{
+    WebClient client = new WebClient();
+    // Because the task is awaited, result of the task is assigned to response
+    string response = await client.DownloadStringTaskAsync("http://somedomain.com");
+}
+
+Section 42.4: Parallel.ForEach
+
+This example uses Parallel.ForEach to calculate the sum of the numbers between 1 and 10000 by using multiple
+
+threads. To achieve thread-safety, Interlocked.Add is used to sum the numbers.
+
+using System.Threading;
+
+int Foo()
+{
+    int total = 0;
+    var numbers = Enumerable.Range(1, 10000).ToList();
+    Parallel.ForEach(numbers,
+        () => 0, // initial value,
+        (num, state, localSum) => num + localSum,
+        localSum => Interlocked.Add(ref total, localSum));
+    return total; // total = 50005000
+}
+
+Section 42.5: Parallel.For
+
+This example uses Parallel.For to calculate the sum of the numbers between 1 and 10000 by using multiple
+
+threads. To achieve thread-safety, Interlocked.Add is used to sum the numbers.
+
+using System.Threading;
+
+int Foo()
+{
+    int total = 0;
+    Parallel.For(1, 10001,
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+131
+
+        () => 0, // initial value,
+        (num, state, localSum) => num + localSum,
+        localSum => Interlocked.Add(ref total, localSum));
+    return total; // total = 50005000
+}
+
+Section 42.6: Task: basic instantiation and Wait
+
+A task can be created by directly instantiating the Task class...
+
+var task = new Task(() =>
+{
+    Console.WriteLine("Task code starting...");
+    Thread.Sleep(2000);
+    Console.WriteLine("...task code ending!");
+});
+
+Console.WriteLine("Starting task...");
+task.Start();
+task.Wait();
+Console.WriteLine("Task completed!");
+
+...or by using the static Task.Run method:
+
+Console.WriteLine("Starting task...");
+var task = Task.Run(() =>
+{
+    Console.WriteLine("Task code starting...");
+    Thread.Sleep(2000);
+    Console.WriteLine("...task code ending!");
+});
+task.Wait();
+Console.WriteLine("Task completed!");
+
+Note that only in the first case it is necessary to explicitly invoke Start.
+
+Section 42.7: Task.WhenAll
+
+var random = new Random();
+IEnumerable<Task<int>> tasks = Enumerable.Range(1, 5).Select(n => Task.Run(() =>
+{
+    Console.WriteLine("I'm task " + n);
+    return n;
+}));
+
+Task<int[]> task = Task.WhenAll(tasks);
+int[] results = await task;
+
+Console.WriteLine(string.Join(",", results.Select(n => n.ToString())));
+// Output: 1,2,3,4,5
+
+Section 42.8: Flowing execution context with AsyncLocal
+
+When you need to pass some data from the parent task to its children tasks, so it logically flows with the execution,
+
+use AsyncLocal class:
+
+void Main()
+{
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+132
+
+    AsyncLocal<string> user = new AsyncLocal<string>();
+    user.Value = "initial user";
+
+    // this does not affect other tasks - values are local relative to the branches of execution flow
+    Task.Run(() => user.Value = "user from another task");
+
+    var task1 = Task.Run(() =>
+    {
+        Console.WriteLine(user.Value); // outputs "initial user"
+        Task.Run(() =>
+        {
+            // outputs "initial user" - value has flown from main method to this task without being
+changed
+            Console.WriteLine(user.Value);
+        }).Wait();
+
+        user.Value = "user from task1";
+
+        Task.Run(() =>
+        {
+            // outputs "user from task1" - value has flown from main method to task1
+            // than value was changed and flown to this task.
+            Console.WriteLine(user.Value);
+        }).Wait();
+    });
+
+    task1.Wait();
+
+    // outputs "initial user" - changes do not propagate back upstream the execution flow    
+    Console.WriteLine(user.Value);
+}
+
+Note: As can be seen from the example above AsynLocal.Value has copy on read semantic, but if you flow some
+reference type and change its properties you will affect other tasks. Hence, best practice with AsyncLocal is to use
+
+value types or immutable types.
+
+Section 42.9: Parallel.ForEach in VB.NET
+
+For Each row As DataRow In FooDataTable.Rows
+    Me.RowsToProcess.Add(row)
+Next
+
+Dim myOptions As ParallelOptions = New ParallelOptions()
+myOptions.MaxDegreeOfParallelism = environment.processorcount
+
+Parallel.ForEach(RowsToProcess, myOptions, Sub(currentRow, state)
+                                               ProcessRowParallel(currentRow, state)
+                                           End Sub)
+
+Section 42.10: Task: WaitAll and variable capturing
+
+var tasks = Enumerable.Range(1, 5).Select(n => new Task<int>(() =>
+{
+    Console.WriteLine("I'm task " + n);
+    return n;
+})).ToArray();
+
+foreach(var task in tasks) task.Start();
+Task.WaitAll(tasks);
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+133
+
+   
+   
+   
+   
+foreach(var task in tasks)
+    Console.WriteLine(task.Result);
+
+Section 42.11: Task: WaitAny
+
+var allTasks = Enumerable.Range(1, 5).Select(n => new Task<int>(() => n)).ToArray();
+var pendingTasks = allTasks.ToArray();
+
+foreach(var task in allTasks) task.Start();
+
+while(pendingTasks.Length > 0)
+{
+    var finishedTask = pendingTasks[Task.WaitAny(pendingTasks)];
+    Console.WriteLine("Task {0} finished", finishedTask.Result);
+    pendingTasks = pendingTasks.Except(new[] {finishedTask}).ToArray();
+}
+
+Task.WaitAll(allTasks);
+
+Note: The final WaitAll is necessary becasue WaitAny does not cause exceptions to be observed.
+
+Section 42.12: Task: handling exceptions (using Wait)
+
+var task1 = Task.Run(() =>
+{
+    Console.WriteLine("Task 1 code starting...");
+    throw new Exception("Oh no, exception from task 1!!");
+});
+
+var task2 = Task.Run(() =>
+{
+    Console.WriteLine("Task 2 code starting...");
+    throw new Exception("Oh no, exception from task 2!!");
+});
+
+Console.WriteLine("Starting tasks...");
+try
+{
+    Task.WaitAll(task1, task2);
+}
+catch(AggregateException ex)
+{
+    Console.WriteLine("Task(s) failed!");
+    foreach(var inner in ex.InnerExceptions)
+        Console.WriteLine(inner.Message);
+}
+
+Console.WriteLine("Task 1 status is: " + task1.Status); //Faulted
+Console.WriteLine("Task 2 status is: " + task2.Status); //Faulted
+
+Section 42.13: Task: handling exceptions (without using Wait)
+
+var task1 = Task.Run(() =>
+{
+    Console.WriteLine("Task 1 code starting...");
+    throw new Exception("Oh no, exception from task 1!!");
+});
+
+var task2 = Task.Run(() =>
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+134
+
+{
+    Console.WriteLine("Task 2 code starting...");
+    throw new Exception("Oh no, exception from task 2!!");
+});
+
+var tasks = new[] {task1, task2};
+
+Console.WriteLine("Starting tasks...");
+while(tasks.All(task => !task.IsCompleted));
+
+foreach(var task in tasks)
+{
+    if(task.IsFaulted)
+        Console.WriteLine("Task failed: " +
+            task.Exception.InnerExceptions.First().Message);
+}
+
+Console.WriteLine("Task 1 status is: " + task1.Status); //Faulted
+Console.WriteLine("Task 2 status is: " + task2.Status); //Faulted
+
+Section 42.14: Task: cancelling using CancellationToken
+
+var cancellationTokenSource = new CancellationTokenSource();
+var cancellationToken = cancellationTokenSource.Token;
+
+var task = new Task((state) =>
+    {
+        int i = 1;
+        var myCancellationToken = (CancellationToken)state;
+        while(true)
+        {
+            Console.Write("{0} ", i++);
+            Thread.Sleep(1000);
+            myCancellationToken.ThrowIfCancellationRequested();
+        }
+    },
+    cancellationToken: cancellationToken,
+    state: cancellationToken);
+
+Console.WriteLine("Counting to infinity. Press any key to cancel!");
+task.Start();
+Console.ReadKey();
+
+cancellationTokenSource.Cancel();
+try
+{
+    task.Wait();
+}
+catch(AggregateException ex)
+{
+    ex.Handle(inner => inner is OperationCanceledException);
+}
+
+Console.WriteLine($"{Environment.NewLine}You have cancelled! Task status is: {task.Status}");
+//Canceled
+
+As an alternative to ThrowIfCancellationRequested, the cancellation request can be detected with
+
+IsCancellationRequested and a OperationCanceledException can be thrown manually:
+
+//New task delegate
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+135
+
+int i = 1;
+var myCancellationToken = (CancellationToken)state;
+while(!myCancellationToken.IsCancellationRequested)
+{
+    Console.Write("{0} ", i++);
+    Thread.Sleep(1000);
+}
+Console.WriteLine($"{Environment.NewLine}Ouch, I have been cancelled!!");
+throw new OperationCanceledException(myCancellationToken);
+
+Note how the cancellation token is passed to the task constructor in the cancellationToken parameter. This is
+
+needed so that the task transitions to the Canceled state, not to the Faulted state, when
+
+ThrowIfCancellationRequested is invoked. Also, for the same reason, the cancellation token is explicitly supplied
+
+in the constructor of OperationCanceledException in the second case.
+
+Section 42.15: Task.WhenAny
+
+var random = new Random();
+IEnumerable<Task<int>> tasks = Enumerable.Range(1, 5).Select(n => Task.Run(async() =>
+{
+    Console.WriteLine("I'm task " + n);
+    await Task.Delay(random.Next(10,1000));
+    return n;
+}));
+
+Task<Task<int>> whenAnyTask = Task.WhenAny(tasks);
+Task<int> completedTask = await whenAnyTask;
+Console.WriteLine("The winner is: task " + await completedTask);
+
+await Task.WhenAll(tasks);
+Console.WriteLine("All tasks finished!");
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+136
+
+Chapter 43: Task Parallel Library (TPL) API
+Overviews
+
+Section 43.1: Perform work in response to a button click and
+update the UI
+
+This example demonstrates how you can respond to a button click by performing some work on a worker thread
+
+and then update the user interface to indicate completion
+
+void MyButton_OnClick(object sender, EventArgs args)
+{
+    Task.Run(() => // Schedule work using the thread pool
+        {
+            System.Threading.Thread.Sleep(5000); // Sleep for 5 seconds to simulate work.
+        })
+    .ContinueWith(p => // this continuation contains the 'update' code to run on the UI thread
+    {
+        this.TextBlock_ResultText.Text = "The work completed at " + DateTime.Now.ToString()
+    },
+    TaskScheduler.FromCurrentSynchronizationContext()); // make sure the update is run on the UI
+thread.
+
+}
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+137
+
+Chapter 44: Synchronization Contexts
+
+Section 44.1: Execute code on the UI thread after performing
+background work
+
+This example shows how to update a UI component from a background thread by using a SynchronizationContext
+
+void Button_Click(object sender, EventArgs args)
+{
+    SynchronizationContext context = SynchronizationContext.Current;
+    Task.Run(() =>
+    {
+        for(int i = 0; i < 10; i++)
+        {
+            Thread.Sleep(500); //simulate work being done
+            context.Post(ShowProgress, "Work complete on item " + i);
+        }
+    }
+}
+
+void UpdateCallback(object state)
+{
+    // UI can be safely updated as this method is only called from the UI thread
+    this.MyTextBox.Text = state as string;
+}
+
+In this example, if you tried to directly update MyTextBox.Text inside the for loop, you would get a threading error.
+
+By posting the UpdateCallback action to the SynchronizationContext, the text box is updated on the same thread
+
+as the rest of the UI.
+
+In practice, progress updates should be performed using an instance of System.IProgress<T>. The default
+
+implementation System.Progress<T> automatically captures the synchronisation context it is created on.
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+138
+
+Chapter 45: Memory management
+
+Section 45.1: Use SafeHandle when wrapping unmanaged
+resources
+
+When writing wrappers for unmanaged resources, you should subclass SafeHandle rather than trying to implement
+
+IDisposable and a finalizer yourself. Your SafeHandle subclass should be as small and simple as possible to
+
+minimize the chance of a handle leak. This likely means that your SafeHandle implementation would an internal
+
+implementation detail of a class which wraps it to provide a usable API. This class ensures that, even if a program
+
+leaks your SafeHandle instance, your unmanaged handle is released.
+
+using System.Runtime.InteropServices;
+
+class MyHandle : SafeHandle
+{
+    public override bool IsInvalid => handle == IntPtr.Zero;
+    public MyHandle() : base(IntPtr.Zero, true)
+    { }
+
+    public MyHandle(int length) : this()
+    {
+        SetHandle(Marshal.AllocHGlobal(length));
+    }
+
+    protected override bool ReleaseHandle()
+    {
+        Marshal.FreeHGlobal(handle);
+        return true;
+    }
+}
+
+Disclaimer: This example is an attempt to show how to guard a managed resource with SafeHandle which
+
+implements IDisposable for you and configures finalizers appropriately. It is very contrived and likely pointless to
+
+allocate a chunk of memory in this manner.
+
+Section 45.2: Unmanaged Resources
+
+When we talk about the GC and the "heap", we're really talking about what's called the managed heap. Objects on
+the managed heap can access resources not on the managed heap, for example, when writing to or reading from a
+
+file. Unexpected behavior can occur when, a file is opened for reading and then an exception occurs, preventing the
+
+file handle from closing as it normally would. For this reason, .NET requires that unmanaged resources implement
+
+the IDisposable interface. This interface has a single method called Dispose with no parameters:
+
+public interface IDisposable
+{
+    Dispose();
+}
+
+When handling unmanaged resources, you should make sure that they are properly disposed. You can do this by
+
+explicitly calling Dispose() in a finally block, or with a using statement.
+
+StreamReader sr;
+string textFromFile;
+string filename = "SomeFile.txt";
+try
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+139
+
+{
+    sr = new StreamReader(filename);
+    textFromFile = sr.ReadToEnd();
+}
+finally
+{
+    if (sr != null) sr.Dispose();
+}
+
+or
+
+string textFromFile;
+string filename = "SomeFile.txt";
+
+using (StreamReader sr = new Streamreader(filename))
+{
+    textFromFile = sr.ReadToEnd();
+}
+
+The latter is the preferred method, and is automatically expanded to the former during compilation.
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+140
+
+Chapter 46: Garbage Collection
+
+In .Net, objects created with new() are allocated on the managed heap. These objects are never explicitly finalized
+
+by the program that uses them; instead, this process is controlled by the .Net Garbage Collector.
+
+Some of the examples below are "lab cases" to show the Garbage Collector at work and some significant details of
+
+its behavior, while other focus on how to prepare classes for proper handling by the Garbage Collector.
+
+Section 46.1: A basic example of (garbage) collection
+
+Given the following class:
+
+public class FinalizableObject
+{
+    public FinalizableObject()
+    {
+        Console.WriteLine("Instance initialized");
+    }
+
+    ~FinalizableObject()
+    {
+        Console.WriteLine("Instance finalized");
+    }
+}
+
+A program that creates an instance, even without using it:
+
+new FinalizableObject(); // Object instantiated, ready to be used
+
+Produces the following output:
+
+<namespace>.FinalizableObject initialized
+
+If nothing else happens, the object is not finalized until the program ends (which frees all objects on the managed
+
+heap, finalizing these in the process).
+
+It is possible to force the Garbage Collector to run at a given point, as follows:
+
+new FinalizableObject(); // Object instantiated, ready to be used
+GC.Collect();
+
+Which produces the following result:
+
+<namespace>.FinalizableObject initialized
+<namespace>.FinalizableObject finalized
+
+This time, as soon as the Garbage Collector was invoked, the unused (aka "dead") object was finalized and freed
+
+from the managed heap.
+
+Section 46.2: Live objects and dead objects - the basics
+
+Rule of thumb: when garbage collection occurs, "live objects" are those still in use, while "dead objects" are those
+
+no longer used (any variable or field referencing them, if any, has gone out of scope before the collection occurs).
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+141
+
+In the following example (for convenience, FinalizableObject1 and FinalizableObject2 are subclasses of
+
+FinalizableObject from the example above and thus inherit the initialization / finalization message behavior):
+
+var obj1 = new FinalizableObject1(); // Finalizable1 instance allocated here
+var obj2 = new FinalizableObject2(); // Finalizable2 instance allocated here
+obj1 = null; // No more references to the Finalizable1 instance
+GC.Collect();
+
+The output will be:
+
+<namespace>.FinalizableObject1 initialized
+<namespace>.FinalizableObject2 initialized
+<namespace>.FinalizableObject1 finalized
+
+At the time when the Garbage Collector is invoked, FinalizableObject1 is a dead object and gets finalized, while
+
+FinalizableObject2 is a live object and it is kept on the managed heap.
+
+Section 46.3: Multiple dead objects
+
+What if two (or several) otherwise dead objects reference one another? This is shown in the example below,
+
+supposing that OtherObject is a public property of FinalizableObject:
+
+var obj1 = new FinalizableObject1();
+var obj2 = new FinalizableObject2();
+obj1.OtherObject = obj2;
+obj2.OtherObject = obj1;
+obj1 = null; // Program no longer references Finalizable1 instance
+obj2 = null; // Program no longer references Finalizable2 instance
+// But the two objects still reference each other
+GC.Collect();
+
+This produces the following output:
+
+<namespace>.FinalizedObject1 initialized
+<namespace>.FinalizedObject2 initialized
+<namespace>.FinalizedObject1 finalized
+<namespace>.FinalizedObject2 finalized
+
+The two objects are finalized and freed from the managed heap despite referencing each other (because no other
+
+reference exists to any of them from an actually live object).
+
+Section 46.4: Weak References
+
+Weak references are... references, to other objects (aka "targets"), but "weak" as they do not prevent those objects
+
+from being garbage-collected. In other words, weak references do not count when the Garbage Collector evaluates
+
+objects as "live" or "dead".
+
+The following code:
+
+var weak = new WeakReference<FinalizableObject>(new FinalizableObject());
+GC.Collect();
+
+Produces the output:
+
+<namespace>.FinalizableObject initialized
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+142
+
+<namespace>.FinalizableObject finalized
+
+The object is freed from the managed heap despite being referenced by the WeakReference variable (still in scope
+
+when the Garbage collector was invoked).
+
+Consequence #1: at any time, it is unsafe to assume whether a WeakReference target is still allocated on the
+
+managed heap or not.
+
+Consequence #2: whenever a program needs to access the target of a Weakreference, code should be provided for
+
+both cases, of the target being still allocated or not. The method to access the target is TryGetTarget:
+
+var target = new object(); // Any object will do as target
+var weak = new WeakReference<object>(target); // Create weak reference
+target = null; // Drop strong reference to the target
+
+// ... Many things may happen in-between
+
+// Check whether the target is still available
+if(weak.TryGetTarget(out target))
+{
+    // Use re-initialized target variable
+    // To do whatever the target is needed for
+}
+else
+{
+    // Do something when there is no more target object
+    // The target variable value should not be used here
+}
+
+The generic version of WeakReference is available since .Net 4.5. All framework versions provide a non-generic,
+
+untyped version that is built in the same way and checked as follows:
+
+var target = new object(); // Any object will do as target
+var weak = new WeakReference(target); // Create weak reference
+target = null; // Drop strong reference to the target
+
+// ... Many things may happen in-between
+
+// Check whether the target is still available
+if (weak.IsAlive)
+{
+    target = weak.Target;
+
+    // Use re-initialized target variable
+    // To do whatever the target is needed for
+}
+else
+{
+    // Do something when there is no more target object
+    // The target variable value should not be used here
+}
+
+Section 46.5: Dispose() vs. finalizers
+
+Implement Dispose() method (and declare the containing class as IDisposable) as a means to ensure any memory-
+
+heavy resources are freed as soon as the object is no longer used. The "catch" is that there is no strong guarantee
+
+the the Dispose() method would ever be invoked (unlike finalizers that always get invoked at the end of the life of
+
+the object).
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+143
+
+One scenario is a program calling Dispose() on objects it explicitly creates:
+
+private void SomeFunction()
+{
+    // Initialize an object that uses heavy external resources
+    var disposableObject = new ClassThatImplementsIDisposable();
+
+    // ... Use that object
+
+    // Dispose as soon as no longer used
+    disposableObject.Dispose();
+
+    // ... Do other stuff
+
+    // The disposableObject variable gets out of scope here
+    // The object will be finalized later on (no guarantee when)
+    // But it no longer holds to the heavy external resource after it was disposed
+}
+
+Another scenario is declaring a class to be instantiated by the framework. In this case the new class usually inherits
+
+a base class, for instance in MVC one creates a controller class as a subclass of System.Web.Mvc.ControllerBase.
+
+When the base class implements IDisposable interface, this is a good hint that Dispose() would be invoked properly
+
+by the framework - but again there is no strong guarantee.
+
+Thus Dispose() is not a substitute for a finalizer; instead, the two should be used for different purposes:
+
+A finalizer eventually frees resources to avoid memory leaks that would occur otherwise
+
+Dispose() frees resources (possibly the same ones) as soon as these are no longer needed, to ease pressure
+
+on overall memory allocation.
+
+Section 46.6: Proper disposal and finalization of objects
+
+As Dispose() and finalizers are aimed to different purposes, a class managing external memory-heavy resources
+
+should implement both of them. The consequence is writing the class so that it handles well two possible scenarios:
+
+When only the finalizer is invoked
+
+When Dispose() is invoked first and later the finalizer is invoked as well
+
+One solution is writing the cleanup code in such a way that running it once or twice would produce the same result
+
+as running it only once. Feasibility depends on the nature of the cleanup, for instance:
+
+Closing an already closed database connection would probably have no effect so it works
+
+Updating some "usage count" is dangerous and would produce a wrong result when called twice instead of
+
+once.
+
+A safer solution is ensuring by design that the cleanup code is called once and only once whatever the external
+
+context. This can be achieved the "classic way" using a dedicated flag:
+
+public class DisposableFinalizable1: IDisposable
+{
+    private bool disposed = false;
+
+    ~DisposableFinalizable1() { Cleanup(); }
+
+    public void Dispose() { Cleanup(); }
+
+    private void Cleanup()
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+144
+
+    {
+        if(!disposed)
+        {
+            // Actual code to release resources gets here, then
+            disposed = true;
+        }
+    }
+}
+
+Alternately, the Garbage Collector provides a specific method SuppressFinalize() that allows skipping the finalizer
+
+after Dispose has been invoked:
+
+public class DisposableFinalizable2 : IDisposable
+{
+    ~DisposableFinalizable2() { Cleanup(); }
+
+    public void Dispose()
+    {
+        Cleanup();
+        GC.SuppressFinalize(this);
+    }
+
+    private void Cleanup()
+    {
+        // Actual code to release resources gets here
+    }
+}
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+145
+
+Chapter 47: Exceptions
+
+Section 47.1: Catching and rethrowing caught exceptions
+
+When you want to catch an exception and do something, but you can't continue execution of the current block of
+
+code because of the exception, you may want to rethrow the exception to the next exception handler in the call
+
+stack. There are good ways and bad ways to do this.
+
+private static void AskTheUltimateQuestion()
+{
+    try
+    {
+        var x = 42;
+        var y = x / (x - x); // will throw a DivideByZeroException
+
+        // IMPORTANT NOTE: the error in following string format IS intentional
+        // and exists to throw an exception to the FormatException catch, below
+        Console.WriteLine("The secret to life, the universe, and everything is {1}", y);
+    }
+    catch (DivideByZeroException)
+    {
+        // we do not need a reference to the exception
+        Console.WriteLine("Dividing by zero would destroy the universe.");
+
+        // do this to preserve the stack trace:
+        throw;
+    }
+    catch (FormatException ex)
+    {
+        // only do this if you need to change the type of the Exception to be thrown
+        // and wrap the inner Exception
+
+        // remember that the stack trace of the outer Exception will point to the
+        // next line
+
+        // you'll need to examine the InnerException property to get the stack trace
+        // to the line that actually started the problem
+
+        throw new InvalidOperationException("Watch your format string indexes.", ex);
+    }
+    catch (Exception ex)
+    {
+        Console.WriteLine("Something else horrible happened. The exception: " + ex.Message);
+
+        // do not do this, because the stack trace will be changed to point to
+        // this location instead of the location where the exception
+        // was originally thrown:
+        throw ex;
+    }
+}
+
+static void Main()
+{
+    try
+    {
+        AskTheUltimateQuestion();
+    }
+    catch
+    {
+        // choose this kind of catch if you don't need any information about
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+146
+
+        // the exception that was caught
+
+        // this block "eats" all exceptions instead of rethrowing them
+    }
+}
+
+You can filter by exception type and even by exception properties (new in C# 6.0, a bit longer available in VB.NET
+
+(citation needed)):
+
+Documentation/C#/new features
+
+Section 47.2: Using a finally block
+
+The finally { ... } block of a try-finally or try-catch-finally will always execute, regardless of whether an
+
+exception occurred or not (except when a StackOverflowException has been thrown or call has been made to
+
+Environment.FailFast()).
+
+It can be utilized to free or clean up resources acquired in the try { ... } block safely.
+
+Console.Write("Please enter a filename: ");
+string filename = Console.ReadLine();
+
+Stream fileStream = null;
+
+try
+{
+    fileStream = File.Open(filename);
+}
+catch (FileNotFoundException)
+{
+    Console.WriteLine("File '{0}' could not be found.", filename);
+}
+finally
+{
+    if (fileStream != null)
+    {
+        fileStream.Dispose();
+    }
+}
+
+Section 47.3: Exception Filters
+
+Since C# 6.0 exceptions can be filtered using the when operator.
+
+This is similar to using a simple if but does not unwind the stack if the condition inside the when is not met.
+
+Example
+
+try
+{
+  // ...
+}
+catch (Exception e) when (e.InnerException != null) // Any condition can go in here.
+{
+  // ...
+}
+
+The same info can be found in the C# 6.0 Features here: Exception filters
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+147
+
+Section 47.4: Rethrowing an exception within a catch block
+
+Within a catch block the throw keyword can be used on its own, without specifying an exception value, to rethrow
+
+the exception which was just caught. Rethrowing an exception allows the original exception to continue up the
+
+exception handling chain, preserving its call stack or associated data:
+
+try {...}
+catch (Exception ex) {
+  // Note: the ex variable is *not* used
+  throw;
+}
+
+A common anti-pattern is to instead throw ex, which has the effect of limiting the next exception handler's view of
+
+the stack trace:
+
+try {...}
+catch (Exception ex) {
+  // Note: the ex variable is thrown
+  //  future stack traces of the exception will not see prior calls
+  throw ex;  
+}
+
+In general using throw ex isn't desirable, as future exception handlers which inspect the stack trace will only be
+
+able to see calls as far back as throw ex. By omitting the ex variable, and using the throw keyword alone the
+
+original exception will "bubble-up".
+
+Section 47.5: Throwing an exception from a dierent method
+while preserving its information
+
+Occasionally you'd want to catch an exception and throw it from a different thread or method while preserving the
+
+original exception stack. This can be done with ExceptionDispatchInfo:
+
+using System.Runtime.ExceptionServices;
+
+void Main()
+{
+    ExceptionDispatchInfo capturedException = null;
+    try
+    {
+        throw new Exception();
+    }
+    catch (Exception ex)
+    {
+        capturedException = ExceptionDispatchInfo.Capture(ex);
+    }
+
+    Foo(capturedException);
+}
+
+void Foo(ExceptionDispatchInfo exceptionDispatchInfo)
+{
+    // Do stuff
+
+    if (capturedException != null)
+    {
+        // Exception stack trace will show it was thrown from Main() and not from Foo()
+        exceptionDispatchInfo.Throw();
+    }
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+148
+
+   
+}
+
+Section 47.6: Catching an exception
+
+Code can and should throw exceptions in exceptional circumstances. Examples of this include:
+
+Attempting to read past the end of a stream
+
+Not having necessary permissions to access a file
+
+Attempting to perform an invalid operation, such as dividing by zero
+
+A timeout occurring when downloading a file from the internet
+
+The caller can handle these exceptions by "catching" them, and should only do so when:
+
+It can actually resolve the exceptional circumstance or recover appropriately, or;
+
+It can provide additional context to the exception that would be useful if the exception needs to be re-thrown
+
+(re-thrown exceptions are caught by exception handlers further up the call stack)
+
+It should be noted that choosing not to catch an exception is perfectly valid if the intention is for it to be handled at
+
+a higher level.
+
+Catching an exception is done by wrapping the potentially-throwing code in a try { ... } block as follows, and
+
+catching the exceptions it's able to handle in a catch (ExceptionType) { ... } block:
+
+Console.Write("Please enter a filename: ");
+string filename = Console.ReadLine();
+
+Stream fileStream;
+
+try
+{
+    fileStream = File.Open(filename);
+}
+catch (FileNotFoundException)
+{
+    Console.WriteLine("File '{0}' could not be found.", filename);
+}
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+149
+
+Chapter 48: System.Diagnostics
+
+Section 48.1: Run shell commands
+
+string strCmdText = "/C copy /b Image1.jpg + Archive.rar Image2.jpg";
+System.Diagnostics.Process.Start("CMD.exe",strCmdText);
+
+This is to hide the cmd window.
+
+System.Diagnostics.Process process = new System.Diagnostics.Process();
+System.Diagnostics.ProcessStartInfo startInfo = new System.Diagnostics.ProcessStartInfo();
+startInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;
+startInfo.FileName = "cmd.exe";
+startInfo.Arguments = "/C copy /b Image1.jpg + Archive.rar Image2.jpg";
+process.StartInfo = startInfo;
+process.Start();
+
+Section 48.2: Send Command to CMD and Receive Output
+
+This method allows a command to be sent to Cmd.exe, and returns the standard output (including standard error) as
+
+a string:
+
+private static string SendCommand(string command)
+{
+    var cmdOut = string.Empty;
+
+    var startInfo = new ProcessStartInfo("cmd", command)
+    {
+        WorkingDirectory = @"C:\Windows\System32", // Directory to make the call from
+        WindowStyle = ProcessWindowStyle.Hidden,   // Hide the window
+        UseShellExecute = false,                   // Do not use the OS shell to start the process
+        CreateNoWindow = true,                     // Start the process in a new window
+        RedirectStandardOutput = true,             // This is required to get STDOUT
+        RedirectStandardError = true               // This is required to get STDERR
+    };
+
+    var p = new Process {StartInfo = startInfo};
+
+    p.Start();
+
+    p.OutputDataReceived += (x, y) => cmdOut += y.Data;
+    p.ErrorDataReceived += (x, y) => cmdOut += y.Data;
+    p.BeginOutputReadLine();
+    p.BeginErrorReadLine();
+    p.WaitForExit();
+    return cmdOut;
+}
+
+Usage
+
+var servername = "SVR-01.domain.co.za";
+var currentUsers = SendCommand($"/C QUERY USER /SERVER:{servername}")
+
+Output
+
+string currentUsers = "USERNAME SESSIONNAME ID STATE IDLE TIME LOGON TIME Joe.Bloggs ica-cgp#0 2
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+150
+
+   
+Active 24692+13:29 25/07/2016 07:50 Jim.McFlannegan ica-cgp#1 3 Active . 25/07/2016 08:33
+
+Andy.McAnderson ica-cgp#2 4 Active . 25/07/2016 08:54 John.Smith ica-cgp#4 5 Active 14 25/07/2016
+
+08:57 Bob.Bobbington ica-cgp#5 6 Active 24692+13:29 25/07/2016 09:05 Tim.Tom ica-cgp#6 7 Active .
+
+25/07/2016 09:08 Bob.Joges ica-cgp#7 8 Active 24692+13:29 25/07/2016 09:13"
+
+On some occasions, access to the server in question may be restricted to certain users. If you have the login
+
+credentials for this user, then it is possible to send queries with this method:
+
+private static string SendCommand(string command)
+{
+    var cmdOut = string.Empty;
+
+    var startInfo = new ProcessStartInfo("cmd", command)
+    {
+        WorkingDirectory = @"C:\Windows\System32",
+        WindowStyle = ProcessWindowStyle.Hidden,    // This does not actually work in conjunction
+with "runas" - the console window will still appear!
+        UseShellExecute = false,
+        CreateNoWindow = true,
+        RedirectStandardOutput = true,
+        RedirectStandardError = true,
+
+        Verb = "runas",
+        Domain = "doman1.co.za",
+        UserName = "administrator",
+        Password = GetPassword()
+    };
+
+    var p = new Process {StartInfo = startInfo};
+
+    p.Start();
+
+    p.OutputDataReceived += (x, y) => cmdOut += y.Data;
+    p.ErrorDataReceived += (x, y) => cmdOut += y.Data;
+    p.BeginOutputReadLine();
+    p.BeginErrorReadLine();
+    p.WaitForExit();
+    return cmdOut;
+}
+
+Getting the password:
+
+static SecureString GetPassword()
+{
+    var plainText = "password123";
+    var ss = new SecureString();
+    foreach (char c in plainText)
+    {
+        ss.AppendChar(c);
+    }
+
+    return ss;
+}
+
+Notes
+
+Both of the above methods will return a concatenation of STDOUT and STDERR, as OutputDataReceived and
+
+ErrorDataReceived are both appending to the same variable - cmdOut.
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+151
+
+   
+Section 48.3: Stopwatch
+
+This example shows how Stopwatch can be used to benchmark a block of code.
+
+using System;            
+using System.Diagnostics;
+
+public class Benchmark : IDisposable
+{
+    private Stopwatch sw;
+
+    public Benchmark()
+    {
+        sw = Stopwatch.StartNew();
+    }
+
+    public void Dispose()
+    {
+        sw.Stop();
+        Console.WriteLine(sw.Elapsed);
+    }
+}
+
+public class Program
+{
+    public static void Main()
+    {
+        using (var bench = new Benchmark())
+        {
+            Console.WriteLine("Hello World");
+        }
+    }
+}
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+152
+
+       
+Chapter 49: Encryption / Cryptography
+
+Section 49.1: Encryption and Decryption using Cryptography
+(AES)
+
+Decryption Code
+
+    public static string Decrypt(string cipherText)
+    {
+        if (cipherText == null)
+            return null;
+
+        byte[] cipherBytes = Convert.FromBase64String(cipherText);
+        using (Aes encryptor = Aes.Create())
+        {
+            Rfc2898DeriveBytes pdb = new Rfc2898DeriveBytes(CryptKey, new byte[] { 0x49, 0x76,
+0x61, 0x6e, 0x20, 0x4d, 0x65, 0x64, 0x76, 0x65, 0x64, 0x65, 0x76 });
+            encryptor.Key = pdb.GetBytes(32);
+            encryptor.IV = pdb.GetBytes(16);
+
+            using (MemoryStream ms = new MemoryStream())
+            {
+                using (CryptoStream cs = new CryptoStream(ms, encryptor.CreateDecryptor(),
+CryptoStreamMode.Write))
+                {
+                    cs.Write(cipherBytes, 0, cipherBytes.Length);
+                    cs.Close();
+                }
+
+                cipherText = Encoding.Unicode.GetString(ms.ToArray());
+            }
+        }
+
+        return cipherText;
+    }
+
+Encryption Code
+
+    public static string Encrypt(string cipherText)
+    {
+        if (cipherText == null)
+            return null;
+
+        byte[] clearBytes = Encoding.Unicode.GetBytes(cipherText);
+        using (Aes encryptor = Aes.Create())
+        {
+            Rfc2898DeriveBytes pdb = new Rfc2898DeriveBytes(CryptKey, new byte[] { 0x49, 0x76,
+0x61, 0x6e, 0x20, 0x4d, 0x65, 0x64, 0x76, 0x65, 0x64, 0x65, 0x76 });
+            encryptor.Key = pdb.GetBytes(32);
+            encryptor.IV = pdb.GetBytes(16);
+
+            using (MemoryStream ms = new MemoryStream())
+            {
+                using (CryptoStream cs = new CryptoStream(ms, encryptor.CreateEncryptor(),
+CryptoStreamMode.Write))
+                {
+                    cs.Write(clearBytes, 0, clearBytes.Length);
+                    cs.Close();
+                }
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+153
+
+   
+     
+                cipherText = Convert.ToBase64String(ms.ToArray());
+            }
+        }
+        return cipherText;
+    }
+
+Usage
+
+var textToEncrypt = "TestEncrypt";
+
+var encrypted = Encrypt(textToEncrypt);
+
+var decrypted = Decrypt(encrypted);
+
+Section 49.2: RijndaelManaged
+
+Required Namespace: System.Security.Cryptography
+
+private class Encryption {
+
+          private const string SecretKey = "topSecretKeyusedforEncryptions";
+
+          private const string SecretIv = "secretVectorHere";
+
+          public string Encrypt(string data) {
+            return string.IsNullOrEmpty(data) ? data :
+Convert.ToBase64String(this.EncryptStringToBytesAes(data, this.GetCryptographyKey(),
+this.GetCryptographyIv()));
+          }
+
+          public string Decrypt(string data) {
+            return string.IsNullOrEmpty(data) ? data :
+this.DecryptStringFromBytesAes(Convert.FromBase64String(data), this.GetCryptographyKey(),
+this.GetCryptographyIv());
+          }
+
+          private byte[] GetCryptographyKey() {
+            return Encoding.ASCII.GetBytes(SecretKey.Replace('e', '!'));
+          }
+
+          private byte[] GetCryptographyIv() {
+            return Encoding.ASCII.GetBytes(SecretIv.Replace('r', '!'));
+          }
+
+          private byte[] EncryptStringToBytesAes(string plainText, byte[] key, byte[] iv) {
+            MemoryStream encrypt;
+            RijndaelManaged aesAlg = null;
+            try {
+              aesAlg = new RijndaelManaged {
+                Key = key,
+                IV = iv
+              };
+              var encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);
+              encrypt = new MemoryStream();
+              using (var csEncrypt = new CryptoStream(encrypt, encryptor, CryptoStreamMode.Write))
+{
+                using (var swEncrypt = new StreamWriter(csEncrypt)) {
+                  swEncrypt.Write(plainText);
+                }
+              }
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+154
+
+   
+   
+   
+   
+   
+   
+   
+            } finally {
+              aesAlg?.Clear();
+            }
+            return encrypt.ToArray();
+          }
+
+          private string DecryptStringFromBytesAes(byte[] cipherText, byte[] key, byte[] iv) {
+            RijndaelManaged aesAlg = null;
+            string plaintext;
+            try {
+              aesAlg = new RijndaelManaged {
+                Key = key,
+                IV = iv
+              };
+              var decryptor = aesAlg.CreateDecryptor(aesAlg.Key, aesAlg.IV);
+              using (var msDecrypt = new MemoryStream(cipherText)) {
+                using (var csDecrypt = new CryptoStream(msDecrypt, decryptor,
+CryptoStreamMode.Read)) {
+                  using (var srDecrypt = new StreamReader(csDecrypt))
+                    plaintext = srDecrypt.ReadToEnd();
+                }
+              }
+            } finally {
+              aesAlg?.Clear();
+            }
+            return plaintext;
+          }
+        }
+
+Usage
+
+var textToEncrypt = "hello World";
+
+ var encrypted = new Encryption().Encrypt(textToEncrypt); //-> zBmW+FUxOvdbpOGm9Ss/vQ==
+
+ var decrypted = new Encryption().Decrypt(encrypted); //-> hello World
+
+Note:
+
+Rijndael is the predecessor of the standard symmetric cryptographic algorithm AES.
+
+Section 49.3: Encrypt and decrypt data using AES (in C#)
+
+using System;
+using System.IO;
+using System.Security.Cryptography;
+
+namespace Aes_Example
+{
+    class AesExample
+    {
+        public static void Main()
+        {
+            try
+            {
+                string original = "Here is some data to encrypt!";
+
+                // Create a new instance of the Aes class.
+                // This generates a new key and initialization vector (IV).
+                using (Aes myAes = Aes.Create())
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+155
+
+   
+                {
+                    // Encrypt the string to an array of bytes.
+                    byte[] encrypted = EncryptStringToBytes_Aes(original,
+                                                                myAes.Key,
+                                                                myAes.IV);
+
+                    // Decrypt the bytes to a string.
+                    string roundtrip = DecryptStringFromBytes_Aes(encrypted,
+                                                                  myAes.Key,
+                                                                  myAes.IV);
+
+                    //Display the original data and the decrypted data.
+                    Console.WriteLine("Original:   {0}", original);
+                    Console.WriteLine("Round Trip: {0}", roundtrip);
+                }
+            }
+            catch (Exception e)
+            {
+                Console.WriteLine("Error: {0}", e.Message);
+            }
+        }
+
+        static byte[] EncryptStringToBytes_Aes(string plainText, byte[] Key, byte[] IV)
+        {
+            // Check arguments.
+            if (plainText == null || plainText.Length <= 0)
+                throw new ArgumentNullException("plainText");
+            if (Key == null || Key.Length <= 0)
+                throw new ArgumentNullException("Key");
+            if (IV == null || IV.Length <= 0)
+                throw new ArgumentNullException("IV");
+
+            byte[] encrypted;
+
+            // Create an Aes object with the specified key and IV.
+            using (Aes aesAlg = Aes.Create())
+            {
+                aesAlg.Key = Key;
+                aesAlg.IV = IV;
+
+                // Create a decrytor to perform the stream transform.
+                ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key,
+                                                                    aesAlg.IV);
+
+                // Create the streams used for encryption.
+                using (MemoryStream msEncrypt = new MemoryStream())
+                {
+                    using (CryptoStream csEncrypt = new CryptoStream(msEncrypt,
+                                                                     encryptor,
+                                                                     CryptoStreamMode.Write))
+                    {
+                        using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
+                        {
+                            //Write all data to the stream.
+                            swEncrypt.Write(plainText);
+                        }
+
+                        encrypted = msEncrypt.ToArray();
+                    }
+                }
+            }
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+156
+
+            // Return the encrypted bytes from the memory stream.
+            return encrypted;
+        }
+
+        static string DecryptStringFromBytes_Aes(byte[] cipherText, byte[] Key, byte[] IV)
+        {
+            // Check arguments.
+            if (cipherText == null || cipherText.Length <= 0)
+                throw new ArgumentNullException("cipherText");
+            if (Key == null || Key.Length <= 0)
+                throw new ArgumentNullException("Key");
+            if (IV == null || IV.Length <= 0)
+                throw new ArgumentNullException("IV");
+
+            // Declare the string used to hold the decrypted text.
+            string plaintext = null;
+
+            // Create an Aes object with the specified key and IV.
+            using (Aes aesAlg = Aes.Create())
+            {
+                aesAlg.Key = Key;
+                aesAlg.IV = IV;
+
+                // Create a decrytor to perform the stream transform.
+                ICryptoTransform decryptor = aesAlg.CreateDecryptor(aesAlg.Key,
+                                                                    aesAlg.IV);
+
+                // Create the streams used for decryption.
+                using (MemoryStream msDecrypt = new MemoryStream(cipherText))
+                {
+                    using (CryptoStream csDecrypt = new CryptoStream(msDecrypt,
+                                                                     decryptor,
+                                                                     CryptoStreamMode.Read))
+                    {
+                        using (StreamReader srDecrypt = new StreamReader(csDecrypt))
+                        {
+
+                            // Read the decrypted bytes from the decrypting stream
+                            // and place them in a string.
+                            plaintext = srDecrypt.ReadToEnd();
+                        }
+                    }
+                }
+            }
+
+            return plaintext;
+        }
+    }
+}
+
+This example is from MSDN.
+
+It is a console demo application, showing how to encrypt a string by using the standard AES encryption, and how to
+decrypt it afterwards.
+
+(AES = Advanced Encryption Standard, a specification for the encryption of electronic data established by the U.S.
+National Institute of Standards and Technology (NIST) in 2001 which is still the de-facto standard for symmetric
+
+encryption)
+
+Notes:
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+157
+
+In a real encryption scenario, you need to choose a proper cipher mode (can be assigned to the Mode
+
+property by selecting a value from the CipherMode enumeration). Never use the CipherMode.ECB (electronic
+codebook mode), since this procuces a weak cypher stream
+
+To create a good (and not a weak) Key, either use a cryptographic random generator or use the example
+
+above (Create a Key from a Password). The recommended KeySize is 256 bit. Supported key sizes are
+available via the LegalKeySizes property.
+
+To initialize the initialization vector IV, you can use a SALT as shown in the example above (Random SALT)
+
+Supported block sizes are available via the SupportedBlockSizes property, the block size can be assigned via
+
+the BlockSize property
+
+Usage: see Main() method.
+
+Section 49.4: Create a Key from a Password / Random SALT
+(in C#)
+
+using System;
+using System.Security.Cryptography;
+using System.Text;
+
+public class PasswordDerivedBytesExample
+{
+    public static void Main(String[] args)
+    {
+        // Get a password from the user.
+        Console.WriteLine("Enter a password to produce a key:");
+
+        byte[] pwd = Encoding.Unicode.GetBytes(Console.ReadLine());
+
+        byte[] salt = CreateRandomSalt(7);
+
+        // Create a TripleDESCryptoServiceProvider object.
+        TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider();
+
+        try
+        {
+            Console.WriteLine("Creating a key with PasswordDeriveBytes...");
+
+            // Create a PasswordDeriveBytes object and then create
+            // a TripleDES key from the password and salt.
+            PasswordDeriveBytes pdb = new PasswordDeriveBytes(pwd, salt);
+
+            // Create the key and set it to the Key property
+            // of the TripleDESCryptoServiceProvider object.
+            tdes.Key = pdb.CryptDeriveKey("TripleDES", "SHA1", 192, tdes.IV);
+
+            Console.WriteLine("Operation complete.");
+        }
+        catch (Exception e)
+        {
+            Console.WriteLine(e.Message);
+        }
+        finally
+        {
+            // Clear the buffers
+            ClearBytes(pwd);
+            ClearBytes(salt);
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+158
+
+            // Clear the key.
+            tdes.Clear();
+        }
+
+        Console.ReadLine();
+    }
+
+    #region Helper methods
+
+    /// <summary>
+    /// Generates a random salt value of the specified length.
+    /// </summary>
+    public static byte[] CreateRandomSalt(int length)
+    {
+        // Create a buffer
+        byte[] randBytes;
+
+        if (length >= 1)
+        {
+            randBytes = new byte[length];
+        }
+        else
+        {
+            randBytes = new byte[1];
+        }
+
+        // Create a new RNGCryptoServiceProvider.
+        RNGCryptoServiceProvider rand = new RNGCryptoServiceProvider();
+
+        // Fill the buffer with random bytes.
+        rand.GetBytes(randBytes);
+
+        // return the bytes.
+        return randBytes;
+    }
+
+    /// <summary>
+    /// Clear the bytes in a buffer so they can't later be read from memory.
+    /// </summary>
+    public static void ClearBytes(byte[] buffer)
+    {
+        // Check arguments.
+        if (buffer == null)
+        {
+            throw new ArgumentNullException("buffer");
+        }
+
+        // Set each byte in the buffer to 0.
+        for (int x = 0; x < buffer.Length; x++)
+        {
+            buffer[x] = 0;
+        }
+    }
+
+    #endregion
+}
+
+This example is taken from MSDN.
+
+It is a console demo, and it shows how to create a secure key based on a user-defined password, and how to create
+
+a random SALT based on the cryptographic random generator.
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+159
+
+Notes:
+
+The built-in function PasswordDeriveBytes uses the standard PBKDF1 algorithm to generate a key from the
+
+password. Per default, it uses 100 iterations to generate the key to slow down brute force attacks. The SALT
+
+generated randomly further strenghens the key.
+
+The function CryptDeriveKey converts the key generated by PasswordDeriveBytes into a key compatible
+
+with the specified encryption algorithm (here "TripleDES") by using the specified hash algorithm (here
+
+"SHA1"). The keysize in this example is 192 bytes, and the initialization vector IV is taken from the triple-DES
+
+crypto provider
+
+Usually, this mechanism is used to protect a stronger random generated key by a password, which encrypts
+
+large amount of data. You can also use it to provide multiple passwords of different users to give access to
+
+the same data (being protected by a different random key).
+
+Unfortunately, CryptDeriveKey does currently not support AES. See here.
+
+NOTE: As a workaround, you can create a random AES key for encryption of the data to be protected with
+AES and store the AES key in a TripleDES-Container which uses the key generated by CryptDeriveKey. But
+
+that limits the security to TripleDES, does not take advantage of the larger keysizes of AES and creates a
+
+dependency to TripleDES.
+
+Usage: See Main() method.
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+160
+
+Chapter 50: Work with SHA1 in C#
+
+in this project you see how to work with SHA1 cryptographic hash function. for example get hash from string and
+
+how to crack SHA1 hash.
+
+source compelete on github: https://github.com/mahdiabasi/SHA1Tool
+
+Section 50.1: #Generate SHA1 checksum of a file
+
+first you add System.Security.Cryptography namespace to your project
+
+public string GetSha1Hash(string filePath)
+    {
+        using (FileStream fs = File.OpenRead(filePath))
+        {
+            SHA1 sha = new SHA1Managed();
+            return BitConverter.ToString(sha.ComputeHash(fs));
+        }
+    }
+
+Section 50.2: #Generate hash of a text
+
+  public static string TextToHash(string text)
+    {
+        var sh = SHA1.Create();
+        var hash = new StringBuilder();
+        byte[] bytes = Encoding.UTF8.GetBytes(text);
+        byte[] b = sh.ComputeHash(bytes);
+        foreach (byte a in b)
+        {
+            var h = a.ToString("x2");
+            hash.Append(h);
+        }
+        return hash.ToString();
+    }
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+161
+
+Chapter 51: Unit testing
+
+Section 51.1: Adding MSTest unit testing project to an existing
+solution
+
+Right click on the solution, Add new project
+
+From the Test section, select an Unit Test Project
+
+Pick a name for the assembly - if you are testing project Foo, the name can be Foo.Tests
+
+Add a reference to the tested project in the unit test project references
+
+Section 51.2: Creating a sample test method
+
+MSTest (the default testing framework) requires you to have your test classes decorated by a [TestClass] attribute,
+
+and the test methods with a [TestMethod] attribute, and to be public.
+
+[TestClass]
+public class FizzBuzzFixture
+{
+    [TestMethod]
+    public void Test1()
+    {
+        //arrange
+        var solver = new FizzBuzzSolver();
+        //act
+        var result = solver.FizzBuzz(1);
+        //assert
+        Assert.AreEqual("1",result);
+    }
+}
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+162
+
+Chapter 52: Write to and read from StdErr
+stream
+
+Section 52.1: Write to standard error output using Console
+
+var sourceFileName = "NonExistingFile";
+try
+{
+    System.IO.File.Copy(sourceFileName, "DestinationFile");
+}
+catch (Exception e)
+{
+    var stdErr = Console.Error;
+    stdErr.WriteLine($"Failed to copy '{sourceFileName}': {e.Message}");
+}
+
+Section 52.2: Read from standard error of child process
+
+var errors = new System.Text.StringBuilder();
+var process = new Process
+{
+    StartInfo = new ProcessStartInfo
+    {
+        RedirectStandardError = true,
+        FileName = "xcopy.exe",
+        Arguments = "\"NonExistingFile\" \"DestinationFile\"",
+        UseShellExecute = false
+    },
+
+};
+process.ErrorDataReceived += (s, e) => errors.AppendLine(e.Data);
+process.Start();
+process.BeginErrorReadLine();
+process.WaitForExit();
+
+if (errors.Length > 0) // something went wrong
+    System.Console.Error.WriteLine($"Child process error: \r\n {errors}");
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+163
+
+           
+Chapter 53: Upload file and POST data to
+webserver
+
+Section 53.1: Upload file with WebRequest
+
+To send a file and form data in single request, content should have multipart/form-data type.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Net;
+using System.Threading.Tasks;
+
+public async Task<string> UploadFile(string url, string filename,
+    Dictionary<string, object> postData)
+{
+    var request = WebRequest.CreateHttp(url);
+    var boundary = $"{Guid.NewGuid():N}"; // boundary will separate each parameter
+    request.ContentType = $"multipart/form-data; {nameof(boundary)}={boundary}";
+    request.Method = "POST";
+
+    using (var requestStream = request.GetRequestStream())
+    using (var writer = new StreamWriter(requestStream))
+    {
+        foreach (var data in postData)
+            await writer.WriteAsync( // put all POST data into request
+                $"\r\n--{boundary}\r\nContent-Disposition: " +
+                $"form-data; name=\"{data.Key}\"\r\n\r\n{data.Value}");
+
+        await writer.WriteAsync( // file header
+            $"\r\n--{boundary}\r\nContent-Disposition: " +
+            $"form-data; name=\"File\"; filename=\"{Path.GetFileName(filename)}\"\r\n" +
+            "Content-Type: application/octet-stream\r\n\r\n");
+
+        await writer.FlushAsync();
+        using (var fileStream = File.OpenRead(filename))
+            await fileStream.CopyToAsync(requestStream);
+
+        await writer.WriteAsync($"\r\n--{boundary}--\r\n");
+    }
+
+    using (var response = (HttpWebResponse) await request.GetResponseAsync())
+    using (var responseStream = response.GetResponseStream())
+    {
+        if (responseStream == null)
+            return string.Empty;
+        using (var reader = new StreamReader(responseStream))
+            return await reader.ReadToEndAsync();
+    }
+}
+
+Usage:
+
+var response = await uploader.UploadFile("< YOUR URL >", "< PATH TO YOUR FILE >",
+    new Dictionary<string, object>
+    {
+        {"Comment", "test"},
+        {"Modified", DateTime.Now }
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+164
+
+    });
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+165
+
+Chapter 54: Networking
+
+Section 54.1: Basic TCP chat (TcpListener, TcpClient,
+NetworkStream)
+
+using System;
+using System.IO;
+using System.Net;
+using System.Net.Sockets;
+using System.Text;
+
+class TcpChat
+{
+    static void Main(string[] args)
+    {
+        if(args.Length == 0)
+        {
+            Console.WriteLine("Basic TCP chat");
+            Console.WriteLine();
+            Console.WriteLine("Usage:");
+            Console.WriteLine("tcpchat server <port>");
+            Console.WriteLine("tcpchat client <url> <port>");
+            return;
+        }
+
+        try
+        {
+            Run(args);
+        }
+        catch(IOException)
+        {
+            Console.WriteLine("--- Connection lost");
+        }
+        catch(SocketException ex)
+        {
+            Console.WriteLine("--- Can't connect: " + ex.Message);
+        }
+    }
+
+    static void Run(string[] args)
+    {
+        TcpClient client;
+        NetworkStream stream;
+        byte[] buffer = new byte[256];
+        var encoding = Encoding.ASCII;
+
+        if(args[0].StartsWith("s", StringComparison.InvariantCultureIgnoreCase))
+        {
+            var port = int.Parse(args[1]);
+            var listener = new TcpListener(IPAddress.Any, port);
+            listener.Start();
+            Console.WriteLine("--- Waiting for a connection...");
+            client = listener.AcceptTcpClient();
+        }
+        else
+        {
+            var hostName = args[1];
+            var port = int.Parse(args[2]);
+            client = new TcpClient();
+            client.Connect(hostName, port);
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+166
+
+   
+        }
+
+        stream = client.GetStream();
+        Console.WriteLine("--- Connected. Start typing! (exit with Ctrl-C)");
+
+        while(true)
+        {
+            if(Console.KeyAvailable)
+            {
+                var lineToSend = Console.ReadLine();
+                var bytesToSend = encoding.GetBytes(lineToSend + "\r\n");
+                stream.Write(bytesToSend, 0, bytesToSend.Length);
+                stream.Flush();
+            }
+
+            if (stream.DataAvailable)
+            {
+                var receivedBytesCount = stream.Read(buffer, 0, buffer.Length);
+                var receivedString = encoding.GetString(buffer, 0, receivedBytesCount);
+                Console.Write(receivedString);
+            }
+        }
+    }
+}
+
+Section 54.2: Basic SNTP client (UdpClient)
+
+See RFC 2030 for details on the SNTP protocol.
+
+using System;
+using System.Globalization;
+using System.Linq;
+using System.Net;
+using System.Net.Sockets;
+
+class SntpClient
+{
+    const int SntpPort = 123;
+    static DateTime BaseDate = new DateTime(1900, 1, 1);
+
+    static void Main(string[] args)
+    {
+        if(args.Length == 0) {
+            Console.WriteLine("Simple SNTP client");
+            Console.WriteLine();
+            Console.WriteLine("Usage: sntpclient <sntp server url> [<local timezone>]");
+            Console.WriteLine();
+            Console.WriteLine("<local timezone>: a number between -12 and 12 as hours from UTC");
+            Console.WriteLine("(append .5 for an extra half an hour)");
+            return;
+        }
+
+        double localTimeZoneInHours = 0;
+        if(args.Length > 1)
+            localTimeZoneInHours = double.Parse(args[1], CultureInfo.InvariantCulture);
+
+        var udpClient = new UdpClient();
+        udpClient.Client.ReceiveTimeout = 5000;
+
+        var sntpRequest = new byte[48];
+        sntpRequest[0] = 0x23; //LI=0 (no warning), VN=4, Mode=3 (client)
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+167
+
+        udpClient.Send(
+            dgram: sntpRequest,
+            bytes: sntpRequest.Length,
+            hostname: args[0],
+            port: SntpPort);
+
+        byte[] sntpResponse;
+        try
+        {
+            IPEndPoint remoteEndpoint = null;
+            sntpResponse = udpClient.Receive(ref remoteEndpoint);
+        }
+        catch(SocketException)
+        {
+            Console.WriteLine("*** No response received from the server");
+            return;
+        }
+
+        uint numberOfSeconds;
+        if(BitConverter.IsLittleEndian)
+            numberOfSeconds = BitConverter.ToUInt32(
+                sntpResponse.Skip(40).Take(4).Reverse().ToArray()
+                ,0);
+        else
+            numberOfSeconds = BitConverter.ToUInt32(sntpResponse, 40);
+
+        var date = BaseDate.AddSeconds(numberOfSeconds).AddHours(localTimeZoneInHours);
+
+        Console.WriteLine(
+            $"Current date in server: {date:yyyy-MM-dd HH:mm:ss}
+UTC{localTimeZoneInHours:+0.#;-0.#;.}");
+    }
+}
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+168
+
+       
+Chapter 55: HTTP servers
+
+Section 55.1: Basic read-only HTTP file server (ASP.NET Core)
+
+1 - Create an empty folder, it will contain the files created in the next steps.
+
+2 - Create a file named project.json with the following content (adjust the port number and rootDirectory as
+
+appropriate):
+
+{
+  "dependencies": {
+    "Microsoft.AspNet.Server.Kestrel": "1.0.0-rc1-final",
+    "Microsoft.AspNet.StaticFiles": "1.0.0-rc1-final"
+  },
+
+  "commands": {
+    "web": "Microsoft.AspNet.Server.Kestrel --server.urls http://localhost:60000"
+  },
+
+  "frameworks": {
+    "dnxcore50": { }
+  },
+
+  "fileServer": {
+    "rootDirectory": "c:\\users\\username\\Documents"
+  }
+}
+
+3 - Create a file named Startup.cs with the following code:
+
+using System;
+using Microsoft.AspNet.Builder;
+using Microsoft.AspNet.FileProviders;
+using Microsoft.AspNet.Hosting;
+using Microsoft.AspNet.StaticFiles;
+using Microsoft.Extensions.Configuration;
+
+public class Startup
+{
+    public void Configure(IApplicationBuilder app)
+    {
+        var builder = new ConfigurationBuilder();
+        builder.AddJsonFile("project.json");
+        var config = builder.Build();
+        var rootDirectory = config["fileServer:rootDirectory"];
+        Console.WriteLine("File server root directory: " + rootDirectory);
+
+        var fileProvider = new PhysicalFileProvider(rootDirectory);
+
+        var options = new StaticFileOptions();
+        options.ServeUnknownFileTypes = true;
+        options.FileProvider = fileProvider;
+        options.OnPrepareResponse = context =>
+        {
+            context.Context.Response.ContentType = "application/octet-stream";
+            context.Context.Response.Headers.Add(
+                "Content-Disposition",
+                $"Attachment; filename=\"{context.File.Name}\"");
+        };
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+169
+
+        app.UseStaticFiles(options);
+    }
+}
+
+4 - Open a command prompt, navigate to the folder and execute:
+
+dnvm use 1.0.0-rc1-final -r coreclr -p
+dnu restore
+
+Note: These commands need to be run only once. Use dnvm list to check the actual number of the latest installed
+version of the core CLR.
+
+5 - Start the server with: dnx web. Files can now be requested at http://localhost:60000/path/to/file.ext.
+
+For simplicity, filenames are assumed to be all ASCII (for the filename part in the Content-Disposition header) and
+
+file access errors are not handled.
+
+Section 55.2: Basic read-only HTTP file server (HttpListener)
+
+Notes:
+
+This example must be run in administrative mode.
+
+Only one simultaneous client is supported.
+
+For simplicity, filenames are assumed to be all ASCII (for the filename part in the Content-Disposition header) and file
+
+access errors are not handled.
+
+using System;
+using System.IO;
+using System.Net;
+
+class HttpFileServer
+{
+    private static HttpListenerResponse response;
+    private static HttpListener listener;
+    private static string baseFilesystemPath;
+
+    static void Main(string[] args)
+    {
+        if (!HttpListener.IsSupported)
+        {
+            Console.WriteLine(
+                "*** HttpListener requires at least Windows XP SP2 or Windows Server 2003.");
+            return;
+        }
+
+        if(args.Length < 2)
+        {
+            Console.WriteLine("Basic read-only HTTP file server");
+            Console.WriteLine();
+            Console.WriteLine("Usage: httpfileserver <base filesystem path> <port>");
+            Console.WriteLine("Request format: http://url:port/path/to/file.ext");
+            return;
+        }
+
+        baseFilesystemPath = Path.GetFullPath(args[0]);
+        var port = int.Parse(args[1]);
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+170
+
+       
+        listener = new HttpListener();
+        listener.Prefixes.Add("http://*:" + port + "/");
+        listener.Start();
+
+        Console.WriteLine("--- Server stated, base path is: " + baseFilesystemPath);
+        Console.WriteLine("--- Listening, exit with Ctrl-C");
+        try
+        {
+            ServerLoop();
+        }
+        catch(Exception ex)
+        {
+            Console.WriteLine(ex);
+            if(response != null)
+            {
+                SendErrorResponse(500, "Internal server error");
+            }
+        }
+    }
+
+    static void ServerLoop()
+    {
+        while(true)
+        {
+            var context = listener.GetContext();
+
+            var request = context.Request;
+            response = context.Response;
+            var fileName = request.RawUrl.Substring(1);
+            Console.WriteLine(
+                "--- Got {0} request for: {1}",
+                request.HttpMethod, fileName);
+
+            if (request.HttpMethod.ToUpper() != "GET")
+            {
+                SendErrorResponse(405, "Method must be GET");
+                continue;
+            }
+
+            var fullFilePath = Path.Combine(baseFilesystemPath, fileName);
+            if(!File.Exists(fullFilePath))
+            {
+                SendErrorResponse(404, "File not found");
+                continue;
+            }
+
+            Console.Write("    Sending file...");
+            using (var fileStream = File.OpenRead(fullFilePath))
+            {
+                response.ContentType = "application/octet-stream";
+                response.ContentLength64 = (new FileInfo(fullFilePath)).Length;
+                response.AddHeader(
+                    "Content-Disposition",
+                    "Attachment; filename=\"" + Path.GetFileName(fullFilePath) + "\"");
+                fileStream.CopyTo(response.OutputStream);
+            }
+
+            response.OutputStream.Close();
+            response = null;
+            Console.WriteLine(" Ok!");
+        }
+    }
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+171
+
+    static void SendErrorResponse(int statusCode, string statusResponse)
+    {
+        response.ContentLength64 = 0;
+        response.StatusCode = statusCode;
+        response.StatusDescription = statusResponse;
+        response.OutputStream.Close();
+        Console.WriteLine("*** Sent error: {0} {1}", statusCode, statusResponse);
+    }
+}
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+172
+
+Chapter 56: HTTP clients
+
+Section 56.1: Reading GET response as string using
+System.Net.HttpClient
+
+HttpClient is available through NuGet: Microsoft HTTP Client Libraries.
+
+string requestUri = "http://www.example.com";
+string responseData;
+
+using (var client = new HttpClient())
+{
+    using(var response = client.GetAsync(requestUri).Result)
+    {
+       response.EnsureSuccessStatusCode();
+       responseData = response.Content.ReadAsStringAsync().Result;
+    }
+}
+
+Section 56.2: Basic HTTP downloader using
+System.Net.Http.HttpClient
+
+using System;
+using System.IO;
+using System.Linq;
+using System.Net.Http;
+using System.Threading.Tasks;
+
+class HttpGet
+{
+    private static async Task DownloadAsync(string fromUrl, string toFile)
+    {
+        using (var fileStream = File.OpenWrite(toFile))
+        {
+            using (var httpClient = new HttpClient())
+            {
+                Console.WriteLine("Connecting...");
+                using (var networkStream = await httpClient.GetStreamAsync(fromUrl))
+                {
+                    Console.WriteLine("Downloading...");
+                    await networkStream.CopyToAsync(fileStream);
+                    await fileStream.FlushAsync();
+                }
+            }
+        }
+    }
+
+    static void Main(string[] args)
+    {
+        try
+        {
+            Run(args).Wait();
+        }
+        catch (Exception ex)
+        {
+            if (ex is AggregateException)
+                ex = ((AggregateException)ex).Flatten().InnerExceptions.First();
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+173
+
+            Console.WriteLine("--- Error: " +
+                (ex.InnerException?.Message ?? ex.Message));
+        }
+    }
+    static async Task Run(string[] args)
+    {
+        if (args.Length < 2)
+        {
+            Console.WriteLine("Basic HTTP downloader");
+            Console.WriteLine();
+            Console.WriteLine("Usage: httpget <url>[<:port>] <file>");
+            return;
+        }
+
+        await DownloadAsync(fromUrl: args[0], toFile: args[1]);
+
+        Console.WriteLine("Done!");
+    }
+}
+
+Section 56.3: Reading GET response as string using
+System.Net.HttpWebRequest
+
+string requestUri = "http://www.example.com";
+string responseData;
+
+HttpWebRequest request = (HttpWebRequest)WebRequest.Create(parameters.Uri);
+WebResponse response = request.GetResponse();
+
+using (StreamReader responseReader = new StreamReader(response.GetResponseStream()))
+{
+    responseData = responseReader.ReadToEnd();
+}
+
+Section 56.4: Reading GET response as string using
+System.Net.WebClient
+
+string requestUri = "http://www.example.com";
+string responseData;
+
+using (var client = new WebClient())
+{    
+    responseData = client.DownloadString(requestUri);
+}
+
+Section 56.5: Sending a POST request with a string payload
+using System.Net.HttpWebRequest
+
+string requestUri = "http://www.example.com";
+string requestBodyString = "Request body string.";
+string contentType = "text/plain";
+string requestMethod = "POST";
+
+HttpWebRequest request = (HttpWebRequest)WebRequest.Create(requestUri)
+{
+  Method = requestMethod,
+  ContentType = contentType,
+};
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+174
+
+byte[] bytes = Encoding.UTF8.GetBytes(requestBodyString);
+Stream stream = request.GetRequestStream();
+stream.Write(bytes, 0, bytes.Length);
+stream.Close();
+
+HttpWebResponse response = (HttpWebResponse)request.GetResponse();
+
+Section 56.6: Sending a POST request with a string payload
+using System.Net.WebClient
+
+string requestUri = "http://www.example.com";
+string requestBodyString = "Request body string.";
+string contentType = "text/plain";
+string requestMethod = "POST";
+
+byte[] responseBody;    
+byte[] requestBodyBytes = Encoding.UTF8.GetBytes(requestBodyString);
+
+using (var client = new WebClient())
+{
+    client.Headers[HttpRequestHeader.ContentType] = contentType;
+    responseBody = client.UploadData(requestUri, requestMethod, requestBodyBytes);
+}
+
+Section 56.7: Sending a POST request with a string payload
+using System.Net.HttpClient
+
+HttpClient is available through NuGet: Microsoft HTTP Client Libraries.
+
+string requestUri = "http://www.example.com";
+string requestBodyString = "Request body string.";
+string contentType = "text/plain";
+string requestMethod = "POST";
+
+var request = new HttpRequestMessage
+{
+    RequestUri = requestUri,
+    Method = requestMethod,
+};
+
+byte[] requestBodyBytes = Encoding.UTF8.GetBytes(requestBodyString);
+request.Content = new ByteArrayContent(requestBodyBytes);
+
+request.Content.Headers.ContentType = new MediaTypeHeaderValue(contentType);
+
+HttpResponseMessage result = client.SendAsync(request).Result;
+result.EnsureSuccessStatusCode();
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+175
+
+   
+Chapter 57: Serial Ports
+
+Section 57.1: Basic operation
+
+var serialPort = new SerialPort("COM1", 9600, Parity.Even, 8, StopBits.One);
+serialPort.Open();
+serialPort.WriteLine("Test data");
+string response = serialPort.ReadLine();
+Console.WriteLine(response);
+serialPort.Close();
+
+Section 57.2: List available port names
+
+string[] portNames = SerialPort.GetPortNames();
+
+Section 57.3: Asynchronous read
+
+void SetupAsyncRead(SerialPort serialPort)
+{
+    serialPort.DataReceived += (sender, e) => {
+        byte[] buffer = new byte[4096];
+        switch (e.EventType)
+        {
+            case SerialData.Chars:
+                var port = (SerialPort)sender;
+                int bytesToRead = port.BytesToRead;
+                if (bytesToRead > buffer.Length)
+                    Array.Resize(ref buffer, bytesToRead);
+                int bytesRead = port.Read(buffer, 0, bytesToRead);
+                // Process the read buffer here
+                // ...
+                break;
+            case SerialData.Eof:
+                // Terminate the service here
+                // ...
+                break;
+        }
+    };
+
+Section 57.4: Synchronous text echo service
+
+using System.IO.Ports;
+
+namespace TextEchoService
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            var serialPort = new SerialPort("COM1", 9600, Parity.Even, 8, StopBits.One);
+            serialPort.Open();
+            string message = "";
+            while (message != "quit")
+            {
+                message = serialPort.ReadLine();
+                serialPort.WriteLine(message);
+            }
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+176
+
+            serialPort.Close();
+        }
+    }
+}
+
+Section 57.5: Asynchronous message receiver
+
+using System;
+using System.Collections.Generic;
+using System.IO.Ports;
+using System.Text;
+using System.Threading;
+
+namespace AsyncReceiver
+{
+    class Program
+    {
+        const byte STX = 0x02;
+        const byte ETX = 0x03;
+        const byte ACK = 0x06;
+        const byte NAK = 0x15;
+        static ManualResetEvent terminateService = new ManualResetEvent(false);
+        static readonly object eventLock = new object();
+        static List<byte> unprocessedBuffer = null;
+
+        static void Main(string[] args)
+        {
+            try
+            {
+                var serialPort = new SerialPort("COM11", 9600, Parity.Even, 8, StopBits.One);
+                serialPort.DataReceived += DataReceivedHandler;
+                serialPort.ErrorReceived += ErrorReceivedHandler;
+                serialPort.Open();
+                terminateService.WaitOne();
+                serialPort.Close();
+            }
+            catch (Exception e)
+            {
+                Console.WriteLine("Exception occurred: {0}", e.Message);
+            }
+            Console.ReadKey();
+        }
+
+        static void DataReceivedHandler(object sender, SerialDataReceivedEventArgs e)
+        {
+            lock (eventLock)
+            {
+                byte[] buffer = new byte[4096];
+                switch (e.EventType)
+                {
+                    case SerialData.Chars:
+                        var port = (SerialPort)sender;
+                        int bytesToRead = port.BytesToRead;
+                        if (bytesToRead > buffer.Length)
+                            Array.Resize(ref buffer, bytesToRead);
+                        int bytesRead = port.Read(buffer, 0, bytesToRead);
+                        ProcessBuffer(buffer, bytesRead);
+                        break;
+                    case SerialData.Eof:
+                        terminateService.Set();
+                        break;
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+177
+
+                }
+            }
+        }
+        static void ErrorReceivedHandler(object sender, SerialErrorReceivedEventArgs e)
+        {
+            lock (eventLock)
+                if (e.EventType == SerialError.TXFull)
+                {
+                    Console.WriteLine("Error: TXFull. Can't handle this!");
+                    terminateService.Set();
+                }
+                else
+                {
+                    Console.WriteLine("Error: {0}. Resetting everything", e.EventType);
+                    var port = (SerialPort)sender;
+                    port.DiscardInBuffer();
+                    port.DiscardOutBuffer();
+                    unprocessedBuffer = null;
+                    port.Write(new byte[] { NAK }, 0, 1);
+                }
+        }
+
+        static void ProcessBuffer(byte[] buffer, int length)
+        {
+            List<byte> message = unprocessedBuffer;
+            for (int i = 0; i < length; i++)
+                if (buffer[i] == ETX)
+                {
+                    if (message != null)
+                    {
+                        Console.WriteLine("MessageReceived: {0}",
+                            Encoding.ASCII.GetString(message.ToArray()));
+                        message = null;
+                    }
+                }
+                else if (buffer[i] == STX)
+                    message = null;
+                else if (message != null)
+                    message.Add(buffer[i]);
+            unprocessedBuffer = message;
+        }
+    }
+}
+
+This program waits for messages enclosed in STX and ETX bytes and outputs the text coming between them.
+
+Everything else is discarded. On write buffer overflow it stops. On other errors it reset input and output buffers and
+
+waits for further messages.
+
+The code illustrates:
+
+Asynchronous serial port reading (see SerialPort.DataReceived usage).
+
+Serial port error processing (see SerialPort.ErrorReceived usage).
+
+Non-text message-based protocol implementation.
+
+Partial message reading.
+
+The SerialPort.DataReceived event may happen earlier than entire message (up to ETX) comes. The
+
+entire message may also not be available in the input buffer (SerialPort.Read(..., ..., port.BytesToRead)
+
+reads only a part of the message). In this case we stash the received part (unprocessedBuffer) and
+
+carry on waiting for further data.
+
+Dealing with several messages coming in one go.
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+178
+
+The SerialPort.DataReceived event may happen only after several messages have been sent by the
+
+other end.
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+179
+
+Appendix A: Acronym Glossary
+
+Section A.1: .Net Related Acronyms
+
+Please note that some terms like JIT and GC are generic enough to apply to many programming language
+
+environments and runtimes.
+
+CLR: Common Language Runtime
+
+IL: Intermediate Language
+
+EE: Execution Engine
+
+JIT: Just-in-time compiler
+
+GC: Garbage Collector
+
+OOM: Out of memory
+
+STA: Single-threaded apartment
+
+MTA: Multi-threaded apartment
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+180
+
+Credits
+
+Thank you greatly to all the people from Stack Overflow Documentation who helped provide this content,
+
+more changes can be sent to web@petercv.com for new content to be published or updated
+
+Adi Lester
+Adil Mammadov
+Adriano Repetti
+Akshay Anand
+Alan McBee
+ale10ander
+Aleks Andreev
+Alexander Mandt
+Alexander V.
+Alfred Myers
+Aman Sharma
+Andrew Jens
+Andrew Morton
+Andrey Shchekin
+Andrius
+Anik Saha
+Aphelion
+Arvin Baccay
+Arxae
+Ashtonian
+Athari
+avat
+Axarydax
+BananaSft
+Bassie
+Behzad
+Benjamin Hodgson
+binki
+Bjørn
+Bradley Grainger
+Bruno Garcia
+BrunoLM
+Carlos Muñoz
+CodeCaster
+Daniel A. White
+Darrel Lee
+Dave R.
+dbasnett
+delete me
+demonplus
+Denuath
+DLeh
+Dmitry Egorov
+DoNot
+Dr Rob Lang
+Drew
+DrewJordan
+
+Chapters 42 and 47
+Chapter 8
+Chapters 1, 2, 4 and 18
+Chapter 25
+Chapters 12, 14 and 47
+Chapters 16 and 35
+Chapters 10, 52 and 53
+Chapter 49
+Chapter 8
+Chapter 47
+Chapters 5 and 42
+Chapter 1
+Chapter 25
+Chapter 28
+Chapter 32
+Chapter 28
+Chapter 34
+Chapter 47
+Chapter 19
+Chapter 28
+Chapter 1
+Chapter 46
+Chapter 51
+Chapter 47
+Chapter 48
+Chapter 39
+Chapter 8
+Chapter 45
+Chapters 4 and 10
+Chapter 8
+Chapter 8
+Chapter 15
+Chapter 8
+Chapters 8, 17, 28, 47 and 56
+Chapters 1 and 25
+Chapter 4
+Chapter 47
+Chapter 35
+Chapter 18
+Chapters 30 and 49
+Chapter 15
+Chapters 31 and 33
+Chapters 27 and 57
+Chapter 8
+Chapter 9
+Chapter 25
+Chapters 12 and 45
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+181
+
+Eduardo Molteni
+Ehsan Sajjad
+Eric
+Felipe Oriani
+Filip Frącz
+Fredou
+Gajendra
+GalacticCowboy
+George Polevoy
+Guanxi
+Gusdor
+Haney
+harriyott
+hatchet
+Heinzi
+Hogan
+Hywel Rees
+i3arnon
+Ian
+Igor
+Ingenioushax
+Jacobr365
+Jagadisha B S
+JamyRyals
+jbtule
+Jigar
+Jim
+jnovo
+Joe Amenta
+John
+Kevin Montrose
+Konamiman
+Krikor Ailanjian
+Kritner
+lokusking
+Lorenzo Dematté
+Luaan
+Lucas Trzesniewski
+M22an
+Mafii
+mahdi abasi
+MarcinJuraszek
+Mark C.
+Matas Vaitkevicius
+Mathias Müller
+Matt
+Matt dc
+matteeyah
+Matthew Whited
+McKay
+Mellow
+Mihail Stancescu
+Mr.Mindor
+
+Chapter 8
+Chapter 8
+Chapter 32
+Chapters 4 and 5
+Chapter 17
+Chapter 48
+Chapter 37
+Chapters 3 and 8
+Chapters 4, 11 and 34
+Chapter 22
+Chapters 43 and 44
+Chapter 8
+Chapter 5
+Chapter 4
+Chapter 25
+Chapter 4
+Chapter 7
+Chapter 38
+Chapter 4
+Chapter 25
+Chapter 16
+Chapters 38, 42 and 43
+Chapter 49
+Chapter 42
+Chapter 8
+Chapter 10
+Chapter 11
+Chapter 8
+Chapters 8 and 20
+Chapter 3
+Chapter 1
+Chapters 8, 42, 54, 55 and 56
+Chapter 36
+Chapter 47
+Chapter 49
+Chapter 10
+Chapter 23
+Chapter 9
+Chapter 32
+Chapter 47
+Chapter 50
+Chapters 1 and 8
+Chapter 5
+Chapters 10 and 28
+Chapter 42
+Chapter 49
+Chapter 15
+Chapter 1
+Chapter 13
+Chapter 8
+Chapter 39
+Chapter 24
+Chapter 8
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+182
+
+MSE
+n.podbielski
+Nate Barbettini
+Nikola.Lukovic
+NikolayKondratyev
+Ogglas
+Ondřej Štorc
+Ozair Kafray
+Pavel Mayorov
+Pavel Voronin
+PedroSouki
+ProgramFOX
+Ringil
+Rion Williams
+Robert Columbia
+RoyalPotato
+Ruben Steins
+Salvador Rubio Martinez
+Sammi
+Scott Hannen
+SeeuD1
+Sergio Domínguez
+Sidewinder94
+smdrager
+starbeamrainbowlabs
+Steve
+Steven Doggart
+Stilgar
+Tanveer Badar
+tehDorf
+the berserker
+Theodoros
+Chatzigiannakis
+Thomas Bledsoe
+Thriggle
+toddmo
+Tolga Evcimen
+Tomáš Hübelbauer
+user2321864
+vicky
+wangengzheng
+Yahfoufi
+ʇolɐǝz ǝɥʇ qoq
+
+Chapter 40
+Chapter 11
+Chapter 8
+Chapter 38
+Chapter 23
+Chapter 48
+Chapter 48
+Chapter 28
+Chapter 42
+Chapters 2 and 42
+Chapter 32
+Chapter 21
+Chapter 4
+Chapter 1
+Chapter 4
+Chapter 17
+Chapter 8
+Chapter 8
+Chapter 8
+Chapters 26 and 29
+Chapter 1
+Chapter 8
+Chapter 8
+Chapter 10
+Chapters 37 and 47
+Chapter 30
+Chapter 1
+Chapter 11
+Chapter 58
+Chapters 6 and 15
+Chapter 4
+
+Chapter 37
+
+Chapter 42
+Chapter 32
+Chapter 23
+Chapter 32
+Chapter 4
+Chapter 25
+Chapter 30
+Chapter 11
+Chapter 41
+Chapter 1
+
+GoalKicker.com – .NET Framework Notes for Professionals
+
+183
+
+You may also like
+
+
\ No newline at end of file