Diploma in DotNet

Course Information

It is used for:

.Net is a software framework of Microsoft. It primarily runs on Windows.
It is used by developers to develop new applications majorly for Windows platform. ASP.NET is a server side web application framework that is developed from initial .NET release. With ASP.NET developers can now efficiently produce dynamic web pages and applications and help in providing web services. This course can be taken by any individual who needs to achieve up surely an ASP.NET Web Developer or needs to learn MS.NET Framework. It runs mostly on Microsoft Windows. You will have able to manufacture programming for high and short organizations.
You have a package of profession progress in .Net.

Following professionals can go for it:

• Fresher’s
• IT Experts

 

.NET Professional Track

Part 1: Introducing C# and the .NET Platform
The Philosophy of .NET

• Understanding the Previous State of Affairs
• The .NET Solution
• Introducing the Building Blocks of the .NET Platform (the CLR, CTS, and CLS)
• Additional .NET-Aware Programming Languages
• An Overview of .NET Assemblies
• Understanding the Common Type System
• Understanding the Common Language Specification
• Understanding the Common Language Runtime
• The Assembly/Namespace/Type Distinction
• Exploring an Assembly Using ildasm.exe
• Exploring an Assembly Using Reflector
• Deploying the .NET Runtime
• The Platform-Independent Nature of .NET

Building C# Applications

• The Role of the .NET Framework 4.0 SDK
• Building C# Applications Using csc.exe
• Building .NET Applications Using Notepad++
• Building .NET Applications Using SharpDevelop
• Building .NET Applications Using Visual C# 2010 Express
• Building .NET Applications Using Visual Studio 2010

Part 2: Core C# Programming Constructs

Core C# Programming Constructs, Part I

• The Anatomy of a Simple C# Program
• An Interesting Aside: Some Additional Members of the System. Environment Class
• The System. Console Class
• System Data Types and C# Shorthand Notation
• Working with String Data
• Narrowing and Widening Data Type Conversions
• Understanding Implicitly Typed Local Variables
• C# Iteration Constructs
• Decision Constructs and the Relational/Equality Operators

Core C# Programming Constructs, Part II

• Methods and Parameter Modifiers
• Understanding C# Arrays
• Understanding the Enum Type
• Understanding the Structure Type
• Understanding Value Types and Reference Types
• Understanding C# Nullable Types
• Defining Encapsulated Class Types
• Introducing the C# Class Type
• Understanding Constructors
• The Role of the this Keyword
• Understanding the static Keyword
• Defining the Pillars of OOP

C# Access Modifiers

• The First Pillar: C#’s Encapsulation Services
• Understanding Automatic Properties
• Understanding Object Initializer Syntax
• Working with Constant Field Data
• Understanding Partial Types
• Understanding Inheritance and Polymorphism The Basic Mechanics of Inheritance
• Revising Visual Studio Class Diagrams
• The Second Pillar of OOP: The Details of Inheritance
• Programming for Containment/Delegation
• The Third Pillar of OOP: C#’s Polymorphic Support
• Understanding Base Class/Derived Class Casting Rules
• The Master Parent Class: System. Object
• Understanding Structured Exception Handling
• Ode to Errors, Bugs, and Exceptions

The Role of .NET Exception Handling

• The Simplest Possible Example
• Configuring the State of an Exception
• System-Level Exceptions (System. System Exception)
• Application-Level Exceptions (System. Application Exception)
• Processing Multiple Exceptions

The Result of Unhandled Exceptions
Debugging Unhandled Exceptions Using Visual Studio

Understanding Object Lifetime

• Classes, Objects, and References
• The Basics of Object Lifetime
• The Role of Application Roots
• Understanding Object Generations
• Building Finalizable Objects
• Building Disposable Objects
• Building Finalizable and Disposable Types
• Understanding Lazy Object Instantiation

Part 3: Advanced C# Programming Constructs

