! [Technical ]

Interview at Amazon Bangalore

2016-05-02T22:34:00.000-07:00

Some time back i had an interview with Amazon bangalore, i had to go through a telephonic round which lasted up to an hour, once i cleared that i received an email from HR stating that i need to write a snippet about my achievements either on technical or management. So i chose what i had been doing best in that last 2 years at my previous employment.

Instances when you adopted new innovative ideas from your team or elsewhere to improve and simplify your product/ Process. How do you quantify the benefits? What was the learning?

Below is what i actually submitted to Amazon and after that i was called for a F2F interview with them.

One of the most satisfying moments in my career was while I was at XXXX.
I led two mission critical and high visibility products in the YYYYY department. To give you some context the YYY product has over 450 Hospitals as a client base and run at some of the most important hospitals in the US.

When I came into the organization, XXXX was in the end stages of porting the YYYY application to a newer technology. At the same time through the existing team we had to maintain and support the older line on an older technology. Towards the end of 2014 as the product was GA we had issues crop up from our Beta customers and we were caught up in addressing issues as soon as they came. Given the limited resources and the need to support two lines of the product it was apparent that we will soon be hitting a crunch on time and people resources.

The first thing that I set about to optimize were the following

1) Sync-up meetings (Bangalore Team -- US Team)
On an average the team were spending 2 hours updating their status of tasks one at beginning of the week and the other at the end of the week. So cumulatively given a team size of 15 that is a cumulative 30 hours.

Why did I feel this was important?
a. Breakdown in stakeholder communication
b. Lack of trust.
c. Effective hours spent in office
d. Colleagues get frustrated.

Root cause & Fix
Team tended to take on more tasks without understanding the depth of the problem. Also since the new product line was developed by consultants and handed over to the DEV team we were also stuck with issues coming out of regression testing. This led us to over commit based on our capacity and led to slip up on tasks.

I approached this issue by including my Director in Bangalore with a plan of approach and gaining consensus so as to
○ Limit number of participants to Engineering Manager, Lead, PM, QA lead and reduce the duration and frequency
○ Setup a separate meeting that included me and counterparts in the US middle of the week to sync up on team performance
○ I worked with the team to improve the communication to key stakeholders by first breaking down the task the least possible work item and providing an better estimate.
○ Spoke to my counterparts and laid out a plan of improvement over a Q-O-Q basis and then was successful to bring this down to a half hour meeting in a week as they saw improvement in the team performance.

2) Service Package Quality (SP)
We deliver code break fixes on a monthly basis to our customers, package quality is a metric used at XXXX which roughly calculates the number of client downloads of the SP versus the number of tickets raised against that down through support.
This was one of the biggest challenge that I faced, how do I improve my teams code quality and have customer base that is raving about our quality. At the beginning of my journey with XXXX the package quality roughly stood as follows, Q3, 2013 was the timeline when I joined XXXX , this was the challenge I was faced with a worse package quality that has visibilty of all the VP at XXXXX. Towards the end of my tenure I was able to move the bar higher for the team through these slew of corrections

Root Cause & Fix
• QA at XXXX is a separate organization all together and I realized that though there were one or two QA persons involved in testing, we cant improve our quality if QA leadership isn't behind us. We had to find a way to collaborate better and work on improving quality as a team.
• Co-ordination : QA and Dev were not aligned on the nature of change, for a proposed change in code, QA wasn’t given time to align their test cases or time to write new test cases as all the estimates were given by the architect who didn’t consult with QA lead on what their estimates would be.
• No formal design review meetings at engineering level. Failure to identify true impact of change.
• No formal code review mechanism, though the team already had a process of using Crucible Review they were not implementing it.
• Right size the delivery items, justify with data on how many items we can fix realistically per SP.
• QA team missing key testing areas
• Whitebox testing issues from developers
• Lead Architect and developers trust issues and breakdown in environment
• No Gated check-in concept so as to catch the failure earlier
• No automated unit testing frameworks used.

Improvements made
• Setup a collaborative environment working with the QA Manager and worked together with him to get QA resources behind our release, to ensure a stringent release process we started bug bash sessions, unscripted testing.
• Lead from the front by driving all the meetings and code reviews. We introduced a concept that architect needs to review code along with two other engineers to be allowed to check-in and any build failures to be caught early.
• Setup meeting and training with the team on identifying issues in code and how to analyze impact of change areas.
• Worked with the team and their feedback on improving team environment by ensuring that any code break is not a persons fault but a fault in process that needs to be improved upon
• Architect took up the challenge to setup a Jenkins box to allow us to build first on our local environment before code is checked-in to ensure we do it right the first time.

Measurable Improvements
• 20 to 30% increase in Service Package Quality numbers quarter on quarter compared to where we started in Q3 2013
• 100% critical enhancement and bug-fix delivery to clients for Obligations (customer funded fixes)
• Improved customer feedback and reduction in number of support tickets open

Facebook behind the scenes - TAO

2015-11-06T01:19:00.003-08:00

Ever wondered what the technology is behind the scenes at Facebook. Take a look at this video, it is suprisingly honest and concise.
Graphs and more Graphs as a data structure.

If you are querying billions of queries having petabytes of information every second, this is what Facebook does..

Click here to see the presentation on TAO

WCF Handling Exceptions

2013-05-02T01:42:00.002-07:00

If you are designing any complicated service where in you want to ensure that all possible requests are served, then it becomes important that there is a proper error handling strategy.
In one of my projects i had a retry mechanism which would try 3 times to send / process the request on certain types of errors. I have listed out the function which handles the retry mechanism


  public bool IsError(System.Exception ex)
  {
   bool retry = FALSE;

   if (ex is System.ServiceModel.CommunicationException)
   {
    if (ex is FaultException)
    {
     // We get this case sometimes when connection has been closed, on next call.
     if ((ex as FaultException).Detail.Type !=
      "System.ObjectDisposedException")
     {
      ErrorLoger("generic fault - not retrying.", ex);
     }
    }
    else if (ex is System.ServiceModel.FaultException)
    {
     ErrorLoger("generic fault - not retrying.", ex);
    }
    else if (ex is System.ServiceModel.AddressAccessDeniedException ||
       ex is System.ServiceModel.Security.SecurityAccessDeniedException ||
       ex is System.ServiceModel.Security.SecurityNegotiationException ||
       ex is System.Security.Authentication.AuthenticationException)
    {
     ErrorLoger("Received access denied - not retrying.", ex);
    }
    else if (ex is System.ServiceModel.EndpointNotFoundException)
    {
     ErrorLoger("Endpoint was not found - not retrying.", ex);
    }
    else if (ex is System.ServiceModel.ServerTooBusyException)
    {
     ErrorLoger("Service AppPool may be down - not retrying.", ex);
    }
   }
   else if (ex is System.ObjectDisposedException)
   {
    var ode = ex as ObjectDisposedException;
    if (!ode.ObjectName.Contains("System.ServiceModel.ChannelFactory"))
    {
     ErrorLoger("object disposed exception not related to channel factory.", ex);
    }
    else
    {
     ErrorLoger("Received object disposed exception related to the channel factory.", ex);
     retry = TRUE;
    }
   }
   else if (ex is System.TimeoutException || ex is System.Net.Sockets.SocketException)
   {
    if ((ex is System.TimeoutException))
    {
     ErrorLoger("Received TimeoutException. Retrying", ex);
    }
    else
    {
     ErrorLoger("Received SocketException. Retrying", ex);
    }
    retry = true;
   }
   else
   {
    ErrorLoger("General error, so not retrying.", ex);
   }
   return retry;
  }
The FaultException class belongs to the System.ServiceModel library.

Generating an ASYNC proxy for your WCF service

2013-04-30T01:52:00.000-07:00

If your WCF service supports ASYNC calls then we will need the right proxy that supports ASYNC so that the client can use that capability.
You have to use the Async attribute for your Interfaces.


        [OperationContractAttribute(AsyncPattern = true)]
        IAsyncResult BeginProcessStudentEnrollment(AsyncCallback callback, object asyncState);
        Result EndProcessStudentEnrollment(IAsyncResult result);

The Async pattern follows the Begin and End pairs, this internally makes use of the Async pattern in the System.IAsyncResult interface.

In your implementation class you will have to do the following, implement both the Begin and End pairs. This is case sensitive do make sure that it follows the same as in your interface definition


public IAsyncResult BeginProcessStudentEnrollment(AsyncCallback callback, object asyncState)
        {
            ServerResponse response = new ServerResponse();
            try
            {             
                    long rows = GetEnrollment(); //Business Layer call
                    if (rows > 0)
                    {
                        response.SetSuccessResponse(true, "Successfully executed");
                    }
                    else
                    {
                        response.SetSuccessResponse(false, "No records were updated");
                    }
            }
            
            catch (Exception error)
            {
              response.SetErrorResponse(500, "General type exception, see service error logs for details");
            }
            return new CompletedAsyncResult(response);
        }

        public Result EndProcessStudentEnrollment(IAsyncResult r)
        {
            CompletedAsyncResult result = r as CompletedAsyncResult;
            return result.Data;
        }

