Mobiele apps programmeren met Xamarin – Anatomie van een C# programma – Arrays en enumeraties

print

Inhoud


Wat vooraf ging

U hebt ondertussen reeds een aardige kennis opgebouwd met XAML en C# door de voorgaande posts uit deze reeks door te nemen. Meer specifiek hebt u kennis van de post Start to Program – Werken met datastructuren.


Lijsten (eendimensionale arrays)

Lijsten (eendimensionale arrays) worden gebruikt wanneer u meerdere waarden aan eenzelfde variabele wenst toe te kennen.

In het geheugen van de computer staan alle elementen van de lijst na elkaar. De index van het element bepaalt de volgorde, het rangnummer, van het element binnen de array.

Werken zonder array

Voorbeeld 1 (zonder gebruik te maken van een array)

Stel, u wilt 5 willekeurige getallen bijhouden met een waarde tussen 1 en 6.

U bent reeds vertrouwd met variabelen en het genereren van willekeurige getallen. Dan mag onderstaande code weinig geheimen bevatten.

In dit voorbeeld willen we slechts 5 willekeurige getallen genereren, maar stel nu dat u er 100 wilt, of 1000, of… Hebt u zin om er aan te beginnen op deze manier?

De oplossing ligt hem in het gebruik van een lijst/array. Een array wordt immers gebruikt om “meerdere waarden aan eenzelfde variabele toe te kennen” en dat is nu net wat we wensen te doen. We wensen een variabele Getal meerdere, gelijkaardige, waarden toe te kennen.

De array declareren

Eerst moeten we de array declareren. De algemene syntax is:

type[] arrayName;

Bijvoorbeeld:

int[] Getal;

Bovenstaande array is gedeclareerd maar heeft nog geen waarden.

U kunt bij de declaratie ook meteen waarden toekennen door deze op te sommen tussen {} gescheiden door een komma.

int[] numbers = { 1, 2, 3, 4, 5 };
string[] Vestigingen = {"Ninove", "Oudenaarde", "Zottegem"};

U kunt ook een array declareren zonder waarden maar met een reeds bepaald aantal elementen. Onderstaande array zal 5 elementen bevatten, die nog niet toegekend zijn (en dus voorlopig een onbepaalde, willekeurige waarde bevatten). Merk het gebruik van new op.

int[] getal = new int[5];

Elementen binnen een array aanspreken

Na het declareren van de array kunnen de elementen met hun index aangesproken worden. Dit gebeurt als volgt:

arraynaam[index];

Het eerste element in een array heeft index = 0.

De waarde van elementen binnen een array wijzigen of toevoegen

Om de waarde van elementen binnen een array te wijzigen gebruiken we onderstaande code:

arraynaam[index] = waarde;

Bijvoorbeeeld:

getal[0] = Willekeurig.Next(1, 7);
getal[1] = Willekeurig.Next(1, 7);

Voorbeeld 2 (met een array)

Stel, u wilt 5 willekeurige getallen bijhouden met een waarde tussen 1 en 6.

Ok, we gebruiken nu een array, maar waar is de winst want uiteindelijk moet er nog steeds evenveel getypt worden.

Wel, de winst komt er als we de array opvullen en weergeven gebruikmakend van een lus.

Lussen gebruiken om een array op te vullen en weer te geven

We kunnen de array opvullen met willekeurige getallen gebruikmakend van een lus.

int AantalGetallen = 4;
for (int x = 0; x <= AantalGetallen; x++) {
getal[x] = Willekeurig.Next(1, 7);
}

Door de waarde van de variabele AantalGetallen te wijzigen kan u zoveel getallen toevoegen als u wenst. Let op dat u voor AantalGetallen eentje minder neemt dan het getal dat u wenst omdat u moet beginnen te tellen bij 0. Vandaar int AantalGetallen = 4;.

Indien u liever toch AantalGetallen = 5 gebruikt, dat kan, maar denkt er dan aan dat u de lus moet doorlopen zolang de waarde van x kleiner is dan het AantalGetallen. U moet dus het =-teken verwijderen.

for (int x = 0; x < Aantalgetallen; x++)

In plaats van de waarde van de variabele kan je ook de bovengrens van de array opvragen, eens deze gekend is. Dit doe je met de code:

arraynaam.GetUpperBound(0)

