C# 7 and .NET: Designing Modern Cross-platform Applications

Name: C# 7 and .NET: Designing Modern Cross-platform Applications | The Open Source revolution of .NET Core
Brand: Packt Publishing
Price: 38.99 EUR
Availability: OnlineOnly

The Open Source revolution of .NET Core

Price Mark J. Price(Autor*in)

Packt Publishing

Erschienen am 21. Dezember 2018

668 Seiten

E-Book

ePUB mit Adobe-DRM

Systemvoraussetzungen

978-1-78995-787-7 (ISBN)

38,99 €inkl. 7% MwSt.

Systemvoraussetzungen

für ePUB mit Adobe-DRM

E-Book Einzellizenz

Als Download verfügbar

Beschreibung

Explore C# and the .NET Core framework to create applications and optimize them with ASP.NET Core 2Key FeaturesGet to grips with multi-threaded, concurrent, and asynchronous programming in C# and .NET CoreDevelop modern, cross-platform applications with .NET Core 2.0 and C# 7.0Create efficient web applications with ASP.NET Core 2.Book DescriptionC# is a widely used programming language, thanks to its easy learning curve, versatility, and support for modern paradigms. The language is used to create desktop apps, background services, web apps, and mobile apps. .NET Core is open source and compatible with Mac OS and Linux. There is no limit to what you can achieve with C# and .NET Core.This Learning Path begins with the basics of C# and object-oriented programming (OOP) and explores features of C#, such as tuples, pattern matching, and out variables. You will understand.NET Standard 2.0 class libraries and ASP.NET Core 2.0, and create professional websites, services, and applications. You will become familiar with mobile app development using Xamarin.Forms and learn to develop high-performing applications by writing optimized code with various profiling techniques.By the end of C# 7 and .NET: Designing Modern Cross-platform Applications, you will have all the knowledge required to build modern, cross-platform apps using C# and .NET.This Learning Path includes content from the following Packt products:C# 7.1 and .NET Core 2.0 - Modern Cross-Platform Development - Third Edition by Mark J. PriceC# 7 and .NET Core 2.0 High Performance by Ovais Mehboob Ahmed KhanWhat you will learnExplore ASP.NET Core to create professional web applicationsMaster OOP with C# to increase code reusability and efficiencyProtect your data using encryption and hashingMeasure application performance using BenchmarkDotNetUse design techniques to increase your application's performanceLearn memory management techniques in .NET CoreUnderstand tools and techniques to monitor application performanceWho this book is forThis Learning Path is designed for developers who want to gain a solid foundation in C# and .NET Core, and want to build cross-platform applications. To gain maximum benefit from this Learning Path, you must have basic knowledge of C#.

Weitere Details

Weitere Ausgaben

Inhalt