CompletedAsyncResult is the class that will handle your Response objects. I have listed this class below


    /// 
    /// This class handles the completed Async calls by implementing the IAsyncResult interface.
    /// 
    /// 
    public class CompletedAsyncResult : IAsyncResult
    {
        T data;

        public CompletedAsyncResult(T data)
        {
            this.data = data;
        }

        public T Data
        {
            get { return data; }
        }

        #region IAsyncResult Members
        public object AsyncState
        {
            get
            {
                return (object)data;
            }
        }

        public WaitHandle AsyncWaitHandle
        {
            get
            {
                return null;
            }
        }

        public bool CompletedSynchronously
        {
            get
            {
                return true;
            }
        }

        public bool IsCompleted
        {
            get
            {
                return true;
            }
        }
        #endregion
    }

and finally the generation of the Async aware proxy is done with this command line argument

svcutil http://localhost/StudentPerfService/PerfService.svc?wsdl /a /tcv:Version35

How to Mole DataReader in your Unit Tests

2013-04-29T02:19:00.000-07:00

In one of my projects i had to write unit test cases around a DataReader object.
We have a middle tier that talks to the database and fetches the records. The middle tier then uses the C# DataReader class and populates the business layer objects.

This example shows a Moles sample on how to do this.

This is the DB layer class that makes the call to the Stored Procedure

public List GetConfiguration()
        {
            ConnectionString = connectionstring;
            List configDataList = new List();
            using (sqlconnection = GetDbConnection())
            {
                using (SqlCommand sqlCommand = GetDbSprocCommand(DataAccessConstants.LoadConfiguration, sqlconnection))
                {
                    if (sqlCommand != null)
                    {
                        if (sqlconnection.State != System.Data.ConnectionState.Open)
                        {
                            sqlconnection.Open();
                        }

                        SqlDataReader dr = sqlCommand.ExecuteReader();
                        ConfigData configdata;
                        while (dr.Read())
                        {
                            configdata = new ConfigData();
                            configdata.ConfigKeyName = dr[0].ToString();
                            configdata.ConfigKeyValue = dr[1].ToString();
                            configDataList.Add(configdata);
                        }
                        dr.Close();
                    }
                }
            }
            return configDataList;
        }

I now want to Mole out the SQLDATAReader in the code above. Since the SqlCommand is a C# native library i cannot Stub it out , so i Mole out that library by right clicking in the References and choosing 'Mole it' in the options that come up.
The idea is that i need to unit test the whole While loop above because the SQL Database is mocked we need to ensure that the test case passes in the while loop.

Listed below is how i moled out the DataReader class


public void Sanity_Test()
        {

            MSqlConnection.AllInstances.Open = (c) => { };
            MSqlConnection.AllInstances.Close = (c) => { };
         
            int readCount = 0;
            object[] data = { "STRING_NAME1", "y", "STRING_Name2", "n", "String_Name3", "ValuesAre" };
            //Create a delegate the simulates result in the record 
            MSqlCommand.AllInstances.ExecuteReader = (SqlCommand cmd) =>
            {
                MSqlDataReader x = new MSqlDataReader();
                x.Read = () => readCount++ == 0;
                x.ItemGetInt32 = index => data[index];
                return x;
            };

            MSqlDataReader.AllInstances.Read = (a) => { return false; };
            
            //Also create a delegate for the DataReader close 
            MSqlDataReader.AllInstances.Close = (a) => { };

            MySpecialClass rep = new MySpecialClass();
            var result = rep.GetConfigurationValues();
            if (null != result)
            {
                Assert.AreEqual(result[0].ConfigKeyName,"STRING_NAME1");
            }
        }

By creating the Object [] Array and then by mocking the Execute reader class as shown above i am able to do it.
The trick is to use the following lines
MSqlDataReader x = new MSqlDataReader();
x.Read = () => readCount++ == 0;
x.ItemGetInt32 = index => data[index];
return x;

Dot NET unit testing frameworks

2013-04-29T01:25:00.000-07:00

Unit testing is defined as Testing the smallest unit of work. What that means is to test your functions independent of dependent functions. This kind of testing will just test one part of the function independent of other dependents.
If the module is dependent on an external source we will need to make a Mock or in other words generate a proxy for that class. This way we only test the function that we are interested in.

Unit tests are generally done to get code coverage stats which show how much of the code is covered by the test case. Whether all the conditional statements, Error handling conditions are tested.

It has wide acceptance in TDD methodology, unit tests are created before code is written. The unit tests are executed against the function frequently. As code is developed further either, code is changed or via an automated process with the build. If the unit tests fail, it is considered to be a bug either in the changed code or the tests themselves.

There are a lot of Mocking Frameworks out there, There are essentially two different types of mocking frameworks, one that are implemented via dynamic proxy and another one that are implemented via CLR profiler API.

Proxy based mocking frameworks

Proxy based mocking frameworks uses reflection and runtime code generation to dynamically generate classes (proxies) that either implement an interface being mocked or derive from a non-sealed class that’s being mocked.
This can be used only when good OO principles and dependency injection container been utilized for building the system (i.e. loose coupling, high cohesion and utilizes interfaces heavily)

A proxy object is an object that is used to take the place of a real object. In the case of mock objects, a proxy object is used to imitate the real object your code is dependent on. We can create a proxy object with any of below available proxy based mocking frameworks.

NSubstitue

Rhino mocks

FakeItEasy

NMock

EasyMock

Simple.NET

NUnit.Mocks

Pros and Cons

Pros

Open source and free
Can mock both non-sealed classes and interfaces
Type safe
Expressive and easy-to-learn syntax
Easy-to-use
Performance/Speed

Cons

Heavily relies on dependency injection pattern
Cannot mock non-virtual, non-abstract and static methods
Cannot mock sealed classes and private classes
Backward compatibility
Limited technical support and community
Limite documentation

Profiler based Mocking frameworks

Profiler based mocking frameworks uses the CLR profiler API’s to intercept and redirect calls to any method of any type. This makes it capable of mocking sealed types, system classes and even intercept and divert calls to non-virtual methods of concrete types.

In general, Proxy based frameworks require that your mocks implement an interface. But what do you do when the class you are trying to mock is static or sealed with no interface. If you can’t modify the class then your unit testing efforts are usually stuck. In that case, Profiler based mocking frameworks are generally better for developers wanting to use them on existing legacy code since it may not possible to refractor such into a design that is more testable.

Here is the list of profiler based mocking frameworks.

Moles Framework (from Microsoft) – Free

TypeMock Isolator – Commercial/Paid

JustMock – Commercial / Paid

Pros and Cons

Pros

Doesn’t rely on dependency injection pattern
Can mock anything including
- Non-virtual, non-abstract and static methods
- Sealed and private classes
Type safe
Expressive and easy-to-learn syntax
Community & technical support and documentation
Backward compatibility

Cons

Not open source
Performance – profiler’s uses runtime instrumentation under the hood
Not easy-to-use when compared with proxy based mocking frameworks

Recommended Mocking Frameworks

Following are the recommended mocking frameworks based on above factors and external links.

Moles Framework

Moles Framework is a light weight CLR profiler based framework for test stubs and detours for .NET that is based on delegates.

This Framework actually supports two different kinds of substitution class – stub types and mole types. These two approaches allow you to create substitute classes for code dependencies under different circumstances.

1. Stub types – Provide a lightweight isolation framework that generates fake stub implementation of virtual methods, interfaces for unit testing. For every stubbed interface and class, code is generated at compile time i.e. one stub class per interface and class.

2. Mole types - use a powerful detouring framework that uses code profiler APIs to intercept calls to dependency classes and redirects the calls to a fake object. It is used to detour any .NET method, including non-virtual and static methods in sealed types.

Pros and Cons

Pros

It's from Microsoft
Support legacy code
Can mock any type of object that includes from .NET library

Cons

Mole types would be quite hefty performance impact because it uses runtime instrumentation under the hood.
Need to regenerate the Moles assemblies each time when there is any method signature change in the system.

Moq

Moq is the simplest proxy based mocking framework which takes advantages of the .NET 3.5 language features like lambda expression trees and C# 3.0 features like lambda expressions that make it the most productive, type-safe and refactoring-friendly mocking library available. And it supports mocking interfaces as well as classes. Its API is extremely simple and straightforward, and doesn't require any prior knowledge or experience with mocking concepts.

Pros and Cons

Pros

Very much popular
Strong technical support and community

Cons

Support .NET runtime 3.5 and above only
Difficult to mock static classes and sealed types (Code refactoring is required for legacy code)
Need to use "mock.Object" property if we pass the mocked interface/ class over

NSubstitute

NSubstitute is a friendly substitute for mocking frameworks which is a proxy based and makes use of extension methods on object for its API. And it is designed for Arrange-Act-Assert (AAA) testing, so you just need to arrange how it should work, then assert it received the calls you expected once you're done.

Pros and Cons

Pros

Simple syntax compared to Moq
No need to use lambdas to set return values for a mocked property. Hence improves readability.
Better internal error messages compared to Moq

Cons

Difficult to mock static classes and sealed types (Code refactoring is required for legacy code)
Relatively new framework compared to Moq
Minimal technical support and community

I highly recommend reading this article. It has some good insights like Unit testing isn't about finding bugs :) Unit Test the right way

WCF REST service hosted on IIS 5

2013-04-19T02:19:00.002-07:00

Making your WCF service as RESTful is pretty simple in DOTNET. You have three options Get,Post and Put. To this you have to label your contract with an attribute something like below.

[WebGet(UriTemplate = "/StartProcessing")]
[WebInvoke(Method = "POST", UriTemplate = "/SyncCustomerDetails", BodyStyle = WebMessageBodyStyle.WrappedRequest)]

When i was working on my local development environment which had IIS 7.5 everything went fine and i was able to access the REST based services.
The problem started when i wanted to deploy this to our Development lab which has IIS 5. After it was deployed i could not even access the WCF Rest Help page, this can be accessed by appending a /help after your SVC file in the browser.

The error returned was something Like Http 403 error saying bad request and clicking on the help link below would also throw this error. Searching on the internet did not provide with much help.

Only one link that i found mentioned that this problem is with IIS 5 and that it does not allow accessing URL that are extension-less. To solve this some websites said to allow the '*' as a rule, strange this is that IIS 5 will not allow you to even put in such a parameter.

Next suggestion i tried was to add the '*' in the wild card application map extension for the website / virtual directory. To do this, i had to right click the website -> properties -> Virtual Directory Tab -> click on configuration.
In the application configuration tab that comes up, press the insert button and map to aspnet_isapi dll and remove the "Verify this file" exists.

Sad to say even this option did not work out.

The thing that worked for me was this.

My site is configured to run on AspNet 4.0, and the problem was that the Application Pool was configured to run on AspNet 4.0 but the account under which it runs did not have access to C:\WINDOWS\Microsoft.NET\Framework\v4.0.30319\Temporary ASP.NET Files.
The error that was returned also did not provide any help to this because there were no errors in IIS logs, no errors in event viewer, so it really side tracked this.

I hope someone out there finds this useful and can save some time by trying these steps.

How to do Versioning in WCF

2013-04-03T00:24:00.000-07:00

Overview

After initial deployment, and potentially several times during their lifetime, services (and the endpoints they expose) may need to be changed for a variety of reasons, such as changes in data contracts, operations, and end point addresses. The following diagram and sections describe how these changes would lead to breaking /non-breaking changes and the action to be taken accordingly.

Fig 1.Versioning Decision Tree

The decision tree above shows you what you will need to do to handle every case and it also shows the consequences of each versioning choice you might make. The decisions include changes in the service operations, data contract, and bindings.

Process Flow in Versioning

Adding and Removing Data Members

In most cases, adding or removing a data member is not a breaking change, unless you require strict schema validity (new instances validating against the old schema).

When a type with an extra field is deserialized into a type with a missing field, the extra information is ignored. (It may also be stored for round-tripping purposes; for more information, see Forward-Compatible Data Contracts).
When a type with a missing field is deserialized into a type with an extra field, the extra field is left at its default value, usually zero, or null. (The default value may be changed; for more information, see Version-Tolerant Serialization Callbacks.)
For example, you can use the CarV1 class on a client and the CarV2 class on a service, or you can use the CarV1 class on a service and the CarV2 class on a client:

 // Version 1 of a data contract, on machine V1.
[DataContract(Name = "Car")]
public class CarV1
{
    [DataMember]
    private string Model;
}
 
// Version 2 of the same data contract, on machine V2.
[DataContract(Name = "Car")]
public class CarV2
{
    [DataMember]
    private string Model;
 
    [DataMember]
    private int HorsePower;
}

The version 2 endpoint can successfully send data to the version 1 endpoint. Serializing version 2 of the Car data contract yields XML similar to the following.

[javascript:CopyCode('ctl00_rs1_mainContentContainer_ctl15other'); Copy Code]
<Car>
    <Model>Porsche</Model>
    <HorsePower>300</HorsePower>
</Car>

The deserialization engine on V1 does not find a matching data member for the HorsePower field, and discards that data.
Also, the version 1 endpoint can send data to the version 2 endpoint.
The version 2 deserializer does not know what to set the HorsePower field to, because there is no matching data in the incoming XML. Instead, the field is set to the default value of 0.

Required Data Members

A data member may be marked as being required by setting the “IsRequired” property of the DataMemberAttribute to true. If required data is missing while deserializing, an exception is thrown instead of setting the data member to its default value.
Adding a required data member is a breaking change. That is, the newer type can still be sent to endpoints with the older type, but not the other way around. Removing a data member that was marked as required in any prior version is also a breaking change.
Changing the IsRequired property value from true to false is not breaking, but changing it from false to true may be breaking if any prior versions of the type do not have the data member in question.
Note: Although the IsRequired property is set to true, the incoming data may be null or zero, and a type must be prepared to handle this possibility. Do not use IsRequired as a security mechanism to protect against bad incoming data.

Best Practice Usage and Guidelines

Best Practice Usage -Operation Change and Versioning

If you are adding a new operation, simply define a new service contract that derives from the service contract of the existing service, add the new operations to the new service contract, and then have your service type, the class that implements the existing service contract, implement the new service contract instead of the old one. Update the definition of the service endpoint so that it refers to the new, derived service contract. Now existing clients, which will only know about the old service contract, can have the operations that they already knew executed at the original endpoint, and new clients, which know about the enhanced service contract, can have the additional operations executed at the same endpoint.
[ServiceContract]

public interface IMyServiceContract 
{    
[OperationContract]    
 public void MyMethod(MyDataContract input); 
} 
 
[ServiceContract] 
public interface IMyAugmentedServiceContract: IMyServiceContract 
{    
 [OperationContract]    
 public void MyNewMethod(MyOtherDataContract input); 
}   
 
public class MyOriginalServiceType: IAugmentedServiceContract
If you are deleting an operation or changing a data contract type

Best Practice Usage-Data Contract Changes and Versioning

Breaking versus Nonbreaking Changes

Changes to a data contract can be breaking or nonbreaking. When a data contract is changed in a nonbreaking way, an application using the older version of the contract can communicate with an application using the newer version, and an application using the newer version of the contract can communicate with an application using the older version. On the other hand, a breaking change prevents communication in one or both directions.
Any changes to a type that do not affect how it is transmitted and received are nonbreaking. Such changes do not change the data contract, only the underlying type. For example, you can change the name of a field in a nonbreaking way if you then set the Name property of the DataMemberAttribute to the older version name. The following code shows version 1 of a data contract.

  
// Version 1
[DataContract]
public class Person
{
    [DataMember]
    private string Phone;
}

The following code shows a nonbreaking change.

 
// Version 2. This is a non-breaking change because the data contract 
// has not changed, even though the type has.
[DataContract]
public class Person
{
    [DataMember(Name = "Phone")]
    private string Telephone;
}

Some changes do modify the transmitted data, but may or may not be breaking. The following changes are always breaking:

Changing the Name or Namespace value of a data contract.
Changing the order of data members by using the Order property of the DataMemberAttribute.
Renaming a data member.
Changing the data contract of a data member. For example, changing the type of data member from an integer to a string, or from a type with a data contract named "Customer" to a type with a data contract named "Person".

Schema Considerations

The schema WCF produces for data contract types makes no provisions for versioning. That is, the schema exported from a certain version of a type contains only those data members present in that version. Implementing the IExtensibleDataObject interface does not change the schema for a type.
Data members are exported to the schema as optional elements by default. That is, the minOccurs (XML attribute) value is set to zero. Required data members are exported with minOccurs set to 1.
Many of the changes considered to be nonbreaking are actually breaking if strict adherence to the schema is required. In the preceding example, a CarV1 instance with just the Model element would validate against the CarV2 schema (which has both Model and Horsepower, but both are optional). However, the reverse is not true: a CarV2 instance would fail validation against the CarV1 schema.
Round-tripping also entails some additional considerations. For more information, see the "Schema Considerations" section in Forward-Compatible Data Contracts.

Guidelines

Enumerations

Adding or removing an enumeration member is a breaking change. Changing the name of an enumeration member is breaking, unless its contract name is kept the same as in the old version by using the EnumMemberAtttribute attribute. For more information, see Enumeration Types in Data Contracts.

Collections

Most collection changes are nonbreaking because most collection types are interchangeable with each other in the data contract model. However, making a noncustomized collection customized or vice versa is a breaking change. Also, changing the collection's customization settings is a breaking change; that is, changing its data contract name and namespace, repeating element name, key element name, and value element name. For more information about collection customization, see Collection Types in Data Contracts.

Other Permitted Changes

Implementing the IExtensibleDataObject interface is a nonbreaking change. However, round-tripping support does not exist for versions of the type prior to the version in which IExtensibleDataObject was implemented. For more information, see Forward-Compatible Data Contracts.

ASP.NET MVC Best practise

2013-04-02T23:30:00.001-07:00

This page provides guidance and best practices on ASP.NET Model View Controller (MVC), which is a framework for building web application. The page also discusses on ASP.NET MVC advantages, features and how to use the framework to build a web application.

What is ASP.NET MVC?

ASP.NET MVC is a part of the ASP.NET Web application framework.

ASP.NET MVC framework was created to support pattern-based software development. In other words, the framework was designed to make it easier to implement software design principles and patterns when building web applications. It is designed to its core to support unit tests. Web applications written with the ASP.NET MVC framework are highly testable.

Why ASP.NET MVC?

