C # 'da, genel, özel, korumalı ve erişim değiştiricisine sahip olmama arasındaki fark nedir?

Tek sahip üniversite yıllarından kullanıyorum publicve arasındaki farkı bilmek istiyorum public, privateve protected?

Ayrıca statichiçbir şeye sahip olmanın aksine ne yapar ?

Erişim değiştiricileri

Gönderen docs.microsoft.com :

public

Tür veya üyeye aynı derlemedeki herhangi bir kod veya ona başvuran başka bir derleme tarafından erişilebilir.

private

Tür veya üyeye yalnızca aynı sınıf veya yapıdaki kodla erişilebilir.

protected

Tür veya üyeye yalnızca aynı sınıf veya yapıdaki veya türetilmiş bir sınıftaki kodla erişilebilir.

private protected (C # 7.2'ye eklenmiştir)

Tür veya üyeye yalnızca aynı sınıf veya yapıdaki veya aynı derlemeden türetilmiş bir sınıftaki kodla erişilebilir, ancak başka bir derlemeden erişilemez.

internal

Tür veya üyeye aynı montajdaki herhangi bir kodla erişilebilir, ancak başka bir montajdan erişilemez.

protected internal

Tür veya üyeye aynı montajdaki herhangi bir kod veya başka bir montajdaki herhangi bir türetilmiş sınıf tarafından erişilebilir.

Herhangi bir erişim değiştirici ayarlanmadığında, varsayılan bir erişim değiştirici kullanılır. Bu nedenle, ayarlanmamış olsa bile her zaman bir çeşit erişim değiştirici vardır.

static niteleyici

Bir sınıftaki statik değiştirici, sınıfın başlatılamadığı ve tüm üyelerinin statik olduğu anlamına gelir. Statik bir üye, çevreleme türünün kaç örneğinin oluşturulduğuna bakılmaksızın bir sürüme sahiptir.

Statik sınıf temel olarak statik olmayan bir sınıfla aynıdır, ancak bir fark vardır: statik bir sınıf harici olarak başlatılamaz. Başka bir deyişle, sınıf türünde bir değişken oluşturmak için yeni anahtar sözcüğü kullanamazsınız. Örnek değişkeni olmadığından, statik adın üyelerine sınıf adının kendisini kullanarak erişirsiniz.

Bununla birlikte, statik bir yapıcı gibi bir şey vardır . Statik sınıflar da dahil olmak üzere herhangi bir sınıf bunlardan birine sahip olabilir. Doğrudan çağrılamazlar ve parametreleri olamaz (sınıfın kendisinde herhangi bir tür parametresi dışında). İlk örnek oluşturulmadan veya statik üyelere başvurulmadan önce sınıfı başlatmak için statik bir yapıcı otomatik olarak çağrılır. Buna benzer:

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

    public static string Bar { get; set; }
}

Statik sınıflar genellikle hizmet olarak kullanılır, bunları şu şekilde kullanabilirsiniz:

MyStaticClass.ServiceMethod(...);

Grafiksel bir genel bakış (özet olarak)

Yana statik sınıflar mühürlendi korumalı anahtar kelime statik sınıflar üzerinde geçersiz ararlar, bu nedenle (Object hariç) miras edilemez.

Önde hiçbir erişim değiştiricisi koymazsanız varsayılanlar için buraya bakın:
C # sınıfları ve üyeleri (alanlar, yöntemler vb.) İçin varsayılan görünürlük?

Sigara iç içe

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

İç içe geçmiş:

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

Ayrıca, mühürlü-anahtar kelime vardır, bu da bir sınıfı devralmaz hale getirir.
Ayrıca, VB.NET'te, anahtar kelimeler bazen farklıdır, bu yüzden burada bir hile sayfası:

Genel - Sınıfı görebiliyorsanız, yöntemi görebilirsiniz

Özel - Sınıfın bir parçasıysanız , yöntemi görebilirsiniz, aksi halde göremezsiniz.

Korumalı - Özel ile aynı, ayrıca tüm torunlar da yöntemi görebilir.

Statik (sınıf) - "Sınıf" ve "Nesne" arasındaki farkı hatırlıyor musunuz? Hepsini unutun. "Statik" ile aynıdırlar ... sınıf kendisinin bir ve tek örneğidir.

Statik (yöntem) - Bu yöntemi her kullandığınızda, parçası olduğu sınıfın gerçek örneğinden bağımsız olarak bir referans çerçevesi olacaktır.

Bu cevaptan harika diyagramları yeniden yayınlamak .

Venn diyagramlarında daha sınırlayıcıdan daha karışık olana kadar tüm erişim değiştiricileri:

private:

private protected: - C # 7.2'de eklendi

internal:

protected:

protected internal:

public:

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();
        }
    }
}

Hiçbir Şey Sorunu Hakkında

• Ad alanı türleri varsayılan olarak dâhildir
• Yuvalanmış türler dahil olmak üzere tüm tür üyeleri varsayılan olarak gizlidir

