c#中4个访问修饰符和8个声明修饰符详解

傷城~ 2022-05-14 08:35 198阅读 0赞

***4*个访问修饰符**（是添加到类、结构或成员声明的关键字）

*Public*：公有的，是类型和类型成员的访问修饰符。对其访问没有限制。

*Internal*：内部的，是类型和类型成员的访问修饰符。同一个程序集中的所有类都可以访问

*Private*：私有的，是一个成员访问修饰符。只有在声明它们的类和结构中才可以访问。

*Protected:*：受保护的，是一个成员访问修饰符。只能在它的类和它的派生类中访问。

*protected internal*：访问级别为* internal *或* protected*。即，*“*同一个程序集中的所有类，以及所有程序集中的子类都可以访问

**注意点：**

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

如果在成员声明中未指定访问修饰符，则使用默认的可访问性

*  ** *****类型成员默认的可访问性**

<table> 
 <tbody> 
 <tr> 
 <td style="background-color:#e5e5e5;border-color:#bbbbbb;text-align:left;"> 属于 </td> 
 <td style="background-color:#e5e5e5;text-align:left;"> 默认的成员可访问性 </td> 
 <td style="background-color:#e5e5e5;text-align:left;"> 该成员允许的声明的可访问性 </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;text-align:left;"> enum </td> 
 <td style="background-color:#ffffff;text-align:left;"> public </td> 
 <td style="background-color:#ffffff;text-align:left;"> 无 </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;text-align:left;"> class </td> 
 <td style="background-color:#ffffff;text-align:left;"> private </td> 
 <td style="background-color:#ffffff;text-align:left;"> public protected internal private protected internal </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;text-align:left;"> interface </td> 
 <td style="background-color:#ffffff;text-align:left;"> public </td> 
 <td style="background-color:#ffffff;text-align:left;"> 无 </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;text-align:left;"> struct </td> 
 <td style="background-color:#ffffff;text-align:left;"> private </td> 
 <td style="background-color:#ffffff;text-align:left;"> public internal private </td> 
 </tr> 
 </tbody> 
</table>

***Internal *和* protected internal *详解（即什么是同一个程序集）**

** **

**  示例*1*：（这里同一个程序集指同一个命名空间）**

*Class1*：

*using System;*

*using System.Collections.Generic;*

*using System.Text;*

*namespace Example05Lib*

