Visual Basic 2012 Voorbeelden
   

visual basic 2012 broncode voorbeelden

Blijf op de hoogte van de recente aanpassingen op vbvoorbeelden!

Microsoft Visual Studio 2012Microsoft Developers Network - Visual BasicMicrosoft .NET Framework

23.4. System.Collections.Generic.IEnumerable(Of T) en IEnumerator(Of T)

Print Email Deel op Twitter Deel op Facebook

Dit artikel is gepubliceerd op maandag 15 oktober 2012 op vbvoorbeelden, bezoek de website voor een recente versie van dit artikel of andere artikels.

23.4.1. Strongly Typed IEnumerable(Of T) en IEnumerator(Of T)

Er zijn ook strongly typed versies van de IEnumerable en IEnumerator interfaces.

Namelijk System.Collections.Generic.IEnumerable(Of T) :
Interface IEnumerable(Of T) : Inherits IEnumerable
    Function GetEnumerator() As IEnumerator(Of T)
End Interface
En System.Collections.Generic.IEnumerator(Of T) :
Interface IEnumerator(Of T) : Inherits IEnumerator, IDisposable
    ReadOnly Property Current() As T
End Interface
Bestudeer de topics over generics en disposing voor een goed begrip van volgend voorbeeld.

In onderstaand voorbeeld creëren we een typesafe BoundedQueue (voor het beheren van Integer waardes) met een strongly typed enumerator :
Visual Basic 2012 Broncode - Codevoorbeeld 594
Option Strict On

Imports System.Collections.Generic

Namespace Example
    Class BoundedQueue : Implements IEnumerable(Of Integer)
        Protected _Items As Integer()
        Protected _Count As Integer
        Public Sub New(ByVal capacity As Integer)
            ReDim _Items(capacity - 1)
        End Sub
        Public ReadOnly Property Count() As Integer
            Get
                Count = _Count
            End Get
        End Property
        Public ReadOnly Property Capacity() As Integer
            Get
                Capacity = _Items.Length
            End Get
        End Property
        Public Sub Enqueue(ByVal value As Integer)
            If Count < Capacity Then
                _Items(Count) = value
                _Count += 1
            End If
        End Sub
        Public Function Peek() As Object
            Peek = _Items(0)
        End Function
        Public Sub Dequeue()
            For index As Integer = 0 To Count - 2
                _Items(index) = _Items(index + 1)
            Next
            _Items(Count - 1) = 0
            _Count -= 1
        End Sub
        '
        Private Function getObjectEnumerator() As IEnumerator _
                                            Implements IEnumerable.GetEnumerator
            getObjectEnumerator = GetEnumerator()
        End Function
        Public Function GetEnumerator() As Generic.IEnumerator(Of Integer) _
                         Implements Generic.IEnumerable(Of Integer).GetEnumerator
            GetEnumerator = New BoundedQueueEnumerator(_Items, Count)
        End Function
        '
        Private Class BoundedQueueEnumerator
            Implements IEnumerator(Of Integer)
            Private _Items As Integer()
            Private _Count As Integer
            Private _Cursor As Integer = -1
            Public Sub New(ByVal items As Integer(), ByVal count As Integer)
                _Items = items
                _Count = count
            End Sub
            Public Function MoveNext() As Boolean _
                                                 Implements IEnumerator.MoveNext
                _Cursor += 1
                MoveNext = (_Cursor < _Count)
            End Function
            Public Sub Reset() Implements IEnumerator.Reset
                _Cursor = -1
            End Sub
            Private ReadOnly Property currentObject() As Object _
                                                  Implements IEnumerator.Current
                Get
                    currentObject = Current
                End Get
            End Property
            Public ReadOnly Property Current() As Integer _
                               Implements Generic.IEnumerator(Of Integer).Current
                Get
                    Current = _Items(_Cursor)
                End Get
            End Property
#Region " IDisposable Support "
            Private disposedValue As Boolean = False ' To detect redundant calls
            Protected Overridable Sub Dispose(ByVal disposing As Boolean)
                If Not Me.disposedValue Then
                    If disposing Then
                        ' TODO: free other state (managed objects).
                    End If
                    ' TODO: free your own state (unmanaged objects).
                    ' TODO: set large fields to null.
                End If
                Me.disposedValue = True
            End Sub
            ' This code added by Visual Basic to correctly implement the
            ' disposable pattern.
            Public Sub Dispose() Implements IDisposable.Dispose
                ' Do not change this code.  Put cleanup code in Dispose(ByVal
                ' disposing As Boolean) above.
                Dispose(True)
                GC.SuppressFinalize(Me)
            End Sub
#End Region
        End Class
    End Class
    Class Client
        Public Shared Sub Main()
            Dim boundedQueue1 As New BoundedQueue(3)
            boundedQueue1.Enqueue(1)
            boundedQueue1.Enqueue(2)
            boundedQueue1.Enqueue(3)
            boundedQueue1.Enqueue(4)
            '
            For Each element As Integer In boundedQueue1                   ' (1)
                Console.Write(element.ToString() & " ")
            Next
            '
            Console.ReadLine()
        End Sub
    End Class
End Namespace
Console Application Output
1 2 3
Om het voorbeeld eenvoudig te houden is hier een niet robuuste iterator gedefinieerd.

Zelfs met strict type semantics (Option Strict On) is het mogelijk de element variabele van de For Each ... Next iteratie van het type Integer te declareren.

Het cleanup-pattern (region " IDisposable Support ") hoeft hier geen verdere implementatie.  Er zijn hier bijvoorbeeld geen schaarse resources die we vrij moeten geven, geen databaseconnecties of streams die we moeten sluiten en geen unmanaged resources die we moeten vrijgeven.
Visual Studio : De members uit de region " IDisposable Support " worden automatisch toegevoegd indien je aangeeft een generische instantie van IEnumerator(Of T) te implementeren.

Dit artikel is gepubliceerd op maandag 15 oktober 2012 op vbvoorbeelden, bezoek de website voor een recente versie van dit artikel of andere artikels.