• Working with Interfaces
• Understanding Interface Types
• Defining Custom Interfaces
• Implementing an Interface
• Invoking Interface Members at the Object Level
• Interfaces As Parameters
• Interfaces As Return Values
• Arrays of Interface Types

Resolving name clashes via explicit interface implementation

• Designing Interface Hierarchies
• Understanding Generics
• The Issues with Non-Generic Collections
• The Role of Generic Type Parameters
• The System.Collections.Generic Namespace
• Creating Custom Generic Methods
• Creating Custom Generic Structures and Classes
• Constraining Type Parameters
• Delegates, Events, and Lambdas
• Understanding the .NET Delegate Type
• Defining a Delegate Type in C#
• Understanding Delegate Covariance
• Understanding Generic Delegates
• Understanding C# Events
• Understanding C# Anonymous Methods
• Understanding Lambda Expressions
• Advanced C# Language Features
• Understanding Indexer Methods
• Understanding Operator Overloading
• Understanding Custom Type Conversions
• Understanding Extension Methods
• Understanding Partial Methods
• Understanding Anonymous Types
• Working with Pointer Types

LINQ to Objects

• LINQ Specific Programming Constructs
• Understanding the Role of LINQ
• Applying LINQ Queries to Primitive Arrays
• Returning the Result of a LINQ Query
• Applying LINQ Queries to Collection Objects
• Investigating the C# LINQ Query Operators
• The Internal Representation of LINQ Query Statements

Programming with .NET Assemblies

• Configuring .NET Assemblies
• Defining Custom Namespaces
• The Role of .NET Assemblies
• Understanding the Format of a .NET Assembly
• Building and Consuming a Single-File Assembly
• Building and Consuming a Multifile Assembly
• Understanding Private Assemblies
• Understanding Shared Assemblies
• Consuming a Shared Assembly
• Configuring Shared Assemblies
• Understanding Publisher Policy Assemblies
• Understanding the Element
• The System.Configuration Namespace
• Dynamically Loading Assemblies
• Reflecting on Shared Assemblies
• Understanding Late Binding
• Understanding the Role of .NET Attributes
• Building Custom Attributes
• Assembly-Level (and Module-Level) Attributes

The Role of a Windows Process

• Interacting with Processes Under the .NET Platform
• Understanding .NET Application Domains
• Interacting with the Default Application Domain
• Creating New Application Domains
• Understanding Object Context Boundaries
• Summarizing Processes, AppDomains, and Context
• Understanding CIL and the Role of Dynamic Assemblies
• Reasons for Learning the Grammar of CIL
• Examining CIL Directives, Attributes, and Opcodes
• Pushing and Popping: The Stack-Based Nature of CIL
• Understanding Round-Trip Engineering
• Understanding CIL Directives and Attributes

.NET Base Class Library, C#, and CIL Data Type Mappings

• Defining Type Members in CIL
• Examining CIL Opcodes
• Building a .NET Assembly with CIL
• Understanding Dynamic Assemblies
• Dynamic Types and the Dynamic Language Runtime
• The Role of the C# dynamic Keyword
• The Role of the Dynamic Language Runtime (DLR)
• Simplifying Late Bound Calls Using Dynamic Types
• Simplifying COM Interoperability using Dynamic Data
• COM Interop using C# 4.0 Language Features

Introducing the .NET Base Class Libraries

• Multithreaded and Parallel Programming
• The Process/AppDomain/Context/Thread Relationship
• A Brief Review of the .NET Delegate
• The Asynchronous Nature of Delegates
• Invoking a Method Asynchronously
• The System.Threading Namespace
• The System.Threading.Thread Class
• Programmatically Creating Secondary Threads
• The Issue of Concurrency
• Programming with Timer Callbacks
• Understanding the CLR ThreadPool
• Parallel Programming under the .NET Platform
• Parallel LINQ Queries (PLINQ)

Summary

File I/O and Object Serialization

