Delen via

in (Generic Modifier) (C#-verwijzing)

  • Artikel

Voor algemene typeparameters geeft het in trefwoord aan dat de typeparameter contravariant is. U kunt het in trefwoord gebruiken in algemene interfaces en gemachtigden.

Met Contravariantie kunt u een minder afgeleid type gebruiken dan het type dat is opgegeven door de algemene parameter. Dit maakt impliciete conversie van klassen mogelijk die contravariantinterfaces implementeren en impliciete conversie van gedelegeerdentypen. Covariantie en contravariantie in algemene typeparameters worden ondersteund voor referentietypen, maar worden niet ondersteund voor waardetypen.

Een type kan alleen worden gedeclareerd als contravariant in een algemene interface of gedelegeerde als het het type parameters van een methode definieert en niet van het retourtype van een methode. In, refen out parameters moeten invariant zijn, wat betekent dat ze geen covariant of contravariant zijn.

Met een interface met een parameter voor het contravarianttype kunnen de methoden argumenten accepteren van minder afgeleide typen dan de parameters die zijn opgegeven door de parameter van het interfacetype. In de IComparer<T> interface is type T bijvoorbeeld contravariant, kunt u een object van het IComparer<Person> type toewijzen aan een object van het IComparer<Employee> type zonder speciale conversiemethoden te gebruiken als Employee dit Personwordt overgenomen.

Aan een contravariant gedelegeerde kan een andere gemachtigde van hetzelfde type worden toegewezen, maar met een minder afgeleide algemene typeparameter.

Zie Covariantie en Contravariantie voor meer informatie.

Algemene interface contravariant

In het volgende voorbeeld ziet u hoe u een algemene interface voor contravariant declareert, uitbreidt en implementeert. U ziet ook hoe u impliciete conversie kunt gebruiken voor klassen die deze interface implementeren.

// Contravariant interface.
interface IContravariant<in A> { }

// Extending contravariant interface.
interface IExtContravariant<in A> : IContravariant<A> { }

// Implementing contravariant interface.
class Sample<A> : IContravariant<A> { }

class Program
{
    static void Test()
    {
        IContravariant<Object> iobj = new Sample<Object>();
        IContravariant<String> istr = new Sample<String>();

        // You can assign iobj to istr because
        // the IContravariant interface is contravariant.
        istr = iobj;
    }
}

Contravariant algemene gemachtigde

In het volgende voorbeeld ziet u hoe u een algemene gemachtigde kunt declareren, instantiëren en aanroept. U ziet ook hoe u impliciet een type gedelegeerde kunt converteren.

// Contravariant delegate.
public delegate void DContravariant<in A>(A argument);

// Methods that match the delegate signature.
public static void SampleControl(Control control)
{ }
public static void SampleButton(Button button)
{ }

public void Test()
{

    // Instantiating the delegates with the methods.
    DContravariant<Control> dControl = SampleControl;
    DContravariant<Button> dButton = SampleButton;

    // You can assign dControl to dButton
    // because the DContravariant delegate is contravariant.
    dButton = dControl;

    // Invoke the delegate.
    dButton(new Button());
}

C#-taalspecificatie

Zie de C#-taalspecificatie voor meer informatie. De taalspecificatie is de definitieve bron voor de C#-syntaxis en het gebruik.

Zie ook