RESTful Web Services Vs Custom Web Services?

REST "Representational State Transfer" is a type of web services that are resource-centric while Custom Web services are operation-centric.

Here are the details of REST in WCF
http://msdn.microsoft.com/en-us/netframework/cc950529.aspx

ASP.NET MVC - A URL does not equal a page

When you build a traditional ASP.NET Web Forms application or an Active Server Pages application, there is a one-to-one correspondence between a URL and a page. If you request a page named SomePage.aspx from the server, then there had better be a page on disk named SomePage.aspx. If the SomePage.aspx file does not exist, you get an ugly 404 – Page Not Found error.

When building an ASP.NET MVC application, in contrast, there is no correspondence between the URL that you type into your browser’s address bar and the files that you find in your application. In an ASP.NET MVC application, a URL corresponds to a controller action instead of a page on disk.

In a traditional ASP.NET or ASP application, browser requests are mapped to pages. In an ASP.NET MVC application, in contrast, browser requests are mapped to controller actions. An ASP.NET Web Forms application is content-centric. An ASP.NET MVC application, in contrast, is application logic centric.

Detailed MVC here

http://www.asp.net/learn/mvc/

Javascript Functions - Add or Subtract Values

function addthem() {
    //ADD FIRST INPUT VALUE
    var add1 = document.addem.input1.value
    var add1 = parseFloat(add1, 10)
    add1 = (isNaN(add1))?0:add1;
    
    //ADD SECOND INPUT VALUE
    var add2 = document.addem.input2.value
    var add2 = parseFloat(add2, 10)
    add2 = (isNaN(add2))?0:add2;
    
    //ADD THEM TOGETHER
    return eval(add1) + eval(add2);
}

function subtractthem() {
    //SUBTRACT FIRST INPUT VALUE
    var add01 = document.addem.input01.value
    var add01 = parseFloat(add01, 10)
    add01 = (isNaN(add01))?0:add01;

    //SUBTRACT SECOND INPUT VALUE
    var add02 = document.addem.input02.value
    var add02 = parseFloat(add02, 10)
    add02 = (isNaN(add02))?0:add02;
    
    //SUBTRACT THEM TOGETHER
    return eval(add01) + eval(add02);
}

Javascript Function - Round To Certain Decimal Places

Typically, Rounding function approach used by many developers and found easily on internet is:

----------------------------------------------

        function RoundToNdp(X, N) {

            var result = Math.round(X * Math.pow(10, N)) / Math.pow(10, N);

            return result;

        }

----------------------------------------------

Its works fine, but for one of my applications i need to round to 3 decimal places either the values contains zeros after decimal. So, the above function did'nt produce required output in that scenario. So after googling a bit on internet i find the following solution at Link

Function Link here.....

Thats resolves my issue, hopefully helpful for others too.

ASP.NET Interview Questions - Part 1

What is the difference between Server.Transfer and Response.Redirect? 

Server.Transfer() : client is shown as it is on the requesting page only, but the all the content is of the requested page. Data can be persist across the pages using Context.Item collection, which is one of the best way to transfer data from one page to another keeping the page state alive. 

Response.Dedirect() :client knows the physical location (page name and query string as well). Context.Items loses the persistence when navigate to destination page. In earlier versions of IIS, if we wanted to send a user to a new Web page, the only option we had was Response.Redirect. While this method does accomplish our goal, it has several important drawbacks. 

The biggest problem is that this method causes each page to be treated as a separate transaction. Besides making it difficult to maintain your transactional integrity, Response.Redirect introduces some additional headaches. First, it prevents good encapsulation of code. Second, you lose access to all of the properties in the Request object. Sure, there are workarounds, but they're difficult. Finally, Response.Redirect necessitates a round trip to the client, which, on high-volume sites, causes scalability problems. As you might suspect, Server.Transfer fixes all of these problems. It does this by performing the transfer on the server without requiring a roundtrip to the client. 

Response.Redirect sends a response to the client browser instructing it to request the second page. This requires a round-trip to the client, and the client initiates the Request for the second page. Server.Transfer transfers the process to the second page without making a round-trip to the client. It also transfers the HttpContext to the second page, enabling the second page access to all the values in the HttpContext of the first page.

Can you create an app domain?

Yes, We can create user app domain by calling on of the following overload static methods of the System.AppDomain class

1. Public static AppDomain CreateDomain(String friendlyName)

2. Public static AppDomain CreateDomain(String friendlyName, Evidence securityInfo)

3. Public static AppDomain CreateDomain(String friendlyName, Evidence securityInfo, AppDomainSetup info)

4. Public static AppDomain CreateDomain(String friendlyName, Evidence securityInfo, String appBasePath, String appRelativeSearchPath, bool shadowCopyFiles)

Explain < @OutputCache% > and the usage of VaryByParam, VaryByHeader?

OutputCache is used to control the caching policies of an ASP.NET page or user control. To cache a page @OutputCache directive should be defined as follows < %@ OutputCache Duration="100" VaryByParam="none" % >

VaryByParam: A semicolon-separated list of strings used to vary the output cache. By default, these strings correspond to a query string value sent with GET method attributes, or a parameter sent using the POST method. When this attribute is set to multiple parameters, the output cache contains a different version of the requested document for each specified parameter. Possible values include none, *, and any valid query string or POST parameter name.

VaryByHeader: A semicolon-separated list of HTTP headers used to vary the output cache. When this attribute is set to multiple headers, the output cache contains a different version of the requested document for each specified header.

What is Web Gardening? How would using it affect a design?

The Web garden model is configurable through the section of the machine.config file. Notice that the section is the only configuration section that cannot be placed in an application-specific web.config file. This means that the Web garden mode applies to all applications running on the machine. However, by using the node in the machine.config source, you can adapt machine-wide settings on a per-application basis.

Two attributes in the section affect the Web garden model. They are webGarden and cpuMask. The webGarden attribute takes a Boolean value that indicates whether or not multiple worker processes (one per each affinitized CPU) have to be used. The attribute is set to false by default. The cpuMask attribute stores a DWORD value whose binary representation provides a bit mask for the CPUs that are eligible to run the ASP.NET worker process. The default value is -1 (0xFFFFFF), which means that all available CPUs can be used. The contents of the cpuMask attribute is ignored when the webGarden attribute is false. The cpuMask attribute also sets an upper bound to the number of copies of aspnet_wp.exe that are running.

Web gardening enables multiple worker processes to run at the same time. However, you should note that all processes will have their own copy of application state, in-process session state, ASP.NET cache, static data, and all that is needed to run applications. When the Web garden mode is enabled, the ASP.NET ISAPI launches as many worker processes as there are CPUs, each a full clone of the next (and each affinitized with the corresponding CPU). To balance the workload, incoming requests are partitioned among running processes in a round-robin manner. Worker processes get recycled as in the single processor case. Note that ASP.NET inherits any CPU usage restriction from the operating system and doesn't include any custom semantics for doing this.

All in all, the Web garden model is not necessarily a big win for all applications. The more stateful applications are, the more they risk to pay in terms of real performance. Working data is stored in blocks of shared memory so that any changes entered by a process are immediately visible to others. However, for the time it takes to service a request, working data is copied in the context of the process. Each worker process, therefore, will handle its own copy of working data, and the more stateful the application, the higher the cost in performance. In this context, careful and savvy application benchmarking is an absolute must. 

Changes made to the section of the configuration file are effective only after IIS is restarted. In IIS 6, Web gardening parameters are stored in the IIS metabase; the webGarden and cpuMask attributes are ignored.