Gemeenschappelijk Type Systeem - Common Type System

In Microsoft's .NET Framework , de Common Type System ( CTS ) is een standaard die specificeert hoe soort definities en specifieke waarden van soorten zijn vertegenwoordigd in het computergeheugen. Het is bedoeld om programma's die in verschillende programmeertalen zijn geschreven, gemakkelijk informatie te laten delen. Zoals gebruikt in programmeertalen , kan een type worden beschreven als een definitie van een reeks waarden (bijvoorbeeld "alle gehele getallen tussen 0 en 10") en de toegestane bewerkingen op die waarden (bijvoorbeeld optellen en aftrekken).

De specificatie voor de CTS is opgenomen in Ecma- standaard 335, "Common Language Infrastructure (CLI) Partitions I tot VI." De CLI en de CTS zijn gemaakt door Microsoft en het Microsoft .NET-framework is een implementatie van de standaard.

Functies van het Common Type-systeem

  • Een raamwerk opzetten dat helpt bij het mogelijk maken van meertalige integratie, typeveiligheid en hoogwaardige code-uitvoering.
  • Een objectgeoriënteerd model bieden dat de volledige implementatie van vele programmeertalen ondersteunt.
  • Om regels te definiëren waaraan talen moeten voldoen, wat ervoor zorgt dat objecten die in verschillende talen zijn geschreven, met elkaar kunnen communiceren.
  • De CTS definieert ook de regels die ervoor zorgen dat de gegevenstypen van objecten die in verschillende talen zijn geschreven, met elkaar kunnen communiceren.
  • De CTS specificeert ook de regels voor typezichtbaarheid en toegang tot de leden van een type, dwz de CTS stelt de regels vast waarmee assemblies de scope voor een type vormen, en de Common Language Runtime dwingt de zichtbaarheidsregels af.
  • De CTS definieert de regels voor type-overerving , virtuele methoden en de levensduur van objecten.
  • Talen die door .NET worden ondersteund, kunnen alle of enkele veelvoorkomende gegevenstypen implementeren...

Bij het afronden van fractionele waarden wordt in het hele Framework standaard de halverwege-naar-even ("banker's") methode gebruikt. Sinds versie 2 is "Symmetric Arithmetic Rounding" (helften van nul afronden) ook beschikbaar via de optie van de programmeur.

  • het wordt gebruikt om met andere talen te communiceren

Typ categorieën

Het gemeenschappelijke typesysteem ondersteunt twee algemene typen typen:

Waardetypes
Waardetypen bevatten rechtstreeks hun gegevens en instanties van waardetypen worden ofwel op de stapel toegewezen of inline in een structuur toegewezen. Waardetypen kunnen worden ingebouwd (geïmplementeerd door de runtime), door de gebruiker gedefinieerd of opgesomd.
Referentietypen
Referentietypen slaan een verwijzing op naar het geheugenadres van de waarde en worden op de heap toegewezen . Referentietypen kunnen zelfbeschrijvende typen, aanwijzertypen of interfacetypen zijn. Het type van een referentietype kan worden bepaald uit waarden van zelfbeschrijvende typen. Zelfbeschrijvende typen worden verder opgesplitst in arrays en klassentypen. De klassetypen zijn door de gebruiker gedefinieerde klassen, ingekapselde waardetypen en gedelegeerden.

Het volgende voorbeeld geschreven in Visual Basic .NET toont het verschil tussen referentietypen en waardetypen: 

Imports System

Class Class1
    Public Value As Integer = 0
End Class 'Class1
 
Class Test
    Shared Sub Main()
        Dim val1 As Integer = 0
        Dim val2 As Integer = val1
        val2 = 123
        Dim ref1 As New Class1()
        Dim ref2 As Class1 = ref1
        ref2.Value = 123
        Console.WriteLine("Values: {0}, {1}", val1, val2)
        Console.WriteLine("Refs: {0}, {1}", ref1.Value, ref2.Value)
    End Sub 'Main
End Class 'Test

De output van het bovenstaande voorbeeld 

Values: 0, 123
Refs: 123, 123

Boksen en unboxen

Boksen

Het omzetten van waardetypen naar referentietypes wordt ook wel boksen genoemd . Zoals te zien is in het onderstaande voorbeeld, is het niet nodig om de compiler te vertellen dat een Int32 om een ​​object heen zit, omdat deze dit zelf doet. 

Int32 x = 10; 
object o = x ; // Implicit boxing
Console.WriteLine("The Object o = {0}",o); // prints out "The Object o = 10"

Een Int32 kan echter altijd expliciet als volgt worden ingesloten: 

Int32 x = 10; 
object o = (object) x; // Explicit boxing
Console.WriteLine("The object o = {0}",o); // prints out "The object o = 10"

Uitpakken

Het volgende voorbeeld is bedoeld om te laten zien hoe u een verwijzingstype kunt uitpakken naar een waardetype. Eerst wordt een Int32 in een doos geplaatst om een ​​object, en dan wordt het weer uitgepakt. Merk op dat unboxing expliciete cast vereist. 

Int32 x = 5; 
object o1 = x; // Implicit Boxing
x = (int)o1; // Explicit Unboxing

Zie ook

Referenties

Externe links