.NET Framework
Aangepaste typen

Opmerkingen

Struct Definitie

Structs erven van System.ValueType, zijn waardetypes en leven op de stapel. Wanneer waardetypes als parameter worden doorgegeven, worden ze door waarde doorgegeven.

Struct MyStruct
{
    public int x;
    public int y;
}

Doorgegeven door waarde betekent dat de waarde van de parameter wordt gekopieerd voor de methode en dat wijzigingen in de parameter in de methode niet worden doorgevoerd buiten de methode. Beschouw bijvoorbeeld de volgende code, die een methode met de naam AddNumbers , waarbij de variabelen a en b worden doorgegeven, die van het type int , wat een AddNumbers is.

int a = 5;
int b = 6;

AddNumbers(a,b);

public AddNumbers(int x, int y)
{
    int z = x + y; // z becomes 11
    x = x + 5; // now we changed x to be 10
    z = x + y; // now z becomes 16
} 

Hoewel we 5 toegevoegd aan x in de methode, de waarde van a ongewijzigd blijft, want het is een Value-type, en dat betekent x was een kopie van a S-waarde', maar niet echt a .

Vergeet niet dat waardetypen op de stapel staan en worden doorgegeven door waarde.

Klasse definitie

Klassen erven van System.Object, zijn referentietypes en leven op de heap. Wanneer referentietypen als parameter worden doorgegeven, worden ze doorgegeven als referentie.

public Class MyClass
{
    public int a;
    public int b;
}

Doorgegeven door verwijzing betekent dat een verwijzing naar de parameter wordt doorgegeven aan de methode en dat wijzigingen in de parameter worden weerspiegeld buiten de methode wanneer deze wordt geretourneerd, omdat de verwijzing naar exact hetzelfde object in het geheugen is . Laten we hetzelfde voorbeeld als hiervoor gebruiken, maar we zullen de int 's eerst in een klasse "verpakken".

MyClass instanceOfMyClass = new MyClass();
instanceOfMyClass.a = 5;
instanceOfMyClass.b = 6;

AddNumbers(instanceOfMyClass);

public AddNumbers(MyClass sample)
{
    int z = sample.a + sample.b; // z becomes 11
    sample.a = sample.a + 5; // now we changed a to be 10
    z = sample.a + sample.b; // now z becomes 16
} 

Deze keer, toen we sample.a in 10 veranderden, verandert ook de waarde van instanceOfMyClass.a , omdat deze door verwijzing werd doorgegeven . Doorgegeven door verwijzing betekent dat een verwijzing (ook wel een pointer genoemd ) naar het object in de methode is doorgegeven, in plaats van een kopie van het object zelf.

Vergeet niet dat referentietypes op de heap leven en worden doorgegeven via referentie.

Enum-definitie

Een opsomming is een speciaal soort klasse. Het enum sleutelwoord vertelt de compiler dat deze klasse overneemt van de abstracte klasse System.Enum. Enums worden gebruikt voor afzonderlijke lijsten met items.

public enum MyEnum
{
    Monday = 1,
    Tuesday,
    Wednesday,
    //...
}

Je kunt een opsomming beschouwen als een handige manier om constanten toe te wijzen aan een onderliggende waarde. Het hierboven gedefinieerde getal geeft waarden aan voor elke dag van de week en begint met 1 . Tuesday wordt dan automatisch toegewezen aan 2 , Wednesday aan 3 , enz.

Standaard gebruikt enums int als het onderliggende type en begint bij 0, maar u kunt een van de volgende integraaltypen gebruiken : byte, sbyte, short, ushort, int, uint, long, or ulong en kunnen expliciete waarden opgeven voor elke item. Als sommige items expliciet zijn opgegeven, maar andere niet, wordt elk item na het laatst gedefinieerde item met 1 verhoogd.

We zouden dit voorbeeld te gebruiken door het gieten van een andere waarde aan een MyEnum als volgt:

MyEnum instance = (MyEnum)3; // the variable named 'instance' gets a 
                             //value of MyEnum.Wednesday, which maps to 3.

int x = 2;
instance = (MyEnum)x; // now 'instance' has a value of MyEnum.Tuesday

Een ander handig, hoewel complexer type type wordt Flags . Door een opsomming te decoreren met het kenmerk Flags , kunt u een variabele meerdere waarden tegelijk toewijzen. Merk op dat u hierbij expliciet waarden in base 2-weergave moet definiëren.

[Flags]
public enum MyEnum
{
    Monday = 1,
    Tuesday = 2,
    Wednesday = 4,
    Thursday = 8,
    Friday = 16,
    Saturday = 32, 
    Sunday = 64
}

U kunt nu meer dan één waarde tegelijk vergelijken, met behulp van bitgewijze vergelijkingen of, als u .NET 4.0 of hoger gebruikt, de ingebouwde Enum.HasFlag methode.

MyEnum instance = MyEnum.Monday | MyEnum.Thursday; // instance now has a value of
                                                   // *both* Monday and Thursday,
                                                   // represented by (in binary) 0100. 

if (instance.HasFlag(MyEnum.Wednesday))
{
    // it doesn't, so this block is skipped
}
else if (instance.HasFlag(MyEnum.Thursday))
{
    // it does, so this block is executed
}

Aangezien de Enum-klasse een subklasse is van System.ValueType , wordt deze behandeld als een waardetype en doorgegeven door waarde, niet door verwijzing. Het basisobject wordt op de heap gemaakt, maar wanneer u een opsommingswaarde doorgeeft aan een functieaanroep, wordt een kopie van de waarde met het onderliggende waardetype van de Enum (meestal System.Int32) op de stapel geplaatst. De compiler volgt de associatie tussen deze waarde en het basisobject dat op de stapel is gemaakt. Zie ValueType Class (System) (MSDN) voor meer informatie.