Dotnet 3.5 interview questions and answers

Interview questions for .Net Framework 4.0

noreply@blogger.com (amitmittal77) — Fri, 09 Sep 2011 08:33:00 +0000

Q. How would you Deploy your old applications with .Net Framework 4.0? Are the Old applications compatible?

Ans. .NET Framework 4 is highly compatible with applications that are built with earlier .NET Framework versions. Though Some Changes have been made to improve security, standards compliance, correctness, reliability, and performance.

To run older applications with .NET Framework 4, you will have to re-compile your applications with the target .NET Framework version specified in the properties for your project in Visual Studio Or you can specify the supported runtime with the Element in an application configuration file. .Net Framework 4 does not automatically use its version of the common language runtime to run applications that are built with earlier versions of the .NET Framework.
Q. Whts is Parallel Computing?

Ans. To take advantage of multiple cores (that is, CPUs or processors) you can parallelize your code so that it will be distributed across multiple processors. In the past, parallelization required low-level manipulation of threads and locks, but Visual Studio 2010 and the .NET Framework 4 enhances the support for parallel programming by providing a new runtime, new class library types, and new diagnostic tools. These features simplify parallel development so that you can write efficient, fine-grained, and scalable parallel code in a natural idiom without having to work directly with threads or the thread pool.

The new System.Threading.Tasks namespace and other related types support this new model.

Q. What is BigInteger and When would you use that?

Ans. BigInteger, which is a part of System.Numerics Namespace is a great enhancement over Byte and Int32 data types. It is a nonprimitive integral type that supports arbitrarily large signed integers. Unlike Byte and Int32 types, BigInteger does not include a Minvalue and MaxValue property, so can be used to store large integer values.

Q. What other than BigInteger has been introduced in System.Numerics Namespace?

Ans. Complex types, which represents a complex number has been Introduced. a complex number is a number in the form a + bi, where a is the real part, and b is the imaginary part.

Q. How do you assign a Value to a Complex Number.

Ans. You can assign a value to a complex number in few different ways.
1. By passing two Double values to its constructor. The first value represents the real part of the complex number, and the second value represents its imaginary part.
2. By assigning a Byte, SByte, Int16, UInt16, Int32, UInt32, Int64, UInt64, Single, or Double value to a Complex object. The value becomes the real part of the complex number, and its imaginary part equals 0.

E.g Complex c1 = new Complex(12, 6);
Console.WriteLine(c1);
OutPut - (12, 6)

Q. How has exception hand changed in .Net Framework 4.0

Ans. A New Namespace System.Runtime.ExceptionServices has been introduced which provides classes for advanced exception handling. It has introduced the following classes
1. HandleProcessCorruptedStateExceptionsAttribute Class - Enables managed code to handle exceptions that indicate a corrupted process state.So,If you want to compile an application in the .NET Framework 4 and handle corrupted state exceptions, you can apply this attribute to the method that handles the corrupted state exception.
2.FirstChanceExceptionEventArgs Class -Provides data for the notification event that is raised when a managed exception first occurs, before the common language runtime begins searching for event handlers.

Q. What are the major improvements provided by the common language runtime and the base class libraries?

Ans. Brief about the Improvements -

Diagnostics and Performance - Starting with the .NET Framework 4, you can get processor usage and memory usage estimates per application domain.

Garbage Collection - This feature replaces concurrent garbage collection in previous versions and provides better performance.

Code Contracts - Code contracts let you specify contractual information that is not represented by a method's or type's signature alone. The new System.Diagnostics.Contracts namespace contains classes that provide a language-neutral way to express coding assumptions in the form of preconditions, postconditions, and object invariants.

Design-Time-Only Interop Assemblies - You no longer have to ship primary interop assemblies (PIAs) to deploy applications that interoperate with COM objects. In the .NET Framework 4, compilers can embed type information from interop assemblies, selecting only the types that an application (for example, an add-in) actually uses.

Dynamic Language Runtime - The dynamic language runtime (DLR) is a new runtime environment that adds a set of services for dynamic languages to the CLR. The DLR makes it easier to develop dynamic languages to run on the .NET Framework and to add dynamic features to statically typed languages. To support the DLR, the new System.Dynamic namespace is added to the .NET Framework.

Covariance and Contravariance - Several generic interfaces and delegates now support covariance and contravariance.

BigInteger and Complex Numbers - The new System.Numerics.BigInteger structure is an integer data type that can store fairly large number as it has no upper and lower bound values.Complex types represents a complex number of form a + bi. IT supports arithmetic and trigonometric operations with complex numbers.

Tuples - The .NET Framework 4 provides the System..::.Tuple class for creating tuple objects that contain structured data.

File System Enumeration Improvements - You can now enumerate directories and files by using methods that return an enumerable collection of strings of their names.ou can also use methods that return an enumerable collection of DirectoryInfo, FileInfo, or FileSystemInfo objects.

Memory-Mapped Files - A memory-mapped file contains the contents of a file in virtual memory and is an application’s logical address space. So You can use memory-mapped files to edit very large files and to create shared memory for interprocess communication.

64-Bit Operating Systems and Processes - You can identify 64-bit operating systems and processes with the Environment.Is64BitOperatingSystem and Environment.Is64BitProcess properties.

ASP.NET Page Life Cycle

noreply@blogger.com (amitmittal77) — Wed, 13 Apr 2011 09:42:00 +0000

Page_Init -> During this phase, the server creates an instance of the server control. i.e. various controls are
intialised to default values. but viewstate doesn't exists.

ViewState Load method -> Loads viewstate object.

Load postback Data -> Loads the data posted back incase of isPostback is true.

Page_Load() -> During this phase, the instance of the control is loaded onto the page object in which it is
defined

Pre_Render() -> During this phase, the control is updated with the changes made to it. This prepares the control for rendering.

Save() -> During this phase, the state information of the control is saved. For example, if a value is set for the
control during the Load event, it is embedded in the HTML tag that will be returned to the browser.

SaveViewState()-> Viesstate information is saved.

Rendering()-> During this phase, the server creates the corresponding HTML tag for the control.

Disposing()-> During this phase, all cleanup tasks, such as closing files and database connections opened by the control are performed.

Unloading()-> During this phase, all cleanup tasks, such as destroying the instances of server control are performed.
This is the final event in the life cycle of a server

Factory method and Abstract factory method live example

noreply@blogger.com (amitmittal77) — Wed, 13 Apr 2011 09:31:00 +0000

http://userpages.umbc.edu/~tarr/dp/lectures/Factory.pdf

ASP.NET 4.0 Interview questions

noreply@blogger.com (amitmittal77) — Wed, 29 Sep 2010 12:48:00 +0000

Ques 1. What is new with ASP.Net 4 WebForms ?

Ans. Some of the Features are:

. Ability to Set Metatags.
. More control over view state.
. Added and Updated browser definition files.
. ASP.Net Routing.
. The ability to Persist Selected rows in data Control.
. More control over rendered HTML in FormView and ListView Controls.
. Filtering Support for datasource Controls.

Ques 2. What is machine.config file and how do you use it in ASP.Net 4.0?

Ans. Machine.Config file is found in the "CONFIG" subfolder of your .NET Framework install directory (c:\WINNT\Microsoft.NET\Framework\{Version Number}\CONFIG on Windows 2000 installations). It contains configuration settings for machine-wide assembly binding, built-in remoting channels, and ASP.NET.

In .the NET Framework 4.0, the major configuration elements(that use to be in web.config) have been moved to the machine.config file, and the applications now inherit these settings. This allows the Web.config file in ASP.NET 4 applications either to be empty or to contain just the following lines.

Q. What is RedirectPermanent in ASP.Net 4.0?
Ans. In earlier Versions of .Net, Response.Redirect was used, which issues an HTTP 302 Found or temporary redirect response to the browser (meaning that asked resource is temporarily moved to other location) which inturn results in an extra HTTP round trip. ASP.NET 4.0 however, adds a new RedirectPermanent that Performs a permanent redirection from the requested URL to the specified URL. and returns 301 Moved Permanently responses.
e.g. RedirectPermanent("/newpath/foroldcontent.aspx");

Ques 3. How will you specify what version of the framework your application is targeting?

Ans. In Asp.Net 4 a new element "targetFramework" of compilation tag (in Web.config file) lets you specify the framework version in the webconfig file as

<?xml version="1.0"?>
<configuration>
<system.web>
<compilation targetFramework="4.0" />
</system.web>
</configuration>

It only lets you target the .NET Framework 4.0 and later verisons.

Ques 4. What is Microsoft Ajax Library.

Ans. Microsoft Ajax Library is a client-only JavaScript library that is compatible with all modern browsers, including Internet Explorer, Google Chrome, Apple Safari, and Mozilla Firefox.Because the Microsoft Ajax Library is a client-only JavaScript library, you can use the library with both ASP.NET Web Forms and ASP.NET MVC applications. You can also create Ajax pages that consist only of HTML.

Ques 5. What are the Changes in CheckBoxList and RadioButtonList Control ?

Ans. In ASP.NET 4, the CheckBoxList and RadioButtonList controls support two new values for the RepeatLayout property, OrderedList(The content is rendered as li elements within an ol element) and UnorderedList(The content is rendered as li elements within a ul element.)

Ques 6. Whats Application Warm-Up Module?

Ans. We can set-up a Warm-Up module for warming up your applications before they serve their first request.Instead of writing custom code, you specify the URLs of resources to execute before the Web application accepts requests from the network. This warm-up occurs during startup of the IIS service (if you configured the IIS application pool as AlwaysRunning) and when an IIS worker process recycles. During recycle, the old IIS worker process continues to execute requests until the newly spawned worker process is fully warmed up, so that applications experience no interruptions or other issues due to unprimed caches.

Dotnet 4.0 videos

noreply@blogger.com (amitmittal77) — Thu, 16 Sep 2010 11:26:00 +0000

Find the good videos link for .net 4.0 below

http://www.msdev.com/Directory/SeriesDescription.aspx?CourseId=111

Dotnet interview question for Senior Developers/Architects

noreply@blogger.com (amitmittal77) — Mon, 16 Aug 2010 10:20:00 +0000

Ques 1:     What’s wrong with a line like this? DateTime.Parse(myString);
Ans : parameters are missing as mention below
    public static DateTime Parse(
        string s,
        IFormatProvider provider,
        DateTimeStyles styles
    )

Ques 2: What are PDBs? Where must they be located for debugging to work?
Ans : A program database (PDB) files holds debugging and project state information that allows incremental linking of debug configuration of your program.There are several different types of symbolic debugging information. The default type for Microsoft compiler is the so-called PDB file. The compiler setting for creating this file for Visual Basic/C#/JScript .NET program with /debug.
A PDB file is a separate file, placed by default in the Debug project subdirectory, that has the same name as the executable file with the extension .pdb. The PDB file can be useful to display the detailed stack trace with source files and line numbers.

Ques 3: Write a standard lock() plus “double check” to create a critical section around a variable access.
Ans : Code given below
    — bool notLocked = true;
    — if (notLocked)
    — {
    — — lock (typeof(lockingObject))
    — — {
    — — — if (notLocked)
    — — — {
    — — — — notLocked = false;
    — — — — foo = lockingObject;
    — — — — notLocked = true;
    — — — }
    — — }
    — }
    or
    class Singleton
    {
    public static Singleton GetInstance()
    {
    if (_Instance == null)
    {
    lock(_Instance)
    {
    if (_Instance == null)
    {
    _Instance = new Singleton();
    }
    }
    }
    return _Instance;
    }
    private static volatile Singleton _Instance = null;
    protected Singleton(){}
    }

Ques 4:    What is FullTrust? Do GAC’ed assemblies have FullTrust?
Ans :     Before the .NET Framework existed, Windows had two levels of trust for downloaded code. This old model was a binary trust model. You only had two choices: Full Trust, and No Trust. The code could either do anything you could do, or it wouldn’t run at all. The permission sets in .NET include FullTrust, SkipVerification, Execution, Nothing, LocalIntranet, Internet and Everything. Full Trust Grants unrestricted permissions to system resources. Fully trusted code run by a normal, nonprivileged user cannot do administrative tasks, but can access any resources the user can access, and do anything the user can do. From a security standpoint, you can think of fully trusted code as being similar to native, unmanaged code, like a traditional ActiveX control.
GAC assemblies are granted FullTrust. In v1.0 and 1.1, the fact that assemblies in the GAC seem to always get a FullTrust grant is actually a side effect of the fact that the GAC lives on the local machine. If anyone were to lock down the security policy by changing the grant set of the local machine to something less than FullTrust, and if your assembly did not get extra permission from some other code group, it would no longer have FullTrust even though it lives in the GAC.
FullTrust is a named permission set. FullTrust means executing code has full access to all resources
FullTrust means all .NET security permissions are granted to the assembly. GAC assemblies have FullTrust by default, but that can be changed by the user’s security policy.

SOA: Address Scalability Bottlenecks with Distributed Caching

noreply@blogger.com (amitmittal77) — Thu, 22 Jul 2010 10:13:00 +0000

SOA allows users to distribute applications to multiple locations, multiple departments within an organization, and multiple businesses across the Internet. Plus, it permits reuse of existing code within an organization and, more importantly, collaboration among different business units.
A SOA application is usually deployed in a server farm in a load-balanced environment. The goal is to allow the application to handle as much load as you throw at it. The question thus becomes: What are some of the considerations you should have in mind for improving both performance and scalability of your SOA application?
Although SOA, by design, is intended to provide scalability, there are many issues you must address before you can truly achieve scalability. Some of these issues involve how you code your SOA application, but the most important bottlenecks often relate to how you store and access your data. I’ll explore those issues and provide some solutions in this article.

Find Scalability Bottlenecks

A true SOA application should scale easily as far as the application architecture is concerned. A SOA application has two components: service components and client applications. The client application may be a Web application, another service or any other application that relies on the SOA service components to do its job.
One of the key ideas behind SOA is to break up the application into small chunks so these components can be run on multiple servers as separate services.
Ideally, these services should be stateless as much as possible. Stateless means they don’t retain any data with them across multiple calls, allowing you to run the services on multiple computers. There’s no dependence on where the data was the last time, so there’s no data being kept on any particular server across multiple service calls.
As a result, the architecture of SOA applications is inherently scalable. It can easily grow onto multiple servers and across datacenters. However, as with every other application, SOA applications do have to deal with the data, and that can be a problem. This data access becomes the scalability bottleneck. Bottlenecks typically involve the application data, which is stored in some database, usually a relational database. If the SOA application is using session data, the storage of that data is also another potential scalability bottleneck.
One SOA application relying on other SOA applications is another likely area of poor performance and scalability. Say your application calls one service to do its job, but that service calls out to other services. Those services may be on the same intranet or across the WAN in other locations. Such a data trip can be costly. You can’t scale the application effectively if you’re making those calls over and over again, and these are areas where scalability bottlenecks occur, as shown in Figure 1.

