...

+91 78994 89468 | 78994 89384

Dotnet Training in BTM, Marathahalli, Bangalore & Best Dotnet Training Institutes in Bangalore

About Dotnet Training

Techie Zone is a leader in Providing Dotnet Training Courses located in Marathalli, Bangalore based on real-time scenarios and placement oriented topics. Our Dotnet training course covers basic to advanced levels. Our team consists of highly qualified and certified trainers who are working professionals with hands on real time Dotnet projects knowledge. This  which will provide you an edge over other training institutes.

We provide certification training programs in Dotnet Training. We have successfully trained and provided placement for many of our students in major MNC Companies, after successful completion of the course. We provide placement support for our students. Our Dotnet training center is well equipped with lab facilities and excellent infrastructure for providing you real time training experience.

Techie Zone provides regular training classes(day time classes), weekend training classes, and fast track training classes for Dotnet Training in our Training Centers located in Marathahalli , Bangalore. Students can Enroll and start attending classes as well as practice sessions in the labs without effecting their regular college or office work. We also provide Online Training Classes for Dotnet Training Course.

Our team of experts at Techie Zone Training Institute, Bangalore have designed our Dotnet Training course content and syllabus based on students requirements to achieve everyone's career goal.  Our Dotnet Training course fee is economical and tailor-made based on training requirement.

 Contact us today to schedule a free demo and complete course details on Dotnet Training Course.


Dotnet Training Course Content

Dotnet Course Content:

The .NET Framework

What is the .NET Framework?

Common Language Runtime

.NET Framework Class Library

Assemblies and the Microsoft Intermediate Language (MSIL)

Versions of the .NET Framework and Visual Studio

               Getting Started with Visual Studio

Visual Studio Overview

Choosing the Development Settings

Resetting the Development Settings

Creating a New Project

Components of the IDE

Code and Text Editor

Code Snippets

IntelliSense

Refactoring Support

Debugging

Setting Breakpoints

Stepping through the Code

Watching

Autos and Immediate Windows

Unit Testing

Creating the Test

Running the Test

Testing with Floating Point Numbers

Adding Additional Test Methods

               C# Language Foundations

Using the C# Compiler (csc.exe)

Passing Arguments to Main()

Language Syntax

Keywords

Variables

Scope of Variables

Constants

Comments

Data Types

Value Types

Reference Types

Enumerations

Implicit Typing

Type Conversion

Operators

Arithmetic Operators

Logical Operators

Relational Operators

Increment & Decrement Operators

Bit Shift Operators

Assignment Operators

The is and as Operators

Other Operators

Operator Precedence

Flow Control

if-else Statement

switch Statement

Looping

for Loop

foreach

while and do-while Loops

Exiting from a Loop

Skipping an Iteration

Structs

What Are Structs?

Structs Are Value Types

Assigning to a Struct

Constructors and Destructors

Instance Constructors

Static Constructors

Summary of Constructors and Destructors

Field Initializers Are Not Allowed

Structs Are Sealed

Boxing and Unboxing

Structs as Return Values and Parameters

               Arrays

Single Dimensional Arrays

Accessing Array Elements

Multidimensional Arrays

Arrays of Arrays: Jagged Arrays

Parameter Arrays

Copying Arrays

               Strings and Regular Expressions

The System.String Class

Escape Characters

String Manipulations

String Formatting

The StringBuilder Class

Regular Expressions

Searching for a Match

More Complex Pattern Matching

               OOPs Concepts

Classes

Defining a Class

Creating an Instance of a Class (Object Instantiation)

Class Members

Access Modifiers

Function Members

Overloading Methods

Overloading Operators

Using Partial Classes

Static Classes

System.Object Class

Implementing Equals

ToString() Method

Attributes

Inheritance

Understanding Inheritance

Implementation Inheritance

Inheritance and Constructors

Calling Base Class Constructors

Virtual Methods (Polymorphism)

Sealed Classes and Methods

Abstract Class

Abstract Methods

Interfaces

Defining an Interface

Implementing an Interface

Implementing Multiple Interfaces

Interface Inheritance

Overriding Interface Implementations

               Collections Interfaces

Dynamic Arrays Using the ArrayList Class

Stacks

Queues

Dictionary

Indexers and Iterators

Implementing IEnumerable and IEnumerator

Implementing Comparison Using IComparer and IComparable

               Delegates and Events

Delegates

Creating a Delegate

Delegates Chaining (Multicast Delegates)

Implementing Callbacks Using Delegates

