ECMA-334 C# Language Specification

8.7: Classes (informative)

Class declarations define new reference types. A class can inherit from another class, and can implement interfaces.

Class members can include constants, fields, methods, properties, events, indexers, operators, instance constructors, destructors, static constructors, and nested type declarations. Each member has an associated accessibility (10.5), which controls the regions of program text that are able to access the member. There are five possible forms of accessibility. These are summarized in the table below. Form Intuitive meaning public Access not limited protected Access limited to the containing class or types derived from the containing class internal Access limited to this program protected internal Access limited to this program or types derived from the containing class private Access limited to the containing type

The example 
using System;  
class MyClass  
{  
   public MyClass() {  
      Console.WriteLine("Instance constructor");  
   }  
   public MyClass(int value) {  
      MyField = value;  
      Console.WriteLine("Instance constructor");  
   }  
   ~MyClass() {  
      Console.WriteLine("Destructor");  
   }  
   public const int MyConst = 12;  
   public int MyField = 34;  
   public void MyMethod(){  
      Console.WriteLine("MyClass.MyMethod");  
   }  
   public int MyProperty {  
      get {  
         return MyField;  
      }  
      set {  
         MyField = value;  
      }  
   }  
   public int this[int index] {  
      get {  
         return 0;  
      }  
      set {  
         Console.WriteLine("this[{0}] = {1}", index, value);  
      }  
   }  
   public event EventHandler MyEvent;  
   public static MyClass operator+(MyClass a, MyClass b) {  
      return new MyClass(a.MyField + b.MyField);  
   }  
   internal class MyNestedClass  
   {}  
}
shows a class that contains each kind of member. The example 
class Test  
{  
   static void Main() {  
      // Instance constructor usage  
      MyClass a = new MyClass();  
      MyClass b = new MyClass(123);  
      // Constant usage  
      Console.WriteLine("MyConst = {0}", MyClass.MyConst);  
      // Field usage  
      a.MyField++;  
      Console.WriteLine("a.MyField = {0}", a.MyField);  
      // Method usage  
      a.MyMethod();  
      // Property usage  
      a.MyProperty++;  
      Console.WriteLine("a.MyProperty = {0}", a.MyProperty);  
      // Indexer usage  
      a[3] = a[1] = a[2];  
      Console.WriteLine("a[3] = {0}", a[3]);  
      // Event usage  
      a.MyEvent += new EventHandler(MyHandler);  
      // Overloaded operator usage  
      MyClass c = a + b;  
   }  
   static void MyHandler(object sender, EventArgs e) {  
      Console.WriteLine("Test.MyHandler");  
   }  
   internal class MyNestedClass  
   {}  
}
shows uses of these members.

In This Section: