VB en fonction de plusieurs sorties - affectation des résultats

Je sais il n'y a pas de façon simple pour l'affectation multiple de la fonction dans la VB, mais il y a ma solution - c'est bon, comment voulez-vous faire mieux?

Ce dont j'ai besoin (comment aurais-je le faire en python, juste un exemple)

def foo(a)    ' function with multiple output
    return int(a), int(a)+1

FloorOfA, CeilOfA = foo(a) 'now the assignment of results

Comment je le fais en VB:

Public Function foo(ByVal nA As Integer) As Integer() ' function with multiple output
    Return {CInt(nA),CInt(nA)+1}
End Function

Dim Output As Integer() = foo(nA) 'now the assignment of results
Dim FloorOfA As Integer = Output(0)
Dim CeilOfA As Integer = Output(1)

Il n'y a pas de raison d'utiliser CInt(nA) quand nA est déjà un Integer.

OriginalL'auteur Intelligent-Infrastructure | 2013-05-08

5

Pour les futurs lecteurs, VB.NET 2017 et au-dessus prend désormais en charge la valeur de n-uplets d'une fonctionnalité du langage. Vous déclarez votre fonction comme suit:
```
Function ColorToHSV(clr As System.Drawing.Color) As (hue As Double, saturation As Double, value As Double)
  Dim max As Integer = Math.Max(clr.R, Math.Max(clr.G, clr.B))
  Dim min As Integer = Math.Min(clr.R, Math.Min(clr.G, clr.B))

  Dim h = clr.GetHue()
  Dim s = If((max = 0), 0, 1.0 - (1.0 * min / max))
  Dim v = max / 255.0

  Return (h, s, v)
End Function
```
Et vous l'appeler comme ceci:
```
Dim MyHSVColor = HelperFunctions.ColorToHSV(clr)
MsgBox(MyHSVColor.hue)
```
Remarque comment VB.NET crée propriété publique nommée hue déduit du type de retour de la fonction appelée. Intellisense trop fonctionne correctement pour ces membres.

Noter, cependant, que vous devez cibler .NET Framework de 4,7 pour que cela fonctionne. Alternativement, vous pouvez installer System.ValueTuple (disponible sous forme de package NuGet) dans votre projet pour bénéficier de cette fonctionnalité.

OriginalL'auteur dotNET
8

Votre solution fonctionne, et il est une manière élégante de retourner plusieurs résultats, cependant, vous pouvez également essayer avec cette
```
Public Sub foo2(ByVal nA As Integer, ByRef a1 As Integer, ByRef a2 As Integer) 
    a1 = Convert.ToInt32(nA)
    a2 = Convert.ToInt32(nA) +1
End Sub
```
et de l'appeler avec
```
foo2(nA, CeilOfA, FloorOfA)    
```
Si vous avez beaucoup de résultats à retourner il est logique de penser à une classe qui peut retourner toutes les valeurs requises (Notamment si ces valeurs sont de différents types)
```
Public Class CalcParams
   Public p1 As Integer
   Public p2 As String
   Public p3 As DateTime
   Public p4 As List(Of String)
End Class

Public Function foo2(ByVal nA As Integer) As CalcParams
    Dim cp = new CalcParams()
    cp.p1 = Convert.ToInt32(nA)
    .......
    Return cp
End Function
```
+1 les Pensées de correspondance.
et pour une utilisation de base est-il vraiment nécessaire d'instancier une classe? Peut-être structure est-elle suffisante?
Il n'est pas tellement différent que de retourner un tableau. Mais vous avez raison, avec seulement deux paramètres et de type entier, vous pourriez aller avec votre solution ou de transmettre les résultats attendus Par la Réf. Les choses se compliquent quand vous avez besoin de traiter des données complexes. C'était juste un exemple (je l'avoue, un peu improbable)
Oui aussi une structure qui fonctionne bien. Vous gagnerez quelque chose, mais cela dépend vraiment de combien de fois vous appelez cette méthode.

OriginalL'auteur Steve
3

Peut-être que vous pouvez utiliser Tuple:
```
Public Function foo(ByVal nA As Integer) As Tuple(Of Integer,Integer) ' function with multiple output
    Return Tuple.Create(CInt(nA),CInt(nA)+1)
End Function

Dim FloorOfA, CeilOfA As Integer
With foo(nA) 'now the assignment of results
   FloorOfA =.item1
   CeilOfA = .item2
End With
```
Edit: Nouveau Tuple remplacer par le n-uplet.Créer (merci à @mbomb007)

Je ne l'aime pas de toute façon... tuple semble être lourd, et j'ai juste besoin de deux nombres entiers. + combien de fois la fonction toto est appelée dans la with, un ou les deux?
La sous-routine est appelée qu'une seule fois. "Avec la" remplace "Production" de la déclaration. Les Tuples permettent d'éviter byref paramètres qui ne sont pas considérés comme très bonne pratique. Vous pouvez utiliser .item1 .item2 dans votre agorithm et ainsi éviter FloorOfA,CeilOfA déclaration.
J'aime l'utilisation de Tuple, mais je ne voudrais pas l'utiliser "À" ici. Ajoute un niveau d'imbrication, simplement pour avoir accès à plusieurs retour des résultats. Je voudrais affecter le résultat d'un local var. Dim Output = foo(nA) / Dim FloorOfA = Output.Item1. Comme le code en question, mais à l'aide de n-uplet plutôt que de tableau.
est utilisé pour éviter la nécessité de la déclaration de la variable. Surtout dans le cas où si option infer n'est pas utilisé et l'intégralité de la déclaration Dim Output as Tuple(Of Integer,Integer)= foo(nA) est nécessaire. J'avoue que c'est une question de goût personnel.
C'est ce que Tuple.Create() est, de sorte que vous n'avez pas à utiliser telle une longue déclaration. Utiliser à la place.

OriginalL'auteur IvanH

La méthode que vous utilisez est un bon un, par la manière, vous pouvez passer à la variable requise comme une reference à votre subroutine afin de faire de votre code plus propre.

Dim FloorOfA As Integer
Dim CeilOfA As Integer

Call foo(10.5, FloorOfA, CeilOfA)

Public Sub foo(ByVal xVal As Integer, ByRef x As Integer, ByRef y As Integer)
    x = CInt(xVal)
    y = CInt(xVal) + 1
End Sub

OriginalL'auteur Rajaprabhu Aravindasamy

Vous devez vous connecter pour publier un commentaire.