Figure 1 SOA Architecture with Potential Scalability Bottlenecks

Code for Performance

There are a number of programming techniques that can help improve your SOA application performance.
One thing you can do is design your application to use “chunky” Web method calls. Don’t make frequent calls between the SOA client application and the SOA service layer. There’s usually a great distance between those because they’re not running on the same computer or even in the same datacenter. The fewer calls you make from the client application to the service layers, the better the performance. Chunky calls do more work in one call than multiple calls to do the same work.
Another useful technique is to employ the asynchronous Web method calls supported by the Microsoft .NET Framework. This allows your SOA client application to continue doing other things while the Web method of the service layer is being called and is executing.
The cost of serialization is another aspect to factor in so you don’t serialize any unnecessary data. You should only send data that is required back and forth, allowing you to be highly selective about the type of serialization you want to perform.

Choose the Right Communication Protocol

For SOA applications developed in Windows Communication Foundation (WCF), there are three different protocols that let SOA clients talk to SOA services. These are HTTP, TCP and named pipes.
If both your client and your service are developed in WCF and are running on the same machine, named pipes offer the best performance. A named pipe uses shared memory between client and server processes.
TCP is good if both SOA client and server are developed in WCF, but are running on different computers in the same intranet. TCP is faster than HTTP, but a TCP connection stays open across multiple calls and therefore you can’t automatically route each WCF call to a different server. By employing the NetTcpBinding option that uses connection pools, you can expire TCP connections frequently to restart them so they get routed to a different server, thereby giving you a form of load balancing.
Please note that TCP can’t work reliably across the WAN because socket connections tend to break frequently. If your SOA client and service are not based on WCF or they’re hosted in different locations, then HTTP is your best option. Although HTTP is not as fast as TCP, it offers great scalability due to load balancing.

Use Caching to Improve Client Performance

Thoughtful use of caching can really improve SOA client performance. When a SOA client makes a Web method call to the service layer, you can cache the results at the client application’s end. Then, the next time this SOA client needs to make the same Web method call, it gets that data from the cache instead.
By caching data at the client end, the SOA client application reduces the number of calls it’s going to make to the service layer. This step boosts performance because it didn’t have to make an expensive SOA service call. It also reduces overall pressure on the service layer and improves scalability. Figure 2 shows a WCF client using caching.
Figure 2 WCF Client Caching

using System;
using Client.EmployeeServiceReference;

using Alachisoft.NCache.Web.Caching;

namespace Client {
  class Program {
    static string _sCacheName = "mySOAClientCache";
    static Cache _sCache = NCache.InitializeCache(_sCacheName);

    static void Main(string[] args) {
      EmployeeServiceClient client = 
        new EmployeeServiceClient("WSHttpBinding_IEmployeeService");

      string employeeId = "1000";
      string key = "Employee:EmployeeId:" + employeeId;
            
      // first check the cache for this employee
      Employee emp = _sCache.Get(key);

      // if cache doesn't have it then make WCF call
      if (emp == null) {
        emp = client.Load("1000");

        // Now add it to the cache for next time
       _sCache.Insert(key, emp);
      }
    }
  }
}

In many situations, your client is physically removed from the service layer and is running across the WAN. In that case, you have no way of knowing whether the data you have cached has been updated. Therefore, you have to identify only those data elements for caching that you feel will not change for at least a few minutes to perhaps a few hours, depending on your application. You can then specify expiration for these data elements in the cache so the cache will automatically remove them at that time. This helps ensure that cached data is always fresh and correct.

Distributed Caching for Service Scalability

The real scalability gains through caching are found in the SOA service layer. Scalability bottlenecks are not always removed despite many of the programming techniques mentioned already because the major scalability bottlenecks are with data storage and access. Services often live in a load-balanced server farm, allowing the service itself to scale quite nicely—except the data storage can’t scale in the same manner. Data storage thus becomes the SOA bottleneck.
You can scale the service layer by adding more servers to the server farm, increasing the computing capacity through these additional application servers. But all those SOA transactions still deal with some data. That data has to be stored somewhere, and that data storage can easily become the bottleneck.
This data storage barrier to scalability can be improved at multiple levels. SOA services deal with two types of data. One is session-state data and the other is application data that resides in the database (see Figure 3). Both cause scalability bottlenecks.

Figure 3 How Distributed Caching Reduces Pressure on a Database

Storing Session State in a Distributed Cache

One of the limitations of the default session-state storage is that it does not support Web farms because it is in-memory storage living inside the WCF service process. A much better alternative is to use ASP.NET compatibility mode and the ASP.NET session state in WCF services. This allows you to specify OutProc storage including StateServer, SqlServer, or a distributed cache as session state storage.
Enabling ASP.NET compatibility mode is a two-step process. First, you have to specify ASP.NET compatibility in your class definition, as shown in Figure 4. Then you have to specify this in your app.config file, as shown in Figure 5. Notice that Figure 4 also demonstrates how to specify a distributed cache as your SessionState storage in the same web.config file.
Figure 4 Specifying ASP.NET Compatibility for WCF Services in Code

using System;
using System.ServiceModel;
using System.ServiceModel.Activation;

namespace MyWcfServiceLibrary {
  [ServiceContract]
  public interface IHelloWorldService {
    [OperationContract]
    string HelloWorld(string greeting);
  }

  [ServiceBehavior (InstanceContextMode = 
    InstanceContextMode.PerCall)]
  [AspNetCompatibilityRequirements (RequirementsMode = 
    AspNetCompatibilityRequirementsMode.Allowed)]

  public class HelloWorldService : IHelloWorldService {
    public string HelloWorld(string greeting) {
      return string.Format("HelloWorld: {0}", greeting);
    }
  }
}

Figure 5 Specifying ASP.NET Compatibility for WCF Services in Config


  
    
      mode="Custom" 
      customProvider="DistCacheSessionProvider" 
      timeout="20">
      
        
          type="Vendor.DistCache.Web.SessionState.SessionStoreProvider"/>
      
    
    
  

  
    
    
      aspNetCompatibilityEnabled="true"/>

StateServer and SqlServer session storage options do not scale well and, in the case of StateServer, it is also a single point of failure. A distributed cache is a much better alternative because it scales nicely and replicates sessions to multiple servers for reliability.

Caching Application Data

Application data is by far the heaviest data usage in a WCF service, and its storage and access is a major scalability bottleneck. To address this scalability-bottleneck problem, you can use distributed caching in your SOA service-layer implementation. A distributed cache is used to cache only a subset of the data that is in the database based on what the WCF service needs in a small window of a few hours.
Additionally, a distributed cache gives a SOA application a significant scalability boost because this cache can scale out as a result of the architecture it employs. It keeps things distributed across multiple servers—and still gives your SOA application one logical view so you think it’s just one cache. But the cache actually lives on multiple servers and that’s what allows the cache to really scale. If you use distributed caching in between the service layer and the database, you’ll improve performance and scalability of the service layer dramatically.
The basic logic to implement is that, before going to the database, check to see if the cache already has the data. If it does, take it from the cache. Otherwise, go to the database to fetch the data and put it in the cache for next time. Figure 6 shows an example.
Figure 6 WCF Service Using Caching

using System.ServiceModel;
using Vendor.DistCache.Web.Caching;

namespace MyWcfServiceLibrary {
  [ServiceBehavior]
  public class EmployeeService : IEmployeeService {
    static string _sCacheName = "myServiceCache";
    static Cache _sCache = 
      DistCache.InitializeCache(_sCacheName);

    public Employee Load(string employeeId) {
      // Create a key to lookup in the cache.
      // The key for will be like "Employees:PK:1000".
      string key = "Employee:EmployeeId:" + employeeId;

      Employee employee = (Employee)_sCache[key];
      if (employee == null) {
        // item not found in the cache. 
        // Therefore, load from database.
        LoadEmployeeFromDb(employee);

        // Now, add to cache for future reference.
       _sCache.Insert(key, employee, null,
          Cache.NoAbsoluteExpiration,
          Cache.NoSlidingExpiration,
          CacheItemPriority.Default);
      }

      // Return a copy of the object since 
      // ASP.NET Cache is InProc.
      return employee;
    }
  }
}

By caching application data, your WCF service saves a lot of expensive database trips and instead finds the frequently used transactional data in a nearby in-memory cache.

Expiring Cached Data

Expirations let you specify how long data should stay in the cache before the cache automatically removes it. There are two types of expirations you can specify: absolute-time expiration and sliding- or idle-time expiration.
If the data in your cache also exists in the database, you know that this data can be changed in the database by other users or applications that may not have access to your cache. When that happens, the data in your cache becomes stale, which you do not want. If you’re able to make a guess as to how long you think it’s safe for this data to be kept in the cache, you can specify absolute-time expiration. You can say something like “expire this item 10 minutes from now” or “expire this item at midnight today.” At that time, the cache expires this item:

using Vendor.DistCache.Web.Caching;
...
// Add an item to ASP.NET Cache with absolute expiration
_sCache.Insert(key, employee, null, 
  DateTime.Now.AddMinutes(2),
  Cache.NoSlidingExpiration, 
  CacheItemPriority.Default, null);

You can also use idle-time or sliding-time expiration to expire an item if nobody uses it for a given period. You can specify something like “expire this item if nobody reads or updates it for 10 minutes.” This is useful when your application needs the data temporarily and when your application is done using it, you want the cache to automatically expire it. ASP.NET compatibility-mode session state is a good example of idle-time expiration.
Notice that absolute-time expiration helps you avoid situations where the cache has an older or stale copy of the data than the master copy in the database. On the other hand, idle-time expiration serves a totally different purpose. It’s meant really to simply clean up the cache once your application no longer needs the data. Instead of having your application keep track of this clean up, you let the cache take care of it.

Managing Data Relationships in the Cache

Most data comes from a relational database, and even if it’s not coming from a relational database, it’s relational in nature. For example, you’re trying to cache a customer object and an order object and both objects are related. A customer can have multiple orders.
When you have these relationships, you need to be able to handle them in a cache. That means the cache should know about the relationship between a customer and an order. If you update or remove the customer from the cache, you may want the cache to automatically remove the order object from the cache. This helps maintain data integrity in many situations.
If a cache can’t keep track of these relationships, you’ll have to do it yourself—and that makes your application more cumbersome and complex. It’s a lot easier if you just tell the cache when you add the data about this relationship. The cache then knows if that customer is ever updated or removed, the order also has to be removed.
ASP.NET has a useful feature called CacheDependency that allows you to keep track of relationships between different cached items. Some commercial caches also have this feature. Here’s an example of how ASP.NET lets you keep track of relationships among cached items:

using Vendor.DistCache.Web.Caching;
...
public void CreateKeyDependency() {
  Cache["key1"] = "Value 1";

  // Make key2 dependent on key1.
  String[] dependencyKey = new String[1];
  dependencyKey[0] = "key1";
  CacheDependency dep1 = 
    new CacheDependency(null, dependencyKey);

  _sCache.Insert("key2", "Value 2", dep2);
}

This is multi-layer dependency, meaning A can depend on B and B can depend on C. So, if your application updates C, both A and B have to be removed from the cache.

Synchronizing the Cache with a Database

The need for database synchronization arises because the database is really being shared across multiple applications, and not all of those applications have access to your cache. If your WCF service application is the only one updating the database and it can also easily update the cache, you probably don’t need the database-synchronization capability.
But, in a real-life environment, that’s not always the case. Third-party applications update data in the database and your cache becomes inconsistent with the database. Synchronizing your cache with the database ensures that the cache is always aware of these database changes and can update itself accordingly.
Synchronizing with the database usually means invalidating the related cached item from the cache so the next time your application needs it, it will have to fetch it from the database because the cache doesn’t have it.
ASP.NET has a SqlCacheDependency feature that allows you to synchronize the cache with SQL Server 2005, SQL Server 2008 or Oracle 10g R2 and later—basically any database that supports the CLR. Some of the commercial caches also provide this capability. Figure 7 shows an example of using SQL dependency to synchronize with a relational database.
Figure 7 Synchronizing Data via SQL Dependency

using Vendor.DistCache.Web.Caching;
using System.Data.SqlClient;
...

public void CreateSqlDependency(
  Customers cust, SqlConnection conn) {

  // Make cust dependent on a corresponding row in the
  // Customers table in Northwind database

  string sql = "SELECT CustomerID FROM Customers WHERE ";
  sql += "CustomerID = @ID";
  SqlCommand cmd = new SqlCommand(sql, conn);
  cmd.Parameters.Add("@ID", System.Data.SqlDbType.VarChar);
  cmd.Parameters["@ID"].Value = cust.CustomerID;

  SqlCacheDependency dep = new SqlCacheDependency(cmd);
  string key = "Customers:CustomerID:" + cust.CustomerID;
_  sCache.Insert(key, cust, dep);
}

One capability that ASP.NET does not provide, but some commercial solutions do, is polling-based database synchronization. This is handy if your DBMS doesn’t support the CLR and you can’t benefit from SqlCacheDependency. In that case, it would be nice if your cache could poll your database at configurable intervals and detect changes in certain rows in a table. If those rows have changed, your cache invalidates their corresponding cached items.

Enterprise Service Bus for SOA Scalability

Enterprise Service Bus (ESB) is an industry concept where many technologies are used to build it. An ESB is an infrastructure for Web services that mediates communication among components. Put plainly, an ESB is a simple and powerful way for multiple applications to share data asynchronously. It is not meant to be used across organizations or even across a WAN, however. Usually SOA applications are by design broken up into multiple pieces, so when they need to share data with each other, ESB is a powerful tool.
There are many ways to build an ESB. Figure 8 shows an example of an ESB created with a distributed cache. Multiple loosely coupled applications or service components can use it to share data with each other in real time and across the network.

