11

共分散とは、(大まかに) 「単純な」型の継承を、それらを使用する複合型にミラーリングする機能です。たとえば、 のインスタンスは常に のインスタンスとして
扱うことができます。ComplexType が共変の場合、Aは として扱われます。CatAnimalComplexType<Cat>ComplexType<Animal>

私は疑問に思っています:共分散の「タイプ」とは何ですか?また、それらはC#とどのように関係していますか(サポートされていますか?)
コード例は役に立ちます.

たとえば、戻り値の型 covarianceは Java でサポートされていますが、C# ではサポートされていません。

関数型プログラミングのチョップを持っている人も参加できることを願っています!

4

3 に答える 3

10

これが私が考えることができるものです：

アップデート

Eric Lippert によって指摘された (そして書かれた) 建設的なコメントと大量の記事を読んだ後、私は答えを改善しました。

  • 配列共分散の壊れやすさを更新
  • 「純粋な」デリゲート分散を追加
  • BCL からの例をさらに追加
  • 概念を詳細に説明する記事へのリンクを追加しました。
  • 高階関数パラメーターの共分散に関するまったく新しいセクションを追加しました。

型の共分散を返す:

Java (>= 5)[1]と C++[2]で利用できますが、C# ではサポートされていません (Eric Lippert がサポートしていない理由とそれについてできることを説明しています):

class B {
    B Clone();
}

class D: B {
    D Clone();
}

インターフェイスの共分散[3]- C# でサポート

BCL では、ジェネリックIEnumerableインターフェイスが共変であると定義されています。

IEnumerable<out T> {...}

したがって、次の例は有効です。

class Animal {}
class Cat : Animal {}

IEnumerable<Cat> cats = ...
IEnumerable<Animal> animals = cats;

は定義上「読み取り専用」であることに注意してくださいIEnumerable。要素を追加することはできません。これを、たとえば以下を使用して変更できる
定義と比較してください。IList<T>.Add()

public interface IEnumerable<out T> : ...  //covariant - notice the 'out' keyword
public interface IList<T> : ...            //invariant

メソッド グループによる共分散の委譲[4]- C# でサポート

class Animal {}
class Cat : Animal {}

class Prog {
    public delegate Animal AnimalHandler();

    public static Animal GetAnimal(){...}
    public static Cat GetCat(){...}

    AnimalHandler animalHandler = GetAnimal;
    AnimalHandler catHandler = GetCat;        //covariance

}

「純粋な」デリゲート共分散[5 - pre-variance-release article]- C# でサポート

パラメーターをとらず、何かを返すデリゲートの BCL 定義は共変です。

public delegate TResult Func<out TResult>()

これにより、次のことが可能になります。

Func<Cat> getCat = () => new Cat();
Func<Animal> getAnimal = getCat;

配列の共分散- C# でサポートされていますが、壊れた形でサポートされています[6] [7]

string[] strArray = new[] {"aa", "bb"};

object[] objArray = strArray;    //covariance: so far, so good
//objArray really is an "alias" for strArray (or a pointer, if you wish)


//i can haz cat?
object cat == new Cat();         //a real cat would object to being... objectified.

//now assign it
objArray[1] = cat                //crash, boom, bang
                                 //throws ArrayTypeMismatchException

そして最後に、高階関数用の、驚くべき、やや頭を悩ませる
Delegate パラメーターの共分散(そうです、共分散です) です。[8]

1 つのパラメーターを取り、何も返さないデリゲートの BCL 定義は反変です。

public delegate void Action<in T>(T obj)

我慢してください。サーカスの動物調教師を定義しましょう - 彼は動物を調教する方法を教えられます(その動物で動作する を彼に与えることによってAction)。

delegate void Trainer<out T>(Action<T> trainingAction);

トレーナーの定義があります。トレーナーを取得して、彼を働かせましょう。

Trainer<Cat> catTrainer = (catAction) => catAction(new Cat());

Trainer<Animal> animalTrainer = catTrainer;  
// covariant: Animal > Cat => Trainer<Animal> > Trainer<Cat> 

//define a default training method
Action<Animal> trainAnimal = (animal) => 
   { 
   Console.WriteLine("Training " + animal.GetType().Name + " to ignore you... done!"); 
   };

