Obviously
the limitations of ASMX have led the revolution of WCF. So what are those limitations
for ASMX?

The revolution of ASMX came into existence
when you had to talk to get data from other service providers before the ASMX
companies used to have their own common standard mechanism to converse the
trade in the between the companies like EDI or calling a asp  pages. A company would publish their
application as ASMX only if it was really distributed or enterprise
application, so enterprise or distributed application is usually built on ASMX
along with WSE extensions, MSMQ, COM and .NET and as we know from our
experience that there were countless successful apps built on these concepts so
Microsoft realized they have too many layers.

The
limitations of ASMX

1. RPC calls
2. Dependent on
   HTTP/IIS
3. Classic XmlSerializer

So,
Microsoft realized lets upgrade ASMX so that it can serve for other protocols
and later realize why can’t we do the same for HTTP protocol which evolve WCF –
basicHTTP

Let’s look into the difference between ASMX
and WCF

ASMX

• Uses XmlSerializer
• Serializes only Public methods
• Soap Extentions, Customized SOAP Messages
• Requires HTTP transportation with IIS
• .asmx
• Role-based security
• Unhandled exceptions are handled as SOAP Faults
• Soap Exception is generic exception to handle errors
• Uses HTTPContext Object for state storage

WCF

• Uses DataContractSerialzier
• Serializes all methods including private methods
• However it does support XmlSerialization
• Soap Extentions arent supported
• Transportation protocols HTTP. TCP, MSMQ, named pipes
• .svc
• You can still use asmx for WCF just to support asmx client apps
  just by adding handler on the app.config
• Supports Claims based security model  and doesn’t depend on WSE mechanism
• Unhandled exception thorws a SOAP Faults but you override this behavior
  by adding a servicedebug element
• Faultexception<T> where T is the datacontract , you can use
  DataContract to define FaultContract
• ·
  You can use HTTPContext Object and as well
  implement System.ServiceModel.IExtensibleObject<T>
  interface (ServiceHostBased and InstanceContext)
• ServiceHostBased allows access to
  all the service instances in the same host to access the same state data. The instancecontext
  allows only in one instance

Code Samples
for WCF

         <system.web>
    <compilation>
        <compilation debug="true">
            <buildProviders>
                <remove extension=".asmx"/>
                <add extension=".asmx"
                     type="System.ServiceModel.ServiceBuildProvider,
                     Systemm.ServiceModel,
                     Version=3.0.0.0,
                     Culture=neutral,
                     PublicKeyToken=b77a5c561934e089" />
            </buildProviders>
        </compilation>
    </compilation>

</system.web>

<configuration>
    <system.serviceModel>
        <services>
            <service name="Service ">
                <endpoint
                    address="EmployeeService"
                    binding="basicHttpBinding"
                    contract="IEmployeeService "/>
            </service>
        </services>
    </system.serviceModel>
</configuration>

[DataContract]

public
class FindEmployeeFault

{

[DataMember]

public string Request;

[DataMember]

public string Description;

}

[ServiceContract]

public
interface IEmployeeManager

{
[OperationContract(Action = "FindEmployeeByLastName")]
[FaultContract(typeof(EmployeeService.FaultContracts.FindEmployeeFault))]
EmployeeService.DataContracts.Employee FindEmployeeByLastName(string request);

}

having experience with designing several applications, some time or the other i run into a situation which strategy should i adopt for data transformation either DataSets OR typed DataSets OR custom collections OR plain XML

What is Our problem?

 Imagine those common three logical layers—presentation and interface services, business logic with core functionalities, and data access, where all database stuff and messaging happens.

When considering factors such as the ability to cascade changes (such as new data schemas) through layers and the amount of overhead involved when data is moved from one layer to the next. Plus you need a business tier to execute your business logic, and you need a DAL to provide Create/Read/Update/Delete (CRUD) functions to the rest of the system. There are two primary ways to provide this functionality—by using a commercial Object/Relational (O/R) mapping tool or by rolling your own DAL.