Figure 8 An ESB Created with a Distributed Cache
A distributed cache by its nature spans multiple computers. This makes it highly scalable, which meets the first criterion of an ESB. In addition, a good distributed cache replicates all its data intelligently to ensure that no data loss occurs if any cache server goes down. (I’ll discuss this later.) Finally, a good distributed cache provides intelligent event-propagation mechanisms.
There are two types of events that a distributed cache must provide to be fit for an ESB. First, any client application of the ESB should be able to register interest in a data element on the ESB so if anybody modifies or deletes it, the client application is notified immediately. Second, the cache should allow client applications to fire custom events into the ESB so all other applications connected to the ESB that are interested in this custom event are immediately notified, no matter where they are on the network (of course, within the intranet).
With the help of an ESB, a lot of data exchange that would otherwise require SOA calls from one application to another can be done very easily through the ESB. Additionally, asynchronous data sharing is something a simple WCF service is not designed to do easily. But the ESB makes this job seamless. You can easily create situations where data is even pushed to the clients of the ESB if they have shown interest in it up front.

Cache Scalability and High Availability

Caching topology is a term used to indicate how data is actually stored in a distributed cache. There are various caching topologies that are designed to fit different environments. I’ll discuss three here: partitioned cache, partitioned-replicated cache and replicated cache.
Partitioned and partitioned-replicated are two caching topologies that play major roles in the scalability scenario. In both topologies, the cache is broken up into partitions, then each partition stored in different cache servers in the cluster. Partitioned-replicated cache has a replica of each partition stored on a different cache server.
Partitioned and partitioned-replicated caches are the most scalable topology for transactional data caching (where writes to the cache are as frequent as reads) because, as you add more cache servers to the cluster, you’re not only increasing the transaction capacity, you’re also increasing the storage capacity of the cache because all those partitions together form the entire cache.
A third caching topology, replicated cache, copies the entire cache to each cache server in the cache cluster. This means the replicated cache provides high availability and is good for read-intensive usage. It is not good for frequent updates, however, because updates are done to all copies synchronously and are not as fast as with other caching topologies.
As shown in Figure 9, partitioned-replicated cache topology is ideal for a combination of scalability and high availability. You don’t lose any data because of the replicas of each partition.

Figure 9 Partitioned-Replicated Caching Topology for Scalability
High availability can be further enhanced through dynamic cache clustering, which is the ability to add or remove cache servers from the cache cluster at run time without stopping the cache or the client applications. Because a distributed cache runs in a production environment, high availability is an important feature requirement.

Next Steps

As you’ve seen, an SOA application can’t scale effectively when the data it uses is kept in a storage that is not scalable for frequent transactions. This is where distributed caching really helps.
Distributed caching is a new concept but rapidly gaining acceptance among .NET developers as a best practice for any high-transaction application. The traditional database servers are also improving but without distributed caching, they can’t meet the exploding demand for scalability in today’s applications.

Reference URL : http://msdn.microsoft.com/en-us/magazine/ff714590.aspx

New C# Features in the .NET Framework 4

noreply@blogger.com (amitmittal77) — Tue, 20 Jul 2010 12:34:00 +0000

Covariance and Contravariance

Covariance and contravariance are best introduced with an example, and the best is in the framework. In System.Collections.Generic, IEnumerable and IEnumerator represent, respectively, an object that’s a sequence of T’s and the enumerator (or iterator) that does the work of iterating the sequence. These interfaces have done a lot of heavy lifting for a long time, because they support the implementation of the foreach loop construct. In C# 3.0, they became even more prominent because of their central role in LINQ and LINQ to Objects—they’re the .NET interfaces to represent sequences.
So if you have a class hierarchy with, say, an Employee type and a Manager type that derives from it (managers are employees, after all), then what would you expect the following code to do?

IEnumerable ms = GetManagers();
IEnumerable es = ms;

It seems as though one ought to be able to treat a sequence of Managers as though it were a sequence of Employees. But in C# 3.0, the assignment will fail; the compiler will tell you there’s no conversion. After all, it has no idea what the semantics of IEnumerable are. This could be any interface, so for any arbitrary interface IFoo, why would an IFoo be more or less substitutable for an IFoo?
In C# 4.0, though, the assignment works because IEnumerable, along with a few other interfaces, has changed, an alteration enabled by new support in C# for covariance of type parameters.
IEnumerable is eligible to be more special than the arbitrary IFoo because, though it’s not obvious at first glance, members that use the type parameter T (GetEnumerator in IEnumerable and the Current property in IEnumerator) actually use T only in the position of a return value. So you only get a Manager out of the sequence, and you never put one in.
In contrast, think of List. Making a List substitutable for a List would be a disaster, because of the following:

List ms = GetManagers();
List es = ms; // Suppose this were possible
es.Add(new EmployeeWhoIsNotAManager()); // Uh oh

As this shows, once you think you’re looking at a List, you can insert any employee. But the list in question is actually a List, so inserting a non-Manager must fail. You’ve lost type safety if you allow this. List cannot be covariant in T.
The new language feature in C# 4.0, then, is the ability to define types, such as the new IEnumerable, that admit conversions among themselves when the type parameters in question bear some relationship to one another. This is what the .NET Framework developers who wrote IEnumerable used, and this is what their code looks like (simplified, of course):

public interface IEnumerable { /* ... */ }

Notice the out keyword modifying the definition of the type parameter, T. When the compiler sees this, it will mark T as covariant and check that, in the definition of the interface, all uses of T are up to snuff (in other words, that they’re used in out positions only—that’s why this keyword was picked).
Why is this called covariance? Well, it’s easiest to see when you start to draw arrows. To be concrete, let’s use the Manager and Employee types. Because there’s an inheritance relationship between these classes, there’s an implicit reference conversion from Manager to Employee:
Manager → Employee
And now, because of the annotation of T in IEnumerable, there’s also an implicit reference conversion from IEnumerable to IEnumerable. That’s what the annotation provides for:
IEnumerable → IEnumerable
This is called covariance, because the arrows in each of the two examples point in the same direction. We started with two types, Manager and Employee. We made new types out of them, IEnumerable and IEnumerable. The new types convert the same way as the old ones.
Contravariance is when this happens backward. You might anticipate that this could happen when the type parameter, T, is used only as input, and you’d be right. For example, the System namespace contains an interface called IComparable, which has a single method called CompareTo:

public interface IComparable { 
  bool CompareTo(T other); 
}

If you have an IComparable, you should be able to treat it as though it were an IComparable, because the only thing you can do is put Employees in to the interface. Because a manager is an employee, putting a manager in should work, and it does. The in keyword modifies T in this case, and this scenario functions correctly:

IComparable ec = GetEmployeeComparer();
IComparable mc = ec;

This is called contravariance because the arrow got reversed this time:
Manager → Employee
IComparable ← IComparable
So the language feature here is pretty simple to summarize: You can add the keyword in or out whenever you define a type parameter, and doing so gives you free extra conversions. There are some limitations, though.
First, this works with generic interfaces and delegates only. You can’t declare a generic type parameter on a class or struct in this manner. An easy way to rationalize this is that delegates are very much like interfaces that have just one method, and in any case, classes would often be ineligible for this treatment because of fields. You can think of any field on the generic class as being both an input and an output, depending on whether you write to it or read from it. If those fields involve type parameters, the parameters can be neither covariant nor contravariant.
Second, whenever you have an interface or delegate with a covariant or contravariant type parameter, you’re granted new conversions on that type only when the type arguments, in the usage of the interface (not its definition), are reference types. For instance, because int is a value type, the IEnumerator doesn’t convert to IEnumerator , even though it looks like it should:
IEnumerator IEnumerator
The reason for this behavior is that the conversion must preserve the type representation. If the int-to-object conversion were allowed, calling the Current property on the result would be impossible, because the value type int has a different representation on the stack than an object reference does. All reference types have the same representation on the stack, however, so only type arguments that are reference types yield these extra conversions.
Very likely, most C# developers will happily use this new language feature—they’ll get more conversions of framework types and fewer compiler errors when using some types from the .NET Framework (IEnumerable, IComparable, Func, Action, among others). And, in fact, anyone designing a library with generic interfaces and delegates is free to use the new in and out type parameters when appropriate to make life easier for their users.
By the way, this feature does require support from the runtime—but the support has always been there. It lay dormant for several releases, however, because no language made use of it. Also, previous versions of C# allowed some limited conversions that were contravariant. Specifically, they let you make delegates out of methods that had compatible return types. In addition, array types have always been covariant. These existing features are distinct from the new ones in C# 4.0, which actually let you define your own types that are covariant and contravariant in some of their type parameters.

Dynamic Dispatch

On to the interop features in C# 4.0, starting with what is perhaps the biggest change.
C# now supports dynamic late-binding. The language has always been strongly typed, and it continues to be so in version 4.0. Microsoft believes this makes C# easy to use, fast and suitable for all the work .NET programmers are putting it to. But there are times when you need to communicate with systems not based on .NET.
Traditionally, there were at least two approaches to this. The first was simply to import the foreign model directly into .NET as a proxy. COM Interop provides one example. Since the original release of the .NET Framework, it has used this strategy with a tool called TLBIMP, which creates new .NET proxy types you can use directly from C#.
LINQ-to-SQL, shipped with C# 3.0, contains a tool called SQLMETAL, which imports an existing database into C# proxy classes for use with queries. You’ll also find a tool that imports Windows Management Instrumentation (WMI) classes to C#. Many technologies allow you to write C# (often with attributes) and then perform interop using your handwritten code as basis for external actions, such as LINQ-to-SQL, Windows Communication Foundation (WCF) and serialization.
The second approach abandons the C# type system entirely—you embed strings and data in your code. This is what you do whenever you write code that, say, invokes a method on a JScript object or when you embed a SQL query in your ADO.NET application. You’re even doing this when you defer binding to run time using reflection, even though the interop in that case is with .NET itself.
The dynamic keyword in C# is a response to dealing with the hassles of these other approaches. Let’s start with a simple example—reflection. Normally, using it requires a lot of boilerplate infrastructure code, such as:

object o = GetObject();
Type t = o.GetType();
object result = t.InvokeMember("MyMethod", 
  BindingFlags.InvokeMethod, null, 
  o, new object[] { });
int i = Convert.ToInt32(result);

With the dynamic keyword, instead of calling a method MyMethod on some object using reflection in this manner, you can now tell the compiler to please treat o as dynamic and delay all analysis until run time. Code that does that looks like this:

dynamic o = GetObject();
int i = o.MyMethod();

It works, and it accomplishes the same thing with code that’s much less convoluted.
The value of this shortened, simplified C# syntax is perhaps more clear if you look at the ScriptObject class that supports operations on a JScript object. The class has an InvokeMember method that has more and different parameters, except in Silverlight, which actually has an Invoke method (notice the difference in the name) with fewer parameters. Neither of these are the same as what you’d need to invoke a method on an IronPython or IronRuby object or on any number of non-C# objects you might come into contact with.
In addition to objects that come from dynamic languages, you’ll find a variety of data models that are inherently dynamic and have different APIs supporting them, such as HTML DOMs, the System.Xml DOM and the XLinq model for XML. COM objects are often dynamic and can benefit from the delay to run time of some compiler analysis.
Essentially, C# 4.0 offers a simplified, consistent view of dynamic operations. To take advantage of it, all you need to do is specify that a given value is dynamic, ensuring that analysis of all operations on the value will be delayed until run time.
In C# 4.0, dynamic is a built-in type, and a special pseudo-keyword signifies it. Note, however, that dynamic is different from var. Variables declared with var actually do have a strong type, but the programmer has left it up to the compiler to figure it out. When the programmer uses dynamic, the compiler doesn’t know what type is being used—the programmer leaves figuring it out up to the runtime.

Dynamic and the DLR

The infrastructure that supports these dynamic operations at run time is called the Dynamic Language Runtime (DLR). This new .NET Framework 4 library runs on the CLR, like any other managed library. It’s responsible for brokering each dynamic operation between the language that initiated it and the object it occurs on. If a dynamic operation isn’t handled by the object it occurs on, a runtime component of the C# compiler handles the bind. A simplified and incomplete architecture diagram looks something like Figure 1.

Figure 1 The DLR Runs on Top of the CLR
The interesting thing about a dynamic operation, such as a dynamic method call, is that the receiver object has an opportunity to inject itself into the binding at run time and can, as a result, completely determine the semantics of any given dynamic operation. For instance, take a look at the following code:

dynamic d = new MyDynamicObject();
d.Bar("Baz", 3, d);

If MyDynamicObject was defined as shown here, then you can imagine what happens:

class MyDynamicObject : DynamicObject {
  public override bool TryInvokeMember(
    InvokeMemberBinder binder, 
    object[] args, out object result) {

    Console.WriteLine("Method: {0}", binder.Name);
    foreach (var arg in args) {
      Console.WriteLine("Argument: {0}", arg);
    }

    result = args[0];
    return true;
  }
}

In fact, the code prints:

Method: Bar
Argument: Baz
Argument: 3
Argument: MyDynamicObject

By declaring d to be of type dynamic, the code that consumes the MyDynamicObject instance effectively opts out of compile-time checking for the operations d participates in. Use of dynamic means “I don’t know what type this is going to be, so I don’t know what methods or properties there are right now. Compiler, please let them all through and then figure it out when you really have an object at run time.” So the call to Bar compiles even though the compiler doesn’t know what it means. Then at run time, the object itself is asked what to do with this call to Bar. That’s what TryInvokeMember knows how to handle.
Now, suppose that instead of a MyDynamicObject, you used a Python object:

dynamic d = GetPythonObject();
d.bar("Baz", 3, d);

If the object is the file listed here, then the code also works, and the output is much the same:

def bar(*args):
  print "Method:", bar.__name__
  for x in args:
    print "Argument:", x

Under the covers, for each use of a dynamic value, the compiler generates a bunch of code that initializes and uses a DLR CallSite. That CallSite contains all the information needed to bind at run time, including such things as the method name, extra data, such as whether the operation takes place in a checked context, and information about the arguments and their types.
This code, if you had to maintain it, would be every bit as ugly as the reflection code shown earlier or the ScriptObject code or strings that contain XML queries. That’s the point of the dynamic feature in C#—you don’t have to write code like that!
When using the dynamic keyword, your code can look pretty much the way you want: like a simple method invocation, a call to an indexer, an operator, such as +, a cast or even compounds, like += or ++. You can even use dynamic values in statements—for example, if(d) and foreach(var x in d). Short-circuiting is also supported, with code such as d && ShortCircuited or d ?? ShortCircuited.
The value of having the DLR provide a common infrastructure for these sorts of operations is that you’re no longer having to deal with a different API for each dynamic model you’d like to code against—there’s just a single API. And you don’t even have to use it. The C# compiler can use it for you, and that should give you more time to actually write the code you want—the less infrastructure code you have to maintain means more productivity for you.
The C# language provides no shortcuts for defining dynamic objects. Dynamic in C# is all about consuming and using dynamic objects. Consider the following:

