• Indexers enable objects to be indexed in a similar way to arrays.

• A get accessor returns a value. A set accessor assigns a value.

• The this keyword is used to define the indexers.

• The value keyword is used to define the value being assigned by the set indexer.

• Indexers do not have to be indexed by an integer value; it is up to you how to define the specific look-up mechanism.

• Indexers can be overloaded.

• Indexers can have more than one formal parameter, for example, when accessing a two-dimensional array.

Time in hours: 24

• Properties enable a class to expose a public way of getting and setting values, while hiding implementation or verification code.

• A get property accessor is used to return the property value, and a set accessor is used to assign a new value. These accessors can have different access levels. For more information, see Accessor Accessibility.

• The value keyword is used to define the value being assigned by the set indexer.

• Properties that do not implement a set method are read only.

A class can be declared static, indicating that it contains only static members. It is not possible to create instances of a static class using the new keyword. Static classes are loaded automatically by the .NET Framework common language runtime (CLR) when the program or namespace containing the class is loaded.

Use a static class to contain methods that are not associated with a particular object. For example, it is a common requirement to create a set of methods that do not act on instance data and are not associated to a specific object in your code. You could use a static class to hold those methods.

The main features of a static class are:

• They only contain static members.

• They cannot be instantiated.

• They are sealed.

