Internal Private

Internal Private

Table of contents

Exit focus mode

Light

Dark

High contrast

Light

Dark

High contrast

This browser is no longer supported.
Upgrade to Microsoft Edge to take advantage of the latest features, security updates, and technical support.
All types and type members have an accessibility level. The accessibility level controls whether they can be used from other code in your assembly or other assemblies. An assembly is a .dll or .exe created by compiling one or more .cs files in a single compilation. Use the following access modifiers to specify the accessibility of a type or member when you declare it:
The following examples demonstrate how to specify access modifiers on a type and member:
Not all access modifiers are valid for all types or members in all contexts. In some cases, the accessibility of a type member is constrained by the accessibility of its containing type.
Classes, records, and structs declared directly within a namespace (in other words, that aren't 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 public , internal , or private . Class members, including nested classes and structs, can be public , protected internal , protected , internal , private protected , or private . Class and struct members, including nested classes and structs, have private access by default. Private nested types aren't accessible from outside the containing type.
Derived classes and derived records can't have greater accessibility than their base types. You can't declare a public class B that derives from an internal class A . If allowed, it would have the effect of making A public, because all protected or internal members of A are accessible from the derived class.
You can enable specific other assemblies to access your internal types by using the InternalsVisibleToAttribute . For more information, see Friend Assemblies .
Class and record members (including nested classes, records and structs) can be declared with any of the six types of access. Struct members can't be declared as protected , protected internal , or private protected because structs don't support inheritance.
Normally, the accessibility of a member isn't greater than the accessibility of the type that contains it. However, a public member of an internal class might be accessible from outside the assembly if the member implements interface methods or overrides virtual methods that are defined in a public base class.
The type of any member field, property, or event must be at least as accessible as the member itself. Similarly, the return type and the parameter types of any method, indexer, or delegate must be at least as accessible as the member itself. For example, you can't have a public method M that returns a class C unless C is also public . Likewise, you can't have a protected property of type A if A is declared as private .
User-defined operators must always be declared as public and static . For more information, see Operator overloading .
Finalizers can't have accessibility modifiers.
To set the access level for a class , record , or struct member, add the appropriate keyword to the member declaration, as shown in the following example.
Interfaces declared directly within a namespace can be public or internal and, just like classes and structs, interfaces default to internal access. Interface members are public by default because the purpose of an interface is to enable other types to access a class or struct. Interface member declarations may include any access modifier. This is most useful for static methods to provide common implementations needed by all implementors of a class.
Enumeration members are always public , and no access modifiers can be applied.
Delegates behave like classes and structs. By default, they have internal access when declared directly within a namespace, and private access when nested.
For more information, see the C# Language Specification . The language specification is the definitive source for C# syntax and usage.
Non-derived class (different assembly)

Internal access specifier allows a class to expose its member variables and member functions to other functions and objects in the current assembly.
Any member with internal access specifier can be accessed from any class or method defined within the application in which the member is defined.
Private access specifier allows a class to hide its member variables and member functions from other functions and objects. Only functions of the same class can access its private members.
© Copyright 2022. All Rights Reserved.
We make use of First and third party cookies to improve our user experience. By using this website, you agree with our Cookies Policy.
Agree
Learn more

Home

Tutorials

Microsoft Technologies Tutorials

Java Programming Tutorials

Web Designing Tutorials

Script Programming Tutorials

Database Programming Tutorials

Mobile Technologies Tutorials

Other Programming Tutorials

Examples

Articles

Tools

News

C# Access Modifiers (Public, Private, Protected, Internal)

using System; namespace Tutlane {  class User  {    public string Name;    public string Location;    public int Age;    public void GetUserDetails()    {      Console . WriteLine ( "Name: {0}" , Name);      Console . WriteLine ( "Location: {0}" , Location);      Console . WriteLine ( "Age: {0}" , Age);    }  }  class Program  {    static void Main( string [] args)    {      User u = new User();      u. Name = "Suresh Dasari" ;      u. Location = "Hyderabad" ;      u. Age = 32 ;      u. GetUserDetails ();      Console . WriteLine ( "\nPress Enter Key to Exit.." );      Console . ReadLine ();    }  } }
using System; namespace Tutlane {  class User  {    private string Name;    private string Location;    private int Age;    private void GetUserDetails()    {      Console . WriteLine ( "Name: {0}" , Name);      Console . WriteLine ( "Location: {0}" , Location);      Console . WriteLine ( "Age: {0}" , Age);    }  }  class Program  {    static void Main( string [] args)    {      User u = new User();      // Complier Error      // These are inaccessible due to private specifier      u. Name = "Suresh Dasari" ;      u. Location = "Hyderabad" ;      u. Age = 32 ;      u. GetUserDetails ();      Console . WriteLine ( "\nPress Enter Key to Exit.." );      Console . ReadLine ();    }  } }
using System; namespace Tutlane {   class User   {     protected string Name;     protected string Location;     protected int Age;     protected void GetUserDetails()     {       Console . WriteLine ( "Name: {0}" , Name);       Console . WriteLine ( "Location: {0}" , Location);       Console . WriteLine ( "Age: {0}" , Age);     }   }   class Program   {     static void Main( string [] args)     {       User u = new User();       // Complier Error       // These are inaccessible due to protected specifier       u. Name = "Suresh Dasari" ;       u. Location = "Hyderabad" ;       u. Age = 32 ;       u. GetUserDetails ();       Console . WriteLine ( "\nPress Enter Key to Exit.." );       Console . ReadLine ();     }   } }
using System; namespace Tutlane {  class User  {    protected string Name;    protected string Location;    protected int Age;    protected void GetUserDetails()    {      Console . WriteLine ( "Name: {0}" , Name);      Console . WriteLine ( "Location: {0}" , Location);      Console . WriteLine ( "Age: {0}" , Age);    }  }  class Program: User  {    static void Main( string [] args)    {      User u = new User();      Program p = new Program();      // Complier Error      // protected members can only accessible with derived classes      //u.Name = "Suresh Dasari";      p. Name = "Suresh Dasari" ;      p. Location = "Hyderabad" ;      p. Age = 32 ;      p. GetUserDetails ();      Console . WriteLine ( "\nPress Enter Key to Exit.." );      Console . ReadLine ();    }  } }
In c#, the struct members cannot be protected because the struct cannot be inherited.
using System; namespace Tutlane {   class User   {    internal string Name;    internal string Location;    internal int Age;    internal void GetUserDetails()    {      Console . WriteLine ( "Name: {0}" , Name);      Console . WriteLine ( "Location: {0}" , Location);      Console . WriteLine ( "Age: {0}" , Age);    }   }   class Program   {    static void Main( string [] args)    {      User u = new User();      u. Name = "Suresh Dasari" ;      u. Name = "Suresh Dasari" ;      u. Location = "Hyderabad" ;      u. Age = 32 ;      u. GetUserDetails ();      Console . WriteLine ( "\nPress Enter Key to Exit.." );      Console . ReadLine ();    }   } }
using System; namespace Tutlane {  class User  {    protected internal string Name;    protected internal string Location;    protected internal int Age;    protected internal void GetUserDetails()    {      Console . WriteLine ( "Name: {0}" , Name);      Console . WriteLine ( "Location: {0}" , Location);      Console . WriteLine ( "Age: {0}" , Age);    }  }  class Program  {    static void Main( string [] args)    {     User u = new User();     u. Name = "Suresh Dasari" ;     u. Name = "Suresh Dasari" ;     u. Location = "Hyderabad" ;     u. Age = 32 ;     u. GetUserDetails ();     Console . WriteLine ( "\nPress Enter Key to Exit.." );     Console . ReadLine ();    }  } }
using System; namespace Tutlane {  class User  {    private protected string Name;    private protected string Location;    private protected int Age;    private protected void GetUserDetails()    {     Console . WriteLine ( "Name: {0}" , Name);     Console . WriteLine ( "Location: {0}" , Location);     Console . WriteLine ( "Age: {0}" , Age);    }  }  class Program: User  {    static void Main( string [] args)    {      User u = new User();      Program p = new Program();      // Complier Error      // protected members can only accessible with derived classes      //u.Name = "Suresh Dasari";      p. Name = "Suresh Dasari" ;      p. Location = "Hyderabad" ;      p. Age = 32 ;      p. GetUserDetails ();      Console . WriteLine ( "\nPress Enter Key to Exit.." );      Console . ReadLine ();    }  } }
In c#, Access Modifiers are the keywords used to define an accessibility level for all types and type members.
By specifying an access level for all types and type members, we can control whether they can be accessed in other classes or the current assembly or other assemblies based on our requirements.
The following are the different types of access modifiers available in the c# programming language.
Using these four access modifiers, we can specify the following six levels of accessibility for all types and type members based on our requirements.
Generally, in c# only one access modifier is allowed to use with any member or type, except when we use protected internal or private protected combinations.
In c#, we are not allowed to use any access modifiers on namespaces because the namespaces have no access restrictions.
Only certain access modifiers are allowed to specify based on the context in which a member declaration occurs. If we didn’t mention any access modifiers during member declaration, then the default access modifiers will be used depending on the member declaration context.
For example, the top-level types which are not nested in any other type can only have public or internal accessibility. The default accessibility for top-level types is internal .
In c#, the public modifier is used to specify that access is not restricted, so the defined type or member can be accessed by any other code in the current assembly or another assembly that references it.
Following is the example of defining members with a public modifier in the c# programming language.
If you observe the above example, we defined a User class with required variables and method using public access modifier and trying to access those variables and method in another class with an object reference of User class .
When you execute the above c# program, you will get the result as shown below.
If you observe the above result, we are able to access the variables and methods of the User class in another class because of specifying with public specifiers based on our requirements.
As discussed, the public access specifier will make all the defined members or types available to all the types in our application.
In c#, the private modifier is used to specify that access is limited to the containing type, so the defined type or member can only be accessed by the code in the same class or structure .
Following is the example of defining members with a private modifier in the c# programming language.
If you observe the above example, we defined a User class with required variables and method using private access modifier and trying to access those variables and method in another class with an object reference of User class .
When you execute the above c# program, you will get compile-time errors like as shown below.
If you observe the above result, we are getting compile-time errors because the private modifier members of the User class are referred in another class .
As discussed, the private modifier type or member can be accessed only by code in the same class or structure .
In c#, the protected modifier is used to specify that access is limited to the containing type or types derived from the containing class , so the type or member can only be accessed by code in the same class or in a derived class .
Following is the example of defining members with a protected modifier in the c# programming language.
If you observe the above example, we defined a User class with required variables and method using protected access modifier and trying to access those variables and method in another class with an object reference of User class .
When you execute the above c# program, you will get compile-time errors like as shown below.
If you observe the above result, we are getting compile-time errors because the protected modifier members of the User class are referred in another class .
As discussed, the protected members of a base class can be accessible in the derived class only when access occurs through the derived class type.
Following is the example of accessing a base class protected members in derived class through derived class type.
If you observe the above example, we are accessing base class ( User ) protected members using the reference of the derived class ( Program ). If we uncomment the commented code, we will get a compile-time error because we are trying to access protected members with base class ( User ) reference instead of the derived class ( Program ).
When you execute the above c# program, you will get the result as shown below.
This is how you can use protected modifiers in our c# applications to limit access to type or member in the same class or derived class based on our requirements.
In c#, the internal modifier is used to specify that access is limited to the current assembly. The type or member can be accessed by any code in the same assembly but not from another assembly.
Following is the example of defining the members with an internal modifier in the c# programming language.
If you observe the above example, we defined a User class with required variables and method using internal access modifier and trying to access those variables and method in another class with an object reference of User class .
When you execute the above c# program, you will get the result as shown below.
If you observe the above
Pissing Porno Pee
Naked Horror
Nyx Lingerie 06

Internal Private

Report Page