వర్కింగ్ డైరెక్టరీ అనేది ఫైల్ సిస్టమ్‌లోని అప్లికేషన్ ప్రస్తుతం అమలవుతున్న స్థానాన్ని సూచిస్తుంది. ఇది అన్ని అనుబంధిత ఫైల్ మరియు ఫోల్డర్ కార్యకలాపాలకు ప్రారంభ బిందువుగా పనిచేస్తుంది కాబట్టి, అర్థం చేసుకోవడానికి ఈ డైరెక్టరీ అవసరం. మేము ఈ గైడ్‌లో దీని గురించి మాట్లాడటానికి వివిధ కోడ్ నమూనాల గురించి తెలుసుకోబోతున్నాము.
ఉదాహరణ 1:
C#లో GetCurrentDirectory() ఫంక్షన్‌ని ఉపయోగించడాన్ని ప్రదర్శించడానికి ఈ గైడ్ యొక్క మొదటి ఉదాహరణ వైపు వెళ్దాం. 'ఉపయోగించు' ఆదేశాలు ప్రోగ్రామ్ 'సిస్టమ్' మరియు 'System.IO' నేమ్‌స్పేస్‌ల నుండి తరగతులు మరియు పద్ధతులను యాక్సెస్ చేయడానికి అనుమతిస్తాయి. 'సిస్టమ్' నేమ్‌స్పేస్ ప్రాథమిక రకాలు మరియు ప్రాథమిక సిస్టమ్ కార్యాచరణను అందిస్తుంది, అయితే 'System.IO' పత్రాలు మరియు డైరెక్టరీలతో ఉపయోగం కోసం తరగతులను అందిస్తుంది.
తదుపరి పంక్తి 'తరగతి' కీవర్డ్ ద్వారా 'డమ్మీ' అనే కొత్త తరగతిని నిర్వచిస్తుంది. 'డమ్మీ' అనే పేరు ఏకపక్షంగా ఉంది మరియు ఏదైనా చెల్లుబాటు అయ్యే ఐడెంటిఫైయర్‌కి మార్చవచ్చు. మెయిన్() ఫంక్షన్ స్టాటిక్ కీవర్డ్‌తో మొదలవుతుంది, ఇది క్లాస్-లెవల్ పద్ధతి అని సూచిస్తుంది మరియు ఇది పని చేయడానికి క్లాస్ ఇన్‌స్టాన్స్‌ను ప్రారంభించాల్సిన అవసరం లేదు.
డైరెక్టరీ ఫంక్షన్ కాల్ జరగబోతోంది. అప్లికేషన్ యొక్క ప్రస్తుత వర్కింగ్ డైరెక్టరీని పొందడానికి GetCurrentDirectory() పద్ధతిని ఉపయోగించవచ్చు. GetCurrentDirectory() ఫంక్షన్ అనేది 'System.IO' నేమ్‌స్పేస్‌లో భాగమైన 'డైరెక్టరీ' క్లాస్ నుండి స్టాటిక్ ఫంక్షన్. ఇది ప్రస్తుత డైరెక్టరీని సూచించే స్ట్రింగ్‌ను అందిస్తుంది మరియు దానిని “cd” వేరియబుల్‌కు కేటాయిస్తుంది.
Console.WriteLine() పద్ధతిని ప్రామాణిక అవుట్‌పుట్ (కన్సోల్)కి టెక్స్ట్ లైన్‌ని ప్రదర్శించడానికి ఉపయోగించబడుతుంది. ఈ సందర్భంలో, ఇది ప్రస్తుత డైరెక్టరీ మార్గాన్ని కలిగి ఉన్న “cd” వేరియబుల్ విలువతో సంగ్రహించబడిన “నా ప్రస్తుత డైరెక్టరీ:” సందేశాన్ని ముద్రిస్తుంది.
సిస్టమ్ ఉపయోగించి ;
సిస్టమ్ ఉపయోగించి. IO ;
తరగతి డమ్మీ {
స్థిరమైన శూన్యం ప్రధాన ( ) {
స్ట్రింగ్ cd = డైరెక్టరీ. GetCurrentDirectory ( ) ;
కన్సోల్. రైట్ లైన్ ( 'నా ప్రస్తుత డైరెక్టరీ:' + cd ) ;
}
}
మీరు ఈ C# ప్రోగ్రామ్‌ని అమలు చేసినప్పుడు, “మెయిన్” పద్ధతి అమలు చేయబడుతుంది మరియు ప్రస్తుత డైరెక్టరీ కన్సోల్‌లో ప్రదర్శించబడుతుంది. మీరు ఏదైనా ఆన్‌లైన్ C# కంపైలర్‌ని ఉపయోగిస్తుంటే, అది కంపైలర్ పాత్‌ను ప్రదర్శిస్తుంది, అనగా /హోమ్/కంపైలర్.
మీరు అప్లికేషన్‌ను ఎలా అమలు చేస్తారనే దానిపై ఆధారపడి ఇది మారవచ్చు (ఉదా., విజువల్ స్టూడియో, కమాండ్ ప్రాంప్ట్ లేదా వేరే IDE నుండి).
ఉదాహరణ 2:
“డైరెక్టరీ” క్లాస్ కాకుండా, ప్రస్తుత వర్కింగ్ డైరెక్టరీని పొందడానికి C# యొక్క పర్యావరణాన్ని కూడా ఉపయోగించవచ్చు. ఇచ్చిన C# ఉదాహరణ కోడ్‌ని దశలవారీగా వివరిస్తాము. కోడ్ “సిస్టమ్‌ని ఉపయోగించడం;”తో ప్రారంభమవుతుంది. ప్రోగ్రామ్‌లోని “సిస్టమ్” నేమ్‌స్పేస్‌ను కలిగి ఉన్న ప్రకటన. కోడ్ 'టెస్ట్' అనే కొత్త తరగతిని నిర్వచిస్తుంది.
'dir' పేరుతో స్ట్రింగ్-టైప్ వేరియబుల్ ప్రకటించబడింది మరియు 'మెయిన్' ఫంక్షన్ లోపల విలువ ఇవ్వబడుతుంది. అప్లికేషన్ యొక్క ప్రస్తుత క్రియాశీల డైరెక్టరీని పొందడానికి, Environment.CurrentDirectory లక్షణాన్ని ఉపయోగించండి. 'ఎన్విరాన్‌మెంట్' క్లాస్ ఫైల్ సిస్టమ్ మరియు సిస్టమ్ ఎన్విరాన్‌మెంట్ వేరియబుల్స్ గురించిన సమాచారంతో సహా అప్లికేషన్ రన్ అవుతున్న ఎన్విరాన్‌మెంట్ గురించి సమాచారాన్ని అందిస్తుంది.
మీరు ఉపయోగిస్తున్న IDE కన్సోల్‌లో ప్రస్తుత డైరెక్టరీని ప్రదర్శించడానికి “Console.WriteLine” పద్ధతి ఉపయోగించబడుతుంది. “+” ఆపరేటర్ “ప్రస్తుత డైరెక్టరీ:” స్ట్రింగ్‌ను “dir” వేరియబుల్‌లో నిల్వ చేసిన విలువతో కలపడానికి ఉపయోగించబడుతుంది.
సిస్టమ్ ఉపయోగించి ;తరగతి పరీక్ష {
స్థిరమైన శూన్యం ప్రధాన ( ) {
స్ట్రింగ్ dir = పర్యావరణం. ప్రస్తుత డైరెక్టరీ ;
కన్సోల్. రైట్ లైన్ ( 'ప్రస్తుత డైరెక్టరీ:' + మీరు ) ;
}
}
అప్లికేషన్ రన్ అయినప్పుడు 'ప్రధాన' పద్ధతి డిఫాల్ట్‌గా అమలు చేయబడుతుంది. ఇది Environment.CurrentDirectoryని ఉపయోగించి ప్రస్తుత డైరెక్టరీని తిరిగి పొందడం ద్వారా ప్రారంభమవుతుంది. అప్పుడు, ఇది 'ప్రస్తుత డైరెక్టరీ:' సందేశాన్ని ప్రింట్ చేయడం ద్వారా ప్రస్తుత డైరెక్టరీని ప్రదర్శిస్తుంది, దాని తర్వాత Environment.CurrentDirectory ప్రాపర్టీని ఉపయోగించి కన్సోల్‌కు డైరెక్టరీ పాత్ వస్తుంది.
ఉదాహరణ 3:
AppDomain.CurrentDomain.BaseDirectory లక్షణంతో అప్లికేషన్ యొక్క ప్రస్తుత డైరెక్టరీని పొందడం సులభం. AppDomain.CurrentDomain.BaseDirectory వినియోగాన్ని ప్రదర్శించడానికి మేము మరొక C# కోడ్ ఉదాహరణను జోడిస్తాము.
“సిస్టమ్” నేమ్‌స్పేస్‌ని జోడించిన తర్వాత, కోడ్ “టెస్ట్” అనే తరగతిని నిర్వచిస్తుంది. అప్లికేషన్ యొక్క ప్రస్తుత వర్కింగ్ డైరెక్టరీని తిరిగి పొందడానికి పంక్తిని జోడించడం ద్వారా 'ప్రధాన' పద్ధతి దాని అమలును ప్రారంభిస్తుంది. “AppDomain” తరగతి ఒక అప్లికేషన్ డొమైన్‌ను సూచిస్తుంది మరియు “CurrentDomain” అనేది ప్రస్తుత అప్లికేషన్ డొమైన్‌ను అందించే స్టాటిక్ ప్రాపర్టీ.
'BaseDirectory' ప్రాపర్టీ, ప్రస్తుత అప్లికేషన్ డొమైన్ యొక్క బేస్ డైరెక్టరీని (అప్లికేషన్ యొక్క రూట్ డైరెక్టరీ అని కూడా పిలుస్తారు) అందిస్తుంది. తదుపరి పంక్తి ప్రస్తుత డైరెక్టరీని నిల్వ చేయడానికి టైప్ స్ట్రింగ్ యొక్క “dir” అనే వేరియబుల్‌ని ప్రకటించింది. తదుపరి వరుస లైన్ Console.WriteLine పద్ధతిని ఉపయోగించి కన్సోల్‌కు ప్రస్తుత డైరెక్టరీని అవుట్‌పుట్ చేస్తుంది. “+” ఆపరేటర్ “ప్రస్తుత డైరెక్టరీ:” స్ట్రింగ్‌ను “dir” వేరియబుల్ విలువతో కలపడానికి ఉపయోగించబడుతుంది.
సిస్టమ్ ఉపయోగించి ;తరగతి పరీక్ష {
స్థిరమైన శూన్యం ప్రధాన ( ) {
స్ట్రింగ్ dir = AppDomain. ప్రస్తుత డొమైన్ . బేస్ డైరెక్టరీ ;
కన్సోల్. రైట్ లైన్ ( 'ప్రస్తుత డైరెక్టరీ:' + మీరు ) ;
}
}
మీరు ఈ C# ప్రోగ్రామ్‌ని అమలు చేసినప్పుడు, ఇది కన్సోల్‌లో అప్లికేషన్ యొక్క ప్రస్తుత డైరెక్టరీని ప్రదర్శిస్తుంది.
ఉదాహరణ 4:
ఈ గైడ్ నుండి మా చివరి ఉదాహరణ కోసం ఇది సమయం. అందించిన C# కోడ్ అనేది 'Path.GetDirectoryName()' మరియు 'Assembly.GetExecutingAssembly().Location' పద్ధతులను ఉపయోగించి ప్రస్తుత డైరెక్టరీని పొందడానికి ప్రదర్శించే ఒక సాధారణ కన్సోల్ అప్లికేషన్.
ఈ కోడ్‌లో, మూడు నేమ్‌స్పేస్‌లు దిగుమతి చేయబడ్డాయి: “సిస్టమ్”, “సిస్టమ్.ఐఓ” మరియు “సిస్టమ్.రిఫ్లెక్షన్”. ఈ నేమ్‌స్పేస్‌లు కోడ్‌లోని వివిధ కార్యకలాపాలకు అవసరమైన తరగతులు మరియు పద్ధతులను కలిగి ఉంటాయి. కోడ్‌లో “ప్రధాన” పద్ధతి మరియు “పరీక్ష” అనే తరగతి నిర్వచించబడ్డాయి. ప్రస్తుత వర్కింగ్ డైరెక్టరీని పొందడానికి, 'Assembly.GetExecutingAssembly()' పద్ధతి ప్రస్తుతం అమలులో ఉన్న అసెంబ్లీని సూచించే 'అసెంబ్లీ' ఆబ్జెక్ట్‌ను అందిస్తుంది (అంటే, రన్నింగ్ ఎక్జిక్యూటబుల్).
'అసెంబ్లీ' ఆబ్జెక్ట్ యొక్క 'లొకేషన్' ప్రాపర్టీ రన్నింగ్ ఎక్జిక్యూటబుల్ (ఫైల్ పేరుతో సహా) స్థానానికి పూర్తి మార్గాన్ని అందిస్తుంది. ఇప్పుడు, “లొకేషన్” ప్రాపర్టీ ఫైల్ పేరుతో సహా ఎక్జిక్యూటబుల్‌కు పూర్తి మార్గాన్ని కలిగి ఉండవచ్చు. డైరెక్టరీ భాగాన్ని మాత్రమే సంగ్రహించడానికి, “Path.GetDirectoryName()” ఉపయోగించబడుతుంది. ఫైల్ చిరునామాను ఇన్‌పుట్‌గా అంగీకరించిన తర్వాత ఫైల్‌ను కలిగి ఉన్న డైరెక్టరీ పాత్ ఈ ఫంక్షన్ ద్వారా తిరిగి ఇవ్వబడుతుంది.
చివరగా, కోడ్ 'Console.WriteLine()'ని ఉపయోగించి కన్సోల్‌కు పొందిన ప్రస్తుత డైరెక్టరీని ప్రింట్ చేస్తుంది. “+” ఆపరేటర్ “ప్రస్తుత డైరెక్టరీ:” స్ట్రింగ్‌ను “cd” వేరియబుల్ విలువతో కలపడానికి ఉపయోగించబడుతుంది (ఇది ప్రస్తుత డైరెక్టరీ పాత్‌ను కలిగి ఉంటుంది).
సిస్టమ్ ఉపయోగించి ;సిస్టమ్ ఉపయోగించి. IO ;
సిస్టమ్ ఉపయోగించి. ప్రతిబింబం ;
తరగతి పరీక్ష {
స్థిరమైన శూన్యం ప్రధాన ( ) {
స్ట్రింగ్ cd = మార్గం. GetDirectoryName ( అసెంబ్లీ. GetExecutingAssembly ( ) . స్థానం ) ;
కన్సోల్. రైట్ లైన్ ( 'ప్రస్తుత డైరెక్టరీ:' + cd ) ;
}
}
మీరు ఈ C# ప్రోగ్రామ్‌ని అమలు చేసినప్పుడు, ఇది చిత్రంలో చూపిన అవుట్‌పుట్ ప్రకారం కన్సోల్‌లో నడుస్తున్న ఎక్జిక్యూటబుల్ యొక్క ప్రస్తుత డైరెక్టరీని ప్రదర్శిస్తుంది:
ముగింపు
పైన పేర్కొన్న సందర్భాలు వివిధ C# పద్ధతులు మరియు లక్షణాలను ఉపయోగించి అప్లికేషన్ యొక్క ప్రస్తుత ఫైల్ సిస్టమ్‌ను పొందుతాయి. నడుస్తున్న వాతావరణం మరియు ప్రోగ్రామ్ ఎలా ప్రారంభించబడుతుందనే దానిపై ఆధారపడి ప్రస్తుత మార్గం మారవచ్చని గుర్తుంచుకోండి.