How can I ensure that a class has just 1 constructor in .NET?

Question

Well my question is pretty self-explanatory. I have a class and I want to ensure that there is just 1 public constructor to this class. Moreover, I also want to ensure that the constuctor should have just 1 parameter. My class will be modified by many different developers, and I am looking for a way to ensure that they do not write any more constructors than are currently specified. Is it possible? If yes, then how?

Note, my class inherits from another class which currently does not have any constructor but it might have in the future. I don't know if this information will affect the answer or not but just thought of adding it.

Please help! Thanks in advance!

Answer 1

You could consider writing a unit test to encode this design constraint. As long as the test isn't fiddled with, this will warn when the contraint is broken.

This would be a good case for a nice comment in your class detailing this constraint.

The following testing approach can be expanded to provide a test which could test derived types, rather than a single type. This approach is a type of static analysis, and removes the overhead that would be incurred by expensive runtime checking through reflection for instance. A test ensures that the design constraint is validated at build time, rather than at runtime which could be after code is released.

[Test]
public void myClass_must_have_one_single_paramter_ctor()
{
    Type type = typeof(MyClass);

    const BindingFlags Flags = (BindingFlags.Public | BindingFlags.Instance);

    ConstructorInfo[] ctors = type.GetConstructors(Flags);

    Assert.AreEqual(1, ctors.Length, "Ctor count.");

    ParameterInfo[] args = ctors[0].GetParameters();

    Assert.AreEqual(1, args.Length, "Ctor parameter count.");

    Assert.AreEqual(typeof(string), args[0].ParameterType, "Ctor parameter type.");
}

public class MyClass
{
    public MyClass(string woo) {}
}

Answer 2

All classes have one constructor. If you don't specify one in the source code, the compiler will add an empty public constructor - the equivalent of:

public class MyClass
{
    public MyClass()
    {
    }
}

However if you specify at least one constructor in the source, only the constructors that you explicitly specify will be created, e.g. the following class has one public constructor that takes a single string parameter:

public class MyClass
{
    public MyClass(string myParameter)
    {
        ...
    }
}

In short, there's nothing special you need to do. If you only want one public constructor then ... just write one public constructor.

Answer 3

Only the person who codes the class can restrict the number and type of constructors. So if that is you, then you can just code it the way you want.

Answer 4

Constructors are not inherited from base classes.

Your class will have only the constructors that you write, except for (as others have pointed out) a default public constructor that is generated by the compiler when you do not explicitly provide one of your own.

Answer 5

This could be achieved using reflection. The only thing you need to take care is, the base class code shouldn't be accessible to or editable by developers.

class Program
{
    static void Main(string[] args)
    {
        Inherited obj = new Inherited("Alpha");
        obj.test();

        Inherited1 obj1 = new Inherited1(); //This will fail as there is no ctor with single param.
        obj1.test();
    }
}

public class MyBase
{
    private static IList<string> ValidatedClasses = new List<string>();

   public MyBase()
   {
      if(!ValidatedClasses.Contains(this.GetType().FullName) && 
          !ValidateConstructorLogic())
      {
          throw new ApplicationException("Expected consturctor with single argument");
      }
   }

    public bool ValidateConstructorLogic()
    {
        bool ValidConstFound = false;

        foreach (var info in this.GetType().GetConstructors())
        {
            if(info.GetParameters().Length ==1)
            {
                lock (ValidatedClasses)
                {
                    ValidatedClasses.Add(this.GetType().FullName);    
                } 

                ValidConstFound = true;
            }

        }

        return ValidConstFound;
    }
}

public class Inherited:MyBase
{
    public Inherited(string test)
    {
        Console.WriteLine("Ctor");
    }

    public void test()
    {
        Console.WriteLine("TEST called");
    }
}

public class Inherited1 : MyBase
{

    public void test()
    {
        Console.WriteLine("TEST called");
    }
}

You could use FxCop to validate your code against a set of predefined rules. I beleive this might be the apt solution to your problem. If you need help on creating custom FxCop rules, please refer this article.

Answer 6

You could try using a nested builder, as described by Jon Skeet. Basically: You force the user to go through the builder which then calls the private class constructor. Since the class constructor is private, only the nested builder has access to it.

Alternative: Use static factory methods, make the constructor private & document your intentions.

Answer 7

Based on your comments, I don't think this is a "coding" problem. This is a policy & enforcement problem. You don't want other developers in your team creating more constructors.

In that case, go tell them that. Whoever is in charge of your source code repository can enforce it by rejecting changes that break the policy. Adding code to deal with this is just going to add runtime penalties to users for no reason.