如何创建一个抽象的类，但不是内部的类

Question

Is this possible in c# somehow? This is the exact case I need it for: He (the user) must not be able to create instances of this class. However, I want to be able to create instances of this class inside my project. (hence: internally) Other classes should be able to inherit from it. I want to force the user to only use the bigger Sound class. The big "BUT": The user must be able to use instances of this class if I give it to him, that's why I can't just make it internal and be done with it. Neither can I make it abstract, because I want to make copies myself. I thought about giving the user only interfaces like IChannel back, but that doesn't solve my problem that he shouldn't be able to make an instance of Channel. He will still be able to see the class if he looks for it, and if he is adventureous enough even try to create an instance. But as I mentioned before: I can't make it abstract because I need to make copies internally.

Appreciate your help!

Answer 1

You should be able to declare the constructor as internal and the class itself as public. That should (I think) give you what you want.

Answer 2

Shouldn't an internal constructor solve the issue? That way only your assembly can create instances, but the user can still use instances without restrictions.

Answer 3

内部构造函数。

Answer 4

只是让类的构造函数内部？

Answer 5

You can always control instance creation by using different modifiers on the constructor:

public class MyClass
{
    internal MyClass()
    {
    }
}

Now nobody can instantiate your class, but if you give them an instance they can work with it like normal.

Answer 6

As many other people mentioned you can have an internal constructor in a public class.

However, I would provide the customer with a public interface and make the whole class internal (or abstract if you want the client to be able to subclass it). This way they will use the interface, which will make it easier for them to unit test their code. It will give you flexibility to change the implementation in the future.

Answer 7

Using an internally scoped constructor will allow you to create subclasses within the same assembly or any other assembly to which you've made internals visible. It will prevent the creation of subclasses in other assemblies, however, because every class derived from another is required to call a constructor on the base class. If your constructor isn't available based on its scope this will prevent other's from deriving from your class.

Generally, I don't like this kind of thinking, though. As a developer it's really annoying to find that the developer of an API I am using thinks he knows everything about how I want to use it. Yes, hide the internal details of the implementation if you must, but please allow me to extend the API to do what I need (and you haven't thought of) and don't make me jump through hoops to do it.

Oh -- and yes, do create an interface for it and use it as the return. You'll make my and your life easier in the long run, in addition to making it much easier to mock out your code in my unit tests.

Answer 8

I think what you want is a public class with a protected constructor and an internal factory method:

public class MyClassWhichIsAbstractExceptForMe
{
    // Allow derived classes but prevent public construction.
    protected MyClassWhichIsAbstractExceptForMe()
    {
    }

    // Allow internal construction
    internal static MyClassWhichIsAbstractExceptForMe Create()
    {
        return new MyClassWhichIsAbstractExceptForMe();
    }
}

I also gently recommend a design review. This seems quite odd, as others have pointed out.