book

C# 6 and .NET Core 1.0

Name: C# 6 and .NET Core 1.0
Author: Mark J. Price
ISBN: 9781785285691

by Mark J. Price

March 2016

Intermediate to advanced

550 pages

10h 57m

English

Packt Publishing

Read now

Unlock full access

C# 6 and .NET Core 1.0Modern Cross-Platform Development
Table of Contents
C# 6 and .NET Core 1.0
Credits
About the Author
About the Reviewers
www.PacktPub.com
eBooks, discount offers, and moreWhy subscribe?
Preface
What this book covers
What you need for this book
Who this book is for

Conventions
Reader feedback
Customer support
Downloading the example codeErrataPiracyQuestions
1. Hello, C#! Welcome, .NET Core!
Setting up your development environmentUsing alternative C# IDEsUsing Visual Studio 2015 on Windows 10Installing Microsoft Visual Studio 2015Choosing the default installationChoosing the custom installationCompleting the installationSigning in to Visual StudioChoosing development settingsUpdating extensions and productsUsing older versions of Visual Studio
Understanding .NET Framework, .NET Core, and .NET Native
Understanding .NET Framework platformUnderstanding the Mono projectUnderstanding the .NET Core platformStreamlining .NETThe future of .NETUnderstanding the .NET Native platformComparing .NET technologies
Writing and compiling code using the Developer Command Prompt
Writing code using NotepadCompiling code using the Developer Command PromptFixing compiler errorsDecompiling code using ILDASMDisassembling compiled assemblies
Writing and compiling code using Microsoft Visual Studio 2015
Writing code using Visual Studio 2015Compiling code using Visual StudioFixing mistakes with the error listExperimenting with C# InteractiveOther useful windows
Targeting the .NET Core
Understanding the .NET Portability AnalyzerInstalling the .NET Portability AnalyzerConfiguring the .NET Portability AnalyzerAnalyzing a solution.NET Portability and this bookCreating new projects for the .NET CoreManaging .NET Core development with Command Line ToolsInstalling the .NET Command Line ToolsCreating a .NET Core application using Command Line ToolsCreating a .NET Core application using Visual Studio 2015
Managing source code with GitHub
Using the Team Explorer windowCloning a GitHub repositoryManaging a GitHub repository
Practicing and exploring
Exercise 1.1 – test your knowledgeExercise 1.2 – practice managing Visual Studio WindowsExercise 1.3 – practice coding anywhereExercise 1.4 – explore topics
Summary
2. Speaking C#
Understanding C# basicsThe C# grammarStatementsBlocksThe C# vocabularyWriting the codeVerbs are methodsNouns are types, fields, and variablesCounting types and methods
Declaring variables
Naming variablesStoring textStoring numbersStoring whole numbersStoring real numbersSizes of numbers in memoryComparing double and decimalStoring BooleansThe object typeThe dynamic typeLocal variablesInferring the type of a local variableMaking a value type nullableStoring multiple values in an array
Building console applications
Displaying output to the userGetting input from the userImporting a namespaceSimplifying the usage of the console in C# 6Reading arguments and working with arrays
Operating on variables
Experimenting with unary operatorsExperimenting with arithmetic operatorsComparison and Boolean operators
Practicing and exploring
Exercise 2.1 – test your knowledgeExercise 2.2 – practice number sizes and rangesExercise 2.3 – explore topics
Summary
3. Controlling the Flow, Converting Types, and Handling Exceptions
Selection statementsThe if-else statementThe switch-case statementAutoformatting code
Iteration statements
The while statementThe do-while statementThe for statementThe foreach statementHow does the foreach statement actually work?
Casting and converting between types
Casting from numbers to numbersUsing the Convert typeRounding numbersConverting from any type to a stringParsing from strings to numbers or dates and times
Handling exceptions
The try-catch statementCatching all exceptionsCatching specific exceptionsThe finally statementSimplifying disposal with the using statement
Checking for overflow
The checked statementThe unchecked statement
Looking for help
MSDNGetting the definition of codeStackOverflowGoogleDesign patterns
Practice and explore
Exercise 3.1 – test your knowledgeExercise 3.2 – explore loops and overflowExercise 3.3 – practice loops and operatorsExercise 3.4 – practice exception handlingExercise 3.5 – explore topics
Summary
4. Using Common .NET Types
Using assemblies and namespacesComparing .NET Framework with .NET CoreBase Class Libraries and CoreFXAssembliesNamespacesReferencing an assemblyReferencing Microsoft Core LibraryAn example of assembly referencesRelating assemblies and namespacesImporting a namespaceBrowsing assemblies and namespacesRelating C# keywords to .NET types
Storing and manipulating text
Getting the length of a stringGetting the characters of a stringSplitting a stringExtracting part of a stringChecking a string for contentOther string membersBuilding strings efficientlyValidating input with regular expressionsThe syntax of a regular expressionExamples of regular expressions
Storing data with collections
Understanding collectionsListsDictionariesStacksQueuesSetsWorking with listsWorking with dictionariesSorting collectionsAvoiding old collectionsUsing specialized collections
Practicing and exploring
Exercise 4.1 – test your knowledgeExercise 4.2 – practice regular expressionsExercise 4.3 – explore topics
Summary
5. Using Specialized .NET Types
Debugging and diagnosticsDebugging an applicationSetting a breakpointThe debugging toolbarDebugging windowsStepping through codeCustomizing breakpointsMonitoring performance and resource usageEvaluating the efficiency of typesMonitoring performance and memory useMeasuring the efficiency of processing stringsMonitoring with Debug and TraceWriting to the default trace listenerConfiguring trace listenersConfiguring compiler symbols for .NET FrameworkDefining compiler symbols for .NET CoreChecking compiler symbolsSwitching trace levels
Unit testing an application
Creating a unit of code that needs testingCreating a unit test projectRunning unit tests
Internationalizing an application
Globalizing an applicationLocalizing an application
Interoperating with unmanaged code
Automating Microsoft Excel using COM InteropAccessing the Win32 API with P/Invoke
Practicing and exploring
Exercise 5.1 – test your knowledgeExercise 5.2 – practice using Debug and TraceExercise 5.3 – explore topics
Summary
6. Building Your Own Types with Object-Oriented Programming
Talking about OOP
Building class libraries
Creating a class library to share codeDefining a classInstantiating a class
Storing data with fields
Defining fieldsStoring a value using the enum keywordStoring multiple values using collectionsMaking a field staticMaking a field constantMaking a field read onlyInitializing fields with constructors
Writing and calling methods
Overloading methodsOptional parameters and named argumentsSplitting classes using partial
Controlling access with properties and indexers
Defining read-only propertiesDefining settable propertiesDefining indexers
Simplifying methods with operators
Raising and handling events
Calling methods using delegatesDefining events
Practicing and exploring
Exercise 6.1 – test your knowledgeExercise 6.2 – practice writing mathematical methodsExercise 6.3 – explore topics
Summary
7. Implementing Interfaces and Inheriting Classes
Implementing interfacesCommon interfacesComparing objects when sortingDefining a separate comparer
Managing memory with reference and value types
Defining a type using the struct keywordReleasing unmanaged resourcesEnsuring that dispose is called
Inheriting from classes
Extending classesHiding membersOverriding membersPreventing inheritance and overridingPolymorphism
Casting within inheritance hierarchies
Implicit castingExplicit castingHandling casting exceptions
Documenting your types
Inheriting and extending .NET types
Inheriting from the Exception classExtending types when you can't inheritUsing static methods to reuse functionalityUsing extension methods to reuse functionality
Practice and explore
Exercise 7.1 – test your knowledgeExercise 7.2 – practice creating an inheritance hierarchyExercise 7.3 – explore topics
Summary
8. Working with Relational Data Using the Entity Framework
Relational Database Management SystemsConnecting to Microsoft SQL Server LocalDbThe Northwind sample databaseChoosing a .NET data provider
Using ADO.NET
Connecting to the databaseExecuting commands and reading result setsLoading a connection string from configuration
Using Entity Framework 6
Building an Entity Framework 6 modelEntity Framework Code First modelsEF Code First conventionsEF annotation attributesEF Fluent APIQuerying an Entity Data ModelLogging SQL statementsManipulating data with Entity Data ModelsInserting entitiesUpdating entitiesTransactionsDefining an explicit transactionLoading patterns with EFLazy loading entitiesEager loading entitiesExplicit loading entities
Using Entity Framework Core
Practicing and exploring
Exercise 8.1 – test your knowledgeExercise 8.2 – explore the EF Core documentationExercise 8.3 – explore topics
Summary
9. Querying and Manipulating Data with LINQ
Writing LINQ queriesExtending sequences with the Enumerable classFiltering entities with WhereTargeting a named methodSimplifying the code by removing the explicit delegate instantiationTargeting a lambda expressionSorting sequences with OrderBySorting by multiple properties with the ThenBy methodWorking with setsProjecting entities with Select statementJoining and groupingSweetening the syntax with syntactic sugar
Using multiple threads with Parallel LINQ
Creating your own LINQ extension methods
Working with LINQ to XML
Generating XML using LINQ to XMLReading XML by using LINQ to XML
Practicing and exploring
Exercise 9.1 – test your knowledgeExercise 9.2 – practice querying with LINQExercise 9.3 – explore topics
Summary
10. Working with Files, Streams, and Serialization
Managing the filesystemManaging directoriesManaging filesManaging pathsGetting file information
Reading and writing with streams
Writing to text and XML streamsCompressing streams
Encoding text
Encoding strings as byte arraysEncoding and decoding text in files
Serializing object graphs
Serializing with XMLDeserializing with XMLCustomizing the XMLSerializing with JSONSerializing with other formatsSerializing with runtime serializers
Practice and explore
Exercise 10.1 – test your knowledgeExercise 10.2 – practice serializing as XMLExercise 10.3 – explore serialization formatsExercise 10.4 – explore Microsoft's System.IO typesExercise 10.5 – explore topics
Summary
11. Protecting Your Data and Applications
Understanding the vocabulary of protectionKeys and key sizesIVs and block sizesSaltsGenerating keys and IVs
Encrypting and decrypting data
Encrypting symmetrically with AES
Hashing data
Hashing with SHA256
Signing data
Signing with SHA256 and RSA
Authenticating and authorizing users
Managing local accountsAuthenticating with WindowsAuthorizing with Windows
Practicing and exploring
Exercise 11.1 – test your knowledgeExercise 11.2 – practice protecting data with encryption and hashingExercise 11.3 – practice protecting data with decryptionExercise 11.4 – explore topics
Summary
12. Improving Performance and Scalability with Multitasking
Understanding processes and threads
Running tasks asynchronously
Running multiple actions synchronouslyRunning multiple actions asynchronously using tasksWaiting for tasksContinuing with another taskNested and child tasks
The async and await keywords
Creating a GUI that blocksCreating a GUI that doesn't blockOther types with Async methodsawait in catch blocksImproving scalability for client-server applications
Synchronizing access to shared resources
Accessing a resource from multiple threadsApplying a mutually exclusive lock to a resourceUnderstanding the lock statementMaking operations atomicApplying other types of synchronization
Practicing and exploring
Exercise 12.1 – test your knowledgeExercise 12.2 – explore topics
Summary
13. Building Universal Windows Platform Apps Using XAML
Understanding the UWPAdapting your app's layoutTaking advantage of unique device capabilities
Understanding XAML
Simplifying code using XAML
Creating a Windows desktop application using WPF
Choosing common controls
Creating an app for the Universal Windows Platform
Analyzing UWP portability
Using resources and templates 
Sharing resourcesReplacing a control template
Data binding
Binding to elementsBinding to data
Animating with storyboards
Testing in emulators
Practicing and exploring
Exercise 13.1 – test your knowledgeExercise 13.2 – practice building a universal tip calculatorExercise 13.3 – explore topics
Summary
14. Building Web Applications and Services Using ASP.NET Core
Understanding ASP.NET CoreClassic ASP.NET versus modern ASP.NET CoreClient-side web developmentInstall Web Essentials 2015The HyperText Transfer Protocol (HTTP)Create a web application projectExploring the parts of an ASP.NET Core web application
ASP.NET Core startup
Understanding the default route
ASP.NET Core controllers
Defining the Home controller's actions
ASP.NET Core models
Create Entity models for NorthwindConfigure Entity Framework Core as a serviceCreate view models for requestsFetch the model in the controller
ASP.NET Core views
Rendering the Home controller's viewsSharing layouts between viewsDefining custom stylesDefining a typed view
Taking ASP.NET Core further
Passing parameters using a route valuePassing parameters using a query stringAnnotating models
ASP.NET Core Web API
Scaffolding an API controllerCalling a Web API service from a UWP app
Practicing and exploring
Exercise 14.1 – test your knowledgeExercise 14.2 – practice building a data-driven web applicationExercise 14.3 – explore topics
Summary
15. Taking C# Cross-Platform
Understanding cross-platform developmentVisual Studio Code.NET Core 1.0ASP.NET Core 1.0Entity Framework Core 1.0.NET NativeXamarinCross-device Universal Windows Platform (UWP)
Installing Visual Studio Code and ASP.NET Core
Installing Visual Studio CodeManaging development from the terminalInstalling HomebrewInstalling ASP.NET Core and the .NET Version ManagerListing the installed versions of .NETSwitching from Mono to .NET Core
Building a console application
Creating the source filesEditing the codeDownloading dependency packages and compiling
Building cross-platform web applications using ASP.NET Core
Creating the simplest ASP.NET Core web applicationInstalling Yeoman and related toolsScaffolding projects using YeomanEditing projects using Visual Studio Code
Understanding the .NET Core command-line tools
Understanding the DNX toolsUnderstanding the CLI toolsCommon DNX commandsCommon CLI commands
Practicing and exploring
Exercise 15.1 – test your knowledgeExercise 15.2 – practice transferring an existing ASP.NET applicationExercise 15.3 – explore topics
Summary
16. Building a Quiz
Designing the quiz applicationChoosing the platformDeciding the functional requirementsSeparating concerns
Building the quiz solution
Defining the entity modelsCreating the data repositoryCreating the web applicationDefining view modelsAdding sample quiz questionsConfiguring session stateAdding custom controller actionsAdding custom views
Running the quiz
Configuring the project to use Kestrel and .NET Core
Hosting ASP.NET Core web apps in Microsoft Azure
Register an Azure accountCreate an Azure web appPublishing an ASP.NET web application to the Web App
Practicing and exploring
Exercise 16.1 – test your knowledgeExercise 16.2 – practice by extending the quiz web appExercise 16.3 – explore topics
Summary
A. Answers to the Test Your Knowledge Questions
Chapter 1 – Hello, C#! Welcome, .NET Core!
Chapter 2 – Speaking C#
Chapter 3 – Controlling the Flow, Converting Types, and Handling Exceptions
Exercise 3.2
Chapter 4 – Using Common .NET Types
Chapter 5 – Using Specialized .NET Types
Chapter 6 – Building Your Own Types with Object-Oriented Programming
Chapter 7 – Implementing Interfaces and Inheriting Classes
Chapter 8 – Working with Relational Data Using the Entity Framework
Chapter 9 – Querying and Manipulating Data with LINQ
Chapter 10 – Working with Files, Streams, and Serialization
Chapter 11 – Protecting Your Data and Applications
Chapter 12 – Improving Performance and Scalability with Multitasking
Chapter 13 – Building Universal Windows Platform Apps Using XAML
Chapter 14 – Building Web Applications and Services Using ASP.NET Core
Chapter 15 – Taking C# Cross-Platform
Chapter 16 – Building a Quiz
B. Creating a Virtual Machine for Your Development Environment
Signing up for a Microsoft account
Creating a Microsoft Azure subscription
Managing your Microsoft Azure account
Creating a virtual machine
Connecting to your virtual machine using remote desktop
Supporting other platforms
Summary
Index

Content preview from C# 6 and .NET Core 1.0

Practicing and exploring

Test your knowledge and understanding by answering some questions, get some hands-on practice, and explore this chapter's topics with deeper research.

Exercise 12.1 – test your knowledge

Answer the following questions:

By convention, what suffix should be applied to a method that returns Task or Task<T>?
To use the await keyword inside a method, what keyword must be applied to the method declaration?
How do you create a child task?
Why should you avoid the lock keyword?
When should you use the Interlocked class?

Exercise 12.2 – explore topics

Use the following links to read more about this chapter's topics:

Threads and threading: https://msdn.microsoft.com/en-us/library/6kac2kdh(v=vs.110).aspx
Task parallelism (task parallel library) ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781785285691

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills