[C#] foreach + ArrayList + drie classes

[Verwijderd]

Hmmz, 'k vraag me af of het volgende kan. 'k heb een ArrayList gemaakt genaamd Connections en in deze ArrayList gaan steeds nieuwe objecten. Nu heb ik drie verschillende classes, namelijk Connection, ManagementConnection en MonitorConnection. Nu wil ik op een bepaald moment alleen alle MonitorConnection classes in die ArrayList hebben, dus schreef ik de volgende code:

code:

foreach (MonitorConnection con in Connections) {
 <blabla>
}

Nou krijg ik dus een fout op MonitorConnection con van het type The specified cast is invalid. Dus ik vraag me af of ik dan voor elke class een aparte ArrayList moet maken, of zou het wel moeten kunnen op deze manier?

[Verwijderd]

Je kunt of overal een aparte ArrayList voor maken, of er doormiddel van een for loop doorheen lopen en vervolgens met 'is' kijken wat voor type het huidige object heeft.

[Verwijderd]

Maar met foreach dus weer niet. Beetje jammer, maar goed, dan kan'k beter een aparte ArrayList maken voor elke soort, want dat is toch al handiger in de administratie .

[Verwijderd]

Of alle classes moeten dezelfde base hebben. Je kan idd ook gewoon met een for lus erdoor heen fietsen, en dan steeds met if (object is MyClass) checken of het om het goede type gaat. Maar 3 ArrayList's is makkelijker .

[whoami]

Als MonitorConnection afgeleid is van de class Connection, dan zal het geen probleem zijn om de MonitorConnection objecten in een array te stoppen van het type Connection. (Een beetje zoals KoenM zegt).

[Orphix]

Wat ik ooit in een msn-lib heb gemaakt is verschillende enumerators gebruikt. Op die manier kon je door alle, alleen online, of alleen offline personen wandelen. Deze zaten allemaal in dezelfde arraylist. Dit is wel zo makkelijk namelijk.

Ik had dit (beetje ingekort):

code:

public class ContactList : Hashtable
        {
            public class ListEnumerator : IEnumerator
            {
                protected IDictionaryEnumerator baseEnum;
                public ListEnumerator(IDictionaryEnumerator listEnum)
                {
                    baseEnum = listEnum;
                }
                public bool MoveNext()
                {                   
                    return baseEnum.MoveNext();
                }
                public Object Current 
                {
                    get { return baseEnum.Value; }
                }
                public void Reset()
                {
                    baseEnum.Reset();
                }
                public IEnumerator GetEnumerator()
                {           
                    return this;
                }
            }
            public class ForwardListEnumerator : ContactList.ListEnumerator
            {
                public ForwardListEnumerator(IDictionaryEnumerator listEnum)
                    : base(listEnum)
                {
                }
                public new bool MoveNext()
                {                   
                    while(baseEnum.MoveNext())
                    {
                        // filter on the forward boolean
                        if(((Contact)baseEnum.Current).forward == true)
                            return true;
                    }
                    return false;
                }
            }

public ContactList.ForwardListEnumerator ForwardList
        {
            get { return new ContactList.ForwardListEnumerator(contacts.GetEnumerator()); }
        }
      }
private ContactList contacts = new ContactList();

* Orphix maakt z'n eigen design patterns
Ik was hier net bezig met C#, dus kan allemaal niet zo netjes enzo zijn.
Maar als het goed is kan je nu met

code:

foreach(Contact contact in contacts.ForwardList)
{
 // doe hier wat met je contact
}

Door alle personen lopen die enkel op de forward list staan (=msn term).

Of je het mooi vindt of niet moet je zelf bepalen, ik vind het wel een mooie manier voor de eindgebruiker. Bovendien is het handig data alle data uiteindelijk op 1 plek staat. De performance is natuurlijk iets minder, maar dat is in dit geval niet zo'n probleem.