సింటాక్స్:
C# “ఉపయోగించడం” ప్రకటన సౌకర్యవంతంగా మరియు సురక్షితంగా స్పష్టంగా పారవేయాల్సిన వనరులను నిర్వహించడానికి ఉపయోగించబడుతుంది. ఇది క్రింది విధంగా నిర్దిష్ట సింటాక్స్‌ను అనుసరిస్తుంది:
ఉపయోగించి ( వనరుల రకం వనరు = కొత్త రిసోర్స్ టైప్ ( ) ) { // కోడ్}- 'ఉపయోగించు' ప్రకటనను ప్రకటించడానికి 'ఉపయోగించు' కీవర్డ్ ఉపయోగించబడుతుంది.
- 'ఉపయోగించు' కీవర్డ్ తర్వాత, మీరు పని చేయాలనుకుంటున్న వనరు రకాన్ని పేర్కొనండి, దాని తర్వాత బ్లాక్‌లోని వనరును సూచించే వేరియబుల్ పేరు ఉంటుంది. ID డిస్పోజబుల్ ఇంటర్‌ఫేస్‌ను అమలు చేసే ఏదైనా వస్తువు అర్హత పొందుతుంది. మీరు అవసరమైన విధంగా బ్లాక్‌లోని వనరుపై పని చేయవచ్చు.
- తరువాత, వేరియబుల్‌కు వనరు రకం యొక్క కొత్త ఉదాహరణను కేటాయించడానికి సమాన గుర్తు (=) ఉపయోగించబడుతుంది.
- ఇక్కడ, 'కొత్త' కీవర్డ్ వనరు రకం యొక్క కొత్త వస్తువును రూపొందించడానికి ఉపయోగించబడుతుంది.
- కొత్త కీవర్డ్ తర్వాత కుండలీకరణాల్లో ఏదైనా అదనపు ప్రారంభించడం లేదా కాన్ఫిగరేషన్ చేయవచ్చు.
- చివరగా, మీరు రిసోర్స్‌ను ఉపయోగించే కోడ్‌ను కర్లీ బ్రేస్‌లలో {} జతచేస్తారు.
ఉదాహరణ 1:
ఈ కథనంలో C# 'ఉపయోగించు' ప్రకటన యొక్క వినియోగాన్ని ప్రదర్శించడానికి C# కోడ్ ఉదాహరణలతో ప్రారంభిద్దాం. ఇచ్చిన కోడ్ C# ప్రోగ్రామ్‌ను కవర్ చేస్తుంది, ఇది 'ఉపయోగించు' స్టేట్‌మెంట్‌లోని 'స్ట్రీమ్‌రీడర్' క్లాస్‌ని ఉపయోగించి టెక్స్ట్ ఫైల్ యొక్క కంటెంట్‌లను చదివేస్తుంది.
ఇన్‌పుట్/అవుట్‌పుట్ ఆపరేషన్‌లు మరియు ఫైల్ హ్యాండ్లింగ్ కోసం తరగతులను అందించే అవసరమైన నేమ్‌స్పేస్‌లు, సిస్టమ్ మరియు System.IOలను దిగుమతి చేయడం ద్వారా ప్రోగ్రామ్ ప్రారంభమవుతుంది. ప్రోగ్రామ్ 'డమ్మీ' అనే తరగతిని నిర్వచిస్తుంది. “డమ్మీ” క్లాస్ లోపల, ఒక మెయిన్() పద్ధతి ఉంది, ఇది మొత్తం ప్రోగ్రామ్‌ను ప్రారంభం నుండి చివరి వరకు అమలు చేయడానికి ఏదైనా C# ప్రోగ్రామ్‌కు ఎల్లప్పుడూ ఎంట్రీగా పరిగణించబడుతుంది.
Main() పద్ధతి “fp” స్ట్రింగ్ వేరియబుల్‌ని ప్రకటించడం ద్వారా మరియు దానికి “test.txt” విలువను కేటాయించడం ద్వారా ప్రారంభమవుతుంది. ఇది చదవవలసిన టెక్స్ట్ ఫైల్ యొక్క ఫైల్ పాత్‌ను సూచిస్తుంది. ఫైల్‌లను చదివేటప్పుడు సంభవించే అన్ని లోపాలను అధిగమించడానికి, ట్రై-క్యాచ్ బ్లాక్ ఉపయోగించబడుతుంది.
ట్రై బ్లాక్‌లో, “స్ట్రీమ్‌రీడర్” క్లాస్ యొక్క ఉదాహరణను సృష్టించడానికి “ఉపయోగించు” స్టేట్‌మెంట్ ఉపయోగించబడుతుంది. ఫైల్ నుండి కంటెంట్‌ను గ్రహించే పని 'స్ట్రీమ్‌రీడర్'కి వస్తుంది. “fp” వేరియబుల్‌లో నిల్వ చేయబడిన ఫైల్ మార్గం “StreamReader” కన్‌స్ట్రక్టర్‌కి పంపబడుతుంది, చదవాల్సిన ఫైల్‌ను సూచిస్తుంది.
'ఉపయోగించు' బ్లాక్ లోపల, పత్రం యొక్క చివరి పంక్తి కనిపించకపోతే, ఫైల్ యొక్క కంటెంట్‌లు 'వేళ' లూప్‌ని ఉపయోగించి లైన్ వారీగా పరిశీలించబడతాయి. లూప్ “స్ట్రీమ్ రీడర్” యొక్క రీడ్‌లైన్() పద్ధతిని ఉపయోగించి ఒక పంక్తిని చదువుతుంది మరియు దానిని స్ట్రింగ్ వేరియబుల్ “l”కి కేటాయిస్తుంది. లైన్ శూన్యం కాకపోతే, అది కన్సోల్‌ను ఉపయోగించి కన్సోల్‌కు ముద్రించబడుతుంది.WriteLine(l).
ఫైల్ ముగింపుకు చేరుకున్న తర్వాత మరియు చదవడానికి మరిన్ని పంక్తులు లేనప్పుడు, “ఉపయోగించు” బ్లాక్ నిష్క్రమించబడుతుంది మరియు “ఉపయోగించు” ప్రకటన కారణంగా “స్ట్రీమ్ రీడర్” ఆబ్జెక్ట్ స్వయంచాలకంగా పారవేయబడుతుంది. పత్రాన్ని చదివేటప్పుడు IOException వచ్చినప్పుడు క్యాచ్ బ్లాక్ యాక్టివేట్ చేయబడుతుంది. మినహాయింపు సందేశం e.Messageని ఉపయోగించి పొందబడుతుంది మరియు Console.WriteLine()ని ఉపయోగించి కన్సోల్‌లో దోష సందేశం ప్రదర్శించబడుతుంది.
ప్రోగ్రామ్ అమలు పూర్తయింది మరియు కన్సోల్ అవుట్‌పుట్ ప్రదర్శించబడుతుంది. “test.txt” ఫైల్ ఉనికిలో ఉందని మరియు అనేక వచన పంక్తులను కలిగి ఉందని ఊహిస్తే, ఈ కోడ్ యొక్క అవుట్‌పుట్ కింది జోడించిన చిత్రంలో ప్రదర్శించబడినట్లుగా కన్సోల్‌లో ముద్రించబడిన ఫైల్ యొక్క కంటెంట్‌లు. ప్రతి పంక్తి అవుట్‌పుట్‌లో విడిగా చూపబడింది:
సిస్టమ్ ఉపయోగించి ;సిస్టమ్ ఉపయోగించి. IO ;
తరగతి డమ్మీ {
స్థిరమైన శూన్యం ప్రధాన ( ) {
స్ట్రింగ్ fp = 'test.txt' ;
ప్రయత్నించండి {
ఉపయోగించి ( స్ట్రీమ్ రీడర్ రీడర్ = కొత్త స్ట్రీమ్ రీడర్ ( fp ) )
{
స్ట్రింగ్ l ;
అయితే ( ( ఎల్ = పాఠకుడు. రీడ్‌లైన్ ( ) ) != శూన్య )
{
కన్సోల్. రైట్ లైన్ ( ఎల్ ) ;
}
}
}
క్యాచ్ ( IO మినహాయింపు ఇ ) {
కన్సోల్. రైట్ లైన్ ( 'తప్పు సంభవించింది:' + అది. సందేశం ) ;
}
}
}
గమనిక: “test.txt” ఫైల్ ఉనికిలో లేకుంటే లేదా ఫైల్ యాక్సెస్ లేదా రీడింగ్‌లో సమస్య ఉంటే, క్యాచ్ బ్లాక్ అమలు చేయబడుతుంది మరియు సంభవించిన నిర్దిష్ట మినహాయింపును సూచించే దోష సందేశం కన్సోల్‌లో ప్రదర్శించబడుతుంది.
ఉదాహరణ 2:
ఫైల్‌కి డేటాను వ్రాయడానికి స్ట్రీమ్‌రైటర్‌తో C# “ఉపయోగించు” స్టేట్‌మెంట్ యొక్క వినియోగాన్ని ప్రదర్శించే మరొక సాధారణ ఉదాహరణ ఇక్కడ ఉంది. కోడ్‌ని దాని అంచనా అవుట్‌పుట్‌తో పాటు వివరణ ఇక్కడ ఉంది. కోడ్ 'డమ్మీ' క్లాస్ మరియు 'మెయిన్' పద్ధతి యొక్క డిక్లరేషన్‌తో మొదలవుతుంది, ఇది చివరికి ప్రోగ్రామ్‌ను ప్రారంభించి ముగిస్తుంది.
“ప్రధాన” పద్ధతిలో, “fp” స్ట్రింగ్ వేరియబుల్ ప్రకటించబడింది మరియు “test.txt” ఫైల్ మార్గంతో ప్రారంభించబడుతుంది. సమాచారం వ్రాయబడిన పత్రం దీని ద్వారా సూచించబడుతుంది. డాక్యుమెంట్ రైటింగ్ ప్రక్రియ అంతటా ఉత్పన్నమయ్యే ఏదైనా సాధ్యమైన IOExceptionతో వ్యవహరించడానికి, ప్రోగ్రామ్ ట్రై-క్యాచ్ బ్లాక్‌లో జతచేయబడుతుంది.
ట్రై బ్లాక్ లోపల, “రైటర్” అనే పేరుతో స్ట్రీమ్‌రైటర్ ఆబ్జెక్ట్ సృష్టించబడుతుంది మరియు “ఉపయోగించు” స్టేట్‌మెంట్‌ని ఉపయోగించి ప్రారంభించబడుతుంది. StreamWriter ఫైల్‌కి అక్షరాలను వ్రాయడానికి బాధ్యత వహిస్తుంది. రైటర్ ఆబ్జెక్ట్ యొక్క రైట్‌లైన్ ఫంక్షన్ ద్వారా “ఉపయోగించడం” విభాగంలోని పత్రానికి రెండు వేర్వేరు పంక్తులు కంటెంట్ జోడించబడతాయి. బ్లాక్ నుండి నిష్క్రమించిన తర్వాత, StreamWriter యొక్క డిస్పోజ్() పద్ధతి స్వయంచాలకంగా పిలువబడుతుంది, ఇది ఏదైనా పెండింగ్ డేటా ఫైల్‌కి వ్రాయబడిందని మరియు అవసరమైన వనరులు విడుదల చేయబడుతుందని నిర్ధారిస్తుంది.
చివరగా, 'ఉపయోగించే' బ్లాక్ వెలుపల, 'డేటా విజయవంతంగా వ్రాయబడింది.' కన్సోల్‌లో సందేశం చూపబడుతుంది, ఇది పత్రం యొక్క వ్రాత ఆపరేషన్ విజయవంతమైందని మరియు దోష రహితంగా ఉందని చూపుతుంది. పత్రం వ్రాసే ప్రక్రియలో ఏదైనా IOException జరిగితే క్యాచ్ బ్లాక్ యాక్టివేట్ చేయబడుతుంది. ఆ సందర్భంలో, కన్సోల్‌లో నిర్దిష్ట మినహాయింపు సందేశంతో పాటు ఒక దోష సందేశం ప్రదర్శించబడుతుంది.
సిస్టమ్ ఉపయోగించి ;సిస్టమ్ ఉపయోగించి. IO ;
తరగతి డమ్మీ {
స్థిరమైన శూన్యం ప్రధాన ( ) {
స్ట్రింగ్ fp = 'test.txt' ;
ప్రయత్నించండి {
ఉపయోగించి ( స్ట్రీమ్ రైటర్ రచయిత = కొత్త స్ట్రీమ్‌రైటర్ ( fp ) )
{
రచయిత. రైట్ లైన్ ( 'హలో, సి-షార్ప్!' ) ;
రచయిత. రైట్ లైన్ ( 'ఇది పరీక్ష వచనం.' ) ;
}
కన్సోల్. రైట్ లైన్ ( 'డేటా విజయవంతంగా వ్రాయబడింది.' ) ;
}
క్యాచ్ ( IO మినహాయింపు ఇ ) {
కన్సోల్. రైట్ లైన్ ( 'లోపం సంభవించింది:' + అది. సందేశం ) ;
}
}
}
సారాంశంలో, కోడ్ స్ట్రీమ్‌రైటర్ ఆబ్జెక్ట్‌ను “ఉపయోగించు” స్టేట్‌మెంట్‌ని ఉపయోగించి సృష్టిస్తుంది, ఫైల్‌కి రెండు లైన్ల టెక్స్ట్‌ను వ్రాస్తుంది, ఆపై స్ట్రీమ్‌రైటర్‌ను స్వయంచాలకంగా పారవేస్తుంది. రైటింగ్ ఆపరేషన్ విజయవంతమైతే, సాఫ్ట్‌వేర్ విజయ సందేశాన్ని రూపొందిస్తుంది. లేకపోతే, ఏదైనా IOException సంభవించినట్లయితే అది వైఫల్య సందేశాన్ని విడుదల చేస్తుంది.
ముగింపు
C# “ఉపయోగించడం” ప్రకటన స్పష్టమైన పారవేయడం అవసరమయ్యే వనరులను నిర్వహించడానికి ఆచరణాత్మక మరియు సురక్షితమైన పద్ధతిని అందిస్తుంది. అవసరమైన క్లీనప్ విధానాలు స్వయంచాలకంగా నిర్వహించబడతాయని మరియు వనరుల వినియోగాన్ని 'ఉపయోగించు' బ్లాక్‌లో చేర్చడం ద్వారా వనరుల లీక్‌ల సంభావ్యతను తగ్గించవచ్చని మీరు హామీ ఇవ్వవచ్చు. ఇది మీ కోడ్ యొక్క విశ్వసనీయతను పెంచుతుంది.