Index
A
- abstraction / Talking about OOP
- access
- synchronizing, to shared resources / Synchronizing access to shared resources
- access modifiers / Defining a class, Understanding access modifiers
- Active Server Pages (ASP) / Understanding ASP.NET Core
- aggregation / Talking about OOP
- Android
- implementing, on mobile apps / Creating an interface for dialing phone numbers
- Angular
- used, for building SPAs / Building SPAs using Angular
- NorthwindService, calling / Calling NorthwindService
- component, testing / Testing the Angular component calling the service
- Angular component, testing
- service, calling / Testing the Angular component calling the service
- Visual Studio 2017, using / Using Visual Studio 2017
- Visual Studio Code, using / Using Visual Studio Code
- Angular project template
- about / Understanding the Angular project template
- Visual Studio 2017, using / Using Visual Studio 2017
- Visual Studio Code, using / Using Visual Studio Code
- API component infrastructure project
- API composition / Wrapping microservices behind an API gateway, What is API composition?
- application
- debugging, during development / Debugging an application during development
- creating, with deliberate bug / Creating an application with a deliberate bug
- globalizing / Globalizing an application
- apps, building
- Windows Template Studio, installing / Installing Windows Template Studio
- project types, selecting / Selecting project types, frameworks, pages, and features
- pages and features, selecting / Selecting project types, frameworks, pages, and features
- frameworks, selecting / Selecting project types, frameworks, pages, and features
- project, retargeting / Retargeting the project
- views, customizing / Customizing some views
- functionality, testing / Testing the app's functionality
- array
- ASP.NET
- reference / Understanding HTTP
- versus ASP.NET Core / Classic ASP.NET versus modern ASP.NET Core
- ASP.NET Core
- HTTP / Understanding HTTP
- about / Understanding ASP.NET Core
- versus ASP.NET / Classic ASP.NET versus modern ASP.NET Core
- empty project template, reviewing / Reviewing the ASP.NET Core Empty project template
- empty website, testing / Testing the empty website
- ASP.NET Core MVC models
- EF Core entity data model, configuring / Configuring an EF Core entity data model
- view models, creating for requests / Creating view models for requests
- model, fetching in controller / Fetch the model in the controller
- ASP.NET Core MVC views
- about / Understanding ASP.NET Core MVC views
- Home controller's views, rendering / Rendering the Home controller's views
- layouts, sharing between views / Sharing layouts between views
- custom styles, defining / Defining custom styles
- typed view, defining / Defining a typed view
- ASP.NET Core MVC web application
- about / Defining a typed view
- parameters, passing query string used / Passing parameters using a query string
- ASP.NET Core MVC website
- setting up / Setting up an ASP.NET Core MVC website
- creating / Creating an ASP.NET Core MVC website
- Visual Studio 2017, using / Using Visual Studio 2017
- testing / Testing the ASP.NET MVC website
- about / Understanding an ASP.NET Core MVC website
- startup file / ASP.NET Core startup
- default route / Understanding the default route
- controllers / Understanding ASP.NET Core MVC controllers
- models / Understanding ASP.NET Core MVC models
- ASP.NET Core project
- creating with Microsoft Visual Studio 2017 / Creating an ASP.NET Core project with Visual Studio 2017
- creating, with Microsoft Visual Studio Code / Creating an ASP.NET Core project with Visual Studio Code
- Visual Studio Code, using / Using Visual Studio Code, Using Visual Studio Code
- ASP.NET Core MVC project template, reviewing / Reviewing the ASP.NET Core MVC project template
- database migrations, performing / Performing database migrations
- ASP.NET Core Web API project
- creating, Visual Studio 2017 used / Using Visual Studio 2017
- creating, Visual Studio Code used / Using Visual Studio Code
- ASP.NET Identity
- used, for reviewing authentication / Reviewing authentication with ASP.NET Identity
- ASP.NET MVC / Understanding ASP.NET Core
- ASP.NET SignalR / Understanding ASP.NET Core
- ASP.NET Web API / Understanding ASP.NET Core
- ASP.NET Web Forms / Understanding ASP.NET Core
- assemblies
- referencing, Visual Studio 2017 used / Referencing an assembly using Visual Studio 2017, Referencing an assembly using Visual Studio Code
- using / Understanding assemblies and namespaces
- about / Assemblies, NuGet packages, and platforms, Working with types and attributes
- dependent assembly, referencing / Understanding dependent assemblies
- relating, with namespaces / Relating assemblies and namespaces
- browsing, Visual Studio 2017 used / Browsing assemblies with Visual Studio 2017
- versioning / Versioning of assemblies
- assembly metadata
- reading / Reading assembly metadata
- async / Understanding async and await
- asynchronous event-driven communication / Consistency across business scenarios
- Atomicity, Consistency, Integrity, and Durability (ACID) transaction / Consistency across business scenarios
- attributes
- working with / Working with types and attributes
- custom attributes, creating / Creating custom attributes
- authentication server, libraries
- IdentityServer4 / Developing an identity service for user authorization
- OpenIddict / Developing an identity service for user authorization
- ASOS (AspNet.Security.OpenIdConnect.Server) / Developing an identity service for user authorization
- await keyword
- about / Understanding async and await
- in catch blocks / Await in catch blocks
B
- Banker's Rounding / Rounding numbers
- Base64 encoding / Converting from a binary object to a string
- base class / Talking about OOP
- Base Class Libraries (BCL) / Understanding assemblies and namespaces, Base Class Libraries and CoreFX
- BenchmarkDotNet
- exploring / Exploring BenchmarkDotNet
- working / How it works
- parameters, setting / Setting parameters
- memory diagnostics / Memory diagnostics using BenchmarkDotnet
- configurations, adding / Adding configurations
- reference / Adding configurations
- big integers
- working with / Working with big integers
- Big O notation
- used, for measuring performance of algorithm / Understanding the use of Big O notation to measure the performance and complexity of an algorithm
- binary object
- converting, to string / Converting from a binary object to a string
- blogs
- subscribing / Subscribing to blogs
- Bower / Client-side web development
- boxing / Boxing and unboxing overhead
- break mode / Setting a breakpoint
- breakpoints
- setting / Setting a breakpoint
- customizing / Customizing breakpoints
- Business-to-Business (B2B) / Database architecture in microservices
- Business-to-Consumer (B2C) / Database architecture in microservices
- business scenarios
- consistency / Consistency across business scenarios
- byte arrays
- strings, encoding as / Encoding strings as byte arrays
C
- C#
- primitive data types / What are data structures?
- C# keywords
- relating, to .NET types / Relating C# keywords to .NET types
- caching / Caching
- cardinal numbers / Formatting numbers for output
- casting
- about / Casting and converting between types, Casting within inheritance hierarchies
- within inheritance hierarchies / Casting within inheritance hierarchies
- implicit casting / Implicit casting
- explicit casting / Explicit casting
- casting exceptions
- handling / Handling casting exceptions
- cast operator / Casting numbers explicitly
- catch blocks
- await keyword / Await in catch blocks
- catch statement / Catching all exceptions, Catching specific exceptions
- Central Authentication Server (CAS) / Developing an identity service for user authorization
- characters
- obtaining, of string / Getting the characters of a string
- checked statement
- using / The checked statement
- child task / Nested and child tasks
- circular linked list / Circular linked lists
- class
- defining / Defining a class, Defining the classes
- instantiating / Instantiating a class
- namespace, importing / Importing a namespace
- System.Object, inheriting from / Inheriting from System.Object
- inheriting, from System.Object / Inheriting from System.Object
- splitting, partial keyword used / Splitting classes using partial
- inheriting from / Inheriting from classes
- extending / Extending classes
- members, hiding / Hiding members
- members, overriding / Overriding members
- class library
- creating, with Microsoft Visual Studio 2017 for unit testing / Creating a class library that needs testing with Visual Studio 2017
- creating, with Visual Studio Code / Creating a class library that needs testing with Visual Studio Code, Creating a class library with Visual Studio Code
- building / Building class libraries
- creating, with Visual Studio 2017 / Creating a class library with Visual Studio 2017
- setting up / Setting up a class library and console application
- Visual Studio 2017, using / Using Visual Studio 2017
- Visual Studio Code, using / Using Visual Studio Code
- about / Understanding dependent assemblies
- client-side web development
- components, used / Client-side web development
- CLR internals
- analyzing, through SOS debugger / Analysing CLR internals through the SOS debugger in .NET Core
- code
- internationalizing / Internationalizing your code
- code cross-platform
- sharing, with .NET Standard 2.0 class libraries / Sharing code cross-platform with .NET Standard 2.0 class libraries
- code optimization
- coding principles
- about / Coding principles
- naming conventions / Naming convention
- code comments / Code comments
- one class per file / One class per file
- one logic per method / One logic per method
- collections
- used, for storing multiple values / Storing multiple values using collections
- working with / Working with collections
- reference / Working with collections
- features / Common features of all collections
- about / Understanding collections
- lists / Lists
- dictionaries / Dictionaries
- stacks / Stacks
- queues / Queues
- sets / Sets
- sorting / Sorting collections
- specialized collections / Using specialized collections
- immutable collections / Using immutable collections
- Command-Line Interface (CLI) / Creating a sample app in .NET Core using microservices architecture
- Command Query Responsibility Segregation (CQRS) / Denormalizing data into a flat schema for read/query purposes, CQRS
- Comma Separated Value (CSV) / Exploring BenchmarkDotNet
- Common Language Infrastructure (CLI) / Understanding MSIL, CLI, CTS, and CLS
- Common Language Runtime (CLR) / Disposing objects in a timely fashion, Memory allocation process overview
- Common Language Runtime (CoreCLR) / Understanding assemblies and namespaces
- Common Language Specification (CLS) / Understanding MSIL, CLI, CTS, and CLS
- Common Type System (CTS) / Understanding MSIL, CLI, CTS, and CLS
- communication
- about / Communication
- lighter interfaces, using / Using lighter interfaces
- message size, minimizing / Minimizing message size
- queuing / Queuing communication
- with microservices / Communication with microservices
- compaction / Memory fragmentation
- complex numbers
- working with / Working with complex numbers
- composition / Talking about OOP
- concurrency / Concurrency
- console applications
- setting up / Setting up a class library and console application
- Visual Studio 2017, using / Using Visual Studio 2017
- Visual Studio Code, using / Using Visual Studio Code
- creating, to publish / Creating a console application to publish
- responsiveness, improving / Improving responsiveness for console apps
- constructors
- about / Defining a class
- fields, initializing with / Initializing fields with constructors
- continuation tasks / Waiting for tasks
- convert type
- using / Using the convert type
- CoreCLR
- about / CoreCLR
- working / How the CLR works
- CoreFX / Base Class Libraries and CoreFX, CoreFX
- Core infrastructure project
- developing / Developing a Core infrastructure project
- BaseEntity class, creating / Creating the BaseEntity class
- UnitOfWork pattern / The UnitOfWork pattern
- repository interface, creating / Creating a repository interface
- logging / Logging
- Create, Read, Update, and Delete (CRUD) / Data manipulation with microservices
- CreateDefaultBuilder method
- Cross-Origin Resource Sharing (CORS)
- reference / Calling NorthwindService
- about / Creating the identity service project
- cross-platform environments
- CSS3 / Client-side web development
- custom attributes
- creating / Creating custom attributes
- custom styles
- defining / Defining custom styles
D
- data
- storing, with fields / Storing data with fields
- denormalizing, into flat schema for read/query purposes / Denormalizing data into a flat schema for read/query purposes
- database architecture, microservices
- about / Database architecture in microservices
- tables per service / Tables per service
- database per service / Database per service
- challenges, in segregating tables/database per service / Challenges in segregating tables or databases per service
- database migrations, performing
- Visual Studio 2017, using / Using Visual Studio 2017
- data binding
- about / Data binding
- to elements / Binding to elements
- to data sources / Binding to data sources
- data binding, to data sources
- NorthwindService, modifying / Modifying the NorthwindService
- Northwind app, creating / Creating the Northwind app
- data encryption
- with Visual Studio 2017 / Using Visual Studio 2017
- with Visual Studio Code / Using Visual Studio Code
- Recorder class, creating / Creating the Recorder class
- data manipulation
- with microservices / Data manipulation with microservices
- data repositories
- creating, for entities / Creating data repositories for entities
- customers repository, configuring / Configuring and registering the customers repository
- Web API controller, creating / Creating the Web API controller
- data structures
- about / What are data structures?, Data structures
- selecting, for performance optimizations / Choosing the right data structure for performance optimization
- arrays / Arrays
- lists / Lists
- stacks / Stacks
- queue / Queue
- linked list / Linked lists
- hashsets / Dictionaries, hashtables, and hashsets
- dictionaries / Dictionaries, hashtables, and hashsets
- hashtables / Dictionaries, hashtables, and hashsets
- generic lists / Generic lists
- Debug
- instrumenting with / Instrumenting with Debug and Trace
- debugging
- stepping, through code / Stepping through code
- debugging toolbar / The debugging toolbar
- debugging windows / Debugging windows
- debug mode
- versus release mode / How releasing builds increases performance
- default literals
- fields, setting with / Setting fields with default literal
- default trace listener
- writing to / Writing to the default trace listener
- delegates
- used, for calling methods / Calling methods using delegates
- deliberate bug
- application, creating with / Creating an application with a deliberate bug
- dependencies
- fixing / Fixing dependencies
- Dependency Injection (DI) / The Dependency Inversion principle, Creating the APIComponents infrastructure project
- Dependency Inversion Principle (DIP) / The Dependency Inversion principle
- dependent assembly / Understanding dependent assemblies
- deserialization / Serializing object graphs
- design patterns
- about / Design patterns
- reference / Design patterns
- Singleton pattern / Singleton pattern
- design principles
- about / Design principles
- KISS (Keep it Simple, Stupid) / KISS (Keep It Simple, Stupid)
- YAGNI (You're not gonna need it) / YAGNI (You Aren't Gonna Need It)
- DRY (Don't repeat yourself) / DRY (Don't Repeat Yourself)
- Separation of Concerns (SoC) / Separation of Concerns (SoC)
- SOLID principles / SOLID principles
- caching / Caching
- data structures / Data structures
- communication / Communication
- resource management / Resource management
- concurrency / Concurrency
- dictionaries
- about / Dictionaries
- working with / Working with dictionaries
- directories
- managing / Managing directories
- dispose
- calling off / Ensuring that dispose is called
- Dispose method / Finalizer and Dispose
- DNS
- working with / Working with URIs, DNS, and IP addresses
- Docker
- about / What is Docker?
- benefits / What is Docker?
- using, with .NET Core / Using Docker with .NET Core
- Docker containers
- microservices, deploying on / Deploying microservices on Docker containers
- Docker Hub
- reference / What is Docker?
- Docker images
- executing / Running Docker images
- Domain-Driven Design (DDD) pattern / Standard practice when developing microservices, DDD
- Don't Repeat Yourself (DRY) / Writing functions
- do statement / The do statement
- dotnet CLI / Understanding dotnet commands
- dotnet commands / Understanding dotnet commands
- dot syntax / Calling methods using delegates
- doubly linked lists / Doubly linked lists
- drives
- managing / Managing drives
- DRY (Don't repeat yourself) / DRY (Don't Repeat Yourself)
- DuckDuckGo
- reference / Stack Overflow
- dynamic link library / Understanding dependent assemblies
E
- efficiency
- evaluating, of types / Evaluating the efficiency of types
- empty website
- static files, enabling / Enabling static files
- default files, enabling / Enabling default files
- encapsulation / Talking about OOP
- Entity Framework (EF) / Logical architecture
- Entity Framework Core (EF Core)
- empty project template, reviewing / Reviewing the ASP.NET Core Empty project template
- using, with ASP.NET Core / Using Entity Framework Core with ASP.NET Core
- entity models, creating for Northwind / Creating Entity models for Northwind
- configuring, as service / Configure Entity Framework Core as a service
- data, manipulating / Manipulating data
- Entity Resource Planning (ERP) / Wrapping microservices behind an API gateway
- enum keyword
- used, for storing value / Storing a value using the enum keyword
- events
- about / Raising and handling events
- handling / Raising and handling events
- raising / Raising and handling events
- defining / Defining events
- defining, Visual Studio 2017 used / Using Visual Studio 2017, Using Visual Studio 2017 or Visual Studio Code
- defining, Visual Studio Code used / Using Visual Studio Code
- exception handling / Exception handling
- exceptions
- handling / Handling exceptions when converting types
- handling, try statement used / The try statement
- all exceptions, catching / Catching all exceptions
- specific exceptions, catching / Catching specific exceptions
- inheriting from / Inheriting from an exception
- explicit casting / Casting and converting between types, Explicit casting
- eXtensible Markup Language (XML) / Serializing object graphs
- extension methods
- about / Extending types when you can't inherit
- used, for reusing functionality / Using extension methods to reuse functionality
F
- factorials
- calculating, with recursion / Calculating factorials with recursion
- fields
- about / Defining a class
- constants / Defining a class
- read-only fields / Defining a class
- events / Defining a class
- data, storing with / Storing data with fields
- defining / Defining fields
- static, making / Making a field static
- constant, making / Making a field constant
- read-only, making / Making a field read-only
- initializing, with constructors / Initializing fields with constructors
- setting, with default literal / Setting fields with default literal
- naming, of tuples / Naming the fields of a tuple
- file information
- obtaining / Getting file information
- file resources
- disposing / Disposing of file resources
- files
- managing / Managing files
- controlling / Controlling files
- text, encoding / Encoding and decoding text in files
- text, decoding / Encoding and decoding text in files
- filesystem
- managing / Managing the filesystem
- handling / Handling cross-platform environments and filesystems
- paths, managing / Managing paths
- Finalize method / Finalizer and Dispose
- finalizer keyword / Releasing unmanaged resources
- finalizers
- avoiding / Avoiding finalizers
- finally statement
- disposal, simplifying with using statement / Simplifying disposal with the using statement
- Firefox / Understanding HTTP
- first-in, first out (FIFO) / Queues
- First In First Out (FIFO) / Queue
- Fluent Design System
- about / Understanding Fluent Design System
- user interface elements, filling with acrylic brushes / Filling user interface elements with acrylic brushes
- user interface elements, connecting with animations / Connecting user interface elements with animations
- parallax views / Parallax views and Reveal lighting
- Reveal lighting / Parallax views and Reveal lighting
- foreach loop / For and foreach
- foreach statement
- about / The foreach statement
- working / The foreach statement
- for loop / For and foreach
- for statement / The for statement
- framework-dependent deployments (FDDs) / How the CLR works
- frameworks / Understanding frameworks
- functions
- writing / Writing functions
- times table function / Writing a times table function
- writing, that returns value / Writing a function that returns a value
- mathematical functions / Writing mathematical functions
- function streams / Reading and writing with streams
G
- garbage collection (GC)
- about / CoreCLR, Garbage collection, Disposing objects in a timely fashion
- generations / Generations in GC
- garbage collector (GC) / Creating the Recorder class
- generic lists / Generic lists
- generic method
- making / Making a generic method
- generics
- about / Storing multiple values using collections
- used, for making types reusable / Making types more reusable with generics
- generic type
- making / Making a generic type
- Global Assembly Cache (GAC) / Differences between .NET Framework and .NET Core
- globalization / Internationalizing your code
- Google / Google
- Google Chrome / Understanding HTTP
- graphical user interface (GUI) / Understanding async and await
- GUI apps
- responsiveness, improving / Improving responsiveness for GUI apps
- GZIP compression algorithm / Compressing streams
H
- hashsets / Dictionaries, hashtables, and hashsets
- hashtables / Dictionaries, hashtables, and hashsets
- heap memory / Managing memory with reference and value types
- Home controller's views
- rendering / Rendering the Home controller's views
- HTML5 / Client-side web development
- HTML Programming, in VS code
- reference / Client-side web development
- Hypertext Transfer Protocol (HTTP) / Understanding HTTP
I
- identity service, for user authorization
- developing / Developing an identity service for user authorization
- OpenIddict connect flows / OpenIddict connect flows
- identity service project
- creating / Creating the identity service project
- IDisposable interface
- about / Introduction to the IDisposable interface
- using / Using IDisposable
- implementing / When to implement the IDisposable interface
- if statement
- about / The if statement
- code / The code
- pattern matching / Pattern matching with the if statement
- immutable collections
- using / Using immutable collections
- implicit casting / Casting and converting between types, Implicit casting
- indexers
- about / Defining a class
- access, controlling with / Controlling access with properties and indexers
- defining / Defining indexers
- inheritance
- about / Talking about OOP
- preventing / Preventing inheritance and overriding
- inter-process synchronization / Applying other types of synchronization
- interface, creating for dialing phone numbers
- phone dialer, implementing for iOS / Implement the phone dialer for iOS
- phone dialer, implementing for Android / Implement the phone dialer for Android
- interfaces
- implementing / Implementing interfaces
- common interfaces / Common interfaces
- IComparable / Common interfaces
- IComparer / Common interfaces
- IDisposable / Common interfaces
- IFormattable / Common interfaces
- IFormatter / Common interfaces
- IFormatProvider / Common interfaces
- Interface Segregation Principle (ISP) / The Interface Segregation principle
- intermediate language (IL) / Understanding assemblies and namespaces
- Intermediate Language (IL) / Understanding MSIL, CLI, CTS, and CLS
- internationalization / Internationalizing your code
- International Standards Organization (ISO) / Internationalizing your code
- intersect / Sets
- IP addresses
- working with / Working with URIs, DNS, and IP addresses
- iteration statements
- about / Iteration statements
- while statement / The while statement
- do statement / The do statement
- for statement / The for statement
- foreach statement / The foreach statement
J
- JavaScript / Client-side web development
- JavaScript Object Notation (JSON) / Adding a package reference, Serializing object graphs
- JIT compilation / .NET Native and JIT compilation
- JSON
- serializing with / Serializing with JSON
- JSON Web Tokens (JWT) / Creating the identity service project
- Just In Time (JIT) compiler / CoreCLR
K
- Kestrel / Classic ASP.NET versus modern ASP.NET Core, Testing the ASP.NET MVC website
- KISS (Keep it Simple, Stupid) / KISS (Keep It Simple, Stupid)
L
- language compilers / Understanding assemblies and namespaces
- large object heap (LOH) / Memory fragmentation
- last-in, first-out (LIFO) / Stacks
- Last In First Out (LIFO) / Stacks
- layered architecture
- versus microservices architecture / Standard practice when developing microservices
- libraries
- packaging, for NuGet distributions / Packaging your libraries for NuGet distribution, Packaging a library for NuGet
- linked list
- about / Linked lists
- singly linked list / Singly linked lists
- doubly linked lists / Doubly linked lists
- circular linked list / Circular linked lists
- benefits / Circular linked lists
- Linux
- Microsoft Visual Studio Code, using on / Using Visual Studio Code on macOS, Linux, or Windows
- Liskov Substitution Principle (LSP) / Liskov principle
- lists
- about / Lists, Lists
- working with / Working with lists
- benefits / Lists
- local functions
- defining / Defining local functions
- localization / Internationalizing your code
- lock statement / Understanding the lock statement
- logarithm operation / Logarithms
- logging
- during development / Logging during development and runtime
- during runtime / Logging during development and runtime
M
- macOS
- Microsoft Visual Studio Code, using on / Using Visual Studio Code on macOS, Linux, or Windows
- filesystem, managing / Using macOS
- Mads Kristensen's extensions, for VS code
- reference / Client-side web development
- Markdown Documentation (MD) / Exploring BenchmarkDotNet
- mathematical functions
- writing / Writing mathematical functions
- memory
- managing, with reference type / Managing memory with reference and value types
- managing, with value types / Managing memory with reference and value types
- usage, monitoring / Monitoring performance and memory use
- memory allocation
- overview / Memory allocation process overview
- memory diagnostics
- with BenchmarkDotnet / Memory diagnostics using BenchmarkDotnet
- memory fragmentation / Memory fragmentation
- metadata / Working with types and attributes
- metapackages / Understanding metapackages
- methods
- about / Writing functions, Defining a class, Raising and handling events
- writing / Writing and calling methods
- calling / Writing and calling methods
- defining, with tuples / Defining methods with tuples
- parameters, passing to / Defining and passing parameters to methods
- parameters, defining to / Defining and passing parameters to methods
- overloading / Overloading methods
- optional parameters / Optional parameters and named arguments
- named arguments / Optional parameters and named arguments
- simplifying, with operators / Simplifying methods with operators
- functionality, implementing / Implementing some functionality with a method
- calling, delegates used / Calling methods using delegates
- method signature / Overloading methods
- microservices
- standard practice, on deployment / Standard practice when developing microservices
- types / Types of microservices
- stateless microservices / Stateless microservices
- stateful microservices / Stateful microservices
- using, for data manipulation / Data manipulation with microservices
- wrapping, behind API gateway / Wrapping microservices behind an API gateway
- communication / Communication with microservices
- database architecture / Database architecture in microservices
- deploying, on Docker containers / Deploying microservices on Docker containers
- microservices architecture
- about / Microservices architecture
- benefits / Benefits of microservices architecture
- versus layered architecture / Standard practice when developing microservices
- developing, in .NET Core / Developing microservices architecture with .NET Core
- used, for creating sample app in .NET Core / Creating a sample app in .NET Core using microservices architecture
- Microsoft .NET Core App platform / Understanding dependent assemblies
- Microsoft Developer Network (MSDN) / Microsoft Docs and MSDN
- Microsoft Docs
- reference link / Microsoft Docs and MSDN
- Microsoft Edge / Understanding HTTP
- Microsoft Intermediate Language (MSIL) / Understanding MSIL, CLI, CTS, and CLS
- Microsoft Visual Studio 2017
- ASP.NET Core project, creating / Creating an ASP.NET Core project with Visual Studio 2017
- Microsoft Visual Studio Code
- URL, for extensions / Client-side web development
- mobile apps
- building, Visual Studio for Mac used / Building mobile apps using Xamarin.Forms
- Android SDKs, adding / Adding Android SDKs
- Xamarin.Forms solution, creating / Creating a Xamarin.Forms solution
- model, creating / Creating a model
- interface, creating for phone numbers / Creating an interface for dialing phone numbers
- views, creating for customers list / Creating views for the customers list and customer details, Creating the view for the list of customers, Creating the view for the customer details
- views, creating for customer details / Creating views for the customers list and customer details, Creating the view for the customer details
- testing, with iOS / Testing the mobile app with iOS
- NuGet packages, adding for REST service calls / Adding NuGet packages for calling a REST service
- customers, obtaining from service / Getting customers from the service
- multiple cores, of CPU
- utilizing, for high performance / Utilizing multiple cores of the CPU for high performance
- multiple projects
- managing, with Microsoft Visual Studio Code / Managing multiple projects with Visual Studio Code
- multiple values
- storing, collections used / Storing multiple values using collections
- combining, with tuples / Combining multiple values with tuples
- multitasking
- supporting types / Common types that support multitasking
- mutually exclusive lock
- applying, to resource / Applying a mutually exclusive lock to a resource
N
- .NET Core
- struct types / Managing memory with reference and value types
- supported applications / Could you port?
- unsupported applications / Could you port?
- versus .NET Framework / Differences between .NET Framework and .NET Core
- components / .NET Core internals
- compilation process / From compilation to execution – Under the hood
- nonprimitive types / What are data structures?
- microservices architecture, developing / Developing microservices architecture with .NET Core
- Docker, using with / Using Docker with .NET Core
- .NET Core 2.0
- applications, benchmarking / Benchmarking .NET Core 2.0 applications
- .NET Core application
- publishing, for deployment / Publishing your applications for deployment
- console application, creating / Creating a console application to publish
- publishing, with Microsoft Visual Studio 2017 on Windows / Publishing with Visual Studio 2017 on Windows
- publishing, with Microsoft Visual Studio Code on macOS / Publishing with Visual Studio Code on macOS
- .NET Core packages
- frameworks / Understanding frameworks
- .NET Core source browser
- reference / CoreFX
- .NET Framework
- porting, to .NET Core / Porting from .NET Framework to .NET Core
- versus .NET Core / Differences between .NET Framework and .NET Core
- .NET Native / .NET Native and JIT compilation
- .NET Portability Analyzer
- .NET Standard 2.0 class library
- code cross-platform, sharing / Sharing code cross-platform with .NET Standard 2.0 class libraries
- creating / Creating a .NET Standard 2.0 class library
- creating, Visual Studio 2017 used / Using Visual Studio 2017
- creating, Visual Studio Code used / Using Visual Studio Code
- .NET types
- inheriting / Inheriting and extending .NET types
- extending / Inheriting and extending .NET types
- C# keywords, relating to / Relating C# keywords to .NET types
- namespaces
- using / Understanding assemblies and namespaces
- about / Namespaces
- assemblies, relating with / Relating assemblies and namespaces
- importing / Importing a namespace
- nested task / Nested and child tasks
- network resources
- working with / Working with network resources
- server, pinging / Pinging a server
- non-.NET Standard libraries
- non polymorphic inheritance / Polymorphism
- nonprimitive types, .NET Core / What are data structures?
- Northwind database context
- class library, creating / Creating a class library for Northwind database context
- Visual Studio 2017, using / Using Visual Studio 2017
- Visual Studio Code, using / Using Visual Studio Code
- Northwind entity classes
- entity models, using / Creating Entity models for Northwind
- class library, creating / Creating a class library for the Northwind entity classes
- entity classes, defining / Defining the entity classes
- database context class, defining / Defining the database context class
- NorthwindService
- calling, with Visual Studio 2017 / Using Visual Studio 2017
- calling, with Visual Studio Code / Using Visual Studio Code
- calling, by modifying component / Modifying the home component to call NorthwindService
- NuGet distribution
- libraries, packaging for / Packaging your libraries for NuGet distribution
- NuGet packages
- about / Understanding assemblies and namespaces, Assemblies, NuGet packages, and platforms, Understanding NuGet packages
- metapackages / Understanding metapackages
- dependencies, fixing / Fixing dependencies
- library, packaging for / Packaging a library for NuGet
- reference / Using non-.NET Standard libraries
- adding, for REST service calls / Adding NuGet packages for calling a REST service
- numbers
- casting, implicitly / Casting numbers implicitly
- casting, explicitly / Casting numbers explicitly
- rounding / Rounding numbers
- formatting, for output / Formatting numbers for output
- working with / Working with numbers
- big integers / Working with big integers
- complex numbers / Working with complex numbers
O
- object-oriented programming (OOP)
- about / Talking about OOP
- encapsulation / Talking about OOP
- composition / Talking about OOP
- aggregation / Talking about OOP
- inheritance / Talking about OOP
- abstraction / Talking about OOP
- polymorphism / Talking about OOP
- object disposition, in .NET Core
- best practices / Best practices for disposing of objects in .NET Core
- object graphs, serializing
- about / Serializing object graphs
- with XML / Serializing with XML
- with JSON / Serializing with JSON
- with other formats / Serializing with other formats
- Object Oriented Principles (OOP) / KISS (Keep It Simple, Stupid)
- Object Relationship Mapping (ORM) / Logical architecture
- objects
- comparing, when sorting / Comparing objects when sorting
- OpenAPI Specification / Testing POST, PUT, and DELETE requests with Swagger
- Open Closed Principle (OCP)
- about / Open Closed principle
- parameters / Parameters
- inheritance / Inheritance
- composition / Composition
- OpenIddict / OpenIddict connect flows
- operators
- about / Defining a class
- methods, simplifying with / Simplifying methods with operators
- functionality, implementing / Implementing some functionality with an operator
- ordinal numbers / Formatting numbers for output
- overflow
- checking for / Checking for overflow
- checking, checked statement used / The checked statement
- overriding
- preventing / Preventing inheritance and overriding
P
- package
- benefits / Understanding NuGet packages
- testing / Testing your package
- testing, Visual Studio Code used / Using Visual Studio Code
- testing, Visual Studio 2017 used / Using Visual Studio 2017
- package reference
- adding / Adding a package reference
- adding, Visual Studio Code used / Using Visual Studio Code
- adding, Visual Studio 2017 used / Using Visual Studio 2017
- parameters
- defining, to methods / Defining and passing parameters to methods
- passing, to methods / Defining and passing parameters to methods, Controlling how parameters are passed
- passing, to method / Controlling how parameters are passed
- passing, route value used / Passing parameters using a route value
- passing, query string used / Passing parameters using a query string
- partial keyword
- used, for splitting classes / Splitting classes using partial
- used, for splitting class / Splitting classes using partial
- paths
- managing / Managing paths
- pattern matching
- with if statement / Pattern matching with the if statement
- with switch statement / Pattern matching with the switch statement
- reference / Pattern matching with the switch statement
- with regular expressions / Pattern matching with regular expressions
- performance
- monitoring / Monitoring performance and memory use
- Plain Old CLR Object (POCO) / Minimizing message size, Logical architecture
- polymorphic inheritance / Polymorphism
- polymorphism / Talking about OOP, Polymorphism
- Portable Class Libraries (PCL) / Sharing code cross-platform with .NET Standard 2.0 class libraries
- portable executable (PE) file / From compilation to execution – Under the hood
- primitive data types, C# / What are data structures?
- processes / Understanding processes, threads, and tasks
- processing strings
- efficiency, measuring / Measuring the efficiency of processing strings
- project templates
- using / Using other project templates
- reference / Installing additional template packs
- additional packs, installing / Installing additional template packs
- properties
- about / Defining a class
- access, controlling with / Controlling access with properties and indexers
- read-only properties / Defining read-only properties
- settable properties / Defining settable properties
Q
- query string
- used, for passing parameters / Passing parameters using a query string
- queue
- queues / Queues
R
- Razor / Understanding ASP.NET Core MVC views
- Razor Pages
- exploring / Exploring Razor Pages
- enabling / Enabling Razor Pages
- defining / Defining a Razor Page
- shared layouts, using / Using shared layouts with Razor Pages
- shared layout, setting / Setting a shared layout
- shared layout, defining / Defining a shared layout
- code-behind files, using / Using code-behind files with Razor Pages
- read-only properties
- defining / Defining read-only properties
- read mode / Applying other types of synchronization
- recursion
- factorials, calculating with / Calculating factorials with recursion
- versus iteration, reference / Calculating factorials with recursion
- reflection / Working with types and attributes, Doing more with reflection
- regular expressions
- pattern matching / Pattern matching with regular expressions
- syntax / The syntax of a regular expression
- examples / Examples of regular expressions
- release build / How releasing builds increases performance
- release mode
- versus debug mode / How releasing builds increases performance
- Representational State Transfer (REST) / Building web services using ASP.NET Core Web API
- resource management
- threads misuse, avoiding / Avoiding improper use of threads
- objects, disposing / Disposing objects in a timely fashion
- resources, acquiring / Acquiring resources when they are required
- resources
- usage, monitoring / Monitoring performance and resource usage
- using / Using resources and templates
- sharing / Sharing resources
- REST service
- calling, with NuGet packages / Adding NuGet packages for calling a REST service
- Reveal
- reference / Parallax views and Reveal lighting
- route value
- used, for passing parameters / Passing parameters using a route value
- Runtime IDentifier (RID)
- about / Creating a console application to publish
- reference link / Creating a console application to publish
S
- Safari / Understanding HTTP
- sample app, in .NET Core
- creating, microservices architecture used / Creating a sample app in .NET Core using microservices architecture
- solution structure / Solution structure
- logical architecture / Logical architecture
- vendor service implementation / Implementing the vendor service
- vendor domain, creating / Creating a vendor domain
- vendor infrastructure, creating / Creating the vendor infrastructure
- vendor service, creating / Creating the vendor service
- mediator pattern, implementing in vendor service / Implementing the mediator pattern in the vendor service
- Secure Sockets Layer (SSL)
- segments / Understanding the default route
- selection statements
- about / Selection statements
- Microsoft Visual Studio 2017, using / Using Visual Studio 2017
- Microsoft Visual Studio Code, using on macOS / Using Visual Studio Code on macOS, Linux, or Windows
- Microsoft Visual Studio Code, using on Linux / Using Visual Studio Code on macOS, Linux, or Windows
- Microsoft Visual Studio Code, using on Windows / Using Visual Studio Code on macOS, Linux, or Windows
- if statement / The if statement
- switch statement / The switch statement
- self-contained deployments (SCDs) / How the CLR works
- semantic versioning
- reference / Versioning of assemblies
- separate comparer
- defining / Defining a separate comparer
- Separation of Concerns (SoC) / Separation of Concerns (SoC)
- serialization / Serializing object graphs
- sets
- about / Sets
- settable properties
- defining / Defining settable properties
- shared resources
- access, synchronizing / Synchronizing access to shared resources
- accessing, from multiple threads / Accessing a resource from multiple threads
- mutually exclusive lock, applying / Applying a mutually exclusive lock to a resource
- lock statement / Understanding the lock statement
- operations, making atomic / Making operations atomic
- signaling / Applying other types of synchronization
- Single-Page Applications (SPAs) / OpenIddict connect flows
- Single Page Application (SPA)
- about / Understanding dotnet commands, Client-side web development
- building, with Angular / Building SPAs using Angular
- Single Responsibility Principle (SRP) / Single Responsibility Principle
- Singleton pattern
- about / Singleton pattern
- reference / Singleton pattern
- singly linked lists / Singly linked lists
- small object heap (SOH) / Memory fragmentation
- SOLID principles
- about / SOLID principles
- Single Responsibility Principle (SRP) / Single Responsibility Principle
- Open Closed Principle (OCP) / Open Closed principle
- Liskov Substitution Principle (LSP) / Liskov principle
- Interface Segregation Principle (ISP) / The Interface Segregation principle
- Dependency Inversion Principle (DIP) / The Dependency Inversion principle
- SOS debugger
- CLR internals, analyzing through / Analysing CLR internals through the SOS debugger in .NET Core
- specialized collections
- using / Using specialized collections
- stack memory / Managing memory with reference and value types
- Stack Overflow / Stack Overflow
- stacks / Stacks
- stateful microservices / Stateful microservices
- stateless microservices / Stateless microservices
- statements
- selection statements / Selection statements
- iteration statements / Iteration statements
- static members / Making a field static
- static methods
- used, for reusing functionality / Using static methods to reuse functionality
- Stream class
- members / Reading and writing with streams
- streams
- about / Reading and writing with streams
- reading with / Reading and writing with streams
- writing with / Reading and writing with streams
- compressing / Compressing streams
- string
- types, converting to / Converting from any type to a string
- binary type, converting to / Converting from a binary object to a string
- converting, to numbers / Parsing from strings to numbers or dates and times
- length, obtaining / Getting the length of a string
- characters, obtaining of / Getting the characters of a string
- splitting / Splitting a string
- part of string, obtaining / Getting part of a string
- checking, for content / Checking a string for content
- members / Other string members
- building, efficiently / Building strings efficiently
- encoding, as byte arrays / Encoding strings as byte arrays
- string concatenation / String concatenation
- struct type
- defining / Defining a struct type
- super class / Talking about OOP
- Swagger
- used, for testing DELETE requests / Testing POST, PUT, and DELETE requests with Swagger
- about / Testing POST, PUT, and DELETE requests with Swagger
- used, for testing POST requests / Testing POST, PUT, and DELETE requests with Swagger
- used, for testing PUT requests / Testing POST, PUT, and DELETE requests with Swagger
- reference / Testing POST, PUT, and DELETE requests with Swagger
- Swagger package installation
- Visual Studio 2017, using / Installing a Swagger package
- Visual Studio Code, using / Using Visual Studio Code
- Swagger UI
- used, for testing GET request / Testing GET requests with Swagger UI
- used, for testing POST requests / Testing POST requests with Swagger UI
- switch statement
- about / The switch statement
- code / The code
- pattern matching / Pattern matching with the switch statement
- synchronization
- types, applying / Applying other types of synchronization
- System.Object
- inheriting from / Inheriting from System.Object
T
- task / Utilizing multiple cores of the CPU for high performance
- task parallel library (TPL)
- tasks
- about / Understanding processes, threads, and tasks
- executing, asynchronously / Running tasks asynchronously
- multiple actions, executing synchronously / Running multiple actions synchronously
- used, for executing multiple actions asynchronously / Running multiple actions asynchronously using tasks
- waiting for / Waiting for tasks
- continuing / Continuing with another task
- child task / Nested and child tasks
- nested task / Nested and child tasks
- templates
- using / Using resources and templates
- control template, replacing / Replacing a control template
- Test Driven Development (TDD)
- reference / Unit testing functions
- text
- working with / Working with text
- encoding / Encoding text
- encoding, in files / Encoding and decoding text in files
- decoding, in files / Encoding and decoding text in files
- text streams
- writing to / Writing to text and XML streams, Writing to text streams
- threads
- about / Understanding processes, threads, and tasks
- resources, accessing / Accessing a resource from multiple threads
- times table function
- writing / Writing a times table function
- Trace
- instrumenting with / Instrumenting with Debug and Trace
- trace levels
- switching / Switching trace levels
- trace listeners
- about / Instrumenting with Debug and Trace
- configuring / Configuring trace listeners
- try statement
- about / The try statement
- file resources disposal, implementing / Implementing disposal with try statement
- tuple name inference / Inferring tuple names
- tuples
- multiple values, combining with / Combining multiple values with tuples
- methods, defining with / Defining methods with tuples
- fields, naming / Naming the fields of a tuple
- deconstructing / Deconstructing tuples
- typed view
- defining / Defining a typed view
- types
- casting between / Casting and converting between types
- converting between / Casting and converting between types
- converting, to string / Converting from any type to a string
- extending / Extending types when you can't inherit
- working with / Working with types and attributes
U
- unboxing / Boxing and unboxing overhead
- unchecked statement / The unchecked statement
- Unicode / Encoding text
- Uniform Resource Locator (URL) / Understanding HTTP, OpenIddict connect flows
- unit testing
- functions / Unit testing functions
- reference / Unit testing functions
- class library, creating with Microsoft Visual Studio 2017 / Creating a class library that needs testing with Visual Studio 2017
- unit test project
- creating, with Visual Studio 2017 / Creating a unit test project with Visual Studio 2017
- unit tests
- writing / Writing unit tests
- running, with Visual Studio 2017 / Running unit tests with Visual Studio 2017
- running, with Visual Studio Code / Running unit tests with Visual Studio Code
- Universal Windows Platform (UWP)
- about / Understanding Universal Windows Platform
- app's layout, adapting / Understanding Universal Windows Platform
- advantages / Understanding Universal Windows Platform
- unmanaged resources
- releasing / Releasing unmanaged resources
- upgradeable read mode / Applying other types of synchronization
- URIs
- working with / Working with URIs, DNS, and IP addresses
- user agent / Understanding HTTP
- user interface (UI) / Improving responsiveness for GUI apps
- using statement
- file resources disposal, simplifying / Simplifying disposal with the using statement
- UWP apps / Understanding XAML Standard 1.0
- UWP Community Toolkit
- reference / Installing more controls
V
- view engines / Understanding ASP.NET Core MVC views
- view models
- creating, for requests / Creating view models for requests
- about / Creating view models for requests
- views
- creating, for customers details / Creating the view for the customer details
- Virtual Machine (VM) / Microservices architecture
- Visual Studio
- used, for creating .NET Standard 2.0 class library / Using Visual Studio Code
- Visual Studio 2017
- using, for selection statements / Using Visual Studio 2017
- class library, creating for unit testing / Creating a class library that needs testing with Visual Studio 2017
- unit test project, creating / Creating a unit test project with Visual Studio 2017
- unit tests, running with / Running unit tests with Visual Studio 2017
- class library, creating / Creating a class library with Visual Studio 2017
- used, for referencing assembly / Referencing an assembly using Visual Studio 2017
- events, defining / Using Visual Studio 2017, Using Visual Studio 2017 or Visual Studio Code
- dependent assemblies / Using Visual Studio 2017
- assemblies, browsing / Browsing assemblies with Visual Studio 2017, Using Visual Studio 2017 or Visual Studio Code
- used, for creating .NET Standard 2.0 class library / Using Visual Studio 2017
- publishing with / Publishing with Visual Studio 2017 on Windows
- used, for adding package reference / Using Visual Studio 2017
- Visual Studio Code
- using, on macOS / Using Visual Studio Code on macOS, Linux, or Windows
- using, on Linux / Using Visual Studio Code on macOS, Linux, or Windows
- using, on Windows / Using Visual Studio Code on macOS, Linux, or Windows
- class library, creating / Creating a class library that needs testing with Visual Studio Code, Creating a class library with Visual Studio Code
- unit tests, running with / Running unit tests with Visual Studio Code
- used, for referencing assembling / Referencing an assembly using Visual Studio Code
- multiple projects, managing / Managing multiple projects with Visual Studio Code
- events, defining / Using Visual Studio Code
- dependent assemblies / Using Visual Studio Code
- publishing with / Publishing with Visual Studio Code on macOS
- used, for adding package reference / Using Visual Studio Code
- used, for testing package / Using Visual Studio Code, Using Visual Studio 2017
W
- web applications
- scalability improving / Improving scalability for web applications and web services
- web development
- HTTP / Understanding HTTP
- client-side web development / Client-side web development
- web service
- creating, for Northwind database / Creating a web service for the Northwind database
- data repositories, creating for entities / Creating data repositories for entities
- web service, for Northwind database
- creating / Creating a web service for the Northwind database
- Visual Studio 2017, using / Using Visual Studio 2017
- Visual Studio Code, using / Using Visual Studio Code
- web services
- about / Building web services using ASP.NET Core Web API
- ASP.NET Core controllers / Understanding ASP.NET Core controllers
- ASP.NET Core Web API project, creating / Creating an ASP.NET Core Web API project
- testing, Swagger used / Documenting and testing web services using Swagger
- documenting, Swagger used / Documenting and testing web services using Swagger
- GET requests, testing with browser / Testing GET requests with any browser
- while statement / The while statement
- Windows
- Microsoft Visual Studio Code, using on / Using Visual Studio Code on macOS, Linux, or Windows
- Windows 10
- filesystem, managing / Using Windows 10
- Windows app
- creating / Creating a modern Windows app
- developer mode, enabling / Enabling developer mode
- UWP project, creating / Creating a UWP project
- common controls, exploring / Exploring common controls and acrylic brushes
- acrylic brushes, exploring / Exploring common controls and acrylic brushes
- Reveal, exploring / Exploring Reveal
- controls, installing / Installing more controls
- Windows Communication Foundation (WCF) / Understanding ASP.NET Core
- Windows Driver Kit (WDK)
- installation link / Analysing CLR internals through the SOS debugger in .NET Core
- Windows platform / Understanding the modern Windows platform
- Windows Presentation Foundation (WPF) / Understanding XAML Standard 1.0
- Windows Template Studio
- used, for building apps / Building apps using Windows Template Studio
- write mode / Applying other types of synchronization
X
- Xamarin
- about / Understanding Xamarin and Xamarin.Forms
- extending, by Xamarin.Forms / How Xamarin.Forms extends Xamarin
- Xamarin.Forms
- about / Understanding Xamarin and Xamarin.Forms
- Xamarin, extending / How Xamarin.Forms extends Xamarin
- mobile app, in cloud / Mobile first, cloud first
- XAML
- about / Understanding XAML Standard 1.0
- used, for simplifying code / Simplifying code using XAML
- common controls, selecting / Choosing common controls
- XML
- serializing with / Serializing with XML
- deserializing with / Deserializing with XML
- customizing / Customizing the XML
- XML streams
- writing to / Writing to text and XML streams, Writing to XML streams
Y
- YAGNI (You're not gonna need it) / YAGNI (You Aren't Gonna Need It)