ASP.NET Web Forms made it very easy to get started, but, in other ways, trying to apply design principles to Web apps was a struggle. Web Forms are relentlessly UI focused; the fundamental atom is the page. The page is designed by dragging controls in to it. And the application logic that we have usually will reside in event handlers. Unit testing of pages is often difficult. ASP.NET MVC is a solution addressing these issues.

The ASP.NET MVC framework provides the following features:

Separation of application tasks (input logic, business logic, and UI logic), testability, and test-driven development (TDD) by default. All core contracts in the MVC framework are interface-based and can be tested by using mock objects, which are simulated objects that imitate the behavior of actual objects in the application. We can unit-test the application without having to run the controllers in an ASP.NET process, which makes unit testing fast and flexible. We can use any unit-testing framework that is compatible with the .NET Framework.
An extensible and pluggable framework. The components of the ASP.NET MVC framework are designed so that they can be easily replaced or customized. We can plug in our own view engine, URL routing policy, action-method parameter serialization, and other components. The ASP.NET MVC framework also supports the use of Dependency Injection (DI) and Inversion of Control (IOC) container models. DI allows us to inject objects into a class, instead of relying on the class to create the object itself. IOC specifies that if an object requires another object, the first objects should get the second object from an outside source such as a configuration file. This makes testing easier.
A powerful URL-mapping component that lets us build applications that have comprehensible and searchable URLs. URLs do not have to include file-name extensions, and are designed to support URL naming patterns that work well for search engine optimization (SEO) and representational state transfer (REST) addressing.
Support for using the markup in existing ASP.NET page (.aspx files), user control (.ascx files), and master page (.master files) markup files as view templates. We can use existing ASP.NET features with the ASP.NET MVC framework, such as nested master pages, in-line expressions (<%= %>), declarative server controls, templates, data-binding, localization, and so on.
Support for existing ASP.NET features. ASP.NET MVC lets us use features such as forms authentication and Windows authentication, URL authorization, membership and roles, output and data caching, session and profile state management, health monitoring, the configuration system, and the provider architecture.

ASP.NET MVC Framework Overview

This framework is based around the Model View Controller (MVC) pattern, thus the name, ASP.NET MVC. An MVC Application is designed and implemented using the following three attributes:

Model - The model contains the core information for an application. This includes the data and validation rules as well as data access and aggregation logic.

View - The view encapsulates the presentation of the application, and in ASP.NET this is typically the HTML markup.

Controller - The controller contains the control-flow logic. It interacts with the Model and Views to control the flow of information and execution of the application.

Fig 2 Model-View-Controller concept

In the context of Web, the input is an HTTP request, and the request flow looks as shown below.

Fig 3 HTTP request flow

This is actually quite different from the process in Web Forms. In Web Forms model, the input goes into the page (the View), and the view is responsible for both handling the input and generating the output. When it comes to MVC, on the other hand, the responsibilities are separated.

Features

System Requirements

The following is the system requirement for building ASP.NET MVC application.

Visual Studio 2010/2008 or Visual Web Developer 2008 SP1/2010
NET Framework 3.5 SP1 or .NET Framework 4
ASP.NET MVC 1/ASP.NET MVC 2
IIS 7.0 - integrated mode (For IIS 7.0 (classic mode), IIS 6.0 or below, configuration needs to be done to use ASP.NET routing)
Visual Studio 2008 SP1 (in case of Visual Studio 2008)

Process Flow in ASP.NET- Creating a Sample ASP.NET MVC application

Let us create an application to maintain team member information. The information that it maintains are as follows

First Name
Last Name
Employee Number
Login Id
Date of Joining

Creating a ASP.NET MVC project in visual studio

Follow the steps to create the application:
1. Launch Visual Studio

2. Select the menu option File -> New -> Project. Note: As of now there is no template available for creating ASP.NET MVC website

