Hello!

Yes, you can use the type as the return type for the method and have the
compiler check for conversion errors.

You may also use the "where" keyword to access the interface of the type in
the method body.

public T Load(T value) where T : CustomType, ICustomInterface
{
   //method  body

   return value;
}

Ashish,

   Yes, it is, you would declare it like this:

public T Load<T>(T value)

   However, you could not call it like you would.  You would have to do
this to call it:

Address addr = DataStore.Load<Address>(addrInstance);

   Hope this helps.

The above code will not compile as you are not specifying a return type. You
need to change it but...

IF this is what you want to achieve, then you need to do something more like
this :

public T Load<T>()
{
 // method body
}

Used like this :

Address addr = DataStore.Load<Address>();

You do not need to pass any parameters to the function, just substitute the
generic parameter to strictly type the method.

Joanna

Ahsish... The general form is:

   // generic method to invoke
   public interface IInvoke<R,P>
   {
       R Invoke(P p);
   }
   public delegate R DInvoke<R,P>(P p);

   // generic collection
   public class JALGenericCollection<T,R,P> : Disposable, IInvoke<R,P>
       where T : IDisposable, IInvoke<R,P>

Regards,
Jeff

Ashish,
As the other have shown you can define a method with a parameterized return
type.

Yes you can define a generic function where the parameter is only used for
the return type.

   public T doSomething<T where T:new()>()

However! You need to supply the type parameter when you call the method
directly, something like:

   object o = doSomething<object>();
   MemoryStream m = doSomething<MemoryStream>();

However! it "violates" an FxCop rule as its "ambiguous". The compiler is not
able to use Type Inference to figure out the type parameter...

Here is a thread that discusses it:

http://groups.google.com/group/microsoft.public.dotnet.languages.csharp/browse_f
rm/thread/c96debb32de857b1/cf4e46ca8f99b798#cf4e46ca8f99b798

Personally I find in the case of GetCustomAttribute (as the thread shows) it
makes sense as the type parameter is encapsulating the downcast, plus the
type parameter is used to "do work".