[ASP] Wat is sneller? rs(0) of rs("id")

[akakiwi]

Hallo allemaal,

Ik heb een klein probleempje.
Wat is sneller in mijn ASP code.

ASP.NET Visual Basic:

iId = cint(rs(0))

of

ASP.NET Visual Basic:

iId = cint(rs("Id"))

Ik las namelijk een tijdje geleden ergens dat de eerste aanroep !!trager!! is dan de tweede, terwijl ik eigenlijk dacht dat rechtstreeks een aanroep naar een index (rs(0)) sneller is dan de aanroep van een alias (rs("Id"))

Ik krijg over dit onderwerp niet veel zinnigs gevonden op het grote internet, maar misschien weten jullie hier een helder lichtje op te schijnen.

[gorgi_19]

1e is sneller, aangezien er geen index hoeft opgevraagd te worden, alleen als je hier je snelheidswinst uit moet halen...

[akakiwi]

Snelheidswinst hoeft hier gelukkig niet uit gehaald te worden.
Anders zou ik wel erg sneu aan het programmeren zijn.

[whoami]

De eerste is sneller, de tweede is onderhoudbaarder en leesbaarder.

Aangezien -zoals gorgi_19 al zegt- de naam niet moet opgezocht worden, en gemapped worden naar de index, gaat dat al sneller.

Je moet het anders maar eens testen. Schrijf eens een iteratie die een aantal 1000x een recordset uitleest op de eerste, en een aantal 1000x op de 2de manier, en time dat.

[gorgi_19]

akakiwi schreef op 08 July 2003 @ 15:24:
Snelheidswinst hoeft hier gelukkig niet uit gehaald te worden.
Anders zou ik wel erg sneu aan het programmeren zijn.

Anders gezegd, voor de duidelijkheid zou ik optie 2 kiezen, zeker gezien de marginale snelheidswinst van optie 1. Ik vraag me zelfs af of dit met een relatief kleine iteratie meetbaar is, het verschil.

[ Voor 12% gewijzigd door gorgi_19 op 08-07-2003 15:28 ]

[mOrPhie]

Hoewel de ene of de andere optie echt geen enorme snelheidswinsten gaat halen, zou je de leesbaarheid ook nog kunnen oplossen met een const:

ASP:

const ID = 0

iId = cint(rs(ID))

Die zal qua snelheid (hoe insignificant ook), tussen de eerste en de tweede optie van de TS'er liggen, denk ik.

[akakiwi]

We gebruiken optie 2 voor de gehele tool.
Nu had ik dus een tijdje geleden gelezen dat het 85% scheelde in tijd tussen beide aanroepen, in het nadeel van de eerste aanroep, wat ik niet kon geloven.
Nu zag ik net dat een collega programmeur hier op 1 plek optie 1 gebruikte en ik kwam er geen wijs uit.
whoami en gorgi_19 wat jullie dus zeiden over de duidelijkheid.

Ben blij dat jullie mijn vermoedens bevestigen dat de eerste sneller is.

BTW. We gaan gewoon lekker verder met het aanroepen van rs("Id") e.d.

Bedankt.

[mulder]

Roep dan rs.Fields("Id") aan.

[BasSpruit]

als je wel een echte snelheidswinst wilt behalen raad ik aan om getRows() te gebruiken (100%+ snelheidswinst heb ik gemeten). nadeel is dat je zonder de namen van de kolommen moet werken. (ikzelf zet altijd een extra comment in me code waar alle veldnamen in staan)

[-FoX-]

Als het puur om de snelheidswinst zou gaan, zou ik je toch aanraden om achter andere stukken code te zoeken, waar de snelheid significanter is.

rs(0) is natuurlijk, zoals je waarschijnlijk zelf ook wel gedacht zal hebben, sneller. Nu moet je jezelf afvragen of deze luttele snelheidswinst belangrijker is dan een duidelijke/leesbare code. Ik zou in ieder geval gaan voor het tweede stukje code.

[Glimi]

Nou, je zit te kijken naar een translatie in een translatie tabel van een string naar een index.
We kunnen eigenlijk wel zeggen dat in die verdeling in een HashMap dat O(1) (constante) tijd kost.
Je probeert dus te besparen op een kleine constante operatie terwijl er waarschijnlijk heel veel O(n), O(n logn) of zelfs O( n² ) operaties in het programma zijn die veel meer executietijd slurpen.

Maw zelfs niet aan zulk soort optimalisaties denken voordat je al het andere gedaan hebt

[Crazy D]

De hidden recordset.Collect("veld") is nog iets sneller dan recordset("veld"). Of die ook op index kan i.p.v. veldnaam weet ik eigenlijk niet, dat gebruik ik nooit. (en de eventuele snelheidswinst verziek ik ergens anders in code wel weer ).

[Verwijderd]

Don Facundo schreef op 08 July 2003 @ 15:46:
Roep dan rs.Fields("Id") aan.

rs.Fields("Id").Value