3. In the New Project dialog, select programming language (C# or VB.NET) and select the ASP.NET MVC 2 Web Application template. Give the project name “TeamMemberInfoManager” and click OK.

4. A Dialog asking for creating unit test project appears. Lets not create a test project for this application, so select No and click OK.

5. The solution gets created as shown as follows.

ASP.NET MVC Folder Convention

There are standard locations for each type of file in an ASP.NET MVC project. The ASP.NET MVC application project contains the following folders:

Folder	Description of the content
App_Data	Contains database files. For example, the App_Data folder might contain a local instance of a SQL Server Express database. This folder is not specific to ASP.NET MVC, this is same folder that we find in ASP.NET web application.
Content	Contains static content such as images and Cascading Style Sheet files.
Controllers	Contains ASP.NET MVC controller classes
Models	Contains ASP.NET MVC model classes.
Scripts	Contains JavaScript files including the ASP.NET AJAX Library and jQuery
Views	Contains ASP.NET MVC views.

When building an ASP.NET MVC application, one should only place controllers in the Controllers folder, JavaScript scripts in the Scripts folder, ASP.NET MVC views in the Views folder, and so on. By following these conventions, we make our application more easily maintained and easily understood by others.

1. Run the solution created. The page looks as below.

Fig 7 ASP .Net MVC Home Page

Let us implement Create and Edit functionalities for team members.

Model

The model contains the core information for an application. This includes the data and validation rules as well as data access and aggregation logic.

1. Right click on “Models” folder and add new class “TeamMemberModels”.

Fig 8 Add New Item

2. Change the code in the file to look as below.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
 
namespace TeamMemberInfoManager.Models
{
    public class TeamMember
    {
        public String FirstName { get; set; }
        public String LastName { get; set; }
        public String EmployeeNumber { get; set; }
        public String LoginId { get; set; }
        public DateTime DateOfJoining { get; set; }
    }
}

3. Let us implement the logic for creating and maintaining team members. IRepository is an interface defining the behavior of create and update. The code for IRepository looks as follows. Create this interface within folder Models.

using TeamMemberInfoManager.Models;
using System.Collections.Generic;
interface IRepository
{
    void Add(TeamMember newTeamMember);
    TeamMember Search(string EmployeeNumber);
    List<TeamMember> getAllTeamMembers();
    void Update(TeamMember updatedTeamMember, string    employeeNumber);
}

4. Let us implement Repository as below in the folder Models. This has the code implementing the behavior

1. Add new team member
2. Search for a team member
3. Get all team members
4. Update a team member info

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
 
namespace TeamMemberInfoManager.Models
{
    public class Repository : IRepository
    {
        static List<TeamMember> teamMembers = new List<TeamMember>();
 
        public void Add(TeamMember newTeamMember)
        {
            teamMembers.Add(newTeamMember);
        }
 
        public TeamMember Search(string employeeNumber)
        {
            foreach (TeamMember member in teamMembers)
            {
                if (string.Compare(member.EmployeeNumber, employeeNumber, true) == 0)
                {
                    return member;
                }
            }
            return null;
        }
        public List<TeamMember> getAllTeamMembers() 
        { 
                return teamMembers;
        }
        public void Update(TeamMember updatedTeamMember, string employeeNumber)
        {
            teamMembers.Remove(Search(employeeNumber));
            teamMembers.Add(updatedTeamMember);
        }
    }
}

Controller

The ASP.NET MVC framework maps URLs to classes that are referred to as controllers. Controllers process incoming requests, handle user input and interactions, and execute appropriate application logic. A controller class typically calls a separate view component to generate the HTML markup for the request.

1. Right click on Controllers folder, Add Controller…

Fig 9 Controllers folder

2. Give the name as “TeamMemberController”. Controller files should always be suffixed with the word “Controller”. Select the check box to create action methods for create, update and detail.
3. Code gets generated for Create, Update and Details.

The base class for all controllers is the ControllerBase class, which provides general MVC handling. The Controller class inherits from ControllerBase. The Controller class is responsible for the following processing stages:

Locating the appropriate action method to call and validating that it can be called.
Getting the values to use as the action method's arguments.
Handling all errors that might occur during the execution of the action method.
Providing the default WebFormViewEngine class for rendering ASP.NET page types (views).

The methods in the controller are the actions exposed by the controller. The URL /TeamMember/Index invokes TeamMember.Index() method and the URL /TeamMember/Create invokes TeamMember.Create () method.
A controller action returns action result. The ASP.NET MVC framework supports several types of action results including:

ViewResult - Represents HTML and markup.
EmptyResult - Represents no result.
RedirectResult - Represents a redirection to a new URL.
JsonResult - Represents a JavaScript Object Notation result that can be used in an AJAX application.
JavaScriptResult - Represents a JavaScript script.
ContentResult - Represents a text result.
FileContentResult - Represents a downloadable file (with the binary content).
FilePathResult - Represents a downloadable file (with a path).
FileStreamResult - Represents a downloadable file (with a file stream).

All of these action results inherit from the base ActionResult class.
The controller action Index exposed by TeamMemberController return a function View() which returns a ViewResult. A view contains the HTML markup and content that is sent to the browser. A view is the equivalent of a page when working with an ASP.NET MVC application.
In order to be exposed to the universe as an action, a method in a controller must meet below requirements:

The method must be public.
The method cannot be a static method.
The method cannot be an extension method.
The method cannot be a constructor, getter, or setter.
The method cannot have open generic types.
The method is not a method of the controller base class.
The method cannot contain ref or out parameters.

If we need a public method in a controller class which should not be exposed as an action, use the attribute [NoAction]. In the example below, the method CompanySecrets is not exposed to public as an action.

namespace MvcApplication1.Controllers
{
    public class WorkController : Controller
    {
        [NonAction]
        public string CompanySecrets()
        {
            return "This information is secret.";
        }
 
    }
}

Let us update the methods generated in control to make it work.

Implement Index method to return all team members, to display on initial page.
Remove Details method, as we are not implementing this functionality.
Update HTTPPost, Create method to add new team member to the list.
Update Edit method to return a particular team member which needs to be edited.
Update HttpPost, Edit method to update a team member information.

The code looks as below after the change.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using TeamMemberInfoManager.Models;
namespace TeamMemberInfoManager.Controllers
{    
    public class TeamMemberController : Controller
    {
        IRepository repo = new Repository();  
        // GET: /TeamMember/
        public ActionResult Index()
        {
            return View(repo.getAllTeamMembers());
        }     
        // GET: /TeamMember/Create       
        public ActionResult Create()
        {
            return View();
        } 
        // POST: /TeamMember/Create
        [HttpPost]
        public ActionResult Create(TeamMember newTeamMember)
        {
            try
            {
                if (ModelState.IsValid)
                {
                    repo.Add(newTeamMember);
                    return View("Index", repo.getAllTeamMembers());                    
                }
                else
                {
                    return View();
                }                
            }
            catch
            {
                return View();
            }
        }
        // GET: /TeamMember/Edit/5 
        public ActionResult Edit(String id)
        {
            return View(repo.Search(id));            
        }
        // POST: /TeamMember/Edit/5
        [HttpPost]
        public ActionResult Edit(String id, TeamMember updatedTeamMember)
        {
            try
            {
                if (ModelState.IsValid)
                {
                    repo.Update(updatedTeamMember, id);
                    return View("Index", repo.getAllTeamMembers());                   
                }
                else
                {
                    return View();
                }                
             }
            catch
            {
                return View();
            }
        }
    }
}

View

The view encapsulates the presentation of the application, and this is typically the HTML markup. The folder includes .aspx pages. The views must be created at right location. The TeamMemberController.Index() action returns a view located at the path “\Views\TeamMember\Index.aspx”. The TeamMemberController.Create() action returns a view located at the path “\Views\ TeamMember\Create.aspx”
In general, the controller action returns a view that is located at subfolder with same name as that of controller within the folder “Views” and with the same name as that of action.

Creating a view for action “Index”

To create a view for action index, perform the following:

1. Right click on the method and “Add View”. This creates the page and the corresponding folder if doesn’t exists.

Fig 10 Action index

2. There is an option to create “strongly-typed view”. Let us choose this and select the options as below. This means that index page should display a List of team members. (If you cannot see the TeamMember class in the dropdown, build the application and try again.)

Fig 11 Add view - List

Un-checking both “Create a partial view (.ascx)” and “Create a strongly-typed view” will create a blank page.

Choosing partial view creates a user control for the action.

There are 2 ways how the data can be transferred from controller to view.

Loosely –typed dictionary

Uses ViewData dictionary to store string-object as a key-value pair.
Need to typecast the object, every time while using.

Strongly –typed dictionary

A particular type of object, specified as a model is expected by the view.
ViewDataDictionary<TModel> represents a container that is used to pass strongly typed data between a controller and a view.
For strongly-typed view, view page inherits from ViewPage<T> class.
The object passed to view is accessed through a variable named model.

A view created is a standard (X)HTML document that can contain scripts. The script is enclosed with the tags <% and %>.

Note: ASP.NET 4 is introducing new code expression syntax <%: %> that renders output like <%= %> block do and also does HTML encoding before rendering.

HTML Helpers

To make it easier to add content to a view, we can take advantage of something called an HTML Helper. An HTML Helper, typically, is a method that generates a string. We can use HTML Helpers to generate standard HTML elements such as textboxes, links, dropdown lists, and list boxes. The code looks as below.

<body>
    <div>    
    <% using (Html.BeginForm())
       { %>   
        <label for="UserName">User Name:</label>
        <br />
        <%= Html.TextBox("UserName") %>        
        <br /><br />            
        <label for="Password">Password:</label>
        <br />
        <%= Html.Password("Password") %>        
        <br /><br />
        <input type="submit" value="Log in" />            
    <% } %>    
    </div>
</body>

HTML Helper is rendered with <%= %> tags instead of <% %> tags. If you don't include the equal sign, then nothing gets rendered to the browser.
Below are the few standard HTML Helpers available.

Html.ActionLink()
Html.BeginForm()
Html.CheckBox()
Html.DropDownList()
Html.EndForm()
Html.Hidden()
Html.ListBox()
Html.Password()
Html.RadioButton()
Html.TextArea()
Html.TextBox()

View Data

View data is used to pass data from a controller to a view. All data passed from a controller to a view must be sent using this package view data. The controller ViewData property represents a collection of name and value pairs.
As we are done with creating Model, Controller and View for Index, let us run the application.
1. Run the application. Suffix the URL with “TeamMember/Index” and refresh the page. It looks as below. As there is no team member information, the grid is empty.

Fig 13 Application Run wth TeamMemberIndex as the suffix

Routing

The URL specified in the browser gets mapped to a controller action through routing. ASP.NET Routing is used by ASP.NET MVC framework to route incoming requests to controller actions. ASP.NET Routing uses a route table to handle incoming requests.

When we create a new ASP.NET MVC application, the application is already configured to use ASP.NET Routing. ASP.NET Routing is setup in two places.

First, ASP.NET Routing is enabled in our application's Web configuration file (Web.config file). There are four sections in the configuration file that are relevant to routing: the system.web.httpModules section, the system.web.httpHandlers section, the system.webserver.modules section, and the system.webserver.handlers section. Be careful not to delete these sections because without these sections routing will no longer work.

Second, and more importantly, a route table is created in the application's Global.asax file. The Global.asax file is a special file that contains event handlers for ASP.NET application lifecycle events. The route table is created during the Application Start event. The code in the files is as follows

public class MvcApplication : System.Web.HttpApplication
    {
        public static void RegisterRoutes(RouteCollection routes)
        {
            routes.IgnoreRoute("{resource}.axd/{*pathInfo}");
 
            routes.MapRoute(
                "Default",                                              // Route name
                "{controller}/{action}/{id}",                           // URL with parameters
                new { controller = "Home", action = "Index", id = "" }  // Parameter defaults
            );
 
        }
 
        protected void Application_Start()
        {
            AreaRegistration.RegisterAllAreas();
 
            RegisterRoutes(RouteTable.Routes);
        }
    }

The default route table contains a single route (named Default). The Default route maps the first segment of a URL to a controller name, the second segment of a URL to a controller action, and the third segment to a parameter named id.
Default route maps the URL “/Home/Index/3” to following parameters:

controller = Home
action = Index
id = 3

When we request the URL /Home/Index/3, the code that gets executed is “HomeController.Index(3)”
The Default route includes defaults for all three parameters. If we don't supply a controller, then the controller parameter defaults to the value Home. If we don't supply an action, the action parameter defaults to the value Index. Finally, if we don't supply an id, the id parameter defaults to an empty string.

As there is no data to display in Index page, let us create a view for create, so that the data created gets shown in page Index.

1. Adding a view for Create. Right click on method Create and add the page by selecting the options as shown below.

Fig 14 Add view - Create

2.The page gets created as below with text boxes for each of the fields.

Fig 15 Add view page

3. To add a View for Edit, right click on method Edit and add the page by selecting the options as shown below.

Fig 16 Add view - Edit

4. In Index page, let us remove the link for details and modify the code to pass id on click of edit.

With this we have Team Member Info Manager Application working with basic functionalities Create, View and Edit for team members.

Validation

Code for default validation of the form gets generated with the page. Below is the line of code that gets generated for each input fields. The validation of the input controls is done based on the data type of the object that is bound.

<%= Html.ValidationMessageFor(model => model.DateOfJoining) %>

The validation message gets shown as below.

Fig 17 Application validation

The validation message can be customized by specifying the message as an argument for Validation function.

DataAnnotation Validation Support

DataAnnotations provides an easy way to declaratively add validation rules to Model and ViewModel classes within an application, and have automatic binding and UI helper validation support within ASP.NET MVC. ASP.NET MVC 2 includes built-in support for DataAnnotation validations.

The properties of model can be decorate with appropriate validation rules using the DataAnnotation attributes implemented within the System.ComponentModel.DataAnnotations namespace.

The code looks as follows:

using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.ComponentModel.DataAnnotations;
 
namespace TeamMemberInfoManager.Models
{
    
    public class TeamMember
    {
        [Required(ErrorMessage="Please specify First Name")]
        public String FirstName { get; set; }
 
        public String LastName { get; set; }
 
        [Required(ErrorMessage="Please specify Employee Number")]
        [StringLength(10, ErrorMessage = "Must be of 10 characters")]
        public String EmployeeNumber { get; set; }
 
        public String LoginId { get; set; }
 
        public DateTime DateOfJoining { get; set; }
 
       
    }
}

We also have attributes like Range and RegularExpression for data validation.

This is how the screen looks with validation message.

Fig 18 Range and RegularExpression data validation

We can change the display name to a more readable format by adding an attribute [DisplayName] to the model properties. The code looks as follows:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel;
 
namespace TeamMemberInfoManager.Models
{
    
    public class TeamMember
    {
        [Required(ErrorMessage="Please specify First Name")]
        [DisplayName("First Name")]
        public String FirstName { get; set; }
 
        [DisplayName("Last Name")]
        public String LastName { get; set; }
 
        [DisplayName("Employee Number")]
        [Required(ErrorMessage="Please specify Employee Number")]
        [StringLength(10, ErrorMessage = "Employee Number can not be more thatn 10 characters")]
        public String EmployeeNumber { get; set; }
 
        [DisplayName("Login ID")]
        public String LoginId { get; set; }
 
        [DisplayName("Joining Date")]
        public DateTime DateOfJoining { get; set; }       
    }
}

Guidelines and Best Practices

Security

ASP.NET MVC supports all forms of authentication (Forms, Windows, and Passport) like web forms. We have the option for providing authorization for each action in the control. [Authorize] is an attribute that can be used for authorizing an action in controller. Below is the sample code implementing this.

[Authorize]
        public ActionResult CompanySecrets()
        {
            return View();
        }
        [Authorize(Users="Stephen")]
        public ActionResult StephenSecrets()
        {
            return View();
        }
        [Authorize(Roles = "Administrators")]
        public ActionResult AdministratorSecrets()
        {
            return View();
        }

Filters

A filter is an attribute that can be applied to a controller action or an entire controller to modify the way in which the action is executed.
The ASP.NET MVC framework supports four different types of filters:

Authorization filters - Authorization filters are used to implement authentication and authorization for controller actions. Authorization filters implements IAuthorizationFilter attribute. Authorize filter is an example of an Authorization filter.
Action filters - Action filters contain logic that is executed before and after a controller action executes. Action filters implements the IActionFilter attribute. We can use an action filter, for instance, to modify the view data that a controller action returns.
Result filters - Result filters contain logic that is executed before and after a view result is executed. Result filters implements the IResultFilter attribute. This can be used to modify a view result right before the view is rendered to the browser.
Exception filters - Exception filters are the last type of filter to run. We can use an exception filter to handle errors raised by either controller actions or controller action results. We also can use exception filters to log errors. Exception filters Implements the IExceptionFilter attribute.

Filters are executed in the order listed above. For example, authorization filters are always executed before action filters and exception filters are always executed after every other type of filter.

ASP.NET MVC Areas

To accommodate large projects, ASP.NET MVC lets us partition Web applications into smaller units that are referred to as areas. Areas provide a way to separate a large MVC Web application into smaller functional groupings. An area is effectively an MVC structure inside an application. An application could contain several MVC structures (areas). For more informatino, refer ASP.NET MVC Areas to learn more.

Deciding When to Create an MVC Application

One must consider carefully whether to implement a Web application by using either the ASP.NET MVC framework or the ASP.NET Web Forms model. The MVC framework does not replace the Web Forms model; we can use either framework for Web applications. (If we have existing Web Forms-based applications, these continue to work exactly as they always have.) We can also have application developed using both web forms and ASP.NET MVC.
Before we decide to use the MVC framework or the Web Forms model for a specific Web site, weigh the advantages of each approach.

Advantages of a MVC-Based Web Application

The ASP.NET MVC framework offers the following advantages:

It makes it easier to manage complexity by dividing an application into the model, the view, and the controller.
It does not use view state or server-based forms. This makes the MVC framework ideal for developers who want full control over the behavior of an application.
It uses a Front Controller pattern that processes Web application requests through a single controller. This enables you to design an application that supports a rich routing infrastructure.
It provides better support for test-driven development (TDD).
It works well for Web applications that are supported by large teams of developers and Web designers who need a high degree of control over the application behavior.

Advantages of a Web Forms-Based Web Application

The Web Forms-based framework offers the following advantages:

It supports an event model that preserves state over HTTP, which benefits line-of-business Web application development. The Web Forms-based application provides dozens of events that are supported in hundreds of server controls.
It uses a Page Controller pattern that adds functionality to individual pages.
It uses view state or server-based forms, which can make managing state information easier.
It works well for small teams of Web developers and designers who want to take advantage of the large number of components available for rapid application development.
In general, it is less complex for application development, because the components (the Page class, controls, and so on) are tightly integrated and usually require less code than the MVC model.
As it is a classic way of implementing web application, required time for learning is less.

Other Best practices

Demo code should not be part of production application. So delete AccountController demo code that gets generated on creating MVC application.
Isolate controllers from external world
- HttpContext
- Data Access Classes
- Configuration management
- Logging
- Clock
Never use magic strings.
- Never use ViewData[“key”], but always create a ViewModel per each View, and use strongly-typed views ViewPage<ViewModel>.
Pay attention to verbs
- Show data in GET.
- Modify data in POST.
Have DataModel != View Model
- Data Model contains data and behavior; it is hierarchical and contains complex types.
- View Model contains only data; it is flat and contains only string data types.
Do not use code behind.
Do not have logic in views.
- If and Foreach are allowed in view and accomplish this logic with HtmlHelper class.

Windows Security for WCF Intranet Applications

2013-04-02T04:34:00.000-07:00

Pattern Description

In an intranet scenario where the WCF service serves .NET clients, it would be ideal to take advantage of the existing Windows security (that is, Kerberos authentication and Active Directory role base authorization) infrastructure. This pattern explains how to configure a WCF service to do just that.

In this pattern we host the service in IIS with “wsHttpBinding” binding. Note that the service could also be hosted in a Windows Service process using the “NetTCPBinding.” Although TCP provides better performance over HTTP, however, IIS provides many benefits over Windows Service such as on-demand service activation, process recycling, etc. Also note that in Windows 2008 and IIS 7, bindings other than “*HttpBinding” can be hosed on Windows Activation Service (WAS).

Using this pattern, the caller’s Windows identity will flow to the service. Who the “caller” is, depends on the client type (rich/ASP.NET/another WCF service) and whether or not impersonation occurs:

Rich client (Winform/WPF): The logon user identity unless the app impersonates a different user in code.
ASP.NET client: The process identity (App Pool identity), unless the app impersonates the original caller.
Another WCF service: The service account that the service is running on, unless the WCF is impersonating the original caller.
In the sample implementation in this document, we follow a “Trusted Sub System” model where the ASP.NET client application does not impersonate the original caller.The sample, however, shows how to send the original caller’s identity in the message header.

Pattern Flow Description

The service requires that all communications between it and its clients are encrypted. It also requires that the clients must have a Windows identity and reside on the same domain as the service or a trusting domain. The caller’s Window’s identity flows to the service. The service authenticates the caller and verifies if the caller is authorized to access the service’s methods/properties. If the service needs to call other resources such a database that require Windows authentication the service will present its process identity (service account if not self hosted).

Implementation Details

Description

The following steps show how to configure the service and its client(s) to implement this pattern:

1.Create a “.svc” file that specifies the service type and copy it to the root of your Virtual Directory:


<%@ ServiceHost Language = "C#" Service = "WCF.Demo.Service"%>

2.In the “web.config” file add a “Services” section that sets the binding as “wsHttpBinding” and the service’s end point address:

<services>
        <service name=" WCF.Demo.Servce">
               <endpoint address=“http://localhost/MYSITE"
                       binding=“wsHttpBinding" bindingConfiguration="wsHttpBindingWindows"
                       contract=“WCF.Demo.IService" />
          </service>
</services>

3.In the “web.config” file add a “Binding” section that sets “Security Mode” to “Message” and “Client Credential Type” to “Windows”:

<bindings>
      <wsHttpBinding>
        <binding name="wsHttpBindingWindows">
          <reliableSession enabled="false" />
          <security mode="Message">
            <transport clientCredentialType="Windows" />
            <message clientCredentialType="Windows" negotiateServiceCredential="false"
              establishSecurityContext="false" />
          </security>
        </binding>
      </wsHttpBinding>
    </bindings>

4.Add logic for your service.

Client

In Visual Studio set a “Service Reference” to the service you created in the previous step. This will create a service proxy and will add appropriate sections in the config file that specifies server’s end point address, binding, authentication requirements, and so on..

1. In the config file, find the “Identity” sub section under the “Client” section and change:

<userPrincipalName value="MyServiceAcct" />
 
To
 
<servicePrincipalName value="MyServiceAcct" />

2.Create an instance of the service proxy and call its methods.

Examples

Client

Client app is an ASP.NET application.
The ASP.NET’s app pool is set to use a custom domain account that has an SPN mapping.
The ASP.NET’s app pool is authorized to call the service.
The ASP.NET app is configured in IIS to use “Windows Integrated Security”
The ASP.NET app is set to use coarse authorization in “web.config”:

<allow roles="DOMAIN\USERGROUPS" />
<deny users="*" />

The ASP.NET app uses finer grain security in code:

if (User.IsInRole("DOMAIN\\USERGROUPS")) {//call service}

The ASP.NET does not impersonate the caller.

Service

The WCF service is hosted in IIS 6.0.
The service’s app pool is set to use a custom domain account that has an SPN mapping.
The service’s app pool identity has been given access to SQL Server.
The service uses Windows Integrated Security to connect to SQL Server.
The service uses “wsHttpBinding” with message security and Kerberos authentication (see service config file).
The service only trusts a group that contains the ASP.NET’s app pool identity. It uses .NET authorization techniques (for this demo all three methods are used for illustration: Direct Role checking, Imperative, Declarative) to ensure that the caller belongs to an authorized group.

SQL Server

SQL Server is configured to use Windows Integrated Security
Only the WCF Service’s app pool identity has been given access to SQL Server and tables.

Sample Code

Client Code: Config File

Security section

<authentication mode="Windows"/>
  <authorization>
      <allow roles="DOMAIN\USERGROUPS" />
      <deny users="*" />
</authorization

Service Proxy Section
Once the client creates a proxy for the service, Visual Studio automatically adds a “Service Model” section to the client’s config file that specifies things such as the end point address, binding, security, and so on.. For clarity, some section has been removed. The only thing to note here is to make sure you change “userPrincipalName” to “servicePrincipalName”:

<system.serviceModel>
 <client>
    <endpoint address=http://LOCALHOST/MYSITE/PAGE.SVC 
                   binding="wsHttpBinding" 
                   bindingConfiguration="WSHttpBinding_IService"     
                   contract="WCFProxy.IService" 
                   name="WSHttpBinding_IService">
     <identity>
  <servicePrincipalName   
             value="SERVICEACCOUNT"/>
     </identity>
   </endpoint>
 </client>
</system.serviceModel>

ASP.NET Code

    protected void Button1_Click(object sender, EventArgs e)
    {
        // Perform a Direct Role check to ensure the caller 
        // is authorized to access the web application.
        if (User.IsInRole("DOMAIN\USERGROUPS"))
        {
            using (WCFProxy.ServiceClient svc = new 
                  WCFProxy.ServiceClient())
            {
                try
                {
      // Call the service
                    Label1.Text = 
                    svc.ConnectToSQLServer().ToString();
                }
                catch (Exception ex)
                {
                   Label1.Text = "Error: " + ex.Message;
                }
            }
        }
        else
        {
            Label1.Text = "Error: " + "Access denied";
        }
   }

Service Code: Config File

The appropriate sections in the service’s configuration file. It specifies

   <bindings>
      <wsHttpBinding>
        <binding name="wsHttpBindingWindows">
          <reliableSession enabled="false" />
          <security mode="Message">
            <transport clientCredentialType="Windows" />
            <message clientCredentialType="Windows" 
              negotiateServiceCredential="false"
              establishSecurityContext="false" />
          </security>
        </binding>
      </wsHttpBinding>
    </bindings>
 
    <services>
      <service behaviorConfiguration="ServiceBehavior" 
               name="Service">
        <endpoint address="HTTP://LOCALHOST/MYSITE/PAGE.svc"
          binding="wsHttpBinding" 
          bindingConfiguration="wsHttpBindingWindows"
          contract="IService" />
      </service>
    </services>
 
    <behaviors>
      <serviceBehaviors>
        <behavior name="ServiceBehavior">
          <serviceMetadata httpGetEnabled="true" />
          <serviceDebug includeExceptionDetailInFaults="true" />
                </behavior>
      </serviceBehaviors>
    </behaviors>

Service Methods

The following methods show how the service is implemented. What the service does is not important here. What is important is illustrating the principal of “Trusted Sub Systems.” These include:
The service performs authorization to ensure the caller is authorized before executing methods and accessing SQL Server. In this case, the service trusts the calling application’s service account (app pool id).
This sample shows how to implement authorization in the service using three methods of authorization that .NET support namely: “Direct,” “Imperative,” and “Declarative.”

Only the service’s app pool identity is given access to SQL Server.

    // Declarative Authorization, make sure the caller belongs to "DOMAIN\USERGROUPS" group.
    // Note that ASP.NET’s app pool identiy should belong to 
    // this group. 
    [PrincipalPermission(SecurityAction.Demand, Role = 
                                        "DOMAIN\USERGROUPS")]
    public bool ConnectToSQLServer()
    {
        // Windows integrated security is used to connect to
        // SQL Server. The service’s app pool id is passed
        // to SQL Server.
        string conn = "Data Source = SQLEXPRESS01; Initial Catalog = 
               Northwind; Integrated Security = SSPI;";
        
        SqlCommand command = new SqlCommand();
        command.Connection = new SqlConnection(conn);
        command.Connection.Open();
        command.Connection.Close();
 
        return true;
    }
 
 
public List<string> GetEndPointsDetails()
{
        // Use direct Role check for this method
     // make sure the caller belongs to    
     // "DOMAIN\USERGROUPS" group.
     // Note that ASP.NET’s app pool identiy should belong to 
     // this group. 
        if (Thread.CurrentPrincipal.IsInRole("DOMAIN\USERGROUPS"))
        {
            ServiceHost host = new ServiceHost(typeof(Service));
            List<string> list = new List<string>();
 
            Foreach             
            (System.ServiceModel.Description.ServiceEndpoint 
                    endPoint in host.Description.Endpoints)
            {
                list.Add("Logical Address=" + endPoint.Address + 
                "    " + "Physical Address=" + 
                endPoint.ListenUri);
            }
 
            return list;
        }
        else
        {
            //throw exception
            throw new FaultException("Authorization failed");
        }
           }
 
          public string GetThreadIdentity()
    {
        // Imperative Authorization. The ASP.NET 
        // app pool identity must belong to at least
        // one of the fictious “BuyersAdmin” or 
        // “SupplyAdmins” groups.
        PrincipalPermission devPermission = new 
        PrincipalPermission(null, "DOMAIN\USERGROUPS");
        PrincipalPermission adminPermission = new 
        PrincipalPermission(null, "DOMAIN\USERGROUPS2");
 
        // User must be in at least one of the authorized groups
        devPermission.Union(adminPermission).Demand();
        return Thread.CurrentPrincipal.Identity.Name;

}

C# threading advanced concepts

2013-03-27T02:21:00.000-07:00

C# has definetly made it easy to work with threads considering how difficult they are in C , C++ One of the requirements we had to work on was to perform a task A by spawning configurable amount of threads. Once and only once task A was done we should proceed with Tasks B, C, D.

To implement this i had used the Monitor.Pulse and Monitor.Wait methods. Here is a snapshot of the implementation.

public static class mylocker 
{ 
  public static int runningWorkers = 5; 
} 
public class PriceManager 
{ 
  private static object workerLocker = new object(); 
  private Handler handler; 
  private void StartXHandler_Threads() 
  { 
    this.handler= new Handler (workerLocker); 
    for (int i = 0; i < mylocker.runningWorkers; i++) 
    { 
      ThreadPool.QueueUserWorkItem(new WaitCallback(o => new Handler().ProcessActivity())); 
    } 
    lock (workerLocker) 
    { 
      while (mylocker.runningWorkers > 0) Monitor.Wait(workerLocker); 
    } 
  }  
} 

Public class Handler 
{ 
  private static object workerLocker; 
  Public Handler(object _workerLocker): this() 
  { 
    workerLocker = _workerLocker; 
  } 
  Public void ProcessActivity() 
  { 
    //---> Do SOME WORK 

    //Once Done, Decrement the thread count and pulse to the main application call that 
    // we are done 

    lock (workerLocker) 
    { 
      mylocker.runningWorkers--; 
      Monitor.Pulse(workerLocker); 
    } 
  } 
}

This for most part works fine until we were told that even putting a lock and decrementing the count is not thread safe and the lock on object can sometime be broken, apparently there is a class in C# called the Interlocked class that allows you decrement, increment in a safe manner.

Some highlights of this class are "The Interlocked class works by requesting that the CLR and Operating System increment (or, decrement, etc.) the number atomically.

The .NET Framework’s Interlocked class taps right into this OS functionality, thus allowing you to avoid errors when two threads attempt an increment at the same time." You can read up more from this nicely written article.
Interlocked Classes and Use

SQL Server Query Tuning

2012-05-31T07:25:00.001-07:00

You can definitely find a lot of articles out on the internet showing different techniques for optimization of queries. What follows is actual implementation or rather sequence of steps that i did to tune the database for improved performance and speed.

The first step is to find which of the queries are slow performing. Most of the times it is only after the client or end user starts complaining that the application is slow.
The right way to go about this is to think about performance when you go about designing the database, tables, stored procedures and indexes.

SETTING AND CHOOSING INDEXES

There are only two types of indexes available Clustered and Non clustered indexes.

There can only be one clustered index and that is how the actual data will be stored in the database. You can have several non-clustered indexes according to MSDN the maximum number is around 249 indexes.
To give a real world explanation of clustered and non-clustered index, think of a yellow book. The index at the end is the non-clustered index, it gives a pointer to the where you can find the actual data.

Some of the golden rules while going about optimization are

(1)Selectivity A good rule for non-clustered index is the percentage of records that are unique, the higher the value the better the selectivity. For example a column of type boolean will have good selectivity since it will have a 50% unique selectivity on the account of possible values being True or False.
Keep in mind that setting a non-clustered index might not always be better since it will have to perform an actual lookup on the clustered index to find the actual data.
If the index is going to perform multiple lookups then there can be instances where an actual table scan might perform better.

(2)Exception to Selectivity When foreign keys come into picture the rule of selectivity can be thrown out of the window. Why foreign keys and not other columns is because it improves the join performance as it performs a MERGE JOIN internally. More on the different types of joins later.
This brings up the point that selectivity is not everything,and the question you should ask is how often is this field going to be used.

(3)Index decrease performance Though a well designed index speeds up performance they can be slow while trying to update data. Anytime data is modified any index related to that data also needs to be updated.. So what that means is that if you have a clustered index on an integer and there are constant updates to this field. Sql server will have to sort this data.
Internally sql server stores the data in one format only, but i uses a Array of sort internally storing the order of the field. Also if you keep changing the clustered index then this Array is sorted again, so it adds to performance issues.

(4)Don't Accept the Default Clustered index when you define a key as primary by default SQL Server sets this column as a clustered index.
A clustered index should be defined on a column that participates in a range query for example a column that takes part in a between, <, >, MAX, MIN and COUNT aggregates. The reason why this works well is because the query can do directly to the data and keep reading till it gets to the end.

(5)Keep Index Keys Short
The larger an index key is, the harder a database has to work to use the index. For instance, an integer key is smaller in size then a character field for holding 100 characters. In particular, keep clustered indexes as short as possible.
There are several approaches to keeping an index key short. Try to limit the index to as few columns as possible. While composite indexes are useful and can sometimes optimize a query, they are also larger and cause more disk reads for the database. Choose a data type for an index column with less number of bytes required for each data type. Integer keys are small and easy for the database to compare. In contrast, strings require a character-by-character comparison.

As a rule of thumb, try to avoid using character columns in an index. Integer columns will always have an advantage over character fields in ability to boost the performance of a query.

IE BOX MODEL

2012-05-31T07:09:00.001-07:00

IE 7 Onwards uses the W3C box model and other browser too. IE 6 uses the IE box model. The IE box model includes padding, border in its calculation of its width. The W3C model does not and calculates it separately. This is the main reason for alignment problems.
IE box model, a box having a width of 100px, with 2px padding on each side, a 3px border, and 7px margin on each side, will have a visible width of 114px.

The W3C box model, excludes the padding and border from the width/height of an element. A box having a width of 100px, with 2px padding on each side, a 3px border, and 7px margin on each side, will have a visible width of 124px.

In order to make IE use the W3C box model (which is what every other browser uses), your page needs to be rendered in Strict mode. By default, IE renders in Quirks mode.

In order to trigger Strict mode in IE, you must specify a doctype. You can use any of the following doctypes:

HTML4 Strict:

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"

"http://www.w3.org/TR/html4/strict.dtd" >

XHTML 1.0 Strict:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

XHTML 1.0 Transitional:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

Your doctype must be the first thing to appear on your page. It is even before the tag, on its own line. (Adding an prolog will cause IE to go back in Quirks mode, so remove it if you have one).

Event with jQuery.event.fix

2012-05-31T06:59:00.000-07:00

If you want to use the traditional HTML event binding and still use jQuery, here is a quick tip to get a “clean” (i.e. cross browsers) html event using jQuery.event.fix:



<input type=”file” name=”photoFile” onchange=”upload(event)”/>

<script>

function upload(e)
{

var e = $.event.fix(e);

alert(”target: ” + e.target);

}

</script>

HTML 5 enabling your web application

2012-05-31T00:07:00.001-07:00

There are several steps you need to take to ensure that your web application is ready for HTML 5. I am in the midst of a porting project from code that is written specifically for IE 6 to make it HTML 5 enabled. Eventually this site should also be accessible on IPAD. I will list the steps to take and the things to watch out for. These are the steps and procedures that i am following.

The first thing is to decide on the DOCTYPE. DOCTYPE is the document type in browsers, this was introduced so that browsers can support different version of HTML. Setting will ensure that the browser will run in the latest mode and that is HTML 5. Setting a DOCTYPE like means that browser will run in standard mode and is an HTML 4.01 version. There are several other doctypes that you can set, This tells modern browsers that you want to display your HTML 4.01 page in strict compliance with the DTD. These browsers will go into "strict" or "standards" mode and render the page in compliance with the standards. So for example in this case using element will not work as it is not w3c compliant.
w3c is the governing body that defines the standards on HTML and what it does. When you set the DTD using the doctype it validates that the rendering is done as per the standard.

-----------------------------------
QUIRKS MODE
-----------------------------------
In IE, the rendering mode decides which box model it follows. In quirks mode it uses the traditional model, in strict mode the W3C model. Doctype switching is the only way of selecting a box model in IE 6 Windows. Mozilla, Opera and IE Mac allow the use of the box-sizing declaration to select a box model, while Safari only supports the W3C box model. See this site, it has more details: http://www.quirksmode.org/css/quirksmode.html
-----------------------------------
Once you have set the doctype, make sure that the scripts , css are browser agnostic, now my current project the client has written code for IE 6 browser and it is a 15 year old web application. To port something like this over here is a list of things to watch out for 1) window.event.keyCode is an IE only event property , to get it working on other browsers use


   if(window.event)
       keyPressed = window.event.keyCode; // IE
   else
       keyPressed = e.which; // Firefox

2) window.event.srcElement works only on safari, chrome and IE. The window.event.srcElement equivalent in firefox is window.event.target.


   if (window.event) e = window.event;
          var srcElement = e.srcElement? e.srcElement : e.target;