Hierbij verwijst de 0 naar de eerste dimensie (een array kan immers meerdere dimensies hebben maar dit is voor later).

Bijvoorbeeld:

for (int x = 0; x < Getallen.GetUpperBound(0); x++) {
getal[x] = Willekeurig.Next(1, 7);
}

Voorbeeld 3 (met een array en een lus)

Stel, u wilt 5 willekeurige getallen bijhouden met een waarde tussen 1 en 6.
using System;
					
public class Program
{
	public static void Main()
	{
		int[] getal = new int[5];
		String uitvoer = "";
		Random Willekeurig = new Random();
		
		//Genereren		
		for (int x = 0; x <= getal.GetUpperBound(0); x++)
		{
			getal[x] = Willekeurig.Next(1, 7);
		}

		//Uitvoer		
		for (int y = 0; y <= getal.GetUpperBound(0); y++)
		{
			uitvoer += Convert.ToString(getal[y]) + Environment.NewLine;
		}

		Console.WriteLine(uitvoer);
	}
}

Om de lengte van een array te kennen gebruikt u: getal.Length. De lengte is per definitie steeds 1 hoger dan getal.GetUpperBound(0).

Een array sorteren

Om een array te sorteren gebruikt u de ingebouwde klasse Array.

De Array klasse kent een methode Sort() die als paramater de array ontvangt die gesorteerd moet worden.

Array.Sort(getal)

Deze methode plaatst u na het inlezen en voor het uitschrijven van de Array.

using System;
					
public class Program
{
	public static void Main()
	{
		int[] getal = new int[5];
		String uitvoer = "";
		Random Willekeurig = new Random();
		
		for (int x = 0; x <= getal.GetUpperBound(0); x++)
		{
			getal[x] = Willekeurig.Next(1, 7);
		}
		
		Array.Sort(getal);
		
		for (int y = 0; y <= getal.GetUpperBound(0); y++)
		{
			uitvoer += Convert.ToString(getal[y]) + Environment.NewLine;
		}

		Console.WriteLine(uitvoer);
	}
}

De positie van een element in een array opzoeken

De Array klasse kent een methode IndexOf() die als paramater de array ontvangt waarin moet gezocht worden en de waarde die moet gezocht worden. Komt de waarde in de array voor dan wordt de index (positie beginnende bij 0) weergegeven. Komt de waarde niet in de array voor dan is de uitkomst -1.

Array.IndexOf(getal, 6)

using System;
					
public class Program
{
	public static void Main()
	{
		int[] getal = new int[5];
		String uitvoer = "";
		Int32 positie;
		Random Willekeurig = new Random();		
		
		for (int x = 0; x <= getal.GetUpperBound(0); x++)
		{
			getal[x] = Willekeurig.Next(1, 7);
		}
		
		Array.Sort(getal);
		
		for (int y = 0; y <= getal.GetUpperBound(0); y++)
		{
			uitvoer += Convert.ToString(getal[y]) + Environment.NewLine;
		}
		
		positie = Array.IndexOf(getal, 6);
		
		if (positie != -1)
		{
			uitvoer += Environment.NewLine + "Het getal 6 staat op positie " + (positie + 1) + ".";
		}
		else
		{
			uitvoer += Environment.NewLine + "Het getal 6 komt niet voor!";
		}

		Console.WriteLine(uitvoer);
	}
}

Wilt u weten wanneer een waarde de laatste keer voorkwam in een array dan gebruikt u Array.LastIndexOf(getal, 6). Om het opzoeken pas vanaf een zekere index te laten starten kunt u een 3de argument meegeven met de startindex voor het zoeken.

Een dynamische array

Stel dat u een array wenst te gebruiken maar u hebt nog geen idee hoeveel elementen die array moet bevatten, dit moet later bepaald worden door bv. de gebruiker zelf, dan kunt u de array dynamisch declareren.

Dit gebeurt in 2 stappen. Eerst declareert u de array zonder dat u reeds een aantal elementen toekent via:

int[] getal = null;

Eens u het aantal getallen kent, dan kent u deze toe aan de array.

int aantalgetallen = 0;
aantalgetallen = 5;
getal = new int[aantalgetallen];

using System;
					
