OV-chipkaart perikelen

Door Luuk1983 op woensdag 17 augustus 2011 16:20 - Reacties (43)
Categorie: Overige toelie, Views: 9.560

De OV-chipkaart. Iedereen heeft het er wel over gehad. Lek, onhandig en duur zijn veelgebruikte woorden. Maar wat merk je daar zelf van in de praktijk? Ik deze blog mijn ervaring met de OV-chipkaart.

Ik ben nooit echt heel negatief geweest over de OV-chipkaart. Natuurlijk waren er problemen, natuurlijk werd het project veel te duur en natuurlijk was de beveiliging zo lek als een mandje, maar eerlijk is eerlijk: direct merk ik daar als consument weinig van. Ik ben al jaren geleden afgestudeerd, dus de problemen met het activeren van de OV-studentenkaarten heb niet bewust meegemaakt. Ik zag wel hele duidelijke voordelen die zo'n kaart zou kunnen bieden. Wel moet ik er even bij vermelden dat ik voornamelijk met de trein reis, met bussen en trams heb ik beperkte ervaring.

Enfin, om een lang verhaal kort te maken. Op een dag besloot ik dat het wel handig zou zijn om een anonieme OV-chipkaart aan te schaffen. Ik ging wat regelmatiger met de trein en ik vond het handig als ik niet in de rij voor de automaten zou moeten gaan staan.
Het aanschaffen van een anonieme OV-chipkaart kan gewoon bij de automaat en is net zo simpel als het aanschaffen van een kaartje. Ook wat geld op de kaart zetten ging zonder problemen. Eigenlijk best simpel dus allemaal. Totdat je bij het incheckpaaltje komt...

De incheckpaaltjes kunnen twee geluiden maken: een dubbele, subtiele zachte piep in combinatie met een groen lampje en bevestiging van je inchecken, of een hele harde, schelle piep die niet zou misstaan als je illegaal door de alarmpoortjes van een dure kledingzaak loopt met een aanzienlijk deel van de nieuwe collectie. oh ja, en er hoort ook nog een rood lampje bij. Mag je één keer raden... Juist, het rode lampje. Maar verder geen melding van wat er nou precies fout is en waarom het inchecken niet werkt. Volgens mij geeft de gemiddelde Windows foutmelding onderhand meer uitleg over wat er aan de hand is. En je verwacht het niet, maar ook de tweede en derde keer lukte het niet. Van ellende ben ik maar een kaartje uit de automaat gaan halen, omdat ik anders de trein zou missen.

Eenmaal op de bestemming aangekomen had ik wat meer tijd om even bij de automaat te gaan rotzooien met de kaart. Ik moest zelf uitzoeken dat:
  • Je reizen op saldo bij de NS moet activeren
  • Je minimaal 20 euro op de kaart moet hebben staan om überhaupt in te kunnen checken
Nou zijn beide problemen heel simpel om op te lossen en ergens is het minimale saldo van 20 euro goed te begrijpen, maar dat moeten activeren van reizen op saldo bij NS komt nogal vreemd over. Mijn oma zal daar maar gestaan hebben. Of een buitenlandse bezoeker. Het is toch één kaart voor bus, trein en metro? Ijdele hoop...

Maar goed, sindsdien gebruik ik de kaart eigenlijk zonder problemen. Inchecken lukt altijd, saldo opladen lukt altijd. En toen ik een weekendje in Den Haag was (en mijn vriendin ten huwelijk gevraagd heb O-)) bleek de OV-chipkaart prima in de trams te werken. Het enige waarvan ik me afvroeg hoe je dat zou moeten doen is het volgende:
Stel, je hebt iemand met een OV-studentenkaart of iemand met een voordeelurenabonnement, dan mogen er een paar andere mensen op meereizen met korting. Echter, dit kan je alleen bereiken door een kaartje met 40% korting te kopen. Er is geen manier om in te checken met de korting van een ander. Ik zou ook niet weten hoe je dat moet oplossen, maar handig is anders.

