Thanks for your help .
My english is so bad that I can't show my problem clearly : - (

I write this code to make the Test method can reusnable. All class which
derived from BaseClass can be a parameter for this method.But if I write
like this:

BaseClass y ;
Test( out y);

static void Test(  out BaseClass y )
{
  y = new SubClass();
  Console.WriteLine(1);
 }

this code can be compiled . But the BaseClass will mean nothing.. If I don't
use the out word,everything is good.
So I think  there are some thing that I never knew with the out word.

class Class1
{
 [STAThread]
 static void Main(string[] args)
 {
  DeriveClass y ;
  Test( out y);

  DeriveClass  s  = new DeriveClass();
  DeriveClass2 s1 = new DeriveClass2();
  Test1(s);
  Test1(s1);
 }
 static void Test(  out BaseClass y )
 {
  y = new DeriveClass();
  Console.WriteLine(1);
 }
 static void Test1 ( BaseClass y )
 {
  Console.WriteLine(2);
 }
}
class BaseClass
{
}
class DeriveClass : BaseClass
{

}
class DeriveClass2 : BaseClass
{

}

thanks in advance
Yadong Zhao

It's not a misleading message - it's just that there are multiple
things wrong with the code.

No - it's not assumed to be null. It's not definitely assigned. Big
difference :) If it were assumed to be null, you wouldn't get a
compile-time error, you'd get a NullReferenceException at run-time.

Indeed. The reason the OP is getting the error message, however, is
that the actual argument must be a variable of exactly the same type as
the output parameter.

This question is from our project . My origin code is an example for
project's code .
The project's framework design and coding is aleary finished . The desinger
and coder of the framework is at another country . So we have no chance to
change it and I think I must know the real reason for this. Thanks for your
help !

Thanks and  Regards
Yadong Zhao

Good. It's worth avoiding out parameters where you can though,
preferring to use straight return values. That's simpler, and more
obvious.

In actual fact, what you are doing is implementing the Factory Method design
pattern.

Using an out parameter is not the usual way of doing this, at least for
returning a single instance of a given type.

You could just as well do this :

class Class1
{
 [STAThread]
 static void Main(string[] args)
 {
   BaseClass y = BaseClass.CreateInstance(typeof(DeriveClass2));
   y.WriteName();
   Console.ReadLine();
 }
}

Or if you still feel that you need to have a Factory Method in Class1 as
well, then just use a method that returns an object of BaseClass type.

class Class1
{
 static BaseClass Test(Type t )
 {
   return BaseClass.CreateInstance(t);
 }

 [STAThread]
 static void Main(string[] args)
 {
   BaseClass y = Test(typeof(DeriveClass2));
   y.WriteName();
   Console.ReadLine();
 }
}

Joanna