public class Program
{
	public static void Main()
	{
		int[] getal = null;
		string uitvoer = "";
		Random willekeurig = new Random();		
		int aantalgetallen = 0;
		
		aantalgetallen = 5;	
		getal = new int[aantalgetallen];
		
		for (int x = 0; x <= getal.GetUpperBound(0); x++)
		{
			getal[x] = willekeurig.Next(1, 7);
		}
		
		
		
		for (int y = 0; y <= getal.GetUpperBound(0); y++)
		{
			uitvoer += Convert.ToString(getal[y]) + Environment.NewLine;
		}

		Console.WriteLine(uitvoer);
	}
}

Stel dat u een array wilt uitbreiden met één element dan gebruikt u Array.Resize(ref getal, getal.GetUpperBound(0) + 1);.

Tweedimensionale array

Een tweedimensionale array kan je vergelijken met een tabel.

Een tweedimensionale array bevat 2 getallen (de 1ste en 2de dimensie) bij de declaratie. Bijvoorbeeld een tweedimensionale array van 3 reeksen van 6 getallen.

int[,] getal = new int[3, 6];

  • Het inlezen (en in dit voorbeeld meteen ook het uitlezen) gebeurt via een dubbele for-lus.
  • De bovengrens van de 1ste array wordt bepaald door getal.GetUpperBound(0). De bovengrens van de 2de array door getal.GetUpperBound(1).

Voorbeeld tweedimensionale array

Stel dat u niet 1 reeks van getallen wilt bijhouden maar een aantal reeksen van getallen. Er wordt dus een 2de dimensie toegevoegd. In het onderstaand voorbeeld worden 3 reeksen van 6 getallen gegenereerd.
using System;
					
public class Program
{
	public static void Main()
	{
		int[,] getal = new int[3, 6];
		string uitvoer = "";
		Random willekeurig = new Random();		
		
		for (int x = 0; x <= getal.GetUpperBound(0); x++) 
		{
			for (int y = 0; y <= getal.GetUpperBound(1); y++) 
			{
				getal[x, y] = willekeurig.Next(1, 7);
			}
		}
		
		for (int x = 0; x <= getal.GetUpperBound(0); x++)
		{
			uitvoer += "Reeks " + (x + 1) + ":";
			for (int y = 0; y <= getal.GetUpperBound(1); y++)
			{
				uitvoer += Convert.ToString(getal[x, y]).PadLeft(10);
			}
			uitvoer += Environment.NewLine;
		}

		Console.WriteLine(uitvoer);
	}
}

Merk op dat de uitlijning van de getallen wordt verzorgt door de functie PadLeft(10).

uitvoer += Convert.ToString(getal[x, y]).PadLeft(10);

Een array van arrays wordt een Jagged Array genoemd. Omwille van de complexiteit wordt dit hier niet verder behandeld.

Een array doorgeven als parameter aan een functie

Een array wordt op de normale manier doorgegeven.

Bijvoorbeeld:

int[] theArray = { 1, 3, 5, 7, 9 };
PrintArray(theArray);

De functie ontvangt de array op de normale manier.

void PrintArray(int[] arr)
{
// Statements.
}


Arrays weergeven in Xamarin

Uiteraard moet u ook een lijst/array kunnen weergeven in Xamarin. Bovendien moeten elementen binnen deze lijst aanklikbaar zijn.

XAML

Om een lijst weer te geven gebruikt u, in XAML, het element ListView. Deze ListView geeft u een naam x:Name=”ListVestigingen” en u voegt de event ItemSelected=”ListVestigingen_ItemSelected” toe.

  • Pas de XAML van de pagina Mainpage.xaml als volgt aan:
<?xml version="1.0" encoding="utf-8" ?>
<ContentPage xmlns="http://xamarin.com/schemas/2014/forms" xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml" xmlns:local="clr-namespace:ArrayWeergeven" x:Class="ArrayWeergeven.MainPage">
    <StackLayout>
 	 	<Label Text="PCVO Dender en Schelde" VerticalOptions="Center" HorizontalOptions="Center" />
        <ListView x:Name="ListVestigingen" ItemSelected="ListVestigingen_ItemSelected"></ListView>
    </StackLayout>

</ContentPage>

Code-behind

Ga naar de code-behind MainPage.xaml.cs.

U voegt eerst een array toe die de drie vestigingen van het PCVO Dender en Schelde bevat.

string[] Vestigingen = { "Ninove", "Oudenaarde", "Zottegem" };

