From Java To C# A Developers Guide

6.2 Class members

In addition to instance and static variables, other classes (inner classes), and methods, a C# class can include many other different members. Class members can be divided into two categories:

• data members

• function ^[1] members.

  ^[1] This is a terminology thing ?the word 'function' (as in function member) does not mean just 'methods'. In OO languages, a method is simply another name for 'function', and some OO developers who graduated from traditional structured programming schools still use the term function to refer to method. In C#, function members include methods and properties, events, indexers, operators, instance constructors, destructors, and static constructors.

Members that can contain executable code are known as function members of the class.

Like Java

All methods and variables must be declared within a class. ^[2] The only C# statements that can be outside a class's curly braces are:

^[2] Like Java, C# has got rid of global methods or variables ?a feature in C/C++.

• C# preprocessor directives (see Chapter 24);

• using statements (similar to Java's import statement);

• namespace statements (similar to Java's package statement);

• code comments (of course).

Unlike Java

There are several new class members not heard of in Java. Examples include properties, events, indexers, operators, delegates, destructors, and static constructors. Table 6.2 gives a brief description of C# class members. Note the new members which do not have equivalents in Java.

The following C# class contains all the possible members mentioned above: ^[3]

^[3] You might notice (probably with unease) that I have named all my identifiers ?except for local variable names ?with an initial capital letter. In accordance to C#'s naming convention, only local variable names start with a lower case letter. This might take some getting used to.

 1: using System;
 2:
 3: public class MyClass{
 4:
 5:   // constant
 6:   public const string MyConstant = "C Sharp is fun!";
 7:
 8:   // instance field
 9:   public int MyField = 2;
10:
11:   // another instance field
12:   private string[] MyArray = new string[10];
13:
14:   // instance constructor
15:   public MyClass(){
16:     Console.WriteLine("1st instance constructor running");
17:   }
18:
19:   // overloaded instance constructor
20:   public MyClass(int newMyField){
21:     Console.WriteLine("2nd instance constructor running");
22:     MyField = newMyField;
23:   }
24:
25:   // static constructor
26:   static MyClass(){
27:     Console.WriteLine("static constructor running");
28:   }
29:
30:   // destructor
31:   ~MyClass(){
32:     Console.WriteLine("destructor running");
33:   }
34:
35:   // instance method
36:   public void DoSomething(){
37:     Console.WriteLine("instance method running");
38:   }
39:
40:   // static Main method
41:   public static void Main(){
42:     Console.WriteLine("Main method running");
43:     MyClass mc = new MyClass();
44:     mc = null;
45:   }
46:
47:   // property
48:   public int MyProperty{
49:     get{
50:       return MyField;
51:     }
52:     set{
53:       MyField = value;
54:     }
55:   }
56:
57:   // indexer
58:   public string this [int index]{
59:     get{
60:       return MyArray[index];
61:     }
62:     set{
63:       MyArray[index] = value;
64:     }
65:   }
66:
67:   // event
68:   public event EventHandler MyEvent;
69:
70:   // operator method
71:   public static MyClass operator + (MyClass a, MyClass b){
72:     return new MyClass(a.MyField + b.MyField);
73:   }
74:
75:   // nested class
76:   class MyNestedClass{
77:   }
78: } // end class

Table 6.2. C# class members

C# Class Member	Nearest equivalent in Java	Comments
Data Members
Constant	Final variable	You can declare a C# constant using the const modifier (see section 8.3)
Read-only variable	Final variable	A read-only variable is somewhat similar to a constant, except that its value can be set in a constructor (see section 8.3.3)
Event	No direct equivalent	An event is a special delegate instance used for event handling in C# (see Chapter 15)
Field	Class/instance variable	A field is similar to non-local variables in Java ?fields can be static (belongs to the class) or non-static (belongs to the object/instance of the class)
Function Members
Destructor	Java finalizer (finalize method)	A destructor is a special method in a class which is invoked by the garbage collector before the object is garbage collected ?in this aspect, a C# destructor is similar to the Java finalizer (see section 7.5)
Indexer	No direct equivalent	An indexer is a convenient way to treat an object encapsulating an array field as an array itself (see Chapter 21)
Instance constructor	Class constructor	The instance constructor is a special method invoked during instantiation of a class (see section 7.3)
Static constructor	Static initializer	The static constructor is a special method invoked before any static methods/fields are utilized (see section 7.4)
Method	Method	C# methods are similar to Java methods. A method can be static (belongs to the class) or non-static (belongs to the object/instance of the class) ?there are significant differences between how C# methods take in parameters though (see section 7.2)
Nested type declarations	Inner classes	Both C# and Java support inner/nested classes (see section 6.9)
Operator (or operator method)	No equivalent	C# supports operator overloading but Java does not ?operator overloading is accomplished by having special operator methods in the C# class (see Chapter 22)
Property	Accessor/mutator methods	A property can be treated as a field which has optional accessor/mutator methods (see Chapter 20)