Call und Callvirt

call ist für den Aufruf nicht-virtuellen, statisch, oder superclass-Methoden, D. H., das Ziel des Anrufs ist nicht Gegenstand überschreiben. callvirt ist für den Aufruf von virtuellen Methoden (so dass, wenn this ist eine Unterklasse überschreibt die Methode der Unterklasse-version aufgerufen wird, statt).

InformationsquelleAutor der Antwort Chris Jester-Young

Aus diesem Grund .NET sealed-Klassen können bessere Methode versandfertig Leistung als Ihre nicht-versiegelt-Pendants.

Leider ist dies nicht der Fall ist. Callvirt tut eine andere Sache, das macht es nützlich. Wenn ein Objekt eine Methode aufgerufen, es callvirt wird prüfen, ob das Objekt existiert, und wenn nicht, wirft eine NullReferenceException. Rufen Sie einfach springen Sie zu der Position im Speicher, selbst wenn die Objekt-Referenz ist nicht da, und versuchen zum ausführen der bytes in diesem Ort.

Was dies bedeutet ist, dass callvirt wird immer dann verwendet der C# - compiler (nicht sicher über VB) für Klassen, und der Anruf wird immer für structs, weil Sie kann nie null sein oder Unterklassen).

Bearbeiten In Reaktion auf Drew Noakes Kommentar: ja, es scheint, Sie können den compiler zu emittieren, einen Anruf, für jede Klasse, aber nur in den folgenden sehr spezifischen Fall:

public class SampleClass
{
    public override bool Equals(object obj)
    {
        if (obj.ToString().Equals("Rubber Ducky", StringComparison.InvariantCultureIgnoreCase))
            return true;

        return base.Equals(obj);
    }

    public void SomeOtherMethod()
    {
    }

    static void Main(string[] args)
    {
        //This will emit a callvirt to System.Object.Equals
        bool test1 = new SampleClass().Equals("Rubber Ducky");

        //This will emit a call to SampleClass.SomeOtherMethod
        new SampleClass().SomeOtherMethod();

        //This will emit a callvirt to System.Object.Equals
        SampleClass temp = new SampleClass();
        bool test2 = temp.Equals("Rubber Ducky");

        //This will emit a callvirt to SampleClass.SomeOtherMethod
        temp.SomeOtherMethod();
    }
}

HINWEIS Die Klasse nicht abgedichtet sein müssen, damit dies funktioniert.

So wie es aussieht wird der compiler emittieren einen Anruf, wenn all diese Dinge wahr sind:

• Der Methodenaufruf wird sofort nach der Objekterstellung
• Die Methode ist nicht implementiert eine Basisklasse

InformationsquelleAutor der Antwort Cameron MacFarland

Eine Sache vielleicht Wert hinzufügen, um den vorherigen Antworten ist,
es scheint nur ein Gesicht auf, wie "IL call" tatsächlich führt,
und zwei Gesichter, die wie "IL callvirt" führt.

Nehmen Sie dieses Beispiel-setup.

    public class Test {
        public int Val;
        public Test(int val)
            { Val = val; }
        public string FInst () //note: this==null throws before this point
            { return this == null ? "NO VALUE" : "ACTUAL VALUE " + Val; }
        public virtual string FVirt ()
            { return "ALWAYS AN ACTUAL VALUE " + Val; }
    }
    public static class TestExt {
        public static string FExt (this Test pObj) //note: pObj==null passes
            { return pObj == null ? "NO VALUE" : "VALUE " + pObj.Val; }
    }

Erste, der CIL Körper der FInst() und FExt() ist zu 100% identisch, opcode -, um-opcode
(außer, dass man als "Instanz" und die anderen "statischen")
-- allerdings, FInst() wird aufgerufen mit "callvirt" und FExt() mit "call".

Zweite, FInst() und FVirt() werden aufgerufen, mit "callvirt"
- auch wenn man virtuellen, aber der andere nicht --
aber es ist nicht das "gleiche callvirt" , wirklich ausgeführt werden.

Hier ist, was grob passiert nach JITting:

    pObj.FExt(); //IL:call
    mov         rcx, <pObj>
    call        (direct-ptr-to) <TestExt.FExt>

    pObj.FInst(); //IL:callvirt[instance]
    mov         rax, <pObj>
    cmp         byte ptr [rax],0
    mov         rcx, <pObj>
    call        (direct-ptr-to) <Test.FInst>

    pObj.FVirt(); //IL:callvirt[virtual]
    mov         rax, <pObj>
    mov         rax, qword ptr [rax]  
    mov         rax, qword ptr [rax + NNN]  
    mov         rcx, <pObj>
    call        qword ptr [rax + MMM]  

Der einzige Unterschied zwischen "call" und "callvirt[Instanz]" ist, dass "callvirt[Instanz]" absichtlich versucht, Zugriff auf ein byte aus *pObj, bevor es fordert den direkten Zeiger auf die Instanz-Funktion (um eventuell eine Ausnahme werfen "und dann rechts").

So, wenn du genervt bist durch die Anzahl der Zeiten, die Sie haben, zu schreiben "- Prüfung Teil"

var d = GetDForABC (a, b, c);
var e = d != null ? d.GetE() : ClassD.SOME_DEFAULT_E;

Können Sie nicht drücken "if (this==null) return SOME_DEFAULT_E;" down in ClassD.GetE() selbst
(als "IL callvirt[Instanz]" Semantik verbietet Ihnen, das zu tun)
aber du bist frei, um schieben Sie es in .GetE (), wenn Sie sich bewegen .GetE (), um eine Erweiterung Funktion irgendwo (als "IL call" semantische erlaubt es-aber leider, verlieren den Zugriff auf private member, etc.)

Sagte, die Ausführung von "callvirt[Instanz]" hat mehr Gemeinsamkeiten
mit "call" als mit "callvirt[virtual]", da der letztere zum ausführen einer triple Umweg, um zu finden, die Adresse für Ihre Funktion.
(Dereferenzierung zu typedef base, dann zu base-vtab-oder-etwas-Schnittstelle, dann an die tatsächlichen slot)

Hoffe, das hilft,
Boris

InformationsquelleAutor der Antwort Boris