Nou wil het zo zijn dat mijn vriendin ergens anders gaat werken en daardoor full-time de auto nodig heeft. Ja, ondergetekende is lief voor z'n meisje en offert zich op en laat haar de auto meenemen. Aangezien ik makkelijk met de trein naar het werk kan, is het zonde om een tweede auto aan te schaffen. Dus wat bedenk je als nuchtere Hollandse tweakert? Dat je een persoonlijke OV-chipkaart gaat halen, daar een maandtrajectkaart op gaat zetten en dat je je anonieme OV-chipkaart gaat verpatsen aan je ouders of schoonouders. En zoals wel vaker klopt de theorie niet bij de praktijk. Even een korte samenvatting van de abonnementen van de NS. De bedenker van de NS-systemen moet in ieder geval een IQ van onder die van zanger Rinus hebben gehad om dit überhaupt te kunnen verzinnen:
  • Een voordeelurenabonnement kan op een 'gewone' persoonlijke OV-chipkaart. Hiermee kan je bij de NS en andere aanbieders op Saldo reizen en krijg je korting buiten de spits bij de NS. Niet interessant voor mij in ieder geval, want ik reis in de spits.
  • Zodra je een ander abonnement hebt worden deze meestal (met uitzondering van maandabonnementen) standaard op een persoonlijke OV-chipkaart geleverd. Zodra er een abonnement op de kaart staan kan je NIET MEER OP SALDO REIZEN met de betreffende kaart bij de NS. Uh...whut? Nou, zodra er een abonnement op de kaart staan kan je NIET MEER OP SALDO REIZEN met de betreffende kaart bij de NS. Maar je kan wel op saldo reizen bij de andere aanbieders. Een quote:
    Ook andere NS-abonnementen - met uitzondering van het Maandabonnement - worden standaard op een OV-chipkaart geleverd. U ziet het aan het OV-chipkaartlogo op de kaart. Het is nu nog niet mogelijk om met deze abonnementen bij NS op saldo te reizen. U blijft dus reizen zoals u gewend bent. Zodra er iets verandert, krijgt u bericht. U kunt met uw OV-chipkaart met NS-abonnement wel bij andere vervoerders op saldo reizen.
    8)7 8)7 8)7 8)7 8)7
Ik in mijn oneindige onschuldigheid dacht toch echt dat het hele idee van de OV-chipkaart was dat je één kaart hebt waar je abonnementen aan kan toevoegen en verwijderen. Bij de NS in ieder geval niet. En er klopt wel meer niet bij de NS. Als je bijvoorbeeld in Nijmegen van de NS-trein overstapt op een Veolia-trein moet je eerst uitchecken bij de NS en inchecken bij Veolia. En als je student bent kan je je 'OV-studentenabonnement' niet op een OV-chipkaart zetten waar al een ander product op staat. En ga zo maar door.

De conclusie lijkt me duidelijk. Bij de NS werkt het hele OV-gebeuren voor geen ene meter. Het instaptarief is vrij hoog met 20 euro, maar dit is nog te begrijpen. En zolang je af en toe met de trein gaat is het handig dat je je niet druk hoeft te maken dat je mogelijk bij de automaat in de rij moet staan. Als je daarbij je saldo gewoon netjes in de gaten houdt en op tijd oplaadt, dan is er weinig aan de hand.
Zodra je ook maar iets meer wil dan dat, dan wordt het onoverzichtelijk, onduidelijk en soms zelf onmogelijk. Laten we het bij de trein gewoon lekker bij kaartjes houden. Dat is waarschijnlijk nog een stuk goedkoper ook.

Bij de metro, bus en tram lijkt de OV-chipkaart meer potentie te hebben. Door de lagere instaptarieven en relatief kleine bedragen is het handig dat je niet met kleingeld hoeft te klooien. Maar er is voorlopig in ieder geval nog geen enkele sprake van één kaart voor bus, trein, tram en metro.

Edit: Nog een mooi artikel over de 'logica' van de OV-chipkaart: http://frontpage.fok.nl/n...korting-vaak-duurder.html

.NET Features: question mark

Door Luuk1983 op donderdag 23 juni 2011 09:03 - Reacties (11)
Categorie: Programmeren, Views: 5.022

