MCSA Microsoft Certified Solutions Associate-Web Applications

MCSA_Course 20480/Exam 70-480: Programming in HTML5 with JavaScript and CSS3

• Implement and Manipulate Document Structures and Objects 
• Implement Program Flow 
• Access and Secure Data 
• Use CSS3 in Applications 

MCSA_Course 20483/Exam 70-483: Programming in C#

• Manage Program Flow 
• Create and Use Types 
• Debug Applications and Implement Security 
• Implement Data Access 

MCSA_Course 20486/Exam 70-486: Developing ASP.NET MVC Web Applications

• Design the application architecture 
• Design the build and deployment architecture
• Design the User Experience
• Develop the User Experience 
• Troubleshoot and Debug Web Applications
• Design and Implement Security 

MCSA_Course 20486: Developing ASP.NET MVC Web Applications

 Design the application architecture

• Plan the application layers

·        Plan data access; plan for separation of concerns, appropriate use of models, views, controllers, 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

• 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 sessionless state including query strings; configure middleware to enable session and application state in ASP.NET Core

• Design a caching strategy

·        Implement page output caching and 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 SignalR; 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 the build and deployment architecture

• 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 xmlDoc 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

Design the User Experience

• 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 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 polyfills

• Plan mobile UI strategy

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

Develop the User Experience

• 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; implement server side localization and globalization

• Design and implement MVC controllers and actions

·        Apply authorization attributes, filters including global, authentication, and overriddable filters; 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; 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

Troubleshoot and Debug Web Applications

• 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

Design and Implement Security

• Configure authentication

·        Authenticate users; enforce authentication settings; implement ASP.NET Core Identity; 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 UserStores 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, querystring, 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

MCSA_Course 20480: Programming in HTML5 with JavaScript and CSS3

 Implement and Manipulate Document Structures and Objects

• Create the document structure by using HTML

·        Structure the UI by using semantic markup, including markup for search engines and screen readers, such as Section, Article, Nav, Header, Footer, and Aside; create a layout container in HTML

• Write code that interacts with UI controls

·        Programmatically add and modify HTML elements; implement media controls; implement HTML5 canvas and SVG graphics

• Apply styling to HTML elements programmatically

·        Change the location of an element; apply a transform; show and hide elements

• Implement HTML5 APIs

·        Implement storage APIs and the Geolocation API

• Establish the scope of objects and variables

·        Define the lifetime of variables; keep objects out of the global namespace; use the “this” keyword to reference an object that fired an event; scope variables locally and globally

• Create and implement objects and methods

·        Implement native objects; create custom objects and custom properties for native objects using prototypes and functions; inherit from an object; implement native methods and create custom methods

Implement Program Flow

• Implement program flow

·        Iterate across collections and array items; manage program decisions by using switch statements, if/then, and operators; evaluate expressions

• Raise and handle an event

·        Handle common events exposed by DOM (OnBlur, OnFocus, OnClick); declare and handle bubbled events; handle an event by using an anonymous function

• Implement exception handling

·        Set and respond to error codes; throw an exception; request for null checks; implement try-catch-finally blocks

• Implement asynchronous programming

·        Receive messages from the HTML5 WebSocket API; use JQuery to make an AJAX call; wire up an event; implement a callback by using anonymous functions; handle the “this” pointer

• Create a web worker process

·        Start and stop a web worker; pass data to a web worker; configure timeouts and intervals on the web worker; register an event listener for the web worker; limitations of a web worker

Access and Secure Data

• Validate user input by using HTML5 elements

·        Choose the appropriate controls based on requirements; implement HTML input types and content attributes to collect user input

• Validate user input by using JavaScript

·        Evaluate a regular expression to validate the input format; validate that you are getting the right kind of data type by using built-in functions; prevent code injection

• Consume data

·        Consume JSON and XML data; retrieve data by using web services; load data or get data from other sources by using XMLHTTPRequest

• Serialize, deserialize, and transmit data

·        Handle binary data; handle text data such as JSON and XML; implement the JQuery serialize method; use Form.Submit; parse data; send data by using XMLHTTPRequest; sanitize input by using URI/form encoding

Use CSS3 in Applications

• Style HTML text properties

·        Apply styles to text appearance; apply styles to text font, including WOFF, @font-face, size, and understudy fonts; apply styles to text alignment, spacing, and indentation; apply styles to text hyphenation; apply styles for a text drop shadow

• Style HTML box properties

·        Apply styles to alter appearance attributes, including size, borders, rounded corners, outline, padding, and margin; apply styles to alter graphic effects, including transparency, opacity, background image, gradients, shadow, and clipping; apply styles to establish and change an element’s position

• Create a flexible content layout

·        Implement a layout using a flexible box model; implement a multi-column layout; implement a layout using position floating and exclusions; implement a layout using grid alignment; implement a layout using regions, grouping, and nesting

• Create an animated and adaptive UI

·        Animate objects by applying CSS transitions; apply 3-D and 2-D transformations; adjust UI based on media queries, including device adaptations for output formats, displays, and representations; hide or disable controls

• Find elements by using CSS selectors and JQuery

·        Choose the correct selector to reference an element; define element, style, and attribute selectors; find elements by using pseudo-elements and pseudo-classes

• Structure a CSS file by using CSS selectors

·        Reference elements correctly; implement inheritance; override inheritance by using !important; style an element based on pseudo-elements and pseudo-classes

MCSA_Course 20483: Programming in C#

Manage Program Flow

• Implement multithreading and asynchronous processing

·        Use the Task Parallel library, including theParallel.For method, PLINQ, Tasks;create continuation tasks; spawn threads by using ThreadPool; 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 callbacks

·        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-catchfinally blocks; throw exceptions; rethrow an exception; create custom exceptions; handle inner exceptions; handle aggregate exception

Create and Use Types

• 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 overriden methods

• Consume types

·        Box or unbox to convert between value types; cast types; convert types; handle dynamic types; ensure interoperability with 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 CodeDom 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

Debug Applications and Implement Security

• 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; hash 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 WinMD assembly

• Debug an application

·        Create and manage preprocessor directives; choose an appropriate build type; manage program database files (debug symbols)

• Implement diagnostics in an application

·        Implement logging and tracing; profiling applications; create and monitor performance counters; write to the event log

Implement Data Access

• 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 methodbased 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