dynamic list = GetDynamicList();
dynamic index1 = GetIndex1();
dynamic index2 = GetIndex2();
string s = list[++index1, index2 + 10].Foo();

This code compiles, and it contains a lot of dynamic operations. First, there’s the dynamic pre-increment on index1, then the dynamic add with index2. Then a dynamic indexer get is called on list. The product of those operations calls the member Foo. Finally, the total result of the expression is converted to a string and stored in s. That’s five dynamic operations in one line, each dispatched at run time.
The compile-time type of each dynamic operation is itself dynamic, and so the “dynamicness” kind of flows from computation to computation. Even if you hadn’t included dynamic expressions multiple times, there still would be a number of dynamic operations. There are still five in this one line:

string s = nonDynamicList[++index1, index2 + 10].Foo();

Because the results of the two indexing expressions are dynamic, the index itself is as well. And because the result of the index is dynamic, so is the call to Foo. Then you’re confronted with converting a dynamic value to a string. That happens dynamically, of course, because the object could be a dynamic one that wants to perform some special computation in the face of a conversion request.
Notice in the previous examples that C# allows implicit conversions from any dynamic expression to any type. The conversion to string at the end is implicit and did not require an explicit cast operation. Similarly, any type can be converted to dynamic implicitly.
In this respect, dynamic is a lot like object, and the similarities don’t stop there. When the compiler emits your assembly and needs to emit a dynamic variable, it does so by using the type object and then marking it specially. In some sense, dynamic is kind of an alias for object, but it adds the extra behavior of dynamically resolving operations when you use it.
You can see this if you try to convert between generic types that differ only in dynamic and object; such conversions will always work, because at runtime, an instance of List actually is an instance of List:

List ld = new List();

You can also see the similarity between dynamic and object if you try to override a method that’s declared with an object parameter:

class C {
  public override bool Equals(dynamic obj) { 
    /* ... */ 
  }
}

Although it resolves to a decorated object in your assembly, I do like to think of dynamic as a real type, because it serves as a reminder that you can do most things with it that you can do with any other type. You can use it as a type argument or, say, as a return value. For instance, this function definition will let you use the result of the function call dynamically without having to put its return value in a dynamic variable:

public dynamic GetDynamicThing() { 
  /* ... */ }

There are a lot more details about the way dynamic is treated and dispatched, but you don’t need to know them to use the feature. The essential idea is that you can write code that looks like C#, and if any part of the code you write is dynamic, the compiler will leave it alone until run time.
I want to cover one final topic concerning dynamic: failure. Because the compiler can’t check whether the dynamic thing you’re using really has the method called Foo, it can’t give you an error. Of course, that doesn’t mean that your call to Foo will work at run time. It may work, but there are a lot of objects that don’t have a method called Foo. When your expression fails to bind at run time, the binder makes its best attempt to give you an exception that’s more or less exactly what the compiler would’ve told you if you hadn’t used dynamic to begin with.
Consider the following code:

try 
{
  dynamic d = "this is a string";
  d.Foo();
}
catch (Microsoft.CSharp.RuntimeBinder.RuntimeBinderException e)
{
  Console.WriteLine(e.Message);
}

Here I have a string, and strings clearly do not have a method called Foo. When the line that calls Foo executes, the binding will fail and you’ll get a RuntimeBinderException. This is what the previous program prints:

'string' does not contain a definition for 'Foo'

Which is exactly the error message you, as a C# programmer, expect.

Named Arguments and Optional Parameters

In another addition to C#, methods now support optional parameters with default values so that when you call such a method you can omit those parameters. You can see this in action in this Car class:

class Car {
  public void Accelerate(
    double speed, int? gear = null, 
    bool inReverse = false) { 

    /* ... */ 
  }
}

You can call the method this way:

Car myCar = new Car();
myCar.Accelerate(55);

This has exactly the same effect as:

myCar.Accelerate(55, null, false);

It’s the same because the compiler will insert all the default values that you omit.
C# 4.0 will also let you call methods by specifying some arguments by name. In this way, you can pass an argument to an optional parameter without having to also pass arguments for all the parameters that come before it.
Say you want to call Accelerate to go in reverse, but you don’t want to specify the gear parameter. Well, you can do this:

myCar.Accelerate(55, inReverse: true);

This is a new C# 4.0 syntax, and it’s the same as if you had written:

myCar.Accelerate(55, null, true);

In fact, whether or not parameters in the method you’re calling are optional, you can use names when passing arguments. For instance, these two calls are permissible and identical to one another:

Console.WriteLine(format: "{0:f}", arg0: 6.02214179e23);
Console.WriteLine(arg0: 6.02214179e23, format: "{0:f}");

If you’re calling a method that takes a long list of parameters, you can even use names as a sort of in-code documentation to help you remember which parameter is which.
On the surface, optional arguments and named parameters don’t look like interop features. You can use them without ever even thinking about interop. However, the motivation for these features comes from the Office APIs. Consider, for example, Word programming and something as simple as the SaveAs method on the Document interface. This method has 16 parameters, all of which are optional. With previous versions of C#, if you want to call this method you have to write code that looks like this:

Document d = new Document();
object filename = "Foo.docx";
object missing = Type.Missing;
d.SaveAs(ref filename, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing);

Now, you can write this:

Document d = new Document();
d.SaveAs(FileName: "Foo.docx");

I would say that’s an improvement for anyone who works with APIs like this. And improving the lives of programmers who need to write Office programs was definitely a motivating factor for adding named arguments and optional parameters to the language.
Now, when writing a .NET library and considering adding methods that have optional parameters, you’re faced with a choice. You can either add optional parameters or you can do what C# programmers have done for years: introduce overloads. In the Car.Accelerate example, the latter decision might lead you to produce a type that looks like this:

class Car {
  public void Accelerate(uint speed) { 
    Accelerate(speed, null, false); 
  }
  public void Accelerate(uint speed, int? gear) { 
    Accelerate(speed, gear, false); 
  }
  public void Accelerate(uint speed, int? gear, 
    bool inReverse) { 
    /* ... */ 
  }
}

Selecting the model that suits the library you’re writing is up to you. Because C# hasn’t had optional parameters until now, the .NET Framework (including the .NET Framework 4) tends to use overloads. If you decide to mix and match overloads with optional parameters, the C# overload resolution has clear tie-breaking rules to determine which overload to call under any given circumstances.

Indexed Properties

Some smaller language features in C# 4.0 are supported only when writing code against a COM interop API. The Word interop in the previous illustration is one example.
C# code has always had the notion of an indexer that you can add to a class to effectively overload the [] operator on instances of that class. This sense of indexer is also called a default indexer, since it isn’t given a name and calling it requires no name. Some COM APIs also have indexers that aren’t default, which is to say that you can’t effectively call them simply by using []—you must specify a name. You can, alternatively, think of an indexed property as a property that takes some extra arguments.
C# 4.0 supports indexed properties on COM interop types. You can’t define types in C# that have indexed properties, but you can use them provided you’re doing so on a COM type. For an example of what C# code that does this looks like, consider the Range property on an Excel worksheet:

using Microsoft.Office.Interop.Excel;

class Program {
  static void Main(string[] args) {
    Application excel = new Application();
    excel.Visible = true;

    Worksheet ws = 
      excel.Workbooks.Add().Worksheets["Sheet1"];
    // Range is an indexed property
    ws.Range["A1", "C3"].Value = 123; 
    System.Console.ReadLine();
    excel.Quit();
  }
}

In this example, Range[“A1”, “C3”] isn’t a property called Range that returns a thing that can be indexed. It’s one call to a Range accessor that passes A1 and C3 with it. And although Value might not look like an indexed property, it, too, is one! All of its arguments are optional, and because it’s an indexed property, you omit them by not specifying them at all. Before the language supported indexed properties, you would have written the call like this:

ws.get_Range("A1", "C3").Value2 = 123;

Here, Value2 is a property that was added simply because the indexed property Value wouldn’t work prior to C# 4.0.

Omitting the Ref Keyword at COM Call Sites

Some COM APIs were written with many parameters passed by reference, even when the implementation doesn’t write back to them. In the Office suite, Word stands out as an example—its COM APIs all do this.
When you’re confronted with such a library and you need to pass arguments by reference, you can no longer pass any expression that’s not a local variable or field, and that’s a big headache. In the Word SaveAs example, you can see this in action—you had to declare a local called filename and a local called missing just to call the SaveAs method, since those parameters needed to be passed by reference.

