Wednesday, May 4, 2016

Tuesday, February 2, 2016

Sri Lankan IT Industry Statistics and Trends

It is said that fourth largest exporter of services in Sri Lanka is the IT industry. But is it getting the place it deserves? Here's a quick look at GDP of few countries and How much Information Technology Industry earns for the respective countries. 

 Sri Lanka GDP (2013) - $67.18 billion
Sri Lanka IT industry (2015) - $700 - $800 million

 India GDP (2013) $1877 billion
India IT industry (2015) $147 billion (source)

 USA GDP (2013) $16770 billion
USA IT industry (2011) $646 billion (source)

Sources
http://www.slasscom.lk/why-sri-lanka
http://www.slasscom.lk/sites/default/files/Sri%20Lankan%20IT-BPM%20Industry%20Review%202014.pdf

Saturday, July 18, 2015

ASP.NET MVC Controller Actions

MVC Actions usually returns instance of a class which derives from ActionResult. But you can return any type of object from MVC action even objects. These return types are wrapped in appropriate ActionResult type before they are rendered in response stream.


There are few tricky things you need to understand when dealing with HTTP methods and Controller actions. The most basic form of returning a result from controller action is like below,


The return type Json above is just an extension method which returns JsonResult. There is no difference between returning Json and JsonResult. 

The above ReturnJSON() and GetAction() actions cannot be called via. a GET request. You'll get the following 500 internal server error.


You can read more about that here and here. But you can use HTTP methods like POST or PUSH to successfully call the ReturnJSON action. But since GetAction() is decorated with HttpGet attribute you can't call it using POST. If you try you'll get 404 not found error. 


You can get GET request work when you do like below. Not only GET, this allows you to do POST, PUT requests as well. 

You can do the following only to allow GET requests or POST requests.

Resources
https://msdn.microsoft.com/en-us/library/dd410269(v=vs.100).aspx

Saturday, May 9, 2015

Application Pools in IIS

Application pool is a way to manage multiple web applications under IIS server. App pools allows you to isolate applications with different security controls from one another. It helps you to manage your applications separately. 


IIS Worker Process
Is a Windows process (w3wp.exe) which runs web applications. It is responsible for handling requests for a specific application pool. App pool can contain more than one worker process. This is known as web farm or web garden. Read here

Application Pool Recycling
To make the application running smooth without memory leaks you need  to recycle the application pool. Any code which failed to implement IDisposable would run finalizers which will release resources.


Identity

Application Pool Settings (General)
  • .NET CLR Version
    • This should correspond to appropriate version of .NET framework version of your application
  • Managed Pipeline Mode
  • Queue Length
    • Max No. of requests HTTP.sys will queue for the app pool. When queue is full you'll get 503 "Service Unavailable" error
  • Start Mode : OnDemand or Always Running. See (SimpleTalk - Speeding up your application with Auto-Start feature)

Resources

Friday, May 1, 2015

LINQ in Entity Framework

To retrieve lists from database you can use IEnumerbale<T> or IQueryable<T> interfaces. IQueryable allows you to do LINQ-to-SQL while IEnumerable<T> is LINQ-to-Objects. Both gives you the opportunity to do deferred execution. (Read this article for more).

In IEnumerable all objects matching the original query will be loaded to the memory from database. 

Above first and last LINQ statements will generate first SQL query while second LINQ expression will generate the second query below,

LINQ First and FirstOrDefault


LINQ Single and SingleOrDefault


LINQ Any
Note that Count will iterate all the records in the table while Any will stop at first record it finds. (source)

LINQ Count and LongCount



The difference between Count and Count_Big is latter returns bigint while count returns int. See more details on data types.

LINQ Contains


















Group by

Saturday, February 7, 2015

Introduction to ReactJS


React is a JavaScript library developed by Facebook. ReactJS focuses on,
  • UI : Use React as the V in MVC
  • Virtual DOM : DOM diff implementation for high performance
  • Data flow : Offers reactive data flow
