Written by students who passed Immediately available after payment Read online or as PDF Wrong document? Swap it for free 4.6 TrustPilot
logo-home
Summary

Summary Dot NET Framework Notes For Professionals

Rating
-
Sold
-
Pages
186
Uploaded on
07-10-2023
Written in
2023/2024

I am selling you future books (programming). I will present to you everything you will need in terms of knowledge of any programming language in the form of a book with a lot of useful information for you, and as you also know that programmers have very high salaries, I will help you to be great programmers I wish you a pleasant reading and learning.

Show more Read less
Institution
Course

Content preview

Contents
About ................................................................................................................................................................................... 1
Chapter 1: Getting started with .NET Framework ........................................................................................ 2
Section 1.1: Hello World in C# ........................................................................................................................................ 2
Section 1.2: Hello World in F# ....................................................................................................................................... 3
Section 1.3: Hello World in Visual Basic .NET .............................................................................................................. 3
Section 1.4: Hello World in C++/CLI .............................................................................................................................. 3
Section 1.5: Hello World in IL ......................................................................................................................................... 3
Section 1.6: Hello World in PowerShell ......................................................................................................................... 4
Section 1.7: Hello World in Nemerle ............................................................................................................................. 4
Section 1.8: Hello World in Python (IronPython) ......................................................................................................... 4
Section 1.9: Hello World in Oxygene ............................................................................................................................ 4
Section 1.10: Hello World in Boo ................................................................................................................................... 4
Chapter 2: Strings ......................................................................................................................................................... 5
Section 2.1: Count characters ....................................................................................................................................... 5
Section 2.2: Count distinct characters ......................................................................................................................... 5
Section 2.3: Convert string to/from another encoding ............................................................................................. 5
Section 2.4: Comparing strings .................................................................................................................................... 6
Section 2.5: Count occurrences of a character .......................................................................................................... 6
Section 2.6: Split string into fixed length blocks ......................................................................................................... 6
Section 2.7: Object.ToString() virtual method ............................................................................................................ 7
Section 2.8: Immutability of strings ............................................................................................................................. 8
Chapter 3: DateTime parsing ................................................................................................................................. 9
Section 3.1: ParseExact .................................................................................................................................................. 9
Section 3.2: TryParse .................................................................................................................................................. 10
Section 3.3: TryParseExact ......................................................................................................................................... 12
Chapter 4: Dictionaries ............................................................................................................................................ 13
Section 4.1: Initializing a Dictionary with a Collection Initializer .............................................................................. 13
Section 4.2: Adding to a Dictionary ........................................................................................................................... 13
Section 4.3: Getting a value from a dictionary ......................................................................................................... 13
Section 4.4: Make a Dictionary<string, T> with Case-Insensivitve keys ................................................................. 14
Section 4.5: IEnumerable to Dictionary (≥ .NET 3.5) ................................................................................................ 14
Section 4.6: Enumerating a Dictionary ...................................................................................................................... 14
Section 4.7: ConcurrentDictionary<TKey, TValue> (from .NET 4.0) ...................................................................... 15
Section 4.8: Dictionary to List ..................................................................................................................................... 16
Section 4.9: Removing from a Dictionary ................................................................................................................. 16
Section 4.10: ContainsKey(TKey) ............................................................................................................................... 17
Section 4.11: ConcurrentDictionary augmented with Lazy'1 reduces duplicated computation ........................... 17
Chapter 5: Collections .............................................................................................................................................. 19
Section 5.1: Using collection initializers ...................................................................................................................... 19
Section 5.2: Stack ........................................................................................................................................................ 19
Section 5.3: Creating an initialized List with Custom Types .................................................................................... 20
Section 5.4: Queue ....................................................................................................................................................... 22
Chapter 6: ReadOnlyCollections ......................................................................................................................... 24
Section 6.1: Creating a ReadOnlyCollection .............................................................................................................. 24
Section 6.2: Updating a ReadOnlyCollection ........................................................................................................... 24
Section 6.3: Warning: Elements in a ReadOnlyCollection are not inherently read-only ...................................... 24

