Prise en charge des valeurs de retour de référence (Visual Basic)Support for reference return values (Visual Basic)

En commençant par C# 7.0, le C# prend en charge du langage référencer des valeurs de retour.Starting with C# 7.0, the C# language supports reference return values. Pour comprendre les valeurs de retour de référence est qu’ils sont le contraire des arguments qui sont passés par référence à une méthode.One way to understand reference return values is that they are the opposite of arguments that are passed by reference to a method. Lorsqu’un argument passé par référence est modifié, les modifications sont répercutées dans la valeur de la variable sur l’appelant.When an argument passed by reference is modified, the changes are reflected in value of the variable on the caller. Lorsqu’une méthode fournit une valeur de retour de référence à un appelant, les modifications apportées à la valeur de retour de référence par l’appelant sont reflétées dans les données de la méthode appelée.When an method provides a reference return value to a caller, modifications made to the reference return value by the caller are reflected in the called method's data.

Visual Basic n’autorise pas les valeurs de retour vous permettent de créer des méthodes avec référence, mais il vous autorise à utiliser les valeurs de retour de référence.Visual Basic does not allow you to author methods with reference return values, but it does allow you to consume reference return values. En d’autres termes, vous pouvez appeler une méthode avec une valeur de retour de référence et modifier cette valeur de retour, et les modifications apportées à la valeur de retour de référence sont répercutées dans les données de la méthode appelée.In other words, you can call a method with a reference return value and modify that return value, and changes to the reference return value are reflected in the called method's data.

Modification directe de la valeur de retour refModifying the ref return value directly

Pour les méthodes qui réussissent et n’ont pas toujours ByRef paramètres, vous pouvez modifier directement la valeur de retour de référence.For methods that always succeed and have no ByRef parameters, you can modify the reference return value directly. Pour cela, affectez la nouvelle valeur pour les expressions qui retourne la valeur de retour de référence.You do this by assigning the new value to the expressions that returns the reference return value.

Ce qui suit C# exemple définit un NumericValue.IncrementValue valeur de retour de méthode qui incrémente une valeur interne et le retourne en tant que référence.The following C# example defines a NumericValue.IncrementValue method that increments an internal value and returns it as a reference return value.

// <Snippet1>
using System;

public class NumericValue
{
   private int value = 0;
       
   public NumericValue(int value)
   {
      this.value = value;
   }     
   
   public ref int IncrementValue()
   {
      value++;
      return ref value;
   }
   
   public int GetValue()
   {
      return value;
   }
}
// </Snippet1>

La référence de retourner la valeur est ensuite modifiée par l’appelant dans l’exemple Visual Basic suivant.The reference return value is then modified by the caller in the following Visual Basic example. Notez que la ligne avec la NumericValue.IncrementValue appel de méthode n’affecte pas une valeur à la méthode.Note that the line with the NumericValue.IncrementValue method call does not assign a value to the method. Au lieu de cela, il attribue une valeur à la valeur de retour de référence retournée par la méthode.Instead, it assigns a value to the reference return value returned by the method.

Module Example
   Public Sub Main()
      Dim n As New NumericValue(15)
      n.IncrementValue() += 12
      Console.WriteLine(n.GetValue) 
   End Sub
End Module
' Output:   28

À l’aide d’une méthode d’assistanceUsing a helper method

Dans d’autres cas, modifier la valeur de retour de référence d’un appel de méthode directement toujours peut-être pas souhaitable.In other cases, modifying the reference return value of a method call directly may not always be desirable. Par exemple, une méthode de recherche qui retourne une chaîne peut trouver pas toujours une correspondance.For example, a search method that returns a string may not always find a match. Dans ce cas, vous souhaitez modifier la valeur de retour de référence uniquement si la recherche est réussie.In that case, you want to modify the reference return value only if the search is successful.