Asynchronous Callbacks

Events

Handling Events

Implementing Events

Difference between Events and Delegates

Passing State Information to an Event Handler

               Generics

Understanding Generics

Generic Classes

Using the default Keyword in Generics

Advantages of Generics

Using Constraints in a Generic Type

Generic Interfaces

Generic Methods

Generic Operators

Generic Delegates

Generics and the .NET Framework Class Library

System.Collections.ObjectModel

               Exception Handling

Handling Exceptions

Handling Exceptions Using the try-catch Statement

Handling Multiple Exceptions

Throwing Exceptions Using the throw Statement

Using Exception Objects

The finally Statement

Creating Custom Exceptions

               Threading

Processes, AppDomains, and Object Contexts

Reviewing Traditional Win32 Processes

Interacting with Processes Under the .NET Platform

Understanding .NET Application Domains

Understanding Object Context Boundaries

Threading

The Need for Multithreading

Starting a Thread

Aborting a Thread

Passing Parameters to Threads

Thread Synchronization

Using Interlocked Class

Using C# Lock

Monitor Class

Using the BackgroundWorker Control

Testing the Application

               Files and Streams

Working with Files and Directories

Working with Directories

Working with Files Using the File and FileInfo Classes

Creating a FileExplorer

The Stream Class

BufferedStream

The FileStream Class

MemoryStream

               Working with XML

Introduction to XML

Markup

The Document Type Declaration (DTD)

Encoding Declaration

Writing XML Code using Code Editor

XML Syntax

XML Reading & Writing

Text Writer Fundamentals

Text Reader Fundamentals

XMLDocument

Serialization

Binary Serialization

XML Serialization

               Assemblies and Versioning

Assemblies

Structure of an Assembly

Examining the Content of an Assembly

Single and Multi-File Assemblies

Understanding Namespaces and Assemblies

Private versus Shared Assemblies

Creating a Shared Assembly

The Global Assembly Cache

Putting the Shared Assembly into GAC

Making the Shared Assembly Visible in Visual Studio

Using the Shared Assembly

               Type Reflection, Late Binding, and Attribute-Based

Programming

The Necessity of Type Metadata

Understanding Reflection

Understanding Late Binding

Building a Custom Metadata Viewer

Dynamically Loading Assemblies

Reflecting on Shared Assemblies

Understanding Attributed

Assembly-Level (and Module-Level) Attributes

Reflecting on Attributes Using Early Binding

Reflecting on Attributes Using Late Binding

Putting Reflection, Late Binding, and Custom Attributes in Perspective

               ADO.NET

ADO .NET Introduction

ADO vs. ADO .NET

ADO .NET Architecture

Connecting to Data Sources

Choosing a .Net Data Provider

Defining a Connection

Managing a Connection

Handling Connection Exceptions

Connection Pooling

Performing Connected Database Operations

Working in a Connected Environment

Building Command Objects

Executing the Commands

Data Reader Object

Using Transactions

Perfoming Dis-Connected Database Operations

Configuring a DataAdapter to Retrieve Information

Populating a DataSet Using a DataAdapter

Modifying Data in a DataTable

Persisting Changes to a Data Source

Working in a Disconnected Environment

Building Datasets and DataTables

Binding and Saving a Dataset

Defining Data Relationships

Reading and Writing XML with ADO.NET

Creating XSD Schemas

Loading Schemas and Data into DataSets

Writing XML from a DataSet

               ASP.NET

ASP.NET Introduction

The Evolution of Web Development

HTML and HTML Forms

Server-Side Programming

Client-Side Programming

Facts about ASP .NET

ASP .NET different versions

Developing ASP.NET Applications

Creating Websites

Creating a New Web Application

Websites and Web Projects

The Hidden Solution Files

The Solution Explorer

Adding Web Forms

Migrating a Website from a Previous Version of Visual Studio

Designing a Web Page

Adding Web Controls

The Properties Window

The Anatomy of a Web Form

The Web Form Markup

The Page Directive

The Doctype

Writing Code

The Code-Behind Class

Adding Event Handlers

IntelliSense and Outlining

Visual Studio Debugging

The Visual Studio Web Server

Single-Step Debugging

Variable Watches

               Creating N-Tier Applications

Multi-Tier Architectures

Creating an N-Tier ASP.NET Application

The Data Tier

The Middle Tier

The Presentation Tier

Managing Concurrency

               Web Form Fundamentals

The Anatomy of an ASP.NET Application

ASP.NET File Types

ASP.NET Application Directories

