Diploma in DotNet

dotnet development course in kharghar

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


Eligibility: Technical graduate having fundamental knowledge of any programming languages like C, C++, Java, HTML. JavaScript will be benefited but not mandatory. Anybody structured like Oracle, SQL Server, and MySQL. We will provide a foundational and basics that are required.

Lecture Duration: 6 months

Placement: 100% Placement Assistance

Job Profile: Dotnet developer

Placement: 100% Placement Assistance

.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)


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

HTML Attributes
HTML Styles
HTML Forms
HTML Input Element Types 
HTML Input Attributes
HTML File Paths
Script tag and its uses 
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
Environmental setup
MVC Architecture
Model-View-Controller explained 
Why MVC matters
MVC – the AngularJS way
First Application
Introduction to Directives 
Directive lifecycle
Using AngularJS built-in directives 
Binding controls to data 
Matching directives
Creating a custom directive 
Role of a Controller
Attaching properties and functions to scope 
Nested Controllers
Using filters in Controllers 
Controllers in External Files 
Controllers & Modules
Built-in filters
Using AngularJS filters 
Creating custom filters 
Introduction to AngularJS Modules Bootstrapping
Working with Angular Forms 
Model binding
Form controller  
Validating Angular Forms
Updating models with a twist
$error object
Form events
Scope lifecycle
Two way data binding 
Scope inheritance 
Scope & controllers 
Scope & directives
$apply and $watch 
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


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


  • 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


  • Legacy XML
  • OPENXML Result Formats
  • FOR XML Clause
  • 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
  • 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

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
  • The TABLESAMPLE Clause
  • 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?


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


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


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


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


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

Contact Us

Our Top Recruiters