Pourquoi exprimées à une interface?

Parce que vous voulez vous limiter aux seules méthodes fournies par l'interface. Si vous utilisez la classe, vous courez le risque de l'appel d'une méthode (par inadvertance) qui ne fait pas partie de l'interface.

Je ne suis pas sûr, en vertu de ce contexte, l'exemple a été donné dans le livre. Mais, en général, vous pouvez saisir effectuer un cast d'un objet à l'interface pour obtenir l'héritage multiple. J'ai donné l'exemple ci-dessous.

public interface IFoo
{
     void Display();
}
public interface IBar
{
     void Display();
}

public class MyClass : IFoo, IBar
{
    void IBar.Display()
    {
        Console.WriteLine("IBar implementation");
    }
    void IFoo.Display()
    {
        Console.WriteLine("IFoo implementation");
    }
}

public static void Main()
{
    MyClass c = new MyClass();
    IBar b = c as IBar;
    IFoo f = c as IFoo;
    b.Display();
    f.Display();
    Console.ReadLine();
}

Ce serait d'afficher

IBar de la mise en œuvre

IFoo mise en œuvre

La doc objet peut être d'un type qui implémente les membres de IStorable explicitement, pas de les ajouter à la les classes de primaire de l'interface (c'est à dire, ils ne peuvent être appelés via l'interface).

Fait "casting" (à l'aide de l' (T) de la syntaxe) n'a aucun sens puisque C# poignées upcasts (en fonte de type parent) automatiquement (à la différence de F# par exemple).

La meilleure raison pourquoi vous mettrait à des interfaces serait si vous écrivez du code contre des objets et vous ne savez pas quel type de béton qu'ils sont et vous ne voulez pas.

Si vous savez que vous pouvez venir à travers un objet qui implémente une interface spécifique, vous pouvez obtenir les valeurs de l'objet sans avoir à connaître la classe de béton que cet objet est. Aussi, si vous savez qu'un objet implémente une interface donnée, cette interface peut définir des méthodes que vous pouvez exécuter à prendre certaines mesures sur l'objet.

Voici un exemple simple:

public interface IText
{
string Text { get; }
}
public interface ISuperDooper
{
string WhyAmISuperDooper { get; }
}
public class Control
{
public int ID { get; set; }
}
public class TextControl : Control, IText
{
public string Text { get; set; }
}
public class AnotherTextControl : Control, IText
{
public string Text { get; set; }
}
public class SuperDooperControl : Control, ISuperDooper
{
public string WhyAmISuperDooper { get; set; }
}
public class TestProgram
{
static void Main(string[] args)
{
List<Control> controls = new List<Control>
{
new TextControl
{
ID = 1, 
Text = "I'm a text control"
},
new AnotherTextControl
{
ID = 2, 
Text = "I'm another text control"
},
new SuperDooperControl
{
ID = 3, 
WhyAmISuperDooper = "Just Because"
}
};
DoSomething(controls);
}
static void DoSomething(List<Control> controls)
{
foreach(Control control in controls)
{
//write out the ID of the control
Console.WriteLine("ID: {0}", control.ID);
//if this control is a Text control, get the text value from it.
if (control is IText)
Console.WriteLine("Text: {0}", ((IText)control).Text);
//if this control is a SuperDooperControl control, get why
if (control is ISuperDooper)
Console.WriteLine("Text: {0}", 
((ISuperDooper)control).WhyAmISuperDooper);
}
}
}

l'exécution de ce petit programme vous donnera le résultat suivant:

ID: 1

Texte: je suis d'un contrôle de texte

ID: 2

Texte: je suis un autre texte de contrôle

ID: 3

Texte: Juste Parce Que

Notez que je n'ai pas besoin d'écrire du code dans la méthode DoSomething qui m'a obligé de savoir quelque chose au sujet de tous les objets que je travaillais sur le béton des types d'objet. La seule chose que je sais c'est que je suis en train de travailler sur des objets qui sont au moins une instance de la classe de Contrôle. Je peux alors utiliser l'interface pour trouver de quoi d'autre ils pourraient avoir.

Il y a un million de raisons différentes qui vous permettrait de prendre cette approche avec des interfaces sur vos objets, mais cela vous donne un lâche moyen d'accéder à vos objets sans avoir à connaître exactement ce que c'est.

De penser à toutes les cartes de crédit dans le monde, chaque entreprise fait de leur propre, l'interface est la même, de sorte que chaque lecteur de carte peut avoir une carte glissée dans ce qui suit la norme. Similaire à l'utilisation d'interfaces.

Le point est, de l'objet (où avez-vous l'obtenir?) mai pas implémenter l'interface, dans ce cas, une exception est levée, qui peuvent être capturées et traitées. Bien sûr, vous pouvez utiliser le "est" de l'opérateur de vérifier, et le "comme" opérateur de cast au lieu de la C-style fonte.