È possibile implementare il rendimento restituito per le funzioni IEnumerable in VB.NET?

Question

Eventuali duplicati:
Yield In VB.NET

In C#, quando si scrive una funzione che restituisce un IEnumerble<>, è possibile utilizzare yield return per restituire un singolo elemento dell'enumerazione e yield break; a significare nessun residuo elementi. Qual è la sintassi VB.NET per fare la stessa cosa?

Un esempio dal codice NerdDinner:

public IEnumerable<RuleViolation> GetRuleViolations() { 

    if (String.IsNullOrEmpty(Title)) 
     yield return new RuleViolation("Title required","Title"); 

    if (String.IsNullOrEmpty(Description)) 
     yield return new RuleViolation("Description required","Description"); 

    if (String.IsNullOrEmpty(HostedBy)) 
     yield return new RuleViolation("HostedBy required", "HostedBy"); 

    if (String.IsNullOrEmpty(Address)) 
     yield return new RuleViolation("Address required", "Address"); 

    if (String.IsNullOrEmpty(Country)) 
     yield return new RuleViolation("Country required", "Country"); 

    if (String.IsNullOrEmpty(ContactPhone)) 
     yield return new RuleViolation("Phone# required", "ContactPhone"); 

    if (!PhoneValidator.IsValidNumber(ContactPhone, Country)) 
     yield return new RuleViolation("Phone# does not match country", "ContactPhone"); 

    yield break; 
} 

Questo convert C# to VB.NET tool dà un "YieldStatement non è supportato" errore.

Answer 1

Non ci sono attualmente pari a rendimento ritorno C# 's in VB.Net da un livello sintassi del linguaggio.

Tuttavia c'è stata una recente scrittura in rivista MSDN da Bill McCarthy su come implementare un modello simile in VB.Net 9,0

• http://visualstudiomagazine.com/articles/2009/02/01/use-iterators-in-vb-now.aspx

Answer 2

Nessun ritorno resa in VB.NET :( Basta creare un elenco e lo restituisce.

Answer 3

Vedere le mie risposte qui:

• Yield in VB.NET
• Iterator pattern in VB.NET (C# would use yield!)

In sintesi:
VB.Net non ha resa, ma C# implementa resa convertendo il codice per una macchina a stati dietro a quelle scene. La parola chiave Static di VB.Net consente anche di memorizzare lo stato all'interno di una funzione, quindi in teoria dovresti essere in grado di implementare una classe che ti permetta di scrivere codice simile quando usato come membro di un metodo come Static.

Answer 4

Dietro le quinte, il compilatore crea una classe di enumeratore per eseguire il lavoro. Dal momento che VB.NET non implementa questo modello, è necessario creare una propria implementazione di IEnumerator (Of T)

Answer 5

seguente fornisce in uscita: 2, 4, 8, 16, 32

In VB,

Public Shared Function setofNumbers() As Integer() 

    Dim counter As Integer = 0 
    Dim results As New List(Of Integer) 
    Dim result As Integer = 1 
    While counter < 5 
     result = result * 2 
     results.Add(result) 
     counter += 1 
    End While 
    Return results.ToArray() 
End Function 

Private Sub Form1_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load 
    For Each i As Integer In setofNumbers() 
     MessageBox.Show(i) 
    Next 
End Sub 

in C#

private void Form1_Load(object sender, EventArgs e) 
    { 
     foreach (int i in setofNumbers()) 
     { 
      MessageBox.Show(i.ToString()); 
     } 
    } 

    public static IEnumerable<int> setofNumbers() 
    { 
     int counter=0; 
     //List<int> results = new List<int>(); 
     int result=1; 
     while (counter < 5) 
     { 
      result = result * 2; 
      counter += 1; 
      yield return result; 
     } 
    } 

Answer 6

Il nuovo Async CTP include il supporto per Yield in VB.NET.

Vedere Iterators in Visual Basic per informazioni sull'utilizzo.