Syntaks:
C# 'using'-sætningen bruges til at administrere de ressourcer, der eksplicit skal bortskaffes bekvemt og sikkert. Det følger en specifik syntaks som følger:
ved brug af ( ResourceType ressource = ny ressourcetype ( ) ) { // Kode }- Nøgleordet 'bruger' bruges til at erklære 'bruger'-sætningen.
- Efter nøgleordet 'bruger' angiver du den ressourcetype, du vil arbejde med, efterfulgt af et variabelnavn, der repræsenterer ressourcen i blokken. Ethvert objekt, der udfører IDisposable-grænsefladen, er kvalificeret. Du kan operere på ressourcen i blokken efter behov.
- Dernæst bruges et lighedstegn (=) til at tildele en ny forekomst af ressourcetypen til variablen.
- Her bruges det 'nye' nøgleord til at generere et nyt objekt af ressourcetypen.
- Enhver yderligere initialisering eller konfiguration kan udføres inden for parentesen efter det nye nøgleord.
- Til sidst vedlægger du koden, der bruger ressourcen, i de krøllede klammeparenteser {}.
Eksempel 1:
Lad os begynde med C#-kodeeksemplerne for at demonstrere brugen af C# 'using'-sætningen i denne artikel. Den givne kode dækker et C#-program, der læser indholdet af en tekstfil ved hjælp af 'StreamReader'-klassen i en 'using'-sætning.
Programmet starter med at importere de nødvendige navnerum, System og System.IO, som giver klasser til input/output operationer og filhåndtering. Programmet definerer en klasse kaldet 'Dummy'. Inde i 'Dummy'-klassen er der en Main()-metode, som altid skal behandles som indgangen for ethvert C#-program for at udføre det overordnede program fra start til slut.
Main()-metoden begynder med at erklære 'fp'-strengvariablen og tildele den 'test.txt'-værdien. Dette repræsenterer filstien til den tekstfil, der skal læses. For at klare alle mulige fejl, der kan opstå ved læsning af filer, benyttes en try-catch-blok.
Indenfor try-blokken bruges en 'using'-sætning til at oprette en forekomst af klassen 'StreamReader'. Opgaven med at forstå indholdet fra en fil falder på 'StreamReader'. Filstien, der er gemt i 'fp'-variablen, videregives til 'StreamReader'-konstruktøren angiver den fil, der skal læses.
Inde i 'bruger'-blokken undersøges filens indhold linje for linje ved hjælp af en 'mens'-løkke, medmindre den sidste linje i dokumentet vises. Sløjfen læser en linje ved hjælp af ReadLine() metoden i 'StreamReader' og tildeler den til strengvariablen 'l'. Hvis linjen ikke er nul, udskrives den til konsollen ved hjælp af Console.WriteLine(l).
Når slutningen af filen er nået, og der ikke er flere linjer at læse, forlades 'using'-blokken, og 'StreamReader'-objektet bortskaffes automatisk på grund af 'using'-sætningen. Fangstblokken aktiveres, når der opstår en IOException under læsning af et dokument. Undtagelsesmeddelelsen opnås ved hjælp af e.Message, og en fejlmeddelelse vises på konsollen ved hjælp af Console.WriteLine().
Programafviklingen afsluttes, og konsoloutputtet vises. Hvis det antages, at 'test.txt'-filen eksisterer og indeholder flere tekstlinjer, er outputtet af denne kode indholdet af filen, der udskrives på konsollen som vist i det følgende vedhæftede billede. Hver linje vises separat i outputtet:
ved hjælp af System ;ved hjælp af System. IO ;
klasse Dummy {
statisk ugyldig Hoved ( ) {
streng fp = 'test.txt' ;
prøve {
ved brug af ( StreamReader-læser = ny StreamReader ( fp ) )
{
streng l ;
mens ( ( l = læser. ReadLine ( ) ) != nul )
{
Konsol. WriteLine ( l ) ;
}
}
}
fangst ( IOException e ) {
Konsol. WriteLine ( 'Fejl opstod:' + Det er. Besked ) ;
}
}
}
Bemærk: Hvis 'test.txt'-filen ikke eksisterer, eller der er et problem med filadgang eller læsning, udføres catch-blokken, og der vises en fejlmeddelelse på konsollen, der angiver den specifikke undtagelse, der opstod.
Eksempel 2:
Her er et andet simpelt eksempel, der demonstrerer brugen af C# 'using'-sætningen med en StreamWriter til at skrive dataene til en fil. Her er en forklaring af koden sammen med dens forventede output. Koden starter med erklæringen af 'Dummy'-klassen og 'Main'-metoden, som til sidst vil starte og afslutte programmet.
Inden for 'Main'-metoden erklæres 'fp'-strengvariablen og initialiseres med filstien 'test.txt'. Det dokument, som oplysningerne er skrevet på, repræsenteres herved. For at håndtere enhver mulig IOException, der kunne opstå under dokumentskrivningsprocessen, er programmet indesluttet i en try-catch-blok.
Inde i try-blokken oprettes et StreamWriter-objekt ved navn 'writer' og initialiseres ved hjælp af 'using'-sætningen. StreamWriteren er ansvarlig for at skrive tegn til en fil. To separate indholdslinjer føjes til et dokument inde i 'bruger'-sektionen via writer-objektets WriteLine-funktion. Når blokken er afsluttet, kaldes Dispose()-metoden for StreamWriter automatisk, hvilket sikrer, at eventuelle ventende data skrives til filen, og de nødvendige ressourcer frigives.
Til sidst, uden for 'bruger'-blokken, 'Data skrevet med succes.' meddelelse vises på konsollen, som viser, at dokumentets skriveoperation er vellykket og fejlfri. Fangstblokken aktiveres, hvis der sker en IOException under dokumentets skriveproces. I så fald vises en fejlmeddelelse sammen med den specifikke undtagelsesmeddelelse på konsollen.
ved hjælp af System ;ved hjælp af System. IO ;
klasse Dummy {
statisk ugyldig Hoved ( ) {
streng fp = 'test.txt' ;
prøve {
ved brug af ( StreamWriter-skribent = nye StreamWriter ( fp ) )
{
forfatter. WriteLine ( 'Hej, C-Sharp!' ) ;
forfatter. WriteLine ( 'Dette er en testtekst.' ) ;
}
Konsol. WriteLine ( 'Data skrevet med succes.' ) ;
}
fangst ( IOException e ) {
Konsol. WriteLine ( 'Der er sket en fejl: ' + Det er. Besked ) ;
}
}
}
Sammenfattende opretter koden et StreamWriter-objekt ved hjælp af 'using'-sætningen, skriver to linjer tekst til en fil og kasserer derefter StreamWriter automatisk. Hvis skriveoperationen lykkes, genererer softwaren en succesmeddelelse. Ellers udsender den en fejlmeddelelse, hvis der opstår en IOException.
Konklusion
C# 'using'-erklæringen tilbyder en praktisk og sikker metode til at styre de ressourcer, der kræver en eksplicit bortskaffelse. Du kan garantere, at de nødvendige oprydningsprocedurer udføres automatisk og reducere sandsynligheden for ressourcelækage ved at lukke ressourceforbruget i en 'brugende' blok. Dette øger pålideligheden af din kode.