MCSD Certification Training

Plan the application layers

• Plan data access; plan for separation of concerns,
• Appropriate use of models, views, controllers, view components, and service dependency injection;
• Choose between client-side and server-side processing;
• Design for scalability;
• Choose between ASP.NET Core and ASP.NET;
• Choose when to use .NET standard libraries;

Design a Distributed Application

• Design a hybrid application;
• Plan for session management in a distributed environment
• Plan web farms; run Microsoft Azure services on-premises with Azure Pack;
• Enable deferred processing through Azure features (including queues, scheduled, and on-demand jobs, Azure Functions, and Azure Web Jobs, etc.)

Design and Implement the Azure Web Apps Life Cycle

• Identify and implement Start, Run, and Stop events
• Code against application events in applications;
• Configure startup tasks, including (IIS, app pool configuration, and third-party tools)

Configure State Management

• Choose a state management mechanism including (in-process, out of process, and Redis- based state management);
• Plan for scalability;
• Use cookies or local storage to maintain state;
• Apply configuration settings in web.config files;
• Implement session less state (including Query Strings)
• Configure middleware to enable session and application state in ASP.NET Core

Design a Caching Strategy

• Implement page output caching
• Implement data caching;
• Create cache profiles;
• Implement HTTP caching;
• Implement Azure Redis caching
• Plan a content delivery
• Network (CDN) strategy, for example, Azure CDN

Design and implement a Web Socket strategy

• Read and write string and binary data asynchronously
• Choose a connection loss strategy; decide when to use
• Web Sockets; implement Signal R;
• Enable web socket features in an Azure Web App instance

Design a Configuration Management Solution

• Manage configuration sources, including XML, JSON, and INI files;
• Manage environment variables; implement Option objects;
• Implement multiple environments using files and hierarchical structure
• Manage sensitive configuration;
• React to runtime configuration changes;
• Implement a custom configuration source;
• Secure configuration by using Azure Key Vault
• Use the Secret Manager tool in development to keep secrets out of your code for configuration values

Interact with the host environment

• Work with file system using file providers; work with environment variables;
• Determine hosting environment capabilities;
• Implement native components, including PInvoke and native dependencies for hosts including Linux and Windows;
• Use ASP.NET hosting on an Open Web Interface for .NET (OWIN)-based server

Compose an application by using the framework pipeline

• Add custom request processing modules to the pipeline;
• Add, remove, and configure services used in the application;
• Design and implement middleware;
• Design for kestrel, Http.sys web server and IIS;
• Design and implement startup filters

Design a browser artifact build strategy

• Design a JavaScript build pipeline using Gulp, Grunt, NPM and Bower;
• Design an artifact build strategy using Less, Sass and Font Awesome;
• Design and implement a bundling and minification strategy for browser artifacts, including JavaScript, CSS, and images

Design a server build strategy

• Manage NuGet dependencies;
• Target runtimes, including the full .NET Framework, .NET core, and .NET standard;
• Manage debug and release configurations, including compilation and optimization options;
• Include or exclude files from build;
• Manage build sources, including content, resources, and shared files;
• Implement metadata for projects, including version, release notes, and descriptions;
• Define other build options, including XML Doc and warningsAsErrors;
• Work with static files in ASP.NET core.

Design a publishing strategy

• Implement application publishing using dotnet.exe;
• Manage publishing options in csproj; implement additional tooling;
• Implement pre-publish and post-publish scripts;
• Implement native compilation;
• Publish to Docker container image

Implement an Azure deployment strategy

• Deploy Azure Web App using supported deployment models including FTP, Kudu, Web Deploy, and Visual Studio Publishing Wizard;
• Provision ARM- based resources while deploying applications;
• Implement deployment environments, including dev, test, and prod in Azure;
• Use deployment slots for staging sites;
• Deploy to Azure Stack

Implement a on-premises deployment strategy

• Deploy application to IIS using Web Deploy, XCOPY, and Visual Studio Publishing Wizard;
• Deploy application to Windows Nano Server, deploy application to IIS Hosted Web Core, deploy application to HTTP.sys web server;
• Deploy application to Kestrel on Windows and Linux; implement reverse proxying to Kestrel using IIS and Nginx

Create elements of the user interface for a web application

• Create and apply styles by using CSS;
• Structure and lay out the user interface by using HTML,
• Implement dynamic page content based on a design

Design and implement UI behavior