React is all about building reusable components. (Why Facebook built react). It doesn't manipulate DOM unless it needs to (check react displaying data example). It uses a fast, internal mock DOM to perform diffs and computes the most efficient DOM mutation for you. React components can only render a single root node. If you want to return multiple nodes they must be wrapped in a single root. Why React's Virtual DOM concept is more efficient than dirty model checking. Also check how Virtual DOM and diffing works in React.

Why use Reactjs


Here's a simple hello world example. Here, React.createClass will create a Component. (Read more)

var App = React.createClass({
            render: function () {
                return React.DOM.h1(null, "Hi there");
            }
        });
React.render(App(), document.body);

JSX

React believes components are the right way to separate concerns rather than using templates. JSX enables you to create JavaScript objects using HTML syntax.

const element = <h1>Hello, world!</h1>;

JSX is similar to HTML, but not exactly the same. See JSX Gotchas and JSX in depth. You don't have to use JSX with React. You can just use plain JS. However, we recommend using JSX because it is a concise and familiar syntax for defining tree structures with attributes.

 JSX elements gets converted to react elements with Babel. Same as what you create using React.createElement method. Therefore you can only have single root tag for a JSX statement.

 React can either render HTML tags (strings) or React components (classes). React JSX transforms from an XML-like syntax into native JavaScript. 

Components and Props

Components let you split the UI into independent, reusable pieces, and think about each piece in isolation.

Conceptually, components are like JavaScript functions. They accept arbitrary inputs (called “props”) and return React elements describing what should appear on the screen.

Loading Ajax data using JQuery

In Load Initial Data via AJAX example, you can see how to load data from ajax call and show them in the browser. We use JQuery here to make things easier. Typical error you'll get when implementing is mountNode is not defined error.

React integration with C# and ASP.NET MVC

You can use ReactJS.NET to integrate your .NET application easily. Take a look at this sample tutorial.



What is Flux

Architecture Facebook uses internally when working with react. It is now recommended to use Redux over Flux

https://scotch.io/tutorials/getting-to-know-flux-the-react-js-architecture
http://facebook.github.io/flux/docs/overview.html
http://facebook.github.io/flux/
https://www.youtube.com/watch?list=PLb0IAmt7-GS188xDYE-u1ShQmFFGbrk0v&t=621&v=nYkdrAPrdcw


Why use Redux

Redux has many benefits. Simply Redux is a state management tool. It is a very lightweight library which can be used with many JavaScript frameworks. 

Simply Redux keeps state of your application in a store. Each component can access any state that is needed from the store. So why use Redux? As React is based on components, these needs to communicate with each other. Redux helps you by keeping it in a central location. 

Redux has three building parts: actions, store and reducers.
  • Actions are events: They are the only way you can send data from your application to your Redux store. The data can be from user interactions, API calls or even form submission.
  • Reducers: Reducers are pure functions that take the current state of an application, perform an action and returns a new state.
  • Store: The store holds the application state. There is only one store in any Redux application.

Monday, December 29, 2014

C# - Classes and Structs

Classes and structs encapsulates set of data and behaviors into a logical unit. A class is a reference type while struct is of value type. When a struct is assigned to a new variable it is copied. Struct is like a light-weight class. (Read)
Note: the new operator is used to create and invoke objects. The new operator doesn't mean it is a reference type. It says the type has a constructor. All value and reference types has constructors at least the default one. (SO).

 int i = new int(); equals to
int A = new int(); or int A = default(int);

Encapsulation defines how accessible the members of the classes are to the outside of the class. Class can have fields, constants, properties, methods, constructors, destructors, events, indexers, operators as well as nested types. (See Class members article)

 When defining a struct if you're adding a parameterized constructor, you must initialize all fields in that (Source). Also it is not a good practice to use mutable structs. See examples of mutable structs. 

Inheritance : Classes support inheritance. A class can derive from another class (base class). Structs does not support inheritance because it is of value type. Classes can be declared as abstract meaning, one or more methods have no implementation. Classes and structs can inherit multiple interfaces. 
See : Why structs cannot be inherited, Why structs needs to be boxed, 

Generic Types : Classes and structs can be defined with one or more type parameters.

