Web Service optimization

1. Call Web Methods Asynchronously
2. Use ExecuteXmlReader instead of DataSet
3. Use Compression
4. Using SOAP Extensions
5. Use One-Way Method
6. Using Transactions in Web Services
7. SOAP, HTTP GET, HTTP Post
8. Create instances in advance to preload all the referenced assemblies at the very beginning
9. Use pre-authentication
10. Edit IIS custom error messages

Call Web Methods Asynchronously

• Invoking a web-method asynchronously means that an invoked member will perform its work on a different thread and after all the work is done, this member must notify the main thread and, optionally, pass the return values to it.
• This seriously increases performance. If a complicated and slow web method is executed in a separate thread, the main application can proceed performing its tasks without waiting for a web method to complete.
• To call a Web method asynchronously, you have the following choices:
  
  Create a new thread and call the method from there.
  Create a delegate object that matches the Web method signature and call it from there.

Use ExecuteXmlReader instead of DataSet

• Using ExecuteXmlReader you can return an XmlDocument object or a string from a Web service.
• You can fully control the response of a WebMethod.
   
  

  String sqlString = "SELECT CustomerID, CompanyName FROM Customers For XML AUTO";

  rdr = command.ExecuteXmlReader();

  rdr.Read();

  while (rdr.ReadState != System.Xml.ReadState.EndOfFile)

  {

      ret += rdr.ReadOuterXml();

  }

Use Compression

• Compress the XML-traffic between the client and the server using the SOAPExtensions mechanism and any compression algorithm.
• You can use a ZIP-compression for you data. There are a lot of open-source compression libraries for C#.
• You can use a free library called SharpZipLib to compress your web methods. 
• Adding a compression to your webservice is very easy: include the downloaded project into your solution, reference it in your webservice, and mark your web methods with [CompressionExtension] in the proxy-class code.

Using SOAP Extensions

• Typically SOAP extensions are used to handle data encryption or to compress data to provide better performance. SOAP extensions are often used in conjunction with a custom SOAP header for user authentication.
• You can use custom SOAP extensions to handle unhandled exceptions for Web services.
• For this solution, code need to be added in AfterSerialize stage to check for unhanded SOAP exceptions.
• SOAP extension can be used to override the processing of the SOAP message on the Web server. On the Web server, there are four stages associated with these steps. Each of these stages is repeated twice.
  
  1. BeforeSerialize
  2. AfterSerialize
  3. BeforeDeserialize
  4. AfterDeserialize

Use OneWay Method

• In many cases, the Web method you expose through your Web service does not require a response from the client. In cases such as this, you can specify that your Web method is a one-way method by applying the OneWay attribute.
• Applying this attribute makes your method perform more efficiently because it will not wait for a response from the client.
• Your method will only process input parameters and cannot be used to return referenced values or throw exceptions.
• In this caller does not get anything in return so it is called as one-way communication. 
   
  

  [SoapDocumentMethod (OneWay=true)]

  [WebMethod]

  public string TestMethod()

  { } 

Using Transactions in Web Services

• You can declare the Web service's transactional behaviour by setting the TransactionOption property of the WebMethod attribute applied to the Web service method.
• XML Web service methods can only participate as the root object in a transaction, due to the stateless nature of the HTTP protocol. 
   
  Example:
  
  

  using System.EnterpriseServices;

  public class Bank : WebService

  {

      [WebMethod(TransactionOption = TransactionOption.RequiresNew)]

      public int DeleteAuthor(string lastName)

      {

          //ContextUtil.SetAbort();

      }

  }

SOAP, HTTP GET, HTTP Post

Create instances in advance to preload all the referenced assemblies at the beginning

Everybody notices that a first call to a web service takes more time to execute than the subsequent calls.
Why is that? Try to run your application in Debug mode and look at the "Output" window of Visual Studio.

• Once a web method is invoked, the application loads a number of libraries like System.Web.dll, System.Web.Services.dll, System.XML.dll etc. And maybe other assemblies of your own, which describe some classes you, use to work with your web service.
• This loading takes time, of course. So create an instance of a web service in advance, when your application starts.
• This loads all the needed libraries in memory and saves time.

Using pre-authentication

• Any call to a webservice's method generates at least one 401 error (and if you use "integrated Windows authentication", then there might be two or three 401 errors!). To avoid this, set PreAuthenticate to true.
• But keep in mind that not all authentication methods used by the hosting web servers support pre-authentication if your hosting IIS-server uses "Windows Integrated Authentication", pre-authentication is not possible.
• To speed-up the web service call, use the "basic" authentication scheme. Use it only with SSL-protected webservices and websites.

Edit IIS custom error messages