在Jesse Liberty的《Programming C#》（第142页）中，他提供了一个示例，在该示例中，他将对象转换为接口。
interface IStorable
{
...
}
public class Document : IStorable
{
...
}
...
IStorable isDoc = (IStorable) doc;
...
如果对象的类已经实现了该接口，那么这样做的目的是什么？
编辑1: 为了澄清，我对于强制类型转换的原因很感兴趣，而不是实现接口的原因。另外，这本书是他2001年的第一版（基于C#1），所以这个示例可能对于后续版本的C#来说不相关。
编辑2: 我添加了一些代码上下文。
只有一种情况需要进行类型转换：当“doc”是实现了“IStorable”的对象的基本类型时。让我解释一下：
public class DocBase
{
public virtual void DoSomething()
{
}
}
public class Document : DocBase, IStorable
{
public override void DoSomething()
{
// Some implementation
base.DoSomething();
}
#region IStorable Members
public void Store()
{
// Implement this one aswell..
throw new NotImplementedException();
}
#endregion
}
public class Program
{
static void Main()
{
DocBase doc = new Document();
// Now you will need a cast to reach IStorable members
IStorable storable = (IStorable)doc;
}
}
public interface IStorable
{
void Store();
}
IStorable时，使用转换运算符向IStorable变量赋值，而不是使用EDIT2的方法，这个问题没有得到解释。 - binkidoc.Store()的，因为doc被声明为DocBase，而该类型并未实现IStorable接口。 - Basilpublic void IStorable.StoreThis(...)），那么强制转换是实际访问接口成员最简单的方法。我不确定书中给出的示例是在什么情况下使用的。但是，您通常可以将对象强制转换为接口以实现多重继承。我已经给出了以下示例。
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();
}
这将显示
IBar 实现
IFoo 实现
没有更多的上下文很难确定。如果变量doc被声明为实现该接口的类型，则强制转换是冗余的。
你正在阅读哪个版本的书？如果是《Programming C# 3.0》，我晚上回家后会看一下。
编辑：就目前为止，我们已经看到了三个潜在的问题：
doc是适当的编译时类型，则不必这样做）doc 对象可能是一种实现了 IStorable 成员的类型，它们没有被添加到类的主要接口中（即它们只能通过接口调用）。
实际上，“强制类型转换”（使用 (T) 语法）没有任何意义，因为 C# 自动处理向上转型（转换为父类型），与 F# 不同。
这里有很多好的答案，但我不认为它们真正回答了为什么你实际上想要使用可能最严格的接口。
原因并不涉及您的初始编码，而是涉及下次访问或重构代码时--或者是其他人进行代码编辑时--会发生什么。
假设您想要一个按钮并将其放置在屏幕上。您通过传递或从另一个函数中获取该按钮，如下所示：
Button x=otherObject.getVisibleThingy();
frame.add(x);
您知道VisibleThingy是一个按钮，它返回一个按钮，所以一切都很好（不需要强制转换）。
现在，假设您将VisibleThingy重构为返回一个切换按钮。您现在必须重构您的方法，因为您对实现了解得太多了。
由于您只需要Component中的方法（button和Toggle的父级，这可以是接口 - 对于我们的目的来说几乎相同），如果您最初编写第一行代码如下：
Component x=(Component)otherObject.getVisibleThingy();
你不需要重构任何东西，它只是起作用了。
这是一个非常简单的情况，但它也可以更加复杂。
所以我想总结一下，接口是查看对象的特定方法--就像通过过滤器查看它...你只能看到一些部分。如果你能够限制你的视角，对象可以在你特定的视角下“变形”，而不会影响你当前的世界--这是抽象的一个非常强大的技巧。
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);
}
}
}
请注意，我不需要在DoSomething方法中编写任何代码，也不需要知道所有工作对象都是具体对象类型。我唯一知道的是，我正在处理至少是Control类实例的对象。然后，我可以使用接口查找它们可能具有的其他内容。ID：1
文本：我是一个文本控件
ID：2
文本：我是另一个文本控件
ID：3
文本：只是因为