An O/R mapper works by mapping custom objects to entities into a relational database. Through an XML file or any other form of a settings container, the tool shields you from relying on any knowledge of the underlying database. You work with domain-specific objects provided to you by the mapper. On the opposite end of the spectrum is the other more common approach, building your own DAL. Here your primary problem is making a decision about the mechanism used to pass data around.

All things considered, I’d say that four options are worth spending some time on:

unTyped DataSets, typed DataSets, custom collections, and plain XML.

Plain XML

Using plain XML text is the least attractive option even though it provides full integration with any other platform. It is weakly typed, hard to maintain, performs poorly, and is not a powerful programming interface in the context of an enterprise app.

DataSets – Good and Bad

Good

The DataSet is designed to be a general-purpose container of any information that can be expressed in a tabular format

The DataSet was not specifically designed to work with databases, but it does fit well into a pure database scenario. The DataSet was designed to be a datacentric container which you can populate with tabular data from virtually any source

ADO.NET provides a family of objects that bridge DataSets to databases in an intelligent way using DataAdapters

With a DataSet object you can easily pack and transmit any sort of data and combine interrelated data from different sources and tables. In addition, the DataSet is serializable, has integrated XML capabilities, has built-in support for optimistic concurrency, and the ability to define and handle complex relationships between contained tables

If you think of your application design with a SQL Server™ or ADO.NET mindset, opting for the DataSet is a natural choice, and probably the only one you would ever think of.

Bad

The DataSet implements a serialization algorithm that performs less than optimally as the DataSet grows to thousands of rows especially if it uses XMl Serializarion but in 2.0 it uses binary serialization which is pretty fast.

In complex scenarios, where you need to employ smarter objects with their own behavior that are fully representative of business entities, the DataSet is simply the wrong tool. It’s the proverbial hammer that makes everything look like a nail.

having DataSets at work in a complex enterprise application with articulated business logic and interoperating entities may not

DataSets should not be used with Web services or, at least, they should not be the sole possible return value of a Web method. You should use Web method overloading (each overload of the same functionality with its own exposed name) and return the same data in other simpler formats

Collection Basics

A collection is a set of homogeneous objects that are managed through the interface of a container class

  Collection Interfaces in the .NET Framework

Collection Classes in the .NET Framework

Choose a Collection Class

Most of the above mentioned collection classes aren’t strict with custom business entites, but if we really want strict collection classes then we have to build custom class

How do we build a custom class

Basics

More or less we have to inherit from most of these interfaces mentioned below

  Collection Interfaces in the .NET Framework

With above lines of definitions, let do a illustration

OrderInfo Class, Could be an entity class

using System;

using System.ComponentModel;

namespace Msdn.CuttingEdge.Samples

{

    [Serializable]

    public class OrderInfo

    {

        private int m_id;

        private DateTime m_date;

        private int m_employeeID;

        private string m_customerID;

        public OrderInfo() {}

        public OrderInfo(int id)

        {

            m_id = id;

        }

        public OrderInfo(int id, DateTime date) : this(id)

        {

            m_date = date;

        }

        public int ID

        {

            get {return m_id;}

        }

        public DateTime Date

        {

            get {return m_date;}

            set {m_date = value;}

        }

        public string CustomerID

        {

            get {return m_customerID;}

            set {m_customerID = value;}

        }

        public int EmployeeID

        {

            get {return m_employeeID;}

            set {m_employeeID = value;}

        }

    }

}

OrderCollection Class

using System;

using System.Collections;

namespace Msdn.CuttingEdge.Samples

{

    public class OrderCollection : CollectionBase

    {

        // Class constructor

        public OrderCollection() {}

        // Add method

        public void Add(OrderInfo o)

        {

            InnerList.Add(o);

        }

        // Indexer property

        public OrderInfo this[int index]

        {

            get { return (OrderInfo) InnerList[index]; }

            set { InnerList[index] = value; }

        }

    }

}

Fill the Collection

OrderCollection orders = new OrdersCollection(year);

OR

public class OrderCollection : Collection<OrderInfo> {}

 Generics-Powered Collection-Related Classes in .NET

ADO.NET Connections
          One way to reduce the number of connections is to reuse connections through connection pooling.

Open Late, Close Early
keep the connection open only as long as you need it.

