Le coût de performances à l'aide de ref au lieu de retourner mêmes types?

Le but principal de l'utilisation du mot-clé ref est pour signifier que la valeur de la variable peut être modifiée par la fonction de son passé. Lorsque vous passez une variable par valeur, les mises à jour à partir de la fonction ne pas l'effet de l'original de la copie.

Son extrêmement utile (et plus rapide) pour les situations où vous souhaitez que plusieurs valeurs de retour et la construction d'une spéciale struct ou class pour les valeurs de retour serait exagéré. Par exemple,

public void Quaternion.GetRollPitchYaw(ref double roll, ref double pitch, ref double yaw){
    roll = something;
    pitch = something;
    yaw = something;
}

C'est une question assez fondamentale modèle dans les langues qui ont sans restriction de l'utilisation de pointeurs. En c/c++, vous voyez souvent des primitives d'être passés par valeur avec des classes et des tableaux de pointeurs. C# est l'opposé donc, " ref " est à portée de main dans des situations comme ci-dessus.

Lorsque vous passez une variable que vous voulez mettre à jour dans une fonction par ref, 1 seule opération d'écriture est nécessaire pour vous donner le résultat. Lors du renvoi des valeurs toutefois, vous écrivez à une variable à l'intérieur de la fonction, le retourner, puis d'écrire de nouveau à la variable de destination. Selon les données, ce qui pourrait ajouter une surcharge inutile. De toute façon, ce sont les principales choses que j'ai généralement considérer avant d'utiliser le mot-clé ref.

Parfois ref est un peu plus rapide lorsqu'il est utilisé comme ce, en c#, mais pas assez pour l'utiliser comme un goto justification de la performance.

Voici ce que j'ai obtenu sur un enfant de 7 ans à la machine à l'aide du code ci-dessous en passant et mise à jour d'un 100k chaîne par référence et par valeur.

De sortie:

itérations: 10000000
byref: 165ms
byval: 417ms

private void m_btnTest_Click(object sender, EventArgs e) {

    Stopwatch sw = new Stopwatch();

    string s = "";
    string value = new string ('x', 100000);    //100k string
    int iterations = 10000000;

    //-----------------------------------------------------
    //Update by ref
    //-----------------------------------------------------
    sw.Start();
    for (var n = 0; n < iterations; n++) {
        SetStringValue(ref s, ref value);
    }
    sw.Stop();
    long proc1 = sw.ElapsedMilliseconds;

    sw.Reset();

    //-----------------------------------------------------
    //Update by value
    //-----------------------------------------------------
    sw.Start();
    for (var n = 0; n < iterations; n++) {
        s = SetStringValue(s, value);
    }
    sw.Stop();
    long proc2 = sw.ElapsedMilliseconds;

    //-----------------------------------------------------
    Console.WriteLine("iterations: {0} \nbyref: {1}ms \nbyval: {2}ms", iterations, proc1, proc2);
}

public string SetStringValue(string input, string value) {
    input = value;
    return input;
}

public void SetStringValue(ref string input, ref string value) {
    input = value;
}

OriginalL'auteur drankin2112

D'abord, ne pas la peine à savoir si l'utilisation ref est plus lent ou plus rapide. Il est prématuré d'optimisation. Dans 99.9999% des cas, vous ne serez pas dans une situation ce serait la cause d'une performance bottlenect.

Deuxième, en retournant le résultat du calcul d'une valeur de retour par opposition à l'aide ref est préférée en raison de l'habitude "fonctionnel" la nature de la C-comme les langues. Il conduit à une meilleure chaînage de déclarations/appels.

OriginalL'auteur Ondrej Tucny