Introducing Server Controls

HTML Server Controls

Converting an HTML Page to an ASP.NET Page

A Deeper Look at HTML Control Classes

HTML Control Events

Advanced Events with the HtmlInputImage Control

The HtmlControl Base Class

The HtmlContainerControl Class

The HtmlInputControl Class

The Page Class

Sending the User to a New Page

HTML Encoding

Application Events

The Global.asax File

Additional Application Events

ASP.NET Configuration

The web.config File

Nested Configuration

Storing Custom Settings in the web.config File

The Website Administration Tool (WAT)

               Web Controls

Stepping Up Web Controls

Basic Web Control Classes

The Web Control Tags

Web Control Classes

The WebControl Base Class

Units

Enumerations

Colors

Fonts

Focus

The Default Button

List Controls

Multiple-Select List Controls

The BulletedList Control

Table Controls

Web Control Events and AutoPostBack

How Postback Events Work

The Page Life Cycle

A Simple Web Page

Improving the Greeting Card Generator

Generating the Cards Automatically

               Validation

Understanding Validation

The Validator Controls

Server-Side Validation

Client-Side Validation

The Validation Controls

A Simple Validation Example

Other Display Options

Manual Validation

Validating with Regular Expressions

A Validated Customer Form

Validation Groups

               The Data Controls

The GridView

Automatically Generating Columns

Defining Columns

Formatting the GridView

Formatting Fields

Using Styles

Formatting-Specific Values

Selecting a GridView Row

Adding a Select Button

Editing with the GridView

Sorting and Paging the GridView

Sorting

Paging

Using GridView Templates

Using Multiple Templates

Editing Templates in Visual Studio

Handling Events in a Template

Editing with a Template

The DetailsView and FormView

The DetailsView

The FormView

               Rich Controls

The Calendar

Formatting the Calendar

Restricting Dates

The AdRotator

The Advertisement File

The AdRotator Class

Pages with Multiple Views

The MultiView Control

The Wizard Control

               Files and Streams

Files and Web Applications

File System Information

The Path Class

A Sample File Browser

Reading and Writing with Streams

Text Files

Binary Files

Shortcuts for Reading and Writing Files

A Simple Guest Book

Allowing File Uploads

The FileUpload Control

               State Management

The Problem of State

View State

The ViewState Collection

A View State Example

Making View State Secure

Retaining Member Variables

Storing Custom Objects

Transferring Information between Pages

Cross-Page Posting

The Query String

Cookies

A Cookie Example

Session State

Session Tracking

Using Session State

A Session State Example

Session State Configuration

Cookieless

Timeout

Mode

Application State

An Overview of State Management Choices

               Error Handling, Logging, and Tracing

Common Errors

Exception Handling

The Exception Class

The Exception Chain

Handling Exceptions

Catching Specific Exceptions

Nested Exception Handlers

Exception Handling in Action

Mastering Exceptions

Throwing Your Own Exceptions

Logging Exceptions

Viewing the Windows Event Logs

Writing to the Event Log

Custom Logs

A Custom Logging Class

Retrieving Log Information

Error Pages

Error Modes

Custom Error Pages

Page Tracing

Enabling Tracing

Tracing Information

Writing Trace Information

Application-Level Tracing

               Deploying ASP.NET Applications

ASP.NET Applications and the Web Server

How Web Servers Work

The Virtual Directory

Web Application URLs

Web Farms

Internet Information Services (IIS)

The Many Faces of IIS

Installing IIS 5 (in Windows XP)

Installing IIS 7 (in Windows Vista)

Registering the ASP.NET File Mappings

Verifying That ASP.NET Is Correctly Installed

Managing Websites with IIS Manager

Creating a Virtual Directory

Configuring a Virtual Directory

Deploying a Simple Site

Web Applications and Components

Other Configuration Steps

Code Compilation

The ASP.NET Account

Deploying with Visual Studio

Creating a Virtual Directory for a New Project

Copying a Website

Publishing a Website

               User Controls and Graphics

User Controls

Creating a Simple User Control

Independent User Controls

Integrated User Controls

User Control Events

Passing Information with Events

Dynamic Graphics

Basic Drawing

Drawing a Custom Image

Placing Custom Images Inside Web Pages

Image Format and Quality

               Caching

Understanding Caching

When to Use Caching

Caching in ASP.NET

Output Caching

Caching on the Client Side

Caching and the Query String

Caching with Specific Query String Parameters

A Multiple Caching Example

Custom Caching Control

Fragment Caching