Returning a Single Column or Row
            

• When you want to execute an action query and do not want to return any data, use the Command object’s ExecuteNonQuery method
• If you want to retrieve a single value, the ExecuteReader, ExecuteXmlReader, and Fill methods are usually overkill. If you use the DataAdapter’s Fill method to fill a DataSet with a single column and a single row, you are also getting all of the metadata and overhead that comes with the more powerful DataSet object. It would be more efficient to use the Command object’s ExecuteScalar method.
• If all you need are a handful of values from a single row, using the ExecuteScalar (for 1 value) or output parameters executes faster than retrieving a rowset into a DataSet, and then having to pass that data to another application tier

Inefficient Queries
              

• A SELECT statement should only return the columns that are going to be used, possibly for display purposes or some business logic. For example, suppose I return 100 rows of data and you retrieve two extra integer columns that are not used anywhere. Each integer column is 4 bytes, so I am returning 8 bytes per row or 800 extra unused bytes of data. Then, when inserted into a DataSet, which may be passed to another application layer, the XML and supporting metadata that is needed for the extra columns adds to that total.
• Superfluous data from the database server to my business logic server and then passing extra data around as XML to services
• When a SELECT statement retrieves more rows than it needs. For example, returning 100 rows is overkill when you will only display the top 10. It’s better to trim the SELECT statement to retrieve only the top 10 records, using the TOP keyword
• I recommend avoiding the CommandBuilder object entirely at run time.
• Another key point I look for in reviews of SQL code and stored procedures is excessive joins.

Commands and Parameters

• Avoid Sql Statements.
• If you really want to use SQL statement use Prepare command with it

ADO.NET Transactions

• Like connections, transactions should be kept as short as possible

Steps
1. Create a Sample class library
2. Implement custom XML attributes
3. Write Client Call to serialize to XMLString

Example
Create a Sample class library & Implement custom XML attributes

namespace ExpShoppingList
{
[XmlRoot("shoppingList")]
public class ShoppingList
{
    private ArrayList listShopping;

    public ShoppingList()
    {
        listShopping = new ArrayList();
    }

    [XmlElement("item")]
    public Item[] Items
    {
        get
        {
            Item[] items = new Item[listShopping.Count];
            listShopping.CopyTo(items);
            return items;
        }
        set
        {
            if (value == null) return;
            Item[] items = (Item[])value;
            listShopping.Clear();
            foreach (Item item in items)
                listShopping.Add(item);
        }
    }

    public int AddItem(Item item)
    {
        return listShopping.Add(item);
    }

    public void LoadData()
    {
        this.AddItem(new Item(“eggs”, 1.49));
        this.AddItem(new Item(“ground beef”, 3.69));
        this.AddItem(new Item(“bread”, 0.89));
    }
}

// Items in the shopping list
public class Item
{
    private string _name;
    [XmlAttribute("name")]
    public string name
    {
        get { return _name; }
        set { _name = value; }
    }
    [XmlAttribute("price")]
    public double price;

    public Item()
    {
    }
    public Item(string Name, double Price)
    {
        _name = Name;
        price = Price;
    }
}

2. Create a Client Porject, which will Call to Serialize the instantiationed object to string

namespace ExportClassTest
{
    class Program
    {
        static void Main(string[] args)
        {

            ExpShoppingList.ShoppingList myList = new ExpShoppingList.ShoppingList();
            myList.LoadData();

            // Serialization
            System.Xml.Serialization.XmlSerializer x = new XmlSerializer(typeof(ExpShoppingList.ShoppingList));
            System.IO.MemoryStream ms = new System.IO.MemoryStream();
            x.Serialize(ms, myList);
            ms.Position = 0;
            ms.Flush() ;
            StreamReader sr = new StreamReader(ms);

            string s = sr.ReadToEnd();

           //Console.ReadLine();
        }
    }
}

Instantiation
you dont need to create a object variable and assign the instantiation to it.

Example
new MyClass().AddMethod(12,35) ;

Extensions
Declare a Class and add Static class with Extensions keyword under the same namespace
that will add all methods of Static class Extensions to all classes in that namespace

Example

class Class1
{
    public  Class1()
    {

    }
   public void Method1(string s)
   {
    Console.WriteLine(“Class2.Method1″);
   }
}
static class Extensions
{
  static public void Method1(this object o, int i)
  {
    Console.WriteLine(“Extensions.Method1″);
  }

