Del 9.

Dynamiska listor

När vi tidigare gick igenom hur vi kunde lagra linjär information av vilken datatyp som helst i typen array så upptäckte vi en stor nackdel med typen array och det var att när den väl är deklarerad så kunde vi inte utöka den med fler element eller minska ner storleken på den när vi tog bort något element. En array är låst till antalet element som den är deklarerad för.

Vad är då lösningen om vi behöver ha linjär lagring av information men vi vet inte hur många element som kommer att behöva lagras? Lösningen heter ArrayList.

ArrayList

ArrayList är en klass som vi kan hitta i namespace System.Collections och som dynamiskt kan ändra sin storlek för att anpassas efter fler eller färre element.

Vi kan lagra vilka typer som helst i en ArrayList.
Låt oss se på ett exempel

using System.Collections;
class Program
{
  public static void Main(string[] args)
  {
  	// Skapa en ny lista...
    ArrayList things = new ArrayList();
	
    // Lägg till lite element av olika datatyper
    things.Add("Michael");
    things.Add(DateTime.Today);
    things.Add(25);
    things.Add("Hej");

	// Anropa Display för att visa innehåll
    Display(things);
  }

  public static void Display(ArrayList list)
  {
  	// Nu kan vi använda oss av loopen foreach...
    foreach (var item in list)
    {
      Console.WriteLine("My thing {0}", item);
    }
  }
}

Problem med ArrayList

Tyvärr så lider ArrayList av ett problem och problemet är precis det som vi gör i ovanstående exempel. Vi lagrar olika typer i vår ArrayList, vilket kanske är precis vad vi vill. Problemet uppstår när vi måste gå igenom listan och plocka ut respektive objekt/element ur listan. I och med att det kan vara precis vad som helst som ligger i listan så måste vi veta vad respektive objekt är för typ för att kunna plocka ut det på ett korrekt sätt.

ArrayList är en gammal struktur för dynamiska listor som introducerades redan i det gamla .NET ramverket version 1.1.

Läser vi dokumentation angående ArraList så rekommenderar Microsoft INTE att vi använder ArrayList vid utveckling av nya applikationer utan istället använder oss av generiska listor.

Generiska Listor

I .NET och i C# kan vi bestämma vilken typ som vi vill kunna lagra i en lista genom att ange typen som ska lagras. Vi gör detta genom att använda ett begrepp som kallas för Generics i .NET.

Syntaxen för att skapa en generisk lista är:

List<T>

List är motsvarigheten till ArrayList men med den stora skillnaden att List är typsäker , där <T> representerar typen som vi vill använda i listan.

List finns i namespace eller namnutrymmet System.Collection.Generic.

Låt oss titta på ett exempel:

using System.Collections.Generic;
public class Program
{
  private static void Main()
  {
    // Deklarera en variabel list som enbart kommer att 
    // innehålla strängar.
    var list = new List<String>();
    list.Add("Michael");
    list.Add("Eva");
    list.Add("Paula");
    list.Add("Bosse");

    foreach (var name in list)
    {
      Console.WriteLine(name);
    }
  }
}

Output resultat:

Michael
Eva
Paula
Bosse

Vad händer om vi försöker addera ett objekt som inte är av typen sträng?

using System.Collections.Generic;
public class Program
{
  private static void Main()
  {
    // Deklarera en variabel list som enbart kommer att 
    // innehålla strängar.
    var list = new List<String>();
    list.Add("Michael");
    list.Add("Eva");
    list.Add("Paula");
    list.Add("Bosse");
    list.Add(200);

    foreach (var name in list)
    {
      Console.WriteLine(name);
    }
  }
}

Output resultatet i det här fallet är ett felmeddelande:
error CS1503: Argument 1: cannot convert from 'int' to 'string'

Som tydligt indikerar att vi försöker placera ett heltalsvärde in en lista som endast tillåter strängar.

Detta var bara en liten introduktion till generics eller generiska typer. Vi kommer att se mer av dessa när vi börjar arbeta med Objekt Orienterad Programmering.