【转】C# 中访问修饰符

用通过代码：

 类内部

using System;
class Mod
{
    void defaultMethod()
    {
        Console.WriteLine("this is a default method");
    }

    public void publicMethod()
    {
        Console.WriteLine("this is a public method");

    }
    private void privateMethod()
    {
        Console.WriteLine("this is a private method");
    }

    internal void internalMethod()
    {
        Console.WriteLine("this is a internal method");
    }

    protected void protectedMethod()
    {
        Console.WriteLine("this is a protected method");
    }

    protected internal void protectInternalMethod()
    {
        Console.WriteLine("this is a protected internal method");
    }

    static void Main()
    {
        Mod mod=new Mod();
        mod.defaultMethod();
        mod.publicMethod();
        mod.privateMethod();
        mod.internalMethod();
        mod.protectedMethod();
        mod.protectInternalMethod();
    }

}

D:/Project/handing/char>Method1
this is a default method
this is a public method
this is a private method
this is a internal method
this is a protected method
this is a protected internal method

 子类

using System;
class Mod
{
    void defaultMethod()
    {
        Console.WriteLine("this is a default method");
    }

    public void publicMethod()
    {
        Console.WriteLine("this is a public method");

    }
    private void privateMethod()
    {
        Console.WriteLine("this is a private method");
    }

    internal void internalMethod()
    {
        Console.WriteLine("this is a internal method");
    }

    protected void protectedMethod()
    {
        Console.WriteLine("this is a protected method");
    }

    protected internal void protectInternalMethod()
    {
        Console.WriteLine("this is a protected internal method");
    }

}

class Test
{
        static void Main()
            {
                Mod mod=new Mod();
            //    mod.defaultMethod();
                mod.publicMethod();
            //    mod.privateMethod();
                mod.internalMethod();
            //    mod.protectedMethod();
                mod.protectInternalMethod();
            }
}

D:/Project/handing/char>Method2
this is a public method
this is a internal method
this is a protected internal method

程序集内

using System;
class Mod
{
    void defaultMethod()
    {
        Console.WriteLine("this is a default method");
    }

    public void publicMethod()
    {
        Console.WriteLine("this is a public method");

    }
    private void privateMethod()
    {
        Console.WriteLine("this is a private method");
    }

    internal void internalMethod()
    {
        Console.WriteLine("this is a internal method");
    }

    protected void protectedMethod()
    {
        Console.WriteLine("this is a protected method");
    }

    protected internal void protectInternalMethod()
    {
        Console.WriteLine("this is a protected internal method");
    }


}
class Modl : Mod
{
    static void Main()
    {
        Modl mod=new Modl();
            
    //    mod.defaultMethod();
        mod.publicMethod();
    //    mod.privateMethod();
        mod.internalMethod();
        mod.protectedMethod();
        mod.protectInternalMethod();
    }
    


}

D:/Project/handing/char>Method3
this is a public method
this is a internal method
this is a protected method
this is a protected internal method

程序集外

放在同一个NAMESPACE中，区别于JAVA的包。

 D:/Project/handing/04_01>csc /target:library Method4.cs
Microsoft (R) Visual C# 2005 编译器 版本 8.00.50727.42
用于 Microsoft (R) Windows (R) 2005 Framework 版本 2.0.50727
版权所有 (C) Microsoft Corporation 2001-2005。保留所有权利。

D:/Project/handing/04_01>csc /r:Method4.dll Method5.cs
Microsoft (R) Visual C# 2005 编译器 版本 8.00.50727.42
用于 Microsoft (R) Windows (R) 2005 Framework 版本 2.0.50727
版权所有 (C) Microsoft Corporation 2001-2005。保留所有权利。

D:/Project/handing/04_01>Method5
this is a public method

Method4.cs

using System;
namespace 4
{
    public class Mod
        {
            void defaultMethod()
            {
                Console.WriteLine("this is a default method");
            }

            public void publicMethod()
            {
                Console.WriteLine("this is a public method");

            }
            private void privateMethod()
            {
                Console.WriteLine("this is a private method");
            }

            internal void internalMethod()
            {
                Console.WriteLine("this is a internal method");
            }

            protected void protectedMethod()
            {
                Console.WriteLine("this is a protected method");
            }

            protected internal void protectInternalMethod()
            {
                Console.WriteLine("this is a protected internal method");
            }


        }
}

Method5.cs

using 4;
using System;
public class Test
{
    public    static void Main()
    {
        Mod mod=new Mod();
        mod.defaultMethod();
        mod.publicMethod();
        mod.privateMethod();
        mod.internalMethod();
        mod.protectedMethod();
        mod.protectInternalMethod();
    }

}

以下摘自:http://blog.csdn.net/bill1315/archive/2007/07/01/1673001.aspx

msdn的解释如下:internal指的是同一个程序集,内部成员和类型才是可以访问的.内部访问通常用于基于组件的开发，因为它使一组组件能够以私有方式进行合作，而不必向应用程序代码的其余部分公开

一个成员或类型只能有一个访问修饰符，使用 protectedinternal 组合时除外。

