protection level c#




公共,私人,受保護和沒有什麼區別? (10)

我一直在使用public課的大學時間,想知道publicprivateprotected之間的區別嗎?

還有什麼是static ,而不是什麼都沒有?


訪問修飾符

上市

類型或成員可以被同一程序集或引用它的其他程序集中的任何其他代碼訪問。

私人的

類型或成員只能由同一類或結構中的代碼訪問。

保護

類型或成員只能由同一類或結構中的代碼或派生類中的代碼訪問。

內部

類型或成員可以由同一個程序集中的任何代碼訪問,但不能從另一個程序集訪問。

內部保護

類型或成員可以被同一程序集中的任何代碼或另一個程序集中的任何派生類訪問。

如果設置訪問修飾符,則使用默認訪問修飾符。 所以即使沒有設置,總是有一些訪問修飾符的形式。

靜態的

一個類的靜態修飾符意味著該類不能被實例化,並且它的所有成員都是靜態的。 一個靜態成員有一個版本,無論其封閉類型創建了多少個實例。

靜態類與非靜態類基本相同,但有一點不同:靜態類不能從外部實例化。 換句話說,您不能使用new關鍵字來創建類類型的變量。 由於沒有實例變量,因此可以使用類名稱本身訪問靜態類的成員。

但是, 靜態構造函數就是這樣的。 任何類都可以具有其中的一個類,包括靜態類。 它們不能被直接調用,也不能有參數(除了類本身的任何類型參數)。 在創建第一個實例或引用任何靜態成員之前,會自動調用靜態構造函數以初始化該類。 看起來像這樣:

static class Foo()
{
    static Foo()
    {
        Bar = "fubar";
    }

    public static string Bar { get; set; }
}

靜態類通常用作服務,你可以像這樣使用它們:

MyStaticClass.ServiceMethod(...);

using System;

namespace ClassLibrary1
{
    public class SameAssemblyBaseClass
    {
        public string publicVariable = "public";
        protected string protectedVariable = "protected";
        protected internal string protected_InternalVariable = "protected internal";
        internal string internalVariable = "internal";
        private string privateVariable = "private";
        public void test()
        {
            // OK
            Console.WriteLine(privateVariable);

            // OK
            Console.WriteLine(publicVariable);

            // OK
            Console.WriteLine(protectedVariable);

            // OK
            Console.WriteLine(internalVariable);

            // OK
            Console.WriteLine(protected_InternalVariable);
        }
    }

    public class SameAssemblyDerivedClass : SameAssemblyBaseClass
    {
        public void test()
        {
            SameAssemblyDerivedClass p = new SameAssemblyDerivedClass();

            // NOT OK
            // Console.WriteLine(privateVariable);

            // OK
            Console.WriteLine(p.publicVariable);

            // OK
            Console.WriteLine(p.protectedVariable);

            // OK
            Console.WriteLine(p.internalVariable);

            // OK
            Console.WriteLine(p.protected_InternalVariable);
        }
    }

    public class SameAssemblyDifferentClass
    {
        public SameAssemblyDifferentClass()
        {
            SameAssemblyBaseClass p = new SameAssemblyBaseClass();

            // OK
            Console.WriteLine(p.publicVariable);

            // OK
            Console.WriteLine(p.internalVariable);

            // NOT OK
            // Console.WriteLine(privateVariable);

            // Error : 'ClassLibrary1.SameAssemblyBaseClass.protectedVariable' is inaccessible due to its protection level
            //Console.WriteLine(p.protectedVariable);

            // OK
            Console.WriteLine(p.protected_InternalVariable);
        }
    }
}
 using System;
        using ClassLibrary1;
        namespace ConsoleApplication4

{
    class DifferentAssemblyClass
    {
        public DifferentAssemblyClass()
        {
            SameAssemblyBaseClass p = new SameAssemblyBaseClass();

            // NOT OK
            // Console.WriteLine(p.privateVariable);

            // NOT OK
            // Console.WriteLine(p.internalVariable);

            // OK
            Console.WriteLine(p.publicVariable);

            // Error : 'ClassLibrary1.SameAssemblyBaseClass.protectedVariable' is inaccessible due to its protection level
            // Console.WriteLine(p.protectedVariable);

            // Error : 'ClassLibrary1.SameAssemblyBaseClass.protected_InternalVariable' is inaccessible due to its protection level
            // Console.WriteLine(p.protected_InternalVariable);
        }
    }

