Is there a way to specify the where T:new() restriction but with internal constructor?

Question

I've created a generic class that needs to instantiate its implementation type, so the implementation type has to have an accessible parameter less constructor. Looks like the new() restriction could do the job but its enforcing the implementation type to have a public constructor when I have it internal (but accessible as both are on the same assembly).

1. Is there a reason to force it to be public rather than "accessible"?
2. Is there a way to do what I need?

Thanks in advance.

EDIT: The reason to do this is that I have a class X that must be used through a Singleton. The Singleton class is a generic class and I want to make the class X constructor internal to avoid external users accessing the object in a wrong way (calling the constructor).

Answer 1

This is disallowed by the C# language as outlined in section 4.4.3 of the specification Bound and Unbound Types.

If the constraint is the constructor constraint new(), the type A must not be abstract and must have a public parameterless constructor. This is satisfied if one of the following is true.

• A is a value type, since all value types have a public default constructor
• A is a type parameter having the cosntructor constraint
• A is a type parameter having the value type constraint
• A is a class that is not abstract and contains an explicitly declared public constuctor with no parameters
• A is not abstract and has a default constructor.

A compiler error if any one of these conditions are not met. If you find yourself having types that are public but only with internal constructors, then most likely they should actually be internal types with public constructors.

I would recommend changing your types accessor to internal and its constructor's to public, and make it parameterless. Your public parameterless constructor could then call through to a non-parameterless private or internal constructor to do any additional initialization work.

internal class C<T> where : T new()
{
    public C() : this(new T()) {
    }

    private C(T t) {
        // Do additional initialization
    }
}

Mind you that pattern is limited, but there's nothing stopping you from using a private method instead.

internal class C<T> where T : new() {
    public C() {
        T t = new T();
        InitializeClass(t);
    }

    private void InitializeClass(T t) {
        throw new NotImplementedException();
    }
}   

As per your update, here's a small example of a public singleton patter.

public class Singleton<T> where T : new()
{
    public static Singleton<T> Current {
        get;
        private set;
    }

    internal Singleton() : this(new T()) {
    }

    private Singleton(T t) {
        Current = this;
        // Do whatever you need to with T
    }        

    public String Name {
        get;
        set;
    }
}

Usage

// Somewhere in your internal assembly
Singleton<String> singleton = new Singleton<String>();

// In an external assembly
Singleton.Current.Name = "SoMoS";

You don't even need to use constructors in that fashion either, you can just as easily do something simple.

public class Singleton<T> where T : new()
{
    public static Singleton<T> Current {
        get;
        private set;
    }

    internal Singleton() {
        T t = new T();
        // Do stuff with T
    }

    public String Name {
        get;
        set;
    }
}

Generics may not be the way to go if you can't design it to fit your requirements. Generics can only do so much and don't solve every problem. There are things like Factory Pattern, Injection, etc..

Answer 2

Is there a reason to force it to be public rather than "accessible"?

Term accessible is very context sensitive, generics are not, by architecture. In your specific case internal could be accessible, but generics are made for generic solutions.

Is there a way to do what I need?

Based on first point, no, it's not possible, nor that I'm aware of.

Answer 3

Generics are for generic solution, therefore if you use the "new" constraint, your solution have to work with every class which implements a public ctor.

If you want to implement a generic solution for a specific kind of classes you can define an abstract base class which implements a such internal constructor. Implement a generic solution for this abstract base class and use

* where T : MyBaseClassWithInternalCtor *

as constraint.