Web Application Life Cycle

Exploring the System.IO Namespace

The Directory(Info) and File(Info) Types

• Working with the DirectoryInfo Type
• Working with the Directory Type
• Working with the DriveInfo Class Type
• Working with the FileInfo Class
• Working with the File Type
• The Abstract Stream Class
• Working with StreamWriters and StreamReaders
• Working with StringWriters and StringReaders
• Working with BinaryWriters and BinaryReaders
• Watching Files Programmatically

Understanding Object Serialization

• Configuring Objects for Serialization
• Choosing a Serialization Formatter
• Serializing Objects Using the BinaryFormatter
• Serializing Objects Using the SoapFormatter
• Serializing Objects Using the XmlSerializer
• Serializing Collections of Objects
• Customizing the Soap/Binary Serialization Process

ADO.NET Part I: The Connected Layer

Creating a Simple Web Service and Client with JAX-RPC

• A High-Level Definition of ADO.NET
• Understanding ADO.NET Data Providers
• Additional ADO.NET Namespaces
• The Types of the System.Data Namespace
• Abstracting Data Providers Using Interfaces
• Creating the AutoLot Database
• The ADO.NET Data Provider Factory Model
• Understanding the Connected Layer of ADO.NET

ADO.NET Part III: The Entity Framework

• Understanding the Role of Entity Framework
• Building and Analyzing your First EDM
• Programming Against the Conceptual Model
• AutoLotDAL Version 4.0, Now with Entities
• Data Binding Entities to Windows Forms GUIs

Introducing LINQ to XML

• A Tale of Two XML APIs
• Members of the System.Xml.Linq Namespace
• Working with XElement and XDocument
• Manipulating an in Memory XML Document
• Introducing Windows Communication Foundation
• A Potpourri of Distributed Computing APIs

The Role of WCF

• Investigating the Core WCF Assemblies
• The Visual Studio WCF Project Templates
• The Basic Composition of a WCF Application
• The ABCs of WCF
• Building a WCF Service
• Hosting the WCF Service
• Building the WCF Client Application
• Simplifying Configuration Settings with WCF 4.0
• Using the WCF Service Library Project Template
• Hosting the WCF Service within a Windows Service
• Invoking a Service Asynchronously from the Client.
• Designing WCF Data Contracts
• Introducing Windows Workflow Foundation 4.0

Defining a Business Process

• Building a (Painfully) Simple Workflow
• The WF 4.0 Runtime
• Examining the Workflow 4.0 Activities
• Building a Flowchart Workflow
• Isolating Workflows into Dedicated Libraries
• Consuming the Workflow Library

Building Desktop User Interfaces with WPF

• Introducing Windows Presentation Foundation and XAML
• The Motivation Behind WPF
• The Various Flavors of WPF
• Investigating the WPF Assemblies
• Building a WPF Application without XAML
• Building a WPF Application using Only XAML
• Transforming Markup into a .NET Assembly
• Understanding The Syntax of WPF XAML
• Building a WPF Application using Code-Behind Files
• Building WPF Applications Using Visual Studio 2010

Programming with WPF Controls

• A Survey of the Core WPF Controls
• Controlling Content Layout Using Panels
• Building a Window’s Frame Using Nested Panels
• Understanding WPF Control Commands
• Building a WPF User Interface with Expression Blend
• Building the Ink API Tab
• Introducing the Documents API
• Building the Documents Tab
• Introducing the WPF Data-Binding Model
• WPF Graphics Rendering Services
• Understanding WPF’s Graphical Rendering Services
• Rendering Graphical Data Using Shapes
• WPF Brushes and Pens

Applying Graphical Transformations

• Working with Shapes using Expression Blend
• Rendering Graphical Data Using Drawings and Geometries
• Generating Complex Vector Graphics using Expression Design
• Rendering Graphical Data Using the Visual Layer
• WPF Resources, Animations, and Styles
• Understanding the WPF Resource System
• Working with Object (Logical) Resources
• Understanding WPF’s Animation Services
• Authoring Animations in XAML

