Here are the new improvements in WCF in .Net 3.5 and VS 2008 SP1

http://www.pluralsight.com/community/blogs/aaron/archive/2008/05/12/50909.aspx

Ta,

The strategy pattern is typically used when your programmer's algorithm should be interchangeable with different variations of the algorithm. For example, if you have code that sorts array, under certain circumstances, you might want to create QuickSort and under other circumstances, you might want to create Merge Sort.

The strategy pattern is usually implemented by declaring an abstract base class with an algorithm method, which is then implemented by inheriting concrete classes. At some point in the code, it is decided what concrete strategy is relevant; it would then be instantiated and used wherever relevant.

Following example shows how a ArrayList with diffrent sort algorithms.

since i have already posted basic ContraVariance in delegate, i am not going to go thru the same again, those of you who had missed my earlier post can refer here

here is an example of using generics with contravariance

namespace ContravarianceWithGenerics
{
    public interface IEquity
    {
        string ToString();
        string Save();
    }

    //base class
    abstract class Equity : IEquity
    {
        int _price;

        public Equity(int Price)
        {
            _price = Price;
        }
        public override string ToString()
        {
            return GetType().Name + " : " + _price;
        }

        #region IEquity Members

A generic class that uses parameterized types, like MyBase<T>, is called an open-constructed generic. A generic class that uses no parameterized types, like MyBase<int>, is called a closed-constructed generic.

You may derive from a closed-constructed generic; that is, you may inherit a class named MyDerived from another class named MyBase, as in:

A generic class allows you to write your class without committing to any type, yet allows the user of your class, later on, to indicate the specific type to be used. While this gives greater flexibility by placing some constraints on the types that may be used for the parameterized type, you gain some control in writing your class. Let's look at an example:

Example 1. The need for constraints: code that will not compile

Delegate inference allows you to make a direct assignment of a method name to a
delegate variable, without wrapping it first with a delegate object.

The oldwayclass shows implementation in C# 1.1

class OldWayClass
{
   delegate void notifyDelegate();
   public void InvokeMethod()
   {
      notifyDelegate del = new notifyDelegate(SomeMethod);
      del();
   }
   void SomeMethod()
   {...}
}

Covariance and contravariance provide a degree of flexibility when you match method signatures with delegate types. Covariance permits a method to have a more derived return type than what is defined in the delegate. Contravariance permits a method with parameter types that are less derived than in the delegate type.

contravariance example:

This example demonstrates how delegates can be used with methods that have parameters of a type that are base types of the delegate signature parameter type. With contravariance, you can now use one handler in places where, previously, you would have had to use separate handlers. For example both sellNotifyDlg and sellBondNotify delegates are using the same handler - EquitySaleReport since both stock and bond derive from Equity base class

using System;
using System.Collections.Generic;
using System.Text;

namespace ContraVariance
{
    //base class
    class Equity
    {
        int _price;

        public Equity(int Price)
        {
            _price = Price;
        }
        public override string ToString()
        {
            return GetType().Name + " : " + _price;
        }
    }
    //derived
    class Stock : Equity
    {
        public Stock(int Price)
            : base(Price)
        {

        }
    }

    //derived
    class Bond : Equity
    {
        public Bond(int Price)
            : base(Price)
        {

        }
    }

    class Program
    {
        delegate void StockSellNotify(Stock s);
        delegate void BondSellNotify(Bond b);

        static void EquitySaleReport(Equity e)
        {
            Console.WriteLine("Report of sale is " + e);
        }

        static StockSellNotify sellNotifyDlg;
        static BondSellNotify sellBondNotify;

        static void Sell(Stock s)
        {
            if (null != sellNotifyDlg)
            {
                sellNotifyDlg(s);
            }
        }

        //overload
        static void Sell(Bond  b)
        {
            if (null != sellBondNotify)
            {
                sellBondNotify(b);
            }
        }
      

        static void Main(string[] args)
        {
            sellNotifyDlg += EquitySaleReport;
            Sell(new Stock(100));

            sellBondNotify += EquitySaleReport;
            Sell(new Bond(101));

            //both sellNotifyDlg and sellBondNotify are using the same handler - EquitySaleReport

           
        }
    }
}

In my next post i will put a sample for Covariance and try to refine the contravariance sample with generics ...

Happy programming !!!

When we generate (WCF) service proxy class for a service by using svcutil.exe, it creates a proxy that derives from System.ServiceModel.ClientBase<TChannel>. The proxy implements IDisposable and the client code can be wraped inside using statement and guaranteed clean-up in the face of exceptions.

However, the System.ServiceModel.ClientBase<TChannel> class can throw exceptions from its Dispose method, because it internally invokes Close() method which might lead t0 a faulted state. In that case you have to call Abort for clean-up. Most times you are not interested in knowing whether the Dispose fails or not and you just want to have guaranteed clean up of any resources held by the proxy.

Check out this discussion on the WCF forum for why Microsoft implemented the dispose in this way.

To prevent you from writing a lot of code to accomplish this clean-up, I have written a generic GenericServiceProxyAgent class that does it for you.

The idea is that you derive a class from my GenericServiceProxyAgent<TProxy, TChannel> class. Insert your proxy class (that should derive from ClientBase<TChannel>) name for TProxy, and the service interface name for TChannel. The helper class wraps the proxy and doesn't directly expose its methods. From your derived class you can use the protected Proxy property to get access to the service proxy. You should add methods to your derived class that delegate to the proxy.

Create a convenience method to the derived helper that create request messages and unpack response messages. So our helper methods have a different signature than the methods on the proxy class itself.

here is the code snippet.

i just finished writing Windows service host for my WCF services, there were no crash or exceptions thrown either by client or server,

I was just browing event log to check things were fine, then noticed at end of each call to WCF service, there was a log message with the following exception

System.ServiceModel.CommunicationException occurred
  Message="The socket connection was aborted. This could be caused by an error processing your message or a receive timeout being exceeded by the remote host, or an underlying network resource issue. Local socket timeout was '00:02:00'."
  Source="System.ServiceModel"

ok here is the solution: when using netTcpBinding the service client has to call the close() method of the service in order to relase the instance back to the pool

Agile way to fix this is by change the binding type to WSHttp or BasicHttp. it will work

Happy Programing !!!

I guess most of us know what a static class is, you can't instiantiate, cannot have any instancing members etc.

This might sound funny but the truth is Static class are "Abstract and Sealed", never understood why ?

If you dont agree with me, use reflector or ILDASM and view your static Class .

Happy Programming !!!

----