CODEWITHSUNDEEP
c#access-modifiers
DarkLightA
DarkLightA

Reputation: 15692

Difference between public and private variables

namespace hi
{
    class hithere
    {
         public int numberOne = 12;
         private int numberTwo = 12;

         static void yo()
         {
         }
    }
}

Can someone tell me the difference between the variables numberOne and numberTwo in this code excerpt?

Upvotes: 3

Views: 13537

Answers (8)

user541686
user541686

Reputation: 210755

It means that if you have another class like this:

namespace hi
{
    class hithere2
    {
         static void yo2()
         {
             hithere h = new hithere();
             h.numberOne = 2;
             h.numberTwo = 3;
         }
    }
}

The second one errors, but the first is OK.

Upvotes: 0

jason
jason

Reputation: 241779

public and private are access modifiers for members. This refers to who can access the members directly through code. public means that access is not limited so that anyone can access the member directly through code. private means that access is limited only to the containing class. So everyone can access numberOne directly through code, but only the containing class can access numberTwo directly through code.

There are a total of five access modifiers:

public: access is not limited

protected: access is limited to the containing class or classes derived from the containing class

internal: access is limited to the containing assembly

protected internal: this is an OR of protected and internal so that access is limited to the containing class or classes derived from the containing class OR the containing assembly

private: access is limited to the containing class

Note that the clause "directly through code" is critical here; it is possible to access these members using reflection.

The relevant section of the C# specification is §3.5, especially §3.5.2.

Upvotes: 0

Saeed Amiri
Saeed Amiri

Reputation: 22565

Public variables are accessible from out side classes but private one just accessible for current class and inner classes:

public class VarClass
{
    public int publicID = 10;
    private int privateID = 100;
    public VarClass()
    {
        Console.WriteLine(publicID);
        Console.WriteLine(privateID);
    }

    public class InnerClass
    {
        public InnerClass()
        {
            VarClass c = new VarClass();
            Console.WriteLine(c.privateID);
            Console.WriteLine(c.publicID);
        }
    }
}

public class OuterClass
{
    public OuterClass()
    {
        VarClass c = new VarClass();
        Console.WriteLine(c.privateID); // Compile Error
        Console.WriteLine(c.publicID);
    }
}

Upvotes: 2

MrEyes
MrEyes

Reputation: 13750

In the simplest terms numberOne being marked as public means that if you create an instance of your hithere class this member variable will be accessible. For example:

hithere h = new hithere()
h.numberOne = 42;

numberTwo being private means that this is not accessible and can only be used within the hithere class. So taking the above example further:

hithere h = new hithere()
h.numberOne = 42;
h.numberTwo = 84;

The last line would cause a compiler error as you cannot access numberTwo as this is private.

It is probably worth spending some time reading up on access modifiers, a quick google will find many examples, e.g:

http://www.devsource.com/c/a/Techniques/Understanding-C-Class-and-Member-Modifiers/ http://msdn.microsoft.com/en-us/library/ba0a1yw2%28v=vs.80%29.aspx

Additionally your hithere class does not have an access modifier defined therefore the compiler assumes this to be private. As such if you were to reference your library from another you would not be able to create instances of the hithere class.

Upvotes: 0

alansiqueira27
alansiqueira27

Reputation: 8534

Search for "Encapsulation". There are so many easy materials to study it.

Upvotes: 0

SDReyes
SDReyes

Reputation: 9954

From the accessibility levels at MSDN:

public Access is not restricted.

protected Access is limited to the containing class or types derived from the containing class.

internal Access is limited to the current assembly.

protected internal Access is limited to the current assembly or types derived from the containing class.

private Access is limited to the containing type.

Upvotes: 5

DRapp
DRapp

Reputation: 48179

in general, PUBLIC means any other code outside the class can change its value. PRIVATE are only able to be used/changed IN the class itself. Additionally, if you build classes that are derived from another, and you want the child-level class to be able to use/change values of its parent, but not other generic code outside the class, use PROTECTED.

Upvotes: 0

kemiller2002
kemiller2002

Reputation: 115538

Other objects can access NumberOne, but they can't access numberTwo.

So I can do Your_Object.numberOne = 14; but I can't do Your_Object.numberTwo= 14;

Now I might be able to access the numberTwo through reflection depending on the permissions set up in the application, but I can't directly.

Variables in C#
Reflection in C#
Accessors in C#

Upvotes: 1

Related Questions