Als .NET-programmeur merk ik regelmatig dat andere programmeurs niet op de hoogte zijn van sommige handige en slimme features in het .NET framework die het programmeren een stuk makkelijker kunnen maken. Soms zijn deze features verstopt, of soms zijn ze pas nieuw, maar handig zijn ze altijd. Dit is deel 4 van een serie met kleine voorbeelden van features die je als .NET-programmeur (met name in C#) mogelijk nog niet kent. Deze keer: het vraagteken in C#.

Met het vraagteken kan je in C# een hoop dingen doen. Ik zal een aantal voorbeelden geven van toepassingen van het vraagteken.

Ten eerste kan je het vraagteken gebruiken om objecten die dat standaard niet zijn nullable te maken. Nullable houdt in dat er een null waarde toegekend kan worden. De toepassing hiervan is redelijk beperkt omdat objecten die afstammen van de Object class al nullable zijn, maar dingen zoals een int of bool zijn dat standaard niet.
C#:
1
2
3
4
//This doesn't work
int aNotNullableInt = null;
//This is OK
int? aNullableInt = null;

Je kan nu met .HasValue en .Value controleren of het object null is of niet en wat de waarde dan is.
C#:
1
2
3
4
5
6
7
8
9
object foo;
//The long version
if (aNullableInt.HasValue)
    foo = DoSomething(aNullableInt.Value);
else
    foo = DoSomething(-1);

//The short version that does the same thing
object foo = (aNullableInt.HasValue) ? DoSomething(aNullableInt.Value) : DoSomething(-1);

Als de conditie voor het vraagteken true is zal de code direct achter het vraagteken uitgevoerd worden. Als de conditie false is zal de code direct achter de dubbele punt uitgevoerd worden.

Al laatste is er een constructie met een dubbel vraagteken. Waar de constructie hierboven bedoeld is om middels een conditie optie A of B te laten uitvoeren, is de dubbele vraagteken constructie bedoeld om een alternatieve optie te geven in het geval dat een object null is:
C#:
1
2
3
4
5
6
7
8
9
//This is the long version
object newObject;
if (foo != null)
    newObject = foo;
else
    newObject = new object();

//This is the short version that does the same thing
object newObject = foo ?? new object();

In het geval dat 'foo' null is zal de waarde achter de ?? toegekend worden aan newObject.

Wederom hoop ik dat jullie er wat aan hebben. En wederom zijn suggesties altijd welkom.

.NET Features: Object Initializer

Door Luuk1983 op woensdag 22 juni 2011 11:20 - Reacties (11)
Categorie: Programmeren, Views: 3.249

Als .NET-programmeur merk ik regelmatig dat andere programmeurs niet op de hoogte zijn van sommige handige en slimme features in het .NET framework die het programmeren een stuk makkelijker kunnen maken. Soms zijn deze features verstopt, of soms zijn ze pas nieuw, maar handig zijn ze altijd. Dit is deel 3 van een serie met kleine voorbeelden van features die je als .NET-programmeur (met name in C#) mogelijk nog niet kent. Deze keer: Object initializers in C#.

Ik zie nog veel programmeurs hun classes en bijbehorende properties op de volgende manier declareren:
C#:
1
2
3
var foo = new Foo();
foo.ABoolean = true;
foo.AnIntegerValue = 1;

Dit is natuurlijk niet fout, maar het kan ook anders. Je kan het aanmaken van het object combineren met het zetten van de waardes. Dit heeft als voordeel dat je code (mogelijk) beter leesbaar wordt. Zeker als er maar weinig properties gezet hoeven te worden kan de object initialisatie plus het zetten van de properties op één regel.
C#:
1
var foo = new Foo {ABoolean = true, AnIntegerValue = 1};

Naar mijn mening verhoogt dit de leesbaarheid van de code. De functionaliteit is toegevoegd vanaf C#3.0 en is te gebruiken vanaf .NET3.5.

.NET Features: auto properties

Door Luuk1983 op dinsdag 21 juni 2011 14:44 - Reacties (9)
Categorie: Programmeren, Views: 3.163

Als .NET-programmeur merk ik regelmatig dat andere programmeurs niet op de hoogte zijn van sommige handige en slimme features in het .NET framework die het programmeren een stuk makkelijker kunnen maken. Soms zijn deze features verstopt, of soms zijn ze pas nieuw, maar handig zijn ze altijd. Dit is deel 2 van een serie met kleine voorbeelden van features die je als .NET-programmeur (met name in C#) mogelijk nog niet kent. Deze keer: auto properties in C#.

In het algemeen is het goed gebruik dat als je variabelen wilt ontsluiten gebruik te maken van public properties (naast functions natuurlijk) en geen public variabelen. Het was altijd veel werk om publieke properties te maken, omdat je dan altijd een achterliggende private variabele moest declareren om de waarde in vast te houden. Hoewel je met de refactor optie van Visual Studio niet alles helemaal zelf hoefde uit te typen, was het toch omslachtig.

Dit hoeft sinds .NET3.5/Visual Studio 2008 niet meer. Dit geldt overigens alleen voor 'simpele' properties waar je alleen een waarde aan wil kunnen toekennen en uitlezen. Als je meer dan dat wilt, dan gaat onderstaand verhaal niet op.

Voorheen moest je properties zo declareren:
C#:
1
2
3
4
5
6
7
8
9
10
public class Foo
{
    private int _anIntegerValue;

    public int AnIntegerValue
    {
        get { return _anIntegerValue; }
        set { _anIntegerValue = value; }
    }
}

Sinds .NET3.5/Visual Studio 2008 kan het veel korter:
C#:
1
2
3
4
public class Foo
{
    public int AnIntegerValue { get; set; }
}

Je hoeft niet perse meer een achterliggende private variabele aan te maken, dat gebeurt automatisch.

Overigens kan je de get en set nog steeds andere access-modifiers geven:
C#:
1
2
3
4
public class Foo
{
    public int AnIntegerValue { get; private set; }
}

(dank CyCloneNL voor de toevoeging)

Je mag niet alleen de get of de set expliciet implementeren en de ander impliciet. Dit kan dus niet:
C#:
1
2
3
4
5
6
7
8
9
10
public class Foo
{
    private int _anIntegerValue;

    public int AnIntegerValue
    {
        get;
        set { _anIntegerValue = value; }
    }
}


Maar nogmaals: dit verhaal geldt alleen voor 'simpele' properties, als je meer wilt dan een waarde opslaan en ophalen, dan heb je meer nodig dan bovenstaand verhaal.

Hopelijk hebben jullie er wat aan! Suggesties zijn altijd welkom.

.NET features: Optional Parameters

Door Luuk1983 op maandag 20 juni 2011 08:36 - Reacties (23)
Categorie: Programmeren, Views: 2.920

Als .NET-programmeur merk ik regelmatig dat andere programmeurs niet op de hoogte zijn van sommige handige en slimme features in het .NET framework die het programmeren een stuk makkelijker kunnen maken. Soms zijn deze features verstopt, of soms zijn ze pas nieuw, maar handig zijn ze altijd. Dit is deel 1 van een serie met kleine voorbeelden van features die je als .NET-programmeur (met name in C#) mogelijk nog niet kent. Deze keer: optional parameters in C#.

Optional Parameters zijn nieuw in .NET 4.0 voor C# en kunnen gebruikt worden om één functie met meerdere signatures te maken in plaats van meerdere overloaded functies. Deze functionaliteit is al langer beschikbaar in VB.NET. Een simpel voorbeeld van een paar overloaded functies:

C#:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public void DoSomething()
{
    DoSomething(false, false);
}

public void DoSomething(bool bool1)
{
    DoSomething(bool1, false);
}

public void DoSomething(bool bool1, bool bool2)
{
    //Here code that does something
}


In .NET 4.0 kan dit samengevoegd worden tot één functie door middel van optional parameters. Je geeft dan aan welke properties optioneel zijn, waarna je ze niet perse hoeft in te vullen. Let wel op dat de optionele parameters altijd achteraan moeten komen te staan.

Je maakt parameters optioneel door ze een default waarde te geven:

C#:
1
2
3
4
public void DoSomething(bool bool1 = false, bool bool2 = false)
{
    //Here code that does something
}


Op dit moment zijn de volgende aanroepen naar bovenstaande functie geldig:

C#:
1
2
3
DoSomething();
DoSomething(false);
DoSomething(false,false);


Zoals je ziet zijn de drie overloaded functies aan het begin van deze blog nu vervangen door één functie met optionele parameters. Er is echter ook nog een belangrijk voordeel aan het gebruik van optional parameters: je hoeft niet perse alle optionele parameters in te vullen. Zo kan je in bovenstaand voorbeeld er ook voor kiezen om alleen de tweede parameter in te vullen en de eerste de default waarde te laten behouden:

C#:
1
DoSomething(bool2: true);


bool1 zal in dit geval zijn default waarde van false behouden en wordt alleen bool2 expliciet ingevuld.

Ik hoop dat jullie er wat aan hebben, of mochten er mensen zijn die nog wat aanvullingen hebben, dan hoor ik het graag.