  static void Main()
  {
    new Class1().Method1(12);   // Extensions.Method1 is called
    new Class1().Method1(“12″); // Class1.Method1 is called
  }
}

Caveats

the Method invocation works is decided at runtime with signature of each functoin call, meaning should it invoke class method or static method
Offcourse the precedence is always the class method not the static method when you have the same signature

Conclusion
this is simlar to polymorphism (Overrides and override), but there it is constraint to only one class here it is global to the namespace

Var keyword
the var keyword comes from the JS Scripting language and i love using it
My programming was built on foundation of VB and continuing with VB.NET, a guy like me likes that “option sctrict off”
where it allows you to declare generic Object like System.Object

but it is also available in C# and where it used to give complilation error if you declare object variable

Example
 var processes = new List<ProcessData>();

recomendations
I recommend you to use it with a type not anonymous like
 var processes = new List<of T>();

nevermind i may be wrong, but at the end the compiler creates the code for you and makes your life easy

ObjectInitializer
All these past years of my programming i hated writing many constructers for each possiblity

looked the old way doing things
static class LanguageFeatures
{
  class ProcessData
  {
    public Int32 Id { get; set; }
    public Int64 Memory { get; set; }
    public String Name { get; set; }
  }
  static void Main(string[] args)
  {
    ProcessData processes = new ProcessData();
    processes.Id =”1″;  
    processes.Name =”devenv.exe”;  
    processes.Memory =”7123456″; 
  }
}

New way of rewriting the code
static class LanguageFeatures
{
  class ProcessData
  {
    public Int32 Id { get; set; }
    public Int64 Memory { get; set; }
    public String Name { get; set; }
  }
  static void Main(string[] args)
  {
    ProcessData processes = new ProcessData(Id=”1″,Name=”devenv.exe”,Memory =”7123456″);
  }
}

Conclusion
it reduces the lines of code and you dont have to deal with parameterised constructors

Anonymous Types
when you think about Types, you could think of int, string and more
if you want to create data collection class,all you get in your mind is property methods key value pair and for individual class and its members

I am really tired of creating classes with property methods.
i found this really cool feature of anonymous types

new { process.Id, Name=process.ProcessName,
          Memory=process.WorkingSet64 }
the line would create a class of type unknown classname with properties {id,Name,memory}

Example if wanted to write in legacy style
class Employee {
    private string _FirstName;
    public string FirstName {
        get
        {
            return _FirstName;
        }

        set
        {
            _FirstName = value;
        }
    }

