[C#]Class aanmaken met daarin onbekende array

[Gehakt]

Stel ik heb een class met daarin een array van intergers.
En ik weet bij het aanmaken van die class nog niet hoe groot het array moet worden.
Hoe kan ik dit dan voor elkaar krijgen?

C#:

public class Class1
{
    public Class1()
    {}
    int[] a = new int[2];
}

Dit gaat gewoon goed op het moment dat ik dit object aanmaak.
Maar wat is de beste oplossing op het moment dat ik pas later weet hoe groot de array moet zijn.

Moet ik dan een array van grootte 0 defineren en er later vergroten?
Of is het toch mogelijk om eerst enkele functies uit te voeren en dan bijvoorbeeld zoiets te doen?
Ik weet dat het onderstaande codevoorbeeld niet werkt maar ik probeer er mee aan te geven wat ik wil bereiken.

C#:

public class Class1
{
    int aantal;
    public Class1()
    {
          MaakAantal(2);
    }
    int[] a = new int[aantal];

public void MaakAantal(int x)
{
    this.aantal = x;
}

[Y0ur1]

Ik zou eens kijken naar ArrayList

[Verwijderd]

Waarom gebruik je geen List<> of ArrayList? Ik zou zelf doen:

C#:

IList<int> = new List<int>();

[/\/\|)]

Je hoeft het array pas te initialiseren als je er iets mee gaat doen, m.a.w. de new hoeft pas als je het array gaat vullen.

[Gehakt]

Jaa danku danku danku dat is precies het antwoord dat op mijn vraag past!
Het werkt zo:

C#:

namespace ConsoleApplication1
{
    public struct structA
    {
        public int varA;
    }

    public class Class1
    {
        public Class1()
        {
            structTest = new StructA[5];
        }
        public StructA[] structTest;
    }
}

[whoami]

Ik zie hier nergens meer een array van integers; ik zie je nergens gebruik maken van list, en ik zie dat je nu opeens wel op voorhand weet hoe groot die array moet zijn?

[Gehakt]

Ik had als voorbeeld een array van intergers genomen om dat dat makkelijker qua code is dan het met structs gaan uitleggen maar qua principe maakt het geen verschil.
En nee ik weet nog steeds niet op voorhand wat het moet gaan worden.
Maar ik wil met die 5 alleen maar aangeven dat ik daar een ander getal in zou kunnen vullen en dat dan de juiste arraygrootte word aangemaakt bij de constructie van de class.

/\/\|) schreef op maandag 10 december 2007 @ 22:32:
Je hoeft het array pas te initialiseren als je er iets mee gaat doen, m.a.w. de new hoeft pas als je het array gaat vullen.

Zijn antwoord is dus de oplossing die voor mij werkt.
En ik hoef niet in Lists te duiken aangezien ik daar nog niets van weet.

[ Voor 31% gewijzigd door Gehakt op 10-12-2007 23:03 ]

[BikkelZ]

Je kunt de array pas initialiseren op het moment dat je weet hoe groot hij gaat worden, of je past de grootte aan en dan copy je de array naar een nieuwe array die hem vervangt. Dat lijkt misschien omslachtig of 'duur', maar in veel talen is dat het gene wat er achter de schermen gebeurt als je bijvoorbeeld ReDim doet.

[Muyz]

whoami schreef op maandag 10 december 2007 @ 22:46:
Ik zie hier nergens meer een array van integers; ik zie je nergens gebruik maken van list, en ik zie dat je nu opeens wel op voorhand weet hoe groot die array moet zijn?

Inderdaad, dit gaat nergens over...

Paar voorbeeldjes...

C#:

class Example
{
    int[] lstInt;
    List<int> lstInt2;
    List<int> lstInt3;

    public Example()
    {
        lstInt3 = new List<int>();
    }

    public void Init(int iAantal)
    {
        lstInt = new int[iAantal];
    }

    public void Init2(int iAantal)
    {
        lstInt2 = new List<int>(iAantal);
    }
}

...en er zijn nog veel meer mogelijkheden

[riezebosch]

Muyz schreef op maandag 10 december 2007 @ 23:07:
[...]

Inderdaad, dit gaat nergens over...

Paar voorbeeldjes...

C#:

class Example
{
    int[] lstInt;
    List<int> lstInt2;
    List<int> lstInt3;

    public Example()
    {
        lstInt3 = new List<int>();
    }

    public void Init(int iAantal)
    {
        lstInt = new int[iAantal];
    }

    public void Init2(int iAantal)
    {
        lstInt2 = new List<int>(iAantal);
    }
}

...en er zijn nog veel meer mogelijkheden

Je komt dan wel weer gelijk met generics op de proppen, en generics zijn eng

[Ontspannen]

Gehakt schreef op maandag 10 december 2007 @ 22:19:
...En ik weet bij het aanmaken van die class...

Aanmaken = schrijven van de klasse:
Het aantal elementen dmv de constructor van de klasse instellen.

Aanmaken = instantie van de klasse maken:
Eerst een instantie aanmaken pas wanneer je het aantal elementen "weet", via een schrijfeigenschap van de klasse het aantal elementen instellen.



off topic (daar het hier ter sprake komt):
Iem. een voorbeeld waarbij generics super handig is?

[ Voor 10% gewijzigd door Ontspannen op 11-12-2007 03:25 ]

[riezebosch]

C#:

List<int> list = new List<int>();

offtopic:
Flauw, maar generics zijn (bijna) altijd superhanding

[Janoz]

Euhm, wat is er mis met:

C#:

public class Class1
{
    int[] a;
    public Class1()
    {
          //allerlei gedoe waardoor je weet dat het nu 2 is
          a  = new int[2];
    }
}

[Piels]

Lijkt mij niets mis mee.

Alleen defineer je een vaste array van grote 2.

Generics geeft je gewoon een stukje type safety, thats all.
Dus als je een array van ints defineerd, krijg je een fout als je een string in de array probeert te schrijven.

C#:

List<int> intList = new List<int>();
intList.Add(1); // Ok
intList.Add("blaat"); // Error

Dat is het grote voordeel van Generics

[whoami]

Als jij een string in een array van int's steekt, ga je evengoed een compiler error krijgen dan als je een string aan een List<int> toevoegd.

Of je nu een array of een List moet gebruiken, is gewoon afhankelijk van geval tot geval, en wordt bepaald door wat je precies wilt doen.

Als de topicstarter op één of andere manier kan weten hoeveel elementen z'n array moet kunnen bevatten op moment dat hij z'n array creeërt, en die array moet niet meer groeien achteraf, dan kan je een array gebruiken.

[ Voor 27% gewijzigd door whoami op 11-12-2007 10:23 ]

[Janoz]

Piels schreef op dinsdag 11 december 2007 @ 10:18:
Lijkt mij niets mis mee.

Alleen defineer je een vaste array van grote 2.

Ik ken generics, en het voordeel in dit voorbeeld is niet de typesafety, wat je met generics hebt, maar het meegroeien van de List en dat is in dit voorbeeld misschien wel helemaal niet nodig.

De vraag in de topicstart was echter hoe je een normale array initialiseerd wanneer je de grootte pas weet op het moment van het initialiseren van de class.


[edit] Even verduidelijkt..

[ Voor 8% gewijzigd door Janoz op 11-12-2007 10:39 ]

[Verwijderd]

Dus dit werkt dan wel?

code:

public class Class1 
{ 
    int[] a; 
    public Class1() 
    { 
          //allerlei gedoe waardoor je weet dat het nu 2 is 
          a  = new int[2]; 
          a[0] = "TEST";

    } 
}

[Verwijderd]

niet dus :-)

[Piels]

Janoz schreef op dinsdag 11 december 2007 @ 10:27:
[...]

Ik ken generics, en het grote voordeel in deze is niet de typesafety, maar het meegroeien.

Generics are a new feature in version 2.0 of the C# language and the common language runtime (CLR). Generics introduce to the .NET Framework the concept of type parameters, which make it possible to design classes and methods that defer the specification of one or more types until the class or method is declared and instantiated by client code. For example, by using a generic type parameter T you can write a single class that other client code can use without incurring the cost or risk of runtime casts or boxing operations.

Het laten meegroeien van een Arraylist / List is echt geen eigenschap van een generic. Puur het type safe gebeuren is generics

[Janoz]

@piels: Had het wat onduidelijk omschreven. Met 'deze' bedoelde ik niet generics, maar het probleem van de TS. Een normale array heeft ook al typesafety dus dat is niet een extra voordeel. Het voordeel van het gebruiken van een List is het meegroeien en dat is inderdaad geen eigenschap van generics. Ik had mijn posting al wat aangepast.

[Verwijderd]

Idd, dankzij generics voorkom je runtime fouten veroorzaakt door int i = (int) obj casts enzo...
Ze leveren je dus compile-time type safety

[Janoz]

en dat is anders met een int[] want?

[riezebosch]

Het voordeel van een ICollection is dat hij automatisch mee kan groeien, en van een generic implementatie dat ie ook nog is typesafe is

[Woy]

riezebosch schreef op dinsdag 11 december 2007 @ 10:46:
Het voordeel van een ICollection is dat hij automatisch mee kan groeien, en van een generic implementatie dat ie ook nog is typesafe is

offtopic:
De ICollection interface zegt niks over het kunnen meegroeien , dat is de IList interface ( die wel weer inherit van ICollection ) die wel een Add methode defineert

[ Voor 4% gewijzigd door Woy op 11-12-2007 16:41 ]

[voodooless]

Misschien is het wel helemaal geen voordeel dat iets mee kan groeien... misschien wil je wel niet dat het ding kleiner wordt als je er een element uit haalt.. misschien... misschien...

Kortom: op ieder potje past een dekseltje, en zijn er voor een ouderwetse array ook gewoon nuttige toepassingen. 'T is maar net wat je ermee wil.

[/\/\|)]

voodooless schreef op dinsdag 11 december 2007 @ 16:46:
Misschien is het wel helemaal geen voordeel dat iets mee kan groeien... misschien wil je wel niet dat het ding kleiner wordt als je er een element uit haalt.. misschien... misschien...

Kortom: op ieder potje past een dekseltje, en zijn er voor een ouderwetse array ook gewoon nuttige toepassingen. 'T is maar net wat je ermee wil.

Precies, niet in de laatste plaats uit performance oogpunt.

[whoami]

Ik denk dat het qua performance eigenlijk best zal meevallen. Een (Array)List zal achter de schermen ook een array gaan gebruiken, en als je goed gebruik maakt van de Capacity bij het initializeren, denk ik niet dat je een beduidende performance-hit zult krijgen.
Dit zou je eens moeten benchmarken natuurlijk.

Maar, zoals ik al eerder vermelde, en zoals voodooless ook al zegt: 't hangt er van af wat je wilt doen en of je bepaalde functionaliteit nodig hebt of wilt exposen.