instead of
where Tobject : Object

use
where Tobject : Nullable<>

haven't tried but an idea..

Dave,

   You won't be able to do this the way you want.  There are a number of
things that need to be changed here.

   First, your declarations should look like this:

public class A<T>
{
   public void Initialize(string s){}
}

public class D<TObject, TClass>
   where TObject : class
   where TClass : A<TClass>, new()
{
   public TObject someFunction()
   {
       TClass c = new TClass();
       c.Initialize("Test");
       return null;
   }
}

   When you use "class" as a constraint, it means that you can only pass in
reference types.  This is what allows null to be returned for TObject.  The
second thing is you have to declare your initialization outsize of the
constructor.  The reason for this is that the new constraint only constrains
on parameterless constructors.  Because of this, you need a separate method
to call on A which can perform the necessary setup.

   Hope this helps.

Re the new(string) signature, you can't do this at design time (yet - maybe
this will get more powerful in 3.0?). One option is to use reflection to
test this in a static ctor (I posted an example of this a week-or-so ago) -
you'd also need to use the reflected ctor to create your object, so you
could perhaps persist this in a private static field; the validation will
only happen at runtime, but at least it will happen as early as possible.

The Tobject : Object doesn't look like it will do much, since everything is
derived from Object

When you say nullable, do you need to be able to handle Nullable<T>? or just
classes (reference types). If the latter, you could replace this line with
Tobject : class; this then compiles.

Hope this helps,

Marc

Hi,

See inline

The Tobject : object constraint doesn't do anything at all, because
everything in the .NET world derives (or can be boxed in order to
derive) from an object. The right constraint to specify a reference type
would beTobjkec