Vervolgens kent u deze array toe aan de ListView via de eigenschap ItemsSource.

ListVestigingen.ItemsSource = Vestigingen;

De code wordt nu:

using Xamarin.Forms;

namespace ArrayWeergeven
{
    public partial class MainPage : ContentPage
    {
        public MainPage()
        {
            InitializeComponent();

            string[] Vestigingen = { "Ninove", "Oudenaarde", "Zottegem" };
            ListVestigingen.ItemsSource = Vestigingen;
        }

        private void ListVestigingen_ItemSelected(object sender, SelectedItemChangedEventArgs e)
        {
            
        }
    }
}

Tenslotte moeten we ook nog het geselecteerde item weergeven.

Dit gebeurt door gebruik te maken van de parameter SelectedItemChangedEventArgs e. Het geselecteerde item wordt bepaald door:

e.SelectedItem

Eerst wordt er nagegaan of er effectief een item geselecteerd is:

if (e.SelectedItem != null){
}

Vervolgens wordt het geselecteerde item weergegeven in een DisplayAlert. Zoals u weet werkt deze functie het best asynchroon.

await DisplayAlert("U selecteerde de vestiging ", e.SelectedItem.ToString(), "Ok");

De volledige code wordt nu:

using Xamarin.Forms;

namespace ArrayWeergeven
{
    public partial class MainPage : ContentPage
    {
        public MainPage()
        {
            InitializeComponent();

            string[] Vestigingen = { "Ninove", "Oudenaarde", "Zottegem" };
            ListVestigingen.ItemsSource = Vestigingen;
        }

        private async void ListVestigingen_ItemSelected(object sender, SelectedItemChangedEventArgs e)
        {
            if (e.SelectedItem != null)
            {
               await DisplayAlert("U selecteerde de vestiging ", e.SelectedItem.ToString(), "Ok");
            }
            
        }
    }
}

Enumeraties

Enumeraties zijn een opsomming van waarden die logisch bij mekaar horen. Een enumeratie wordt ook gebruikt om het programmeren zelf te vereenvoudigen.

De lijst bevat (tekst)waarden in een specifieke volgorde die geïndexeerd is (standaard beginnend bij 0). U kunt met zowel de tekstwaarde als de indexwaarde werken.

Een enumeratie heeft de volgende syntax:

enum naam {waarde1, waarde2, ...}

Bijvoorbeeld:

enum Vestigingen { Ninove, Oudenaarde, Zottegem}

Enumeraties worden gedeclareerd op het niveau van de klasse.

Onderstaand voorbeeld toont het werken met de bovenstaande enumeratie.

Enumeraties zijn ook handig ter ondersteuning van het programmeren zelf omdat ze tijdens het programmeren de lijst met keuzes aanbiedt:

Komt u dit bekend voor? Inderdaad, we hebben reeds enumeraties gebruikt, o.a. in XAML.

Design guides

Onderstaande design guides sluiten aan bij wat besproken is in deze post. Ik raad aan deze zeker eens te bekijken.

Android

iOS

UWP

  • Introductie in UWP app design
  • Keuzelijsten

  • Hoor het eens van iemand anders

    Laten we eens luisteren wat Bob Tabor van Microsoft Virtual Academy te vertellen heeft over arrays.

    Understanding Arrays

    Defining and Calling Methods

    Essentieel gaat deze video over het aanmaken van functies, maar vermits hij ook arrays gebruikt heb ik deze video pas hier geplaatst. De nadruk in de video ligt ook op het DRY-principe (Don’t Repeat Yourself).


    Behandelde Basiscompetenties uit de module ICT Programmeren – Specifieke ontwikkelomgeving: eenvoudige functionaliteiten

    • IC BC017 – kan ICT veilig en duurzaam gebruiken
    • IC BC234 – kan de basisprincipes van programmeren in een specifieke ontwikkelomgeving toepassen
    • IC BC236 – kan eenvoudige wijzigingen aan een programma aanbrengen
    • IC BC241 – kan een programma in een specifieke ontwikkelomgeving maken
    • IC BC250 – kan bij het programmeren in functie van een specifieke ontwikkelomgeving, een juiste logica volgen

Geef een reactie

  • Abonneer je op deze website d.m.v. e-mail

    Voer je e-mailadres in om je in te schrijven op deze website en e-mailmeldingen te ontvangen van nieuwe berichten.