Static types : Classes can be declared as static while structs cannot. A static class can only contain static members and cannot be instantiated with new keyword. Both classes and structs can contain static members

Nested types : class and struct can be nested within another class or struct. (See Nested Types - MSDN)

Partial classes : You can also define a class in two files using partial. 

Object initializers : You can instantiate class or struct object without explicitly calling the constructor.  (MSDN)

Anonymous types : When it is not necessary to create named classes, you can use anonymous types. (See Anonymous Types in C# Programming guide)

 var msg = new { Id = 108, Message = "Hello" };

 Anonymous types are typically used in select clause of query expressions (LINQ). Anonymous type can contain  one or more public read-only fields. It cannot contain anything else (such as methods, event handlers etc.). 

Extension methods : You can extend a class without creating a derived class by creating separate types using extension methods.

Implicitly typed local variables : You can use these variables to instruct the compiler to determine correct type at runtime. (See implicitly typed local variables)


Resources
https://roslyn.codeplex.com/discussions/568824
http://programmers.stackexchange.com/questions/92339/when-do-you-use-a-struct-instead-of-a-class

Wednesday, October 8, 2014

Saturday, September 27, 2014

Overview of OWIN and Project Katana

owin and katana
Image credit : MSDN


Historically ASP.NET architecture (System.Web.dll) was coupled to a specific web hosting option IIS. To separate this, ASP.NET MVC was released as an independent download.

 Then Microsoft built ASP.NET Web API such that it had no dependencies on any of the core framework types found in System.Web.dll. therefore it had no dependency on IIS and could be run in a custom host (console application, windows service etc. )

 OWIN (Open Web Interface for .NET)
OWIN decouples the coupling between web server and the application. Inspired by the benefits achieved by Rack  in the Ruby community. OWIN has two core components. OWIN is not an implementation, it is just a specification. 

Environment dictionary
  • This data structure is responsible for storing all of the state necessary for processing an HTTP request and response. 
  • An OWIN-compatible Web server is responsible for populating the environment dictionary 
  • It is then the responsibility of the application or framework components to populate or update the dictionary with additional values
  • OWIN specification defines a list of core dictionary key value pairs
Application delegate
  • Is a function signature which serves as the primary interface between all components in an OWIN application
  • Function accepts the environment dictionary as input and returns a Task
  • The asynchronous design enables the abstraction to be efficient
Katana
Katana cloud optimizes your ASP.NET applications. The Katana project represents the set of OWIN components that, while still open source, are built and released by Microsoft.



Resources

Understanding Deferred in JQuery

Simplest example of ajax request in JQuery.

        $.ajax('http://ip.jsontest.com/', {
            success: function (result) {
                console.log('success');
            },
            error: function (err) {
                console.log('error');
            }
        });

Result of success callback function will have 3 parameters, which are "Anything (any type of) data, String textStatus, jqXHR jqXHR".


You can check the state of jqXHR object using jqXHR().state(), If you check with beforeSend event, you can see the state is pending before request is sent. Sometimes you'll get “No 'Access-Control-Allow-Origin' header is present on the requested resource” error.

$.ajax also returns jqXHR object. You can assign multiple callbacks to this.

        var a = $.ajax({
            url: 'http://jsonplaceholder.typicode.com/posts/1',
            success: function (data) {
                console.log(data);
            },
            error: function (data) {
                console.log(data);
            }
        });

        a.done(function (result) {
            console.log('done : ' + result);
        });

        a.then(function (result) {
            console.log('then : ' + result);
        });

        a.error(function (result) {
            console.log('error : ' + result);
        });

here after sending the ajax request, the object immediately returns and other callbacks are attached. Still the ajax state is pending, If success callback get hits, state becomes resolved and then callbacks are called.

If it hits error state is rejected. done or then callbacks won'get called but error callback will get called. then() can also have failCallback attached like below,

        a.then(function (result) {
            console.log('then : ' + result);
        }, errorCallback);

        function errorCallback(err) {
            console.log(err);
        }

If you specify this, errorCallback will get called if an error occurs.

jQuery.when()
accepts one or more objects and provide a way to execute callback functions. Usually deferred. If single Deferred is passed, its Promise is returned.

            function ajaxCall() {
                return $.ajax({
                    url: 'http://jsonplaceholder.typicode.com/posts/1',
                })
                .done(function (data) {
                    console.log(data);
                })
                .fail(function (data) {
                    console.log(data);
                })
            }

            function function2() {
                debugger;
            }

            var a = $.when(ajaxCall());
            a.then(function2);

If a single argument is passed to $.when which is not a Deferred or a promise, It'll be treated as resolved and attached callbacks will be called. Above if you don't return anything from ajaxCall(), a will be resolved and function2 will be executed without waiting for ajaxCall to be finished. Since your Deferred never gets rejected, fail callbacks are never get called. If Deferred resolved with no value, callbacks will get undefined value.

If you return ajax, a will be at pending state until ajaxCall() is finished and then only function2 gets executed.

deferred.then()
Add handlers to be called when deferred object is resolved, rejected or pending.

If we expand on the example above, here you can attach fallCallbacks as well.

            function failPath() {
                debugger;
            }

            var a = $.when(ajaxCall());
            a.then(happyPath, failPath);

deferred.done()
Handlers to be called when deferred object is resolved

        var defer = $.Deferred();
        defer.done(function (val) {
            console.log(val);
        });

        defer.then(function (val) {
            console.log(val);
        }, function (val) {
            console.log(val);
        });

if defer.resolve()
done callback and then's done callback will be called

if defer.reject()
done callback won't get called. then's fail callback will get called.

You can check active Ajax requests using $.active function. See this. 


Thursday, August 21, 2014

Abstract in C#

In this article, we'll look at what abstract in C# is. Also we'll look at 
when and how you can use it to get its benefits.


In C# abstract modifier indicates that the thing being modified has a missing or incomplete implementation. This modifier can be used with classes, methods, properties, indexers and events. 

Abstract classes can contain both abstract and non-abstract members. Abstract member cannot exist outside an abstract class. You can instantiate abstract class by making a concrete class deriving from it (An instance of a derived class is also a instance of its base class). 

 Also you can't create abstract constructor because abstract means you must override it in any non-abstract child class. But you can have non-abstract constructors. You can't override a constructor. You can't create sealed abstract classes. 

You cannot have non-abstract method signature inside abstract class. For non-abstract methods you must provide implementation (link). You cannot have private virtual or abstract members inside a abstract class. But You can have non-abstract private methods inside abstract classes.



Saturday, August 2, 2014

Execution Context Best Practices in JavaScript


In this article we'll see what this means, and places where this is applicable. 
We'll also look at how to manipulate this with built-in functions like 
apply, call and bind.

Every JavaScript statement is executed in one execution context or the other. In it's simplest terms this refers to the "owner"  of  the function we currently executing. this helps us to get the object or the execution context we are currently working with.

 In the above example both func1 and func2 returns this. because f1 was called (executed) inside the window (or global context) func1 returns window. In f2 we are using strict mode. In strict mode, this will be whatever it's set to when entering the execution context. Since we have not defined this, it will remain undefined. We can set that to any value we want. Even null. 

Saturday, July 26, 2014

Hidden Secrets of Interfaces in .NET C#

Interface contains definitions for a group of related functionalties that a class or a struct can implement. Interface in C# is similar to an abstract class in which all methods are abstract (Why C# interface methods not declared as abstract). 

 Interface can contain methods, properties, events, indexers but it can't contain constants, fields (why interface can't have fields), operators, instance constructors or types. Interface members are automatically public and cannot be static. (interfaces in MSDN)

