轉換Java泛型到C＃泛型

Question

這是針對通用bubbleSorter我的Java代碼：

public class BubbleSorter<E extends Comparable<E>> { 
    E[] a; 
    void swap(int i, int j) { 
     E temp; 
     temp=a[i]; 
     a[i]=a[j]; 
     a[j]=temp; 
    } 
    void bubbleSort(E[] a) { 
     this.a=a; 
     for (int i=0 ;i<a.length;i++) { 
      for (int j=0;j<a.length;j++) { 
       if (a[i].compareTo(a[j]) > 0) swap(i,j); 
      } 
     } 
    } 

} 

public interface Comparable<E> { 
    public int compareTo(E e); 
} 

，這裏是使用它的一個例子：

public class Test { 
    public static void main (String arg[]) { 
     Rational[] a = new Rational[3]; 
     a[0]=Rational.rationalFactory(9,2); 
     a[1]=Rational.rationalFactory(1,3); 
     a[2]=Rational.rationalFactory(10,11); 
     Complex[] b = new Complex[3]; 
     b[0]=new Complex(7,5); 
     b[1]=new Complex(3,4); 
     b[2]=new Complex(8,9); 
     BubbleSorter<Rational> br=new BubbleSorter<Rational>(); 
     BubbleSorter<Complex> bi=new BubbleSorter<Complex>(); 
     br.bubbleSort(a); 
     bi.bubbleSort(b); 
     for (int i=0 ; i < 3 ; i++) { 
      System.out.print(a[i] + " "); 
     } 
     System.out.println(); 
     for (int i=0 ; i < 3 ; i++) { 
      System.out.print(b[i] + " "); 
     } 
    } 
} 

public class Rational implements Comparable<Rational> { 
    int mone,mehane; 
    private Rational(int n,int m) { 
     mone=n; 
     mehane=m; 
    } 
    static public Rational rationalFactory(int n,int m) { 
     if (n==0) return null; 
     return new Rational(n,m); 
    } 
    public String toString() { 
     return mone + "/" + mehane; 
    } 
    public int compareTo(Rational r) { 
     return (r.mehane*mone - r.mone*mehane); 
    } 
} 
public class Complex implements Comparable<Complex> { 
     int real,img; 
     public Complex(int r,int i) { 
      real=r; 
      img=i; 
     } 
     public String toString() { 
      return real + "+" + img + "i"; 
     } 
     public int compareTo(Complex r) { 
      double x=(getLength() - r.getLength()); 
      if (x>0) return 1; 
      if (x==0) return 0; 
      return -1; 
     } 
     public double getLength() { 
      return Math.sqrt(real*real+img*img); 
     } 
} 

當我試圖將我的Java代碼到C＃，我卡住試圖強制泛型類型擴展比較自<電子郵件：比較>不起作用。我如何克服這一點？

這是我的嘗試：

abstract class Comparable<E> { 

    static bool operator ==(Comparable<E> e1, Comparable<E> e2); 
    static bool operator !=(Comparable<E> e1, Comparable<E> e2) { 
     return !(e1 == e2); 
    } 
    static bool operator >(Comparable<E> e1, Comparable<E> e2); 
    static bool operator >=(Comparable<E> e1, Comparable<E> e2) { 
     if (e1 > e2) return true; 
     if (e1 == e2) return true; 
     return false; 
    } 
    static bool operator <=(Comparable<E> e1, Comparable<E> e2) { 
     return !(e1 > e2); 
    } 
    static bool operator <(Comparable<E> e1, Comparable<E> e2) { 
     return !(e1 >= e2); 
    } 
} 

public class BubbleSorter<E : Comparable<E>> { 
     E[] a; 
     void swap(int i, int j) { 
      E temp; 
      temp=a[i]; 
      a[i]=a[j]; 
      a[j]=temp; 
     } 
     void bubbleSort(E[] a) { 
      this.a=a; 
      for (int i=0 ;i<a.length;i++) { 
       for (int j=0;j<a.length;j++) { 
        if (a[i]>a[j]) swap(i,j); 
       } 
      } 
     } 

} 

Answer 1

您應該使用內置IComparable<T>界面，然後聲明類爲

public class BubbleSorter<T> where T : IComparable<T> { ... } 

的where關鍵字定義了一個「約束」通用參數T。編譯器將通過確保對泛型類的任何實例化來強制執行此約束，類型實參實現接口IComparable<T>。

Answer 2

這是C＃語法：

public class BubbleSorter<E> where E : Comparable<E> 

Answer 3

在C＃中使用泛型約束的關鍵詞是where。

因此，首先聲明你的通用類型的簽名：

public class BubbleSorter<E> 

然後定義通用約束：

where E : IComparable<E> 

編碼約定的一個字：在C＃，習慣上請撥打單個通用參數T（類似類型）而不是E（如元素）。這是在所有的框架集合類使用的模式，所以你可能要調整你的類型名稱：

public class BubbleSorter<T> 
    where T : IComparable<T> 
{ 
    // ... 
} 

冒號（:），你可以指定一個逗號分隔的接口列表以及可能的類名稱的背後。編譯器知道哪個是哪個，所以你不必明確指定你想實現（接口）還是繼承（從類）。

Answer 4

在C＃中，實現類型可比性的一種常見慣用方法是使其來自IComparable<T>。如果你不能改變類型來實現IComparable，那麼你可以實現一個輔助類來實現IComparer<E>。

public class BubbleSorter<E> 
{ 
    static void Swap(E[] a, int i, int j) 
    { 
     E temp; 
     temp=a[i]; 
     a[i]=a[j]; 
     a[j]=temp; 
    } 

    public void BubbleSort(E[] a, IComparer<E> comparer) 
    { 
     for (int i=0 ;i<a.length;i++) { 
      for (int j=0;j<a.length;j++) { 
       if (comparer.Compare(a[i],a[j]) > 0) swap(a,i,j); 
      } 
     } 
    } 
}