3) To get a custom attribute from an element, IE allows you to do something like this

window.event.srcElement.mycustomAttribute

, for a browser agnostic version use

e.target.attributes["ibID"].nodeValue

4) window.event.srcElement.innerText, innerText for a event srcElement works on chrome, IE and safar but on Firefox, you can use window.event.srcElement.textContent

5) window.event.srcElement.parentElement does not work on firefox, use parentNode which is the DOM equivalent and will work on all browsers

6) IE will allow you to set custom attributes for elements for example: document.getElementById('mydiv').mycustomattr=55 , to get and set using DOM properties use setAttribute and getAttribute.

7) The biggest headache is using the document.all.name and document.all(id). This is an IE only property, it is not possible to just do a find and replace on this because the document.all works as both a name and id selector. To explain this further if there is a function that does something like


function replacedoc(idsearch)
{
   var ele = document.all.idsearch;
   ......
   Look for a certain element
}

The above function will take an id for the element to search and look at the entire DOM. The document.all returns an array containing all the scripts and elements. Now to port this over to cross browser, you will have to know what it is you are looking for and how it is represented in the DOM tree.
It is not that simple as you need to spend time to figure that out. Using JQUERY here as an equivalent, you will have to know the following
1. If a single element is fetched based on ID,

a) Use Jquery ID selector - ($('#id'))
document.all.SideMenu can be replaced with $('#SideMenu') Check for Null references before using it

