Book Image

C# 8.0 and .NET Core 3.0 – Modern Cross-Platform Development - Fourth Edition

By : Mark J. Price
Book Image

C# 8.0 and .NET Core 3.0 – Modern Cross-Platform Development - Fourth Edition

By: Mark J. Price

Overview of this book

In C# 8.0 and .NET Core 3.0 – Modern Cross-Platform Development, Fourth Edition, expert teacher Mark J. Price gives you everything you need to start programming C# applications. This latest edition uses the popular Visual Studio Code editor to work across all major operating systems. It is fully updated and expanded with new chapters on Content Management Systems (CMS) and machine learning with ML.NET. The book covers all the topics you need. Part 1 teaches the fundamentals of C#, including object-oriented programming, and new C# 8.0 features such as nullable reference types, simplified switch pattern matching, and default interface methods. Part 2 covers the .NET Standard APIs, such as managing and querying data, monitoring and improving performance, working with the filesystem, async streams, serialization, and encryption. Part 3 provides examples of cross-platform applications you can build and deploy, such as web apps using ASP.NET Core or mobile apps using Xamarin.Forms. The book introduces three technologies for building Windows desktop applications including Windows Forms, Windows Presentation Foundation (WPF), and Universal Windows Platform (UWP) apps, as well as web applications, web services, and mobile apps.

Related Content you might be interested in

Current Title:

