I have 4+ experience and working as software Engineer with Hytech professionals India PVT ltd and also working as Consultant,Trainer,Blogger and Author on Microsoft technologies,Also I have Trained more than 500+ IT professionals.I have knowledge about Asp.net,C#,SQL,Project management,replication,MVC,WebApi,SSRS,PostMan,TFS,SVN,Swagger,WMI,Agile,SignalR,Angularjs,IIS configuration.
Thursday, 20 July 2017

What is Difference Between Angular 2 And Angular 4 ?

In this blog i am going to explain "what is difference between angular 2 and 4",What new features added in angular 4.
Angular 4 contains some additional features over Angular 2.
  • Smaller & Faster Apps
  • View Engine Size Reduce
  • Animation Package
  • NgIf and ngFor Improvement
  • Template
  • NgIf with Else
  • Use of AS keyword
  • Pipes
  • HTTP Request Simplified
  • Apps Testing Simplified
  • Introduce Meta Tags
  • Added some Forms Validators Attributes
  • Added Compare Select Options
  • Enhancement in Router
  • Added Optional Parameter
  • Improvement Internationalization
Smaller & Faster Apps 

Angular 4 application is smaller and faster in comparison to Angular 2.
View Engine Size Reduced 
There are some changes under the hood to AOT generated code compilation that means Angular 4, hasimproved the compilation time. These changes reduce around 60% of the size in most cases.
Animation Package
Animations now have their own package i.e. @angular/platform-browser/animations
Improvement 

Some Improvement on *ngIf and *ngFor.
Stayed Informed
Template 

The template is now ng-template. You should use the “ng-template” tag instead of “template”. Now Angular has its own template tag that is called “ng-template”.
NgIf with Else 

Now in Angular 4, it's possible to use an else syntax as,
  1. <div *ngIf="user.length > 0; else empty"><h2>Users</h2></div>  
  2. <ng-template #empty><h2>No users.</h2></ng-template>  
AS keyword 

A new addition to the template syntax is the “as keyword” which is used to simplify the “let” syntax.
  1. <div *ngFor="let user of users | slice:0:2 as total; index as = i"> {{i+1}}/{{total.length}}: {{user.name}} </div>  
To subscribe only once to a pipe “|” with “async” and if a user is observable, you can now use it to write
Pipes 

Angular 4 introduced a new “titlecase” pipe “|” and uses it  to change the first letter of each word into uppercase.
The example is,
  1. <h2>{{ 'anil singh' | titlecase }}</h2>  
Http 

Adding search parameters to an “HTTP request” has been simplified as,
  1. //Angular 4 -  
  2. http.get(`${baseUrl}/api/users`, {  
  3.     params: {  
  4.         sort: 'ascending'  
  5.     }  
  6. });  
  7. //Angular 2-  
  8. const params = new URLSearchParams();  
  9. params.append('sort''ascending');  
  10. http.get(`${baseUrl}/api/users`, {  
  11.     search: params  
  12. });  
Test
In Angular 4, overriding a template in a test has also been simplified as,
  1. //Angular 4 -  
  2. TestBed.overrideTemplate(UsersComponent, '<h2>{{users.name}}</h2>');  
  3. //Angular 2 -  
  4. TestBed.overrideComponent(UsersComponent, {  
  5.     set: {  
  6.         template: '<h2>{{users.name}}</h2>'  
  7.     }  
  8. });  
Service
A new service has been introduced to easily get or update “Meta Tags” i.e.
  1. @Component({  
  2.     selector: 'users-app',  
  3.     template: `<h1>Users</h1>`  
  4. })  
  5. export class UsersAppComponent {  
  6.     constructor(meta: Meta) {  
  7.         meta.addTag({  
  8.             name: 'Blogger',  
  9.             content: 'Anil Singh'  
  10.         });  
  11.     }  
  12. }  
Forms Validators 

One new validator joins the existing “required”, “minLength”, “maxLength” and “pattern”. An email helps you validate that the input is a valid email.
Compare Select Options 

A new “compareWith” directive has been added and it used to help you compare options from a selection.
  1. <select [compareWith]="byUId" [(ngModel)]="selectedUsers">  
  2.     <option *ngFor="let user of users" [ngValue]="user.UId">{{user.name}}</option>  
  3. </select>  
Router 

A new interface “paramMap” and “queryParamMap” has been added and it was introduced to represent the parameters of a URL.
  1. const uid = this.route.snapshot.paramMap.get('UId');  
  2. this.userService.get(uid).subscribe(user => this.name = name);  
CanDeactivate 

This “CanDeactivate” interface now has an extra (optional) parameter and it contains the next state.
I18n 
The internationalization is a tiny improvement.

  1. //Angular 4-  
  2. <div [ngPlural]="value">  
  3.     <ng-template ngPluralCase="0">there is nothing</ng-template>  
  4.     <ng-template ngPluralCase="1">there is one</ng-template>  
  5. </div>  
  6.    
  7. //Angular 2-  
  8. <div [ngPlural]="value">  
  9.     <ng-template ngPluralCase="=0">there is nothing</ng-template>  
  10.     <ng-template ngPluralCase="=1">there is one</ng-template>  
  11. </div>  
Bikesh Srivastava AngularJs 2, Interview Question
Sunday, 16 July 2017

ASP.NET,C# Syllabus day and hour wise.

 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<T> and IEnumerator<T>
  • Implementing Comparison Using IComparer<T> and IComparable<T>

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
  • 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
Bikesh Srivastava Syllabus

ASP.NET WEB API Syllabus day and hour wise.

 Using the ASP.NET Web API

  • Overview of the ASP.NET Web API 
  • Building servers and clients 
  • Content negotiation 
  • Validation 
  • Queryable interfaces 
  • Dependency Injection 
  • Session Management 
  • Securing a Web API 
  • OData
Bikesh Srivastava Syllabus
Saturday, 15 July 2017

Angular Syllabus day and hour wise.

 TypeScript

  • Basic Types 
  • Variable Declarations 
  • Classes 
  • Functions 
  • Interfaces 
  • Generics 
  • Enums 
  • Type Inference 
  • Namespaces 
  • Modules 
  • Mixins 
  • Iterators and Generators 
  • TypeScript 2.X Features 

 Angular 2 

  • Introduction to Angular 2 
  • Angular 2 Architecture 
  • Setup installation 
  • Building Blocks of Angular2 Application 
  • Modules 
  • Components 
  • Templates 
  • Views 
  • Directives 
  • Dependency Injection 
  • Services 
  • Validation of Angular Form 
  • Single Page Application and Routing 
  • Asynchronous Calls 
  • Pipes 
  • Security 
  • Internationalization 
  • WebPack 
  • Deployment and Project Configurations 
Bikesh Srivastava Syllabus

Life Is Complicated, But Now programmer Can Keep It Simple.