通过其接口访问对象

这真的取决于。如果变量的类型为“ interface”，则在这种情况下，只能通过接口类型访问对象。

让我们考虑一个示例-假设我有一个如下定义的接口-

interface IMyInterface
{
   string B();
}

并且如果我使用类“ MyClass”实现此接口，如下所示-

public class MyClass:IMyInterface
   {
      public string B()
      { 
           return "In Class";
      }
   }

   public class MyAnotherClass:IMyInterface
       {
          public string B()
          { 
               return "In Another Class";
          }
       }

然后使用如下所示的接口创建该类的实例

   IMyInterface myinst = new MyClass();

那么在上述情况下，我只能使用包含对MyClass类型的引用的变量myinst来访问方法B（）。

进一步讲，假设我有一个采用IMyInterface类型参数的方法，如下所示-

    public class UseOfInterface{
    public void InterfaceUse(IMyInterface myPara)
    {
      myPara.B();
    }
}

我将这个方法称为如下所示-

        IMyInterface myInst = new MyClass();
        IMyInterface myAnotherInst = new MyAnotherClass();

        UseOfInterface interfaceUse = new UseOfInterface();
        interfaceUse.InterfaceUse(myInst); // returns "In Class"
        interfaceUse.InterfaceUse(myAnotherInst); // returns "In Another Class"

然后，如上所示，在运行时决定使用Interface变量调用哪种方法。

但是，如果我创建了一个MyClass类型的变量，该变量本身将包含MyClass类型的引用，如下所示-

   MyClass myinst = new MyClass();

然后可以使用MyClass实例访问方法B（）。因此，这取决于您要处理的场景类型。

编辑：为什么使用接口？

使用接口的主要原因是，除了C＃中的多继承支持之外，它还为正在为其实现的类提供合同。让我们看一个示例，其中提供合同可能会有所帮助。

假设您要公开公开的程序集中有一个类“ Car”，则该类的定义如下所示

namespace CarNameSpace
{
   public class Car()
   {
      public void Drive(IDriver driver)
      {
         if(driver.Age > 18)
         {
            driver.Drive();
         }
      }
   }
}

如上所示，实现IDriver接口的任何人都可以驾驶汽车，如下所述，

interface IDriver
{
   string Age{get; set;}
   string Name {get set;}
   string Drive()
}

反过来，我要开车，我将把IDriver接口暴露给外界，因此实现我的接口的任何人都可以调用Car的Drive方法，无论他如何驾驶汽车，如下所示

public class PerfectDriver:IDriver
{
   public PerfectDriver()
   {
     Name = "Vikram";
     Age = 30;
   }
   public int Age{get; set;}
   public string Name {get; set;}
   public string Drive()
   {
      return "Drive's perfectly";
   }
}

的汽车类可以用作如下所示

  PerfectDriver perf = new PerfectDriver
  Car myCar = Car();  
  myCar.Driver(perf);