• They cannot contain Instance Constructors (C# Programming Guide).

Creating a static class is therefore much the same as creating a class that contains only static members and a private constructor. A private constructor prevents the class from being instantiated.

The advantage of using a static class is that the compiler can check to make sure that no instance members are accidentally added. The compiler will guarantee that instances of this class cannot be created.

Static classes are sealed and therefore cannot be inherited. Static classes cannot contain a constructor, although it is still possible to declare a static constructor to assign initial values or set up some static state. For more information, see Static Constructors (C# Programming Guide).

Suppose you have a class CompanyInfo that contains the following methods to get information about the company name and address.

class CompanyInfo
{
   public string GetCompanyName() { return "CompanyName"; }
   public string GetCompanyAddress() { return "CompanyAddress"; }
   //...
}

These methods do not need to be attached to a specific instance of the class. Therefore, instead of creating unnecessary instances of this class, you can declare it as a static class, like this:

static class CompanyInfo
{
   public static string GetCompanyName() { return "CompanyName"; }
   public static string GetCompanyAddress() { return "CompanyAddress"; }
   //...
}

Use a static class as a unit of organization for methods not associated with particular objects. Also, a static class can make your implementation simpler and faster because you do not have to create an object in order to call its methods. It is useful to organize the methods inside the class in a meaningful way, such as the methods of the Math class in the System namespace.

A static method, field, property, or event is callable on a class even when no instance of the class has been created. If any instances of the class are created, they cannot be used to access the static member. Only one copy of static fields and events exists, and static methods and properties can only access static fields and static events. Static members are often used to represent data or calculations that do not change in response to object state; for instance, a math library might contain static methods for calculating sine and cosine.

Static class members are declared using the static keyword before the return type of the member, for example:

public class Automobile
{
   public static int NumberOfWheels = 4;
   public static int SizeOfGasTank
   {
       get
       {
           return 15;
       }
   }
   public static void Drive() { }
   public static event EventType RunOutOfGas;

   //other non-static fields and properties...
}

Static members are initialized before the static member is accessed for the first time, and before the static constructor, if any is called. To access a static class member, use the name of the class instead of a variable name to specify the location of the member. For example:

Automobile.Drive();
int i = Automobile.NumberOfWheels;

Here is an example of a static class that contains two methods that convert temperature from Celsius to Fahrenheit and vice versa:

C#

Copy Code

public static class TemperatureConverter
{
   public static double CelsiusToFahrenheit(string temperatureCelsius)
   {
       // Convert argument to double for calculations.
       double celsius = System.Double.Parse(temperatureCelsius);

       // Convert Celsius to Fahrenheit.
       double fahrenheit = (celsius * 9 / 5) + 32;

       return fahrenheit;
   }

   public static double FahrenheitToCelsius(string temperatureFahrenheit)
   {
       // Convert argument to double for calculations.
       double fahrenheit = System.Double.Parse(temperatureFahrenheit);

       // Convert Fahrenheit to Celsius.
       double celsius = (fahrenheit - 32) * 5 / 9;

       return celsius;
   }
}

class TestTemperatureConverter
{
   static void Main()
   {
       System.Console.WriteLine("Please select the convertor direction");
       System.Console.WriteLine("1. From Celsius to Fahrenheit.");
       System.Console.WriteLine("2. From Fahrenheit to Celsius.");
       System.Console.Write(":");

       string selection = System.Console.ReadLine();
       double F, C = 0;

       switch (selection)
       {
           case "1":
               System.Console.Write("Please enter the Celsius temperature: ");
               F = TemperatureConverter.CelsiusToFahrenheit(System.Console.ReadLine());
               System.Console.WriteLine("Temperature in Fahrenheit: {0:F2}", F);
               break;

           case "2":
               System.Console.Write("Please enter the Fahrenheit temperature: ");
               C = TemperatureConverter.FahrenheitToCelsius(System.Console.ReadLine());
               System.Console.WriteLine("Temperature in Celsius: {0:F2}", C);
               break;

           default:
               System.Console.WriteLine("Please select a convertor.");
               break;
       }
   }
}

2

98.6

Please select the convertor

1. From Celsius to Fahrenheit.

2. From Fahrenheit to Celsius.

:2

Please enter the Fahrenheit temperature: 98.6

Temperature in Celsius: 37.00

Additional sample output might look as follows:

Please select the convertor

1. From Celsius to Fahrenheit.

2. From Fahrenheit to Celsius.

:1

Please enter the Celsius temperature: 37.00

Temperature in Fahrenheit: 98.60

Using the partial keyword indicates that other parts of the class, struct, or interface can be defined within the namespace. All the parts must use the partial keyword. All of the parts must be available at compile time to form the final type. All the parts must have the same accessibility, such as public, private, and so on.

If any of the parts are declared abstract, then the entire type is considered abstract. If any of the parts are declared sealed, then the entire type is considered sealed. If any of the parts declare a base type, then the entire type inherits that class.

All of the parts that specify a base class must agree, but parts that omit a base class still inherit the base type. Parts can specify different base interfaces, and the final type implements all of the interfaces listed by all of the partial declarations. Any class, struct, or interface members declared in a partial definition are available to all of the other parts. The final type is the combination of all the parts at compile time.

Note
The partial modifier is not available on delegate or enumeration declarations.

Nested types can be partial, even if the type they are nested within is not partial itself. For example:

class Container
{
   partial class Nested
   {
       void Test() { }
   }
   partial class Nested
   {
       void Test2() { }
   }
}

• At compile time, attributes of partial-type definitions are merged. For example, the following declarations:

[System.SerializableAttribute]
partial class Moon { }

[System.ObsoleteAttribute]
partial class Moon { }

are equivalent to:

[System.SerializableAttribute]
[System.ObsoleteAttribute]
class Moon { }

• The following are merged together from all the partial-type definitions:

• XML comments

• interfaces

• generic-type parameter attributes

• class attributes

• members

For example, the following declarations:

partial class Earth : Planet, IRotate { }
partial class Earth : IRevolve { }

are equivalent to:

class Earth : Planet, IRotate, IRevolve { }

There are several rules to follow when working with partial class definitions:

• All partial-type definitions meant to be parts of the same type must be modified with partial. For example, the following class declarations generate an error:

  C#

  
  

  public partial class A { }
  //public class A { }  // Error, must also be marked partial
  

• The partial modifier can only appear immediately before the keywords class, struct, or interface.

• Nested partial types are allowed in partial-type definitions, for example:

  C#

  
  

  partial class ClassWithNestedClass
  {
     partial class NestedClass { }
  }
  
  partial class ClassWithNestedClass
  {
     partial class NestedClass { }
  }
  

• All partial-type definitions meant to be parts of the same type must be defined in the same assembly and the same module (.exe or .dll file). Partial definitions cannot span multiple modules.

• The class name and generic-type parameters must match on all partial-type definitions. Generic types can be partial. Each partial declaration must use the same parameter names in the same order.

• The following keywords on a partial-type definition are optional, but if present on one partial-type definition, cannot conflict with the keywords specified on another partial definition for the same type:

  • public

  • private

  • protected

  • internal

  • abstract

  • sealed

  • base class

  • new modifier (nested parts)

  • generic constraints (For more information, see Constraints on Type Parameters (C# Programming Guide).)

CoOrds: 10,15