Dynamisk array af egen type

Du kan lave en ny klasse der bruger ArrayList, men hvor metoderne
tager og afleverer den rigtige type. Dine metoder kalder blot
metoderne i ArrayList med passende konvertering af typerne.

tja det er jo en mulighed

Det kommer jo helt an på hvad du skal bruge det til. Jeg kunne forestille mig at det er hurtigere at arbejde med et almindeligt array, dog ved jeg ikke om det så er langsommere at tilføje/fjerne elementer.

Eks. lav en klasse alá denne til at "styre" et array af "myObj":

class myObjArray
{
public myObj[] ary;

public myObjArray()
{
  ary = new myObj[0];
}
public void AddItem(myObj obj)
{
  myObj[] tmp = new myObj[ary.Length + 1];
  Array.Copy(ary, 0, tmp, 0, ary.Length);
  tmp[ary.Length] = obj;
  ary = tmp;
}
public void RemoveItem(int index)
{
  myObj[] tmp = new myObj[ary.Length - 1];
  if(index > 0)
  Array.Copy(ary, 0, tmp, 0, index);
  if(index < ary.Length - 1)
  Array.Copy(ary, index, tmp, index, ary.Length - (index + 1));
  ary = tmp;
}
}

så tror jeg helt klart det er bedre at benytte ArrayList. Hvis bare man kunne låse den til en type

Hvis man kunne det, ville det jo være fino, men med ovenstående undgår du at bruge casting - det skulle efter sigende spare lidt cpu.

Anyway, det var blot et forslag.

jeps jeg læste også at castingen tog lidt cpu, men hvis man skal copy sit array, nedlægge/oprette, må det vel også koste??+ jeg ved ikke om der er megen forskel, men spændende

Jeg går ud fra at når man bruger Array.Copy metoden, så kopierer den kun adresserne på indholdet af arrayet, og ikke selve arrayet. Det er i hvert tilfælde min erfaring at det er betydeligt hurtigere end ArrayList, i langt de fleste tilfælde - dvs. hvis du skal arbejde med meget store arrays eller hvis du bruger objekterne i dit array oftere end du tilføjer/fjerner objekter.

Jeg vil foreslå at du prøver dig frem - hvis du benytter store arrays og er lidt følsom overfor cpu forbrug, kan det vel godt betale sig at prøve både ArrayList og et almindeligt array. Så kan du jo vælge det hurtigste, fra gang til gang.

Den helt rigtige måde at lave en collection på er som følger:

    public class BananaPageCollection : CollectionBase, IEnumerable
    {
        new public virtual int Count
        {
            get { return List.Count; }
        }

        public void Add(BananaPage bananapage)
        {
            List.Add(bananapage);
        }

        new public void Clear()
        {
            List.Clear();
        }

        new public void RemoveAt(int index)
        {
            List.RemoveAt(index);
        }
        public void Remove(BananaPage bananapage)
        {
            List.Remove(bananapage);
        }
        public void RemoveById(int id)
        {
            foreach (BananaPage bananapage in List)
            {
                if (bananapage.ID == id)
                    Remove(bananapage);
            }
        }

        public BananaPage this[int key]
        {
            get
            {
                return (BananaPage)List[key];
            }
        }
        public BananaPage this[string title]
        {
            get
            {
                foreach (BananaPage bananapage in List)
                {
                    if (bananapage.Title == title)
                        return bananapage;
                }
                throw new NullReferenceException("BananaPage does not exist in collection.");
                return new BananaPage();
            }
        }

        new internal BananaPageEnumerator GetEnumerator()
        {
            return new BananaPageEnumerator(this);
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }

        public BananaPageCollection(BananaPage[] BananaPages)
        {
            foreach (BananaPage bananapage in BananaPages)
            {
                List.Add(bananapage);
            }
        }
        public BananaPageCollection() {}
    }

    internal class BananaPageEnumerator : IEnumerator
    {
        int nIndex;
        BananaPageCollection collection;

        public BananaPageEnumerator(BananaPageCollection coll)
        {
            collection = coll;
            nIndex = -1;
        }

        public void Reset()
        {
            nIndex = -1;
        }

        public bool MoveNext()
        {
            nIndex++;
            return nIndex < collection.Count;
        }

        public BananaPage Current
        {
            get
            {
                return (BananaPage)collection[nIndex];
            }
        }

        object IEnumerator.Current
        {
            get
            {
                return Current;
            }
        }
    }

Det kan i øvrigt bruges i foreach loops, og er ikke mere ressourcekrævende end et ArrayList.
(ovenstående er fra et projekt jeg har kørende)

// Simon
// This sentence no verb.

Bemærk i øvrigt, at sådanne Strongly-typed collections er en planlagt udvidelse af C#/.NET (generics)