Can private classes exist in C#, other than in Inner classes? 

Concept of Private class in C#

I just realized that the C# **property construct** can also be used with a **private** access modifier:

    private string Password { get; set; }

Although this is technically interesting, I can&#39;t imagine when I would use it since a **private field** involves even **less ceremony**:

    private string _password;

 and I can&#39;t imagine when I would ever need to be able to internally ***get* but not *set*** or ***set* but not *get*** a private field:

    private string Password { get; }

or

    private string Password { set; }

but perhaps there is a use case with **nested / inherited classes** or perhaps where a get/set might contain **logic** instead of just giving back the value of the property, although I would tend to keep properties strictly simple and let explicit methods do any logic, e.g. `GetEncodedPassword()`.

**Does anyone use private properties in C# for any reason or is it just one of those technically-possible-yet-rarely-used-in-actual-code constructs?**

&lt;h1&gt;Addendum&lt;/h1&gt;

Nice answers, reading through them I culled these uses for private properties:

- when private fields need to be lazily loaded
- when private fields need extra logic or are calculated values
- since private fields can be difficult to debug
- in order to &quot;present a contract to yourself&quot;
- to internally convert/simplify an exposed property as part of serialization
- wrapping global variables to be used inside your class

 

Are there any reasons to use private properties in C#?

I&#39;ve recently upgraded to Intellij IDEA 2017.2 and access modifier icons disappeared from my file tree... How to get them back?

[![][1]][1]


  [1]: https://i.stack.imgur.com/gr70C.png

How to show access modifiers for classes in IntelliJ IDEA?

I have a common assembly/project that has an abstract base class, then several derived classes that I want to make public to other assemblies. 

I don&#39;t want the abstract base class to show up in these other assemblies in Intellisense, so I thought I&#39;d make it `internal`, but I get this error:

&gt; Inconsistent accessibility: base class &#39;Settings&#39; is less accessible than class &#39;IrcSettings&#39; ....

I don&#39;t really get this. I am forced to make the abstract `Settings` class `public`, and thus visible outside this assembly. 

How can I make this class `internal` instead?

Internal abstract class: how to hide usage outside assembly?

In Objective-C instance data can be `public`, `protected` or `private`. For example:

    @interface Foo : NSObject
    {
      @public
        int x;
      @protected:
        int y;
      @private:
        int z;
      }
    -(int) apple;
    -(int) pear;
    -(int) banana;
    @end

I haven&#39;t found any mention of access modifiers in the Swift reference. Is it possible to limit the visibility of data in Swift?

Does Swift have access modifiers?

Can someone please explain the difference between the `protected` and `protected internal` modifiers in C#? It looks like their behavior is identical.

What is the difference between &#39;protected&#39; and &#39;protected internal&#39;?

In Java, are there clear rules on when to use each of access modifiers, namely the default (package private), `public`, `protected` and `private`, while making `class` and `interface` and dealing with inheritance?

What is the difference between public, protected, package-private and private in Java?

All my college years I have been using `public`, and would like to know the difference between `public`, `private`, and `protected`?

Also what does `static` do as opposed to having nothing?

In C#, what is the difference between public, private, protected, and having no access modifier?

I have seen some references refer to a access modifier in Java called `private protected` (both words together):

    private protected someMethod() {

    }

One of the pages I found referring to this is [here][1]. My school lesson also referred to this access modifier (and said it exists). Using it, however, results in an error in the Java language.

I tried with both variables and methods and I&#39;m pretty sure it doesn&#39;t exist, but I want an explanation of what happened. Was it considered, then rejected? Or did it get removed in a newer version of Java?

[1]:https://www.cs.princeton.edu/courses/archive/spr96/cs333/java/tutorial/java/javaOO/methodaccess.html

Edit: I am not looking for info about the `protected` keyword.

Does Java have a &quot;private protected&quot; access modifier?

For all of the different concepts that support access modifiers, such as fields, properties, methods and classes, which access modifiers are implied if not specified?

Which access modifiers are implied when not specified?

While dabbling with Typescript I realised my classes within modules (used as namespaces) were not available to other classes unless I wrote the `export` keyword before them, such as:

    module some.namespace.here
    {
       export class SomeClass{..}
    }

So now I can use the above code like this:

    var someVar = new some.namespace.here.SomeClass();

However I was just wondering why this keyword is used opposed to just using the ``public`` keyword which is used at method level to signify that a method or property should be externally accessible. So why not just use this same mechanism to make classes and interfaces etc externally visible?

This would give resulting code like:

    module some.namespace.here
    {
       public class SomeClass{..}
    }

