Syntax:
Ang C# na 'paggamit' na pahayag ay ginagamit upang pamahalaan ang mga mapagkukunan na kailangang tahasang itapon nang maginhawa at ligtas. Ito ay sumusunod sa isang tiyak na syntax tulad ng sumusunod:
gamit ( ResourceType na mapagkukunan = bagong ResourceType ( ) ) { // Code }- Ang 'gamit' na keyword ay ginagamit upang ideklara ang 'gamit' na pahayag.
- Pagkatapos ng 'paggamit' ng keyword, tinukoy mo ang uri ng mapagkukunan na gusto mong gamitin, na sinusundan ng isang variable na pangalan na kumakatawan sa mapagkukunan sa loob ng block. Ang anumang bagay na nagsasagawa ng IDisposable interface ay kwalipikado. Maaari kang magpatakbo sa mapagkukunan sa loob ng bloke kung kinakailangan.
- Susunod, ang isang pantay na tanda (=) ay ginagamit upang magtalaga ng isang bagong halimbawa ng uri ng mapagkukunan sa variable.
- Dito, ginagamit ang 'bagong' keyword upang makabuo ng bagong object ng uri ng mapagkukunan.
- Ang anumang karagdagang pagsisimula o pagsasaayos ay maaaring gawin sa loob ng mga panaklong pagkatapos ng bagong keyword.
- Panghuli, isinama mo ang code na gumagamit ng mapagkukunan sa loob ng mga kulot na braces {}.
Halimbawa 1:
Magsimula tayo sa mga halimbawa ng C# code upang ipakita ang paggamit ng pahayag na 'paggamit' ng C# sa artikulong ito. Ang ibinigay na code ay sumasaklaw sa isang C# program na nagbabasa ng mga nilalaman ng isang text file gamit ang 'StreamReader' na klase sa loob ng isang 'gamit' na pahayag.
Nagsisimula ang programa sa pamamagitan ng pag-import ng mga kinakailangang namespace, System at System.IO, na nagbibigay ng mga klase para sa mga pagpapatakbo ng input/output at paghawak ng file. Ang programa ay tumutukoy sa isang klase na tinatawag na 'Dummy'. Sa loob ng klase ng 'Dummy', mayroong isang Main() na paraan na dapat palaging ituring bilang entry para sa anumang C# program upang maisagawa ang pangkalahatang programa mula simula hanggang katapusan.
Ang Main() na paraan ay nagsisimula sa pamamagitan ng pagdedeklara ng “fp” string variable at pagtatalaga dito ng “test.txt” value. Kinakatawan nito ang path ng file ng text file na babasahin. Upang makayanan ang lahat ng posibleng mga error na maaaring lumitaw kapag nagbabasa ng mga file, isang try-catch block ang ginagamit.
Sa loob ng try block, ang isang 'paggamit' na pahayag ay ginagamit upang lumikha ng isang halimbawa ng klase ng 'StreamReader'. Ang gawain ng pag-unawa sa nilalaman mula sa isang file ay napupunta sa 'StreamReader'. Ang path ng file na nakaimbak sa variable na 'fp' ay ipinasa sa tagabuo ng 'StreamReader' na nagpapahiwatig ng file na babasahin.
Sa loob ng 'gamit' na bloke, ang mga nilalaman ng file ay sinusuri ng linya sa pamamagitan ng linya gamit ang 'habang' loop maliban kung ang huling linya ng dokumento ay lilitaw. Ang loop ay nagbabasa ng isang linya gamit ang ReadLine() na paraan ng 'StreamReader' at itinalaga ito sa string variable na 'l'. Kung ang linya ay hindi null, ito ay naka-print sa console gamit ang Console.WriteLine(l).
Kapag naabot na ang dulo ng file at wala nang mga linyang mababasa, ang 'gamit' na bloke ay lalabas at ang bagay na 'StreamReader' ay awtomatikong itatapon dahil sa 'gamit' na pahayag. Ang catch block ay isinaaktibo tuwing may IOException na lumabas habang nagbabasa ng isang dokumento. Ang mensahe ng pagbubukod ay nakuha gamit ang e.Message, at ang isang mensahe ng error ay ipinapakita sa console gamit ang Console.WriteLine().
Nakumpleto ang pagpapatupad ng programa at ipinapakita ang output ng console. Ipagpalagay na ang 'test.txt' na file ay umiiral at naglalaman ng ilang linya ng teksto, ang output ng code na ito ay ang mga nilalaman ng file na naka-print sa console tulad ng ipinapakita sa sumusunod na naka-attach na larawan. Ang bawat linya ay ipinapakita nang hiwalay sa output:
gamit ang System ;gamit ang System. IO ;
klase Dummy {
static walang bisa Pangunahing ( ) {
string fp = 'test.txt' ;
subukan {
gamit ( StreamReader reader = bagong StreamReader ( fp ) )
{
string l ;
habang ( ( l = mambabasa. Basahin ang linya ( ) ) != wala )
{
Console. WriteLine ( l ) ;
}
}
}
mahuli ( IOException e ) {
Console. WriteLine ( 'Nagkaroon ng pagkakamali: ' + Ito ay. Mensahe ) ;
}
}
}
Tandaan: Kung wala ang 'test.txt' na file o may isyu sa pag-access o pagbabasa ng file, isasagawa ang catch block, at may ipapakitang mensahe ng error sa console na nagsasaad ng partikular na pagbubukod na naganap.
Halimbawa 2:
Narito ang isa pang simpleng halimbawa na nagpapakita ng paggamit ng C# na 'gamit' na pahayag sa isang StreamWriter upang isulat ang data sa isang file. Narito ang isang paliwanag ng code kasama ang inaasahang output nito. Ang code ay nagsisimula sa deklarasyon ng klase ng 'Dummy' at ang 'Main' na pamamaraan na kalaunan ay magsisimula at magtatapos sa programa.
Sa loob ng 'Main' na paraan, ang 'fp' string variable ay idineklara at sinisimulan sa 'test.txt' file path. Ang dokumento kung saan nakasulat ang impormasyon ay kinakatawan nito. Upang harapin ang anumang posibleng IOException na maaaring lumitaw sa buong proseso ng pagsulat ng dokumento, ang programa ay nakapaloob sa isang try-catch block.
Sa loob ng try block, isang bagay na StreamWriter na pinangalanang 'manunulat' ay nilikha at sinisimulan gamit ang 'paggamit' na pahayag. Ang StreamWriter ay responsable para sa pagsulat ng mga character sa isang file. Dalawang magkahiwalay na linya ng nilalaman ang idinaragdag sa isang dokumento sa loob ng seksyong 'paggamit' sa pamamagitan ng function ng WriteLine ng object ng manunulat. Kapag naalis na ang block, awtomatikong tatawagin ang Dispose() method ng StreamWriter na nagsisiguro na ang anumang nakabinbing data ay isusulat sa file at ang mga kinakailangang mapagkukunan ay ilalabas.
Sa wakas, sa labas ng 'paggamit' na bloke, ang 'Matagumpay na naisulat ang data.' ang mensahe ay ipinapakita sa console na nagpapakita na ang pagpapatakbo ng pagsulat ng dokumento ay matagumpay at walang error. Ang catch block ay isinaaktibo kung anumang IOException ang mangyayari sa panahon ng proseso ng pagsulat ng dokumento. Sa kasong iyon, ang isang mensahe ng error kasama ang partikular na mensahe ng pagbubukod ay ipinapakita sa console.
gamit ang System ;gamit ang System. IO ;
klase Dummy {
static walang bisa Pangunahing ( ) {
string fp = 'test.txt' ;
subukan {
gamit ( Manunulat ng StreamWriter = bagong StreamWriter ( fp ) )
{
manunulat. WriteLine ( 'Hello, C-Sharp!' ) ;
manunulat. WriteLine ( 'Ito ay isang pagsubok na teksto.' ) ;
}
Console. WriteLine ( 'Matagumpay na naisulat ang data.' ) ;
}
mahuli ( IOException e ) {
Console. WriteLine ( 'Naganap ang error: ' + Ito ay. Mensahe ) ;
}
}
}
Sa buod, ang code ay lumilikha ng isang StreamWriter object gamit ang 'gamit' na pahayag, nagsusulat ng dalawang linya ng teksto sa isang file, at pagkatapos ay awtomatikong itinatapon ang StreamWriter. Kung magtagumpay ang operasyon ng pagsulat, bubuo ang software ng mensahe ng tagumpay. Kung hindi, naglalabas ito ng mensahe ng kabiguan kung may nangyaring IOException.
Konklusyon
Ang C# na 'paggamit' na pahayag ay nag-aalok ng isang praktikal at secure na paraan ng pamamahala ng mga mapagkukunan na nangangailangan ng isang tahasang pagtatapon. Maaari mong garantiya na ang mga kinakailangang pamamaraan sa paglilinis ay awtomatikong isinasagawa at bawasan ang posibilidad ng pagtagas ng mapagkukunan sa pamamagitan ng paglalagay ng pagkonsumo ng mapagkukunan sa loob ng isang bloke na 'paggamit'. Pinapataas nito ang pagiging maaasahan ng iyong code.