• Je kan dat doen in een string-variabele met waarde: "lente" of "zomer" of "herfst" of "winter".
  Nadeel: een string kan alle tekenreeksen bevatten, in de programmacode moet je bij tests heel erg oppassen voor tikfouten:

  string seizoen = "herfst";
  ...
  if( seizoen == "hrefst" )
  {
  	....
  }
  

  Dit leidt natuurlijk tot moeilijk te ondervangen fouten
  Een bijkomend nadeel is het ontbreken van een volgorde voor de seizoenen.
• Je zou kunnen opteren voor het gebruik van een int:

  // lente = 0 , zomer = 1, herfst = 2, winter = 3
  int seizoen = 0;
  ...
  if( seizoen == 0 )
  {
  	....
  }
  

  
  Deze oplossing is werkbaar, maar vervelend in die zin dat je je tijdens het programmeren steeds moet afvragen welk seizoen welk cijfer heeft. Niemand belet je om in de variabele seizoen een onmogelijke waarde (bv. 2635) in te geven.
• Een betere oplossing is hier het gebruik van een enumeratie:

  enum Seizoen { lente, zomer, herfst, winter }
  

  Een enumeratie zorgt ervoor dat de elementen aan te spreken zijn met een naam, maar worden intern genummerd (standaard vanaf 0).
  Met een enumeratie heb je onmiddellijk de Visual Studio Intellisense ter beschikking en behoedt je jezelf voor tikfouten en logische fouten.
• Maak een in Window1 een Button btnToonWinter

  

• voorzie volgende code:

  ...
  namespace WpfEnum_Struct
  {
      enum Seizoen { lente, zomer, herfst, winter }
  
      public partial class Window1 : Window
      {
          public Window1()
          {
              InitializeComponent();
          }
  
          private void btnToonWinter_Click(object sender, RoutedEventArgs e)
          {
              Seizoen seizoen = Seizoen.winter;
              int seizoengetal = (int)seizoen;
              MessageBox.Show(String.Format("Seizoen nr. {0} is {1}"
                                      ,seizoengetal
                                      ,seizoen.ToString()));
  
  
             
          }
      }
  }
  

• Klikken op de knop geeft volgende MessageBox:

  

Startwaarde aanpassen

enum Seizoen { lente = 1, zomer, herfst, winter }

Elementen met eenzelfde waarde:

enum Seizoen { lente, zomer, herfst, winter, spring = lente, summer = zomer, autumn = herfst }

Enumeratie overlopen

In volgend voorbeeld doorlussen we de enumeratiemogelijkheden en plaatsen we deze in een ListBox, een aantal nieuwe code-elementen zoals het gebruik van een array en een foreach-lus die later uitvoeriger worden uitgelegd komen hier aan bod.

private void btnToonSeizoenen_Click(object sender, RoutedEventArgs e)
{
      lstSeizoenen.Items.Clear();
      foreach (string s in Enum.GetNames(typeof(Seizoen)))
      {
          lstSeizoenen.Items.Add(s);
      }
           
}

btnTest.Visibility = Visibility.Hidden;

public Visibility Visibility { get; set; }

namespace System.Windows
{
    // Summary:
    //     Specifies the display state of an element.
    public enum Visibility
    {
        // Summary:
        //     Display the element.
        Visible = 0,
        //
        // Summary:
        //     Do not display the element, but reserve space for the element in layout.
        Hidden = 1,
        //
        // Summary:
        //     Do not display the element, and do not reserve space for it in layout.
        Collapsed = 2,
    }
}

• Enumeraties zijn heel eenvoudig namen die in een bepaalde volgorde kunnen worden gezet, en worden als value doorgegeven (op de stack).
• Klassen zijn elementen die je kan gebruiken om volwaardige objecten te maken, op de stack plaatsen we een adres, waarbij op de heap de data van het object wordt gestockeerd.

  Soms is het goed een tussenvorm te gebruiken, meer mogelijkheden dan een enumeratie, maar toch niet de overhead van een klasse, waarbij communicatie is tussen stack en heap en acties intern dus omslachtiger en trager zijn.

• Een Structure is hier het antwoord op: een structure kan fields, methods en constructors hebben, maar wordt gemanaged op de stack en dus doorgegeven by value.

  Concreet wordt binnen .Net veel gebruik gemaakt van structures: int, long en float zijn eigenlijk niks anders dan verkorte schrijfwijzen voor de Structures System.Int32, System.Int64 en System.Single. Deze structures hebben fields en methods (zoals ToString()).

  Een structure wordt voornamelijk gebruikt voor entiteiten die belangrijk zijn om hun waarde, zoals een getal, een tijd, een datum, ...

• Voorzie een Button btnToonTijd in Window1
• Voeg volgende code toe:

  namespace WpfEnum_Struct
  {
      ...
  
      struct Tijd
      {
          public int uren, minuten, seconden;
  
          public Tijd(int uu, int mm, int ss)
          {
              /* we verzekeren ons van een maximale grootte 
               * door de rest bij deling door de maximale waarde te berekenen
               * zo wordt bv. 25 uur herleidt naar 1 uur */
              uren = uu % 24;
              minuten = mm % 60;
              seconden = ss % 60;
          }
  
          public string ToonTijd()
          {
              return String.Format("{0}:{1}:{2}"
                      , TweeCijfersGewenst(uren)
                      , TweeCijfersGewenst(minuten)
                      , TweeCijfersGewenst(seconden));
          }
  
  
          private string TweeCijfersGewenst(int getal)
          {
              string getaltekst = getal.ToString();
              if (getaltekst.Length < 2)
                  getaltekst = "0" + getaltekst;
              return getaltekst;
  
          }
  
  
      }
  
      public partial class Window1 : Window
      {
          public Window1()
          {
              InitializeComponent();
          }
  
          ...
  
          private void btnToonTijd_Click(object sender, RoutedEventArgs e)
          {
              Tijd tijd = new Tijd(11,5,40);
              MessageBox.Show("Tijd = " +tijd.ToonTijd());
          }
      }
  }
  

Meer info over Structures en het verschil met klassen vind je in een artikel bij DevTips