    class DifferentAssemblyDerivedClass : SameAssemblyBaseClass
    {
        static void Main(string[] args)
        {
            DifferentAssemblyDerivedClass p = new DifferentAssemblyDerivedClass();

            // NOT OK
            // Console.WriteLine(p.privateVariable);

            // NOT OK
            //Console.WriteLine(p.internalVariable);

            // OK
            Console.WriteLine(p.publicVariable);

            // OK
            Console.WriteLine(p.protectedVariable);

            // OK
            Console.WriteLine(p.protected_InternalVariable);

            SameAssemblyDerivedClass dd = new SameAssemblyDerivedClass();
            dd.test();
        }
    }
}

C#共有6個訪問修飾符:

private :使用此輔助功能聲明的成員可以在包含類型中可見,但對於任何派生類型,相同程序集中的其他類型或包含程序集外部的類型都不可見。 即訪問僅限於包含類型。

protected :使用此輔助功能聲明的成員可以在從包含程序集中的包含類型派生出的類型中以及從包含程序集以外派生自包含類型的類型中可見。 即,訪問僅限於包含類型的派生類型。

internal :使用此輔助功能聲明的成員可在包含此成員的程序集中可見,但對於包含程序集以外的任何程序集都不可見。 即訪問僅限於包含程序集。

內部保護 :使用此輔助功能聲明的成員可以在從包含程序集內部或外部的包含類型派生的類型中可見,對於包含程序集中的任何類型也是可見的。 即訪問被限制為包含彙編或派生類型。

public :使用此輔助功能聲明的成員可以在包含此成員的程序集或任何其他引用包含程序集的程序集中可見。 即訪問不受限制。

C#7.2增加了一個新的可訪問級別:

private protected :使用此可訪問性聲明的成員可以在包含程序集中的此包含類型派生的類型中可見。 對於不是從包含類型派生的任何類型,或者在包含程序集之外的類型都不可見。 即,訪問僅限於包含程序集中的派生類型。

來源包括新的私人保護訪問修飾符的示例代碼


公開 - 任何人都可以訪問。
私人 - 只能在課堂上進行訪問。
保護 - 只能在類中或從類繼承的任何對像中訪問。

沒有什麼是空的,但在VB中。
靜態意味著你有這個對象的一個實例,該類的每個實例的方法。


一個圖形化的概述(總而言之)

對於默認設置,如果您在前面沒有訪問修飾符,請參閱此處:
C#類和成員(字段,方法等)的缺省可見性?

非嵌套

enum                              public
non-nested classes / structs      internal
interfaces                        internal
delegates in namespace            internal
class/struct member(s)            private
delegates nested in class/struct  private

嵌套:

nested enum      public
nested interface public
nested class     private
nested struct    private

仔細觀察你的課程的可訪問性。 公共和受保護的類和方法默認情況下可供所有人訪問。

此外,Microsoft在創建Visual Studio中的新類時顯示訪問修飾符(公共,受保護等關鍵字)時並不十分清楚。 因此,請小心並考慮您的班級的可訪問性,因為這是實施內部機構的大門。


嗯。

請參閱: 訪問修飾符

簡而言之:

公共給出了方法或類型從其他類型/類完全可見。

Private僅允許包含私有方法/變量的類型訪問私有方法/變量(請注意,嵌套類也可以訪問包含的類私有方法/變量)。

受保護類似於私有,除了派生類也可以訪問受保護的方法。

“Nothing”是VB.NET等於null的。 雖然如果你指的是“沒有”意味著“無訪問修飾符”,那麼它取決於,儘管一個非常粗略的經驗法則(當然在C#中)是如果你沒有明確指定訪問修飾符,方法/變量聲明通常受到限制 。 即

public class MyClass
{
    string s = "";
}

實際上與以下內容相同:

public class MyClass
{
    private string s = "";
}

當沒有顯式指定訪問修飾符時,鏈接的MSDN文章將提供完整說明。


從這個答案重新發布令人敬畏的圖表。

以下是維恩圖中的所有訪問修飾符,從更多限製到更混雜:

private

private protected : - 在C#7.2中添加

internal

protected

protected internal

public


這些訪問修飾符指定您的成員可見的位置。 你應該讀這個。 以IainMH給出的鏈接為起點。

靜態成員是每個類一個,而不是每個實例一個。


關於Nothing的問題

  • 命名空間類型默認是內部的
  • 任何類型的成員,包括嵌套類型在默認情況下都是私有的




access-modifiers