What kind of access modifiers can be applied to a class?

After a little research I've determined that the only access modifiers which you can apply to classes are:

• public - available in any assembly
• internal - available only in the current assembly

but the error message below seems to imply that if a class is not defined in a namespace that it could be defined as private, protected, or protected internal.

Are public and internal the only class modifiers you can use on class or are there more?

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Tes开发者_运维问答t2343434
{
    class Program
    {
        static void Main(string[] args)
        {
            Tools.ToolManager toolManager = new Tools.ToolManager();

            Console.ReadLine();
        }
    }

}

namespace Tools
{
    //error: Elements defined in a namespace cannot be explicitly 
    //declared as private, protected, or protected internal
    private class ToolManager 
    {
        public ToolManager()
        {
            Console.WriteLine("inside tool manager");
        }
    }
}

A nested type can be declared private, protected, or protected internal. You can still declare nested types as public or internal of course - it's just that you can only declare them with the above access modifiers when they're nested:

public class OuterClass
{
    private class PrivateNested {}
    protected class ProtectedNested {}
    protected internal class ProtectedInternalNested {}
    public class PublicNested {}
    internal class InternalNested {}
}

Note that you can't declare a type nested in a struct to be protected or protected internal because it doesn't make any sense to do so :)

public struct OuterStruct
{
    private class PrivateNested {}
    public class PublicNested {}
    internal class InternalNested {}
}

C# doesn't allow types to be nested in interfaces (unfortunately, IMO - it would be useful for code contracts).

All of this is true for other nested types (enums, structs, interfaces, delegates) too.

Take a look at this MSDN page:

Type declarations in a namespace can have either public or internal access. If no accessibility is specified, internal is the default.

It makes little sense for a type declaration in a namespace to be anything other than public to external assemblies, or internal (C# does not support the concept of friend classes or anything like that).

The answer is found in Accessibility Levels.

A "top-level" class, i.e. not nested in another class, can only be public or internal. By default (if you don't declare anything), it is internal.

Nested classes can have all five possible accessibility levels, i.e. public, protected, internal, private, protected internal.

In the context of this question it might be interesting to point out that there is a not so well known mechanism for making internal classes visible to other assemblies. That mechanism is the InternalsVisibleTo attribute. It is not considered one of the access modifiers by any stretch, but does have the effect of manipulating who has access. The concept is referred to as friend assemblies.