,Chapter 7: Stack and Heap ................................................................................................................................... 26
Section 7.1: Value types in use ................................................................................................................................... 26
Section 7.2: Reference types in use ........................................................................................................................... 26
Chapter 8: LINQ ........................................................................................................................................................... 28
Section 8.1: SelectMany (flat map) ............................................................................................................................ 28
Section 8.2: Where (filter) ........................................................................................................................................... 29
Section 8.3: Any ........................................................................................................................................................... 29
Section 8.4: GroupJoin ................................................................................................................................................ 30
Section 8.5: Except ...................................................................................................................................................... 31
Section 8.6: Zip ............................................................................................................................................................ 31
Section 8.7: Aggregate (fold) ..................................................................................................................................... 31
Section 8.8: ToLookup ................................................................................................................................................ 32
Section 8.9: Intersect ................................................................................................................................................... 32
Section 8.10: Concat .................................................................................................................................................... 32
Section 8.11: All ............................................................................................................................................................. 32
Section 8.12: Sum ......................................................................................................................................................... 33
Section 8.13: SequenceEqual ...................................................................................................................................... 33
Section 8.14: Min ........................................................................................................................................................... 33
Section 8.15: Distinct .................................................................................................................................................... 34
Section 8.16: Count ...................................................................................................................................................... 34
Section 8.17: Cast ......................................................................................................................................................... 34
Section 8.18: Range ..................................................................................................................................................... 34
Section 8.19: ThenBy ................................................................................................................................................... 35
Section 8.20: Repeat ................................................................................................................................................... 35
Section 8.21: Empty ..................................................................................................................................................... 35
Section 8.22: Select (map) .......................................................................................................................................... 35
Section 8.23: OrderBy ................................................................................................................................................. 36
Section 8.24: OrderByDescending ............................................................................................................................. 36
Section 8.25: Contains ................................................................................................................................................. 36
Section 8.26: First (find) .............................................................................................................................................. 36
Section 8.27: Single ..................................................................................................................................................... 37
Section 8.28: Last ........................................................................................................................................................ 37
Section 8.29: LastOrDefault ....................................................................................................................................... 37
Section 8.30: SingleOrDefault .................................................................................................................................... 38
Section 8.31: FirstOrDefault ........................................................................................................................................ 38
Section 8.32: Skip ......................................................................................................................................................... 38
Section 8.33: Take ....................................................................................................................................................... 39
Section 8.34: Reverse .................................................................................................................................................. 39
Section 8.35: OfType ................................................................................................................................................... 39
Section 8.36: Max ......................................................................................................................................................... 39
Section 8.37: Average ................................................................................................................................................. 39
Section 8.38: GroupBy ................................................................................................................................................. 40
Section 8.39: ToDictionary .......................................................................................................................................... 40
Section 8.40: Union ...................................................................................................................................................... 41
Section 8.41: ToArray .................................................................................................................................................. 42
Section 8.42: ToList ..................................................................................................................................................... 42
Section 8.43: ElementAt .............................................................................................................................................. 42
Section 8.44: ElementAtOrDefault ............................................................................................................................. 42
Section 8.45: SkipWhile ............................................................................................................................................... 42
Section 8.46: TakeWhile .............................................................................................................................................. 43

, Section 8.47: DefaultIfEmpty ...................................................................................................................................... 43
Section 8.48: Join ........................................................................................................................................................ 43
Section 8.49: Left Outer Join ...................................................................................................................................... 44
Chapter 9: ForEach .................................................................................................................................................... 46
Section 9.1: Extension method for IEnumerable ....................................................................................................... 46
Section 9.2: Calling a method on an object in a list ................................................................................................. 46
Chapter 10: Reflection .............................................................................................................................................. 47
Section 10.1: What is an Assembly? ........................................................................................................................... 47
Section 10.2: Compare two objects with reflection .................................................................................................. 47
Section 10.3: Creating Object and setting properties using reflection ................................................................... 48
Section 10.4: How to create an object of T using Reflection .................................................................................. 48
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 .......................................................................................... 50
Section 11.2: Simple Expression Tree Generated by the C# Compiler .................................................................... 50
Section 11.3: Expression for retrieving a static field .................................................................................................. 51
Section 11.4: InvocationExpression Class ................................................................................................................... 51
Chapter 12: Custom Types ...................................................................................................................................... 54
Section 12.1: Struct Definition ...................................................................................................................................... 54
Section 12.2: Class Definition ...................................................................................................................................... 54
Chapter 13: Code Contracts ................................................................................................................................... 56
Section 13.1: Contracts for Interfaces ........................................................................................................................ 56
Section 13.2: Installing and Enabling Code Contracts .............................................................................................. 56
Section 13.3: Preconditions ......................................................................................................................................... 58
Section 13.4: Postconditions ........................................................................................................................................ 59
Chapter 14: Settings .................................................................................................................................................. 60
Section 14.1: AppSettings from ConfigurationSettings in .NET 1.x ........................................................................... 60
Section 14.2: Reading AppSettings from ConfigurationManager in .NET 2.0 and later ....................................... 60
Section 14.3: Introduction to strongly-typed application and user settings support from Visual Studio
................................................................................................................................................................................ 61
Section 14.4: Reading strongly-typed settings from custom section of configuration file ................................. 62
Chapter 15: Regular Expressions (System.Text.RegularExpressions) .............................................. 65
Section 15.1: Check if pattern matches input ............................................................................................................ 65
Section 15.2: Remove non alphanumeric characters from string .......................................................................... 65
Section 15.3: Passing Options ..................................................................................................................................... 65
Section 15.4: Match into groups ................................................................................................................................. 65
Section 15.5: Find all matches .................................................................................................................................... 65
Section 15.6: Simple match and replace ................................................................................................................... 66
Chapter 16: File Input/Output ............................................................................................................................... 67
Section 16.1: C# File.Exists() ......................................................................................................................................... 67
Section 16.2: VB WriteAllText ...................................................................................................................................... 67
Section 16.3: VB StreamWriter .................................................................................................................................... 67
Section 16.4: C# StreamWriter ................................................................................................................................... 67
Section 16.5: C# WriteAllText() ................................................................................................................................... 68
Chapter 17: System.IO .............................................................................................................................................. 69
Section 17.1: Reading a text file using StreamReader .............................................................................................. 69
Section 17.2: Serial Ports using System.IO.SerialPorts ............................................................................................. 69
Section 17.3: Reading/Writing Data Using System.IO.File ....................................................................................... 70
Chapter 18: System.IO.File class .......................................................................................................................... 72