• Implement client-side forms validation;
• Use JavaScript to manipulate the DOM;
• Extend objects by using prototypal inheritance;
• Use AJAX to make partial page updates
• Design the UI layout of an application
• Implement partial views and view components for reuse in different areas of the application;
• Design and implement pages by using Razor Pages;
• Design and implement layouts to provide visual structure;
• Define and render optional and required page sections;
• Create and use tag and HTML helpers to simplify markup

Plan a responsive UI layout

• Plan for applications that run on multiple devices and screen resolutions;
• Use media queries and Bootstrap’s responsive grid;
• Detect browser features and capabilities;
• Create a web application that runs across multiple browsers and mobile devices;
• Enable consistent cross-browser experiences with poly-fills

Plan mobile UI strategy

• Implement mobile specific UI elements such as touch input, low bandwidth situations, and device orientation changes;
• Define and implement a strategy for working with mobile browsers

Plan for search engine optimization and accessibility

• Use analytical tools to parse HTML;
• Provide an xml sitemap and robots.txt file to improve scraping;
• Write semantic markup for accessibility, for example, screen readers;
• Use rich snippets to increase content visibility

Plan and implement globalization and localization

• Plan a localization strategy;
• Create and apply resources to UI including JavaScript resources;
• Set cultures and implement server-side localization and globalization
• Design and implement MVC controllers and actions
• Apply authorization attributes, filters (e.g., including global, authentication, and overridden filters);
• Use choose and implement custom HTTP status codes and responses;
• Implement action results;
• Implement MVC areas;
• Implement Dependency Injection for services in controllers;

Design and implement routes

• Define a route to handle a URL pattern;
• Apply route constraints; ignore URL patterns;
• Add custom route parameters and define areas;
• Define routes that interoperate with Single Page Application frameworks such as Angular