    private string _LastName;
    public string LastName
    {
        get
        {
            return _LastName;
        }

        set
        {
            _LastName = value;
        }
    }
    private string _DeptName;
    public string DeptName
    {
        get
        {
            return _DeptName;
        }

        set
        {
            _DeptName = value;
        }
    }
}

Collection Class
Class Employees :
                    CollectionBase
    {
        public void Add(Employee empObject)
        {
            InnerList.Add(empObject);
        }

        public void Remove(int index)
        {
            InnerList.RemoveAt(index);
        }
        public Employee Item(int index)
        {
            return (Employee)InnerList[index];
        }
       
    } //end of Employees class

Employees emplys = new Employees()

The New Generation Code using C# Anonymous types
var Employees = new List<Object>();
Employees.Add( new {FirstName=”",LastName=”",DeptName=”"});
Conclusion
offcourse when you start comparing both the old style and new style
the main thing you could see is in the previous one they are predefined one where as the new types late binded
the biggest help for the programmers is the number of lines of code

Anonymous Methods
This is a another anonymous featue, which i have never seen.

this feature is mostly usefull in areas where you use delegates or function pointer

here you will be passing the function implementation code as parameter, but the function will be
executed, when it is invoked

here is a sample Example
  static void DisplayProcesses(Func<Process, Boolean> match)
  {
    var processes = new List<Object>();
    foreach (var process in Process.GetProcesses())
    {
      if (match(process))
      {
        processes.Add( new { process.Id, Name=process.ProcessName,
          Memory=process.WorkingSet64 } );
      }
    }

    ObjectDumper.Write(processes);
  }

  static void Main(string[] args)
  {
    DisplayProcesses(process => process.WorkingSet64 >= 20 * 1024 * 1024);
  }

in the above example method DisplayProcesses, is accepting function implementation for expression oriented
and returns boolean data type.
another example is creating function on fly
Example:
myClass1.MyEvent += delegate(string message)

{

    Console.WriteLine(“your message is: {0}”, message);

};

Shadow and override

shadowing hides the inherited methods from base class,
overriding will override the body implmentation not the signature of the base class
so, if you want to override the signature and body implementation then you have to use “new” keyword

Example

public class InternationalShoppingList : ShoppingList
{
    private ArrayList listShopping;

    public ShoppingList() : base()
    {
        listShopping = new ArrayList();
    }

public new InternationalItem[] Items
{
        get
        {
            InternationalItem[] items = new InternationalItem[listShopping.Count];
            listShopping.CopyTo(items);
            return items;
        }
        set
        {
            if (value == null) return;
            InternationalItem[] items = (InternationalItem[])value;
            listShopping.Clear();
            foreach (InternationalItem item in items)
                listShopping.Add(item);
        }
    }

}

// Items in the shopping list
public class InternationalItem : Item
{
    private string _country;
    public string Country
    {
        get { return _country; }
        set { _country = value; }
    }
}

public class ShoppingList
{
    private ArrayList listShopping;

    public ShoppingList()
    {
        listShopping = new ArrayList();
    }

[XmlElement("item")]
public Item[] Items
    {
        get
        {
            Item[] items = new Item[listShopping.Count];
            listShopping.CopyTo(items);
            return items;
        }
        set
        {
            if (value == null) return;
            Item[] items = (Item[])value;
            listShopping.Clear();
            foreach (Item item in items)
                listShopping.Add(item);
        }
    }

}

// Items in the shopping list
public class Item
{
    private string _name;
    public string name
    {
        get { return _name; }
        set { _name = value; }
    }
    public double price;

    public Item()
    {
    }
    public Item(string Name, double Price)
    {
        _name = Name;
        price = Price;
    }
}

A good metric listed below is the “efficiency” or “cost” of the number of requests per CPU cycle (RPS / CPU Utilization %).  Using this metric, IIS 7.0/W2K8 RTM is over 10% more efficient then IIS 6.0/WS03 SP2in handling live web platform traffic for the site

Listed below the graphical data results is the methodology used in this performance analysis.

Server Efficiency (RPS/ CPU %) – Efficiency of serving live web platform traffic

W2K3 SP2     4.36   “requests per CPU cycle”

W2K8 RTM   4.84   ~ 10.9% increased efficiency

CPU Utilization (%)

W2K3 SP2     44.8%

W2K8 RTM   52.8%   ~ 17.9% degradation (This is impacted by the increased RPS the W2K8 servers are handling)

Web Service – Total Methods Requests/Sec (RPS)

W2K3 SP2     194

W2K8 RTM    255   ~ 31.4% more traffic is being sent to the W2K8 RTM servers

Web Service – Current Connections

W2K3 SP2     280

W2K8 RTM   294   ~ 5% increase

 Load Balancing – Current Client Connections

W2K3 SP2     116

W2K8 RTM   116   Equal – as the hardware load balancer maintains the same amount of outstanding open client connections.

.NET CLR Memory – % Time in GC

W2K3 SP2    1.1%

W2K8 RTM   2.5%  No significant degradation in “Time in GC”

Performance Overview and methodology:

Site: www.microsoft.com 

During this assessment the live www.microsoft.com site was comprised on 80 servers.  There were four load balanced clusters of twenty servers each, located in multiple datacenters.  This performance analysis was developed by using a single twenty server cluster on the www.microsoft.com site.  The cluster is comprised of 19 Windows Server 2008 RTM servers (W2K8 RTM) and a single Windows Server 2003 SP2 (W2K3 SP2) server all taking live internet facing traffic.  This Lone Windows Server 2003 has become quite famous.  In fact, he actually has his own blog located at http://blogs.technet.com/windowsserver/pages/about-lone-server.aspx

Hardware:

  Model: HP DL585 G1 (4 dual-core CPUs)

  RAM: 32GB 

AppPool Mode’s in IIS 7.0

·         Integrated mode[ASp.NET]

·         Classic .NET AppPool

In Previous versions of IIS, the Session of ASP wasnt accessible to ASP.nET. the reason behind in IIS 6 there were two different ISAP dlls[aspnet_ISAPI.dll and asp.dll] for ASP and ASP.NET so they couldnt share the Session and Application objects

Solution : was we can force the asp extension to use ASP.NET handler in IIS 6.0

This is default feature in  IIS 7.0, which is known as Integrated mode

Migrating the Application Configuration
If you simply move the application to IIS7.0 server. it runs this below command.

if you want to disable and not have to run the application
add this to application web.config file
<system.webServer>
<validation validateIntegratedModeConfiguration=”false” />   
</system.webServer

Command to run the ASP.NET application under IIS 7.0 Integration mode

%windir%\system32\inetsrv\APPCMD.EXE migrate config <Application Path>

Where <Application Path> is the virtual path of the application containing the site name, such as “Default Web Site/app1″.

Moving Back to Classic ASP.NET integration Mode

configure your application pool to run under Classic mode

Selecting ASP.NET Version for an Application

ASP.NET v1.1 application on /app1:
ASP.NET v2.0 application on /app2:’

Unfortunately, due to the limitation of the ability to load only one CLR version into a single worker process

Taking Advantage of Integrated ASP.NET Mode
Your ASP.NET application should be using those components which make use of this feature.

This arcticle is for those, who has better understanding how to publish the websites using IIS and who does not have indepth knowledge inside IIS

Difference between windows 32Bit and 64Bit

Difference between kernal and user mode

Compare IIS 6.0 with legacy IIS versions

Concepts of IIS

The difference between 64 and 32 bit processors

1.    Mathematics

Processor	Holds
32Bit	0 to 4,294,967,295
64bit	0 to 18,446,744,073,709,551,615

Obviously this means your computer can do math with larger numbers, and be more efficient with smaller numbers.

2.    Benefits

To academic institutions and private companies

Where large calculations are being performed

Huge databases are being accessed

Complex problems are being solved

The true benefits of this set up don’t come from the amount of bits

 A 64-bit processor is made

More advanced silicon processes,

More transistors

Faster speeds.

This is currently where the true benefit of switching to a 64-bit processor lays

3.    Products
AMD-64bit

4.    Disadavantages

         Not all software vendors have their applications are built on 64bit, so they arent efficient as they would run on 32bit, cant avail the power of 64bit

Difference between kernal and user Mode

1.    Kernel Mode

In Kernel mode, the executing code has complete and unrestricted access to the underlying hardware. It can execute any CPU instruction and reference any memory address. Kernel mode is generally reserved for the lowest-level, most trusted functions of the operating system. Crashes in kernel mode are catastrophic; they will halt the entire PC.

2.    User Mode

In User mode, the executing code has no ability to directly access hardware or reference memory. Code running in user mode must delegate to system APIs to access hardware or memory. Due to the protection afforded by this sort of isolation, crashes in user mode are always recoverable. Most of the code running on your computer will execute in user mode.

What Runs Where?

KERNEL-MODE

The kernel-mode programs run in the background, making sure everything runs smoothly – things like printer drivers, display drivers, drivers that interface with the monitor, keyboard, mouse, etc. These programs all run in such a way that you don’t notice them.

When the computer boots up, Windows calls the KERNEL, the main kernel-mode program that allows all the other programs to run, even the user-mode programs.

USER-MODE

These are the programs that you run when you want specific programs – e.g., MS Paint, MS Word, and Calculator. These are heavily restricted, as to not crash the system. Windows uses memory-protection services offered by the processor to prevent malicious programs from interfering with the rest of the system and corrupting it.

Compare IIS 6.0 with legacy IIS versions