Stack<T> Constructor

Imports System.Collections.Generic

Module Example

   Public Sub Demo(ByVal outputBlock As System.Windows.Controls.TextBlock)

      Dim numbers As New Stack(Of String)
      numbers.Push("one")
      numbers.Push("two")
      numbers.Push("three")
      numbers.Push("four")
      numbers.Push("five")

      ' A stack can be enumerated without disturbing its contents.
      For Each number As String In numbers
         outputBlock.Text &= number & vbCrLf
      Next

      outputBlock.Text &= String.Format(vbLf & "Popping '{0}'", numbers.Pop()) & vbCrLf
      outputBlock.Text &= String.Format("Peek at next item to pop: {0}", _
          numbers.Peek()) & vbCrLf
      outputBlock.Text &= String.Format("Popping '{0}'", numbers.Pop()) & vbCrLf

      ' Create another stack, using the ToArray method and the
      ' constructor that accepts an IEnumerable(Of T). Note that
      ' the order of items on the new stack is reversed.
      Dim stack2 As New Stack(Of String)(numbers.ToArray())

      outputBlock.Text &= vbLf & "Contents of the first copy:" & vbCrLf
      For Each number As String In stack2
         outputBlock.Text &= number & vbCrLf
      Next

      ' Create an array twice the size of the stack, compensating
      ' for the fact that Visual Basic allocates an extra array 
      ' element. Copy the elements of the stack, starting at the
      ' middle of the array. 
      Dim array2((numbers.Count * 2) - 1) As String
      numbers.CopyTo(array2, numbers.Count)

      ' Create a second stack, using the constructor that accepts an
      ' IEnumerable(Of T). The elements are reversed, with the null
      ' elements appearing at the end of the stack when enumerated.
      Dim stack3 As New Stack(Of String)(array2)

      outputBlock.Text &= String.Format(vbLf & _
          "Contents of the second copy, with duplicates and nulls:") & vbCrLf
      For Each number As String In stack3
         outputBlock.Text &= number & vbCrLf
      Next

      outputBlock.Text &= String.Format(vbLf & "stack2.Contains(""four"" & vbCrLf = {0}", _
          stack2.Contains("four"))

      outputBlock.Text &= vbLf & "stack2.Clear()" & vbCrLf
      stack2.Clear()
      outputBlock.Text &= String.Format(vbLf & "stack2.Count = {0}", _
          stack2.Count) & vbCrLf
   End Sub
End Module

' This code example produces the following output:
'
'five
'four
'three
'two
'one
'
'Popping 'five'
'Peek at next item to pop: four
'Popping 'four'
'
'Contents of the first copy:
'one
'two
'three
'
'Contents of the second copy, with duplicates and nulls:
'one
'two
'three
'
'
'
'
'stack2.Contains("four") = False
'
'stack2.Clear()
'
'stack2.Count = 0

using System;
using System.Collections.Generic;

class Example
{
   public static void Demo(System.Windows.Controls.TextBlock outputBlock)
   {
      Stack<string> numbers = new Stack<string>();
      numbers.Push("one");
      numbers.Push("two");
      numbers.Push("three");
      numbers.Push("four");
      numbers.Push("five");

      // A stack can be enumerated without disturbing its contents.
      foreach (string number in numbers)
      {
         outputBlock.Text += number + "\n";
      }

      outputBlock.Text += String.Format("\nPopping '{0}'", numbers.Pop()) + "\n";
      outputBlock.Text += String.Format("Peek at next item to destack: {0}",
          numbers.Peek()) + "\n";
      outputBlock.Text += String.Format("Popping '{0}'", numbers.Pop()) + "\n";

      // Create a copy of the stack, using the ToArray method and the
      // constructor that accepts an IEnumerable<T>.
      Stack<string> stack2 = new Stack<string>(numbers.ToArray());

      outputBlock.Text += "\nContents of the first copy:" + "\n";
      foreach (string number in stack2)
      {
         outputBlock.Text += number + "\n";
      }

      // Create an array twice the size of the stack and copy the
      // elements of the stack, starting at the middle of the 
      // array. 
      string[] array2 = new string[numbers.Count * 2];
      numbers.CopyTo(array2, numbers.Count);

      // Create a second stack, using the constructor that accepts an
      // IEnumerable(Of T).
      Stack<string> stack3 = new Stack<string>(array2);

      outputBlock.Text += String.Format("\nContents of the second copy, with duplicates and nulls:") + "\n";
      foreach (string number in stack3)
      {
         outputBlock.Text += number + "\n";
      }

      outputBlock.Text += String.Format("\nstack2.Contains(\"four\") = {0}",
          stack2.Contains("four")) + "\n";

      outputBlock.Text += "\nstack2.Clear()" + "\n";
      stack2.Clear();
      outputBlock.Text += String.Format("\nstack2.Count = {0}", stack2.Count) + "\n";
   }
}

/* This code example produces the following output:

five
four
three
two
one

Popping 'five'
Peek at next item to destack: four
Popping 'four'

Contents of the first copy:
one
two
three

Contents of the second copy, with duplicates and nulls:
one
two
three




stack2.Contains("four") = False

stack2.Clear()

stack2.Count = 0
 */