okej jag skall förklara varför det är bättre.
Du kan läsa om connection pooling som Engine refererar till och det är det som är nycklen till prestanda vinsten. Det förklara dock inte varför man inte skall göra en massa anrop utan att stänga emellan.
Förklaringen ligger i att du inte själv styr när koden skall exekveras, utan det gör trådhanteraren i OS:et. Säg att du skapar en ASP.NET sida, ASP-motor kan hantera 25 trådar per processor. Det betyder att man kan exekvera 25 sidor samtidigt. Säg nu att alla exekverar samma sida som ser ut så här (dummy sida jag vet, men det åskådligör exemplet bra)
OleDbCommand mycommand=new OleDbCommand();
mycommand.Connection=new OleDbConnection("Provider=Microsoft.Jet.OLEDB.4.0;Data Source=databas.mdb;User Id=admin;Password=;");
mycommand.Connection.Open();
mycommand.CommandText="DELETE * FROM kunder";
mycommand.ExecuteNonQuery();
Thread.Sleep(5000) //-- Motsvarar något arbete på sidan, kanske någon stränghantering
mycommand.CommandText="DELETE * FROM uppringningar";
mycommand.ExecuteNonQuery();
Thread.Sleep(5000) //-- Motsvarar något arbete på sidan, kanske någon stränghantering
mycommand.CommandText="DELETE * FROM sparade_svar";
mycommand.ExecuteNonQuery();
mycommand.Connection.Close();
mycommand.Connection.Dispose();
mycommand.Dispose();
Om man tittar på koden nu så ser man att mellan de olika databasanropen så exekveras en massa kod, som tar en viss tid (i mitt exempel 5 sekunder :)) och det är här som man inser att det blir bättre att stänga kopplingen efter varje anrop.
Säg att person1 kommer in på sidan och kör den, då plockas en connection från poolen och denna behålls nu av denna person i minst 10 sekunder. När näste person kommer in så hämtas en connection från poolen och detta görs ända tills alla connection som finns i poolen är upptagna (default brukar vara 5). Så när person 6 kommer in så finns ingen ledig connection i poolen och det måste skapas en ny (detta tar tid). Osv osv tills alla 25 personer nu har koppling till databasen.
Som vi nu ser så mellan 2 anrop så gör vi något i 5 sekunder, vi använder inte databasen men har ändå en koppling mot den. Och det är dumt, eftersom vi då tar en koppling från poolen.
Om vi istället hade stängt vår koppling mot databasen precis efter vi har använt den, så hade det funnits en ledig koppling i poolen när någon hade behövt den. Om vi i vårt exempel har sådan tur att besökarna kommer precis så att det endast är 5 stycken åtgången som gör ett anrop medans de 20 andra håller på med arbete mellan anropen så skulle en connection pool med 5 kopplingar klara av att hanterar detta utan att skapa ny kopplingar (vilket tog tid). Detta kräver ju dock att vi lämmnar tillbaka vår koppling när vi inte behöver den. Alltså skall vi stänga vår koppling så fort vi inte behöver den.
Nu säger säkert någon att det var ju ett dumt exempel eftersom man inte gör något som tar så lång tid mellan anropen. För att se att detta inte spelar någon roll måsta man förstå att processorn använder trådar för att simulerar samtidighet. Ingen processor i världen kan processa mer än en instruktion samtidigt, man har en massa lösningar för att simulera så att det ser ut så att flera instruktioner exekveras samtidigt, och trådar är en sådan lösning.
Det betyder att lite kod för ett program körs, som sedan (innan det är klart) lämnar ifrån sig processorn till ett annat program som körs lite) som sedan lämnar tillbaka processorn till första programmet. Och eftersom man inte kan vet när en tråd körs eller när den lämnar ifrån sig processorn så kan det hända att en tråd gör ett anrop till databasen, och innan kalla på nästa anrop så kommer det andra trådar in och använder processorn.
Om man då lämnar ifrån sig kopplingen så frigör man resurser som kan användas när tråden sover.
Just i detta exempel som nöff visar så blir vinsten mindre än vid mitt exempel eftersom inga processor tunga operation utförs, men det kan ändå bli så att fler kopplingar än nödvändigt användas bara för att man inte stänger dem. Sedan är nöffs exempel inte riktigt verklighetstroghet eftersom man endast hade använt 1 command och istället skickat in alla 4 SQL satser som en till databasen.
Men återigen, eftersom man använder trådar och du inte själv bestämmer när dessa körs så kan du, om du inte öppnar - kör - stänger använda fler kopplingar än vad som egentligen är nödvändigt. Och det är skapandet av dessa extra kopplingar som kostar i skalbarhet och prestanda.
- M
kom på att det blev lite rörigt men hoppas någon förstår iallafall.