Understanding the Role of WPF Styles

• Generating Styles with Expression Blend
• WPF Control Templates and UserControls
• Understanding the Role of Dependency Properties
• Building a Custom Dependency Property
• Understanding Routed Events
• Logical Trees, Visual Trees and Default Templates
• Building a Custom Control Template with Visual Studio 2010
• Building Custom UserControls with Blend
• Creating the Jackpot Deluxe WPF Application
• Part 7: Building Web Applications with ASP.NET
• Building ASP.NET Web Pages
• The Role of HTTP

Understanding Web Applications and Web Servers

The Role of HTML
The Role of Client-Side Scripting

• Posting Back to the Web Server
• The Feature Set of the ASP.NET API
• Building a Single File ASP.NET Web Page
• Building an ASP.NET Web Page using Code Files
• ASP.NET Web Sites and ASP.NET Web Applications
• The ASP.NET Web Site Directory Structure
• The Inheritance Chain of the Page Type
• Interacting with the Incoming HTTP Request
• Interacting with the Outgoing HTTP Response
• The Life Cycle of an ASP.NET Web Page
• The Role of the Web.config File

ASP.NET Web Controls, Master Pages and Themes

• Understanding the Nature of Web Controls
• The Control and WebControl Base Classes
• Major Categories of ASP.NET Web Controls
• Building the ASP.NET Cars Web Site
• The Role of the Validation Controls
• Working with Themes

ASP.NET State Management Techniques

• The Issue of State
• ASP.NET State Management Techniques
• Understanding the Role of ASP.NET View State
• The Role of the Global.asax File
• Understanding the Application/Session Distinction
• Working with the Application Cache
• Maintaining Session Data
• Understanding Cookies
• The Role of the Element
• Understanding the ASP.NET Profile API

Web Development

HTML & CSS Overview

Introduction

HTML

Basics

HTML

Elements

HTML Attributes

HTML Styles

HTML Forms

HTML Form

Elements

HTML Input Element Types

HTML Input Attributes

HTML File Paths

Script tag and its uses

HTML & XHTML

CSS Introduction

CSS Syntax

CSS Selectors

CSS Styling

Javascript Primer

Introduction to Javascript

Javascript Statements

Javascript Keywords

Javascript Functions

Javascript Programs

Javascript Operators

Function Parameters

Function Return Values

Javascript Data Types

Primitive Types

Working with Objects

Object Overview

Object Oriented Programming

Object creation

Adding Properties to Objects

Adding Methods to Objects

Javascript Conditional Statements

Javascript Loops & Iteration

Enumerating properties

Callbacks

JSON

Environmental setup

MVC Architecture

Model-View-Controller explained

Why MVC matters

MVC – the AngularJS way

First Application
Directives

Introduction to Directives

Directive lifecycle

Using AngularJS built-in directives

Binding controls to data

Matching directives

Creating a custom directive

Expressions
Controllers

Role of a Controller

Attaching properties and functions to scope

Nested Controllers

Using filters in Controllers

Controllers in External Files

Controllers & Modules

Filters

Built-in filters

Using AngularJS filters

Creating custom filters

Tables

HTML DOM

Modules

Introduction to AngularJS Modules Bootstrapping

Forms

Working with Angular Forms

Model binding

Form controller

Validating Angular Forms

Updating models with a twist

$error object

Form events

Scope

Scope lifecycle

Two way data binding

Scope inheritance

Scope & controllers

Scope & directives

$apply and $watch

Rootscope

Scope broadcasting

Dependency Injection & Services

What is Dependency Injection

Using Dependency Injection

What are services

Creating services

Factory, Service & Provider

Using AngularJS built in services

Single Page Application(SPA)

What is SPA

Pros & Cons of SPA

Installing the ngRoute module