Why does Typescript use the keyword &quot;export&quot; to make classes and interfaces public?

What is the default access modifier for a method or an instance variable if I do not state it explicitly?

For example:

    package flight.booking;

    public class FlightLog
    {
        private SpecificFlight flight;

        FlightLog(SpecificFlight flight)
        {
            this.flight = flight;
        }
    }

Is the access modifier of this constructor protected or package? Can other classes in the same package, which is `flight.booking`, call this constructor?


What is the default access modifier in Java?

I am coding a small Python module composed of two parts:

- some functions defining a public interface,
- an implementation class used by the above functions, but which is not meaningful outside the module.

At first, I decided to &quot;hide&quot; this implementation class by defining it inside the function using it, but this hampers readability and cannot be used if multiple functions reuse the same class.

So, in addition to comments and docstrings, is there a mechanism to mark a class as &quot;private&quot; or &quot;internal&quot;? I am aware of the underscore mechanism, but as I understand it it only applies to variables, function and methods name.

&quot;Private&quot; (implementation) class in Python

As part of the [Roslyn](https://github.com/dotnet/roslyn) documentation on GitHub, there&#39;s a page called [Language feature implementation status](https://github.com/dotnet/roslyn/wiki/Languages-features-in-C%23-6-and-VB-14), with planned language features for C# and VB.

One feature I couldn&#39;t wrap my head around was `private protected` access modifier:

    private protected string GetId() { … } 

There is also a page of [C# Language Design Notes](https://github.com/dotnet/csharplang/tree/master/meetings/2014), which explains many new features, but not this one.

Eric Lippert said in a [comment][1]:

&gt; Your error is in thinking of the modifiers as increasing restrictions. The modifiers in fact always decrease restrictions. Remember, things are &quot;private&quot; by default; only by adding modifiers do you make them less restricted.

What is the meaning of `private protected`? When might I use it?

  [1]: https://stackoverflow.com/questions/1063901/why-is-internal-protected-not-more-restrictive-than-internal#comment876691_1063901

What is the meaning of the planned &quot;private protected&quot; C# access modifier?

What is the equivalent of Java&#39;s `final` in C#?

What is the equivalent of Java&#39;s final in C#?

As far as I know, `private` is the default *everywhere* in C# (meaning that if I don&#39;t write `public`, `protected`, `internal`, etc. it will be `private` by default). (Please correct me if I am wrong.)

So, what&#39;s the reason to write that keyword, or why does it even exist for members?

For example, when an event handler is auto-generated it looks like this:

    private void RatTrap_MouseEnter(object sender, CheeseEventArgs e)
    {
        
    }

But why does it even write private if that&#39;s implied and default? Just so that novice developers (who don&#39;t know it&#39;s the C# default) know that it&#39;s private? Or is there a difference for the compiler?

Moreover, is there a case where writing &quot;private&quot; (alone) *will* change the accessibility of the member?


Any reason to write the &quot;private&quot; keyword in C#?

I have some protocols

**LoginStrategy**

    public protocol LoginStrategy {
        func login(_ viewController: UIViewController)
        func getUserInfo(withCompletionHandler completionHandler: @escaping (_ userInfo: [String: Any]?) -&gt; ())
        func createLoginButton(_ frame: CGRect, withCompletionHandler completionHandler: @escaping (_ loginButton: UIView) -&gt; ())
        func getUserId() -&gt; String
    }

and two classes:

**LoginProvider**

    public class LoginProvider {
        
        public let strategy: LoginStrategy
        
        public func login(_ viewController: UIViewController) {
            return self.strategy.login(viewController)
        }
        
        public func getUserInfo(withCompletionHandler completionHandler: @escaping (_ userInfo: [String: Any]?) -&gt; ()) {
            return self.strategy.getUserInfo(withCompletionHandler: completionHandler)
        }
        
        public func createLoginButton(_ frame: CGRect, withCompletionHandler completionHandler: @escaping (_ loginButton: UIView) -&gt; ()) {
            return self.strategy.createLoginButton(frame, withCompletionHandler: completionHandler)
        }
        
        public func getUserId() -&gt; String {
            return self.strategy.getUserId()
        }
        
        public init(strategy: LoginStrategy) {
            self.strategy = strategy
        }
        
    }

**FacebookLoginStrategy**

    import Foundation
    import FacebookCore
    import FacebookLogin
    
    public class FacebookLoginStrategy: LoginStrategy {
        
        public var grantedPermissions: Set&lt;Permission&gt;? = nil
    
        public var declinedPermissions: Set&lt;Permission&gt;? = nil
        
        public var userId: String = &quot;&quot;
        
        public func login(_ viewController: UIViewController) {
            let loginManager = LoginManager()
            let permissions: [ReadPermission] = [.publicProfile, .userFriends, .email]
            loginManager.logIn(permissions, viewController: viewController) { loginResult in
                switch loginResult {
                case .failed(let error):
                    print(error)
                case .cancelled:
                    print(&quot;User cancelled login.&quot;)
                case .success(let grantedPermissions, let declinedPermissions, let accessToken):
                    self.userId = accessToken.userId ?? &quot;&quot;
                    self.grantedPermissions = grantedPermissions
                    self.declinedPermissions = declinedPermissions
                    print(&quot;Logged in!&quot;)
                }
            }
        }
        
        public func getUserId() -&gt; String {
            return userId
        }
        
        public func getUserInfo(withCompletionHandler completionHandler: @escaping (_ userInfo: [String: Any]?) -&gt; ()) {
            let request = GraphRequest(graphPath: &quot;me&quot;, parameters: [&quot;fields&quot;:&quot;email, name&quot;], accessToken: AccessToken.current, httpMethod: .GET, apiVersion: FacebookCore.GraphAPIVersion.defaultVersion)
            request.start { (response, result) in
                switch result {
                case .success(let value):
                    print(value.dictionaryValue)
                    completionHandler(value.dictionaryValue)
                case .failed(let error):
                    print(error)
                }
            }
        }
    
        public func createLoginButton(_ frame: CGRect, withCompletionHandler completionHandler: @escaping (_ loginButton: UIView) -&gt; ()) {
            let permissions: [ReadPermission] = [.publicProfile, .userFriends, .email]
            let loginButton = LoginButton(readPermissions: permissions)
            loginButton.frame = frame
            completionHandler(loginButton)
        }
    }

In my **ViewController**:

When I use:

    let facebookLoginProvider = LoginProvider(strategy: FacebookLoginStrategy())

It says:

&gt; &#39;FacebookLoginStrategy&#39; is inaccessable due to &#39;internal&#39; protection
&gt; level


Initializer is inaccessable due to &#39;internal&#39; protection level

What are public, private and protected in object oriented programming?

I am a little confused over the term &quot;package private&quot; that some of the documentation uses, along with the usage of &quot;default access.&quot; Aren&#39;t package-private and default access both synonymous with protected?

Isn&#39;t &quot;package private&quot; member access synonymous with the default (no-modifier) access?

Could you please explain what the practical usage is for the `internal` keyword in C#?

I know that the `internal` modifier limits access to the current assembly, but when and in which circumstance should I use it?

Practical uses for the &quot;internal&quot; keyword in C#

In Java the `private` access modifier consider as safe since it is not visible outside of the class. Then outside world doesn&#39;t know about that method either. 

But I thought Java reflection can use to break this rule. Consider following case:

&lt;!-- language-all: lang-java --&gt;

    public class ProtectedPrivacy{

      private String getInfo(){
         return &quot;confidential&quot;; 
      }

    }  

Now from another class I am going to get Info:

    public class BreakPrivacy{
      
       public static void main(String[] args) throws Exception {
           ProtectedPrivacy protectedPrivacy = new ProtectedPrivacy();
           Method method = protectedPrivacy.getClass().getDeclaredMethod(&quot;getInfo&quot;, null);
           method.setAccessible(true);
           Object result = method.invoke(protectedPrivacy);
           System.out.println(result.toString());
       }
    } 

At this moment I just thought still private method safe since to do some thing like above we must know method name. But if class which contain private method written by some one else we don&#39;t have visibility of those.

But my point become invalid since below line of code.

    Method method[] = new ProtectedPrivacy().getClass().getDeclaredMethods();

Now this `method[]` contains all the things need to do above thing. My question is, is there a way to avoid this kind of things doing using Java reflection?

I am quote some point from [Java Documentation][1] to clarify my question.

&gt; Tips on Choosing an Access Level: 
&gt; 
&gt; If other programmers use your class, you want to ensure that errors
&gt; from misuse cannot happen. Access levels can help you do this.Use the
&gt; most restrictive access level that makes sense for a particular
&gt; member. Use private unless you have a good reason not to.


  [1]: http://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html

Are private methods really safe?

    class Test {
        public static void main(String arg[]) {    
            System.out.println(&quot;**MAIN METHOD&quot;);
            System.out.println(Mno.VAL); // SOP(9090);
            System.out.println(Mno.VAL + 100); // SOP(9190);
        }

    }
    
    class Mno {
        final static int VAL = 9090;
        static {
            System.out.println(&quot;**STATIC BLOCK OF Mno\t: &quot; + VAL);
        }
    }

I know that a `static` block executed when class loaded. But in this case the instance variable inside class `Mno` is `final`, because of that the `static` block is not executing. 

Why is that so? And if I would remove the `final`, would it work fine? 

Which memory will be allocated first, the `static final` variable or the `static` block? 

If due to the `final` access modifier the class does not get loaded, then how can the variable get memory?

Static block in Java not executed

What is the difference between the `internal` and `private` access modifiers in C#?

Internal vs. Private Access Modifiers

What is the default access modifier for classes, methods, members, constructors, delegates and interfaces?



What are the default access modifiers in C#?

What is the argument against declaring protected-access members on interfaces? This, for example, is invalid:

    public interface IOrange
    {
        public OrangePeel Peel { get; }
        protected OrangePips Seeds { get; }
    }

In this example, the interface `IOrange` would guarantee that implementors *at least* provide an `OrangePips` instance to their inheritors. If the implementor wanted to, they could expand the scope to full `public`:

    public class NavelOrange : IOrange
    {
        public OrangePeel Peel { get { return new OrangePeel(); } }
        protected OrangePips Seeds { get { return null; } }
    }

    public class ValenciaOrange : IOrange
    {
        public OrangePeel Peel { get { return new OrangePeel(); } }
        public OrangePips Seeds { get { return new OrangePips(6); } }
    }


The intent of `protected` members on interfaces is to provide a support contract for *inheritors* (sub-classes), for example:

    public class SpecialNavelOrange : NavelOrange
    {
        ...
        // Having a seed value is useful to me.
        OrangePips seeds = this.Seeds; 
        ...
    }

(Admittedly, this wouldn&#39;t work for `struct`s)

I can&#39;t see much of a case for `private` or `internal` modifiers in interfaces, but supporting both `public` and `protected` modifiers seems perfectly reasonable.

&lt;hr/&gt;

I&#39;m going to try explaining the utility of `protected` members on `interface`s by separating them from `interface`s entirely:

Let&#39;s imagine a new C# keyword, `support`, to enforce inheritor contracts, so that we declare things as follows:

    public support IOrangeSupport
    {
        OrangePips Seeds { get; }
    }

This would allows us to contract classes to provide protected members to their inheritors:

    public class NavelOrange : IOrange, IOrangeSupport
    {
        public OrangePeel Peel { get { return new OrangePeel(); } }
        protected OrangePips Seeds { get { return null; } }
    }

This is not particularly useful, because classes would already imply this contract by providing the `protected` members in the first place.

But then we could also do this:

    public interface IOrange : IOrangeSupport
    {
       ...
    }

Thereby applying `IOrangeSupport` to all classes which implement `IOrange` and requiring them to provide particular `protected` members - which is not something we can currently do.

Why can&#39;t I have protected interface members?

Whoopee, not working on that socket library for the moment. I&#39;m trying to educate myself a little more in C++.

With classes, is there a way to make a variable read-only to the public, but read+write when accessed privately? e.g. something like this:

    class myClass {
        private:
        int x; // this could be any type, hypothetically
        
        public:
        void f() {
            x = 10; // this is OK
        }
    }

    int main() {
        myClass temp;

        // I want this, but with private: it&#39;s not allowed
        cout &lt;&lt; temp.x &lt;&lt; endl;


        // this is what I want:

        // this to be allowed
        temp.f(); // this sets x...

        // this to be allowed
        int myint = temp.x;

        // this NOT to be allowed
        temp.x = myint;
    }

My question, condensed, is how to allow full access to `x` from within `f()` but read-only access from anywhere else, i.e. `int newint = temp.x;` allowed, but `temp.x = 5;` not allowed? like a const variable, but writable from `f()`...

EDIT: I forgot to mention that I plan to be returning a large vector instance, using a getX() function would only make a copy of that and it isn&#39;t really optimal. I could return a pointer to it, but that&#39;s bad practice iirc.

P.S.: Where would I post if I just want to basically show my knowledge of pointers and ask if it&#39;s complete or not? Thanks!

Class variables: public access read-only, but private access read/write

Why does Java specify that the access specifier for an overriding method can allow more, but not less, access than the overridden method? For example, a protected instance method in the superclass can be made public, but not private, in the subclass.

When overriding a method, why can I increase access but not decrease it?

Ok, so this may be a bit of a silly question, and there&#39;s certainly the obvious answer, but I was curious if I&#39;ve missed any subtleties here.

Is there any difference in terms of visibility/usability between a `public` member declared in an `internal` class and an `internal` member declared in an `internal` class?

i.e. between

    internal class Foo
    {
        public void Bar()
        {
        }
    }

and

    internal class Foo
    {
        internal void Bar()
        {
        }
    }

If you declared the method as `public` and also `virtual`, and then overrode it in a derived class that is `public`, the reason for using this modifier is clear. However, is this the only situation... am I missing something else?

Public and Internal members in an Internal class?

In VB6/VBA, you can declare module-level variables outside of a specific `Sub` or `Function` method.  I&#39;ve used `Private` and `Public` before inside modules and understand them like so:

 - `Public` - visible to all code inside the module and all code outside the module, essentially making it global.
 - `Private` - visible only to code inside the module.

I&#39;ve noticed that you can use `Dim` and `Global` as modifiers for modular variables.  Are `Dim` and `Global` different from `Private` and `Public`, respectively, when used as access modifiers on modular fields? If so, how are they different?

What is the difference between Dim, Global, Public, and Private as Modular Field Access Modifiers?

[C# 7.2 introduces the private protected modifier][1]. 

I&#39;ve always protected access to fields with properties, allowing access via the Get/Set methods as I typically don&#39;t want the internal state of my object modified by anything other than my own class.

I&#39;m trying to understand why the C# language team have added this feature. After an extensive search on google, and reading and watching the &#39;what&#39;s new&#39; media (I&#39;ve watched the [press release][2], [details][3] and [video by Mads Torgerson][4]), I am still none the wiser.

To me, this appears to allow a developer to break the Liskov Substitution principle, but this may be because I do not understand why this feature now exists.

I understand how it can be used, just not why - please can someone provide a real-world usage example rather than the contrived one in the MSDN documents?

  [1]: https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/private-protected
  [2]: https://blogs.msdn.microsoft.com/dotnet/2017/11/15/welcome-to-c-7-2-and-span/?utm_source=vs_developer_news&amp;utm_medium=referral
  [3]: https://docs.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-7-2
  [4]: https://channel9.msdn.com/events/Connect/2017/T122

What is the use case for the (C# 7.2) &quot;private protected&quot; modifier?

There are two types of modifiers in Scala: `final` and `sealed`

What are the differences between them? When should you use one over the other?

What are the differences between final class and sealed class in Scala?

What are the differences between the following:

 - Private Sub  
 - Private Function 
 - Private Class

When should each one be used?


Difference between Private Sub, Function and Class

I&#39;m starting in swift and opening a project created using swift2 from xcode 8 beta, the `private` modifier were changed to `fileprivate`. what does this keyword means? and how is different from `private` ?

What does &#39;fileprivate&#39; keyword means in Swift?

Every time I write method in Java with more keywords than `public void`, every time I write it another way. Sometimes &quot;`static public void`&quot; sometimes &quot;`public static void`&quot; etc.

What is the best order (best practices) for these keywords?

[`abstract/static`] [`final`] [`synchronized`] [`public/private/protected`] [`result_type`] ???

Modifier Keyword order in Java

ReSharper suggests changing the accessibility of a `public` constructor in an `abstract` class to `protected`, but it does not state the rationale behind this.

Can you shed some light?

Why should constructors on abstract classes be protected, not public?

My first question is - 

       class Explain() {
            public Explain() {
          }
       }

Should Constructor always declared as public? 

What if I create a `private` constructor.

I always seen constructors are implicitly `public`. So why `private` constructor is useful? Or is it not useful at all. Because nobody could ever call it, or never make an object(because of the `private` constructor) ! And that is my second question.


All Access Modifiers Solutions on Gang of Coders

Total of 36 Access Modifiers Solutions

Concept of Private class in C#

Are there any reasons to use private properties in C#?

How to show access modifiers for classes in IntelliJ IDEA?

Internal abstract class: how to hide usage outside assembly?

Does Swift have access modifiers?

What is the difference between 'protected' and 'protected internal'?

What is the difference between public, protected, package-private and private in Java?

In C#, what is the difference between public, private, protected, and having no access modifier?

Does Java have a "private protected" access modifier?

Which access modifiers are implied when not specified?

Why does Typescript use the keyword "export" to make classes and interfaces public?

What is the default access modifier in Java?

"Private" (implementation) class in Python

What is the meaning of the planned "private protected" C# access modifier?

What is the equivalent of Java's final in C#?

Any reason to write the "private" keyword in C#?

Initializer is inaccessable due to 'internal' protection level

What are public, private and protected in object oriented programming?

Isn't "package private" member access synonymous with the default (no-modifier) access?

Practical uses for the "internal" keyword in C#