CODEWITHSUNDEEP
c#oopaccess-modifiersinformation-hidingpublic-members
user646317
user646317

Reputation: 45

Why aren't all fields/properties/methods public?

I know this may sound stupid, but i really want to know :) im learning c# currently,

and as you know you need to set "object"(button,label,text,variable, etc.) public or whatever you like.

However, you still need to write a code like this:

// my point is you cant just type label1.text you need to type class.label1.text
// so there is no chance of getting bugged
//because there is label1 in each of forms/classes
 class Classlol = new class();
 classlol.label1.blabla

So what's the point of making it unreachable in other forms ? why every thing isnt public or its not public by default ?

Thanks.

Upvotes: 2

Views: 1792

Answers (4)

madd0
madd0

Reputation: 9323

I suggest that you read more about abstraction in object oriented programming. Maybe the Wikipedia article on abstraction is a good place to start.

EDIT: Konrad is absolutely right, abstraction does not automatically imply "hiding" information. You could say that it's the role of encapsulation in object oriented programming.

I guess what I wanted to say is that this question is not specific to C#, but rather begs for a bit of reading on general object oriented programming principles.

Upvotes: 3

Shadow Wizard
Shadow Wizard

Reputation: 66389

The default access modifier is internal which means it's public inside the same assembly and private outside the assembly.

If you want to expose certain data as public, for example text of some Label, the best practice is creating public readonly property like this:

public string LabelText
{
   get { return MyLabel.Text; }
}

To access it you'll have to use such code:

string text = classInstance.LabelText;

This way the Label itself is not public, but its text can be read by everyone.

Upvotes: 0

Cody Gray
Cody Gray

Reputation: 244752

Simply speaking, pretty much the same reason that you wear clothes. Not everything should be exposed to the public at all times. Selected things need to be public so that others can interact with them, but other things are private and should be kept internal to that class.

Although, I probably shouldn't have used the word internal there in that last sentence, because there's a third option: the internal access modifier. The name used in VB.NET (Friend) is probably clearer. This indicates that a piece of data should be visible to all of the other classes within a single assembly, but hidden from outside. A similar analogy applies: there are things that you might share with your closest friends, but still don't want to be public.

There are other more complicated reasons, like to enable information hiding, to maximize the separation between a particular class and the rest of an application, and to maintain a consistent public interface even though implementation details may have been changed between versions, all of which contribute to good object-oriented design. If you really want to understand the nitty-gritty, I suggest picking up a good book on object-oriented programming. It's very difficult, if not impossible, to master an object-oriented language like C# without a solid understanding of the fundamentals.

Things aren't public by default because they might contain sensitive information, or at least information that you don't want to expose as part of the class's public interface. Making something public is a bigger decision with more risks than simply making it private, so you are forced to make that decision explicitly.

Upvotes: 7

Jonathan Wood
Jonathan Wood

Reputation: 67193

The point of using classes is to be able to separate your code into logically related pieces. This makes your code easier to understand and maintain.

For example, if you need to modify code in a class, you can focus more on the way that class functions and less on other parts of your project. However, public members of your class limit this separation somewhat because, if you modify a public member, that can affect other parts of your project.

Keeping as much of your class private as possible (while still usable from your application) maximizes the separation between it and the rest of your application. It makes it easier to think about only the logic in the class you are working on, and it allows you to modify those private members without having to think what other parts of your application might be affected.

Upvotes: 7

Related Questions