*\{    *

*public class Class1   *

* \{       *

* internal String strInternal = null;       *

*public String strPublic;       *

*internal protected String strInternalProtected = null;   *

*\}*

*Class2*：

*using System;  
using System.Collections.Generic;  
using System.text*

*namespace Example05Lib  
\{  
   class Class2  
 \{  
   private String tmpStr=new Class1().strInternal;  
   private String tmpStr=new Class1().strInternalProtected;  
   private String tmpStr=new Class1().strPublic;  
 \}  
\}*

***1.1*结果：* Class2 *类可以访问到* Class1 *的* strInternal *成员，当然也可以访问到* strInternalProtected *成员，因为他们在同一个程序集里**

** **

*Class3*：

*using System;  
using System.Collections.Generic;  
using System.text  
using Example05Lib*

*namespace Example05   
\{  
  class Program  
  \{  
     class Class3:Class1  
     \{  
        public Class3()  
         \{  
            base.StrInternalProtected;  
             base.strPublic;  
          \}   
       \}  
  \}  
\}*

***1.2*结果：*Class3 *类无法访问到* Class1 *的* strInternal *成员，因为它们不在同一个程序集里。但却可以访问到* strInternalProtected *成员，因为* Class3 *是* Class1 *的继承类。**

** **

*using System;  
using System.Collections.Generic;  
using System.text  
using Example05Lib  
namespace Example05   
\{  
class Program  
\{  
   static void Main(string\[\] args)  
   \{  
      String tmpStr=new Class1().strPublic;   
   \}  
\}  
\}*

***1.3*结果：无法访问到* strInternalProtected *与*strInternal *成员，因为它们既不在同一个程序集里也不存在继承关系**

** **

**示例*2*（在这里同一个程序集是指同一个*.cs*文件，不同的*.cs*文件的命名空间省略）**

** **

***2.1*该示例包含两个文件：*Assembly1.cs *和* Assembly2.cs*。第一个文件包含内部基类* BaseClass*。在第二个文件中，实例化* BaseClass *的尝试将产生错误。**

*internal class BaseClass*

*\{*

*   public static int intM = 0;*

*\}*

*class TestAccess*

*\{*

*   static void Main()*

*   \{*

*      BaseClass myBase = new BaseClass();   // CS0122*

*   \}*

*\}*

***2.2 *使用与示例* 1 *中所用的文件相同的文件，并将* BaseClass *的可访问性级别更改为* public*。还将成员* IntM *的可访问性级别更改为* internal*。在此例中，您可以实例化类，但不能访问内部成员。**

*public class BaseClass*

*\{*

*   internal static int intM = 0;*

*\}*

*public class TestAccess*

*\{*

*   static void Main()*

*   \{*

*      BaseClass myBase = new BaseClass();   // Ok.*

*      BaseClass.intM = 444;    // CS0117*

*   \}*

*\}*

**示例*3***

对于一些大型的项目，通常由很多个*DLL*文件组成，引用了这些*DLL*，就能访问*DLL*里面的类和类里面的方法。比如，你写了一个记录日志的*DLL*，任何项目只要引用此*DLL*就能实现记录日志的功能，这个*DLL*文件的程序就是一个程序集。

如果你记录日志的程序集是这么定义的

*namespace LogerHelper*

*\{*

*    internal class aa*

*    \{*

*         public void bb()*

*         \{*

*             return "";*

*         \}*

*    \}*

*    public class Write*

*    \{*

*        public void WriteIn(string content)*

*        \{*

*            class x = new aa();   *

*            x.bb();*

*        \}*

*    \}*

*\}*

当另一个项目引用了此*DLL*

它可以这么访问

*LogerHelper.Write x = new LogerHelper.Write();*

*x.WriteIn("");*

但不可以这么访问

*LogerHelper.aa x = new LogerHelper.aa();*

*x.bb();*

这就叫，只能在程序集中访问

***8*个声明修饰符**

**  **

*   Partial*：在整个同一程序集中定义分部类和结构，详解见问题*1*。

*   Static*： 声明属于类型本身而不是属于特定对象的成员。

*   Abstract*：抽象类，只能是其他类的基类。类中的方法只声明不实现，方法的实现在他的派生类中完成。

*   Sealed*：指定类不能被继承。

*   Virtual*：用于修饰方法、属性、索引器或事件声明，并且允许在派生类中重写这些对象

*Override*：提供从基类继承的成员的新实现

*New*：作修饰符，隐藏从基类成员继承的成员，在不使用* new *修饰符的情况下隐藏成员是允许的，但会生成警告。作运算符，用于创建对象和调用构造函数。

*   Extern*：用于声明在外部实现的方法。* extern *修饰符的常见用法是在使用* Interop *服务调入非托管代码时与* DllImport *特性一起使用。 在这种情况下，还必须将方法声明为* static*

*   **Virtual*****，*override*和*new *的区别**

*1.       **virtual*和*override*配套使用。在基类*base*中声明了虚方法*method*（）并用*virtual*修饰，在子类*derived*中重写方法*method*（）并用*override*修饰。那么当将子类的实例赋予基类的对象（不需要强制转换）时即*Base Bclass= new Derived*（）；*Bclass.Method*（）是调用了子类的*method*（）方法，而不是基类的。所以

*2.       **new*不需要和*virtual*配套使用。在基类*base*中声明了方法*method*（），在子类*derived*中声明了同名的方法*method*（）并用*new*修饰。那么当将子类的实例赋予基类的对象时即*Base Bclass= new Derived*（）；*Bclass.Method*（）是调用了基类类的*method*（）方法，而不是子类的。

*3.       *这说明*,override*可以覆盖基类的方法*,*让基类的方法以子类的内容实现*,*而*new*不用来覆盖基类的方法*,*而是全新定义一个子类的方法*,*这个方法只属于子类*,*与基类的方法无关*,*只是名字上相同而已*.*

下面，我以例子来说明他们之间的微妙区别：

*public class GrandClass//*基类  
*\{  
        public GrandClass()  
        \{  
                Console.WriteLine("In GrandClass.Constructor");  
        \}  
        public virtual void Method()//*用*virtual*才可以在子类中用*override,*而*new*不需要这样  
*        \{  
                Console.WriteLine("In GrandClass.Method()");  
        \}  
\}  
  
public class ParentClass:GrandClass//*继承基类*,*看看*override*状态  
*\{  
        public ParentClass()  
        \{  
                Console.WriteLine("In ParentClass.Constructor");  
        \}  
        public override void Method()//*使用*override,*是说把基类的方法重新定义  
*        \{  
                Console.WriteLine("In ParentClass.Method() use override");  
        \}  
\}  
  
public class NewParentClass:GrandClass//*继承基类*,*看看*new*状态  
*\{  
        public NewParentClass()  
        \{  
                Console.WriteLine("In NewParentClass.Constructor");  
        \}  
        new public void Method()//*使用*new,*不是说用到基类的方法*,*而是重新定义一个子类方法*,*只不过*,*方法名称与基类相同  
*        \{  
                Console.WriteLine("In NewParentClass.Method()");  
        \}  
\}*

下面的调用代码*:*

*static void Main()   
\{  
        GrandClass Parent=(GrandClass)new ParentClass();//*用*override*子类加框一个基类对象句柄  
*        Parent.Method();  
        GrandClass NewParent=(GrandClass)new NewParentClass();//*用*new*子类加框一个基类对象句柄  
*        NewParent.Method();  
        NewParentClass NewParent1=new NewParentClass();//*一个子类句柄  
*        NewParent1.Method();  
\}*

结果是这样的*:*

*\[1\]In GrandClass.Constructor  
\[2\]In ParentClass.Constructor  
\[3\]In ParentClass.Method() use override  
\[4\]In GrandClass.Constructor  
\[5\]In NewParentClass.Constructor  
\[6\]In GrandClass.Method()  
\[7\]In GrandClass.Constructor  
\[8\]In NewParentClass.Constructor  
\[9\]In NewParentClass.Method()*

结果前的序号是我自己加的*.*为了以下的分析*:*  
　　*\[1\],\[2\]*两句是*GrandClass Parent=(GrandClass)new ParentClass();*的结果*.(*注意一下子类构建器与基类构建器的初始化顺序*)*  
　　*\[3\]*是*Parent.Method();*结果*.*  
　　*\[4\],\[5\]*两句是*GrandClass NewParent=(GrandClass)new NewParentClass();*的结果*.*  
　　*\[6\]*是*NewParent.Method();*的结果*.*  
　　*\[7\],\[8\]*两句是*GrandClass NewParent1=(GrandClass)new NewParentClass();*的结果*.*  
　　*\[9\]*是*NewParent1.Method();*的结果*.*  
  
　　这里我们可以看到*,*同样是用子类的对象构造一个基类句柄*.*结果却很明显*,*可以看到*\[3\]*和*\[6\]*的区别*.\[3\]*调用了子类的*Method(),*而*\[6\]*调用了基类的*Method().*  
　　这说明*,override*可以覆盖基类的方法*,*让基类的方法以子类的内容实现*,*而*new*不用来覆盖基类的方法*,*而是全新定义一个子类的方法*,*这个方法只属于子类*,*与基类的方法无关*,*只是名字上相同而已*.  
     *而这一例子的基础是建立在用子类对象加框成基类对象的*,*目的是实现用基类句柄调用子类方法*,*以实现重载的多态性*.*  
　　如果想调用子类的*new*方法*,*用子类的句柄*(*绝对不能用基类句柄*)*来调用*.*结果*\[9\]*可以看出来*.*  
　　用*new*是在为子类定义方法名时*,*实在没有办法定义方法名的情况才与基类的方法相同*,*但这个方法只在子类中起到作用*,*而不影响基类的方法*.*也就是说*,new*方法就是子类新定义的方法*.*用*override*是直正意义上的重载*.  *