Inherit an abstract class without any constructor

Question

I want to inherit a class from another class, marked as abstract, that not have any constructor defined.

This is my code:

// In one assembly (TheMessage.dll), as seen via F12 in VS (from Metadata)
namespace Namespace1 
{
    public abstract class Message
    {
       public string Body { get; set; }
       // some abstract methods here, not shown.
    }
}

// In another assembly (TheUser.dll)
namespace Namespace2
{
    public class MyMessage : Namespace1.Message
    {
         public MyMessage()
         {
         }
    }
}

The problem is that on the public MyMessage() constructor I get the error

The type 'Namespace1.Message' has no constructors defined

I saw on MSDN site (abstract (C# Reference) first example) that inheriting an abstract class without constructor is possible. So, anyone know why I get this error?

Note that one can inherit just fine when type is in the same DLL as the Message class and it works as that assembly exposes some other types deriving from Namespace1.Message similar to following:

// The same assembly  as Message (TheMessage.dll), as seen via F12 in VS (from Metadata)
namespace Namespace3
{
    public class Message : Namespace1.Message
    {
        public Message() {}
        public Message(string to) {}
    }
}

---

I've also checked The type '...' has no constructors defined, but it does not speak about inheritance but rather just new-ing up an instance and I clearly have no expectations to directly instantiate an instance of an abstract class.

Answer 1

If none of the instance constructors of the Message class are visible to you (typically because they are all private and you are outside the class, or they are all private or internal and you are outside the assembly), you cannot write a class that inherits from Message. (Well, you could make two instance constructors which chain each other cyclicly with the :this(...) syntax, but that would not be useful).

Note that when you look at the "metadata" (reflection generated pseudo-C# for an assembly you refer), you typically only see the "visible" members, so any private or internal members will not show up. I think you look at the metadata because we see non-abstract (and non-extern) methods whoses bodies are absent (just a semicolon ; there instead of a body { ... }).

The source code of your Message class will have one or more constructors, each private or internal, but when seen from outside the assembly, these are "non-existent".

If the source code of a non-static C# class Message contains no instance constructors, the compiler will generate one automatically. It will be a public parameterless constructor if the class is concrete (i.e. non-abstratc), and a protected one if the class is abstract.

That means that if the source code looks like this:

public abstract class Message
{
  // note: zero non-static constructors here
}

it will be compiled exactly as if it had said:

public abstract class Message
{
  protected Message()
  {
  }
}

and in that case the generated instance constructor is accessible to all classes deriving from Message.

Answer 2

You probably have an internal constructor (not shown in the code that you posted) and are trying to instantiate the class with the internal constructor from a different assembly.

(The default constructor for a base class is automatically called from a derived class if you don't explicitly specify a base class constructor to call, so it might not be obvious to you that the base class constructor is being called.)

For example, if one assembly contains this class (inside namespace ClassLibrary1):

public class Base
{
    internal Base()
    {
    }
}

And a DIFFERENT assembly does this:

class Derived: Base
{
    public Derived()
    {
    }
}

You will see the following compile error:

The type 'ClassLibrary1.Base' has no constructors defined