When a class or struct implements an interface, it must provide an implementation for all the members that interface defines. If you implement an interface method in a deriving class it must be public. When a base list contains base class and interfaces, base class must come first in the list. 

 Methods in interfaces can have optional parameters. But they are not enforced in implementing classes. 

 Any class or struct that implements IEquatable<T> interface must contain definition for an Equals method. Also note that Reference types doesn't benefit much when using IEquatable.

Importance of an interface
Covered in SO, SO, Here 

An interface can inherit from one or more base interfaces. See Composition over Inheritance.

Explicit interface implementation 

Problem : Class implements 2 interfaces has a member with same signature
Solution : Explicit interface implementation



Friday, July 25, 2014

How to Asynchronous Programming in C#

async and await are the main keywords in asynchronous programming. You can use asynchronous with things such as downloads, uploads etc.


Below example shows you how to get a specific Http Header asynchronously.

  • Name of async method by convention ends with async. 
  • Return type is one of the following,
    • Task<TResult>
    • Task
    • void
  • Method has at least one await expression
Resources

https://msdn.microsoft.com/en-us/library/hh191443.aspx

Wednesday, July 9, 2014

Covariance and Contravariance in Generics

Covariance

Enables you to use more specific type than the type originally specified.

IEnumerable<Derived> d = new List<Derived>();
IEnumerable<Base> b = d;