Configure routes

Passing parameters

Changing location

Resolving promises

Create a Single Page Application

Angular-5

Getting Started

1. Course Introduction.
2. What is Angular?
3. Angular vs Angular 2 vs Angular 4+
4. Project Setup and First App.
5. Editing the First App.
6. The Course Structure.
7. What is TypeScript.
8. A Basic Project Setup using Bootstrap for Styling

The Basics
How an Angular App gets Loaded and Started Components
Components
Using Custom Components
Creating Components with the CLI & Nesting Components
Working with Component Templates
Working with Component Style

Assignment 1: Practicing Components
What is Databinding

• String Interpolation
• Property Binding
• Property Binding vs String Interpolation
• Event Binding
• Bindable Properties and Events
• Passing and Using Data with Event Binding
• Two-Way-Databinding
• Important: FormsModule is Required for Two-Way-Binding
• Combining all Forms of Databinding

Assignment 2: Practicing Databinding

• Understanding Directives
• Using ngIf to Output Data Conditionally
• Enhancing ngIf with an Else Condition.

Components & Databinding Deep Dive

• Splitting Apps into Components
• Property & Event Binding Overview
• Binding to Custom Properties
• Assigning an Alias to Custom Properties
• Binding to Custom Events
• Assigning an Alias to Custom Events
• Custom Property and Event Binding Summary
• Understanding View Encapsulation
• More on View Encapsulation
• Using Local References in Templates.
• Getting Access to the Template & DOM with @ViewChild.
• Understanding the Component Lifecycle

Lifecycle Hooks
Assignment 3: Practicing Property & Event Binding and View Encapsulation
Directives Deep Dive

• ngFor and ngIf ngClass and ngStyle
• How to create a Basic Directive
• Using Services & Dependency Injection Why would you Need Services?
• Creating a Logging Service
• Injecting the Logging Service into Components Creating a Data Service
• Understanding the Hierarchical Injector
• How many Instances of Service Should It Be? Injecting Services into
• Services
• Using Services for Cross-Component Communication

Assignment 4: Practicing Services
Changing Pages with Routing

• Why do we need a Router?
• Understanding the Example Project.
• Setting up and Loading Routes.
• Navigating with Router Links.
• Understanding Navigation Paths.
• Styling Active Router Links.

Navigating Programmatically

• Using Relative Paths in Programmatic Navigation Passing Parameters to Routes
• Fetching Route Parameters
• Fetching Route Parameters Reactively
• An Important Note about Route Observables Passing Query Parameters and Fragments Retrieving Query Parameters and Fragments Setting up Child (Nested) Routes
• Using Query Parameters – Practice Configuring the Handling of Query Parameters Redirecting and Wildcard Routes
• Important: Redirection Path Matching An Introduction to Guards
• Protecting Routes with canActivate
• Protecting Child (Nested) Routes with canActivateChild Using a Fake Auth Service

Controlling Navigation with canDeactivate

• Handling Forms in Angular Apps
• Template-Driven (TD) vs Reactive Approach
• TD Forms

Assignment 5: Practicing Template-Driven Forms

• Introduction to the Reactive Approach
• Reactive Forms

Assignment 6: Practicing Reactive Forms

• Using Pipes to Transform Output
• Introduction & Why Pipes are Useful Using Pipes
• Making Http Requests
• Introduction & How Http Requests Work in SPAs
• Sending Requests (Example: POST Request)
• Adjusting Request Headers
• Sending GET Requests Sending a PUT Request
• Transform Responses Easily with Observable Operators (map())
• Using the Returned Data
• Catching Http Errors
• Using the “async” Pipe with Http Requests.

Authentication & Route Protection in Angular Apps