Mevcut erişim değiştiricinin başka bir görsel yaklaşımı (C # 7.2). Umarım şema daha kolay hatırlamaya yardımcı olur
_{(etkileşimli görünüm için resme tıklayın.)}

Dışarı içeri

İki aşamalı erişim değiştiricilerini hatırlamakta zorlanıyorsanız, içten dışa unutmayın .

• özel korumalı : özel dış (aynı montaj) iç korumalı (aynı montaj)
• korumalı iç : dış korumalı (aynı montaj) iç iç (aynı montaj)

Hmm.

Buraya bakın: Erişim Değiştiricileri .

Kısaca:

Genel yöntem veya türe diğer türlerden / sınıflardan tam görünürlük sağlar.

Özel yalnızca özel yöntemi / değişkeni özel yönteme / değişkene içeren türe izin verir (iç içe sınıfların da içeren sınıflara özel yöntemlere / değişkenlere erişebileceğini unutmayın).

Korumalı özel, türetilmiş sınıfların korumalı yöntemlere erişebilmesi dışında benzerdir.

"Hiçbir şey" VB.NET'in null değerine eşit olduğu anlamına gelmez. Her ne kadar "erişim değiştirici yok" anlamına gelen "hiçbir şeye" atıfta bulunuyorsanız, o zaman duruma göre değişir, ancak çok kaba bir kural (kesinlikle C #'da), bir erişim değiştiricisini açıkça belirtmemeniz durumunda, yöntem / değişken beyan genellikle olabildiğince kısıtlıdır . yani

public class MyClass
{
    string s = "";
}

etkili bir şekilde aynıdır:

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

Bağlantılı MSDN makalesi, açıkça belirtilmiş erişim değiştirici olmadığında tam bir açıklama sunar.

herkese açık - herhangi bir yerden herkes tarafından erişilebilir.
özel - ancak bir parçası olduğu sınıfta erişilebilir.
korumalı - yalnızca sınıftaki veya sınıftan devralınan herhangi bir nesneyle erişilebilir.

Hiçbir şey boş değil ama VB'de.
Statik, o nesnenin bir örneğine, sınıfın her örneği için bir yönteme sahip olduğunuz anlamına gelir.

mmm ...

Statik, sınıfın bir örneğine sahip olmadan bu işleve erişebileceğiniz anlamına gelir.

Doğrudan sınıf tanımından erişebilirsiniz.

Özel durumu, değişkenlere yalnızca aynı sınıftaki nesneler tarafından erişilebildiğini gösterir. Korumalı durum, erişimi sınıfın torunlarını da içerecek şekilde genişletir.

"yukarıdaki tablodan özel ve korumalı arasındaki farkı görebiliriz ... ikisinin de aynı olduğunu düşünüyorum .... yani bu iki ayrı komuta ne gerek var"

Daha fazla bilgi için MSDN bağlantısını kontrol edin

Bu erişim değiştiricileri üyelerinizin nerede görüneceğini belirtir. Muhtemelen bunu okumalısın. IainMH tarafından verilen bağlantıyı başlangıç ​​noktası olarak kabul edin.

Statik üyeler sınıf başına birdir ve örnek başına bir değildir.

Sınıflarınıza erişilebilirliğinizi dikkatlice izleyin. Herkese açık ve korunan sınıflara ve yöntemlere varsayılan olarak herkes erişebilir.

Ayrıca Microsoft, Visual Studio'da yeni sınıflar oluşturulduğunda erişim değiştiricileri (genel, korumalı, vb. Anahtar sözcükler) göstermede çok fazla sorun yaşamamaktadır. Bu yüzden, dikkatli olun ve sınıfınıza erişilebilirliğinizi düşünün, çünkü bu uygulama iç mekanlarınızın kapısıdır.

Bence iyi OOP tasarımı ile ilgili. Bir kütüphanenin geliştiricisiyseniz, kütüphanenizin iç işleyişini gizlemek istersiniz. Böylece kütüphane iç çalışmalarınızı daha sonra değiştirebilirsiniz. Böylece üyelerinizi ve yardımcı yöntemlerinizi özel olarak koyarsınız ve yalnızca arabirim yöntemleri herkese açıktır. Üzerine yazılması gereken yöntemler korunmalıdır.

C # toplam 6 erişim değiştiriciye sahiptir:

private : Bu erişilebilirlikle bildirilen üye, içerme türü içinde görülebilir, türetilmiş türler, aynı derlemedeki diğer türler veya içeren derleme dışındaki türler tarafından görülemez. yani, erişim yalnızca içerme türüyle sınırlıdır.

korumalı : Bu erişilebilirlik ile bildirilen üye, muhafaza tertibatının içindeki muhafaza tipinden türetilen tipler ve ihtiva eden tertibatın dışındaki muhafaza tipinden türetilmiş tipler içinde görülebilir. yani erişim, kapsayıcı tipten türetilmiş tiplerle sınırlıdır.

internal : Bu erişilebilirlikle beyan edilen üye, bu üyeyi içeren montajın içinde görülebilir, içeren montajın dışındaki hiçbir montaj tarafından görülemez. yani erişim, yalnızca montajı içeren tertibatla sınırlıdır.

dahili korumalı : Bu erişilebilirlikle beyan edilen üye, içerilen montajın içinde veya dışında bulunan tipten türetilen tipler içinde görülebilir, ayrıca içerilen grup içindeki herhangi bir tip tarafından da görülebilir. yani erişim, montaj veya türetilmiş tipler ihtiva etmekle sınırlıdır.

public : Bu erişilebilirlikle bildirilen üye, bu üyeyi içeren derlemede veya içeren derlemeye başvuran başka bir derlemede görülebilir. yani erişim sınırlı değildir.

C # 7.2 yeni bir erişilebilirlik düzeyi ekliyor:

özel korumalı : Bu erişilebilirlikle bildirilen üye, içerdiği montaj içinde bu içeren tipten türetilen türler içinde görülebilir. Kapsayıcı tipten türetilmemiş veya kapsayıcı grubun dışından türler tarafından görülemez. yani erişim, kaplayan tertibat içindeki türetilmiş tiplerle sınırlıdır.

Yeni özel korumalı erişim değiştiricisinin örnek kodunu içeren kaynak

C # için tüm erişim değiştiricilerin açıklamaları