Small book image
C# 8.0 and .NET Core 3.0 – Modern Cross-Platform Development - Fourth Edition
Mark J. Price
Oct, 2019 | 818 pages
No titles found
Table of Contents (21 chapters)
Free Chapter
1
Hello, C#! Welcome, .NET!
Hello, C#! Welcome, .NET!
Setting up your development environment
Understanding .NET
Building console apps using Visual Studio Code
Downloading solution code from a GitHub repository
Looking for help
Practicing and exploring
Summary
2
Speaking C#
Speaking C#
Introducing C#
Understanding C# basics
Working with variables
Working with null values
Exploring console applications further
Practicing and exploring
Summary
3
Controlling Flow and Converting Types
Controlling Flow and Converting Types
Operating on variables
Understanding selection statements
Understanding iteration statements
Casting and converting between types
Practicing and exploring
Summary
4
Writing, Debugging, and Testing Functions
Writing, Debugging, and Testing Functions
Writing functions
Debugging during development
Logging during development and runtime
Unit testing functions
Practicing and exploring
Summary
5
Building Your Own Types with Object-Oriented Programming
Building Your Own Types with Object-Oriented Programming
Talking about object-oriented programming
Building class libraries
Storing data within fields
Writing and calling methods
Controlling access with properties and indexers
Practicing and exploring
Summary
6
Implementing Interfaces and Inheriting Classes
Implementing Interfaces and Inheriting Classes
Setting up a class library and console application
Simplifying methods
Raising and handling events
Implementing interfaces
Making types safely reusable with generics
Managing memory with reference and value types
Inheriting from classes
Casting within inheritance hierarchies
Inheriting and extending .NET types
Practicing and exploring
Summary
7
Understanding and Packaging .NET Types
Understanding and Packaging .NET Types
Introducing .NET Core 3.0
Understanding .NET Core components
Publishing your applications for deployment
Decompiling assemblies
Packaging your libraries for NuGet distribution
Porting from .NET Framework to .NET Core
Practicing and exploring
Summary
8
Working with Common .NET Types
Working with Common .NET Types
Working with numbers
Working with text
Pattern matching with regular expressions
Storing multiple objects in collections
Working with spans, indexes, and ranges
Working with network resources
Working with types and attributes
Internationalizing your code
Practicing and exploring
Summary
9
Working with Files, Streams, and Serialization
Working with Files, Streams, and Serialization
Managing the filesystem
Reading and writing with streams
Encoding and decoding text
Serializing object graphs
Practicing and exploring
Summary
10
Protecting Your Data and Applications
Protecting Your Data and Applications
Understanding the vocabulary of protection
Encrypting and decrypting data
Hashing data
Signing data
Generating random numbers
What's new in cryptography
Authenticating and authorizing users
Practicing and exploring
Summary
11
Working with Databases Using Entity Framework Core
Working with Databases Using Entity Framework Core
Understanding modern databases
Setting up EF Core
Defining EF Core models
Querying EF Core models
Loading patterns with EF Core
Manipulating data with EF Core
Practicing and exploring
Summary
12
Querying and Manipulating Data Using LINQ
Querying and Manipulating Data Using LINQ
Writing LINQ queries
Working with sets and bags using LINQ
Using LINQ with EF Core
Sweetening LINQ syntax with syntactic sugar
Using multiple threads with parallel LINQ
Creating your own LINQ extension methods
Working with LINQ to XML
Practicing and exploring
Summary
13
Improving Performance and Scalability Using Multitasking
Improving Performance and Scalability Using Multitasking
Understanding processes, threads, and tasks
Monitoring performance and resource usage
Running tasks asynchronously
Synchronizing access to shared resources
Understanding async and await
Practicing and exploring
Summary
14
Practical Applications of C# and .NET
Practical Applications of C# and .NET
Understanding app models for C# and .NET
New features for ASP.NET Core
Understanding SignalR
Understanding Blazor
Understanding the bonus chapters
Building an entity data model for Northwind
Summary
15
Building Websites Using ASP.NET Core Razor Pages
Building Websites Using ASP.NET Core Razor Pages
Understanding web development
Understanding ASP.NET Core
Exploring Razor Pages
Using Entity Framework Core with ASP.NET Core
Using Razor class libraries
Practicing and exploring
Summary
16
Building Websites Using the Model-View-Controller Pattern
Building Websites Using the Model-View-Controller Pattern
Setting up an ASP.NET Core MVC website
Exploring an ASP.NET Core MVC website
Customizing an ASP.NET Core MVC website
Using other project templates
Practicing and exploring
Summary
17
Building Websites Using a Content Management System
Building Websites Using a Content Management System
Understanding the benefits of a CMS
Understanding Piranha CMS
Defining components, content types, and templates
Testing the Northwind CMS website
Practicing and exploring
Summary
18
Building and Consuming Web Services
Building and Consuming Web Services
Building web services using ASP.NET Core Web API
Documenting and testing web services
Consuming services using HTTP clients
Implementing advanced features
Understanding other communication technologies
Practicing and exploring
Summary
19
Building Intelligent Apps Using Machine Learning
Building Intelligent Apps Using Machine Learning
Understanding machine learning
Understanding ML.NET
Making product recommendations
Practicing and exploring
Summary
20
Building Windows Desktop Apps
Building Windows Desktop Apps
Understanding legacy Windows application platforms
Understanding the modern Windows platform
Creating a modern Windows app
Using resources and templates
Using data binding
Practicing and exploring
Summary
21
Building Cross-Platform Mobile Apps Using Xamarin.Forms
Building Cross-Platform Mobile Apps Using Xamarin.Forms
Understanding Xamarin and Xamarin.Forms
Building mobile apps using Xamarin.Forms
Consuming a web service from a mobile app
Practicing and exploring
Summary
Epilogue

Understanding legacy Windows application platforms

With the Microsoft Windows 1.0 release in 1985, the only way to create Windows applications was to use the C language and call functions in three core DLLs named kernel, user, and GDI. Once Windows became 32-bit with Windows 95, the DLLs were suffixed with 32 and became known as the Win32 API.

In 1991, Microsoft introduced Visual Basic, which provided developers a visual, drag and drop from a toolbox of controls way to build the user interface for Windows applications. It was immensely popular, and the Visual Basic runtime is still part of Windows 10 today.

In 2002, Microsoft introduced .NET Framework, which included Windows Forms for building Windows applications. The code could be written in either Visual Basic or C# languages. Windows Forms had a similar drag and drop visual designer, although it generated C# or Visual Basic code to define the user interface, which can be difficult for humans to understand and...

Previous Section
End of Section 2
Next Section