Control application behavior by using MVC extensibility points `

• Create custom middleware and inject it into the pipeline;
• Implement MVC filters and controller factories;
• Control application behavior by using action results, model binders, and route handlers;
• Inject services into a view

Design and implement serialization and model binding

• Serialize models and data using supported serialization formats, including JSON, XML, protobuf, and WCF/SOAP;
• Implement model and property binding, including custom binding and model validation;
• Implement web socket communication in MVC
• Implement file uploading and multipart data;
• Use AutoRest to build clients

Prevent and troubleshoot runtime issues

• Troubleshoot performance, security, and errors;
• Implement tracing, logging, and debugging (including IntelliTrace);
• Enable and configure health monitoring (including Performance Monitor));
• Configure and use App Insights runtime telemetry

Design an exception handling strategy

• Handle exceptions across multiple layers; use MVC middleware to configure error handling;
• Use different exception handling strategies for different environments;
• Create and display custom error pages;
• Configure a custom pipeline for error handling;
• Handle first chance exceptions;
• Configure and use App Insights;
• Log application exceptions;

Test a web application

• Create and run unit tests, for example, use the Assert class, create mocks and stubs;
• Create and run web tests including using Browser Link;
• Debug a web application in multiple browsers and mobile emulators;
• Use Azure DevTest Labs; use Visual Studio Team Services

Debug an Azure application

• Collect diagnostic information by using Azure App Insights;
• Choose log types, for example, event logs, performance counters, and crash dumps;
• Stream logs directly to Visual Studio from a deployed site;
• Debug an Azure application by using Visual Studio and remote debugging;
• Interact directly with remote Azure websites using Server Explorer

Configure authentication and Authenticate users

• Enforce authentication settings
• Implement ASP.NET Core Identity and enable Facebook, Google and other external providers;
• Implement account confirmation, password recovery, and multi-factor authentication.
• Perform authentication using Azure Active Directory, Azure Active Directory B2C, Azure Active Directory B2B, and Microsoft Identity manage user session by using cookies;
• Acquire access tokens using the Microsoft Authentication Library (MSAL)

Configure and apply authorization

• Create roles; authorize roles programmatically; configure and work with custom User Stores using middleware; configure controllers and actions to participate in authorization
• Design and implement claims-based authentication
• Perform authentication and authorization using tokens including OpenID, OAuth, JWT, SAML, bearer tokens, etc.

Manage data integrity

• Apply encryption to application data; apply encryption to the configuration sections of an application;
• Sign application data to prevent tampering; secure data using Azure Key Vault;
• Implement encryption for data protection using the data protection APIs in transit and at rest

Implement a Secure Site

• Secure communication by applying SSL certificates
• Require SSL for all requests;
• Enable SSL hosting in the development environment;
• Implement SSL using Azure Load Balancers; salt and hash passwords for storage;
• Use HTML encoding to prevent cross-site scripting attacks (ANTI-XSS Library);
• Implement deferred validation and handle unvalidated requests, for example, form, query string, and URL;
• Prevent SQL injection attacks by
• Parameterizing queries; prevent cross-site request forgeries (XSRF);
• Use Azure Security Center to monitor Azure resources;
• Implement Cross Origin Resource Sharing (CORS)
• Implement protection against open redirect attacks

Implement multithreading and asynchronous processing

• Use the Task Parallel library, including the Parallel. For method, PLINQ, Tasks; create continuation tasks; spawn threads by using Thread Pool; unblock the UI; use async and await keywords; manage data by using concurrent collections

Manage Multithreading

• Synchronize resources; implement locking; cancel a long-running task; implement thread-safe methods to handle race conditions

Implement program flow

• Iterate across collection and array items; program decisions by using switch statements, if/then, and operators; evaluate expressions,

Create and implement events and call-backs

• Create event handlers; subscribe to and unsubscribe from events; use built-in delegate types to create events; create delegates; lambda expressions; anonymous methods

Implement exception handling

• Handle exception types, including SQL exceptions, network exceptions, communication exceptions, network timeout exceptions; use catch statements; use base class of an exception; implement try-catch-finally blocks; throw exceptions; rethrow an exception; create custom exceptions; handle inner exceptions; handle aggregate exceptions

Create types

• Create value types, including structs and enum; create reference types, generic types, constructors, static variables, methods, classes, extension methods; create optional and named parameters; create indexed properties; create overloaded and overridden methods

Consume types

• Box or unbox to convert between value types; cast types; convert types; handle dynamic types; ensure interoperability with unmanaged code that accesses COM APIs

Enforce encapsulation

• Enforce encapsulation by using properties; enforce encapsulation by using accessors, including public, private, protected, and internal; enforce encapsulation by using explicit interface implementation

Create and implement a class hierarchy

• Design and implement an interface; inherit from a base class; create and implement classes based on the IComparable, IEnumerable, IDisposable, and IUnknown interfaces

Find, execute, and create types at runtime by using reflection

• Create and apply attributes; read attributes; generate code at runtime by using Code-Dom and lambda expressions; use types from the System. Reflection namespace, including Assembly, PropertyInfo, MethodInfo, Type

Manage the object life cycle

• Manage unmanaged resources; implement IDisposable, including interaction with finalization; manage IDisposable by using the Using statement; manage finalization and garbage collection

Manipulate strings

• Manipulate strings by using the StringBuilder, StringWriter, and StringReader classes; search strings; enumerate string methods; format strings; use string interpolation

Validate application input

• Validate JSON data; choose the appropriate data collection type; manage data integrity; evaluate a regular expression to validate the input format; use built-in functions to validate data type and content

Perform symmetric and asymmetric encryption

• Choose an appropriate encryption algorithm; manage and create certificates; implement key management; implement the System. Security namespace; hashing data; encrypt streams

Manage assemblies

• Version assemblies; sign assemblies using strong names; implement side-by-side hosting; put an assembly in the global assembly cache; create a Win MD assembly

Debug an application

• Create and manage pre-processor compiler directives; choose an appropriate build type; manage program database files and (debug symbols)

Implement diagnostics in an application

• Implement logging and tracing; profiling applications; create and monitor performance counters; write to the event logs.

Perform I/O operations

• Read and write files and streams; read and write from the network by using classes in the System.Net namespace; implement asynchronous I/O operations

Consume data

• Retrieve data from a database; update data in a database; consume JSON and XML data; retrieve data by using web services

Query and manipulate data and objects by using LINQ

• Query data by using operators, including projection, join, group, take, skip, aggregate; create method-based LINQ queries; query data by using query comprehension syntax; select data by using anonymous types; force execution of a query; read, filter, create, and modify data structures by using LINQ to XML.

Serialize and deserialize data

• Serialize and deserialize data by using binary serialization, custom serialization, XML Serializer, JSON Serializer, and Data Contract Serializer

Store data in and retrieve data from collections

• Store and retrieve data by using dictionaries, arrays, lists, sets, and queues; choose a collection type; initialize a collection; add and remove items from a collection; use typed vs. non-typed collections; implement custom collections; implement collection interfaces.