Type: Tutorial
Level: Beginners
Topic Category: General Programming
Main Series: Designing and Implementing Classes in C#
Topic Title: 1) An Introduction to Designing Classes in C# - Pt.2
Quick Review
In part 1 of this article, we discussed classes and how to design them by trying to answer the question of "What is it to declare/define a class?". We established (I hope) what classes are and what they are used for and what they consist of. We also distinguished between the informational and operational features of classes.
Introduction and familiarization
In summary, a class definition consists of defining the following members:
- Fields: describing the informational features of the class that must be stored (some informational features are calculated so they do not need to be stored)
- Properties: aliases for the informational features supporting doing some operations before retrieving or storing a value in the fields. They are also used for calculated informational features.
- Methods: represent the operations the class can do or the operations an object of the class can do.
- Events: a way to make objects of the class capable of informing other pieces of code of any event of interest.
- Class definitions may also contain definition of other types which we call "nested types"
The simplest class declaration in C# consists of the keyword "class" followed by the name of the class followed by a pair of curly brackets "{}". For example, for the mail package class:
class MailPackage{
}
However, the complete syntax is:}
access-modifier [static|abstract|sealed] class class-name [: [parentClass][, implementedInterface]*]
To fully understand this syntax, let's agree on the syntax description language I will be using to the end:
- Italic identifiers means you need to supply it (for instance, the name of the class, its parent, etc.)
- Lower case colored blue words: C# keywords
- Lower case uncolored words: another coding element that needs further description (for example, the access-modifier)
- Things in square brackets: optional items (might be included or not)
- Things separated with a pipe (|) character: either the first or the second but not both.
- Two things after each other, each being in square brackets: either the first or the second or both.
- The * symbol after an item: zero or more instances of this item can be repeated
- The + symbol after an item: one or more instances of this item can be repeated
- public
- internal
Modifiers are keywords that when introduced before a declaration, it modifies the way the declaration will normally behave. Access modifiers are modifiers related to the accessibility of a declared item. Access modifiers are used both with classes and members of classes. The decide what code can "access" the class or member. By access we mean use in the possible ways, for example, accessing a class is being able to use its name to call methods or to declare and instantiate objects. Accessing a field on the other hand means the ability to write to and read from that field. Accessing a method means being able to call the method and execute it, and accessing a property means the ability to read from and (if possible) write to the property. Finally, accessing an event is being able to attach event handlers to that event.
For classes not declared within other classes, there are two levels of accessibility: public and internal. Public classes are accessible in each and every code there is. That means you can use the class within the same assembly, in another assembly, in another country ... whatever and wherever! Internal classes can be accessed only within the same assembly it is in. For example, you can not create an object from a class that was declared internal in its assembly which is already compiled.
Do I have to specify an access modifier? and how do I decide which one to use?
Well, if you don't supply an access modifier, C# assumes it is internal making your class inaccessible anywhere outside the assembly that it belongs to. It is a good practice though to explicitly state the access modifier for you class even if it is internal. The code becomes clearer and it will be less likely that you'll accidentally hide a class that you want public.
As to how you choose, it depends. Usually, classes that are internal to the implementation of an application are declared internal. The rule of thumb is, declare all classes internal unless you want to access them from outside the assembly or you want other people to be able to. Usually, developers who develop class library for other developers to use (or even for themselves to use later on) use both public and internal classes. Application developers, especially when designing a single library unit/application/executable use all internal classes.
You said access modifier apply also to members of classes, how is that?
When you declare members, all of them can have access modifiers and have a default access level. Most members can be one of five access levels defined by the following access modifiers (ordered from highest accessibility to the lowest):
Declared accessibility | Meaning |
|---|---|
| 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. |
One thing to note is not to confuse accessibility with security. Access is granted to code scopes and not to persons or identities when we assign certain accessibility modifiers to classes or members. Also, although most members can have any access level, but usually, there is a scheme that goes on in most cases:
| Member Type | Usual Accessibility levels (ordered from most usual) |
| Field | private, protected, protected internal |
| Property | public, internal |
| Method | public, protected, private, protected internal, internal |
| Events | public |
Here's the link to the accessibility modifiers in C# in MSDN:
No comments:
Post a Comment