如果 C# 有 that 关键字会怎样

Posted on 2004-09-25 21:44 Flier Lu 阅读(2314) 评论(5) 编辑收藏举报

http://www.blogcn.com/User8/flier_lu/index.html?id=3968327

    briankel 的 blog 上有个有趣的讨论，《C# 'that' keyword》。讨论如果在 C# 中增加 that 关键字，将会表示什么意思 :P

    简单分析可以发现，that 关键字应该是与 this 关键字对应或者至少平级的，因此在语法和语义上应该尽量保持同一性。也就是说加入的 that 关键字应该也会用于表示某种隐式的对象引用，与之类似的还有 base 关键字，都是隶属于 Access Keywords。

    因此 Matthew W. Jackson 和 anony 等人的意见是将此关键字用于 with 语句的隐式上下文引用，如

public int ThatExample<T>(T x, T y)
{
  with(System.Collections.Comparer<int>.Default)
  {
    if(that.Compare(x, y) > 0)
      return that.GetHashCode(x)；
    else
      return that.GetHashCode(y)；
  }
}

这样的好处是可以明确获得在 with 范围内的隐式对象引用，而且语义上来说跟 this 的隐式语义很类似。同时能够提供在 with 范围内，将隐式引用对象作为参数传递给其他方法的能力，这是 pascal 等 with 语法中所不具备的能力，如

with new Foo()
{
  WhateverProperty = "property";
  IntProperty = 1;

  //call Whatever with the Foo we just made
  //before calling entering the block
  Bar.Whatever(that)；
}

而除了对象自身作用域内访问隐式对象这一特性外，this 关键字实际上还有一个隐式参数传入的特性。也就是说在对象方法调用时将对象本身的引用，通过 this 隐式传入到方法中。与这一特性对应的当数 pascal 中的 result 关键字，显式访问函数的返回值。因此 Matthew W. Jackson 建议通过如下方式使用 that 关键字：

public int ThatExample<T>(T x, T, y)
{
  IComparer<T> comparer = Comparer<T>.Default;

  if(comparer.Compare(x, y) > 0)
    that = comparer.GetHashCode(x)；
  else
    that = comparer.GetHashCode(y)；
}

    这样可以让使用者无需手工构造返回值实例，而由编译器承担这个薄记工作。同时这也是一种很好的 compiler hint，在进行 JIT 优化时能够避免不必要的临时变量使用，如果 C++ 这种值语义为主的系统能够增加这一特性就好了，呵呵。

    此外还有一些建议是将之用于与 this 相对的用途，如在操作符重载中指向双目操作符的另一个对象，避免使用 rhs 这样的变量，而由编译器隐式处理，减少薄记工作。
    或者用于一些较为特殊的用途，如在 clone 函数里面指向 clone 操作的目标对象

class X : ICloneable
{
  private SomeOtherDeepCopyableClass data;

  [UsesCopy]
  public override object Clone()
  {
    that.data=(SomeOtherDeepCopyableClass)data.Clone()；
  }
}

或者在 foreach 中作为限定符进行过滤，类似 C# 2.0 中对泛型支持时的限定

foreach (MyType a that IBlarg in myCollection)
{
// 只获得实现了 IBlarg 接口的 MyType 类型
}

不过这些用法感觉实在是有些大材小用了，呵呵

有趣的是 Matthew W. Jackson 在第三种意见里面，提出通过 that 关键字提供对 double virutal dispatch 的支持。这里的 double virutal dispatch 是一种在 C++ 中模拟 Multi-Methods 语义的模式，因为 C++ 不像 CLOS 等语言直接提供此类支持。例如我们在 C++ 中定义 Shapre, Rectangle 和 Circle 三种类型，分别对自己与其他类型图元的重叠操作提供支持：

class Shape {

virtual bool intersect(const Shape* s)；

};

class Rectangle : public Shape {

virtual bool intersect(const Shape* s)；
virtual bool intersect(const Circle* s)；

};