Contravariance

Enables you to use more generic type than the type originally specified.

Action<Base> b = (target) => { Console.WriteLine(target.GetType().Name); };
Action<Derived> d = b;
d(new Derived());
Examples from MSDN.




Resources


https://msdn.microsoft.com/en-us/library/ee207183.aspx






http://stackoverflow.com/questions/2662369/covariance-and-contravariance-real-world-example





















            

          

          

        

Tuesday, July 8, 2014


          

        









Introduction to Entity Framework












Entity Framework (EF) is an object-relational mapper (ORM) for .NET. Entity Framework can be used to work with relational data using domain-specific objects. Entity Framework eliminates need for data access code that programmers usually need to write. The codes you write with Entity Framework will be converted to SQL queries. 



You can view them using ((System.Data.Objects.ObjectQuery)result).ToTraceString(); 

ObjectQuery class is the base class for queries against a conceptual model. There's also the ObjectQuery<T> generic class. 



Architecture of Entity Framework











Above diagram shows the high-level architecture of the Entity Framework. Conceptual model contains model classes and there relationshps this is independent from the actual tables in the database. For details of other components in the above diagram see this.



You can also check Entity Framework Overview available in MSDN.  





Workflows





In Entity Framework there are 3 workflows developers can use to start with. They are Model First, Database First and Code first. All of these has its own pros and cons so understanding the differences correctly is important.





Model First





Using Model First approach developers can create the Database model using ORM designer in Visual Studio. Here the designer relies on the .edmx file designer to maintain the design specifics. 







The physical database will be then generated from the model.




Database First



Using this approach you can reverse engineer a model from an existing database. The classes are automatically generated from EDMX file. Read Entity Framework Database First Example for steps.



In the wizard for creating the model, you'll get checkboxes to select Pluralize or singularize generated object names option. Read more about it here.  





Code First





Create classes first and generate Database from the classes directly. No use of Entity designer at all. 



Choosing the suitable workflow

Understanding which workflow to use is important before you start developing data access applications using EF. 



http://blog.smartbear.com/development/choosing-the-right-entity-framework-workflow/

http://msdn.microsoft.com/en-us/library/vstudio/cc853327%28v=vs.110%29.aspx  





Data Persisting in Entity Framework

Entity Framework use Unit of Work pattern to persist data.  



















            

          

          

        

Monday, July 7, 2014


          

        









What is ASP.NET Core












ASP.NET Core (previously known as ASP.NET VNext and then ASP.NET 5) is the next version of ASP.NET. Unlike its predecessors, Core is is open source available on github.







Here are some of the features




    

  • Open source and cross platform
    • 

  • Can run on .NET core or on full .NET framework
    • 

  • Leander and modular
    • 

  • ASP.NET Core is no longer based on System.Web.dll it is now based on NuGet packages
    • 

  • Built-in dependency injection
    • 

  • New light-weight and modular HTTP request pipeline
    • 























        

      












Subscribe to:
Posts (Atom)








Powered by Blogger.















Software Architect at Surge Global/ Certified Scrum Master
Experienced in Product Design, Software Engineering, Team management and Practicing Agile methodologies.
























































Search This Blog




































Facebook