, Section 18.1: Delete a file ............................................................................................................................................. 72
Section 18.2: Strip unwanted lines from a text file ................................................................................................... 73
Section 18.3: Convert text file encoding .................................................................................................................... 73
Section 18.4: Enumerate files older than a specified amount ................................................................................. 74
Section 18.5: Move a File from one location to another .......................................................................................... 74
Chapter 19: Reading and writing Zip files ...................................................................................................... 76
Section 19.1: Listing ZIP contents ................................................................................................................................ 76
Section 19.2: Extracting files from ZIP files ............................................................................................................... 76
Section 19.3: Updating a ZIP file ................................................................................................................................. 76
Chapter 20: Managed Extensibility Framework .......................................................................................... 78
Section 20.1: Connecting (Basic) ................................................................................................................................ 78
Section 20.2: Exporting a Type (Basic) ..................................................................................................................... 78
Section 20.3: Importing (Basic) .................................................................................................................................. 79
Chapter 21: SpeechRecognitionEngine class to recognize speech .................................................... 80
Section 21.1: Asynchronously recognizing speech based on a restricted set of phrases .................................... 80
Section 21.2: Asynchronously recognizing speech for free text dictation ............................................................. 80
Chapter 22: System.Runtime.Caching.MemoryCache (ObjectCache) .............................................. 81
Section 22.1: Adding Item to Cache (Set) .................................................................................................................. 81
Section 22.2: System.Runtime.Caching.MemoryCache (ObjectCache) ................................................................. 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 ......................................................................................... 87
Section 25.2: Executing SQL statements as a command ....................................................................................... 88
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 ..................................................................... 90
Section 26.2: Dependency Injection - Simple example ........................................................................................... 90
Section 26.3: Why We Use Dependency Injection Containers (IoC Containers) .................................................. 91
Chapter 27: Platform Invoke ................................................................................................................................ 94
Section 27.1: Marshaling structs ................................................................................................................................. 94
Section 27.2: Marshaling unions ................................................................................................................................ 95
Section 27.3: Calling a Win32 dll function ................................................................................................................. 96
Section 27.4: Using Windows API ............................................................................................................................... 97
Section 27.5: Marshalling arrays ................................................................................................................................ 97
Chapter 28: NuGet packaging system ............................................................................................................. 98
Section 28.1: Uninstalling a package from one project in a solution ..................................................................... 98
Section 28.2: Installing a specific version of a package ......................................................................................... 98
Section 28.3: Adding a package source feed (MyGet, Klondike, ect) .................................................................... 98
Section 28.4: Installing the NuGet Package Manager ............................................................................................. 98
Section 28.5: Managing Packages through the UI .................................................................................................. 99
Section 28.6: Managing Packages through the console ......................................................................................... 99
Section 28.7: Updating a package ............................................................................................................................ 99
Section 28.8: Uninstalling a package ...................................................................................................................... 100
Section 28.9: Uninstall a specific version of package ........................................................................................... 100
Chapter 29: Globalization in ASP.NET MVC using Smart internationalization for ASP.NET
............................................................................................................................................................................................ 101

Written for

Institution
Course

Document information

Uploaded on
October 7, 2023
Number of pages
186
Written in
2023/2024
Type
SUMMARY

Subjects

$8.49
Get access to the full document:

Wrong document? Swap it for free Within 14 days of purchase and before downloading, you can choose a different document. You can simply spend the amount again.
Written by students who passed
Immediately available after payment
Read online or as PDF

Get to know the seller
Seller avatar
Michael2030

Get to know the seller

Seller avatar
Michael2030 Published
Follow You need to be logged in order to follow users or courses
Sold
-
Member since
2 year
Number of followers
0
Documents
44
Last sold
-
programming books

I am selling you future books (programming). I will present to you everything you will need in terms of knowledge of any programming language in the form of a book with a lot of useful information for you, and as you also know that programmers have very high salaries, I will help you to be great programmers I wish you a pleasant reading and learning.

0.0

0 reviews

5
0
4
0
3
0
2
0
1
0

Recently viewed by you

Why students choose Stuvia

Created by fellow students, verified by reviews

Quality you can trust: written by students who passed their tests and reviewed by others who've used these notes.

Didn't get what you expected? Choose another document

No worries! You can instantly pick a different document that better fits what you're looking for.

Pay as you like, start learning right away

No subscription, no commitments. Pay the way you're used to via credit card and download your PDF document instantly.

Student with book image

“Bought, downloaded, and aced it. It really can be that simple.”

Alisha Student

Working on your references?

Create accurate citations in APA, MLA and Harvard with our free citation generator.

Working on your references?

Frequently asked questions