class Circle : public Shape {

virtual bool intersect(const Shape* s)；
virtual bool intersect(const Rectangle* s)；

};

我们希望两个 Shape 子对象在进行重叠操作时，能够根据两者的类型调用合适的处理方法，如

Shape* circle = new Circle()； // upcast to Shape
Shape* rectangle = new Rectangle()； // upcast to Shape
circle->intersect(rectangle)； // Calls Circle::intersect(Shape*)

这里的 intersect 方法调用，因为参数被静态绑定到 Shape 类型上，因此无法调用我们希望的 Circle::intersect(Rectangle *)，而是调用 Circle 类型重载 Shape 类型的 vtable 中 Shape::intersect(Shape *) 方法的 Circle::intersect(Shape*)。也就是说，只有一次通过 Circle 对象 vtable 进行的 virtual dispatch，是无法满足我们希望的对操作源对象和目标对象 double virtual dispatch 的。因为 C++/C#/Java 这些所谓静态类型语言都无法提供这种语义的直接支持，我们不得不通过 double virtual dispatch 模式来模拟。如在 C# 中定义如下类型：

interface Shape
{
  void intersect(Shape shape)；
  void intersect(Circle circle)；
  void intersect(Rectangle circle)；
}

class Circle : Shape
{
  public void intersect(Shape shape)
  {
    Console.Out.WriteLine("Circle::intersect(Shape)"[img]/images/wink.gif[/img]；

    shape.intersect(this)；
  }

  public void intersect(Circle circle)
  {
    Console.Out.WriteLine("Circle::intersect(Circle)"[img]/images/wink.gif[/img]；
  }

  public void intersect(Rectangle circle)
  {
    Console.Out.WriteLine("Circle::intersect(Rect)"[img]/images/wink.gif[/img]；
  }
}

class Rectangle : Shape
{
  public void intersect(Shape shape)
  {
    Console.Out.WriteLine("Rect::intersect(Shape)"[img]/images/wink.gif[/img]；

    shape.intersect(this)；
  }

  public void intersect(Circle circle)
  {
    Console.Out.WriteLine("Rect::intersect(Circle)"[img]/images/wink.gif[/img]；
  }

  public void intersect(Rectangle circle)
  {
    Console.Out.WriteLine("Rect::intersect(Rect)"[img]/images/wink.gif[/img]；
  }
}

class EntryPoint
{
[STAThread]
static void Main(string[] args)
{
Shape circle = new Circle()；
    Shape rect = new Rectangle()；

    circle.intersect(rect)；
}
}

Shape 类型中预先就定义好可能存在的分发目标，然后通过在 Shape::intersect 方法的重载函数中，调用 shape.intersect(this)；进行二次分发。因为在此时，this 指向的类型是源操作对象的真实类型。也就是说，先通过源对象的 vtable 进行一次 virtual dispatch 之后，再在源对象的 Shape::Intersect 方法重载实现中，调用目标对象的 intersect 方法，通过目标对象 vtable 进行第二次 virtual dispatch，进而通过 double virtual dispatch 模式完成我们期望的 Multi-Methods 支持。允许结果如下

以下为引用：

Circle::intersect(Shape)
Rect::intersect(Circle)

但这样一来引入了几个新的问题。首先，作为基础的抽象 Shape 接口必须与实现其接口的子类型进行绑定，每次添加新类型都必须修改几乎所有类型；其次，每个 Shape 接口的子类型都必须重载其 Shape::intersect(Shape shape) 方法的实现，来完成二次分发，虽然其实现代码语法完全相同；最后，每个新增类型都会要求为所有已有类型添加新的方法，最后方法的数量会根据类型的多少呈指数上升，并且无法收敛。
因此如果希望在 C# 中真正大量使用这种 double virtual dispatch 的语法来模拟不太可能被直接支持的 Multi-Methods 语义，必要的编译器一级的支持是必不可少的。例如通过 that 关键字，指向 this 关键字指向的同一对象，只不过其类型绑定到对象的实际类型上。这样一来就可以将每个子类型中的二次分发函数 Shape::intersect(Shape shape) 的重载消除，只保留 Shape 类型中的唯一实现，如

  abstract class Shape
  {
    virtual public void intersect(Shape shape)
    {
      shape.intersect(that)；
    }
  }

  class Circle : Shape
  {
    override public void intersect(Circle circle)
    {
      Console.Out.WriteLine("Circle::intersect(Circle)"[img]/images/wink.gif[/img]；
    }

    override public void intersect(Rectangle circle)
    {
      Console.Out.WriteLine("Circle::intersect(Rect)"[img]/images/wink.gif[/img]；
    }
  }

  classs Rectangle : Shape
  {
    //
  }

这里的 shape.intersect(that)；语句的语义，实际上等同于

MethodInfo method = shape.GetType().GetMethod("intersect", new Type[] { this.GetType() })；
method.Invoke(shape, new object[] { this })；

而且也无需在根对象上绑定所有的子类型，由执行时根据传入对象的类型完成自动分派。为了处理子对象可能没有专用处理函数的问题，还可以修改其语义为：

Type type = shape.GetType()；
MethodInfo method = null;

while(type != null && method == null)
{
  method = type.GetMethod("intersect", new Type[] { this.GetType() })；

  type = type.BaseType;
}

if(method != null)
  method.Invoke(shape, new object[] { this })；

这样一来子类型就可以任意定义对其他类型的处理方法，如 Circle::intersect(Rectangle)；如果不像定义，或者不知道另外一个子类型的存在，可以通过一个 Circle::intersect(Shape) 安全处理所有例外情况。例如下面代码中，Rectangle 类型没有专门针对 Ellipse 类型的处理函数，但有针对 Ellipse 类型父类 Circle 的处理函数，故而调用结果是 Rect::intersect(Circle)。

abstract class Shape
{
  virtual public void intersect(Shape shape)
  {
    //shape.intersect(that)；

    Type type = shape.GetType()；
    MethodInfo method = null;

    while(type != null && method == null)
    {
      method = type.GetMethod("intersect", new Type[] { this.GetType() })；

      type = type.BaseType;
    }

    if(method != null)
      method.Invoke(shape, new object[] { this })；
  }
}

class Circle : Shape
{
  virtual public void intersect(Circle circle)
  {
    Console.Out.WriteLine("Circle::intersect(Circle)"[img]/images/wink.gif[/img]；
  }

  virtual public void intersect(Rectangle circle)
  {
    Console.Out.WriteLine("Circle::intersect(Rect)"[img]/images/wink.gif[/img]；
  }

  virtual public void intersect(Ellipse ellipse)
  {
    Console.Out.WriteLine("Circle::intersect(Ellipse)"[img]/images/wink.gif[/img]；
  }
}

class Ellipse : Circle
{
  override public void intersect(Circle circle)
  {
    Console.Out.WriteLine("Ellipse::intersect(Circle)"[img]/images/wink.gif[/img]；
  }

  override public void intersect(Rectangle circle)
  {
    Console.Out.WriteLine("Ellipse::intersect(Rect)"[img]/images/wink.gif[/img]；
  }

  override public void intersect(Ellipse ellipse)
  {
    Console.Out.WriteLine("Ellipse::intersect(Ellipse)"[img]/images/wink.gif[/img]；
  }
}

class Rectangle : Shape
{
  public void intersect(Circle circle)
  {
    Console.Out.WriteLine("Rect::intersect(Circle)"[img]/images/wink.gif[/img]；
  }

  public void intersect(Rectangle circle)
  {
    Console.Out.WriteLine("Rect::intersect(Rect)"[img]/images/wink.gif[/img]；
  }
}

class EntryPoint
{
[STAThread]
static void Main(string[] args)
{
Shape circle = new Ellipse()；
    Shape rect = new Rectangle()；

    circle.intersect(rect)；
}
}