Ce qui suit C# exemple illustre ce scénario.The following C# example illustrates this scenario. Il définit un Sentence classe écrite dans C# inclut un FindNext méthode qui recherche le mot suivant dans une phrase qui commence par une sous-chaîne spécifiée.It defines a Sentence class written in C# includes a FindNext method that finds the next word in a sentence that begins with a specified substring. La chaîne est retournée comme valeur de retour de référence et une variable Boolean passée par référence à la méthode indique si la recherche a réussi.The string is returned as a reference return value, and a Boolean variable passed by reference to the method indicates whether the search was successful. La valeur de retour de référence indique que l’appelant peut uniquement pas de lire la valeur retournée ; il ou elle peut également la modifier, et cette modification est répercutée dans les données contenues en interne dans le Sentence classe.The reference return value indicates that the caller can not only read the returned value; he or she can also modify it, and that modification is reflected in the data contained internally in the Sentence class.

using System;
 
public class Sentence
{
    private string[] words;
    private int currentSearchPointer;
    
    public Sentence(string sentence)
    {
        words = sentence.Split(' ');
        currentSearchPointer = -1;
    }
    
    public ref string FindNext(string startWithString, ref bool found)
    {
        for (int count = currentSearchPointer + 1; count < words.Length; count++)
        {
            if (words[count].StartsWith(startWithString))
            {
                currentSearchPointer = count;
                found = true;
                return ref words[currentSearchPointer];
            }
        }
        currentSearchPointer = -1;
        found = false;
        return ref words[0];
    }
    
    public string GetSentence()
    {
        string stringToReturn = null;
        foreach (var word in words)
            stringToReturn += $"{word} ";
      
        return stringToReturn.Trim();    
    }
}

Modifier directement la référence de retourner la valeur dans ce cas n’est pas fiable, étant donné que l’appel de méthode peut échouer rechercher une correspondance et de retourner le premier mot dans la phrase.Directly modifying the reference return value in this case is not reliable, since the method call may fail to find a match and return the first word in the sentence. Dans ce cas, l’appelant sera modifier par inadvertance le premier mot de la phrase.In that case, the caller will inadvertently modify the first word of the sentence. Cela pourrait être bloqué par l’appelant retournant un null (ou Nothing en Visual Basic).This could be prevented by the caller returning a null (or Nothing in Visual Basic). Mais dans ce cas, la tentative de modifier une chaîne dont la valeur est Nothing lève un NullReferenceException.But in that case, attempting to modify a string whose value is Nothing throws a NullReferenceException. Si peut également être évitée en l’appelant retournant String.Empty, mais cela requiert que l’appelant définir une variable de chaîne dont la valeur est String.Empty.If could also be prevented by the caller returning String.Empty, but this requires that the caller define a string variable whose value is String.Empty. Bien que l’appelant peut modifier cette chaîne, la modification elle-même n’a aucune utilité, étant donné que la chaîne modifiée n’a aucune relation avec les mots dans la phrase stockée par le Sentence classe.While the caller can modify that string, the modification itself serves no purpose, since the modified string has no relationship to the words in the sentence stored by the Sentence class.

La meilleure façon de gérer ce scénario consiste à passer la valeur de retour de référence par référence à une méthode d’assistance.The best way to handle this scenario is to pass the reference return value by reference to a helper method. La méthode d’assistance contient alors la logique pour déterminer si l’appel de méthode a réussi et, si elle le faisait, pour modifier la retour de référence valeur.The helper method then contains the logic to determine whether the method call succeeded and, if it did, to modify the reference return value. L’exemple suivant fournit une implémentation possible.The following example provides a possible implementation.

Module Example
   Public Sub Main()
      Dim sentence As New Sentence("A time to see the world is now.")
      Dim found = False
      Dim returns = RefHelper(sentence.FindNext("A", found), "A good", found) 
      Console.WriteLine(sentence.GetSentence()) 
   End Sub
   
   Private Function RefHelper(ByRef stringFound As String, replacement As String, success As Boolean) _ 
                    As (originalString As String, found As Boolean) 
      Dim originalString = stringFound
      If found Then stringFound = replacement
      Return (originalString, found)   
   End Function
End Module
' The example displays the following output:
'      A good time to see the world is now.

Voir aussiSee also