Document d = new Document();
object filename = "Foo.docx";
object missing = Type.Missing;
d.SaveAs(ref filename, ref missing, // ...

You may have noticed in the new C# code that followed, I no longer declared a local for filename:

d.SaveAs(FileName: "Foo.docx");

This is possible because of the new omit ref feature for COM interop. Now, when calling a COM interop method, you can pass any argument by value instead of by reference. If you do, the compiler will create a temporary local on your behalf and pass that local by reference for you if required. Of course, you won’t be able to see the effect of the method call if the method mutates the argument—if you want that, pass the argument by ref.
This should make code that uses APIs like this much cleaner.

Embedding COM Interop Types

This is more of a C# compiler feature than a C# language feature, but now you can use a COM interop assembly without that assembly having to be present at run time. The goal is to reduce the burden of deploying COM interop assemblies with your application.
When COM interop was introduced in the original version of the .NET Framework, the notion of a Primary Interop Assembly (PIA) was created. This was an attempt to solve the problem of sharing COM objects among components. If you had different interop assemblies that defined an Excel Worksheet, we wouldn’t be able to share these Worksheets between components, because they would be different .NET types. The PIA fixed this by existing only once—all clients used it, and the .NET types always matched.
Though a fine idea on paper, in practice deploying a PIA turns out to be a headache, because there’s only one, and multiple applications could try to install or uninstall it. Matters are complicated because PIAs are often large, Office doesn’t deploy them with default Office installations, and users can circumvent this single assembly system easily just by using TLBIMP to create their own interop assembly.
So now, in an effort to fix this situation, two things have happened:

The runtime has been given the smarts to treat two structurally identical COM interop types that share the same identifying characteristics (name, GUID and so on) as though they were actually the same .NET type.
The C# compiler takes advantage of this by simply reproducing the interop types in your own assembly when you compile, removing the need for the interop assembly to exist at run time.

Reference link : http://msdn.microsoft.com/en-us/magazine/ff796223.aspx

Object Relational Modeling Tool Comparison Dot Net

noreply@blogger.com (amitmittal77) — Fri, 30 Oct 2009 17:23:00 +0000

Object Relational Modeling Tool(ORM) Comparison Dot Net

http://www.blogger.com/post-create.g?blogID=1264876288197353948

An ADO.NET Data Services Tutorial

noreply@blogger.com (amitmittal77) — Thu, 22 Oct 2009 17:57:00 +0000

An ADO.NET Data Services Tutorial

http://www.codeguru.com/csharp/.net/net_wcf/article.php/c16231__1/

New Features in Visual Studio 2010 and the .NET Framework 4.0

noreply@blogger.com (amitmittal77) — Thu, 22 Oct 2009 17:55:00 +0000

New Features in Visual Studio 2010 and the .NET Framework 4.0

http://www.codeguru.com/vb/vbnet30/article.php/c15645/

WCF versioning

noreply@blogger.com (amitmittal77) — Wed, 14 Oct 2009 16:21:00 +0000

MSDN has a set of articles regarding WCF versioning that are good to cast your eyes over.

Service Versioning
Data Contract Versioning
Best Practices: Data Contract Versioning
Collection Types in Data Contracts

WCF Interview Questions and Answers

noreply@blogger.com (amitmittal77) — Mon, 12 Oct 2009 19:22:00 +0000

Ques 1: What are end points, contract, address and bindings?
Ans: All communication with a Windows Communication Foundation (WCF) service occurs through the endpoints of the service. Endpoints provide clients access to the functionality offered by a WCF service.
Each endpoint consists of four properties:

An address that indicates where the endpoint can be found.
A binding that specifies how a client can communicate with the endpoint.
A contract that identifies the operations available.
A set of behaviors that specify local implementation details of the endpoint.

The foundation of WCF is ABC (address binding contract).The Address relates to the logical address to which your service is exposed, that is the HTTP URL for a web service
The Binding is the Microsoft Channel stack that shields the complexities of setting up the communication channel etc
The Contract is what the service conforms to so that the consumer knows how to interact with the service; this is done via an Interface
Ques 2: What are bindings?
Ans: The binding specifies how to communicate with the endpoint. This includes:

The transport protocol to use (for example, TCP or HTTP).
The encoding to use for the messages (for example, text or binary).
The necessary security requirements (for example, SSL or SOAP message security).

Ques 3: What are different bindings are supported in WCF?
Ans: Predefined binding in WCF

Binding	Interoperability	Security	Sessions	Transactions
BasicHttpBinding	Basic Profile 1.1	None	No	No
wsHttpBinding	WS	Message	Optional	Yes
wsDualHttpBinding	WS	Message	Yes	Yes
wsFederationHttpBinding	Federation	Message	Yes	Yes
netTcpBinding	.NET	Transport	Optional	Yes
netNamedPipeBinding	.NET	Transport	Yes	Yes
netMsmqBinding	.NET	Transport	Yes	Yes
netPeerTcpBinding	Peer	Transport
msmqIntegrationBinding	MSMQ	Transport	Yes	Yes

Ques 4: What is one way operation?
Ans: The default behavior of a service operation is the request-reply pattern. In a request-reply pattern, the client waits for the reply message, even if the service operation is represented in code as a void method. With a one-way operation, only one message is transmitted. The receiver does not send a reply message, nor does the sender expect one.
WCF has a simple and easy way to define operations that should be made as OneWay.
You do it by setting IsOneWay = true in the OperationContract attribute.
E.g.
[ServiceContract]
public interface IMyServiceOneWay
{
[OperationContract(IsOneWay = true)]
void DoOneWay(bool throwException);
}
The contract contains one operation – DoOneWay which will be invoked in a “OneWay” pattern
General things you should keep in mind about OneWay operations -
1. O/W operations must return void.
2. O/W operations can still yield exceptions. Invoking an operation on the client channel might still throw an exception if it couldn’t transmit the call over to the service.
3. O/W operations can still block. If the service is pumped with messages and a queue had started.
Ques 5: Can you explain duplex contracts in WCF?
Ans : A duplex service contract is a message exchange pattern in which both endpoints can send messages to the other independently. A duplex service, therefore, can send messages back to the client endpoint, providing event-like behavior. Duplex communication occurs when a client connects to a service and provides the service with a channel on which the service can send messages back to the client. Note that the event-like behavior of duplex services only works within a session.
To create a duplex contract you create a pair of interfaces. The first is the service contract interface that describes the operations that a client can invoke. That service contract must specify a callback contract in the System.ServiceModel.ServiceContractAttribute.CallbackContract property. The callback contract is the interface that defines the operations that the service can call on the client endpoint. A duplex contract does not require a session, although the system-provided duplex bindings make use of them.

C# Interview Questions and Answers - Part 3

noreply@blogger.com (amitmittal77) — Fri, 09 Oct 2009 19:51:00 +0000

Part 1

Part 2

Part 3

Ques 21: When should we use structure and when class?
Ans: Structs are always lightweight objects. By that it means they are not created on the CLR heap. They are created on the stack. Its always easy performance wise to create struct variables and to destroy them.
Classes ar3 meant for heavy duty work. Objects in classes are always created on the CLR heap. This means extra overhead of creating the object and maintaining it. All objects are subject to garbage collection whereas struct objects are not.
Use a struct when you want something that behaves like a value type, such as an (i,r) complex number, an (x,y,z) coord or an (A,R,G,B) colour. Otherwise use a class.
Ques 22: What is the difference between Finalize and Dispose (Garbage collection)?
Ans: Class instances often encapsulate control over resources that are not managed by the runtime, such as window handles (HWND), database connections, and so on. Therefore, you should provide both an explicit and an implicit way to free those resources. Provide implicit control by implementing the protected Finalize Method on an object (destructor syntax in C# and the Managed Extensions for C++). The garbage collector calls this method at some point after there are no longer any valid references to the object.
In some cases, you might want to provide programmers using an object with the ability to explicitly release these external resources before the garbage collector frees the object. If an external resource is scarce or expensive, better performance can be achieved if the programmer explicitly releases resources when they are no longer being used. To provide explicit control, implement the Dispose method provided by the IDisposable Interface. The consumer of the object should call this method when it is done using the object. Dispose can be called even if other references to the object are alive.
Note that even when you provide explicit control by way of Dispose, you should provide implicit cleanup using the Finalize method. Finalize provides a backup to prevent resources from permanently leaking if the programmer fails to call Dispose.
Ques 23: How’s method overriding different from overloading?
Ans: When overriding, you change the method behavior for a derived class. Overloading simply involves having a method with the same name within the class.
Ques 24: What does the keyword virtual mean in the method definition?
Ans: The method can be over-ridden.
Ques 25: Can you declare the override method static while the original method is non-static?
Ans: No, you can’t, the signature of the virtual method must remain the same, only the keyword virtual is changed to keyword override.
Ques 26: Can you override private virtual methods?
Ans: No, moreover, you cannot access private methods in inherited classes, have to be protected in the base class to allow any sort of access.
Ques 27: Can you allow class to be inherited, but prevent the method from being over-ridden?
Ans: Yes, just leave the class public and make the method sealed.
Ques 28: Can we declare private methods inside an Interface? Why can’t you specify the accessibility modifier for methods inside the interface?
Ans: No, they all must be public. Therefore, to prevent you from getting the false impression that you have any freedom of choice, you are not allowed to specify any accessibility, its public by default.
Ques 29: How do you initiate a string without escaping each backslash?
Ans: Put @ sign in front of the double-quoted string.
e.g. @“C:\Documents and Settings\Administrator\My Documents”; is equivalent to “C:\\Documents and Settings\\Administrator\\My Documents”.
Ques 30: Describe the accessibility modifier protected internal.
Ans: It’s available to derived classes and classes within the same Assembly (and naturally from the base class it’s declared in).

ASP.NET Interview Questions and Answers - Part 3

noreply@blogger.com (amitmittal77) — Fri, 09 Oct 2009 15:04:00 +0000

Part 1

Part 2

Part 3

Ques 21: Explain Cookies in .Net?
Ans: Cookie are one of several ways to store data about web site visitors during the time when web server and browser are not connected. Common use of cookies is to remember users between visits. Practically, cookie is a small text file sent by web server and saved by web browser on client machine.

C# Code

// Add this on the beginning of your .cs code file
using System;
// Use this line when you want to save a cookie
Response.Cookies["MyCookieName"].Value = "MyCookieValue";
// How long will cookie exist on client hard disk
Response.Cookies["MyCookieName"].Expires = DateTime.Now.AddDays(1);
// To add multiple key/value pairs in single cookie
Response.Cookies["VisitorData"]["FirstName"] = "Richard";
Response.Cookies["VisitorData"]["LastVisit"] = DateTime.Now.ToString();

HttpCookie Class: HttpCookie class is located in System.Web namespace. You can use HttpCookie class to create and manipulate cookies instead of using of Response and Request objects.

HttpCookie class has these properties:
Domain - Gets or sets domain associated with a cookie. It is often used to limit cookie use to web site sub domain.
Expires - Gets or sets time when cookie expires. After that time cookie is deleted by the browser. The maximum life time for cookie is 365 days. You can increase expiration time every time when visitor visits your web site, but if visitor don't comes for more than 365 days, the cookie will be deleted.
HasKeys - Returns true if cookie has key pairs or false if not. Cookies are not limited to only simple data as strings, but could stores key/values pairs as well.
HttpOnly - Gets or sets a true/false value if cookie is accesible by client side javascript. If value is true, cookie will be accessible only by server side ASP.NET code.
Item - Not necessary, it exists only because it is used in old classic ASP.
Name - A name of a cookie.
Path - Similar like Domain property, path is used to limit a cookie scope to specific URL. For example, to limit using of a cookie to sub folder www.yourdomain.com/forum you need to set Path property to "/forum".
Secure - Would cookies will transmit through HTTPS protocol by using SSL (secure socket layer) connection.
Value - Gets or sets a cookie's value.
Values - Used to get or set key/value pairs in individual cookie.

You can use HttpCookie class to create a cookie or set cookie's properties, like in this example code:

HttpCookie MyGreatCookie = new HttpCookie("MyCookieName");
MyGreatCookie.Value = "Some cookie value";
MyGreatCookie.Expires = DateTime.Now.AddDays(100);
Response.Cookies.Add(MyGreatCookie);

Ques 22: How to read a cookie in ASP.NET
Ans: To read a cookie value, use this:
C# Code
string MyCookieValue;
// We need to perform this check first, to avoid null exception
// if cookie not exists
if(Request.Cookies["MyCookieName"] != null)
MyCookieValue = Request.Cookies["MyCookieName"].Value;

Ques 23: How to delete cookie in ASP.NET
Ans: To delete existing cookie we actually just set its expiration time to some time in the past. You can do it with code like this:
C# Code
// First check if cookie exists
if (Request.Cookies["MyCookieName"] != null)
{
// Set its expiration time somewhere in the past
Response.Cookies["MyCookieName"].Expires = DateTime.Now.AddDays(-1);
}
HttpCookie class is located in System.Web namespace. You can use HttpCookie class to create and manipulate cookies instead of using of Response and Request objects.

Ques 24: Web browser limits for cookies?
Ans: Cookie size is limited to 4096 bytes. It is not much, so cookies are used to store small amounts of data, often just user id.
- Also, number of cookies is limited to 20 per website. If you make new cookie when you already have 20 cookies, browser will delete oldest one.
- Your web site visitor can change browser settings to not accept cookies. In that case you are not able to save and retrieve data on this way! Because of this, it is good to check browser settings before saving a cookie.
- If your visitor blocked cookies in web browser privacy settings, you need to decide do you still want to save that data on some other way (maybe with sessions) or to not save it at all. Anyway, your application must continue to work normally with any browser privacy settings. It is better to not store any sensitive or critical data to cookies. If using of cookies is necessary, you should inform your users with some message like: "Cookies must be enabled to use this application".

Ques 25: How to find does web browser accepts cookies?
Ans: There are two possible cases when your client will not accept cookies:
- Web browser does not support cookies
- Web browser supports cookies, but user disabled that option through a browser's privacy settings.
C# Code

if (Request.Browser.Cookies)
{
// Cookies supported
}
else
{
// Web browser not supports cookies
}
Ques 26: How to check if client web browser not saved a cookie because of its privacy settings
Ans:Code above will tell you does web browser supports cookie technology, but your visitor could disable cookies in web browser's privacy settings. In that case, Request.Browser.Cookies will still return true but your cookies will not be saved. Only way to check client's privacy settings is to try to save a cookie on the first page, and then redirect to second page that will try to read that cookie. You can eventually use the same page to save and read a cookie when perform a testing, but you must use Response.Redirect method after saving and before reading cookies.

Ques 27: Best practices with cookies in ASP.NET
Ans: Cookies are just plain text, so usually are not used to store sensitive informations like passwords without prior encryption. If you want to enable "Remember me" option on web site it is recommended to encrypt a password before it is stored in a cookie. Cookies are often used for data like: when visitor last time loged in, what site color she likes, to keep referer id if we offer affiliate program etc.

Ques 28: Security issues about cookies in ASP.NET
Ans: Because of security reasons, your web application can read only cookies related to your web domain. You can't read cookies related to other web sites. Web browser stores cookies from different sites separately.Cookie is just a plain text file on client's hard disk so it could be changed on different ways outside of your application. Because of that, you need to treat cookie value as potentially dangerous input like any other input from the visitor, including prevention of cross site scripting attacks.
Ques 29:. What is cookie less session? How it works?
Ans: By default, ASP.NET will store the session state in the same process that processes the request, just as ASP does. If cookies are not available, a session can be tracked by adding a session identifier to the URL. This can be enabled by setting the following:
Ques 30: What is the difference between Web User Control and Web Custom Control?
Ans: Web custom controls are compiled components that run on the server and that encapsulate user-interface and other related functionality into reusable packages. They can include all the design-time features of standard ASP.NET server controls, including full support for Visual Studio design features such as the Properties window, the visual designer, and the Toolbox.
There are several ways that you can create Web custom controls:
- You can compile a control that combines the functionality of two or more existing controls. For example, if you need a control that encapsulates a button and a text box, you can create it by compiling the existing controls together.
- If an existing server control almost meets your requirements but lacks some required features, you can customize the control by deriving from it and overriding its properties, methods, and events.
- If none of the existing Web server controls (or their combinations) meet your requirements, you can create a custom control by deriving from one of the base control classes. These classes provide all the basic functionality of Web server controls, so you can focus on programming the features you need.
- If none of the existing ASP.NET server controls meet the specific requirements of your applications, you can create either a Web user control or a Web custom control that encapsulates the functionality you need.
The main difference between the two controls lies in ease of creation vs. ease of use at design time.
Web user controls are easy to make, but they can be less convenient to use in advanced scenarios. You develop Web user controls almost exactly the same way that you develop Web Forms pages. Like Web Forms, user controls can be created in the visual designer, they can be written with code separated from the HTML, and they can handle execution events. However, because Web user controls are compiled dynamically at run time they cannot be added to the Toolbox, and they are represented by a simple placeholder glyph when added to a page. This makes Web user controls harder to use if you are accustomed to full Visual Studio .NET design-time support, including the Properties window and Design view previews. Also, the only way to share the user control between applications is to put a separate copy in each application, which takes more maintenance if you make changes to the control.
Web custom controls are compiled code, which makes them easier to use but more difficult to create; Web custom controls must be authored in code. Once you have created the control, however, you can add it to the Toolbox and display it in a visual designer with full Properties window support and all the other design-time features of ASP.NET server controls. In addition, you can install a single copy of the Web custom control in the global assembly cache and share it between applications, which makes maintenance easier.

WCF Bindings In Depth

noreply@blogger.com (amitmittal77) — Thu, 08 Oct 2009 18:06:00 +0000

An excellent article on WCF Bindings

WCF Bindings In Depth

WCF Addressing In Depth

noreply@blogger.com (amitmittal77) — Thu, 08 Oct 2009 18:03:00 +0000

Good article explains WCF Addressing In Depth

WCF Addressing In Depth

C# Interview Questions and Answers - Part 2

noreply@blogger.com (amitmittal77) — Thu, 08 Oct 2009 16:05:00 +0000

Part 1

Part 2

Part 3

Ques 11: Why do we need to call CG.SupressFinalize?
Ans: Requests that the system not call the finalizer method for the specified object.

[C#]
public static void SuppressFinalize(object obj);
The method removes obj from the set of objects that require finalization. The obj parameter is required to be the caller of this method. Objects that implement the IDisposable interface can call this method from the IDisposable.Dispose method to prevent the garbage collector from calling Object.Finalize on an object that does not require it.

Ques 12: What is the difference between CONST and READONLY?
Ans: Both are meant for constant values. A const field can only be initialized at the declaration of the field. A readonly field can be initialized either at the declaration or in a constructor. Therefore, readonly fields can have different values depending on the constructor used.
readonly int b;
public X()
{
b=1;
}
public X(string s)
{
b=5;
}
public X(string s, int i)
{
b=i;
}
Also, while a const field is a compile-time constant, the readonly field can be used for runtime constants, as in the following example:
public static readonly uint l1 = (uint) DateTime.Now.Ticks;
(this can't be possible with const)
Ques 13: What is the difference between ref & out parameters?
Ans: An argument passed to a ref parameter must first be initialized. Compare this to an out parameter, whose argument does not have to be explicitly initialized before being passed to an out parameter.
Ques 14: What is Asynchronous call and how it can be implemented using delegates?
Ans: A synchronous call will wait for a method to complete before program flow is resumed. With an asynchronous call the program flow continues whilst the method executes.
//create object
SomeFunction objFunc = new SomeFunction();
//create delegate
SomeDelegate objDel = new SomeDelegate(objFunc.FunctionA);
//invoke the method asynchronously (use interface IAsyncResult)
IAsyncResult asynchCall = SomeDelegate.Invoke();

Ques 15: What is Jagged Arrays?
Ans: A jagged array is an array whose elements are arrays. The elements of a jagged array can be of different dimensions and sizes. A jagged array is sometimes called an "array-of-arrays."

Ques 16: What are indexers?
Ans: Indexers are similar to properties, except that the get and set accessors of indexers take parameters, while property accessors do not.

Ques 17: What are Sealed Classes in C#?
Ans: The sealed modifier is used to prevent derivation from a class. A compile-time error occurs if a sealed class is specified as the base class of another class. (A sealed class cannot also be an abstract class)
Ques 18: What is Polymorphism? How does C# achieve polymorphism?
Ans: Polymorphism means same operation may behave differently on different classes.
Example of Compile Time Polymorphism: Method Overloading
Example of Run Time Polymorphism: Method Overriding

Example of Compile Time Polymorphism

Method Overloading
- Method with same name but with different arguments is called method overloading.
- Method Overloading forms compile-time polymorphism.
- Example of Method Overloading:
class A1
{
void hello()
{
Console.WriteLine(“Hello”);
}
void hello(string s)
{
Console.WriteLine(“Hello {0}”,s);
}
}

Example of Run Time Polymorphism

Method Overriding
- Method overriding occurs when child class declares a method that has the same type arguments as a method declared by one of its superclass.
- Method overriding forms Run-time polymorphism.
- Note: By default functions are not virtual in C# and so you need to write “virtual” explicitly. While by default in Java each function are virtual.
- Example of Method Overriding:

public class parent
{
public virtual void hello()
{
Console.WriteLine(“Hello from Parent”);
}
}

public class child : parent
{
public override void hello()
{
Console.WriteLine(“Hello from Child”);
}
}

static void main()
{
parent objParent = new child();
objParent.hello();
}
//Output -- Hello from Child

public class Token
{
public string Display()
{
//Implementation goes here
return "base";
}
}
class IdentifierToken:Token
{
public new string Display() //What is the use of new keyword
{
//Implementation goes here
return "derive";
}
}
static void Method(Token t)
{
Console.Write(t.Display());
}
public static void Main()
{
IdentifierToken Variable=new IdentifierToken();
Method (Variable); //Which Class Method is called here
Console.ReadLine();
}

For the above code What is the "new" keyword and Which Class Method is called here
It will call base class Display method
Output : Base

class Token
{
public virtual string Display()
{
//Implementation goes here
return "base";
}
}
class IdentifierToken:Token
{
public override string Display()
{
//Implementation goes here
return "derive";
}
}
static void Method(Token t)
{
Console.Write(t.Display());
}
public static void Main()
{
IdentifierToken Variable=new IdentifierToken();
Method(Variable); //Which Class Method is called here
Console.ReadLine();
}
Output : Derive

Ques 19: In which Scenario you will go for Interface or Abstract Class?
Ans : Interfaces, like classes, define a set of properties, methods, and events. But unlike classes, interfaces do not provide implementation. They are implemented by classes, and defined as separate entities from classes. Even though class inheritance allows your classes to inherit implementation from a base class, it also forces you to make most of your design decisions when the class is first published.
Abstract classes are useful when creating components because they allow you specify an invariant level of functionality in some methods, but leave the implementation of other methods until a specific implementation of that class is needed. They also version well, because if additional functionality is needed in derived classes, it can be added to the base class without breaking code.

Interfaces vs. Abstract Classes
Feature	Interface	Abstract class
Multiple inheritance	A class may implement several interfaces.	A class may extend only one abstract class.
Default implementation	An interface cannot provide any code at all, much less default code.	An abstract class can provide complete code, default code, and/or just stubs that have to be overridden.
Constants	Static final constants only, can use them without qualification in classes that implement the interface. On the other paw, these unqualified names pollute the namespace. You can use them and it is not obvious where they are coming from since the qualification is optional.	Both instance and static constants are possible. Both static and instance intialiser code are also possible to compute the constants.
Third party convenience	An interface implementation may be added to any existing third party class.	A third party class must be rewritten to extend only from the abstract class.
is-a vs -able or can-do	Interfaces are often used to describe the peripheral abilities of a class, not its central identity, e.g. an Automobile class might implement the Recyclable interface, which could apply to many otherwise totally unrelated objects.	An abstract class defines the core identity of its descendants. If you defined a Dog abstract class then Damamation descendants are Dogs, they are not merely dogable. Implemented interfaces enumerate the general things a class can do, not the things a class is.
Plug-in	You can write a new replacement module for an interface that contains not one stick of code in common with the existing implementations. When you implement the interface, you start from scratch without any default implementation. You have to obtain your tools from other classes; nothing comes with the interface other than a few constants. This gives you freedom to implement a radically different internal design.	You must use the abstract class as-is for the code base, with all its attendant baggage, good or bad. The abstract class author has imposed structure on you. Depending on the cleverness of the author of the abstract class, this may be good or bad. Another issue that's important is what I call "heterogeneous vs. homogeneous." If implementors/subclasses are homogeneous, tend towards an abstract base class. If they are heterogeneous, use an interface. (Now all I have to do is come up with a good definition of hetero/homogeneous in this context.) If the various objects are all of-a-kind, and share a common state and behavior, then tend towards a common base class. If all they share is a set of method signatures, then tend towards an interface.
Homogeneity	If all the various implementations share is the method signatures, then an interface works best.	If the various implementations are all of a kind and share a common status and behavior, usually an abstract class works best.
Maintenance	If your client code talks only in terms of an interface, you can easily change the concrete implementation behind it, using a factory method.	Just like an interface, if your client code talks only in terms of an abstract class, you can easily change the concrete implementation behind it, using a factory method.
Speed	Slow, requires extra indirection to find the corresponding method in the actual class. Modern JVMs are discovering ways to reduce this speed penalty.	Fast
Terseness	The constant declarations in an interface are all presumed public static final, so you may leave that part out. You can't call any methods to compute the initial values of your constants. You need not declare individual methods of an interface abstract. They are all presumed so.	You can put shared code into an abstract class, where you cannot into an interface. If interfaces want to share code, you will have to write other bubblegum to arrange that. You may use methods to compute the initial values of your constants and variables, both instance and static. You must declare all the individual methods of an abstract class abstract.
Adding functionality	If you add a new method to an interface, you must track down all implementations of that interface in the universe and provide them with a concrete implementation of that method.	If you add a new method to an abstract class, you have the option of providing a default implementation of it. Then all existing code will continue to work without change.

Ques 20: How can you write a class to restrict that only one object of this class can be created (Singleton class)?

Ans : Use the singleton design pattern.
public sealed class Singleton
{
static readonly Singleton Instance=new Singleton();

      static Singleton()
      {
      }

      Singleton()
      {
      }

public static Singleton Instance

      {
            get
            {
                  return Instance;
            }
      }
}

ASP.NET Interview Questions and Answers - Part 2

noreply@blogger.com (amitmittal77) — Wed, 07 Oct 2009 18:33:00 +0000

Part 1

Part 2

Part 3

Ques 11: Can we have multiple number of Master pages in an ASP.NET 2.0 web application?Ans: Yes. Ques 12: Can we have multiple SiteMapPath controls in an ASP.NET 2.0 web application?Ans: Yes. Ques 13: Describe the Hotspot class?Ans" It implements the basic functionality common to all hot spot shapes. Its Namespace: System.Web.UI.WebControls You cannot directly create instances of the abstract HotSpot class. Instead, this class is inherited by the CircleHotSpot, RectangleHotSpot, and PolygonHotSpot classes to provide the common basic functionality for a hot spot. You must derive from the HotSpot class to create a custom hot spot class that represents a unique shape that you define. However, you can define most shapes using the CircleHotSpot, RectangleHotSpot, and PolygonHotSpot classes. Its used in an ImageMap control. Ques 14: What is ImageMap Control?Ans: It is a control that displays an image on a page. When a hot spot region that is defined within the ImageMap control is clicked, the control either generates a postback to the server or navigates to a specified URL. Inline code example...

<asp:ImageMap
AccessKey="string"
AlternateText="string"
BackColor="color name|#dddddd"
BorderColor="color name|#dddddd"
BorderStyle="NotSet|None|Dotted|Dashed|Solid|Double|Groove|Ridge|
Inset|Outset"
BorderWidth="size"
CssClass="string"
DescriptionUrl="uri"
Enabled="True|False"
EnableTheming="True|False"
EnableViewState="True|False"
ForeColor="color name|#dddddd"
GenerateEmptyAlternateText="True|False"
Height="size"
HotSpotMode="NotSet|Navigate|PostBack|Inactive"
ID="string"
ImageAlign="NotSet|Left|Right|Baseline|Top|Middle|Bottom|
AbsBottom|AbsMiddle|TextTop"
ImageUrl="uri"
OnClick="Click event handler"
OnDataBinding="DataBinding event handler"
OnDisposed="Disposed event handler"
OnInit="Init event handler"
OnLoad="Load event handler"
OnPreRender="PreRender event handler"
OnUnload="Unload event handler"
runat="server"
SkinID="string"
Style="string"
TabIndex="integer"
Target="string"
ToolTip="string"
Visible="True|False"
Width="size"
>
<asp:CircleHotSpot
AccessKey="string"
AlternateText="string"
HotSpotMode="NotSet|Navigate|PostBack|Inactive"
NavigateUrl="uri"
PostBackValue="string"
Radius="integer"
TabIndex="integer"
Target="string|_blank|_parent|_search|_self|_top"
X="integer"
Y="integer" />
<asp:PolygonHotSpot
AccessKey="string"
AlternateText="string"
Coordinates="string"
HotSpotMode="NotSet|Navigate|PostBack|Inactive"
NavigateUrl="uri"
PostBackValue="string"
TabIndex="integer"
Target="string|_blank|_parent|_search|_self|_top"
/>
<asp:RectangleHotSpot
AccessKey="string"
AlternateText="string"
Bottom="integer"
HotSpotMode="NotSet|Navigate|PostBack|Inactive"
Left="integer"
NavigateUrl="uri"
PostBackValue="string"
Right="integer"
TabIndex="integer"
Target="string|_blank|_parent|_search|_self|_top"
Top="integer" />
</asp:ImageMap>

Ques 15: What is Dynamic Compilation?Ans: When an asp.net page is compiled for the first time, a copy of the compiled assembly is saved in the Temporary ASP.NET Files folder. This compiled page is of the type system.web.ui.page and includes all contents of the page (including html & scripts). When it is compiled a second time, a precompiled version is accessed from this location, thus speeding up the process. In case the source is changed, the assembly in the Temporary ASP.NET Files folder gets deleted, and thus re-compilation occurs. This process is called Dynamic Compilation. Compilation may be enabled or disabled at page level by setting the CompilationMode attribute in the Page Directive of the page. Ques 16: How to set Dynamic Compilation for an entire website? Ans:. In web.config, in pages element, add the attribute CompilationMode="Auto".Ques 17: Why do we sometimes need to disable compilation?Ans: In case of big sites with many pages, and we dont want to load an assembly into the memory for every page. We set CompilationMode="Never". The pages are interpreted at runtime. Ques 18: What is the FindControl method? Ans: A method that searches for a control, with a specific ID inside a container and get a reference to it. Its just like the getElementById in javascript. Ques 19: What is a partial class? Whats the advantage of using it? Ans: In ASP.NET 2.0, a class may be written at several places, and at the time of compilation, all these classes (having the same name) get compiled as one single class. Hence these classes are called Partial Classes. Advantage, for example, Any change in Code-Behind page gets reflected in the Presentation Page(inline code) and vice versa, because of the partial class mechanism. Compare this with the older ASP.NET 1.1, whenever a change was made to Code Behind, change got reflected in Presentation page but the reverse threw an error. So for any change in the presentation page, like addition of a new control, we need to specifically add a reference of that control in the Code-Behind page. The concept of partial classes in ASP.NET 2 eliminates this problem. Ques 20 :What is the difference between Server.Transfer and Response.Redirect? Why would I choose one over the other?Ans: Server.Transfer transfers page processing from one page directly to the next page without making a round-trip back to the client's browser. This provides a faster response with a little less overhead on the server. Server.Transfer does not update the clients url history list or current url. Response.Redirect is used to redirect the user's browser to another page or site. This performas a trip back to the client where the client's browser is redirected to the new page. The user's browser history list is updated to reflect the new address.

Design Pattern Quiz

noreply@blogger.com (amitmittal77) — Wed, 07 Oct 2009 15:48:00 +0000

Hi,

Do you want to see where you stand youself in Design patterns?

Then, don't wait, just browse and test yourself at: http://www.vincehuston.org/dp/patterns_quiz.html

UML Class Diagrams

noreply@blogger.com (amitmittal77) — Tue, 06 Oct 2009 20:42:00 +0000

Class diagrams identify the class structure of a system, including the properties and methods of each class. Also depicted are the various relationships that can exist between classes, such as an inheritance relationship.

Notation

The elements on a Class diagram are classes and the relationships between them

Class Classes are the building blocks in object-oriented programming. A Class is depicted using a rectangle divided into three sections. The top section is the name of the Class. The middle section defines the properties of the Class. The bottom section lists the methods of the class.

Example

Association An Association is a generic relationship between two classes, and is modeled by a line connecting the two classes. This line can be qualified with the type of relationship, and can also feature multiplicity rules (eg. one-to-one, one-to-many, many-to-many) for the relationship.

Example

Aggregation Aggregations indicate a whole-part relationship, and are known as "has-a" relationships. An Aggregation relationship is indicated by a line with a hollow diamond.

Example

A school holds both zero or more teachers and students, but the school, students and teacher can exist on their own as well. This is a weakly-coupled relationship and is called an aggregation.

Composition If a class cannot exist by itself, and instead must be a member of another class, then that class has a Composition relationship with the containing class. A Composition relationship is indicated by a line with a filled diamond. There is a special whole/part relationship where one thing contains one or more things. This is a more stronger relationship where one needs the other in order to exist.

Example

In the first diagram, both the human and heart need each other in order to exist. In the second diagram, a car cannot exist without wheels, an engine and doors, yet the doors, engine and wheels that make up the car can exist by themselves.

Dependency When a class uses another class, perhaps as a member variable or a parameter, and so "depends" on that class, a Dependency relationship is formed. A Dependency relationship is indicated by a dotted arrow.

Example

Generalization A Generalization relationship is the equivalent of an inheritance relationship in object-oriented terms (an "is-a" relationship). A Generalization relationship is indicated by an arrow with a hollow arrowhead pointing to the base, or "parent", class.

A generalization is used when two classes are similar, but have some differences

Example:

In this example the classes Corporate Customer and Personal Customer have some similarities such as name and address, but each class has some of its own attributes and operations. The class Customer is a general form of both the Corporate Customer and Personal Customer classes.

The Difference Between RPC and Document Style WSDL

noreply@blogger.com (amitmittal77) — Thu, 01 Oct 2009 18:15:00 +0000

Nice articles to understand difference between RPC and document style in web services.

The Difference Between RPC and Document Style WSDL

Which style of WSDL should I use?

Reap the benefits of document style Web services

Difference between WCF and web service

noreply@blogger.com (amitmittal77) — Wed, 30 Sep 2009 20:55:00 +0000

The best difference / comparison between WCF Service and Asp.Net Web service you can find on the following URL:

http://msdn.microsoft.com/en-us/library/aa738737.aspx

Its really very nice article.

WCF Contracts

noreply@blogger.com (amitmittal77) — Fri, 25 Sep 2009 19:21:00 +0000

Contracts

Service contract Defines which operations the service makes available to be invoked as request messages are sent to the service from the client

Data contract Defines the structure of data included in the payloads of the messages flowing in and out of the service

Message contract Enables you to control the headers that appear in the messages and how the messages are structured

WCF and Web Services Standards

The three core types of WCF contracts map directly to a corresponding Web services standard in the following way:

�� Service contracts map to WSDL

�� Data contracts map to XSD

�� Message contracts map to SOAP

The ServiceContractAttribute

The ServiceContractAttribute, defined in the System.ServiceModel namespace, can be applied to either .NET interfaces or .NET classes. It is used to declare the type as a Service contract. This attribute is not inherited,

NOTE : Always apply the ServiceContractAttribute to an interface

Named Parameter Options for the ServiceContractAttribute

Name Specifies a different name for the contract instead of the default, which is simply the interface or class type name. This contract name is what will appear in the portType name when consumers access the WSDL.

Namespace Specifies a target namespace in the WSDL for the service. The default

namespace is http://tempuri.org

CallbackContract Associates another Service contract as a Callback contract. This sets up the infrastructure for a duplex MEP and thereby allows the service to initiate sending messages to the client.

ProtectionLevel Enables the Service contract to specify constraints on how messages to all operations in the contract are protected on the wire, that is, whether they are signed and encrypted.

ConfigurationName Specifies the name attribute of the service element in a configuration file. The default is the name of the service implementation class, that is, the service type.

SessionMode Specifies whether sessions should be enabled by the endpoint exposing this Service contract.

The OperationContractAttribute

The OperationContractAttribute, also defined in the System.ServiceModel namespace, can be applied only to methods. It is used to declare the method as belonging to a Service contract.

Named Parameter Options for the OperationContractAttribute

Name Specifies a different name for the operation instead of using the default, which is the method name.

Action Controls the action header for messages to this operation.

ReplyAction Controls the action header for response messages from this operation.

IsOneWay Indicates whether the operation is one-way and has no reply. When operations are one-way, ReplyAction is not supported.

ProtectionLevel Enables the Service contract to specify constraints on how messages to all operations in the contract are protected on the wire, that is, whether they are signed and encrypted.

ProtectionLevel property of the ServiceContractAttribute.

IsInitiating Indicates whether invoking the operation initiates a new session between the caller and the service.

IsTerminating Indicates whether invoking the operation terminates an existing session between the caller and the service.

The MessageParameterAttribute

The MessageParameterAttribute, also defined in the System.ServiceModel namespace, controls how the names of any operation parameters and return values appear in the service description, that is, how they are emitted as part of the WSDL for the service. This attribute has only one property, the Name property.

Fault Contracts

Faults vs. Exceptions The first thing to realize is that faults and exceptions are not the same thing. Exceptions, as referred to here, are a .NET mechanism used to communicate problems encountered as a program executes. Alternatively, faults, refer to the SOAP fault mechanism for transferring error or fault conditions from a service to a consumer. The SOAP specification includes a definition for SOAP faults, providing structure for the contents of the message body when errors occur. This makes it possible for all the different SOAP stacks to issue faults in a standard way.

WCF FaultException Class WCF provides a FaultException class (there are actually two versions of it) that is the standard mechanism for translating between the two worlds of .NET exceptions and of SOAP faults. That is, when your service implementation throws a Fault-Exception, the WCF plumbing thereafter takes care of serializing that back to the consumer as a SOAP fault. This class comes in two forms:

�� FaultException Used to send untyped fault data back to the consumer.

�� FaultException A generic version used to send typed fault data back to the client, where TDetail represents the type parameter for the detailed fault information to be serialized back to the consumer as part of the SOAP fault message. If you have some class of objects that you use to bundle up your fault details, you can specify it as the type parameter for this generic exception class. Clients catching the exception can access the detailed fault information by getting it from the exception object’s Detail property.

The FaultContractAttribute The FaultContractAttribute, also defined in System.ServiceModel, enables a service developer to declare which faults a given service operation might issue if things go wrong. Following are the key pieces of information pertinent to working with the

FaultContractAttribute:

The attribute can be applied to operations only.

�� The attribute is not inherited.

�� The attribute can be applied multiple times; for instance, if your service operation might return different types of faults, you would have a FaultContractAttribute declaration for each type of fault.

�� The attribute’s constructor takes a Type object used to reference the .NET type of the Detail object, that is, the type of fault information details you want to bundle with your faults.

Message Exchange Patterns

MEPs describe the protocol of message exchanges a consumer must engage in to converse properly with the service.

· Request/Response – Default.

· OneWay - setting the IsOneWay property on the OperationContractAttribute to true.

· Duplex

Data Contracts

Data contracts are the contractual agreement about the format and structure of the payload data (that is, the SOAP body) in the messages exchanged between a service and its consumer. the WCF Data contract language defines the structure of data in your WCF service messages Data contracts are declared by applying the DataContractAttribute to a .NET type, and you will need to decorate that type’s members that you want to include in the Data contract with the DataMemberAttribute.

Named Parameter Options for the DataContractAttribute

Name Determines the type name as it is generated in the resulting schema. The default is the .NET type name as it is declared.

Namespace Sets the target namespace for the schema. This defaults to http://schemas.datacontract.org/2004/07/[CLR namespace], where [CLR namespace] is the namespace in which the complex type is defined.

The DataMemberAttribute

The DataMemberAttribute, also part of the System.Runtime.Serialization namespace, is applied only to members and is used to declare that the member should be included in the serialization of the data structure.

Named Parameter Options for the DataMemberAttribute

Name Controls the schema element name generated for the member (that is, the field or property) the attribute adorns. The default behavior is to use the field or property name as defined in the .NET type.

IsRequired Controls the minOccurs attribute for the schema element. The default value is false, that is, the element is optional, which translates into minOccurs = 0.

Order Controls the order of each element in the schema. By default, if this property is not set explicitly, the data members appear alphabetically, followed by elements for which this property is set explicitly.

EmitDefaultValue Controls whether default values will be included in the serialization. This property is true by default, so that all data members are serialized. If this property is set to false, any member that is set to its default value for its type (for instance, null for reference types) will not be serialized.

The EnumMemberAttribute

it is used to declare that a given element of an enum that has been declared with a DataContractAttribute should be considered as part of the Data contract. The only property (or named parameter) is the Value property, which can be used to provide an enumerated value to

be serialized. The default is its actual value within the enumeration.

Opt-In vs. Opt-Out

The DataContractSerializer, the new default WCF serializer, operates in an opt-in mode that is the opposite of its predecessor, the XmlSerializer. That is, with the DataContractSerializer, members that are to be part of the Data contract must be explicitly marked as such, whereas with the XmlSerializer, members are assumed to be in the Data contract unless explicitly

marked as opting out.

CollectionDataContractAttribute

You can use this attribute to annotate your own custom collections, and the resulting collection will

always be exposed to its WCF consumers as a List collection.

Known Types

WCF also supplies you with the KnownTypeAttribute, which enables you to designate acceptable

derived classes for a given Data contract.

// C#

[DataContract()]

[KnownType(typeof(LoanApprovalTask))]

class Task

{ // Etc...

}

[DataContract()]

class LoanApprovalTask : Task

{ // Etc...

}

When working with polymorphic types in your Service contract, the KnownTypeAttribute is

required because polymorphism is outside the paradigm of service orientation.

The MessageContractAttribute The MessageContractAttribute can be applied to classes and

structures to define your own message structure. It has several properties

Named Parameter Options for the MessageContractAttribute

Named Parameter Description

IsWrapped If true, the message body includes a wrapper element named by using the Message contract type or the WrapperName if specified. If false, the message body is unwrapped, and body elements appear directly beneath it.

ProtectionLevel Enables the Service contract to specify constraints on how messages to all operations in the contract are protected on the wire, that is, whether they are signed and encrypted.

WrapperName Supplies a custom name for the body wrapper element.

WrapperNamespace Supplies a namespace for the body wrapper element.

The MessageHeaderAttribute The MessageHeaderAttribute can be applied to members of a Message contract to declare which elements belong among the message headers.

Named Parameter Options for the MessageHeaderAttribute

Name Controls the name of the serialized header element.

Namespace Supplies a namespace for the header element and its children unless otherwise overridden at the type level.

ProtectionLevel Enables the Service contract to specify constraints on how messages to all operations in the contract are protected on the wire, that is, whether they are signed and encrypted.

Actor A URI value indicating which actor is the intended target of the header. By default, the receiving service is assumed.

MustUnderstand Indicates whether the recipient of the header (designated through the Actor property) is required to process this header. If this property is set to true and the actor doesn’t understand the header, the actor should issue a fault.

Relay Indicates whether this header should be forwarded to the next recipient of the message in the event the message is not being processed by the actor.

The MessageBodyMemberAttribute The MessageBodyMemberAttribute can be applied to members of your Message contracts to declare which elements belong within the message body. Recall that if IsWrapped is set to false on the MessageContractAttribute, these elements will be direct children of the SOAP body element. If IsWrapped is set to true, they will be wrapped within a child element, an element named using either the WrapperName property if it is set

explicitly or the Message contract name.

Named Parameter Options for the MessageBodyMemberAttribute

Name Controls the name of the serialized body element.

Namespace Supplies a namespace for the body element and its children unless otherwise overridden at the type level.

ProtectionLevel Enables the Service contract to specify constraints on how messages to all operations in the contract are protected on the wire, that is, whether they are signed and encrypted.

Supplying Custom Headers You might sometimes need to send along private elements in your SOAP messages, and defining Message contracts supports this. Two common reasons for doing this are that:

�� You have your own security mechanism in place, so you need to pass along your own

authentication token in a private SOAP header.

�� Consumers of your service might have to include some sort of license key (or developer’s

key) to access the service at run time. In such cases, a SOAP header is a reasonable place

for such a field.

Serialization : WCF provides two serializers

�� The DataContractSerializer, new with WCF

�� The XmlSerializer that has been part of .NET from the outset

The Format Attributes

WCF provides two attributes, namely XmlSerializerFormatAttribute and DataContractFormat-Attribute, that you can use to declare that WCF uses a specific serializer, namely the Xml- Serializer and the DataContractSerializer, respectively. Both of these attributes have a Style property that enables you to control which style of SOAP is to be used, Rpc (remote procedure call) or Document. The XmlSerializerFormatAttribute has another property, called Use, that enables you to control whether the serializer uses the Literal or Encoded approach to

constructing SOAP messages.

Ex. [ServiceContract()]

[DataContractFormat(Style=OperationFormatStyle.Rpc)]

interface ISomeRpcService2

{

[OperationContract()]

string SomeOp2( string name);

}

· For both the DataContractFormatAttribute and the XmlSerializerFormatAttribute, the

default style is Document.

· The DataContractSerializer is the default serializer WCF use

The DataContractSerializer vs. the XmlSerializer

The DataContractSerializer has the following benefits:

�� Its opt-in approach provides nice control over Data contracts for developers. Your Datacontract classes can be equipped with other elements and validation logic that need not be opted in.

�� It is very fast. It is targeted at a very small, simple subset of the XML InfoSet and is focused on speed instead of on being comprehensive.

ASP.NET Objective type questions and Answers

noreply@blogger.com (amitmittal77) — Wed, 23 Sep 2009 21:05:00 +0000

ASP.NET

Note: All the questions have a single correct answer unless specifically mentioned in the question

What is the default value for the Method attribute in a ASP.NET server-side Form control
1. GET
2. POST
3. SOAP
4. SMTP
Which property allows ASP.NET controls to maintain their values when a page is posted to itself.
1. EnableViewState
2. MaintainValue
3. SaveValue
4. AutoPostBack
In a ASP.NET page, which is the best way to find if the contents of a TextBox has changed after the form containing the TextBox has been posted back to the server
1. By comparing the old value with the new value
2. By checking the NewValue property of the TextBox control
3. By handling the TextBox control's TextChanged event
4. By checking the HasChanged property of the TextBox
Which statement among the ones below is correct
1. The Params and Forms collection of the HTTPRequest class are exactly same and the Forms collection has been provided only for backward compatibility
2. The HTTPRequest class does include the Params collection
3. The HTTPRequest class does include the Forms collection
4. The difference between the Params and Forms collection of the HTTPRequest class is that the Params collection also represents QueryStrings, ServerVariables, and Cookies
Which statement among the ones below is correct
1. If you use the server-side version of the <form> tag, you cannot post the form to a different page.
2. You can modify the Action attribute of the server-side version of the <form> tag to post the form to a different page
3. You have to set the Method and Action attributes of the server-side version of the <form> tag to post the form to a different page
4. You can use the SetAction() method of the server-side version of the <form> tag to post the form to a different page
If a form is posted to a different page, the you can retrieve the values of the form elements by
1. Using the properties of the ASP.Net controls
2. Using the GetElementByID() method
3. Using Request.Params
4. The values cannot be retrieved
You are performing Form validations with Validation controls. You need to group all the errors at the top of the page and also show error messages besides each element. The messages besides each element need to be detailed and hence different from the messages at top of the page
1. You can use the ValidationSummary Control to summarize the messages set in the ErrorMessage property of the Validation controls. The messages set in the Text property of the Validation controls can be displayed besides each element.
2. The error messages set in the SummaryText property of each Validation control having isSummary=true will be automatically grouped at the top of the page and the messages set in the Text property can be displayed besides each element.
3. The error messages in the Validation control can only be displayed in a popup
4. The Validation controls cannot be used in the given scenario
How do view states work
1. Using Cookies
2. Using a hidden form field
3. Using Session variables
4. Using Application variables
You need to dynamically add a TextBox control to a page and display it at specific location
1. Place a Label control at the required location in the page and add the control by manipulating the Text property of the Label control
2. Place a PlaceHolder control at the required location in the page. Use the Add method of the Controls collection of the PlaceHolder control to dynamically add the required control
3. Build the HTML for the entire page in a String and insert the HTML code for required control in required place
4. You cannot add a control to a page dynamically
You require to create an ASP.NET page with the functionality to allow a user to upload a file to the server
1. You need to use the System.Web.Upload namespace
2. You need to use a COM component to save the file on the server
3. You need to use the SaveAs method of the HttpPostedFile class
4. The ASP.Net application automatically loops through all the <input type="File"> and saves the uploaded files to a virtual folder called "uploads"
You need to programmatically add a user control without using the Register directive in your code
1. Use AddUserControl
2. Use cannot programmatically add a user control
3. Use UserControl.Add
4. Use LoadControl
You need to develop a business component myComp.dll in .Net and use it in your ASP.NET page
1. You require to register the component using regsvr32.exe
2. You require to register the component using TlbExp.exe
3. You require to copy the component to the /bin directory in your applications root directory
4. You require to copy the component to the /bin directory in your applications root directory and register the component using regsvr32.exe
Is it possible for multiple aspx pages to use the same code-behind file, if required
1. Yes
2. No
How is a ASP.NET presentation page associated with its code-behind
1. The presentation page includes the code-behind file using #include
2. The presentation page includes the code-behind file using <@ Page include="codebehind file name">
3. The presentation page inherits from the code-behind
4. The ASP.NET presentation page and the code-behind page have the same name and hence are automatically associated with each other
Which namespace would you use if you need to create an ASP.NET application with Microsoft SQL Server 2000 as the database.
1. System.Data.SQLServer
2. System.Data.SQLClient
3. System.Data.OleDb
4. System.Data.Microsoft
Which namespace would you use if you need to create an ASP.NET application with Oracle as the database.
1. System.Data.SQLServer
2. System.Data.SQLClient
3. System.Data.OleDb
4. System.Data.NonMS
Which statement among the following is correct while opening a connection using the SQLConnection class
1. You cannot specify a connection string
2. You need to specify a Provider parameter for the connection string
3. You need to use a System DSN
4. You cannot use a DSN
What method of the Command object would you use if you need to retrieve a single value (for example an aggregate value) from a database
1. ExecuteScalar()
2. ExecuteReader()
3. ExecuteSingle()
4. ExecuteNonQuery()
Which are the two things you need to take care of in your ASP.Net application to take advantage of connection pooling (select two)
1. You need to set the Pooling property of the Connection object to True
2. You need to use the same exact connection string whenever you open a database connection
3. You need to call the ReleaseToPool() method after the connection is closed
4. You need to explicitly close the connection with the Close() method
You have created a ASP.Net page Transaction by using <% Transaction = "Required" %>
1. If a transaction already exists, the page will execute within the context of the transaction. However it will not create a new transaction
2. If a transaction already exists, the page will execute within the context of the transaction. If a transaction does not exist, it will create a new one
3. Creates a new transaction for each request
4. You cannot created a ASP.Net page Transaction by using <% Transaction = "Required" %>
You need to retrieve only schema information about the columns contained in a database table without retrieving data. Which of the following is the best way to retrieve it
1. Use the GetSchemaTable() method of the DataReader in conjunction with CommandBehaviour.SchemaOnly
2. Use the SchemaOnly property of the Command class
3. Use the GetSchemaOnly() method of the DataReader
4. You cannot retrieve only schema information without retrieving data
Consider the following example

<Script Runat="Server">
Dim intNextNum As Integer
Sub Page_Load
lblMessage1.DataBind()
lblMessage2.DataBind()
DataBind()
End Sub

Function GetNext() As String
intNextNum += 1
Return intNextNum
End Function
</Script>

<html>
<head><title>DataBindTest2.aspx</title></head>
<body>
<form Runat="Server">
<asp:Label ID="lblMessage1" Text='<%# GetNext() %>' Runat="Server" />
<asp:Label ID="lblMessage2" Text='<%# GetNext() %>' Runat="Server" />
</form>
</body>
</html>

What will be the values assigned to the two Label controls lblMessage1 & lblMessage2 respectively
1. 2 & 3
2. 3 & 3
3. 3 & 4
4. 4 & 4
You need to customize the display format of the DataList control
1. Set the DisplayFormat property of the DataList control to Custom
2. Set the CustomFormat property of the DataList control to True
3. ItemTemplate will allow you to format the appearance of each DataList item
4. The display format of the DataList control is predefined and cannot be customized
You have a DataList control containing a LinkButton. What would you do to raise the DeleteCommand event in the DataList by clicking on the LinkButton.
1. Set CommandName="delete" in the LinkButton
2. Set the OnDelete property of the DataList to the ID of the LinkButton
3. A DataList control cannot raise an event in response to events raised by its child controls
4. A DataList control cannot contain child controls
The Products table has a column named ProductName and a primary key column named ProductID. When a user selects an item in the DataList, you want to retrieve the value of the ProductID column associated with it.
1. In the DataList control set PrimaryKeyField="ProductID"
2. In the DataList control set DataKeyField="ProductID"
3. In the DataList control set KeyField="ProductID"
4. In the DataList control set ID="ProductID"
You need to enable paging for a DataGrid control
1. You can use a DataReader
2. You can use a DataTable
3. You can use either the DataReader or DataTable
4. A DataGrid does not support paging
Can you use a DataView to filter rows in a DataTable
1. Yes, by setting the Filter property of the DataView
2. Yes, by setting the RowFilter property of the DataView
3. Yes, by using the SetFilter() method of the DataView
4. No, a DataView cannot be used to filter rows in a DataTable
Which statement is an accurate description of the code below (dtsDataset is a DataSet)

Cache("myCachedDataSet") = dstDataset
1. Adds a DataSet to the application's cache in the server's memory, automatically preserving it between page requests.
2. Adds a DataSet to the cache in the client's memory, automatically preserving it between page requests.
3. The Cache object cannot be used to cache a DataSet, it can only cache a DataTable
4. The code block is syntactically incorrect and should actually be
  Set Cache("myCachedDataSet") = dstDataset
How can you load an XML file directly into a DataSet
1. By setting the XML property of the DataSet class
2. By using the GetXML() method of the DataSet class
3. By using the ReadXml() method of the DataSet class
4. You cannot load an XML file directly into a DataSet
Your site has been restructured and the paths of few pages have changed. Which method would you use to redirect users requesting for a pages using the old URL
1. Create an ISAPI filter to do the above task
2. Create an entry in the <badlinks> section of the Web.Config file
3. Use the Application.Config file
4. Handle the Application_BeginRequest event and use the RewritePath() method
Which statement about the Web.Config file is the most accurate
1. The Web.Config file can be only placed in the root of a Web Site to override settings in the Machine.Config file for all applications in a particular Web Site
2. The Web.Config file can only be placed in the root of a particular virtual directory
3. The Web.Config file can be placed in the root of the Web Site and the root of a virtual directory. The settings from the file in the virtual directory overrides the settings from the file in the Web Site
4. The Web.Config file can be placed in the root of the Web Site and the root of a virtual directory and in any subdirectory of an application. The settings from a file at a particular level override the settings from the ones above it.
The settings in the Web.Config file are case-sensitive
1. True
2. False
The settings in the Web.Config file can be configured to apply to
1. An application
2. An application or a particular directory
3. An application or a particular directory or even an individual file
4. The Web.Config file always applies to all pages in the current directory and its subdirectories
Is there a way to prevent configuration settings in a Web.Config file from being overridden by a Web.Config file located below it
1. Yes, you can use the allowOverride attribute in the <location> tag to prevent configuration settings in a Web.Config file from being overridden by a Web.Config file located below it
2. Yes, you can use the <PreventOverride> tag to prevent configuration settings in a Web.Config file from being overridden by a Web.Config file located below it
3. If a Web.Config file exist at a particular level then all settings in the Web.Config file located above it are always ignored
4. You cannot have more than one Web.Config file in an ASP.NET application
If you have an ASP.NET application with cookieless sessions enabled, which statement among the
1. You cannot use relative URL's with cookieless sessions
2. You cannot use absolute URL's with cookieless sessions
3. Cookieless sessions have no relation with URL's
4. You cannot have cookieless sessions with an ASP.NET application
You are part of a team that is using Visual Studio .NET to develop a Web application. You have placed a number of configuration settings for the application in the server's Machine.config file. You learn in a meeting that one of your co-workers has created a Web.config file to store these settings, though in comparing notes you realize that you and your co-worker have used different settings.

Which of the following describes what will happen when you execute the application
1. The application will run correctly and will use the settings in the Web.config file, ignoring the Machine.config settings
2. The application will run correctly and will use the settings in the Machine.config file, ignoring the Web.config settings
3. The application will not run correctly until you either remove the Web.config file or delete the settings from the Machine.config file
4. The application will run correctly, using only the settings that are identical in the Web.config and Machine.config files
5. The application will not run correctly until you modify either the Web.config file or the Machine.config file so that the application settings are identical
You are preparing to deploy an ASP.NET Web application. You are currently creating the deployment project. You have started the Web setup project, which is named AccountManagerDeploy, and added the application output to the project, and now you need to set the directory on the Web server to which the application will be installed. Which of the following procedures should you use to do so (Choose two. Each correct answer presents part of the solution.)
1. Set the VirtualDirectory property in the Properties window.
2. Select the Web Application Folder in the File System Editor.
3. Select the AccountManagerDeploy project in the Solution Explorer.
4. Set the Folder property in the Properties window.
5. Select the Primary output from AccountManagerDeploy icon in the Solution Explorer.
You are part of a team that is using Visual Studio .NET to develop a Web application. You are looking through the files in the application, and you see the following files:

createmembership.aspx
createmembership.aspx.vb

Which two of the following statements most accurately describe these two files (Select two.)
1. The createmembership.aspx.vb file is a Web form, which displays a user interface to the user
2. The createmembership.aspx file is a code file, which contains code that interacts with the user interface in the Web form
3. The createmembership.aspx file is an uncompiled file that will become createmembership.aspx.vb when it is compiled
4. The createmembership.aspx.vb file is a code file, which contains code that interacts with the user interface in the Web form
5. The createmembership.aspx file is a Web form, which displays a user interface to the user
6. The createmembership.aspx.vb file is the compiled version of createmembership.aspx
You are using Visual Studio .NET to develop a Web application. You are beginning to debug your application, and you would like to store debug messages in the Windows event log as you proceed with testing. Which of the following will allow you to do so
1. TextWriterTraceListener
2. DefaultTraceListener
3. EventLogTraceListener
4. TraceSwitch
You are using Visual Studio .NET to develop a Web application for a large video rental store. The titles, as well as other information about the store's videotapes, laser disks, DVDs, and audio books, are stored in a SQL Server 2000 database.

The store wants to allow visitors to its Web site to browse the list of titles sorted in various ways, such as by medium (VHS, DVD, etc.), genre, director, and so on. You have created a number of stored procedures to facilitate the different ways of presenting the data.

Given an existing DataSet named dsVids and a Connection named conn, which of the following code examples illustrates the correct way to call the stored procedure named ListDVDTitles that returns the list of DVD titles
1. Dim daDVDList as New SqlDataAdapter()
  daDVDList.SelectCommand = New SqlCommand()
  daDVDList.SelectCommand.Connection = conn
  daDVDList.SelectCommand.CommandText = "ListDVDTitles"
  daDVDList.SelectCommand.CommandType = CommandType.StoredProcedure
  daDVDList.Fill(dsVids, "Titles")
2. Dim daDVDList as New SqlDataAdapter()
  daDVDList.SelectCommand = New StoredProcedure()
  daDVDList.SelectCommand.Connection = conn
  daDVDList.SelectCommand.CommandText = "ListDVDTitles"
  daDVDList.SelectCommand.CommandType = CommandType.SQLCommand
  daDVDList.Fill(dsVids, "Titles")
3. Dim daDVDList as New SqlDataAdapter()
  daDVDList.SelectCommand = New SqlCommand()
  daDVDList.SelectCommand.Connection = "ListDVDTitles"
  daDVDList.SelectCommand.CommandType = CommandType.StoredProcedure
  daDVDList.Fill(dsVids, "Titles")
4. Dim daDVDList as New SqlDataAdapter()
  daDVDList.SelectCommand = New SqlCommand()
  daDVDList.SelectCommand.CommandText = "ListDVDTitles"
  daDVDList.SelectCommand.CommandType = CommandType.StoredProcedure
  daDVDList.Fill(dsVids, "Titles")
You are using Visual Studio .NET to create an ASP.NET application that will serve as a Web service. You are preparing to debug the Web service, and you need to enable debugging in the Web.config file.

Which of the following represents the proper format for enabling debugging in your Web service through the Web.config file
1. <compilation defaultLanguage="VB">
  <debug="true">
2. <compilation defaultLanguage="VB">
  <Debug="on">
3. <compilation defaultLanguage="VB"
  Debug="true">
4. <compilation defaultLanguage="VB"
  debug="true">
5. <compilation defaultLanguage="VB">
  <Debug="true">
6. <compilation defaultLanguage="VB">
  <debug="on">
7. <compilation defaultLanguage="VB"
  debug="on">
8. <compilation defaultLanguage="VB"
  Debug="on">
You are creating a Web service that will include a Web method. You want the method to return its data to the caller as it is created and put into a serial stream, rather than waiting for all of the data to be prepared before returning it. Which of the following WebMethod attributes should you set to enable this
1. <WebMethod(EnableSession:=True)>
2. <WebMethod(BufferResponse:=False)>
3. <WebMethod(EnableSession:=False)>

<WebMethod(BufferResponse:=True)>