1

The default Access modifier of a class in C# is internal. But on inspecting the class with ildasm it shows class as private.

.class private auto ansi beforefieldinit ConsoleApplication1.Program
    extends [mscorlib]System.Object
    {
    } // end of class ConsoleApplication1.Program

Any idea why?

dckuehn
  • 2,427
  • 3
  • 27
  • 37
user1426187
  • 95
  • 2
  • 6
  • Who says it's internal? – cwap Nov 18 '13 at 19:35
  • 2
    Microsoft says it's internal: http://msdn.microsoft.com/en-us/library/ms173121.aspx – Magus Nov 18 '13 at 19:37
  • possible duplicate of [When I declare a class as internal, why does the IL show it as private?](http://stackoverflow.com/questions/18660300/when-i-declare-a-class-as-internal-why-does-the-il-show-it-as-private) – Habib Nov 18 '13 at 19:42
  • Oh, my bad. I should really learn to read the whole question :) – cwap Nov 18 '13 at 20:00

4 Answers4

7

IL does not have the concept of internal, internal classes are represented as private if they are in the root namespace or assembly if they are nested inside another type.

namespace ConsoleApplication1
{
    internal class ExplicitInternal
    {
        private class ExplicitPrivate
        {
        }

        internal class ExplicitNestedInternal
        {
        }

        public class ExplicitNestedPublic
        {
        }
    }

    public class ExplicitPublic
    {
    }

    class ImplicitInternal
    {
        private class ImplicitPrivate
        {
        }
    }
}

becomes

.namespace ConsoleApplication1
{
    .class private auto ansi beforefieldinit ConsoleApplication1.ExplicitInternal
        extends [mscorlib]System.Object
    {
        .class nested private auto ansi beforefieldinit ExplicitPrivate
            extends [mscorlib]System.Object
        {
        }

        .class nested assembly auto ansi beforefieldinit ExplicitNestedInternal
            extends [mscorlib]System.Object
        {
        }

        .class nested public auto ansi beforefieldinit ExplicitNestedPublic
            extends [mscorlib]System.Object
        {
        }
    }

    .class public auto ansi beforefieldinit ConsoleApplication1.ExplicitPublic
        extends [mscorlib]System.Object
    {
    }

    .class private auto ansi beforefieldinit ConsoleApplication1.ImplicitInternal
        extends [mscorlib]System.Object
    {
        .class nested private auto ansi beforefieldinit ImplicitPrivate
            extends [mscorlib]System.Object
        {
        }
    }
}
Scott Chamberlain
  • 124,994
  • 33
  • 282
  • 431
  • 1
    +1, Here is the documentation link http://msdn.microsoft.com/en-us/library/ms173183.aspx "The C# keywords protected and internal have no meaning in IL and are not used in the reflection APIs." – Habib Nov 18 '13 at 19:48
3

The general rule for the default access modifier is going to be the least accessibility possible. MSDN goes into more detail:

Classes and structs that are declared directly within a namespace (in other words, that are not nested within other classes or structs) can be either public or internal. Internal is the default if no access modifier is specified. Struct members, including nested classes and structs, can be declared as public, internal, or private. Class members, including nested classes and structs, can be public, protected internal, protected, internal, or private. The access level for class members and struct members, including nested classes and structs, is private by default.

...

The type of any member that is a field, property, or event must be at least as accessible as the member itself.

So in C# these are the rules, however I agree with comments that the particular issue you are dealing with is ultimately due to internal having no meaning in IL.

P.Brian.Mackey
  • 43,228
  • 68
  • 238
  • 348
  • You should elaborate on this a little bit, and probably provide some relevant documentation – Federico Berasategui Nov 18 '13 at 19:37
  • In other words, `internal` if it's a top-level type (effectively "assembly-private"), and `private` if it's a nested type. – Mike Strobel Nov 18 '13 at 19:37
  • 3
    @user1426187 Because IL modifiers do not necessarily map directly to C# modifiers. – Mike Strobel Nov 18 '13 at 19:39
  • `private` is default access specifier for class members, The reason OP is seeing it as private is because Reflection / IL doesn't have any meaning for internal, see: http://msdn.microsoft.com/en-us/library/ms173183.aspx – Habib Nov 18 '13 at 19:46
  • @Habib - Can you explain why class members are relevant? The OP asked about the default access modifier of a class. – P.Brian.Mackey Nov 18 '13 at 19:49
  • @P.Brian.Mackey, I am not saying that class members are relevant, I am just saying that the reason IL is showing an internal class as private is because of the reflection/IL, since internal doesn't have any meaning in IL, its private to assembly. – Habib Nov 18 '13 at 19:51
1

Is it an inner class? Would be private then.

Konstantin
  • 3,254
  • 15
  • 20
0

Class cannot be created as private by default because for soin that class must be at least nested inside another class. ILDASM show you that class is private because it's mean that class limited in scope to the type in which its declared. If a class is not declared inside the definition of a type then it cannot be private to that type. So, nested classes are private by default while non-nested classes are internal by default. If you dont add some access modifies it's automatically adopt to access level. means

class Myclass1 {
     class MyNestedClass
     {
     }
}

i the same like

internal class Myclass1 {
     private class MyNestedClass
     {
     }
}

Additional information MSDN1 and MSDN2

hbk
  • 10,908
  • 11
  • 91
  • 124