命名空间上不允许使用访问修饰符。命名空间没有访问限制。

根据发生成员声明的上下文，只允许某些声明的可访问性。如果在成员声明中未指定访问修饰符，则使用默认的可访问性。

不嵌套在其他类型中的顶级类型的可访问性只能是 internal 或 public。这些类型的默认可访问性是 internal。

嵌套类型是其他类型的成员，它们可以具有下表所示的声明的可访问性。

属于	默认的成员可访问性	该成员允许的声明的可访问性
enum	public	无
class	private	public protected internal private protected internal
interface	public	无
struct	private	public internal private

区别JAVA

Java用三个关键字在类的内部设定边界：
public、private、 protected。它们的含义和用法非常易懂。这些“访问指定词”(access specifier)决定了紧跟其后被定义的东西可以被谁使用。
public表示紧随其后的元素对任何人都是可用的。
而private这个关键字表示除类型创建者和类型的内部方法之外的任何人都不能访问的元素。private就像你与客户端程序员之间的一堵砖墙，如果有人试图访问private成员，就会在编译时得到错误信息。
protected关键字与private作用相当，差别仅在于继承的类可以访问protected成员，但是不能访问private成员。

C#的访问修饰符:

     Public:可被所属类和成员以及不属于类的成员访问.

所修饰类的成员

可在任何情况下通过类的对象和类成员被使用.

所修饰的类类型

       可在任何情况下被类的访问级别的类继承.

       Internal:可被当前程序集访问           

所修饰类的成员

在统一”解决方案”里的使用与Public相同(与命名空间无关).出了解决方案则不可被使用.

              所修饰的类类型(其为类的默认修饰符)

在统一”解决方案”中,可被相同级别的类继承(也就是说被Internal修饰的类),不可被访问就别比自己高的类继承(Public修饰的类).

同时,在不同”解决方案”中,类类型不可被使用.

       Protected:可被所属类或派生自所属类的类型访问.

              所修饰类的成员

1.      可被类的内部对象(隐指针this) 和类成员使用,以及在类的内部所声明的类的对象使用.

2.      在其他类中声明的自身类的对象却不可访问自身的protected成员.

3.      在同一”命名空间”或不同”命名空间”下,派生自所属类的类就继承了父类的protected以及访问级别以上的类成员,所以他的使用与自身声明的成员无异,其规则参照上两条.

所修饰的类类型

       其修饰符不能修饰类.

       Private:仅所属类的成员才可以访问

              所修饰类的成员(其为类成员的默认修饰符)

1.      可被类的内部对象和类成员使用,以及在类的内部所声明的类的对象使用.

2.      在其他类中声明的自身类的对象也不可访问自身的private成员.

3.      任何情况下,private成员不可被派生类继承.

所修饰的类类型

       其修饰符不能修饰类.

----------------------------------------

static:static 修饰符指明成员属于类本身而不属于类的实例。即使创建了类的多个实例，给定应用程序中只存在 static 成员的一个副本。
您只能通过对类的引用（而不是对实例的引用）来访问 static 成员。但是，在类成员声明中，可以通过 this 对象来访问 static 成员。

sealed:sealed 修饰符可以应用于类、实例方法和属性。密封类不能被继承。密封方法会重写基类中的方法，
但其本身不能在任何派生类中进一步重写。当应用于方法或属性时，sealed 修饰符必须始终与 override（C# 参考） 一起使用。

abstract:在类声明中使用 abstract 修饰符以指示某个类只能是其他类的基类。标记为抽象或包含在抽象类中的成员必须通过从抽象类派生的类来实现。
因为抽象方法声明不提供实际的实现，所以没有方法体；方法声明只是以一个分号结束，并且在签名后没有大括号 ({ })。例如：public abstract void MyMethod();

extern 修饰符用于声明在外部实现的方法。extern 修饰符的常见用法是在使用 Interop 服务调入非托管代码时与 DllImport 属性一起使用；在这种情况下，该方法还必须声明为 static;
使用 extern 修饰符意味着方法在 C# 代码的外部实现，而使用 abstract 修饰符意味着在类中未提供方法实现。
同样没有方法体


virtual:与abstract类似,只是虚方法必须实现,抽象方法可以不实现

protected:protected 关键字是一个成员访问修饰符。受保护成员在它的类中可访问并且可由派生类访问。
    类的实例也不能访问protected成员.

private:是一个成员访问修饰符。私有访问是允许的最低访问级别。私有成员只有在声明它们的类和结构体中才是可访问的

readonly 关键字与 const 关键字不同。const 字段只能在该字段的声明中初始化。readonly 字段可以在声明或构造函数中初始化。因此，根据所使用的构造函数，readonly 字段可能具有不同的值。另外，const 字段为编译时常数，而 readonly 字段可用于运行时常数，

volatile 关键字表示字段可能被多个并发执行线程修改。声明为 volatile 的字段不受编译器优化（假定由单个线程访问）的限制。这样可以确保该字段在任何时间呈现的都是最新的值