Dot Net Core and Progressive Web Application Notes | B.Sc. (Information Technology) Semester 5 | Mumbai University | munotes

Contents

Module I Introduction to C#.NET

1. What .NET Is, and What You Are Actually Installing 1
2. .NET Framework, .NET Core and the Numbered Releases 4
3. Which .NET This Book Runs, and What Your College Lab Will Have 8
4. The Common Language Runtime 11
5. Managed Code, IL and the JIT Compiler 15
6. Assemblies: What the Compiler Produces 18
7. Reading an Assembly, and the Files Beside It 21
8. The dotnet CLI: new, build and run 24
9. dotnet publish, and What Ships to a Server 27
10. The Project File, and What a Package Reference Is 30
11. The Shape of a C# Program 33
12. Value Types and Reference Types 36
13. The Integer Types 39
14. Floating Point, decimal, and Money 43
15. char, string and Text 46
16. bool, and the Operators That Return One 50
17. var, Implicit Typing, and When Not to Use It 53
18. Constants, readonly, and Literals 55
19. Nullable Types, and the null Everybody Meets 57
20. Variables, Scope and Lifetime 60
21. Arithmetic Operators 63
22. Relational and Logical Operators 66
23. Assignment, and the Compound Assignment Operators 69
24. Increment and Decrement, Prefix and Postfix 71
25. The Conditional Operator, and the Null Operators 73
26. Precedence and Order of Evaluation 76
27. Expressions and Statements 79
28. Type Conversion: Implicit, Explicit, Parse and Convert 82
29. if and else 85
30. switch, and the switch Expression 87
31. while and do-while 90
32. The for Loop 93
33. Arrays, and foreach 96
34. break, continue, goto and Labels 99
35. Methods: Declaring One and Calling It 102
36. Parameters: value, ref, out and in 105
37. Optional Arguments, Named Arguments and params 108
38. Method Overloading 110
39. Recursion, and the Method That Calls Itself 113
40. The Three Kinds of Error, and What Error Handling Means 116
41. try, catch and finally 119
42. The Exception Hierarchy, and Choosing What to Catch 122
43. throw, Rethrowing, and Writing Your Own Exception 125
44. Classes and Objects 128
45. Fields, Properties, and a Property That Validates 131
46. Constructors, and Constructor Overloading 134
47. static: Members, Classes and the Main Method 137
48. Inheritance 140
49. The Types of Inheritance, and Why C# Has No Multiple Class Inheritance 143
50. base, and Constructor Chaining 146
51. Polymorphism: virtual, override and new 148
52. Abstract Classes and Abstract Methods 151
53. Interfaces 154
54. Interfaces Against Abstract Classes 157
55. Delegates 159
56. Multicast Delegates 162
57. Events 165
58. Namespaces, and using 168
59. Writing the First Three Practicals: Arithmetic, Floyd's Triangle and Sorted Cities 171
60. What a Web Server Does 174
61. Kestrel, the Reverse Proxy, and the URL a Project Starts On 177
62. The Request Lifecycle 179
63. Middleware, and the Pipeline 182
64. Writing a Middleware of Your Own 184
65. Routing 187
66. Minimal APIs, and the Smallest ASP.NET Core Program 189
67. Controllers 191
68. MVC: Model, View and Controller 194
69. Razor Views, and the View Model 197
70. Razor Pages 200
71. REST, and What Makes an Endpoint RESTful 203
72. Building a REST API Endpoint 206
73. Model Binding and Validation 209
74. Dependency Injection, and Where Configuration Lives 212
75. Entity Framework Core 215
76. CRUD Through EF Core 219
77. Cookies, Sessions and State 222
78. Authentication and Authorization 225
79. Web Forms: What They Are, and Where They Run 228
80. The Web Forms Server Controls MU Sets 231
81. The Validation Controls 234
82. The AdRotator Control 237
83. The Web Forms Page Lifecycle, and Its ASP.NET Core Answer 239

Module II PWA

1. What a Progressive Web Application Is 242
2. How the Idea Arrived 245
3. Reliable, Fast, Engaging 247
4. A PWA Against a Native App 250
5. A PWA Against a Hybrid App 253
6. Why a PWA Requires HTTPS 255
7. localhost, the One Exception 257
8. The Web App Manifest 259
9. The Manifest, Property by Property 261
10. Icons, and the Maskable Icon 264
11. display, orientation, scope and start_url 267
12. Linking the Manifest from the Page 269
13. Installability: What a Browser Requires 271
14. The Service Worker 274
15. Registering a Service Worker 277
16. The Lifecycle: installing, waiting, activated 280
17. Scope, and Which Pages a Worker Controls 283
18. The fetch Event 285
19. The Cache Storage API 288
20. Cache First 291
21. Network First 293
22. Stale While Revalidate 295
23. Choosing a Strategy, Resource by Resource 297
24. Precaching, and Versioning a Cache 300
25. Offline Functionality 303
26. The Custom Offline Page 306
27. An Offline Cart, and Where to Keep It 308
28. Push Notifications 311
29. Permission, and the Notifications API 314
30. Push Subscription and VAPID Keys 317
31. Background Sync, Briefly 320
32. Mobile First 323
33. The Viewport Meta Tag 326
34. Media Queries 328
35. Flexible Layouts with Flexbox 331
36. Flexible Layouts with Grid 334
37. Fluid Type, Fluid Images, and the Units 337
38. UI and UX Principles for Cross-Device Work 340
39. Touch Targets, and the Thumb Zone 343
40. Consuming an ASP.NET Core Web API 346
41. The Student Record Management PWA 349
42. The Factorial Endpoint, and Testing It 352
43. Deployment Basics 355
44. Lighthouse, and Reading Its Report 358
45. CORS 361
46. Authentication Concepts, and What a JWT Is 364
47. Performance Best Practices 367
48. Accessibility Best Practices 370
49. The College Information Portal, Converted 373
50. The Examination: Six Answers in Sixty Minutes 378