Access through an interface allows you to treat the interface polymorphically...

Odnośniki

Smutek to uczucie, jak gdyby się tonęło, jak gdyby grzebano cię w ziemi.
600Programowanie w Access 2000Ogólne informacje dotycz¹ce poszczególnych sekcji raportu znajduj¹ siê we i wbudowanej pomocy w aplikacji Microsoft...
and constructors, 251; behavior of polymorphic 101; ternary, 104; unary, 96, 101 methods inside constructors, 256 operator overloading: in C++,...
Opaque copy (directly or through your agents or retailers) of that edition to the public...
access-list 101 deny TCP 172...
Columns 177 through 1840...
Interfejsy użytkownika...
Dyrektywa NAME określa nazwę, która będzie użyta dla oznaczenia modułu obiektowego wygenerowanego na podstawie bieżącego programu...
Sprawa projektowania â inicjalizacja obiektu...
Melanię to wszystko razem więcej śmieszyło, niż irytowało, Felicja była wściekła, miała własne poglądy na nakrycie stołu i nie przywykła, żeby nią ktoś...
- Katerine Alruddin uciekła ubiegłej nocy - niemalże wypluła z siebie Tialin, a Verin nie potrafiła powstrzymać głośnego westchnienia...

Smutek to uczucie, jak gdyby się tonęło, jak gdyby grzebano cię w ziemi.

In other words, you can have two or more classes implement the interface, and then by accessing these classes only through the interface, you can ignore their real runtime type and treat them interchangeably. See Chapter 5 for more information about polymorphism.
8.2.1 Casting to an Interface
In many cases, you don't know in advance that an object supports a given interface. For example, suppose you have a collection of Documents, some of which can be stored and others of which cannot. Suppose you add a second interface, ICompressible, for those objects that can compress themselves for quick transmission via email:
interface ICompressible
{
void Compress( );
void Decompress( );
}
Given a Document type, you might not know whether it supports IStorable or Icompressible or both. You can just cast to the interfaces:

page 128
Programming C#
Document doc = new Document("Test Document");

IStorable isDoc = (IStorable) doc;
isDoc.Read( );

ICompressible icDoc = (ICompressible) doc;
icDoc.Compress( );
If it turns out that Document implements only the IStorable interface:
public class Document : IStorable
the cast to ICompressible would still compile because ICompressible is a valid interface.
However, because of the illegal cast, when the program is run an exception will be thrown: An exception of type System.InvalidCastException was thrown.
Exceptions are covered in detail in Chapter 11.
8.2.2 The is Operator
You would like to be able to ask the object if it supports the interface, in order to then invoke the appropriate methods. In C# there are two ways to accomplish this. The first method is to use the is operator.
The form of the is operator is:
expression is type
The is operator evaluates true if the expression (which must be a reference type) can be safely cast to type without throwing an exception. Example 8-3 illustrates the use of the is operator to test whether a Document implements the IStorable and ICompressible interfaces.
Example 8-3. Using the is operator
using System;

interface IStorable
{
void Read( );
void Write(object obj);
int Status { get; set; }

}

// here's the new interface
interface ICompressible
{
void Compress( );
void Decompress( );
}

// Document implements IStorable
public class Document : IStorable
{
public Document(string s)
{
Console.WriteLine(
"Creating document with: {0}", s);

page 129
Programming C#

}

// IStorable.Read
public void Read( )
{
Console.WriteLine(
"Implementing the Read Method for IStorable");
}

// IStorable.Write
public void Write(object o)
{
Console.WriteLine(
"Implementing the Write Method for IStorable");
}

// IStorable.Status
public int Status
{
get
{
return status;
}

set
{
status = value;
}
}

private int status = 0;
}

public class Tester
{

static void Main( )
{
Document doc = new Document("Test Document");

// only cast if it is safe
if (doc is IStorable)
{
IStorable isDoc = (IStorable) doc;
isDoc.Read( );
}

// this test will fail
if (doc is ICompressible)
{
ICompressible icDoc = (ICompressible) doc;
icDoc.Compress( );
}
}
}
Example 8-3 is identical to Example 8-2 except that it adds the declaration for the ICompressible interface. Main( ) now determines whether the cast is legal (sometimes referred to as safe) by evaluating the following if clause:
if (doc is IStorable)

page 130
Programming C#
This is clean and nearly self-documenting. The if statement tells you that the cast will happen only if the object is of the right interface type.
Unfortunately, this use of the is operator turns out to be inefficient. To understand why, you need to dip into the MSIL code that this generates. Here is a small excerpt (note that the line numbers are in hexadecimal notation):

IL_0023: isinst ICompressible
IL_0028: brfalse.s IL_0039
IL_002a: ldloc.0
IL_002b: castclass ICompressible
IL_0030: stloc.2
IL_0031: ldloc.2
IL_0032: callvirt instance void ICompressible::Compress( )
IL_0037: br.s IL_0043
IL_0039: ldstr "Compressible not supported"
What is most important here is the test for ICompressible on line 23. The keyword isinst is the MSIL code for the is operator. It tests to see if the object (doc) is in fact of the right type. Having passed this test we continue on to line 2b, in which castclass is called. Unfortunately, castclass also tests the type of the object. In effect, the test is done twice. A more efficient solution is to use the as operator.
8.2.3 The as Operator
The as operator combines the is and cast operations by testing first to see whether a cast is valid (i.e., whether an is test would return true) and then completing the cast when it is. If the cast is not valid (i.e., if an is test would return false), the as operator returns null.
The keyword null represents a null reference, one that does not refer to any
object.

Using the as operator eliminates the need to handle cast exceptions. At the same time you avoid the overhead of checking the cast twice. For these reasons, it is optimal to cast interfaces using as.
The form of the as operator is:
expression as type
The following code adapts the test code from Example 8-3, using the as operator and testing for null:
static void Main( )
{
Document doc = new Document("Test Document");
IStorable isDoc = doc as IStorable;
if (isDoc != null)
isDoc.Read( );
else
Console.WriteLine("IStorable not supported");

ICompressible icDoc = doc as ICompressible;