Saturday, 24 December 2016

Caching is a most important aspect of high-performance web application. Caching provides a way of storing frequently accessed data and reusing that data. Practically, this is an effective way for improving web application’s performance.

Output Cache can dramatically improve the performance of an ASP.NET MVC application. The output cache enables you to cache the content returned by a controller action. That way, the same content does not need to be generated each and every time the same controller action is invoked.

The OutputCache filter allow you to cache the data that is output of an action method. By default, this attribute filter cache the data till 60 seconds. After 60 sec, if a call was made to this action then ASP.NET MVC will cache the output again.

Enabling Output Caching

You enable output caching by adding an [OutputCache] attribute to either an individual controller action or an entire controller class as below.

Output Caching Location
By default, content is cached in three locations: the web server, any proxy servers, and the user's browser. You can control the content's cached location by changing the location parameter of the OutputCache attribute to any of the following values:

Any (Default): Content is cached in three locations: the web server, any proxy servers, and the web browser.

Client: Content is cached on the web browser.

Server: Content is cached on the web server.

ServerAndClient: Content is cached on the web server and and the web browser.

Varying the Output CacheIn some situations, you might want different cached versions of the very same content, So for that we use "VaryByParam" as in above code.In case we have multiple action methods across controllers needing the same caching behavior, we can put this caching values in the web.config and create a cacheprofile for it.

4. Create separate class Inheriting from 'ErrorHandleAttribute'.
In this way we can use code re-usability concept across all controller. we create separate class that inherit from 'ErrorHandleAttribute' class and then we use this 'Errorclass' as an Attribute for Actions in controllers.

.NET Core - .NET Core is a general purpose, modular, cross-platform and open source implementation of the .NET Platform. It contains many of the same APIs as the .NET Framework (but .NET Core is a smaller set) and includes run-time, framework, compiler and tools components that support a variety of operating systems and chip targets. The .NET Core implementation was primarily driven by the ASP.NET Core workloads but also by the need and desire to have a more modern run-time. It can be used in device, cloud and embedded/IoT scenarios.

.NET Core has following main characteristics.1. Cross-Plateform - .NET Core provides key functionality to implement the app features you need and reuse this code regardless of your platform target.2. Open Source - Having .NET Core as an open source project promotes a more transparent development process and is available on GitHub.3. Flexible Deployment - there are two main ways to deploy your app: framework-dependent deployment or self-contained deployment. With framework-dependent deployment, only your app and third-party dependencies are installed and your app depends on a system-wide version of .NET Core to be present. With self-contained deployment, the .NET Core version used to build your application is also deployed along with your app and third-party dependencies and can run side-by-side with other versions. For more information, see .NET Core Application Deployment.4. Modular - Modular means collection of small modules so .NET Core is modular because it is released through NuGet in smaller assembly packages. Rather than one large assembly that contains most of the core functionality, .NET Core is made available as smaller feature-centric packages. This enables a more agile development model for us and allows you to optimize your app to include just the NuGet packages you need. The benefits of a smaller app surface area include tighter security, reduced servicing, improved performance, and decreased costs in a pay-for-what-you-use model.5. Compatible - .NET Core is compatible with .NET Framework, Xamarin and Mono, via the .NET Standard Library.For More refer DotNet Core.NET Core

Monday, 12 December 2016

There are many methods in AngularJs some of them are give below.$watch - Registers a listener callback to be executed whenever the watchExpression changes.The watchExpression is called on every call to $digest() and should return the value that will be watched. (watchExpressionshould not change its value when executed multiple times with the same input because it may be executed multiple times by $digest().The listener is called only when the value from the current watchExpression and the previous call to watchExpression are not equal. example -

$watchgroup - A variant of $watch() where it watches an array of watchExpressions. If any one expression in the collection changes the listener is executed.$apply - $apply() is used to execute an expression in angular from outside of the angular framework. (For example from browser DOM events, setTimeout, XHR or third party libraries). Because we are calling into the angular framework we need to perform proper scope life cycle of exception handling, executing watches.

Any exceptions from the execution of the expression are forwarded to the $exceptionHandler service.

The watch listeners are fired immediately after the expression was executed using the $digest() method.

$digest - Processes all of thewatchersof the current scope and its children. Because awatcher's listener can change the model, the$digest()keeps calling thewatchersuntil no more listeners are firing. This means that it is possible to get into an infinite loop. This function will throw'Maximum iteration limit exceeded.'if the number of iterations exceeds 10.

var scope =...;
scope.name ='misko';
scope.counter =0;
expect(scope.counter).toEqual(0);
scope.$watch('name',function(newValue, oldValue){
scope.counter = scope.counter +1;});
expect(scope.counter).toEqual(0);
scope.$digest();// the listener is always called during the first $digest loop after it was registered
expect(scope.counter).toEqual(1);
scope.$digest();// but now it will not be called unless the value changes
expect(scope.counter).toEqual(1);
scope.name ='adam';
scope.$digest();
expect(scope.counter).toEqual(2);

$destroy - Removes the current scope (and all of its children) from the parent scope. Removal implies that calls to $digest() will no longer propagate to the current scope and its children. Removal also implies that the current scope is eligible for garbage collection.

The $destroy() is usually used by directives such as ngRepeat for managing the unrolling of the loop.

$eval -Executes the expression on the current scope and returns the result. Any exceptions in the expression are propagated (uncaught). This is useful when evaluating Angular expressions.