C# 10 and NET 6 Modern Cross Platform Development 6th Edition by Mark J Price ISBN B09JV37DM6 9781801077361

C# 10 and NET 6 Modern Cross Platform Development 6th Edition by Mark J Price – Ebook PDF Instant Download/Delivery: B09JV37DM6 ,9781801077361
Full download C# 10 and NET 6 Modern Cross Platform Development 6th Edition after payment

Product details:

ISBN 10: B09JV37DM6 
ISBN 13: 9781801077361
Author: Mark J Price

Extensively revised to accommodate all the latest features that come with C# 10 and .NET 6, this latest edition of our comprehensive guide will get you coding in C# with confidence.

You’ll learn object-oriented programming, writing, testing, and debugging functions, implementing interfaces, and inheriting classes. The book covers the .NET APIs for performing tasks like managing and querying data, monitoring and improving performance, and working with the filesystem, async streams, and serialization. You’ll build and deploy cross-platform apps, such as websites and services using ASP.NET Core.

Instead of distracting you with unnecessary application code, the first twelve chapters will teach you about C# language constructs and many of the .NET libraries through simple console applications. In later chapters, having mastered the basics, you’ll then build practical applications and services using ASP.NET Core, the Model-View-Controller (MVC) pattern, and Blazor.

C# 10 and NET 6 Modern Cross Platform Development 6th Edition Table of contents:

1. Where to find the code solutions
2. Where to find the online chapters
3. What this book covers
4. What you need for this book
5. Get in touch
6. Share your thoughts
7. Hello, C#! Welcome, .NET!
8. Setting up your development environment
9. Choosing the appropriate tool and application type for learning
10. Pros and cons of the .NET Interactive Notebooks extension
11. Using Visual Studio Code for cross-platform development
12. Using GitHub Codespaces for development in the cloud
13. Using Visual Studio for Mac for general development
14. Using Visual Studio for Windows for general development
15. What I used
16. Deploying cross-platform
17. Downloading and installing Visual Studio 2022 for Windows
18. Microsoft Visual Studio for Windows keyboard shortcuts
19. Downloading and installing Visual Studio Code
20. Installing other extensions
21. Understanding Microsoft Visual Studio Code versions
22. Microsoft Visual Studio Code keyboard shortcuts
23. Understanding .NET
24. Understanding .NET Framework
25. Understanding the Mono, Xamarin, and Unity projects
26. Understanding .NET Core
27. Understanding the journey to one .NET
28. Understanding .NET support
29. Understanding .NET Runtime and .NET SDK versions
30. Removing old versions of .NET
31. What is different about modern .NET?
32. Windows development
33. Web development
34. Database development
35. Themes of modern .NET
36. Understanding .NET Standard
37. .NET platforms and tools used by the book editions
38. Understanding intermediate language
39. Comparing .NET technologies
40. Building console apps using Visual Studio 2022
41. Managing multiple projects using Visual Studio 2022
42. Writing code using Visual Studio 2022
43. Compiling and running code using Visual Studio
44. Understanding the compiler-generated folders and files
45. Writing top-level programs
46. Adding a second project using Visual Studio 2022
47. Implicitly imported namespaces
48. Building console apps using Visual Studio Code
49. Managing multiple projects using Visual Studio Code
50. Writing code using Visual Studio Code
51. Compiling and running code using the dotnet CLI
52. Adding a second project using Visual Studio Code
53. Managing multiple files using Visual Studio Code
54. Exploring code using .NET Interactive Notebooks
55. Creating a notebook
56. Writing and running code in a notebook
57. Saving a notebook
58. Adding Markdown and special commands to a notebook
59. Executing code in multiple cells
60. Using .NET Interactive Notebooks for the code in this book
61. Reviewing the folders and files for projects
62. Understanding the common folders and files
63. Understanding the solution code on GitHub
64. Making good use of the GitHub repository for this book
65. Raising issues with the book
66. Giving me feedback
67. Downloading solution code from the GitHub repository
68. Using Git with Visual Studio Code and the command line
69. Cloning the book solution code repository
70. Looking for help
71. Reading Microsoft documentation
72. Getting help for the dotnet tool
73. Getting definitions of types and their members
74. Looking for answers on Stack Overflow
75. Searching for answers using Google
76. Subscribing to the official .NET blog
77. Watching Scott Hanselman’s videos
78. Practicing and exploring
79. Exercise 1.1 – Test your knowledge
80. Exercise 1.2 – Practice C# anywhere
81. Exercise 1.3 – Explore topics
82. Summary
83. Speaking C#
84. Introducing the C# language
85. Understanding language versions and features
86. C# 1.0
87. C# 2.0
88. C# 3.0
89. C# 4.0
90. C# 5.0
91. C# 6.0
92. C# 7.0
93. C# 7.1
94. C# 7.2
95. C# 7.3
96. C# 8
97. C# 9
98. C# 10
99. Understanding C# standards
100. Discovering your C# compiler versions
101. How to output the SDK version
102. Enabling a specific language version compiler
103. Understanding C# grammar and vocabulary
104. Showing the compiler version
105. Understanding C# grammar
106. Statements
107. Comments
108. Blocks
109. Examples of statements and blocks
110. Understanding C# vocabulary
111. Comparing programming languages to human languages
112. Changing the color scheme for C# syntax
113. Help for writing correct code
114. Importing namespaces
115. Implicitly and globally importing namespaces
116. Verbs are methods
117. Nouns are types, variables, fields, and properties
118. Revealing the extent of the C# vocabulary
119. Working with variables
120. Naming things and assigning values
121. Literal values
122. Storing text
123. Understanding verbatim strings
124. Storing numbers
125. Storing whole numbers
126. Exploring whole numbers
127. Storing real numbers
128. Writing code to explore number sizes
129. Comparing double and decimal types
130. Storing Booleans
131. Storing any type of object
132. Storing dynamic types
133. Declaring local variables
134. Specifying the type of a local variable
135. Inferring the type of a local variable
136. Using target-typed new to instantiate objects
137. Getting and setting the default values for types
138. Storing multiple values in an array
139. Exploring more about console applications
140. Displaying output to the user
141. Formatting using numbered positional arguments
142. Formatting using interpolated strings
143. Understanding format strings
144. Getting text input from the user
145. Simplifying the usage of the console
146. Getting key input from the user
147. Passing arguments to a console app
148. Setting options with arguments
149. Handling platforms that do not support an API
150. Practicing and exploring
151. Exercise 2.1 – Test your knowledge
152. Exercise 2.2 – Test your knowledge of number types
153. Exercise 2.3 – Practice number sizes and ranges
154. Exercise 2.4 – Explore topics
155. Summary
156. Controlling Flow, Converting Types, and Handling Exceptions
157. Operating on variables
158. Exploring unary operators
159. Exploring binary arithmetic operators
160. Assignment operators
161. Exploring logical operators
162. Exploring conditional logical operators
163. Exploring bitwise and binary shift operators
164. Miscellaneous operators
165. Understanding selection statements
166. Branching with the if statement
167. Why you should always use braces with if statements
168. Pattern matching with the if statement
169. Branching with the switch statement
170. Pattern matching with the switch statement
171. Simplifying switch statements with switch expressions
172. Understanding iteration statements
173. Looping with the while statement
174. Looping with the do statement
175. Looping with the for statement
176. Looping with the foreach statement
177. Understanding how foreach works internally
178. Casting and converting between types
179. Casting numbers implicitly and explicitly
180. Converting with the System.Convert type
181. Rounding numbers
182. Understanding the default rounding rules
183. Taking control of rounding rules
184. Converting from any type to a string
185. Converting from a binary object to a string
186. Parsing from strings to numbers or dates and times
187. Errors using Parse
188. Avoiding exceptions using the TryParse method
189. Handling exceptions
190. Wrapping error-prone code in a try block
191. Catching all exceptions
192. Catching specific exceptions
193. Catching with filters
194. Checking for overflow
195. Throwing overflow exceptions with the checked statement
196. Disabling compiler overflow checks with the unchecked statement
197. Practicing and exploring
198. Exercise 3.1 – Test your knowledge
199. Exercise 3.2 – Explore loops and overflow
200. Exercise 3.3 – Practice loops and operators
201. Exercise 3.4 – Practice exception handling
202. Exercise 3.5 – Test your knowledge of operators
203. Exercise 3.6 – Explore topics
204. Summary
205. Writing, Debugging, and Testing Functions
206. Writing functions
207. Times table example
208. Writing a times table function
209. Writing a function that returns a value
210. Converting numbers from cardinal to ordinal
211. Calculating factorials with recursion
212. Documenting functions with XML comments
213. Using lambdas in function implementations
214. Debugging during development
215. Creating code with a deliberate bug
216. Setting a breakpoint and start debugging
217. Using Visual Studio 2022
218. Using Visual Studio Code
219. Navigating with the debugging toolbar
220. Debugging windows
221. Stepping through code
222. Customizing breakpoints
223. Logging during development and runtime
224. Understanding logging options
225. Instrumenting with Debug and Trace
226. Writing to the default trace listener
227. Configuring trace listeners
228. Switching trace levels
229. Adding packages to a project in Visual Studio Code
230. Adding packages to a project in Visual Studio 2022
231. Reviewing project packages
232. Unit testing
233. Understanding types of testing
234. Creating a class library that needs testing
235. Writing unit tests
236. Running unit tests using Visual Studio Code
237. Running unit tests using Visual Studio
238. Fix the bug
239. Throwing and catching exceptions in functions
240. Understanding usage errors and execution errors
241. Commonly thrown exceptions in functions
242. Understanding the call stack
243. Where to catch exceptions
244. Rethrowing exceptions
245. Implementing the tester-doer pattern
246. Problems with the tester-doer pattern
247. Practicing and exploring
248. Exercise 4.1 – Test your knowledge
249. Exercise 4.2 – Practice writing functions with debugging and unit testing
250. Exercise 4.3 – Explore topics
251. Summary
252. Building Your Own Types with Object-Oriented Programming
253. Talking about OOP
254. Building class libraries
255. Creating a class library
256. Defining a class in a namespace
257. Simplifying namespace declarations
258. Understanding members
259. Instantiating a class
260. Referencing an assembly
261. Importing a namespace to use a type
262. Understanding objects
263. Inheriting from System.Object
264. Storing data within fields
265. Defining fields
266. Understanding access modifiers
267. Setting and outputting field values
268. Storing a value using an enum type
269. Storing multiple values using an enum type
270. Storing multiple values using collections
271. Understanding generic collections
272. Making a field static
273. Making a field constant
274. Making a field read-only
275. Initializing fields with constructors
276. Defining multiple constructors
277. Writing and calling methods
278. Returning values from methods
279. Combining multiple returned values using tuples
280. Language support for tuples
281. Naming the fields of a tuple
282. Inferring tuple names
283. Deconstructing tuples
284. Deconstructing types
285. Defining and passing parameters to methods
286. Overloading methods
287. Passing optional and named parameters
288. Naming parameter values when calling methods
289. Controlling how parameters are passed
290. Simplified out parameters
291. Understanding ref returns
292. Splitting classes using partial
293. Controlling access with properties and indexers
294. Defining read-only properties
295. Defining settable properties
296. Requiring properties to be set during instantiation
297. Defining indexers
298. Pattern matching with objects
299. Creating and referencing a .NET 6 class library
300. Defining flight passengers
301. Enhancements to pattern matching in C# 9 or later
302. Working with records
303. Init-only properties
304. Understanding records
305. Positional data members in records
306. Simplifying data members in records
307. Practicing and exploring
308. Exercise 5.1 – Test your knowledge
309. Exercise 5.2 – Explore topics
310. Summary
311. Implementing Interfaces and Inheriting Classes
312. Setting up a class library and console application
313. More about methods
314. Implementing functionality using methods
315. Implementing functionality using operators
316. Implementing functionality using local functions
317. Raising and handling events
318. Calling methods using delegates
319. Defining and handling delegates
320. Defining and handling events
321. Making types safely reusable with generics
322. Working with non-generic types
323. Working with generic types
324. Implementing interfaces
325. Common interfaces
326. Comparing objects when sorting
327. Comparing objects using a separate class
328. Implicit and explicit interface implementations
329. Defining interfaces with default implementations
330. Managing memory with reference and value types
331. Defining reference and value types
332. How reference and value types are stored in memory
333. Equality of types
334. Defining struct types

People also search for C# 10 and NET 6 Modern Cross Platform Development 6th Edition:

Tags: Mark J Price, C# 10, Cross Platform Development