Tijdens het programmeren komt het voor dat je twee variabelen wilt omwisselen. Soms omdat je twee punten wilt omdraaien of vanwege een sortering, of om altijd een lagere hoogte onderaan te krijgen, noem maar op. Normaal gesproken gebruik je dan zoiets:

var temp = a;
a = b;
b = temp;

Eerst wijs je de waarde van a toe aan een tijdelijke nieuwe variabele, en dan kun je a en b een andere waarde geven. Als je geen tijdelijke waarde zou gebruiken dan zou na de toewijzing ‘a=b’ de beide variabelen dezelfde waarde hebben, want ‘b=a’ zou dan hetzelfde zijn als ‘b=b’.

Kan dit eenvoudiger? Zonder tijdelijke variabelen? Ook al kost het nagenoeg geen resources, het staat gewoon lelijk in de code. Een beetje programmeur krijgt al trillingen in het ooglid als hij één rode Smartie in een bak vol blauwe ziet liggen, dus die ene tijdelijke, zinloze variabele blijft zijn oogballen prikkelen. Daar valt niet omheen te kijken. Zelfs bij het runnen van zijn applicatie zullen zijn gedachten nog steeds bij die ene variabele blijven hangen.

Tuples

Dit is gelukkig te verhelpen door een Tuple te gebruiken. Een Tuple is een soort van container die meerdere waarden of objecten kan bevatten. Het wordt niet veel gebruikt en de werking ervan is een beetje vaag. Maar het kan best handig zijn. De syntax van een Tuple is:

(o1, o2, ...)

Je kunt een Tuple maken door direct een waarde in te voeren of een variabele, zoals:

(a, b)

In dit geval een combinatie van variabelen ‘a’ en ‘b’.

Om de waarde om te wisselen, kun je het volgende doen.

(a, b) = (b, a)

En voilà, nu is ‘a’ ‘b’ geworden en ‘b’ is nu ‘a’. Dit moet uiteraard bewezen worden, anders is het niet waar.

Even een testje, binnen een AutoCAD omgeving, waarbij ik punt 1 wil omwisselen met punt 2. Zoals te zien is, is de waarde van punt 1 na de omwisseling veranderd in de waarde van punt 2.

Nu zijn Point3d objecten Structures, en dat zijn Value Types in .NET. Een Value Type is een object dat direct zijn eigen waarde bevat. Er zijn ook Reference Types, die verwijzen naar een stukje geheugen dat vervolgens verwijst naar het daadwerkelijke object. Een Polyline is daar een voorbeeld van. Zou je twee Polylines hebben en je verwijst de eerste Reference naar de tweede, dan blijven ze allebei altijd naar dezelfde Polyline verwijzen, ook als je later één van beide naar een ander object laat verwijzen.

De vraag is dus, werkt het ook bij Reference Types?

Polyline 1 heeft inderdaad de eigenschappen van Polyline 2 gekregen.

En Polyline 2 ook andersom. Het werken met Tuples is hier inderdaad de oplossing. Handig hé? En het doet nu ook geen pijn meer aan de oogballen.

Altijd al plug-ins willen maken voor AutoCAD? Dan is dit het boek dat je nodig hebt om dat te leren. Het helpt je om plug-ins te ontwikkelen in de .NET taal C# met behulp van Visual Studio. This book is only available in English.