Cache Profiles

Data Caching

Adding Items to the Cache

A Simple Cache Test

Caching to Provide Multiple Views

               Styles, Themes, and Master Pages

Styles

Style Types

Creating a Basic Inline Style

Creating a Style Sheet

Applying Style Sheet Rules

Themes

How Themes Work

Applying a Simple Theme

Handling Theme Conflicts

Creating Multiple Skins for the Same Control

More Advanced Skins

Master Page Basics

A Simple Master Page and Content Page

How Master Pages and Content Pages Are Connected

A Master Page with Multiple Content Regions

Default Content

Master Pages and Relative Paths

Advanced Master Pages

Table-Based Layouts

Code in a Master Page

Interacting with a Master Page Programmatically

               Website Navigation

Site Maps

Defining a Site Map

Seeing a Simple Site Map in Action

Binding an Ordinary Page to a Site Map

Binding a Master Page to a Site Map

Binding Portions of a Site Map

The SiteMap Class

Mapping URLs

The SiteMapPath Control

Customizing the SiteMapPath

Using SiteMapPath Styles and Templates

Adding Custom Site Map Information

The TreeView Control

TreeView Properties

TreeView Styles

The Menu Control

Menu Styles

Menu Templates

               Creating and Using Web Services

Understanding the Web Service Model

Creating an ASP.NET Web Service

WSDL and Web Service Clients

Creating & Consuming Web Services with Visual Studio .NET

               Security Fundamentals

Determining Security Requirements

The ASP.NET Security Model

The Visual Studio Web Server

Authentication and Authorization

Forms Authentication

Web.config Settings

Authorization Rules

The WAT

The Login Page

Windows Authentication

Web.config Settings

IIS Settings

A Windows Authentication Test

Impersonation

Understanding Impersonation

Programmatic Impersonation

Confidentiality with SSL

Creating a Certificate Request

Secure Sockets Layer

               Membership

The Membership Data Store

Membership with SQL Server

Using the Full Version of SQL Server

Configuring the Membership Provider

Creating Users with the WAT

The Membership and MembershipUser Classes

Authentication with Membership

Disabled Accounts

The Security Controls

The Login Control

The CreateUserWizard Control

The PasswordRecovery Control

Role-Based Security

Creating and Assigning Roles

Restricting Access Based on Roles

The LoginView Control

               Profiles

Understanding Profiles

Profile Performance

How Profiles Store Data

Using the SqlProfileProvider

Enabling Authentication

Using the Full Version of SQL Server

The Profile Databases

Defining Profile Properties

Using Profile Properties

Profile Serialization

Profile Groups

Profiles and Custom Data Types

The Profile API

Anonymous Profiles

               ASP.NET AJAX

Understanding Ajax

Ajax: The Good

Ajax: The Bad

The ASP.NET AJAX Toolkit.

The ScriptManager

Partial Refreshes

A Simple UpdatePanel Test

Handling Errors

Conditional Updates

Triggers

Progress Notification

Showing a Simulated Progress Bar

Cancellation

Timed Refreshes

The ASP.NET AJAX Control Toolkit

Installing the ASP.NET AJAX Control Toolkit

               .NET Version 4.0

Implicitly Typed Local Variables and Arrays

Object Initializers

Collection Initializers

Extension Methods

Anonymous Types

Lambda Expressions

Query Keywords

Auto-Implemented Properties

Language-Integrated Query (LINQ)

dynamic data type

Named Parameters

               Windows Communication Foundation

WCF Essentials

WCF Overview

SOA Overview

WCF architecture

Essential WCF concepts:

Addresses

Contracts

Bindings

Endpoints

Hosting

Clients

Contracts

Designing and working with service contracts

Contract overloading and inheritance

Data Contracts

Serialization

Attributes

Versioning

Collections & Generics

Instance Management & Operation

Behaviors

Per-Call Services

Per-Session Services

Singleton Service

Demarcating Operations

Instance Deactivation

Throttling

Operations

Request-Reply

One-Way

Callback

Events

Streaming

Faults

Errors and exceptions

Fault Contracts

Error handling Extensions

Transactions

Transaction Propagation

Protocols and Managers

The Transaction Class

Declarative Programming

Explicit Transaction Programming

With Instance management

Callbacks

Security

Authentication & Authorization

Transfer Security

Scenario-Driven Approach

Concurrency Management

Service Concurrency Mode

Instance Management and Concurrency

Deadlocked Avoidance

Synchronization Context

Callbacks

               Project