b) Use document.getElementById - document.all.dlglst can be replaced with document.getElementById('dlglst')

2. If a single the element is fetched based on name, use name selector.

3. If it is of the form - "document.all." + name;
where name is a parameter passed - THis queries by both name and ID, use "$(\"[name='" + name + "'], #" + name + "\")[0]" Note $(jquery object)[0] returns the HTML element alone. the variable enclosed by $ contains the entire jquery object.

4. If multiple elements are fetched based on ID, Document.all cannot be replaced with Jquery id selector in all scenarios because jquery id selector returns only the first element

http://api.jquery.com/id-selector/ - Each id value must be used only once within a document. If more than one element has been assigned the same ID, queries that use that ID will only select the first matched element in the DOM. This behavior should not be relied on, however; a document with more than one element using the same ID is invalid
This happens if you have badly written HTML where multiple elements share the same ID and this very common in a lot of web applications.

5) Onpropertychange is a IE specific event and the equivalent is DOMATTRModified which works on all browser. This however does not work as IE. In IE the onpropertychange is fired if an element property including its attributes are modified by script.

6) window.event.cancelBubble,
http://msdn.microsoft.com/en-us/library/ms533545(v=vs.85).aspx
http://javascript.about.com/od/byexample/a/events-cancelbubble-example.htm
http://www.quirksmode.org/js/events_order.html
Call the event’s stopPropagation() method.


   function preventbubble(e)
   {
     if (e && e.stopPropagation) //if stopPropagation method supported
        e.stopPropagation()
     else
        event.cancelBubble=true
   }

Use the jquery StopPropogation method

7) document.body.parentElement.outerHTML , outerHTML is not supported on other browsers, use Jquery one for all browser

  
var x = jQuery.extend(jQuery.Event(e.type), e).target.cloneNode(true);
alert($(x).wrap('<br /><div></div>').parent().html());"

8) createElement, this is a DOM property but what it accepts as its function parameter should be kept in mind. Only IE will accept and element with the > and < tags.


      var oIFrame = document.createElement('<iframe class="doAsyncIFrameClass" name=" + szName + ">&lt;p&gt;');

This should be replaced with


    var oIFrame = document.createElement('IFRAME')
    oIFrame.name = szName;
    oIFrame.Class = 'doAsyncIFrameClass'; 
//(Note case-sensitivity "Class" and not 
"class" works on safari-mac)
    oIFrame.style.display = 'none';

9) document.scripts works only on IE , use document.getElementsByTagName('script')