• How Authentication Works in Single-Page-Applications
• Creating a Signup Page and Route
• Setting up the Firebase SDK Signing Users Up
• Signin Users In
• Requiring a Token (on the Backend) Sending the Token
• Checking and Using Authentication Status
• Adding a Logout Button
• Route Protection and Redirection. Wrap Up
• The HttpClient (ANGULAR 5 Addition Bonus SECTION)
• Request Configuration and Response.
• Requesting Events.
• Setting Headers.
• Interceptors.

SQL – Structure Query Language

• RDBMS – An Introduction Database
• Relational Database Systems
• Working with the Book’s Sample Database
• SQL: A Relational Database Language
• Normal Forms
• Entity-Relationship Model
• Syntax Conventions

Foundations of T-SQL

• A Short History of T-SQL
• Imperative vs. Declarative Languages
• SQL Basics
• Statements
• Databases
• Transaction Logs
• Schemas
• Tables
• Views
• Indexes
• Stored Procedures
• User-Defined Functions
• SQL CLR Assemblies
• Elements of Style
• Whitespace
• Naming Conventions
• One Entry, One Exit
• Defensive Coding
• SQL-92 Syntax Outer Joins
• The SELECT * Statement
• Variable Initialization

Procedural Code and CASE Expressions

• Three-Valued Logic
• Control-of-Flow Statements
• The BEGIN and END Keywords
• The IF…ELSE Statement
• The WHILE, BREAK, and CONTINUE Statements
• The GOTO Statement
• The WAITFOR Statement
• The RETURN Statement
• The TRY…CATCH Statement
• The CASE Expression
• The Simple CASE Expression
• The Searched CASE Expression
• CASE and Pivot Tables
• COALESCE and NULLIF
• Cursors

User-Defined Functions

• Scalar Functions
• Recursion in Scalar User-Defined Functions
• Procedural Code in User-Defined Functions
• Multistatement Table-Valued Functions
• Inline Table-Valued Functions
• Restrictions on User-Defined Functions
• Nondeterministic Functions
• State of the Database

Stored Procedures

• Introducing Stored Procedures
• Calling Stored Procedures
• Managing Stored Procedures
• Stored Procedures in Action
• Recursion in Stored Procedures
• Table-Valued Parameters
• Temporary Stored Procedures
• Recompilation and Caching
• Stored Procedure Statistics
• Parameter Sniffing
• Recompilation

Triggers

• DML Triggers
• When to Use DML Triggers
• Auditing with DML Triggers
• Nested and Recursive Triggers
• The UPDATE and COLUMNS_UPDATED Functions
• Triggers on Views
• DDL Triggers
• Logon Triggers

Common Table Expressions and Windowing Functions

• Common Table Expressions
• Multiple Common Table Expressions
• Recursive Common Table Expressions
• Windowing Functions
• The ROW_NUMBER Function
• The RANK and DENSE_RANK Functions
• The NTILE Function
• Aggregate Functions and OVER

XML

• Legacy XML
• OPENXML
• OPENXML Result Formats
• FOR XML Clause
• FOR XML RAW
• FOR XML AUTO
• FOR XML EXPLICIT
• FOR XML PATH
• The xml Data Type
• Untyped xml
• Typed xml
• The xml Data Type Methods
• The query Method
• The value Method
• The exist Method
• The nodes Method
• The modify Method
• XML Indexes
• XSL Transformations

XQuery and XPath

• XPath and FOR XML PATH
• XPath Attributes
• Columns Without Names and Wildcards
• Element Grouping
• The data Function
• XPath and NULL
• The WITH XMLNAMESPACES Clause
• Node Tests
• XQuery and the xml Data Type
• Expressions and Sequences
• The query Method
• Location Paths
• Node Tests
• Namespaces
• Axis Specifiers
• Dynamic XML Construction
• XQuery Comments
• Data Types
• Predicates
• Conditional Expressions (if…then…else)
• Arithmetic Expressions
• XQuery Functions
• Constructors and Casting
• FLWOR Expressions

Catalog Views and Dynamic Management Views