A project using .NET programming has to be developed by participant as a mandatory requirement of this course.

              

 



Reviews for Dotnet Training Course

No Reviews for this Course Yet.. Be the First to Review?

Interview Questions

 

1. Describe what an Interface is and how it’s different from a Class. When would you want to use an abstract class and interface?

2. Why would anyone need to implement their own hashtable or linked list?

3. Can you prevent your class from being inherited by another class? How?

4. When do you absolutely have to declare a class as abstract?

5. Can static constructors use optional arguments?

6. What is Reflection?

7. What is the difference between XML Web Services using ASMX and .NET Remoting using SOAP?

8. Name design patterns and principles you know and how they are utilized in .NET Framework?

9. What is boxing and unboxing? What are the performance implications?

10. What is shadowing and overriding, when do you prefer to use one over the other?

11. What are the 3 approaches to handling exceptions in a Web application?

12. How can error events be used to handle exceptions?

13. How many catch statements can be associated with single try statement?

14. What is Marshalling?

15. How to create a shared assembly or add an assembly to GAC?

16. How was XML handled during COM times?

17. Can you explain why your project needed XML?

18. How does the XmlSerializer work? What ACL permissions does a process using it require?

19. What is the significance of the “PropertySpecified” pattern used by the XmlSerializer? What problem does it attempt to solve?

20. How is the using() pattern useful? What is IDisposable? How does it support deterministic finalization?

21. How do short-circuited operators work?

22. How do you read in configuration settings from the application config file?

23. Why Session states works on some web servers but not on others?

 

24. How the execution process takes place for the managed code?

25. How does windows service lifecycle differ from a “standard” EXE?

26. How is the development of a Windows service different from a Windows Forms application?

27. How do you give a Windows service specific permissions?

28. If I’m developing an application that must accommodate multiple security levels through a secure login and my ASP.NET web application is spanned across three web-servers (using round-robin load balancing) what would be the best approach to maintain login-in state for the users?

29. Explain the Event Lifecycle of ASP.net 2.0?

30. How do you secure connection strings in ASP.net?

31. Are the standard library generic collection classes thread safe?

32. What’s an extension method?

33. What’s the difference between XmlDocument and XmlReader?

34. How do you read in configuration settings from the application config file?

35. Which of the ASP: whatever controls would you ever use in production and why?

36. How does an App domain get created?

37. When would using Assembly.LoadFrom or Assembly.LoadFile be appropriate?

38. What is an Assembly Qualified Name? Is it a filename? How is it different?

39. What is Inversion of Control? How does that relate to dependency injection?

40. How does a 3 tier application differ from a 2 tier one?

41. What are some alternate ways to store data other than a relational database? Why would you do that, and what are the trade-offs?

42. What’s the difference between a web server, web farm, and web garden? How would your web application need to change for each?

43. What do you think is good about .NET?

44. What do you think is bad about .NET?

You can also ask some open-ended questions to gauge the knowledge, passion and interest of the candidate:

45. What is something substantive that you’ve done to improve as a developer in your career?

46. Show me a portfolio of all the applications you worked on, and tell me how you contributed to design them.

47. You’ve just been assigned to a project in a new technology how would you get started?

48. What value do daily builds, automated testing, and peer reviews add to a project? What disadvantages are there?

49. What elements of OO design are most prone to abuse? How would you mitigate that?

50. When do you know your code is ready for production?

51. Describe to me some bad code you’ve read or inherited lately.

ASP.NET MVC Interview Questions List

 

Explain MVC (Model-View-Controller) in general?

What is ASP.NET MVC?

Difference between ASP.NET MVC and ASP.NET WebForms?

What are the Core features of ASP.NET MVC?

Can you please explain the request flow in ASP.NET MVC framework?

What is Routing in ASP.NET MVC?

What is the difference between ViewData, ViewBag and TempData?

What are Action Methods in ASP.NET MVC?

Explain the role of Model in ASP.NET MVC?

What are Action Filters in ASP.NET MVC?

More Interview Questions….

 

What are the new features introduced in ASP.NET MVC5?

What is a ViewEngine in ASP.NET MVC?

What is the difference between Razor View Engine and ASPX View Engine?

What is a ViewModel in ASP.NET MVC?

What are ASP.NET MVC HtmlHelpers?

What is Bootstrap in MVC5?

Kindly explain Attribute Routing in ASP.NET MVC5?

What is Scaffolding in ASP.NET MVC? and what are the advantages of using it?

Briefly explain ASP.NET Identity?

Quick Contact