Cover
Title Page
Copyright
About Packt
Contributors
Table of Contents
Preface
Chapter 1: Controlling the Flow and Converting Types
Selection statements
Using Visual Studio 2017
Using Visual Studio Code on macOS, Linux, or Windows
The if statement
The code
Pattern matching with the if statement
The switch statement
The code
Pattern matching with the switch statement
Iteration statements
The while statement
The do statement
The for statement
The foreach statement
Casting and converting between types
Casting from numbers to numbers
Casting numbers implicitly
Casting numbers explicitly
Using the convert type
Rounding numbers
Converting from any type to a string
Converting from a binary object to a string
Parsing from strings to numbers or dates and times
Handling exceptions when converting types
The try statement
Catching all exceptions
Catching specific exceptions
Checking for overflow
The checked statement
The unchecked statement
Looking for help
Microsoft Docs and MSDN
Go to definition
Stack Overflow
Google
Subscribing to blogs
Design patterns
Singleton pattern
Summary
Chapter 2: Writing, Debugging, and Testing Functions
Writing functions
Writing a times table function
Writing a function that returns a value
Writing mathematical functions
Formatting numbers for output
Calculating factorials with recursion
Debugging an application during development
Creating an application with a deliberate bug
Setting a breakpoint
The debugging toolbar
Debugging windows
Stepping through code
Customizing breakpoints
Logging during development and runtime
Instrumenting with Debug and Trace
Writing to the default trace listener
Configuring trace listeners
Switching trace levels
Unit testing functions
Creating a class library that needs testing with Visual Studio 2017
Creating a unit test project with Visual Studio 2017
Creating a class library that needs testing with Visual Studio Code
Writing unit tests
Running unit tests with Visual Studio 2017
Running unit tests with Visual Studio Code
Summary
Chapter 3: Building Your Own Types with Object-Oriented Programming
Talking about OOP
Building class libraries
Creating a class library with Visual Studio 2017
Creating a class library with Visual Studio Code
Defining a class
Instantiating a class
Referencing an assembly using Visual Studio 2017
Referencing an assembly using Visual Studio Code
Importing a namespace
Managing multiple projects with Visual Studio Code
Inheriting from System.Object
Storing data with fields
Defining fields
Understanding access modifiers
Storing a value using the enum keyword
Storing multiple values using collections
Making a field static
Making a field constant
Making a field read-only
Initializing fields with constructors
Setting fields with default literal
Writing and calling methods
Combining multiple values with tuples
Defining methods with tuples
Naming the fields of a tuple
Inferring tuple names
Deconstructing tuples
Defining and passing parameters to methods
Overloading methods
Optional parameters and named arguments
Controlling how parameters are passed
Splitting classes using partial
Controlling access with properties and indexers
Defining read-only properties
Defining settable properties
Defining indexers
Summary
Chapter 4: Implementing Interfaces and Inheriting Classes
Setting up a class library and console application
Using Visual Studio 2017
Using Visual Studio Code
Defining the classes
Simplifying methods with operators
Implementing some functionality with a method
Implementing some functionality with an operator
Defining local functions
Raising and handling events
Calling methods using delegates
Defining events
Using Visual Studio 2017
Using Visual Studio Code
Using Visual Studio 2017 or Visual Studio Code
Implementing interfaces
Common interfaces
Comparing objects when sorting
Attempting to sort objects without a method to compare
Defining a method to compare
Defining a separate comparer
Making types more reusable with generics
Making a generic type
Making a generic method
Managing memory with reference and value types
Defining a struct type
Releasing unmanaged resources
Ensuring that dispose is called
Inheriting from classes
Extending classes
Hiding members
Overriding members
Using Visual Studio 2017
Using Visual Studio 2017 or Visual Studio Code
Preventing inheritance and overriding
Polymorphism
Casting within inheritance hierarchies
Implicit casting
Explicit casting
Handling casting exceptions
Inheriting and extending .NET types
Inheriting from an exception
Extending types when you can't inherit
Using static methods to reuse functionality
Using extension methods to reuse functionality
Summary
Chapter 5: Understanding and Packaging .NET Standard Types
Understanding assemblies and namespaces
Base Class Libraries and CoreFX
Assemblies, NuGet packages, and platforms
Namespaces
Understanding dependent assemblies
Using Visual Studio 2017
Using Visual Studio Code
Using Visual Studio 2017 and Visual Studio Code
Relating assemblies and namespaces
Browsing assemblies with Visual Studio 2017
Using Visual Studio 2017 or Visual Studio Code
Importing a namespace
Relating C# keywords to .NET types
Sharing code cross-platform with .NET Standard 2.0 class libraries
Creating a .NET Standard 2.0 class library
Using Visual Studio 2017
Using Visual Studio Code
Understanding NuGet packages
Understanding metapackages
Understanding frameworks
Fixing dependencies
Publishing your applications for deployment
Creating a console application to publish
Publishing with Visual Studio 2017 on Windows
Publishing with Visual Studio Code on macOS
Packaging your libraries for NuGet distribution
Understanding dotnet commands
Adding a package reference
Using Visual Studio Code
Using Visual Studio 2017
Packaging a library for NuGet
Testing your package
Using Visual Studio Code
Using Visual Studio 2017
Using Visual Studio 2017 and Visual Studio Code
Porting from .NET Framework to .NET Core
Could you port?
Should you port?
Differences between .NET Framework and .NET Core
Understanding the .NET Portability Analyzer
Using non-.NET Standard libraries
Summary
Chapter 6: Using Common .NET Standard Types
Working with numbers
Working with big integers
Working with complex numbers
Working with text
Getting the length of a string
Getting the characters of a string
Splitting a string
Getting part of a string
Checking a string for content
Other string members
Building strings efficiently
Pattern matching with regular expressions
The syntax of a regular expression
Examples of regular expressions
Working with collections
Common features of all collections
Understanding collections
Lists
Dictionaries
Stacks
Queues
Sets
Working with lists
Working with dictionaries
Sorting collections
Using specialized collections
Using immutable collections
Working with network resources
Working with URIs, DNS, and IP addresses
Pinging a server
Working with types and attributes
Versioning of assemblies
Reading assembly metadata
Creating custom attributes
Doing more with reflection
Internationalizing your code
Globalizing an application
Summary
Chapter 7: Working with Files, Streams, and Serialization
Managing the filesystem
Handling cross-platform environments and filesystems
Using Windows 10
Using macOS
Managing drives
Managing directories
Managing files
Managing paths
Getting file information
Controlling files
Reading and writing with streams
Writing to text and XML streams
Writing to text streams
Writing to XML streams
Disposing of file resources
Implementing disposal with try statement
Simplifying disposal with the using statement
Compressing streams
Encoding text
Encoding strings as byte arrays
Encoding and decoding text in files
Serializing object graphs
Serializing with XML
Deserializing with XML
Customizing the XML
Serializing with JSON
Serializing with other formats
Summary
Chapter 8: Improving Performance and Scalability Using Multitasking
Monitoring performance and resource usage
Evaluating the efficiency of types
Monitoring performance and memory use
Using Visual Studio 2017
Using Visual Studio Code
Creating the Recorder class
Measuring the efficiency of processing strings
Understanding processes, threads, and tasks
Running tasks asynchronously
Running multiple actions synchronously
Running multiple actions asynchronously using tasks
Waiting for tasks
Continuing with another task
Nested and child tasks
Synchronizing access to shared resources
Accessing a resource from multiple threads
Applying a mutually exclusive lock to a resource
Understanding the lock statement
Making operations atomic
Applying other types of synchronization
Understanding async and await
Improving responsiveness for console apps
Improving responsiveness for GUI apps
Improving scalability for web applications and web services
Common types that support multitasking
Await in catch blocks
Summary
Chapter 9: Building Web Sites Using ASP.NET Core Razor Pages
Understanding web development
Understanding HTTP
Client-side web development
Understanding ASP.NET Core
Classic ASP.NET versus modern ASP.NET Core
Creating an ASP.NET Core project with Visual Studio 2017
Creating an ASP.NET Core project with Visual Studio Code
Reviewing the ASP.NET Core Empty project template
Testing the empty website
Enabling static files
Enabling default files
Exploring Razor Pages
Enabling Razor Pages
Defining a Razor Page
Using shared layouts with Razor Pages
Setting a shared layout
Defining a shared layout
Using code-behind files with Razor Pages
Using Entity Framework Core with ASP.NET Core
Creating Entity models for Northwind
Creating a class library for the Northwind entity classes
Defining the entity classes
Creating a class library for Northwind database context
Using Visual Studio 2017
Using Visual Studio Code
Defining the database context class
Configure Entity Framework Core as a service
Manipulating data
Summary
Chapter 10: Building Web Sites Using ASP.NET Core MVC
Setting up an ASP.NET Core MVC website
Creating an ASP.NET Core MVC website
Using Visual Studio 2017
Using Visual Studio Code
Reviewing the ASP.NET Core MVC project template
Performing database migrations
Using Visual Studio 2017
Using Visual Studio Code
Testing the ASP.NET MVC website
Reviewing authentication with ASP.NET Identity
Understanding an ASP.NET Core MVC website
ASP.NET Core startup
Understanding the default route
Understanding ASP.NET Core MVC controllers
Understanding ASP.NET Core MVC models
Configuring an EF Core entity data model
Creating view models for requests
Fetch the model in the controller
Understanding ASP.NET Core MVC views
Rendering the Home controller's views
Sharing layouts between views
Defining custom styles
Defining a typed view
Passing parameters using a route value
Passing parameters using a query string
Summary
Chapter 11: Building Web Services and Applications Using ASP.NET Core
Building web services using ASP.NET Core Web API
Understanding ASP.NET Core controllers
Creating an ASP.NET Core Web API project
Using Visual Studio 2017
Using Visual Studio Code
Using Visual Studio 2017 and Visual Studio Code
Creating a web service for the Northwind database
Using Visual Studio 2017
Using Visual Studio Code
Using Visual Studio 2017 and Visual Studio Code
Creating data repositories for entities
Configuring and registering the customers repository
Creating the Web API controller
Documenting and testing web services using Swagger
Testing GET requests with any browser
Testing POST, PUT, and DELETE requests with Swagger
Installing a Swagger package
Using Visual Studio 2017
Using Visual Studio Code
Using Visual Studio 2017 and Visual Studio Code
Testing GET requests with Swagger UI
Testing POST requests with Swagger UI
Building SPAs using Angular
Understanding the Angular project template
Using Visual Studio 2017
Using Visual Studio Code
Using Visual Studio 2017 and Visual Studio Code
Calling NorthwindService
Using Visual Studio 2017
Using Visual Studio Code
Using Visual Studio 2017 and Visual Studio Code
Modifying the home component to call NorthwindService
Testing the Angular component calling the service
Using Visual Studio 2017
Using Visual Studio Code
Using Visual Studio 2017 and Visual Studio Code
Using other project templates
Installing additional template packs
Summary
Chapter 12: Building Windows Apps Using XAML and Fluent Design
Understanding the modern Windows platform
Understanding Universal Windows Platform
Understanding Fluent Design System
Filling user interface elements with acrylic brushes
Connecting user interface elements with animations
Parallax views and Reveal lighting
Understanding XAML Standard 1.0
Simplifying code using XAML
Choosing common controls
Creating a modern Windows app
Enabling developer mode
Creating a UWP project
Exploring common controls and acrylic brushes
Exploring Reveal
Installing more controls
Using resources and templates
Sharing resources
Replacing a control template
Data binding
Binding to elements
Binding to data sources
Modifying the NorthwindService
Creating the Northwind app
Building apps using Windows Template Studio
Installing Windows Template Studio
Selecting project types, frameworks, pages, and features
Retargeting the project
Customizing some views
Testing the app's functionality
Summary
Chapter 13: Building Mobile Apps Using XAML and Xamarin.Forms
Understanding Xamarin and Xamarin.Forms
How Xamarin.Forms extends Xamarin
Mobile first, cloud first
Building mobile apps using Xamarin.Forms
Adding Android SDKs
Creating a Xamarin.Forms solution
Creating a model
Creating an interface for dialing phone numbers
Implement the phone dialer for iOS
Implement the phone dialer for Android
Creating views for the customers list and customer details
Creating the view for the list of customers
Creating the view for the customer details
Testing the mobile app with iOS
Adding NuGet packages for calling a REST service
Getting customers from the service
Summary
Chapter 14: Understanding .NET Core Internals and Measuring Performance
.NET Core internals
CoreFX
CoreCLR
Understanding MSIL, CLI, CTS, and CLS
How the CLR works
From compilation to execution - Under the hood
Garbage collection
Generations in GC
.NET Native and JIT compilation
Utilizing multiple cores of the CPU for high performance
How releasing builds increases performance
Benchmarking .NET Core 2.0 applications
Exploring BenchmarkDotNet
How it works
Setting parameters
Memory diagnostics using BenchmarkDotnet
Adding configurations
Summary
Chapter 15: Data Structures and Writing Optimized Code in C#
What are data structures?
Understanding the use of Big O notation to measure the performance and complexity of an algorithm
Logarithms
Choosing the right data structure for performance optimization
Arrays
Lists
Stacks
Queue
Linked lists
Singly linked lists
Doubly linked lists
Circular linked lists
Dictionaries, hashtables, and hashsets
Generic lists
Best practices in writing optimized code in C#
Boxing and unboxing overhead
String concatenation
Exception handling
For and foreach
Delegates
Summary
Chapter 16: Designing Guidelines for .NET Core Application Performance
Coding principles
Naming convention
Code comments
One class per file
One logic per method
Design principles
KISS (Keep It Simple, Stupid)
YAGNI (You Aren't Gonna Need It)
DRY (Don't Repeat Yourself)
Separation of Concerns (SoC)
SOLID principles
Single Responsibility Principle
Open Closed principle
Parameters
Inheritance
Composition
Liskov principle
The Interface Segregation principle
The Dependency Inversion principle
Caching
Data structures
Communication
Using lighter interfaces
Minimizing message size
Queuing communication
Resource management
Avoiding improper use of threads
Disposing objects in a timely fashion
Acquiring resources when they are required
Concurrency
Summary
Chapter 17: Memory Management Techniques in .NET Core
Memory allocation process overview
Analysing CLR internals through the SOS debugger in .NET Core
Memory fragmentation
Avoiding finalizers
Best practices for disposing of objects in .NET Core
Introduction to the IDisposable interface
What are unmanaged resources?
Using IDisposable
When to implement the IDisposable interface
Finalizer and Dispose
Summary
Chapter 18: Microservices Architecture
Microservices architecture
Benefits of microservices architecture
Standard practice when developing microservices
Types of microservices
Stateless microservices
Stateful microservices
DDD
Data manipulation with microservices
Wrapping microservices behind an API gateway
Denormalizing data into a flat schema for read/query purposes
Consistency across business scenarios
Communication with microservices
Database architecture in microservices
Tables per service
Database per service
Challenges in segregating tables or databases per service
What is API composition?
CQRS
Developing microservices architecture with .NET Core
Creating a sample app in .NET Core using microservices architecture
Solution structure
Logical architecture
Developing a Core infrastructure project
Creating the BaseEntity class
The UnitOfWork pattern
Creating a repository interface
Logging
Creating the APIComponents infrastructure project
Developing an identity service for user authorization
OpenIddict connect flows
Creating the identity service project
Implementing the vendor service
Creating a vendor domain
Creating the vendor infrastructure
Creating the vendor service
Implementing the mediator pattern in the vendor service
Deploying microservices on Docker containers
What is Docker?
Using Docker with .NET Core
Running Docker images
Summary
Other Books You May Enjoy
Index

Systemvoraussetzungen

Als PDF speichern Als Link merken