//work it!
animalTrainer(trainAnimal);

出力は、これが機能することを証明しています。

あなたを無視するように猫を訓練する...完了！

これを理解するには、冗談が必要です。

ある日、言語学の教授がクラスで講義をしていました。
「英語では、二重否定が肯定を形成します。
しかし、二重肯定が否定を形成できる言語はありません」と彼は指摘した。

部屋の奥から「はい、そうです」という声が響き渡った。

それは共分散と何の関係があるのですか?!

ナプキンの裏側のデモンストレーションを試してみましょう。

AnAction<T>は反変です。つまり、型の関係を「反転」します。

A < B => Action<A> > Action<B> (1)

Aand を使用してand Babove を変更しAction<A>、Action<B>次を取得します。

Action<A> < Action<B> => Action<Action<A>> > Action<Action<B>>  

or (flip both relationships)

Action<A> > Action<B> => Action<Action<A>> < Action<Action<B>> (2)

(1) と (2) を合わせると、次のようになります。

,-------------(1)--------------.
 A < B => Action<A> > Action<B> => Action<Action<A>> < Action<Action<B>> (4)
         `-------------------------------(2)----------------------------'

しかし、Trainer<T>デリゲートは事実上次のようになりAction<Action<T>>ます。

Trainer<T> == Action<Action<T>> (3)

したがって、(4) を次のように書き換えることができます。

A < B => ... => Trainer<A> < Trainer<B>

- これは、定義上、Trainer が共変であることを意味します。

要するに、Action 2 回適用すると、逆対分散が得られます。つまり、型間の関係が2 回反転するので ((4) を参照)、共分散に戻ります。

于 2013-06-21T09:22:56.240 に答える
3

これは、より一般的な構造型の観点から最もよく説明されています。検討：

  1. タプル型: (T1, T2)、型 T1 と T2 のペア (または、より一般的には n-タプル)。
  2. 関数の型: T1 -> T2、引数の型が T1 で結果が T2 の関数。
  3. 可変型: Mut(T)、T を保持する可変変数。

タプルは両方のコンポーネント タイプで共変です。つまり、(T1, T2) < (U1, U2) if T1 < U1 and T2 < U2 ('<' は is-subtype-of を意味します)。

関数は結果が共変で、引数が反変です。つまり、(T1 -> T2) < (U1 -> U2) U1 < T1 および T2 < U2 の場合です。

可変型は不変です。つまり、Mut(T) < Mut(U) は、T = U の場合のみです。

これらの規則はすべて、最も一般的な正しいサブタイプ規則です。

現在、主流の言語でおなじみのオブジェクトやインターフェイスの型は、そのメソッドを関数として含む複雑な形式のタプルとして解釈できます。たとえば、インターフェイス

interface C<T, U, V> {
  T f(U, U)
  Int g(U)
  Mut(V) x
}

基本的に型を表す

C(T, U, V) = ((U, U) -> T, U -> Int, Mut(V))

ここで、f、g、および x は、それぞれタプルの 1 番目、2 番目、および 3 番目のコンポーネントに対応します。

上記の規則から、T < T' および U' < U および V = V' の場合、C(T, U, V) < C(T', U', V') に従います。つまり、ジェネリック型 C は T では共変、U では反変、V では不変です。

もう一つの例：

interface D<T> {
  Int f(T)
  T g(Int)
}

は

D(T) = (T -> Int, Int -> T)

ここで、D(T) < D(T') は、T < T' および T' < T の場合のみです。一般に、これは T = T' の場合にのみ当てはまるため、D は実際には T で不変です。

また、共変と反変の両方を同時に意味する「バイバリアンス」と呼ばれることもある 4 番目のケースもあります。例えば、

interface E<T> { Int f(Int) }

実際には使用されないため、T では二変量です。

于 2013-06-21T13:07:07.153 に答える
1

Java は、ジェネリック型に対してユース サイト分散の概念を採用しています。必要な分散は、各ユース サイトで指定されます。これが、Java プログラマーがいわゆる PECS ルールに精通している必要がある理由です。はい、扱いにくく、すでに多くの批判を受けています。

于 2013-06-21T09:28:38.763 に答える