Properties

Properties look like fields from the outside, but internally they contain logic, like

methods do.

A property is declared like a field, but with a get/set block added. Here’s how to

implement CurrentPrice as a property:

public class Stock

{

decimal currentPrice; // The private "backing" field

public decimal CurrentPrice // The public property

{

get { return currentPrice; } set { currentPrice = value; }

}

}

Const v.s. static readonly

A static readonly field is also advantageous when exposing to

other assemblies a value that might change in a later version.

For instance, suppose assembly X exposes a constant as follows:

public const decimal ProgramVersion = 2.3;

If assembly Y references X and uses this constant, the value 2.3

will be baked into assembly Y when compiled. This means that

if X is later recompiled with the constant set to 2.4, Y will still

use the old value of 2.3 until Y is recompiled. A static

readonly field avoids this problem.

Another way of looking at this is that any value that might

change in the future is not constant by definition, and so should

not be represented as one.

Structs

A struct is similar to a class, with the following key differences:

• A struct is a value type, whereas a class is a reference type.

• A struct does not support inheritance (other than implicitly deriving from object, or more precisely, System.ValueType).

A struct can have all the members a class can, except the following:

• A parameterless constructor

• A finalizer

• Virtual members

public struct Point

{

int x = 1; // Illegal: cannot initialize field

int y;

public Point() {} // Illegal: cannot have

// parameterless constructor

public Point (int x) {this.x = x;} // Illegal: must assign field y

}

Class Access Modifiers

public

Fully accessible. This is the implicit accessibility for members of an enum or

interface.

internal

Accessible only within containing assembly or friend assemblies. This is the

default accessibility for non-nested types.

private

Accessible only within containing type. This is the default accessibility for

members of a class or struct.

protected

Accessible only within containing type or subclasses.

Class2 is accessible from outside its assembly; Class1 is not:

class Class1 {} // Class1 is internal (default)

public class Class2 {}

ClassB exposes field x to other types in the same assembly; ClassA does not:

class ClassA { int x; } // x is private (default)

class ClassB { internal int x; }

Functions within Subclass can call Bar but not Foo:

class BaseClass

{

void Foo() {} // Foo is private (default)

protected void Bar() {}

}

class Subclass : BaseClass

{

void Test1() { Foo(); } // Error - cannot access Foo

void Test2() { Bar(); } // OK

}

Constructors and Inheritance

A subclass must declare its own constructors. The base class’s constructors are

accessible to the derived class, but are never automatically inherited.

public class Baseclass

{

public int X;

public Baseclass () { }

public Baseclass (int x) { this.X = x; }

}

public class Subclass : Baseclass { }

//the following is illegal:

Subclass s = new Subclass (123);

Subclass must hence “redefine” any constructors it wants to expose. In doing so,

however, it can call any of the base class’s constructors with the base keyword:

public class Subclass : Baseclass

{

public Subclass (int x) : base (x) { }

}

If a constructor in a subclass omits the base keyword, the base type’s parameterless constructor is implicitly called. If the base class has no accessible parameterless constructor, subclasses are forced to use the base keyword in their constructors.