• Catalog Views
• Table and Column Metadata
• Index Metadata
• Querying Permissions
• Dynamic Management Views and Functions
• Session Information
• Connection Information
• Currently Executing SQL
• Tempdb Space
• Server Resources
• Unused Indexes
• INFORMATION_SCHEMA Views

SQL CLR Programming

• The Old Way
• The SQL CLR Way
• SQL CLR Assemblies
• User-Defined Functions
• Stored Procedures
• User-Defined Aggregates
• Creating a Simple UDA
• Creating an Advanced UDA
• SQL CLR User-Defined Types

New T-SQL Features

• Set Operators
• The OUTPUT Clause
• The TOP Keyword
• CROSS APPLY and OUTER APPLY
• The TABLESAMPLE Clause
• The NEWSEQUENTIALID Function
• Date and Time Functions
• The max Data Types
• Synonyms
• FILESTREAM Support
• Enabling FILESTREAM Support
• Creating FILESTREAM Filegroups
• FILESTREAM-Enabling Tables
• Accessing FILESTREAM Data

Error Handling and Dynamic SQL

• Error Handling
• Legacy Error Handling
• Try…Catch Exception Handling
• The RAISERROR Statement
• Debugging Tools
• PRINT Statement Debugging
• Trace Flags
• SSMS Integrated Debugger
• Visual Studio T-SQL Debugger
• Dynamic SQL
• The EXECUTE Statement
• SQL Injection and Dynamic SQL
• Troubleshooting Dynamic SQL
• The sp_executesql Stored Procedure
• Dynamic SQL and Scope
• Client-Side Parameterization

Performance Tuning

• SQL Server Storage
• Files and Filegroups
• Space Allocation
• Data Compression
• Indexes
• Heaps
• Clustered Indexes
• Nonclustered Indexes
• Filtered Indexes
• Optimizing Queries
• Reading Query Plans
• Methodology

Software Testing

Duration: 12 hrs.

Software Development Life Cycle :

• What are the different phases of SDLC?
• How does the process of Software Development Start?
• Project Initiation

Requirement Gathering and Analysis

• What is Requirement document and what it contains?
• What is use case document and what it contains?
• What is Basic path and Alternate Path?
• Role of Business Analyst
• Example for explaining each phase
• Role of technical specification team
• What is Technical specification document?

What is System Design?

• Role of Design team
• What is design document?
• Role of architecture team

System development

• Role of development team
• Deliverable of Development phase

System testing

• Role of testers and types of testing
• User acceptance testing
• System deployment

System maintenance

• Events in the maintenance phase like bug fixes

Software Testing Life Cycle

• How are the phases of STLC carried out?
• What is testing?
• Role of testers
• Why do we need to test?
• Activities involved in the testing phase

What is test plan and test case document?

• Steps of test case execution
• What does test case document contain?
• How to write test case document?
• What is required to test any application?

TEST CASES

• What is test case?
• What does test case document contain?
• How to write test case document?
• Different test case techniques

TEST PLAN

• What is Test Plan?
• How to write test plan document?
• What does the test plan document contain?
• Who writes and approves the test plan document?
• How manage the test case documents?
• What is the pass/fail criterion?

TYPES OF TESTING

• Different Phases of testing
• What is unit testing?
• What is Minimum acceptance testing?
• What is integration, system and system integration testing?
• What is User acceptance testing?
• What is Regression Testing?

DEFECT ANALYSIS

• What is a defect?
• Various Defect tracking tools
• How to use the defect tracking tools?
• How to enter the details of defect in the defect tracking tool?
• How to identify a defect?
• What is severity and priority?

TRACEABILITY MATRIX

• What is Traceability Matrix[TM]?
• Who Prepares the TM document?
• What is the reference for writing TM?
• What is the use of TM?
• What is present in the TM document?
• Sample TM
• Tools used for developing TM

Contact Us for any queries related to online dotnet development certification course and training in Kharghar, Navi Mumbai.