Kodekonsepter: .NETs lambdas

My Code-konseptserien har jobbet mot et overordnet poeng: I løpet av noen måneder skal vi sette sammen noen av leksjonene vi har lært til en sinnsykt fantastisk, tilpassede regler-motor. Faktisk kommer det til å bli utrolig, at det faktisk kommer til å skrive seg selv. (Fang opp tidligere kolonner i serien: Kodekonsepter: C #s utvidelsesmetoder og Kodekonsepter: C # 's var nøkkelord.) Men foreløpig vil jeg fokusere på lambdas i .NET, spesifikt hva lambdas er og hvordan du bruker dem.

Hva er lambdas?

En lambda er en snarvei for å skrive en anonym metode. Funksjonelt sett tjener lambdas samme formål som anonyme funksjoner og har en mye renere syntaks. Lambdas tilordnes med => operatøren. Lambdas er delegater og kan brukes i stedet for dem. Lambaer uten returtype er lik den generiske handlingstypen, og lammedyr med returtype er lik Func-typen.

Når du oppretter lambda, trenger du tre elementer: en variabel du tilordner lambda til, en parameterliste og en metodekropp.

  • En variabel å tilordne lambda til: Dette kan være en spesifikk delegatype eller en av de to generiske delegattyper.
  • En parameterliste: Hvis det er flere inndataparametere, må denne listen være vedlagt i parentes, og parameterne må skilles med kommaer. Hvis det bare er en parameter, er parentesene valgfrie. Du kan utelate typene, siden kompilatoren kan utlede typene basert på variabeldeklarasjonen.
  • En metodekropp : Dette må være lukket i krøllete seler hvis det er mer enn ett utsagn. Hvis du bruker krøllete seler, trenger du en setningsterminal (semikolon) etter tannreguleringen.

Du lurer kanskje på hvorfor jeg snakker om krøllete seler som om VB.NET ikke eksisterer. Dessverre er lambdas på dette tidspunktet i utgangspunktet ubrukelige i VB.NET fordi VB.NET ikke kan løse lambdas som spenner over mer enn en linje. Den neste versjonen av VB.NET (Visual Basic 10 i. NET 4) vil støtte flere linjelamdaer gjennom sin nye automatiske uttalelses videreføringsfunksjon.

La oss se på en veldig enkel lambda for å få følelsen av syntaks:

 Func simpleLambda1 = (input1, input2) 

=> String.Format ("{0} ganger {1} = {2}",

input1, input2, input1 * input2);

Dette lager en lambda som godtar to heltall (tilordnet de lokale variablene input1 og input2) og returnerer en streng.

Eventuelle variabler som er erklært i lambdaen er lokale for den og er ikke synlige utenfor den. Når lambda er deklarert, blir alle variabler som den bruker som er deklarert utenfor lambda "fanget" av lambda og "reise" med den, selv om lambda senere blir henrettet i et omfang som inneholder en variabel med samme navn med samme signatur. Her er noen eksempelkode:

 statisk tomrom RunLambda (Action lambdaToRun) 

{

int multiplikator = 2;
 Console.WriteLine ("Kjøre lambda eksternt."); 

for (int teller = 0; teller <10; teller ++)

{

multiplikator ++;

lambdaToRun (teller);

}

}
 statisk tomrom Main () 

{

int multiplikator = 5;

Handling lambda =

input => Console.WriteLine ("{0} ganger {1} = {2}", input, multiplier, input * multiplier);

Console.WriteLine ("Å kjøre lambda lokalt.");

for (int teller = 0; teller <10; teller ++)

{

multiplikator ++;

lambda (teller);

}
 RunLambda (lambda); 
 Console.WriteLine ("Trykk Enter for å avslutte ..."); 

Console.ReadLine ();

}
Ser du på denne koden, kan du i utgangspunktet forvente å se at når RunLambda () kjøres, blir verdien 2 brukt for multiplikatorvariabelen, men du vil ta feil. Figur A viser den faktiske utgangen. Figur A

Verdien av 15 gjennomført til den kalte funksjonen. Dette er en veldig viktig observasjon.

Hvorfor foretrekker vi en lambda fremfor en full funksjon? For en ting er lambdas bærbare. Som du ser, blir lambdas lett ført rundt - å gjøre dette med en normal funksjon ville innebære klønete og indirekte delegatsyntaks. For en annen ting er lambdas ganske kortfattet på et syntaksnivå. Syntaksen gjør det mulig for utvikleren å fokusere på lambdas innhold, ikke alle koder som trengs for å konstruere den. Den store forskjellen er i bekvemmelighet. Fordi lambda-syntaks er så enkel å bruke, finner du deg selv til å gjøre ting du aldri ville gjort med delegater, bare fordi det ikke lenger føles som et ork.

Sammendrag

Dette er en kort introduksjon til lambdas. Når jeg setter alle disse brikkene sammen til en regelmotor, vil du virkelig se hvor nyttige lambdas er i praksis.

Hvis du vil ha en mer detaljert forklaring om lambdas, kan du lese språkbeskrivelsen C # 3.0 (i Word-format), spesielt avsnitt 7.14.

J.Ja

Avsløring av Justin's industri-tilknytning: Justin James har en kontrakt med Spiceworks for å skrive produktkjøpsguider.

-------------------------------------------------- -------------------------------------

Få ukentlige utviklingstips i innboksen Hold utviklerferdighetene dine skarpe ved å registrere deg på TechRepublics gratis nyhetsbrev for Web Developer, levert hver tirsdag. Abonner automatisk i dag!

© Copyright 2021 | pepebotifarra.com