సి # ట్యుటోరియల్: మీరు సి # ను నేర్చుకోవలసిన ప్రాథమిక అంశాలు

సి # ఆల్-పర్పస్ మరియు మైక్రోసాఫ్ట్ కార్పొరేషన్ 2000 సంవత్సరంలో జావాకు ఘోరమైన పోటీదారుగా అభివృద్ధి చేసిన బలమైన ప్రోగ్రామింగ్ భాష. వెబ్ అభివృద్ధితో పాటు డెస్క్‌టాప్ అప్లికేషన్ డెవలప్‌మెంట్ రెండింటికీ వచ్చినప్పుడు ఇది అత్యంత ప్రాచుర్యం పొందింది మరియు ప్రోగ్రామింగ్ భాష.

ఈ సి # ట్యుటోరియల్‌లో, మేము ఈ క్రింది అంశాలను నేర్చుకుంటాము.

• సి # బేసిక్స్
• ఆబ్జెక్ట్ ఓరియెంటెడ్ ప్రోగ్రామింగ్
• అధునాతన సి # కాన్సెప్ట్స్
• సి # ఆధారంగా ఇంటర్వ్యూ ప్రశ్నలు

సి # బేసిక్స్

• సి # ప్రోగ్రామింగ్ భాష పరిచయం
• సి # ప్రోగ్రామింగ్ లాంగ్వేజ్ యొక్క లక్షణాలు
• సంస్థాపన
• సి # ప్రోగ్రామ్ నిర్మాణం
• డేటాటైప్స్
• వేరియబుల్స్
• ఆపరేటర్లు
• ఉచ్చులు
• షరతులతో కూడినది
• తీగలను
• శ్రేణులు
• సేకరణలు
  • జాబితా
  • హాష్ సెట్
  • క్రమబద్ధీకరించిన సెట్
  • స్టాక్
  • క్యూ
  • లింక్డ్ జాబితా
  • నిఘంటువు
  • క్రమబద్ధీకరించిన నిఘంటువు
  • క్రమబద్ధీకరించిన జాబితా
• నిర్మాణం
• విధులు

సి # ప్రోగ్రామింగ్ భాష పరిచయం

90 ల ప్రారంభంలో, వెబ్ అభివృద్ధి, డెస్క్‌టాప్ అప్లికేషన్ అభివృద్ధి మరియు అనేక ఇతర రంగాలకు జావా ప్రముఖ ప్రోగ్రామింగ్ భాష. మైక్రోసాఫ్ట్ జావాను చాలా వెనుకబడి ఉంచగల అనేక అధునాతన లక్షణాలతో పోటీదారునితో రావాలని కోరుకుంది.

ఇది 2000 సంవత్సరంలో, అండర్స్ హెజల్స్బర్గ్ మరియు అతని మైక్రోసాఫ్ట్ బృందం సి # షార్ప్ అని పిలువబడే సి # ఆలోచనతో ముందుకు వచ్చింది. ఈ ప్రయత్నాన్ని అంతర్జాతీయ ప్రమాణాల సంస్థ ఆమోదించింది (ప్రధాన) మరియు యూరోపియన్ కంప్యూటర్ తయారీదారుల సంఘం (ECMA). చివరకు, C # సాఫ్ట్‌వేర్ అభివృద్ధి ప్రపంచంలోకి ప్రవేశిస్తుంది.

సి # ప్రోగ్రామింగ్ లాంగ్వేజ్ యొక్క లక్షణాలు

• ఆబ్జెక్ట్ ఓరియెంటెడ్ ప్రోగ్రామింగ్ లాంగ్వేజ్

ఆబ్జెక్ట్-ఓరియెంటెడ్ ప్రోగ్రామింగ్ విధానం ఏమిటంటే సి # పదునైనది ప్రోగ్రామర్-స్నేహపూర్వక మరియు ప్రోగ్రామింగ్ భాషను అభివృద్ధి చేయడం మరియు నిర్వహించడం సులభం.

• టైప్-సేఫ్ లాంగ్వేజ్

టైప్-సేఫ్ యొక్క అర్థం ఏమిటంటే, కంపైలర్ అమలు చేయడానికి అనుమతి ఉన్న మెమరీ స్థానానికి మాత్రమే యాక్సెస్ ఇవ్వబడుతుంది. ఈ లక్షణం కోడ్ భద్రతను ఎక్స్‌పోనెన్షియల్ స్థాయికి మెరుగుపరుస్తుంది.

• ఇంటర్‌పెరాబిలిటీ

ఇంటర్‌పెరాబిలిటీ యొక్క లక్షణం C ++ ను స్థానికంగా ఉన్న ప్రతిదాన్ని C ++ ను అధిగమింపజేయగల సామర్థ్యాన్ని మరింత సమర్థవంతంగా చేస్తుంది.

• రిచ్ లైబ్రరీ

సి # అభివృద్ధి ప్రక్రియలో గడిపిన సమయాన్ని తగ్గించడానికి ప్రీప్రోగ్రామ్ చేసిన కార్యాచరణలను అందించే అంతర్నిర్మిత లైబ్రరీల యొక్క బహుళ సంఖ్యలకు ప్రాప్తిని అందిస్తుంది.

• స్కేలబుల్ మరియు నవీకరించదగినది

సి # ఇతర ప్రోగ్రామింగ్ భాషలలో ఉన్నతమైనదిగా రూపొందించబడింది. అందువల్ల, ఇది ఎల్లప్పుడూ నవీకరణలకు తెరిచి ఉంటుంది మరియు ఇది దాని లక్షణాలతో అధిక స్కేలబుల్‌గా ఉంచుతుంది.

• భాగం ఓరియంటెడ్

మైక్రోసాఫ్ట్‌లోని డెవలపర్లు సి # ను అభివృద్ధి చేయడానికి భాగం-ఆధారిత విధానాన్ని ఉపయోగించారు. సి # ను అత్యంత స్కేలబుల్ మరియు అప్‌డేట్ చేయడానికి ఇది చాలా ప్రధానమైన అభివృద్ధి పద్దతి.

• నిర్మాణాత్మక భాష

సాఫ్ట్‌వేర్-డెవలప్‌మెంట్ లైఫ్-సైకిల్‌లో స్ట్రక్చర్డ్ ప్రోగ్రామింగ్ విధానం ప్రాధాన్యత ఇవ్వబడుతుంది, ఎందుకంటే ప్రక్రియ-ఆధారిత ప్రోగ్రామింగ్ విధానంతో పోలిస్తే కంపైల్‌ను అభివృద్ధి చేయడం మరియు సాఫ్ట్‌వేర్‌ను అమలు చేయడం సులభం అవుతుంది.

• వేగంగా

C # ప్రోగ్రామింగ్ C ++ మరియు ఇతర ప్రోగ్రామింగ్ భాషలతో పోలిస్తే సంకలనం మరియు అమలులో వేగంగా జరుగుతుంది.

సంస్థాపన

అది నిరూపించబడింది మైక్రోసాఫ్ట్ విజువల్ స్టూడియో సి # ప్రోగ్రామింగ్ కోసం క్లాస్ ఎడిటర్‌లో ఉత్తమమైనది. దిగువ పేర్కొన్న దశలను అనుసరించడం ద్వారా మా సి # ప్రోగ్రామ్‌లను అమలు చేయడానికి మేము మైక్రోసాఫ్ట్ విజువల్ స్టూడియోని ఇన్‌స్టాల్ చేసి సెటప్ చేస్తాము:

దశ 1 : మైక్రోసాఫ్ట్ విజువల్ స్టూడియోని డౌన్‌లోడ్ చేయండి

కోసం గూగుల్ విజువల్ స్టూడియో యొక్క తాజా వెర్షన్ మరియు డౌన్‌లోడ్ చేయండి ఇన్‌స్టాల్ చేయండి మీ స్థానిక సిస్టమ్‌లోకి ఫైల్ చేసి, ఆపై రన్ ఇన్స్టాలర్ ఫైల్ ఒక నిర్వాహకుడు.

దశ 2: .NET డెస్క్‌టాప్ డెవలప్‌మెంట్ ప్యాకేజీని ఎంచుకోండి

మీరు ఇన్‌స్టాలర్‌ను అమలు చేసిన తర్వాత, విజువల్ స్టూడియో ఎడిటర్ మీ స్థానిక సిస్టమ్‌లోకి విజయవంతంగా డౌన్‌లోడ్ చేయబడుతుంది, తరువాత మీ డెస్క్‌టాప్ స్క్రీన్‌లో డైలాగ్ బాక్స్ ప్రదర్శించబడుతుంది. ప్రత్యేక ప్యాకేజీ మీ సిస్టమ్‌లో మీకు అవసరం. ఇక్కడ, మీరు ఎంచుకోవాలి .నెట్ డెస్క్‌టాప్ అభివృద్ధి ప్యాకేజీ.

దశ 3: సి # పర్యావరణాన్ని సెట్ చేయండి

మీ ప్యాకేజీల కోసం ఒకసారి .నెట్ అభివృద్ధి డౌన్‌లోడ్ చేయబడతాయి, అప్పుడు మీరు వెతుకుతున్న అభివృద్ధి వాతావరణాన్ని అడుగుతూ మరొక డైలాగ్ బాక్స్ మీ స్క్రీన్‌లో ప్రదర్శించబడుతుంది. ఇక్కడ, మీరు అవసరం C # కోసం పర్యావరణాన్ని ఎంచుకోండి.

దశ 4: మీ మొదటి ప్రాజెక్ట్‌ను సృష్టించండి

పర్యావరణం ఏర్పడిన తర్వాత, మీరు వెళ్ళడం మంచిది. మీ విజువల్ స్టూడియోని ప్రారంభించి ఎంచుకోండి క్రొత్త ప్రాజెక్ట్ను సృష్టించండి ప్రదర్శించబడిన డైలాగ్ బాక్స్‌లో ఎంపిక.

మీరు తదుపరి డైలాగ్ బాక్స్‌కు మళ్ళించబడతారు మరియు అక్కడ మీరు క్లాస్ లైబ్రరీని ఎంచుకోవాలి .NET ప్రమాణం క్రింద చూపిన విధంగా.

తదుపరి డైలాగ్ బాక్స్‌లో, మిమ్మల్ని అడుగుతారు మీ ప్రాజెక్ట్‌ను కాన్ఫిగర్ చేయండి . దీన్ని కాన్ఫిగర్ చేయండి మరియు మీరు ఇప్పుడు ఎడిటర్‌లో ఉన్నారు. మీ మొదటి ప్రోగ్రామ్‌ను వ్రాయండి మరియు రన్ అది. అవుట్పుట్ విజయవంతంగా ప్రదర్శించబడుతుంది కమాండ్ ప్రాంప్ట్.

సిస్టమ్ క్లాస్ ఎడురేకా ఉపయోగించి {స్టాటిక్ శూన్యత ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {కన్సోల్.రైట్‌లైన్ ('ఎడురేకాకు స్వాగతం!, హ్యాపీ లెర్నింగ్ ..!')}}

// అవుట్పుట్:

మన మొదటి సి # ప్రోగ్రామ్‌ను అమలు చేద్దాం.

సి # ప్రోగ్రామ్ నిర్మాణం

ఇప్పుడు మేము మా మొదటి సి # ప్రోగ్రామ్‌ను అమలు చేసాము, దాని నిర్మాణాన్ని వివరంగా అర్థం చేసుకుందాం. సాధారణ సి # ప్రోగ్రామ్ కింది భాగాలను కలిగి ఉంది.

సిస్టమ్ నేమ్‌స్పేస్ కన్సోల్అప్లికేషన్ 1 {పబ్లిక్ క్లాస్ ఎడురేకా {పబ్లిక్ స్టాటిక్ శూన్యత ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {కన్సోల్.రైట్‌లైన్ ('ఎడురేకాకు స్వాగతం!

// అవుట్పుట్:

ఎడురేకాకు స్వాగతం!, హ్యాపీ లెర్నింగ్ ..!

• తరగతి: తరగతిని సాధారణంగా a గా నిర్వచించవచ్చు కీవర్డ్ C # ప్రోగ్రామ్‌లో తరగతిని నిర్వచించడానికి ఇది ఉపయోగించబడుతుంది.
• ఎడురేకా: ఇది పేరు తరగతి. తరగతి తరచూ బ్లూప్రింట్‌గా పరిగణించబడుతుంది, ఇది తరగతికి సంబంధించిన సభ్యులను మరియు పద్ధతులను నిల్వ చేస్తుంది.
• ప్రధాన: ప్రాథమికంగా ప్రాధమిక పద్ధతి మొత్తం సి # ప్రోగ్రామ్‌లో, ప్రోగ్రామ్‌లోకి ప్రవేశించడానికి నియంత్రణకు ఇది గేట్‌వేగా పనిచేస్తుంది. ప్రోగ్రామ్ యొక్క ఇతర పద్ధతులు అమలు చేయబడటానికి ముందు ఇది అమలు అవుతుంది.
• శూన్యమైనది: కోడ్ యొక్క ఈ విభాగం తిరిగి వచ్చే రకం పద్ధతి యొక్క. ఇది శూన్యమైనది కాకుండా ఏదైనా డేటాటైప్ కావచ్చు. శూన్యత అంటే పద్ధతి నుండి దాని నుండి తిరిగి వచ్చే డేటా లేదు.
• స్టాటిక్: ఇది ఒక కీవర్డ్ ఇది ప్రకటించిన డేటా సభ్యులు స్థిరంగా ఉన్నాయని మరియు ప్రకటించిన సభ్యులకు అంకితమైన మెమరీని కేటాయించారని చెప్పారు.
• స్ట్రింగ్ [] అర్గ్స్: ఇది మా ప్రోగ్రామ్‌లో ఉపయోగించే కమాండ్ లైన్ ఆర్గ్యుమెంట్‌లను పోలి ఉంటుంది. మేము మా ప్రోగ్రామ్‌ను అమలు చేస్తున్నప్పుడు, మేము ప్రాథమికంగా కొన్నింటిని పాస్ చేస్తాము వాదనలు, ఈ స్టేట్మెంట్ కారణంగా ఇది ప్రోగ్రామ్ చేత అంగీకరించబడుతుంది.
• System.Console.WriteLine (“ఎదురేకాకు స్వాగతం!, హ్యాపీ లెర్నింగ్ ..!”) ఇక్కడ, సిస్టమ్ ఉంది నేమ్‌స్పేస్. కన్సోల్వర్గం వివరించబడిందిసిస్టమ్ నేమ్‌స్పేస్‌లో. ది రైట్‌లైన్ () అదిస్టాటిక్టెక్నిక్కన్సోల్వ్రాసేందుకు ఉపయోగించే వర్గంకన్సోల్‌లోని వచనం.

ఇప్పుడు, సి # లో లభించే డేటాటైప్‌లను నేర్చుకుందాం.

డేటాటైప్స్

సి # లోని డేటాటైప్స్ మూడు వర్గాలుగా విభజించబడ్డాయి.

విలువ డేటాటైప్స్

ది విలువ డేటాటైప్స్ లో ఉన్నాయి System.ValueType లైబ్రరీ మరియు ఎల్లప్పుడూ నేరుగా యాక్సెస్ చేయడానికి సిద్ధంగా ఉన్నాయి మరియు వేరియబుల్స్ నేరుగా ఒక నిర్దిష్ట విలువకు కేటాయించబడతాయి. దిగువ చూపిన విధంగా విలువ డేటాటైప్‌లను రెండు రకాలుగా వర్గీకరించారు:

• ముందే నిర్వచించిన డేటాటైప్స్
• వినియోగదారు నిర్వచించిన డేటాటైప్స్

ముందే నిర్వచించిన డేటాటైప్స్: ఇవి మన రోజువారీ ప్రోగ్రామింగ్‌లో సాధారణంగా ఉపయోగించేవి. ఈ డేటాటైప్‌లను భాషా డెవలపర్లు ముందే నిర్వచించారు మరియు ప్రోగ్రామర్‌ల కోసం ఉపయోగించడానికి సిద్ధంగా ఉంచారు.

ఉదాహరణ:

int, float, char, short double, etc

వినియోగదారు నిర్వచించిన డేటాటైప్‌లు: డేటాటైప్‌ల నుండి వేర్వేరు విలువలను ఒకే వేరియబుల్‌లో నిల్వ చేయాల్సిన పరిస్థితులు ఉన్నాయి. ఈ సందర్భాలలో, ది ముందే నిర్వచించిన డేటాటైప్స్ సరిపోదు. వినియోగాదారునిచే నిర్వచించబడినది డేటాటైప్‌లు వినియోగదారుకు అనుకూలీకరించదగిన డేటాటైప్‌ల వంటివి.

ఉదాహరణ: నిర్మాణం, ఎనుమ్

పాయింటర్ డేటాటైప్

పాయింటర్ రకం ఒక సాధారణ డేటాటైప్. దీని కార్యాచరణ సి లోని పాయింటర్లతో పూర్తిగా సమానంగా ఉంటుంది. అవి మరొక పాయింటర్ యొక్క చిరునామాను నిల్వ చేయడానికి రూపొందించబడ్డాయి.

float * ptr

రిఫరెన్స్ డేటాటైప్స్

పేరు స్వీయ వివరణాత్మకమైనది. ది రిఫరెన్స్ డేటాటైప్స్ వాస్తవానికి వేరియబుల్స్ నిల్వ చేయవద్దు, బదులుగా, అవి రిఫరెన్స్ విలువను నిర్దిష్ట వేరియబుల్‌కు నిల్వ చేస్తాయి. మరో మాటలో చెప్పాలంటే, అవి వాస్తవ వేరియబుల్ యొక్క చిరునామాను నిల్వ చేస్తాయి.

క్రింద పేర్కొన్న విధంగా రిఫరెన్స్ వేరియబుల్స్ మూడు వేర్వేరు రకాలుగా వర్గీకరించబడ్డాయి:

• ఆబ్జెక్ట్ రకం

ఆబ్జెక్ట్ డేటాటైప్ సిస్టమ్.ఆబ్జెక్ట్ తరగతి.వస్తువురకాలుఉంటుందికేటాయించబడిందియొక్క విలువలుఇతర రకాలు,సూచనరకాలు, ముందే నిర్వచించిన, వినియోగదారు నిర్వచించినరకాలు. కానీ, ముందుఅప్పగించినవిలువలు, దీనికి అవసరం రకం మార్పిడి.

ఆబ్జెక్ట్ abc abc = 50 // దీనిని బాక్సింగ్ అంటారు

• డైనమిక్ రకం

డైనమిక్ టైప్ వేరియబుల్స్ దాదాపు అన్ని రకాల విలువలను నిల్వ చేయడానికి రూపొందించబడ్డాయి. విలువల టైప్-చెకింగ్ రన్-టైమ్‌లో జరుగుతుంది కాబట్టి దీనిని డైనమిక్ టైప్ అని పిలుస్తారు

డైనమిక్ x = 10

• స్ట్రింగ్ రకం

లో స్ట్రింగ్ రకం అందుబాటులో ఉంది System.String తరగతి. స్ట్రింగ్ రకం స్ట్రింగ్ అక్షరాస్యులను నిల్వ చేయడానికి రూపొందించబడింది. స్ట్రింగ్ లిటరల్స్ రెండు రూపాల్లో నిల్వ చేయబడతాయిరెండు రూపాలు

• • కోట్ చేయబడింది
  • ot కోట్ చేయబడింది.

స్ట్రింగ్ ఎస్ = 'ఎడురేకా'

• ది ot కోట్ చేయబడింది స్ట్రింగ్ అక్షరాలా కనిపిస్తుంది

Ed 'ఎడురేకా'

ఇప్పుడు వేరియబుల్స్ అర్థం చేసుకుందాం.

వేరియబుల్స్

వినియోగదారు ఇచ్చిన నిర్దిష్ట డేటాను నిల్వ చేసే మెమరీ స్థానానికి కేటాయించిన పేర్లు వేరియబుల్స్ మరియు వేరియబుల్ పేరును ఉపయోగించడం ద్వారా డేటాను సులభంగా యాక్సెస్ చేయవచ్చు. సి # లో ఐదు రకాల వేరియబుల్స్ అందుబాటులో ఉన్నాయి

ఉదాహరణ:

int a, b డబుల్ x ఫ్లోట్ పి చార్ ఎబిసి

C # లో వేరియబుల్స్ ప్రకటించడానికి అనుసరించాల్సిన నియమాలు

• వేరియబుల్‌లో వర్ణమాలలు, అంకెలు మరియు అండర్ స్కోర్‌లు ఉంటాయి.
• వేరియబుల్ పేరు వర్ణమాలతో లేదా అండర్ స్కోర్‌తో మాత్రమే ప్రారంభమవుతుంది.
• వేరియబుల్స్ అంకె లేదా ప్రత్యేక అక్షరంతో ప్రారంభించబడవు.
• వేరియబుల్ పేరు మధ్య తెల్లని ఖాళీలు అనుమతించబడవు.
• రిజర్వు చేసిన కీలకపదాలు వేరియబుల్ పేర్లుగా ఉపయోగించకుండా పరిమితం చేయబడ్డాయి.

ఆపరేటర్లు

ఒక ఆపరేటర్‌ను ఒక ప్రత్యేక గణితాన్ని నిర్వహించడానికి కంప్యూటర్‌ను వివరించే ప్రత్యేక చిహ్నంగా నిర్వచించవచ్చు, ఇది వేరియబుల్స్ సమితిపై లాజికల్ ఆపరేషన్. సి # క్రింద పేర్కొన్న వివిధ రకాల ఆపరేటర్లను కలిగి ఉంది.

• అంకగణిత ఆపరేటర్లు
• రిలేషనల్ ఆపరేటర్లు
• లాజికల్ ఆపరేటర్లు
• బిట్‌వైస్ ఆపరేటర్లు
• అసైన్మెంట్ ఆపరేటర్లు

అంకగణిత ఆపరేటర్లు

రిలేషనల్ ఆపరేటర్లు

లాజికల్ ఆపరేటర్లు

బిట్‌వైస్ ఆపరేటర్లు

అసైన్మెంట్ ఆపరేటర్లు

ఉచ్చులు

TO లూప్ ఒక నిర్దిష్ట షరతు సంతృప్తి చెందే వరకు స్టేట్‌మెంట్ యొక్క బ్లాక్‌ను పదేపదే అమలు చేయడానికి స్టేట్‌మెంట్ ఉపయోగించబడుతుంది. సి # భాష కింది లూప్ స్టేట్‌మెంట్‌లను కలిగి ఉంటుంది.

• లూప్ కోసం
• లూప్ అయితే
• లూప్ చేస్తున్నప్పుడు చేయండి

లూప్ కోసం

ది లూప్ కోసం ఇచ్చిన షరతు సంతృప్తి చెందే వరకు నిర్దిష్ట కోడ్ విభాగాన్ని అనేకసార్లు అమలు చేయడానికి ఉపయోగిస్తారు.

సింటాక్స్

(ప్రారంభ స్థితి పెరుగుదల / తగ్గింపు) {// కోడ్ విభాగం}

ఫ్లోచార్ట్:

ఉదాహరణ:

సిస్టమ్ పబ్లిక్ క్లాస్ ForExample {పబ్లిక్ స్టాటిక్ శూన్యత ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {(int i = 1 i<= 5 i++) { Console.WriteLine(i) } } } 

// అవుట్పుట్:

ఒకటి
2
3
4
5

లూప్ అయితే

ది లూప్ అయితే ఒక నిర్దిష్ట పరిస్థితి సంతృప్తి చెందే వరకు అనేక సార్లు కోడ్ విభాగాన్ని అమలు చేయడానికి ఉపయోగించబడుతుంది.

సింటాక్స్

(షరతు) {// కోడ్ అమలు చేయాలి}

ఫ్లోచార్ట్:

ఉదాహరణ:

సిస్టమ్ నేమ్‌స్పేస్ లూప్‌లను ఉపయోగించడం {క్లాస్ ప్రోగ్రామ్ {స్టాటిక్ శూన్యత ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {int x = 5 అయితే (x<= 10) { Console.WriteLine('The value of a: {0}', x) x++ } Console.ReadLine() } } } 

// అవుట్పుట్:

విలువ: 5
విలువ: 6
విలువ: 7
A యొక్క విలువ: 8
విలువ: 9
విలువ: 10

లూప్ చేస్తున్నప్పుడు చేయండి

లూప్ అయితే లూప్ పూర్తిగా సమానంగా ఉంటుంది, అయితే తేడా ఏమిటంటే పరిస్థితి లూప్ చివరిలో ఉంచబడుతుంది. అందువల్ల, లూప్ కనీసం ఒక్కసారైనా అమలు అవుతుంది.

సింటాక్స్

condition // అమలు చేయవలసిన కోడ్} అయితే (షరతు)

ఫ్లోచార్ట్:

ఉదాహరణ:

సిస్టమ్ నేమ్‌స్పేస్ ఉపయోగించి ఎడురేకా {క్లాస్ డోవిల్లేప్ {పబ్లిక్ స్టాటిక్ శూన్యత ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {int i = 1, n = 5, ఉత్పత్తి చేయండి {product = n * i కన్సోల్.రైట్‌లైన్ ('{0} * {1} = { 2} ', n, i, ఉత్పత్తి) i ++} అయితే (i<= 10) } } } 

// అవుట్పుట్:

5 * 1 = 5
5 * 2 = 10
5 * 3 = 15
5 * 4 = 20
5 * 5 = 25
5 * 6 = 30
5 * 7 = 35
5 * 8 = 40
5 * 9 = 45
5 * 10 = 50

షరతులతో కూడినది

షరతులతో కూడిన ప్రకటనలు అమలు చేయడానికి ఉపయోగిస్తారు ప్రకటన లేదా సమూహం ప్రకటనలు కొన్ని షరతుల ఆధారంగా. ఉంటే పరిస్థితి అప్పుడు నిజం సి # ప్రకటనలు లేకపోతే తదుపరి అమలు చేయబడతాయి ప్రకటన అమలు చేయబడుతుంది.

సి ++ భాషలో వివిధ రకాల షరతులతో కూడిన ప్రకటనలు ఈ క్రింది విధంగా ఉన్నాయి:

1. స్టేట్మెంట్ ఉంటే
2. ఉంటే-వేరే ప్రకటన
3. Nested If-else స్టేట్మెంట్
4. ఒకవేళ నిచ్చెన ఉంటే
5. స్టేట్మెంట్ మార్చండి

స్టేట్మెంట్ ఉంటే

సింగిల్ ఉంటే షరతు నిజమైతే కోడ్‌ను అమలు చేయడానికి సి # భాషలోని స్టేట్‌మెంట్ ఉపయోగించబడుతుంది. దీనిని వన్-వే సెలక్షన్ స్టేట్మెంట్ అని కూడా అంటారు.

సింటాక్స్

if (బూలియన్-వ్యక్తీకరణ) bo // బూలియన్-వ్యక్తీకరణ నిజమైతే స్టేట్మెంట్లు అమలు చేయబడతాయి}

ఫ్లోచార్ట్:

ఉదాహరణ:

సిస్టమ్ నేమ్‌స్పేస్‌ను ఉపయోగించడం షరతులతో కూడిన {క్లాస్ ఇఫ్‌స్టేట్‌మెంట్ {పబ్లిక్ స్టాటిక్ శూన్యత ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {పూర్ణాంక సంఖ్య = 2 ఉంటే (సంఖ్య<5) { Console.WriteLine('{0} is less than 5', number) } Console.WriteLine('This statement is always executed.') } } } 

// అవుట్పుట్:

2 5 కన్నా తక్కువ
ఈ ప్రకటన ఎల్లప్పుడూ అమలు చేయబడుతుంది.

ఉంటే-వేరే ప్రకటన

ది if-else షరతు నిజం లేదా తప్పు అయితే కోడ్‌ను అమలు చేయడానికి సి భాషలో స్టేట్‌మెంట్ ఉపయోగించబడుతుంది. దీనిని టూ-వే సెలక్షన్ స్టేట్మెంట్ అని కూడా అంటారు.

సింటాక్స్

if (బూలియన్-ఎక్స్‌ప్రెషన్) {// బూలియన్-ఎక్స్‌ప్రెషన్ నిజమైతే స్టేట్‌మెంట్‌లు అమలు చేయబడతాయి} else {// బూలియన్-ఎక్స్‌ప్రెషన్ తప్పు అయితే స్టేట్‌మెంట్‌లు అమలు చేయబడతాయి}

ఫ్లోచార్ట్:

ఉదాహరణ:

సిస్టమ్ నేమ్‌స్పేస్‌ను ఉపయోగించడం షరతులతో కూడిన {తరగతి IfElseStatement {పబ్లిక్ స్టాటిక్ శూన్యత ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {int సంఖ్య = 12 if (సంఖ్య<5) { Console.WriteLine('{0} is less than 5', number) } else { Console.WriteLine('{0} is greater than or equal to 5', number) } Console.WriteLine('This statement is always executed.') } } } 

// అవుట్పుట్:

12 5 కంటే ఎక్కువ లేదా సమానం
ఈ ప్రకటన ఎల్లప్పుడూ అమలు చేయబడుతుంది.

Nested If-else స్టేట్మెంట్

గూడు if-else ఒక ప్రోగ్రామ్‌కు ఒకటి కంటే ఎక్కువ పరీక్ష వ్యక్తీకరణలు అవసరమైనప్పుడు స్టేట్‌మెంట్ ఉపయోగించబడుతుంది. దీనిని మల్టీ-వే సెలక్షన్ స్టేట్మెంట్ అని కూడా అంటారు. నిర్ణయం యొక్క శ్రేణి ఒక ప్రకటనలో పాల్గొన్నప్పుడు, మేము ఉపయోగిస్తాము if-else సమూహ రూపంలో ప్రకటన.

సింటాక్స్

if (బూలియన్-వ్యక్తీకరణ) {if (nested-expression-1) {// అమలు చేయవలసిన కోడ్} else {// అమలు చేయవలసిన కోడ్}} else {if (nested-expression-2) {// కోడ్ అమలు చేయబడాలి } else {// అమలు చేయవలసిన కోడ్}}

ఫ్లోచార్ట్:

ఉదాహరణ:

సిస్టమ్ నేమ్‌స్పేస్ ఉపయోగించి షరతులతో కూడిన {క్లాస్ నెస్టెడ్ {పబ్లిక్ స్టాటిక్ శూన్యత ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {int మొదటి = 7, రెండవ = -23, మూడవ = 13 ఉంటే (మొదటి & జిటి రెండవ) {if (మొదటి
 // అవుట్పుట్: 
13 అతిపెద్దది
 లేకపోతే-నిచ్చెన 
ది  if-else-if  బహుళ షరతుల నుండి ఒక కోడ్‌ను అమలు చేయడానికి స్టేట్‌మెంట్ ఉపయోగించబడుతుంది. దీనిని మల్టీపాత్ డెసిషన్ స్టేట్మెంట్ అని కూడా అంటారు. ఇది if..else స్టేట్మెంట్ల గొలుసు, దీనిలో ప్రతి స్టేట్మెంట్ వేరే దానితో సంబంధం కలిగి ఉంటే స్టేట్మెంట్ మరియు చివరిది వేరే స్టేట్మెంట్.
 సింటాక్స్ 
if (condition1) condition // కండిషన్ 1 నిజమైతే అమలు చేయవలసిన కోడ్} లేకపోతే (condition2) condition // కండిషన్ 2 నిజమైతే అమలు చేయాలి} లేకపోతే (condition3) condition // కండిషన్ 3 నిజమైతే అమలు చేయాలి} ... else conditions // అన్ని షరతులు తప్పుగా ఉంటే కోడ్ అమలు చేయాలి}
 ఫ్లోచార్ట్: 
 ఉదాహరణ: 
సిస్టమ్ క్లాస్ ఎడురేకా {పబ్లిక్ స్టాటిక్ శూన్యత మెయిన్ (స్ట్రింగ్ [] అర్గ్స్) {int i = 20 if (i == 10) కన్సోల్.రైట్‌లైన్ ('నేను 10') లేకపోతే (i == 15) కన్సోల్.రైట్‌లైన్ (' (15 =) లేకపోతే (i == 20) కన్సోల్.రైట్‌లైన్ ('నేను 20') వేరే కన్సోల్.రైట్‌లైన్ ('నేను లేను')}}
 // అవుట్పుట్: 
నాకు 20 ఏళ్లు
 స్టేట్మెంట్ మార్చండి 
 మారండి  కేసుల జాబితాను పరీక్షించడానికి ఉపయోగించే నిచ్చెన ఉంటే స్టేట్మెంట్ ప్రత్యామ్నాయంగా పనిచేస్తుంది. స్విచ్ స్టేట్మెంట్ ఒకటి లేదా అంతకంటే ఎక్కువ కేస్ లేబుళ్ళను కలిగి ఉంటుంది, ఇవి స్విచ్ వ్యక్తీకరణకు వ్యతిరేకంగా పరీక్షించబడతాయి. వ్యక్తీకరణ ఒక కేసుతో సరిపోలినప్పుడు, ఆ కేసుతో అనుబంధ ప్రకటనలు అమలు చేయబడతాయి.
 సింటాక్స్ 
స్విచ్ (వేరియబుల్ / ఎక్స్‌ప్రెషన్) {కేస్ వాల్యూ 1: // ఎక్స్‌ప్రెషన్ (లేదా వేరియబుల్) = వాల్యూ 1 బ్రేక్ కేస్ వాల్యూ 2: // స్టేట్‌మెంట్స్ ఎగ్జిక్యూట్ అయితే ఎక్స్‌ప్రెషన్ (లేదా వేరియబుల్) = వాల్యూ 1 బ్రేక్ ... ... ... .. . ... ... డిఫాల్ట్: // కేసులు సరిపోలకపోతే స్టేట్‌మెంట్‌లు అమలు చేయబడతాయి}
 ఫ్లోచార్ట్: 
 ఉదాహరణ: 
సిస్టమ్ నేమ్‌స్పేస్‌ను ఉపయోగించడం షరతులతో కూడిన {క్లాస్ స్విచ్‌కేస్ {పబ్లిక్ స్టాటిక్ శూన్యత ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {చార్ చ కన్సోల్.రైట్‌లైన్ ('వర్ణమాలను నమోదు చేయండి') ch = కన్వర్ట్ చేయండి. టోచార్ (కన్సోల్.రెడ్‌లైన్ ()) స్విచ్ (చార్. )) {case 'a': కన్సోల్.రైట్‌లైన్ ('అచ్చు') బ్రేక్ కేసు 'e': కన్సోల్.రైట్‌లైన్ ('అచ్చు') బ్రేక్ కేసు 'i': కన్సోల్.రైట్‌లైన్ ('అచ్చు') బ్రేక్ కేసు 'o': కన్సోల్.రైట్‌లైన్ ('అచ్చు') బ్రేక్ కేసు 'యు': కన్సోల్.రైట్‌లైన్ ('అచ్చు') డిఫాల్ట్: బ్రేక్ డిఫాల్ట్: కన్సోల్.రైట్‌లైన్ ('అచ్చు కాదు') బ్రేక్}}}}
 // అవుట్పుట్: 
వర్ణమాలను నమోదు చేయండి 
 ఉంది 
 అచ్చు
 తీగలను 
 స్ట్రింగ్ డేటాటైప్ సభ్యుడు System.String తరగతి. ఇది అక్షర రకం డేటాను నిల్వ చేయగలదు. వంటి స్టింగ్స్‌లో మేము వివిధ ఆపరేషన్లు చేయవచ్చుసంయోగం, పోలిక, సబ్‌స్ట్రింగ్ పొందడం, శోధన, ట్రిమ్, పున ment స్థాపన మరియు మరెన్నో.
 స్ట్రింగ్ మరియు స్ట్రింగ్ యొక్క సారూప్యత 
సి # లో స్ట్రింగ్ మరియు స్ట్రింగ్ సమానం. స్ట్రింగ్ అనే పదం a కీవర్డ్ మరియు పనిచేస్తుంది System.String తరగతి. తీగలను ప్రకటించడానికి మేము సంస్కరణల్లో దేనినైనా ఉపయోగించవచ్చు.
 సింటాక్స్: 
స్ట్రింగ్ s1 = 'ఎడురేకా' // స్ట్రింగ్ కీవర్డ్ ఉపయోగించి స్ట్రింగ్ సృష్టించడం స్ట్రింగ్ s2 = 'హ్యాపీ లెర్నింగ్' // స్ట్రింగ్ క్లాస్ ఉపయోగించి స్ట్రింగ్ సృష్టించడం
 ఉదాహరణ: 
సిస్టమ్ పబ్లిక్ క్లాస్‌ను ఉపయోగించి p ',' ',' T ',' u ',' t ',' o ',' r ',' i ',' a ',' l '} string s2 = new string (ch) Console.WriteLine ( s1) కన్సోల్.రైట్‌లైన్ (s2)}}
 // అవుట్పుట్: 
ఎడురేకా 
 Csharp ట్యుటోరియల్
 సి # లో స్ట్రింగ్ పద్ధతులు 
 విధానం 
 వివరణ 
 క్లోన్ () 
స్ట్రింగ్ యొక్క ఈ ఉదాహరణకి సూచనను తిరిగి ఇవ్వడానికి ఉపయోగిస్తారు.
 పోల్చండి (స్ట్రింగ్, స్ట్రింగ్) 
పేర్కొన్న రెండు స్ట్రింగ్ వస్తువులను పోల్చడానికి ఉపయోగిస్తారు.
 కాంకాట్ (స్ట్రింగ్, స్ట్రింగ్) 
స్ట్రింగ్ యొక్క పేర్కొన్న రెండు సందర్భాలను సంగ్రహించండి.
 (స్ట్రింగ్) కలిగి ఉంది 
పేర్కొన్న ఉప-స్ట్రింగ్‌ను సూచించే విలువను తిరిగి ఇవ్వండి
 కాపీ (స్ట్రింగ్) 
అదే విలువతో స్ట్రింగ్ యొక్క క్రొత్త ఉదాహరణను సృష్టించడానికి ఉపయోగిస్తారు
 కాపీటో (Int, Char [], Int, Int) 
పేర్కొన్న స్థానం నుండి అక్షరాలను కాపీ చేస్తుంది
 సమానం (స్ట్రింగ్, స్ట్రింగ్) 
రెండు స్ట్రింగ్ వస్తువులు ఒకే విలువను కలిగి ఉన్నాయని నిర్ణయిస్తుంది.
 ఫార్మాట్ (స్ట్రింగ్, ఆబ్జెక్ట్) 
పేర్కొన్న స్ట్రింగ్‌లో ఒకటి లేదా అంతకంటే ఎక్కువ ఫార్మాట్ అంశాలను భర్తీ చేయండి
 ఇండెక్స్ఆఫ్ (స్ట్రింగ్) 
మొదటి సంఘటన యొక్క సున్నా-ఆధారిత సూచికను నివేదిస్తుంది
 చొప్పించు (Int32, స్ట్రింగ్) 
ఇండెక్స్ వద్ద స్ట్రింగ్ చొప్పించిన క్రొత్త స్ట్రింగ్‌ను అందిస్తుంది.
 IsInterned (స్ట్రింగ్) 
ఈ స్ట్రింగ్ యూనికోడ్ సాధారణీకరణ రూపంలో ఉందని సూచిస్తుంది.
 IsNullOrEmpty (స్ట్రింగ్) 
పేర్కొన్న స్ట్రింగ్ శూన్యమైనది లేదా ఖాళీ స్ట్రింగ్ అని సూచిస్తుంది.
 IsNullOrWhiteSpace (స్ట్రింగ్) 
పేర్కొన్న స్ట్రింగ్ శూన్యంగా ఉందా, ఖాళీగా ఉందో లేదో సూచించడానికి ఉపయోగిస్తారు
 చేరండి (స్ట్రింగ్, స్ట్రింగ్ []) 
స్ట్రింగ్ శ్రేణి యొక్క అన్ని అంశాలను సంగ్రహించడానికి ఉపయోగిస్తారు
 లాస్ట్ఇండెక్స్ఆఫ్ (చార్) 
చివరి అక్షరం యొక్క సున్నా-ఆధారిత సూచిక స్థానాన్ని నివేదిస్తుంది
 LastIndexOfAny (చార్ []) 
చివరి అక్షరం యొక్క సున్నా-ఆధారిత సూచిక స్థానాన్ని నివేదిస్తుంది
 తొలగించు (Int32) 
అన్ని అక్షరాలు ఉన్న క్రొత్త స్ట్రింగ్‌ను అందిస్తుంది
 భర్తీ చేయండి (స్ట్రింగ్, స్ట్రింగ్) 
స్ట్రింగ్ యొక్క అన్ని సంఘటనలు కొత్త స్ట్రింగ్‌ను చూపుతాయి
 స్ప్లిట్ (చార్ []) 
ఇది స్ట్రింగ్‌ను సబ్‌స్ట్రింగ్‌లుగా విభజించడానికి ఉపయోగిస్తారు
 స్టార్ట్స్ విత్ (స్ట్రింగ్) 
ఈ స్ట్రింగ్ ప్రారంభం కాదా అని తనిఖీ చేయడానికి ఇది ఉపయోగించబడుతుంది
 సబ్‌స్ట్రింగ్ (Int32) 
ఈ ఉదాహరణ నుండి ఒక సబ్‌స్ట్రింగ్‌ను తిరిగి పొందడానికి ఇది ఉపయోగించబడుతుంది.
 తోచార్అర్రే () 
ఈ సందర్భంలో ఉన్న అక్షరాలను యూనికోడ్ శ్రేణికి కాపీ చేస్తుంది.
 ToString () 
ఇది స్ట్రింగ్ యొక్క ఉదాహరణను తిరిగి ఇవ్వడానికి ఉపయోగించబడుతుంది.
 ట్రిమ్ () 
స్ట్రింగ్‌ను కత్తిరిస్తుంది
  
శ్రేణులు 
ఇతర ప్రోగ్రామింగ్ భాషల మాదిరిగానే, C # కి శ్రేణులు ఉన్నాయి. శ్రేణులు ఒక సాధారణ డేటా నిర్మాణాలు, ఇవి మూలకాల యొక్క ఒకే డేటాటైప్‌ను ఒక మెమరీ ప్రదేశంలో నిల్వ చేయడానికి రూపొందించబడ్డాయి.
సి # కింది శ్రేణి రకాలను సపోర్ట్ చేస్తుంది.
సింగిల్ డైమెన్షనల్ అర్రే
మల్టీ డైమెన్షనల్ అర్రే
బెల్లం అర్రే
 సింగిల్ డైమెన్షనల్ అర్రే 
సింగిల్ డైమెన్షనల్ అర్రే మూలకాలను ఒకే వరుస రూపంలో నిల్వ చేస్తుంది.
 సింటాక్స్ 
int [] arr = new int [5] // శ్రేణిని సృష్టిస్తోంది
 ఉదాహరణ: 
సిస్టమ్ పబ్లిక్ క్లాస్ అర్రేఎక్సాంపుల్ {పబ్లిక్ స్టాటిక్ శూన్యత ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {int [] arr = new int [5] arr [0] = 10 arr [1] = 20 arr [2] = 30 arr [3] = (Int i = 0 i కోసం 40 arr [4] = 50 
 // అవుట్పుట్: 
10 
 ఇరవై 
 30 
 40 
 యాభై
 మల్టీ డైమెన్షనల్ అర్రే 
మల్టీడైమెన్షనల్ అర్రే ఒక మాతృక మరియు క్యూబ్ వంటి బహుళ కొలతలు రూపంలో అంశాలను నిల్వ చేస్తుంది.
 సింటాక్స్ 
int val = a [2,3]
 ఉదాహరణ: 
సిస్టమ్ నేమ్‌స్పేస్ అర్రేఅప్లికేషన్ {క్లాస్ మైఅర్రే {స్టాటిక్ శూన్యత ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {int [,] a = new int [5, 2] {{0, 0}, {1, 2}, {2, 4}, {3, 6}, {4, 8}} int i, j for (i = 0 i<5 i++) { for (j = 0 j < 2 j++) { Console.WriteLine('a[{0},{1}] = {2}', i, j, a[i, j]) } } Console.ReadKey() } } } 
 // అవుట్పుట్: 
a [0,0] = 0 
 a [0,1] = 0 
 a [1,0] = 1 
 a [1,1] = 2 
 a [2,0] = 2 
 a [2,1] = 4 
 a [3,0] = 3 
 a [3,1] = 6 
 a [4,0] = 4 
 a [4,1] = 8
  
 బెల్లం అర్రే 
జాగ్డ్ అర్రే కేవలం శ్రేణుల శ్రేణి.
 ఉదాహరణ: 
సిస్టమ్ నేమ్‌స్పేస్ అర్రేఅప్లికేషన్ {క్లాస్ మైఅర్రే {స్టాటిక్ శూన్యత ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {int [] [] a = new int [] [] {new int [] {0,0}, new int [] {1,2 }, క్రొత్త పూర్ణాంకానికి [] {2,4}, కొత్త పూర్ణాంకానికి [] {3, 6}, క్రొత్త పూర్ణాంకానికి [] {4, 8}} పూర్ణాంకానికి, j కోసం (i = 0 i<5 i++) { for (j = 0 j < 2 j++) { Console.WriteLine('a[{0}][{1}] = {2}', i, j, a[i][j]) } } Console.ReadKey() } } } 
 // అవుట్పుట్: 
a [0] [0] = 0 
 a [0] [1] = 0 
 a [1] [0] = 1 
 a [1] [1] = 2 
 a [2] [0] = 2 
 a [2] [1] = 4 
 a [3] [0] = 3 
 a [3] [1] = 6 
 a [4] [0] = 4 
 a [4] [1] = 8
 సేకరణలు 
సేకరించిన డేటాపై కొన్ని విధులను వర్తింపజేయడానికి సేకరణను కలిసి సేకరించిన వస్తువుల సమూహంగా పరిగణించవచ్చు. ఒకప్పుడు సేకరణలో చేసే కార్యకలాపాలు,
స్టోర్ వస్తువు
నవీకరణ వస్తువు
వస్తువును తొలగించండి
వస్తువును తిరిగి పొందండి
శోధన వస్తువు మరియు
క్రమబద్ధీకరించు వస్తువు
 సేకరణల రకాలు 
సేకరణలతో పనిచేయడానికి మూడు వేర్వేరు అవకాశాలు ఉన్నాయి. మూడు నేమ్‌స్పేస్‌లు క్రింద పేర్కొనబడ్డాయి:
 System.Collections.Generic  తరగతులు
 సిస్టమ్. సేకరణలు  తరగతులు
 System.Collections.Concurrent  తరగతులు
System.Collections.Generic క్లాస్ కింది రకాల తరగతులను కలిగి ఉంది:
జాబితా
స్టాక్
క్యూ
లింక్డ్లిస్ట్
హాష్‌సెట్
క్రమబద్ధీకరించబడింది
నిఘంటువు
క్రమబద్ధీకరించిన నిఘంటువు
క్రమబద్ధీకరించిన జాబితా
ది సిస్టమ్. సేకరణలు తరగతులను లెగసీ తరగతులుగా పరిగణిస్తారు. అవి క్రింది తరగతులను కలిగి ఉంటాయి.
శ్రేణి జాబితా
స్టాక్
క్యూ
హాష్ టేబుల్
ది System.Collections.Concurrent  తరగతులునేమ్‌స్పేస్ థ్రెడ్-సేఫ్ ఆపరేషన్ల కోసం తరగతులను అందిస్తుంది. సేకరణ అంశాలను ప్రాప్యత చేయడానికి ఇప్పుడు బహుళ థ్రెడ్‌లు సమస్యను సృష్టించవు. ఇందులో అందుబాటులో ఉన్న తరగతులు,
బ్లాకింగ్ కలెక్షన్
ఏకకాలిక బ్యాగ్
ఏకకాలిక స్టాక్
ఏకకాలిక క్యూ
ఏకకాలిక నిఘంటువు
విభజనలు
విభజనలు
ఆర్డరబుల్ పార్టిషనర్
 జాబితా 
ది జాబితా లో లభించే డేటా నిర్మాణంగా పరిగణించబడుతుంది System.Collection.Generics నేమ్‌స్పేస్. ఇది మూలకాలను నిల్వ చేయవచ్చు మరియు పొందగలదు. జాబితా నకిలీ అంశాలను నిల్వ చేయగలదు.
 ఉదాహరణ: 
System.Collections.Generic public class Edureka {పబ్లిక్ స్టాటిక్ శూన్యత ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {var పేర్లు = క్రొత్త జాబితా () పేర్లు. ('సంధ్య') పేర్లను జోడించండి. ('అరుణ్') పేర్లను జోడించండి. 'ప్రశాంత్') పేర్లు. ('కిరణ్') ఫోరచ్ (పేర్లలో వర్ పేరు) {కన్సోల్.రైట్‌లైన్ (పేరు)}}}
 // అవుట్పుట్: 
సంధ్య 
 అరుణ్ 
 ప్రశాంత్ 
 కిరణ్
 హాష్ సెట్ 
సి # హాష్‌సెట్వర్గం తరచుగా అలవాటు పడిందిస్టోర్,తీసివేయండిలేదాభాగాలు చదవండి. ఇదిలేదునకిలీ నిల్వభాగాలు.ఇది కోరబడిందిఉపయోగించడానికి హాష్‌సెట్  వర్గంఉంటేమీరు పొందారుదాచిపెట్టటంపూర్తిగా  విలక్షణమైనది   భాగాలు . అది System.Collections.Generic నేమ్‌స్పేస్‌లో కనుగొనబడింది.
 ఉదాహరణ: 
System.Collections.Generic public class Edureka {పబ్లిక్ స్టాటిక్ శూన్యత ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {var పేర్లు = కొత్త హాష్‌సెట్ () పేర్లు. ('సునీల్') పేర్లను జోడించండి. ('అమర్') పేర్లను జోడించండి. 'పూజారి') పేర్లు. ('ఇమ్రాన్') పేర్లను జోడించండి. ('కరణ్') ఫోరచ్ (పేర్లలో వర్ పేరు) {కన్సోల్.రైట్‌లైన్ (పేరు)}}}
 // అవుట్పుట్: 
సునీల్ 
 అమర్ 
 పూజారి 
 ఇమ్రాన్ 
 కరణ్
 క్రమబద్ధీకరించిన సెట్ 
సి # సార్ట్‌సెట్తరగతి తరచుగా అలవాటు పడిందిస్టోర్, తొలగించండి లేదా చదవండి   అంశాలు . ఇది ఆరోహణ క్రమాన్ని నిర్వహిస్తుంది మరియులేదునకిలీ నిల్వఅంశాలు.ఇది ప్రాంప్ట్SortedSet ఉపయోగించడానికివర్గంఉంటేమీరు పొందారుదాచిపెట్టటం విలక్షణమైనది   భాగాలు మరియు ఆరోహణ క్రమాన్ని నిర్వహించండి.అదిSystem.Collections.Generic నేమ్‌స్పేస్‌లో కనుగొనబడింది.
 ఉదాహరణ: 
System.Collections.Generic public class Edureka {public static void Main (string [] args) {var names = new SortedSet () పేర్లు. ('సంజయ్') పేర్లను జోడించండి. ('అనురాధ') పేర్లను జోడించండి. 'ప్రవీణ్') పేర్లు. ('రవి') పేర్లను జోడించండి. ('కాజోల్') ఫోరచ్ (పేర్లలో వర్ పేరు) {కన్సోల్.రైట్‌లైన్ (పేరు)}}}
 // అవుట్పుట్: 
అనురాధ 
 కాజోల్ 
 ప్రవీణ్ 
 రవి 
 సంజయ్
 స్టాక్ 
ది స్టాక్ అనుసరించే సాధారణ సేకరణ ఎడ్జ్ లేదా దానిలో నిల్వ చేసిన మూలకాలను ప్రాసెస్ చేసేటప్పుడు చివరి విధానంలో మొదట.
 ఉదాహరణ: 
System.Collections.Generic public class Edureka {పబ్లిక్ స్టాటిక్ శూన్యత ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {స్టాక్ పేర్లు = కొత్త స్టాక్ () పేర్లు. పుష్ ('చందన్') పేర్లు.పుష్ ​​('పూజా') పేర్లు.పష్ ( 'జేమ్స్') పేర్లు.పుష్ ​​('రాజేష్') పేర్లు.పుష్ ​​('కుమార్') ఫోరచ్ (పేర్లలో స్ట్రింగ్ పేరు) {కన్సోల్.రైట్‌లైన్ (పేరు)} కన్సోల్.రైట్‌లైన్ ('పీక్ ఎలిమెంట్:' + పేర్లు.పీక్ () ) కన్సోల్.రైట్‌లైన్ ('పాప్:' + పేర్లు.పాప్ ()) కన్సోల్.రైట్‌లైన్ ('పాప్ తరువాత, పీక్ ఎలిమెంట్:' + పేర్లు.పీక్ ())}}
 // అవుట్పుట్: 
కుమార్ 
 రాజేష్ 
 జేమ్స్ 
 పూజ 
 చందన్ 
 పీక్ మూలకం: కుమార్ 
 పాప్: కుమార్ 
 పాప్ తరువాత, పీక్ ఎలిమెంట్: రాజేష్
 క్యూ 
క్యూ పూర్తిగా స్టాక్‌తో సమానంగా ఉంటుంది, కానీ ఒకే తేడా ఏమిటంటే క్యూ అనుసరిస్తుంది FIFO లేదా దానిలో నిల్వ చేసిన మూలకాలను ప్రాసెస్ చేసేటప్పుడు మొదటి మరియు మొదటి సూత్రం.
 ఉదాహరణ: 
System.Collections.Generic public class Edureka {పబ్లిక్ స్టాటిక్ శూన్యత ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {క్యూ పేర్లు = కొత్త క్యూ () పేర్లు.ఎంక్యూ ('Srujan') పేర్లు.ఎంక్యూ ('ప్రజత్') పేర్లు.ఎంక్యూ ( 'జాన్') పేర్లు.ఎన్‌క్యూ ('రాజు') పేర్లు.ఎన్‌క్యూ ('హరి') ఫోర్చాచ్ (పేర్లలో స్ట్రింగ్ పేరు) {కన్సోల్.రైట్‌లైన్ (పేరు)} కన్సోల్.రైట్‌లైన్ ('పీక్ ఎలిమెంట్:' + పేర్లు.పీక్ () ) కన్సోల్.రైట్‌లైన్ ('డీక్యూ:' + పేర్లు.డెక్యూ ()) కన్సోల్.రైట్‌లైన్ ('డీక్యూ తరువాత, పీక్ ఎలిమెంట్:' + పేర్లు.పీక్ ())}}
 // అవుట్పుట్: 
శ్రుజన్ 
 ప్రజత్ 
 జాన్ 
 భయంకరమైనది 
 రోజు 
 పీక్ ఎలిమెంట్: స్రుజన్ 
 Dequeue: Srujan 
 డీక్యూ తరువాత, పీక్ ఎలిమెంట్: ప్రజత్
 లింక్డ్ జాబితా 
లింక్ చేయబడిన జాబితా డైనమిక్ మెమరీ సేకరణ. లింక్డ్ జాబితాలోని అంశాలు కుప్ప నుండి మెమరీని యాక్సెస్ చేయడం ద్వారా మరియు వాటి చిరునామాలను లింక్ చేయడం ద్వారా మూలకాలను నిరంతర క్రమంలో నిల్వ చేయడం ద్వారా నిల్వ చేయబడతాయి.
 ఉదాహరణ: 
System.Collections.Generic public class Edureka {పబ్లిక్ స్టాటిక్ శూన్యత ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {var పేర్లు = కొత్త లింక్డ్లిస్ట్ () పేర్లు .అడ్ లాస్ట్ ('రజత్') పేర్లు .అడ్ లాస్ట్ ('అరుణ్') పేర్లు.అడ్ లాస్ట్ ( 'ప్రకాష్') పేర్లు.అడ్ లాస్ట్ ('జే') పేర్లు.అడ్ ఫస్ట్ ('సాయి') ఫోర్చ్ (పేర్లలో వర్ పేరు) {కన్సోల్.రైట్‌లైన్ (పేరు)}}}
 // అవుట్పుట్: 
సాయి 
 హద్దులు 
 అరుణ్ 
 ప్రకాష్ 
 జే
 నిఘంటువు 
 నిఘంటువు  వర్గంఉపయోగిస్తుందిఆలోచనహాష్ టేబుల్ యొక్క. ఇది విలువలను నిల్వ చేస్తుందిఆవరణకీ యొక్క. ఇది కలిగి ఉందివిలక్షణమైనదికీలుపూర్తిగా. ద్వారాసహాయంకీ,మేము సరళంగా చేస్తాముశోధించండి లేదాఅంశాలను తీసివేయండి.అదిSystem.Collections.Generic నేమ్‌స్పేస్‌లో కనుగొనబడింది.
 ఉదాహరణ: 
System.Collections.Generic public class Edureka {పబ్లిక్ స్టాటిక్ శూన్యత ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {నిఘంటువు పేర్లు = కొత్త నిఘంటువు () పేర్లు. ('1', 'శివ') పేర్లను జోడించండి. ('2', 'ప్రసాద్') పేర్లు. ('3', 'ప్రీతం') పేర్లను జోడించండి. ('4', 'రాయ్') పేర్లను జోడించండి. ('5', 'ఆకాష్') ఫోరచ్ (పేర్లలో కీవాల్యూ పెయిర్ కెవి) {కన్సోల్. రైట్‌లైన్ (kv.Key + '' + kv.Value)}}}
 // అవుట్పుట్: 
1 శివ 
 2 ప్రసాద్ 
 3 ప్రీతం 
 4 రాయ్ 
 5ఆకాష్
 క్రమబద్ధీకరించిన నిఘంటువు 
ది క్రమబద్ధీకరించిన నిఘంటువు  వర్గంఉపయోగిస్తుందిరూపకల్పనహాష్ టేబుల్ యొక్క. ఇది విలువలను నిల్వ చేస్తుందిఆలోచనకీ యొక్క. ఇది కలిగి ఉందివిలక్షణమైనదికీలు మరియు ఆరోహణ క్రమాన్ని నిర్వహిస్తుందిఆలోచనకీ యొక్క. ద్వారాసహాయంకీ,మేము సరళంగా చేస్తాముశోధించండి లేదాఅంశాలను తీసివేయండి.అదిSystem.Collections.Generic నేమ్‌స్పేస్‌లో కనుగొనబడింది.
 ఉదాహరణ: 
System.Collections.Generic public class Edureka {పబ్లిక్ స్టాటిక్ శూన్యత ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {SortedDictionary పేర్లు = క్రొత్త క్రమబద్ధీకరించిన నిఘంటువు () పేర్లు. ('1', 'అరుణ్') పేర్లను జోడించండి. ('4', 'విశాల్') పేర్లు. ('5', 'రమేష్') పేర్లను జోడించండి. ('3', 'విద్యా') పేర్లను జోడించండి. ('2', 'పల్లవి') ఫోరచ్ (పేర్లలో కీవాల్యూ పెయిర్ కెవి) {కన్సోల్. రైట్‌లైన్ (kv.Key + '' + kv.Value)}}}
 // అవుట్పుట్: 
1 శివ 
 2 ప్రసాద్ 
 3 ప్రీతం 
 4 రాయ్ 
 5ఆకాష్
 క్రమబద్ధీకరించిన జాబితా 
ది క్రమబద్ధీకరించిన జాబితా ఉందిఒకకీ / విలువ జతల శ్రేణి. ఇది విలువలను నిల్వ చేస్తుందిఆవరణకీ యొక్క. క్రమబద్ధీకరించబడిన జాబితావర్గంకలిగి ఉందివిలక్షణమైనదికీలు మరియు ఆరోహణ క్రమాన్ని నిర్వహిస్తుందిఆవరణకీ యొక్క. ద్వారాసహాయంకీ,మేము సరళంగా చేయగలముశోధించండి లేదా తీసివేయండిఅంశాలు.అదిదొరికింది System.Collections.Generic నేమ్‌స్పేస్.
 ఉదాహరణ: 
System.Collections.Generic public class Edureka {పబ్లిక్ స్టాటిక్ శూన్యత ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {SortedDictionary పేర్లు = క్రొత్త క్రమబద్ధీకరించిన నిఘంటువు () పేర్లు. ('1', 'అరుణ్') పేర్లను జోడించండి. ('4', 'విశాల్') పేర్లు. ('5', 'రమేష్') పేర్లను జోడించండి. ('3', 'విద్యా') పేర్లను జోడించండి. ('2', 'పల్లవి') ఫోరచ్ (పేర్లలో కీవాల్యూ పెయిర్ కెవి) {కన్సోల్. రైట్‌లైన్ (kv.Key + '' + kv.Value)}}}
 // అవుట్పుట్: 
1 అరుణ్ 
 2 Pallavi 
 3 విద్యా 
 4 విశాల్ 
 5రమేష్
 నిర్మాణం 
నిర్మాణం అనేది వివిధ డేటాటైప్ యొక్క బహుళ అంశాలను నిల్వ చేయడానికి రూపొందించబడిన వినియోగదారు-నిర్వచించిన డేటాటైప్. కీవర్డ్ ఉపయోగించి నిర్మాణం ప్రకటించబడింది struct. 
 ఉదాహరణ: 
సిస్టమ్ స్ట్రక్ట్ బుక్స్ {పబ్లిక్ స్ట్రింగ్ టైటిల్ పబ్లిక్ స్ట్రింగ్ రచయిత పబ్లిక్ స్ట్రింగ్ సబ్జెక్ట్ పబ్లిక్ ఇంటెంట్ బుక్_ఐడి} పబ్లిక్ క్లాస్ ఎడురేకా {పబ్లిక్ స్టాటిక్ శూన్యత ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {బుక్స్ బుక్ 1 బుక్స్ బుక్ 2 బుక్ 1. టైటిల్ = 'సి # ప్రోగ్రామింగ్' బుక్ 1.అథోర్ = ' రామ్‌చంద్ర కుమార్ 'Book1.subject =' C ++ ప్రోగ్రామింగ్ ట్యుటోరియల్ 'Book1.book_id = 95908978 Book2.title =' టెలికాం బిల్లింగ్ 'Book2.author =' కరణ్ 'Book2.subject =' టెలికాం బిల్లింగ్ ట్యుటోరియల్ 'Book2.book_id = 18674900 కన్సోల్.రైట్‌లైన్ ( 'బుక్ 1 శీర్షిక: {0}', బుక్ 1. టైటిల్) కన్సోల్.రైట్‌లైన్ ('బుక్ 1 రచయిత: {0}', బుక్ 1.అథోర్) కన్సోల్.రైట్‌లైన్ ('బుక్ 1 విషయం: {0}', బుక్ 1.సబ్జెక్ట్) కన్సోల్.రైట్‌లైన్ ('బుక్ 1 బుక్_ఐడి: {0}', బుక్ 1.బుక్_ఐడి) కన్సోల్.రైట్‌లైన్ ('బుక్ 2 టైటిల్: {0}', బుక్ 2. టైటిల్) కన్సోల్.రైట్‌లైన్ ('బుక్ 2 రచయిత: {0}', Book2.author) Console.WriteLine ('Book 2 subject: {0}', Book2.subject) Console.WriteLine ('Book 2 book_id: {0}', Book2.book_id) Console.ReadKey ()}}
 // అవుట్పుట్: 
పుస్తకం 1 శీర్షిక: సి # ప్రోగ్రామింగ్ 
 పుస్తకం 1 రచయిత: రామ్‌చంద్ర కుమార్ 
 పుస్తకం 1 విషయం: సి ++ ప్రోగ్రామింగ్ ట్యుటోరియల్ 
 పుస్తకం 1 బుక్_ఐడి: 95908978 
 పుస్తకం 2 శీర్షిక: టెలికాం బిల్లింగ్ 
 పుస్తకం 2 రచయిత: కరణ్ 
 బుక్ 2 విషయం: టెలికాం బిల్లింగ్ ట్యుటోరియల్ 
 పుస్తకం 2 బుక్_ఐడి: 18674900
 విధులు 
ఫంక్షన్ ప్రధాన కోడ్ యొక్క కోడ్ యొక్క బ్లాక్గా నిర్వచించబడింది. కోడ్ బ్లాక్‌లో పేర్కొన్న స్టేట్‌మెంట్‌లను అమలు చేయడానికి ఫంక్షన్ ఉపయోగించబడుతుంది. ఒక ఫంక్షన్ కింది భాగాలను కలిగి ఉంటుంది.
 ఫంక్షన్ పేరు:  ఇది ఫంక్షన్ కాల్ చేయడానికి ఉపయోగించే విలక్షణమైన పేరు.
 తిరిగి వచ్చే రకం:  ఇది ఫంక్షన్ రిటర్న్ విలువ యొక్క డేటా రకాన్ని నిర్దేశిస్తుంది.
 శరీరం:  ఇది ఎక్జిక్యూటబుల్ స్టేట్మెంట్లను కలిగి ఉంది.
 ప్రాప్యత నిర్దేశకం:  ఇది అనువర్తనంలో ఫంక్షన్ ప్రాప్యతను నిర్దేశిస్తుంది.
 పారామితులు:  ఇది కాల్ సమయంలో మేము ఫంక్షన్‌కు పంపగల వాదనల జాబితా.
 సింటాక్స్ 
ఫంక్షన్ పేరు () function // ఫంక్షన్ బాడీ // రిటర్న్ స్టేట్మెంట్}
 ఉదాహరణ: 
సిస్టమ్ నేమ్‌స్పేస్ ఫంక్షన్ ఉదాహరణ ఉదాహరణ {క్లాస్ ఎడురేకా {పబ్లిక్ స్ట్రింగ్ షో (స్ట్రింగ్ సందేశం) {కన్సోల్.రైట్‌లైన్ ('ఇన్సైడ్ షో ఫంక్షన్') రిటర్న్ మెసేజ్} స్టాటిక్ శూన్యత ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {ఎడురేకా ప్రోగ్రామ్ = కొత్త ఎడురేకా () ​​స్ట్రింగ్ మెసేజ్ = ప్రోగ్రామ్ .షో ('టు ఎడురేకా') కన్సోల్.రైట్‌లైన్ ('స్వాగతం' + సందేశం)}}}
 // అవుట్పుట్: 
షో ఫంక్షన్ లోపల 
 ఎడురేకాకు స్వాగతం
విధులను 3 రకాలుగా అమలు చేయవచ్చు:
విలువ ద్వారా కాల్ చేయండి
సూచన ద్వారా కాల్ చేయండి
అవుట్ పారామితి
 విలువ ద్వారా కాల్ చేయండి 
సి # లో, విలువ  -టైప్ పారామితులుఉన్నాయిఆ పాస్ఒక ప్రతిరూపంఅసలు విలువబదులుగా ఫంక్షన్సూచన. ఇదిలేదుసవరించండిమొదటి విలువ. ఒకసవరణ సృష్టించబడిందిఆమోదించిందివిలువ లేదువయస్సునిర్దిష్ట విలువ.లోపలక్రింది ఉదాహరణ,మాకు లభించిందిపాస్అంతటా విలువదికాల్.
 ఉదాహరణ: 
సిస్టమ్ నేమ్‌స్పేస్‌ను ఉపయోగించి కాల్‌బైవాల్యూ {క్లాస్ ఎడురేకా {పబ్లిక్ శూన్యత షో (పూర్ణాంక విలువ) {val * = val కన్సోల్.రైట్‌లైన్ ('షో ఫంక్షన్ లోపల విలువ' + వాల్)} స్టాటిక్ శూన్యత ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {int val = 50 ఎడురేకా ప్రోగ్రామ్ = కొత్త ఎడురేకా () ​​కన్సోల్.రైట్‌లైన్ ('ఫంక్షన్‌ను కాల్ చేయడానికి ముందు విలువ' + వాల్) ప్రోగ్రామ్.షో (వాల్) కన్సోల్.రైట్‌లైన్ ('ఫంక్షన్‌ను పిలిచిన తర్వాత విలువ' + వాల్)}}}
// అవుట్పుట్:
ఫంక్షన్ 50 కి కాల్ చేయడానికి ముందు విలువ 
 షో ఫంక్షన్ 2500 లోపల విలువ 
 ఫంక్షన్ 50 కి కాల్ చేసిన తర్వాత విలువ
 సూచన ద్వారా కాల్ చేయండి 
కాల్ బై రిఫరెన్స్ పద్ధతిలో,కు ref సూచన-రకంగా వాదనను పాస్ చేయడానికి కీవర్డ్. ఇది అసలు విలువ యొక్క కాపీ కాకుండా ఫంక్షన్‌కు వాదనల సూచనను పంపుతుంది. ఆమోదించిన విలువలలో మార్పులు శాశ్వతమైనవి మరియు సవరించండి అసలు వేరియబుల్ విలువ.
 ఉదాహరణ: 
సిస్టమ్ నేమ్‌స్పేస్ ఉపయోగించి కాల్‌బై రిఫరెన్స్ {క్లాస్ ఎడురేకా {పబ్లిక్ శూన్య ప్రదర్శన (ref int val) {val * = val Console.WriteLine ('షో ఫంక్షన్ లోపల విలువ' + val)} స్టాటిక్ శూన్యత ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {int val = 50 ఎడురేకా ప్రోగ్రామ్ = కొత్త ఎడురేకా () ​​కన్సోల్.రైట్‌లైన్ ('ఫంక్షన్‌ను కాల్ చేయడానికి ముందు విలువ' + వాల్) ప్రోగ్రామ్.షో (రెఫ్ వాల్) కన్సోల్.రైట్‌లైన్ ('ఫంక్షన్‌ను పిలిచిన తర్వాత విలువ' + వాల్)}}}
// అవుట్పుట్:
ఫంక్షన్ 50 కి కాల్ చేయడానికి ముందు విలువ 
 షో ఫంక్షన్ 2500 లోపల విలువ 
 ఫంక్షన్ 2500 కు కాల్ చేసిన తర్వాత విలువ
 అవుట్ పారామితి 
అవుట్ పారామితిఅందిస్తుంది అవుట్ వాదనలను అవుట్-టైప్ గా పాస్ చేయడానికి కీవర్డ్. ఇది రిఫరెన్స్-టైప్ లాంటిది, తప్ప వెళ్ళే ముందు వేరియబుల్ ప్రారంభించాల్సిన అవసరం లేదు. మనం తప్పక వాడాలి అవుట్ వాదనను అవుట్-టైప్ గా పాస్ చేయడానికి కీవర్డ్. ఒక ఫంక్షన్ బహుళ విలువలను తిరిగి ఇవ్వాలనుకున్నప్పుడు ఇది ఉపయోగపడుతుంది.
 ఉదాహరణ: 
సిస్టమ్ నేమ్‌స్పేస్ ఉపయోగించి అవుట్‌పారామీటర్ {క్లాస్ ఎడురేకా {పబ్లిక్ శూన్యత చూపించు (అవుట్ వాల్) {int స్క్వేర్ = 5 వాల్ = స్క్వేర్ వాల్ * = వాల్} స్టాటిక్ శూన్యత ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {int val = 50 Edureka program = new Edureka () కన్సోల్.రైట్‌లైన్ ('వేరియబుల్ అవుట్ అవ్వడానికి ముందు విలువ' + వాల్) ప్రోగ్రామ్.షో (అవుట్ వాల్) కన్సోల్.రైట్‌లైన్ ('వేరియబుల్‌ను స్వీకరించిన తర్వాత విలువ' + వాల్)}}}
// అవుట్పుట్:
వేరియబుల్ 50 ను దాటడానికి ముందు విలువ
విలువఅవుట్ వేరియబుల్ 25 ను స్వీకరించిన తరువాత
ఇప్పుడు మనం ఆబ్జెక్ట్-ఓరియెంటెడ్ ప్రోగ్రామింగ్‌కి వెళ్దాం
 ఆబ్జెక్ట్ ఓరియెంటెడ్ ప్రోగ్రామింగ్ 
 ఆబ్జెక్ట్-ఓరియెంటెడ్ ప్రోగ్రామింగ్ సిస్టమ్అనే భావన ఆధారంగా ప్రోగ్రామింగ్ ఉదాహరణ వస్తువులు కలిగి డేటా సభ్యులు మరియు పద్ధతులు వారికి సంబంధించినది. ఆబ్జెక్ట్-ఓరియెంటెడ్ ప్రోగ్రామింగ్ యొక్క ప్రాధమిక ఉద్దేశ్యం ప్రోగ్రామ్‌ల యొక్క వశ్యతను మరియు నిర్వహణను పెంచడం
 ఆబ్జెక్ట్-ఓరియెంటెడ్ ప్రోగ్రామింగ్ యొక్క లక్షణాలు: 
ఇది విధానం కంటే డేటాకు ఎక్కువ ప్రాధాన్యత ఇస్తుంది.
ప్రోగ్రామ్‌లను వస్తువులుగా విభజించారు, తద్వారా పని చేయడం సులభం అవుతుంది.
డేటా నిర్మాణాలు వస్తువులను వర్గీకరించే విధంగా రూపొందించబడ్డాయి.
పనిచేసే విధులు పైఒక వస్తువు యొక్క డేటా డేటా నిర్మాణంలో కలిసి ఉంచబడుతుంది.
డేటా దాచబడింది మరియు అనుమతి లేకుండా బాహ్య ఫంక్షన్ల ద్వారా యాక్సెస్ చేయబడదు.
వస్తువుల మధ్య కమ్యూనికేషన్ ఫంక్షన్ల సహాయంతో జరుగుతుంది.
క్రొత్త డేటా మరియు ఫంక్షన్లను జోడించడం సులభం అయింది.
ప్రోగ్రామ్ రూపకల్పనలో బాటప్-అప్ విధానాన్ని అనుసరిస్తుంది.
సి # లోని ఆబ్జెక్ట్ ఓరియెంటెడ్ పారాడిగ్మ్స్ ఈ క్రింది విధంగా ఉన్నాయి
 సి # లో గణన 
 ఆబ్జెక్ట్ ఓరియంటెడ్ ప్రోగ్రామింగ్ అప్రోచ్ 
 ఎన్కప్సులేషన్ 
 సంగ్రహణ 
 ఇంటర్ఫేస్ 
 పాలిమార్ఫిజం 
 వారసత్వం 
 ఓవర్‌లోడింగ్ మరియు ఓవర్‌రైడింగ్ 
 నేమ్‌స్పేస్ 
 ఫైల్ ఆపరేషన్లు 
 సంఘటనలు 
 జెనెరిక్స్ 
 ప్రతినిధులు 
 ప్రతిబింబం 
 సి # లో గణన 
 ఎనుమ్ లేదా ఒక అని కూడా పిలుస్తారు గణన C # ప్రోగ్రామ్ యొక్క మొత్తం అమలు సమయంలో స్థిరమైన విలువలను మార్చకుండా నిల్వ చేయడానికి C # లో ఉపయోగించబడుతుంది. ఇదిసీజన్, రోజులు, నెల, పరిమాణం మొదలైన పేరున్న స్థిరాంకాల సమితిని నిల్వ చేయడానికి ఉపయోగిస్తారు
జావా ఉదాహరణ ప్రోగ్రామ్‌లోని వస్తువుల శ్రేణి
 ఉదాహరణ: 
సిస్టమ్ పబ్లిక్ క్లాస్ ఎనుమ్ఎక్సంపుల్ {పబ్లిక్ ఎన్యూమ్ వీక్ {సోమవారం, మంగళవారం, బుధవారం, గురువారం, శుక్రవారం, శనివారం, ఆదివారం} పబ్లిక్ స్టాటిక్ శూన్యత ప్రధాన () {int x = (int) వారం. సోమవారం int y = (int) week.Friday Console .రైట్‌లైన్ ('సోమవారం = {0}', x) కన్సోల్.రైట్‌లైన్ ('శుక్రవారం = {0}', వై)}}
 // అవుట్పుట్: 
సోమవారం = 0 
 శుక్రవారం = 4
 ఆబ్జెక్ట్ ఓరియంటెడ్ ప్రోగ్రామింగ్ అప్రోచ్ 
ఆబ్జెక్ట్-ఓరియెంటెడ్ స్టైల్ ప్రోగ్రామింగ్ క్రింద సూచించిన పద్ధతులను అనుసరించడం ద్వారా సాధించవచ్చు.
 ఎన్కప్సులేషన్ 
  
 ఎన్కప్సులేషన్ కలపడానికి ఒక పద్ధతి పద్ధతులు వారితో పాటు డేటా సభ్యులు. 
 ఉదాహరణ: 
సిస్టమ్ నేమ్‌స్పేస్ ఉపయోగించి ఎడురేకా {క్లాస్ దీర్ఘచతురస్రం {పబ్లిక్ డబుల్ లెంగ్త్ పబ్లిక్ డబుల్ వెడల్పు పబ్లిక్ డబుల్ గెట్‌అరియా () {రిటర్న్ లెంగ్త్ * వెడల్పు} పబ్లిక్ శూన్య ప్రదర్శన () {కన్సోల్.రైట్‌లైన్ ('పొడవు: {0}', పొడవు) కన్సోల్.రైట్‌లైన్ (' వెడల్పు: {0} ', వెడల్పు) కన్సోల్.రైట్‌లైన్ (' ప్రాంతం: {0} ', గెట్‌ఆరియా ())}} క్లాస్ ఎగ్జిక్యూట్ దీర్ఘచతురస్రం {స్టాటిక్ శూన్యత ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {దీర్ఘచతురస్రం r = కొత్త దీర్ఘచతురస్రం () r.length = 50 r.width = 35 r.Display () కన్సోల్.రెడ్‌లైన్ ()}}}
 // అవుట్పుట్: 
పొడవు: 50 
 వెడల్పు: 35 
 వైశాల్యం: 1750
 సంగ్రహణ 
 సంగ్రహణ ఒక పద్ధతి దాచు అతనికి అవసరమైన సమాచారాన్ని మాత్రమే అందించడం ద్వారా వినియోగదారు నుండి సంక్లిష్టమైన కోడింగ్ భాగం.
 ఉదాహరణ: 
సిస్టమ్ పబ్లిక్ అబ్‌స్ట్రాక్ట్ క్లాస్ షేప్ {పబ్లిక్ అబ్‌స్ట్రాక్ట్ శూన్య డ్రా ()} పబ్లిక్ క్లాస్ దీర్ఘచతురస్రం: ఆకారం {పబ్లిక్ ఓవర్‌రైడ్ శూన్య డ్రా () {కన్సోల్.రైట్‌లైన్ ('డ్రాయింగ్ దీర్ఘచతురస్రం ...')}} పబ్లిక్ క్లాస్ సర్కిల్: ఆకారం {పబ్లిక్ ఓవర్రైడ్ శూన్యత డ్రా () {కన్సోల్.రైట్‌లైన్ ('డ్రాయింగ్ సర్కిల్ ...')}} పబ్లిక్ క్లాస్ టెస్ట్అబ్‌స్ట్రాక్ట్ {పబ్లిక్ స్టాటిక్ శూన్యత ప్రధాన () {ఆకారం ss = కొత్త దీర్ఘచతురస్రం () s.draw () s = కొత్త సర్కిల్ () s.draw ()}}
 // అవుట్పుట్: 
డ్రాయింగ్ దీర్ఘచతురస్రం ... 
 డ్రాయింగ్ సర్కిల్ ...
 ఇంటర్ఫేస్ 
  
ది ఇంటర్ఫేస్ సంగ్రహణకు పూర్తిగా సమానంగా ఉంటుంది. ఇంటర్ఫేస్ యొక్క కార్యాచరణ ఏమిటంటే, వినియోగదారు నుండి అప్రధానమైన డేటాను దాచడం మరియు అతనికి అవసరమైన ఏకైక ముఖ్యమైన డేటాను అందించడం.
 ఉదాహరణ: 
సిస్టమ్ పబ్లిక్ ఇంటర్‌ఫేస్ ఉపయోగించి డ్రావబుల్ {శూన్య డ్రా ()} పబ్లిక్ క్లాస్ దీర్ఘచతురస్రం: డ్రా చేయదగిన {పబ్లిక్ శూన్య డ్రా () {కన్సోల్.రైట్‌లైన్ ('డ్రాయింగ్ దీర్ఘచతురస్రం ...')}} పబ్లిక్ క్లాస్ సర్కిల్: డ్రా చేయదగిన {పబ్లిక్ శూన్య డ్రా () {కన్సోల్ .రైట్‌లైన్ ('డ్రాయింగ్ సర్కిల్ ...')}} పబ్లిక్ క్లాస్ టెస్ట్ఇంటర్‌ఫేస్ {పబ్లిక్ స్టాటిక్ శూన్యత ప్రధాన () {డ్రా చేయదగిన dd = కొత్త దీర్ఘచతురస్రం () d.draw () d = కొత్త సర్కిల్ () d.draw ()}}
 // అవుట్పుట్: 
డ్రాయింగ్ దీర్ఘచతురస్రం ... 
 డ్రాయింగ్ సర్కిల్ ...
 పాలిమార్ఫిజం 
పాలిమార్ఫిజంయొక్క కలయిక “పాలీ” + “మార్ఫ్‌లు” అంటే అనేక రూపాలు. ఇది గ్రీకు పదం. కోడ్ విభాగం బహుళ రూపాలను తీసుకోగలదని దీని అర్థం. మాకు రెండు రకాల పాలిమార్ఫిజం ఉంది.
కంపైల్ టైమ్ పాలిమార్ఫిజం
రన్ టైమ్ పాలిమార్ఫిజం
 ఉదాహరణ: 
సిస్టమ్ పబ్లిక్ క్లాస్ ఉపయోగించి జంతువు {పబ్లిక్ స్ట్రింగ్ కలర్ = 'వైట్'} పబ్లిక్ క్లాస్ డాగ్: యానిమల్ {పబ్లిక్ స్ట్రింగ్ కలర్ = 'బ్లాక్'} పబ్లిక్ క్లాస్ టెస్ట్ సీల్డ్ {పబ్లిక్ స్టాటిక్ శూన్యత ప్రధాన () {యానిమల్ డి = కొత్త డాగ్ () కన్సోల్.రైట్‌లైన్ ( d.color)}}
 // అవుట్పుట్: 
తెలుపు
 వారసత్వం 
 వారసత్వం ఒక ప్రక్రియ దాని మాతృ వస్తువు యొక్క అన్ని లక్షణాలను మరియు ప్రవర్తనలను స్వయంచాలకంగా పొందుతుంది. మీరు ఇతర తరగతిలో నిర్వచించబడిన లక్షణాలను మరియు ప్రవర్తనలను తిరిగి ఉపయోగించుకోవచ్చు, విస్తరించవచ్చు లేదా సవరించవచ్చు. మరొక తరగతి సభ్యులను వారసత్వంగా పొందిన తరగతిని అంటారు ఉత్పన్నమైన తరగతి మరియు సభ్యులు వారసత్వంగా పొందిన తరగతిని అంటారు బేస్ తరగతి. ఉత్పన్నమైన తరగతి బేస్ తరగతికి ప్రత్యేకమైన తరగతి.
 సింగిల్ లెవల్ వారసత్వానికి ఉదాహరణ 
సిస్టమ్ నేమ్‌స్పేస్ దీర్ఘచతురస్రం అనువర్తనం {తరగతి దీర్ఘచతురస్రం {రక్షిత డబుల్ పొడవు రక్షిత డబుల్ వెడల్పు పబ్లిక్ దీర్ఘచతురస్రం (డబుల్ ఎల్, డబుల్ w) {పొడవు = ఎల్ వెడల్పు = w} పబ్లిక్ డబుల్ గెటరియా () {తిరిగి వచ్చే పొడవు * వెడల్పు} పబ్లిక్ శూన్య ప్రదర్శన () {కన్సోల్. రైట్‌లైన్ ('పొడవు: {0}', పొడవు) కన్సోల్.రైట్‌లైన్ ('వెడల్పు: {0}', వెడల్పు) కన్సోల్.రైట్‌లైన్ ('ప్రాంతం: {0}', గెట్‌ఆరియా ())}} తరగతి టేబుల్‌టాప్: దీర్ఘచతురస్రం {ప్రైవేట్ డబుల్ కాస్ట్ పబ్లిక్ టేబుల్‌టాప్ (డబుల్ ఎల్, డబుల్ డబ్ల్యూ): బేస్ (ఎల్, డబ్ల్యూ)}} పబ్లిక్ డబుల్ గెట్‌కోస్ట్ () {డబుల్ కాస్ట్ కాస్ట్ = గెట్‌ఆరియా () * 70 రిటర్న్ కాస్ట్} పబ్లిక్ శూన్య ప్రదర్శన () {బేస్.డిస్ప్లే () కన్సోల్ .రైట్‌లైన్ ('ఖర్చు: {0}', గెట్‌కోస్ట్ ())}} క్లాస్ ఎగ్జిక్యూట్ దీర్ఘచతురస్రం {స్టాటిక్ శూన్యత ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {టేబుల్‌టాప్ టి = కొత్త టేబుల్‌టాప్ (4.5, 7.5) టి. డిస్ప్లే () కన్సోల్.రెడ్‌లైన్ () }}}
 // అవుట్పుట్: 
పొడవు: 4.5 
 వెడల్పు: 7.5 
 వైశాల్యం: 33.75 
 ఖర్చు: 2362.5
 బహుళ-స్థాయి వారసత్వ ఉదాహరణ 
సిస్టమ్ నేమ్‌స్పేస్‌ను ఉపయోగించడం వారసత్వ అనువర్తనం {తరగతి ఆకారం {పబ్లిక్ శూన్య సెట్‌విడ్త్ (పూర్ణాంక w) {వెడల్పు = w} పబ్లిక్ శూన్య సెట్‌హైట్ (int h) {ఎత్తు = h} రక్షిత పూర్ణాంక వెడల్పు రక్షిత పూర్ణాంక ఎత్తు} పబ్లిక్ ఇంటర్‌ఫేస్ పెయింట్‌కోస్ట్ {int getCost (int ప్రాంతం)} తరగతి దీర్ఘచతురస్రం: ఆకారం, పెయింట్‌కోస్ట్ {పబ్లిక్ ఇంటెంట్ గెట్అరియా () {తిరిగి (వెడల్పు * ఎత్తు)} పబ్లిక్ ఇంటెంట్ గెట్‌కోస్ట్ (పూర్ణాంక ప్రాంతం) {తిరిగి వచ్చే ప్రాంతం * 70}} తరగతి దీర్ఘచతురస్రం టెస్టర్ {స్టాటిక్ శూన్యత ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {దీర్ఘచతురస్రం దీర్ఘచతురస్రం = క్రొత్త దీర్ఘచతురస్రం () పూర్ణాంక ప్రాంతం Rect.setWidth (5) Rect.setHeight (7) ప్రాంతం = Rect.getArea () కన్సోల్.రైట్‌లైన్ ('మొత్తం ప్రాంతం: {0}', Rect.getArea ()) కన్సోల్.రైట్‌లైన్ ('మొత్తం పెయింట్ ఖర్చు: $ {0} ', Rect.getCost (ప్రాంతం)) కన్సోల్.రెడ్‌కే ()}}}
 // అవుట్పుట్: 
మొత్తం వైశాల్యం: 35 
 మొత్తం పెయింట్ ఖర్చు: 50 2450
 ఓవర్‌లోడింగ్ 
ఓవర్‌లోడింగ్ అనేది మనకు ఇద్దరు లేదా సభ్యులు ఒకే పేరును ఉపయోగించి ప్రకటించిన పరిస్థితి. మేము ఒకే పేరుతో రెండు లేదా అంతకంటే ఎక్కువ పద్ధతులను ప్రకటించినప్పుడు ఓవర్‌లోడింగ్ కూడా సాధ్యమే. రెండింటి ఉదాహరణలను చూద్దాం.
 సభ్యుడు ఓవర్‌లోడింగ్ 
 ఉదాహరణ: 
సిస్టమ్ పబ్లిక్ క్లాస్ ఎడురేకా ఉపయోగించి {పబ్లిక్ స్టాటిక్ ఇంట్ యాడ్ (int a, int b) {a + b} పబ్లిక్ స్టాటిక్ Int యాడ్ (int a, int b, int c) {a + b + c return} పబ్లిక్ క్లాస్ TestMemberOverloading return పబ్లిక్ స్టాటిక్ శూన్యత ప్రధాన () {కన్సోల్.రైట్‌లైన్ (ఎడురేకా.అడ్ (12, 23)) కన్సోల్.రైట్‌లైన్ (ఎడురేకా.అడ్ (12, 23, 25 శాతం)}}
 // అవుట్పుట్: 
35 
 60
 విధానం ఓవర్‌లోడింగ్ 
 ఉదాహరణ: 
సిస్టమ్ పబ్లిక్ క్లాస్ ఎడురేకా ఉపయోగించి {పబ్లిక్ స్టాటిక్ Int యాడ్ (int a, int b) {తిరిగి a + b} పబ్లిక్ స్టాటిక్ ఫ్లోట్ యాడ్ (ఫ్లోట్ ఎ, ఫ్లోట్ బి) {రిటర్న్ ఎ + బి}} పబ్లిక్ క్లాస్ టెస్ట్మెంబర్ ఓవర్లోడింగ్ {పబ్లిక్ స్టాటిక్ శూన్యత ప్రధాన ( ) {కన్సోల్.రైట్‌లైన్ (ఎడురేకా.అడ్ (12, 23 శాతం) కన్సోల్.రైట్‌లైన్ (ఎడురేకా.అడ్ (12.4 ఎఫ్, 21.3 ఎఫ్))}}
 // అవుట్పుట్: 
35 
 33.699997
 అతిక్రమిస్తోంది 
తల్లిదండ్రులు కూడా నిర్వచించే అదే పద్ధతిని చైల్డ్ క్లాస్ నిర్వచిస్తుంది. ఒక చిన్న ఉదాహరణ ద్వారా దీనిని అర్థం చేసుకుందాం.
 ఉదాహరణ: 
సిస్టమ్ పబ్లిక్ క్లాస్ ఎడురేకా {పబ్లిక్ వర్చువల్ శూన్యమైన తినడం () {కన్సోల్.రైట్‌లైన్ ('తినడం')}} పబ్లిక్ క్లాస్ డాగ్: ఎడురేకా {పబ్లిక్ ఓవర్‌రైడ్ వాయిడ్ ఈట్ () {కన్సోల్.రైట్‌లైన్ ('ఆహారం తినడం')}} పబ్లిక్ క్లాస్ ఓవర్‌రైడింగ్ {పబ్లిక్ స్టాటిక్ శూన్యత ప్రధాన () {కుక్క d = కొత్త కుక్క () d.eat ()}}
 // అవుట్పుట్: 
తిండి తినడము
 నేమ్‌స్పేస్ 
ది నేమ్‌స్పేస్ ప్రోగ్రామ్‌లో ఉన్న బహుళ తరగతులను నిర్వహించడానికి ప్రాథమికంగా ఉపయోగిస్తారు. నేమ్‌స్పేస్ వివిధ మార్గాల్లో లభిస్తుంది.
 సిస్టమ్.కాన్సోల్: ఇక్కడ, ది సిస్టమ్ నేమ్‌స్పేస్ అవుతుంది
నేమ్‌స్పేస్ యొక్క తరగతిని ప్రాప్యత చేయడానికి, మేము ఉపయోగించాలి namespacename.classname. 
మేము ఉపయోగించవచ్చు ఉపయోగించి కీవర్డ్ అలాగే.
 ఉదాహరణ: 
రెండవ నేమ్‌స్పేస్‌ను ఉపయోగించడం ద్వారా సిస్టమ్‌ను ఉపయోగించడం హ్యాపీ లెర్నింగ్ ')}}} పబ్లిక్ క్లాస్ నేమ్‌స్పేస్ {పబ్లిక్ స్టాటిక్ శూన్యత ప్రధాన () {ఎడురేకా h1 = కొత్త ఎడురేకా () ​​హ్యాపీ_లెర్నింగ్ w1 = కొత్త హ్యాపీ_లెర్నింగ్ () h1.sayWelcome () w1.sayWishes ()}}
 // అవుట్పుట్: 
ఎడురేకాకు స్వాగతం 
 హ్యాపీ లెర్నింగ్
 ఫైల్ ఆపరేషన్లు 
ది ఫైల్ ఆపరేషన్లు C # లో అందుబాటులో ఉన్నాయి:
 ఆపరేషన్ 
 వివరణ 
 బైనరీ రీడర్ 
బైనరీ స్ట్రీమ్ నుండి ఆదిమ డేటాను చదువుతుంది.
 బైనరీ రైటర్ 
ఆదిమ డేటాను బైనరీ ఆకృతిలో వ్రాస్తుంది.
 బఫర్డ్ స్ట్రీమ్ 
బైట్ల ప్రవాహం కోసం తాత్కాలిక నిల్వ.
 డైరెక్టరీ 
డైరెక్టరీ నిర్మాణాన్ని మార్చడంలో సహాయపడుతుంది.
 డైరెక్టరీఇన్ఫో 
డైరెక్టరీలపై ఆపరేషన్లు చేయడానికి ఉపయోగిస్తారు.
 డ్రైవ్ఇన్ఫో 
డ్రైవ్‌ల కోసం సమాచారాన్ని అందిస్తుంది.
 ఫైల్ 
ఫైళ్ళను మార్చడంలో సహాయపడుతుంది.
 ఫైల్ఇన్ఫో 
ఫైళ్ళలో ఆపరేషన్లు చేయడానికి ఉపయోగిస్తారు.
 ఫైల్ స్ట్రీమ్ 
ఫైల్‌లోని ఏదైనా ప్రదేశం నుండి చదవడానికి మరియు వ్రాయడానికి ఉపయోగిస్తారు.
 మెమరీ స్ట్రీమ్ 
మెమరీలో నిల్వ చేయబడిన స్ట్రీమ్ చేసిన డేటాకు యాదృచ్ఛిక ప్రాప్యత కోసం ఉపయోగిస్తారు.
 మార్గం 
మార్గం సమాచారంలో కార్యకలాపాలను నిర్వహిస్తుంది.
 స్ట్రీమ్ రీడర్ 
బైట్ స్ట్రీమ్ నుండి అక్షరాలను చదవడానికి ఉపయోగిస్తారు.
 స్ట్రీమ్‌రైటర్ 
స్ట్రీమ్‌కు అక్షరాలను వ్రాయడానికి ఉపయోగిస్తారు.
 స్ట్రింగ్ రీడర్ 
స్ట్రింగ్ బఫర్ నుండి చదవడానికి ఉపయోగిస్తారు.
 స్ట్రింగ్ రైటర్ 
స్ట్రింగ్ బఫర్‌లో వ్రాయడానికి ఉపయోగిస్తారు.
 ఫైల్ మోడ్ 
ది ఫైల్ మోడ్ బహుళ ఫైల్ ఓపెనింగ్ పద్ధతులను నిర్వచించే ఎన్యూమరేటర్. ఫైల్ మోడ్ ఎన్యూమరేటర్ యొక్క సభ్యులు ఈ క్రింది విధంగా వివరించబడ్డారు:
 జోడించు: ఇది ఇప్పటికే ఉన్న ఫైల్‌ను తెరుస్తుంది మరియు కర్సర్‌ను ఫైల్ చివరిలో ఉంచుతుంది లేదా ఫైల్ లేకపోతే ఫైల్‌ను సృష్టిస్తుంది.
 సృష్టించండి: ఇది క్రొత్త ఫైల్‌ను సృష్టించడానికి రూపొందించబడింది.
 సృష్టించు క్రొత్తది: ఇది ఆపరేటింగ్ సిస్టమ్‌కు పేర్కొనడానికి రూపొందించబడింది, ఇది క్రొత్త ఫైల్‌ను సృష్టించాలి.
 తెరవండి: ఇది ఇప్పటికే ఉన్న ఫైల్‌ను తెరవడానికి రూపొందించబడింది.
 OpenOrCreate: ఆపరేటింగ్ సిస్టమ్ ఉన్నట్లయితే అది ఫైల్‌ను తెరవాలని పేర్కొనడానికి ఇది రూపొందించబడింది, లేకుంటే అది క్రొత్త ఫైల్‌ను సృష్టించాలి.
 కత్తిరించు: కత్తిరించు ఇప్పటికే ఉన్న ఫైల్‌ను తెరుస్తుంది మరియు దాని పరిమాణాన్ని సున్నా బైట్‌లకు కత్తిరిస్తుంది.
 ఫైల్ యాక్సెస్ 
 ఫైల్ యాక్సెస్ ఒక నిర్దిష్ట ఫైల్‌కు ప్రాప్యతను పొందడానికి ఎన్యూమరేటర్ ఉపయోగించబడుతుంది. దీనికి కింది సభ్యులు ఉన్నారు.
 చదవండి 
 వ్రాయడానికి 
 చదువు రాయి 
 ఫైల్ షేర్ 
ది ఫైల్ షేర్ నిర్దిష్ట ఫైల్‌ను భాగస్వామ్యం చేయడానికి ఎన్యూమరేటర్ ఉపయోగించబడుతుంది. దీనికి కింది సభ్యులు ఉన్నారు.
 వారసత్వంగా: పిల్లల ప్రక్రియలకు వారసత్వంగా ఇవ్వడానికి ఫైల్‌హ్యాండిల్‌ను వారసత్వంగా అనుమతిస్తుంది.
 ఏదీ లేదు: ప్రస్తుత ఫైల్ భాగస్వామ్యాన్ని ఏదీ తిరస్కరించలేదు
 చదవండి: చదవడానికి ఫైల్‌ను తెరవడానికి రీడ్ అనుమతిస్తుంది.
 చదువు రాయి: రీడ్‌రైట్ ఫైల్‌ను చదవడానికి మరియు వ్రాయడానికి తెరవడానికి అనుమతిస్తుంది.
 వ్రాయడానికి: వ్రాయడం కోసం ఫైల్ను తెరవడానికి రైట్ అనుమతిస్తుంది.
 సంఘటనలు 
ఒక సంఘటనను సాధారణంగా వినియోగదారు సృష్టించిన చర్యగా పిలుస్తారు. ఇది మౌస్ క్లిక్ మరియు కీబోర్డ్ నుండి ఒకే కీస్ట్రోక్ కావచ్చు. అదేవిధంగా, సి # ప్రోగ్రామ్‌లకు కూడా సంఘటనలు ఉన్నాయి. ఈవెంట్ యొక్క జనరేటర్ను అంటారు ప్రచురణకర్త మరియు ఈవెంట్ యొక్క రిసీవర్ అంటారు చందాదారుడు. 
 ప్రచురణకర్త 
TO ప్రచురణకర్త ఈవెంట్ మరియు ప్రతినిధి యొక్క నిర్వచనం కలిగి ఉంది. ది ఈవెంట్-ప్రతినిధి అసోసియేషన్ ఈ వస్తువులో నిర్వచించబడింది. జ ప్రచురణకర్త తరగతి వస్తువు ఈవెంట్‌ను ప్రారంభిస్తుంది మరియు ఇది ఇతర వస్తువులకు తెలియజేయబడుతుంది.
 చందాదారుడు 
TO చందాదారుడు ఈవెంట్‌ను అంగీకరిస్తుంది మరియు అందిస్తుంది ఈవెంట్ హ్యాండ్లర్. ది ప్రతినిధి ప్రచురణకర్త తరగతిలో పద్ధతి / సంఘటనను ప్రారంభిస్తుంది హ్యాండ్లర్ చందాదారుల తరగతి.
 ఉదాహరణ: 
సిస్టమ్ నేమ్‌స్పేస్‌ను ఉపయోగించి ఎడురేకా {పబ్లిక్ డెలిగేట్ స్ట్రింగ్ డెల్ (స్ట్రింగ్ స్ట్రింగ్) క్లాస్ ఈవెంట్‌బ్లాక్ {ఈవెంట్ డెల్ న్యూఈవెంట్ పబ్లిక్ ఈవెంట్‌బ్లాక్ () {this.NewEvent + = new Del (this.WelcomeUser)} పబ్లిక్ స్ట్రింగ్ స్వాగతం యూజర్ (స్ట్రింగ్ యూజర్‌పేరు) . '+ వినియోగదారు పేరు} స్టాటిక్ శూన్యత ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {ఈవెంట్‌బ్లాక్ ఆబ్జెక్ట్ 1 = కొత్త ఈవెంట్‌బ్లాక్ () స్ట్రింగ్ ఫలితం = ఆబ్జెక్ట్ 1.న్యూఈవెంట్ (' హ్యాపీ లెర్నింగ్ ') కన్సోల్.రైట్‌లైన్ (ఫలితం)}}}
 // అవుట్పుట్: 
ఎడురేకాకు స్వాగతం. హ్యాపీ లెర్నింగ్
 జెనెరిక్స్ 
 జెనెరిక్స్ ఒక తరగతి సభ్యులను మరియు పద్ధతులను స్థల హోల్డర్లతో అందించే భావన రన్-టైమ్. మేము ఉపయోగించి జెనెరిక్స్ నిర్వచించవచ్చు బ్రాకెట్లు. ఈ క్రింది ఉదాహరణలను చూద్దాం.
 ఒక తరగతిలో జనరిక్స్ 
సిస్టమ్ నేమ్‌స్పేస్ ఉపయోగించి ఎడురేకా {క్లాస్ జెనెరిక్ క్లాస్ {పబ్లిక్ జెనెరిక్ క్లాస్ (టి ఎంఎస్జి) {కన్సోల్.రైట్‌లైన్ (ఎంఎస్‌జి)}} క్లాస్ ప్రోగ్రామ్ {స్టాటిక్ శూన్యత ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {జెనెరిక్ క్లాస్ జెన్ = కొత్త జెనెరిక్ క్లాస్ ('ఈ సందేశం జెనెరిక్ క్లాస్ నుండి వచ్చింది' ) జెనెరిక్ క్లాస్ genI = కొత్త జెనెరిక్ క్లాస్ (123) జెనెరిక్ క్లాస్ getCh = కొత్త జెనెరిక్ క్లాస్ ('E')}}}
 // అవుట్పుట్: 
ఈ సందేశం సాధారణ తరగతి నుండి 
 123 
 IS
 ఒక పద్ధతిలో జెనెరిక్స్ 
సిస్టమ్ నేమ్‌స్పేస్‌ను ఉపయోగించి ఎడురేకా {క్లాస్ జెనెరిక్ క్లాస్ {పబ్లిక్ శూన్య ప్రదర్శన (టి ఎంఎస్‌జి) {కన్సోల్.రైట్‌లైన్ (ఎంఎస్‌జి)}} క్లాస్ ప్రోగ్రామ్ {స్టాటిక్ శూన్యత ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {జెనెరిక్ క్లాస్ జెఎన్‌సి = కొత్త జెనెరిక్ క్లాస్ () జెఎన్‌సి.షో ('ఇది సందేశం సాధారణ పద్ధతి నుండి వచ్చింది ') genC.Show (321) genC.Show (' H ')}}}
 // అవుట్పుట్: 
ఈ సందేశం సాధారణ పద్ధతి నుండి 
 321 
 హెచ్
 ప్రతినిధులు 
ది ప్రతినిధి పద్ధతికి సూచనగా పనిచేస్తుంది. ప్రాథమికంగా ఇది a ఫంక్షన్ పాయింటర్ C మరియు C ++ లో కానీ చాలా మంచిది మరియు టైప్-సేఫ్. లో ప్రతినిధి స్టాటిక్ పద్ధతి పద్ధతిని మాత్రమే కలుపుతుంది. లో ప్రతినిధి ఉదాహరణకు పద్ధతి పద్ధతి మరియు ఉదాహరణ రెండింటినీ కలుపుతుంది. ప్రతినిధి యొక్క ఉత్తమ ఉపయోగం ఒకగా ఉపయోగించడం ఈవెంట్. 
 ఉదాహరణ: 
సిస్టమ్ ప్రతినిధి పూర్ణాంక కాలిక్యులేటర్ (int n) పబ్లిక్ క్లాస్ ఎడురేకా {స్టాటిక్ పూర్ణాంక సంఖ్య = 25 పబ్లిక్ స్టాటిక్ పూర్ణాంకానికి జోడించు (పూర్ణాంకానికి n) {సంఖ్య = సంఖ్య + n తిరిగి సంఖ్య} పబ్లిక్ స్టాటిక్ పూర్ణాంక ముల్ (పూర్ణాంకానికి n) {సంఖ్య = సంఖ్య * n తిరిగి సంఖ్య} పబ్లిక్ స్టాటిక్ Int getNumber () {తిరిగి సంఖ్య} పబ్లిక్ స్టాటిక్ శూన్యత ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {కాలిక్యులేటర్ c1 = కొత్త కాలిక్యులేటర్ (జోడించు) కాలిక్యులేటర్ c2 = కొత్త కాలిక్యులేటర్ (ముల్) c1 (20) కన్సోల్.రైట్‌లైన్ ('కాలిక్యులేటర్ తరువాత ఒక ప్రతినిధి, క్రొత్త సంఖ్య: '+ getNumber ()) c2 (3) కన్సోల్.రైట్‌లైన్ (' కాలిక్యులేటర్ ఇద్దరు ప్రతినిధి తరువాత, కొత్త సంఖ్య: '+ getNumber ())}}
 // అవుట్పుట్: 
కాలిక్యులేటర్ ఒక ప్రతినిధి తరువాత, క్రొత్త సంఖ్య: 45 
 కాలిక్యులేటర్ ఇద్దరు ప్రతినిధి తరువాత, కొత్త సంఖ్య: 135
 ప్రతిబింబం 
రన్-టైమ్‌లో మెటాడేటాను పొందటానికి ప్రతిబింబం అవసరం. లో సూచన అందుబాటులో ఉంది System.Reflection నేమ్‌స్పేస్. ఇది అమలు చేయడానికి క్రింది తరగతులు అవసరం.
టైప్ చేయండి
సభ్యుడు సమాచారం
కన్స్ట్రక్టర్ఇన్ఫో
మెథడ్ఇన్ఫో
ఫీల్డ్ఇన్ఫో
ప్రాపర్టీఇన్ఫో
టైప్ఇన్ఫో
ఈవెంట్ఇన్ఫో
మాడ్యూల్
అసెంబ్లీ
అసెంబ్లీ పేరు
పాయింటర్
 తరగతి రకం 
సి # రకం తరగతి తరగతి రకాలు, ఇంటర్ఫేస్ రకాలు, గణన రకాలు, శ్రేణి రకాలు, విలువ రకాలు కోసం రకం ప్రకటనలను సూచిస్తుంది
గుణాలు టైప్ చేయండి
టైప్ క్లాసుల యొక్క ముఖ్యమైన లక్షణాల జాబితా క్రింద పేర్కొనబడింది.
 ఆస్తి 
 వివరణ 
 అసెంబ్లీ 
ఈ రకానికి అసెంబ్లీని పొందుతుంది.
 అసెంబ్లీ క్వాలిఫైడ్ నేమ్ 
ఈ రకానికి అసెంబ్లీ అర్హత గల పేరును పొందుతుంది.
 గుణాలు 
రకంతో అనుబంధించబడిన లక్షణాలను పొందుతుంది.
 బేస్ టైప్ 
బేస్ లేదా పేరెంట్ రకాన్ని పొందుతుంది.
 పూర్తి పేరు 
రకం యొక్క పూర్తి అర్హత గల పేరును పొందుతుంది.
 IsAbstract 
రకం వియుక్తంగా ఉందో లేదో తనిఖీ చేయడానికి ఉపయోగిస్తారు.
 ఇస్అర్రే 
రకం అర్రే కాదా అని తనిఖీ చేయడానికి ఉపయోగిస్తారు.
 ఇస్క్లాస్ 
రకం క్లాస్ కాదా అని తనిఖీ చేయడానికి ఉపయోగిస్తారు.
 IsEnum 
రకం ఎనుమ్ కాదా అని తనిఖీ చేయడానికి ఉపయోగిస్తారు.
 IsInterface 
రకం ఇంటర్ఫేస్ కాదా అని తనిఖీ చేయడానికి ఉపయోగించబడుతుంది.
 ఇస్నెస్టెడ్ 
రకం నెస్టెడ్ కాదా అని తనిఖీ చేయడానికి ఉపయోగిస్తారు.
 IsPrimitive 
రకం ఆదిమంగా ఉందో లేదో తనిఖీ చేయడానికి ఉపయోగిస్తారు.
 IsPointer 
రకం పాయింటర్ కాదా అని తనిఖీ చేయడానికి ఉపయోగిస్తారు.
 ఇస్నోట్ పబ్లిక్ 
రకం పబ్లిక్ కాదా అని తనిఖీ చేయడానికి ఉపయోగించబడుతుంది.
 ఇస్పబ్లిక్ 
రకం పబ్లిక్ కాదా అని తనిఖీ చేయడానికి ఉపయోగిస్తారు.
 ఇస్సీల్డ్ 
రకం సీలు చేయబడిందో లేదో తనిఖీ చేయడానికి ఉపయోగిస్తారు.
 IsSerializable 
రకం సీరియలైజబుల్ కాదా అని తనిఖీ చేయడానికి ఉపయోగిస్తారు.
 సభ్యుల రకం 
రకం నెస్టెడ్ రకం సభ్యుల రకం కాదా అని తనిఖీ చేయడానికి ఉపయోగిస్తారు.
 మాడ్యూల్ 
రకం మాడ్యూల్ పొందుతుంది.
 పేరు 
రకం పేరును పొందుతుంది.
 నేమ్‌స్పేస్ 
రకం నేమ్‌స్పేస్‌ను పొందుతుంది.
 ఆస్తి 
 వివరణ 
 GetConstructors () 
రకం కోసం అన్ని పబ్లిక్ కన్స్ట్రక్టర్లను అందిస్తుంది.
 GetConstructors (బైండింగ్ఫ్లాగ్స్) 
పేర్కొన్న బైండింగ్ఫ్లాగ్‌లతో టైప్ కోసం అన్ని కన్స్ట్రక్టర్లను అందిస్తుంది.
 GetFields () 
రకం కోసం అన్ని పబ్లిక్ ఫీల్డ్‌లను చూపుతుంది.
 GetFields (బైండింగ్ఫ్లాగ్స్) 
పేర్కొన్న బైండింగ్ఫ్లాగ్‌లతో రకం కోసం అన్ని పబ్లిక్ కన్స్ట్రక్టర్లను అందిస్తుంది.
 GetMembers () 
రకం కోసం అన్ని ప్రజా సభ్యులను అందిస్తుంది.
 GetMembers (బైండింగ్ఫ్లాగ్స్) 
పేర్కొన్న బైండింగ్ఫ్లాగ్‌లతో రకం కోసం సభ్యులందరినీ అందిస్తుంది.
 GetMethods () 
రకం కోసం అన్ని పబ్లిక్ పద్ధతులను అందిస్తుంది.
 GetMethods (బైండింగ్ఫ్లాగ్స్) 
పేర్కొన్న బైండింగ్ఫ్లాగ్‌లతో టైప్ కోసం అన్ని పద్ధతులను అందిస్తుంది.
 GetProperties () 
రకం కోసం అన్ని పబ్లిక్ ప్రాపర్టీలను చూపుతుంది.
 GetProperties (బైండింగ్ఫ్లాగ్స్) 
పేర్కొన్న బైండింగ్ఫ్లాగ్‌లతో రకం కోసం అన్ని లక్షణాలను చూపుతుంది.
 GetType () 
ప్రస్తుత రకాన్ని పొందుతుంది.
 GetType (స్ట్రింగ్) 
ఇచ్చిన పేరు కోసం రకాన్ని పొందుతుంది.
 ప్రతిబింబ ఉదాహరణలు: 
 రకాన్ని పొందండి 
 ఉదాహరణ: 
సిస్టమ్ పబ్లిక్ క్లాస్ గెట్‌టైప్ ఉపయోగించి {పబ్లిక్ స్టాటిక్ శూన్యత ప్రధాన () {int a = 10 రకం రకం = a.GetType () కన్సోల్.రైట్‌లైన్ (రకం)}}
 // అవుట్పుట్: 
సిస్టమ్.ఇంట్ 32
 
 అసెంబ్లీ పొందండి 
 ఉదాహరణ: 
System.Reflection పబ్లిక్ క్లాస్ GetAssbel {పబ్లిక్ స్టాటిక్ శూన్యత ప్రధాన () {టైప్ t = టైప్ఆఫ్ (System.String) కన్సోల్.రైట్‌లైన్ (t.Assbel)}}
 // అవుట్పుట్: 
System.Private.CoreLib, వెర్షన్ = 4.0.0.0, సంస్కృతి = తటస్థ, PublicKeyToken = 7cec85d7bea7798e
 
 ముద్రణ రకం సమాచారం 
 ఉదాహరణ: 
System.Reflection పబ్లిక్ క్లాస్ ప్రింట్‌టైప్ {పబ్లిక్ స్టాటిక్ శూన్యత ప్రధాన () {టైప్ t = టైప్ఆఫ్ (సిస్టమ్.స్ట్రింగ్) కన్సోల్.రైట్‌లైన్ (t.FullName) కన్సోల్.రైట్‌లైన్ (t.BaseType) కన్సోల్.రైట్‌లైన్ (t.IsClass) కన్సోల్.రైట్‌లైన్ (t.IsEnum) కన్సోల్.రైట్‌లైన్ (t.IsInterface)}}
 // అవుట్పుట్: 
నిజం 
 తప్పుడు 
 తప్పుడు
 
 కన్స్ట్రక్టర్లను ముద్రించండి 
 ఉదాహరణ: 
System.Reflection పబ్లిక్ క్లాస్ ప్రింట్‌కన్‌స్ట్రక్టర్స్ {పబ్లిక్ స్టాటిక్ శూన్యత ప్రధాన () {టైప్ t = టైప్ఆఫ్ (సిస్టమ్.స్ట్రింగ్) కన్సోల్.రైట్‌లైన్ ('{0} రకం కన్స్ట్రక్టర్లు ...', t) కన్స్ట్రక్టర్ ఇన్ఫో [] ci = t .గెట్‌కన్‌స్ట్రక్టర్స్ (బైండింగ్ఫ్లాగ్స్.పబ్లిక్ | బైండింగ్ఫ్లాగ్స్.ఇన్‌స్టాన్స్) ఫోర్కాచ్ (కన్స్ట్రక్టర్ఇన్ఫో సి ఇన్ సిఐ) {కన్సోల్.రైట్‌లైన్ (సి)}}}
 // అవుట్పుట్: 
System.String రకం యొక్క కన్స్ట్రక్టర్లు ... 
 శూన్యం .క్టర్ (చార్ []) 
 శూన్యం .క్టర్ (చార్ [], Int32, Int32) 
 శూన్యం .క్టర్ (చార్ *) 
 శూన్యం .క్టర్ (చార్ *, Int32, Int32) 
 శూన్యం .క్టర్ (SByte *) 
 శూన్యం .క్టర్ (SByte *, Int32, Int32) 
 శూన్య .ctor (SByte *, Int32, Int32, System.Text.Encoding) 
 శూన్యం .క్టర్ (చార్, Int32) 
 శూన్యం .ctor (System.ReadOnlySpan`1 [System.Char])
 
 ప్రింట్ పద్ధతులు 
 ఉదాహరణ: 
System.Reflection పబ్లిక్ క్లాస్ ప్రింట్‌మెథడ్స్ {పబ్లిక్ స్టాటిక్ శూన్యత ప్రధాన () t టైప్ t = టైప్ఆఫ్ (సిస్టమ్.స్ట్రింగ్) కన్సోల్.రైట్‌లైన్ ('{0} రకం యొక్క పద్ధతులు ...', t) మెథడ్ఇన్ఫో [] ci = t .గెట్‌మెథడ్స్ (బైండింగ్ఫ్లాగ్స్.పబ్లిక్ | బైండింగ్ఫ్లాగ్స్.ఇన్‌స్టాన్స్) ఫోర్చాచ్ (మెథడ్ఇన్ఫో m ఇన్ సిఐ) {కన్సోల్.రైట్‌లైన్ (మ)
 // అవుట్పుట్: 
System.String రకం యొక్క పద్ధతులు ... 
 System.String పున lace స్థాపించుము (System.String, System.String) 
 System.String [] Split (చార్, System.StringSplitOptions) 
 System.String [] స్ప్లిట్ (చార్, Int32, System.StringSplitOptions) 
 System.String [] స్ప్లిట్ (చార్ []) 
 System.String [] స్ప్లిట్ (చార్ [], Int32) 
 System.String [] స్ప్లిట్ (చార్ [], System.StringSplitOptions) 
 System.String [] స్ప్లిట్ (చార్ [], Int32, System.StringSplitOptions) 
 System.String [] స్ప్లిట్ (System.String, System.StringSplitOptions) 
 System.String [] స్ప్లిట్ (System.String, Int32, System.StringSplitOptions) 
 System.String [] స్ప్లిట్ (System.String [], System.StringSplitOptions) 
 System.String [] Split (System.String [], Int32, System.StringSplitOptions) ......
 
 ఫీల్డ్లను ముద్రించండి 
 
 ఉదాహరణ: 
System.Reflection పబ్లిక్ క్లాస్ ప్రింట్ ఫీల్డ్స్ {పబ్లిక్ స్టాటిక్ శూన్యత ప్రధాన () {టైప్ t = టైప్ఆఫ్ (సిస్టమ్.స్ట్రింగ్) కన్సోల్.రైట్‌లైన్ ('{0} రకం ఫీల్డ్‌లు ...', t) ఫీల్డ్‌ఇన్ఫో [] ci = t .గెట్‌ఫీల్డ్స్ (బైండింగ్ఫ్లాగ్స్.పబ్లిక్ | బైండింగ్ఫ్లాగ్స్.స్టాటిక్ | బైండింగ్ఫ్లాగ్స్.నాన్‌పబ్లిక్) foreach (ఫీల్డ్‌ఇన్ఫో ఎఫ్ ఇన్ సిఐ) {కన్సోల్.రైట్‌లైన్ (ఎఫ్)}}}
 // అవుట్పుట్: 
System.String రకం యొక్క ఫీల్డ్‌లు ... 
 System.String ఖాళీ
ఇప్పుడు, కొన్ని అధునాతన సి # ప్రోగ్రామింగ్ కాన్సెప్ట్‌లకు వెళ్దాం
 అధునాతన సి # కాన్సెప్ట్స్ 
 అనామక ఫంక్షన్ 
 మల్టీ-థ్రెడింగ్ 
 మినహాయింపు నిర్వహణ 
 సమకాలీకరణ 
 క్రొత్త ఫీచర్లు 
 అనామక ఫంక్షన్ 
నిర్దిష్ట పేరు లేని ఫంక్షన్ అంటారు అనామక విధులు. సి # లో రెండు రకాల అనామక విధులు అందుబాటులో ఉన్నాయి
లాంబ్డా వ్యక్తీకరణలు
అనామక పద్ధతులు
 ఉదాహరణ: 
సిస్టమ్ నేమ్‌స్పేస్ లాంబ్డా ఎక్స్‌ప్రెషన్స్ {క్లాస్ ఎడురేకా {ప్రతినిధి పూర్ణాంకం స్క్వేర్ (పూర్ణాంకం) స్టాటిక్ శూన్యత ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {స్క్వేర్ గెట్‌స్క్వేర్ = x => x * x int j = గెట్‌స్క్వేర్ (25) కన్సోల్ j)}}}
 // అవుట్పుట్: 
స్క్వేర్: 625
 అనామక పద్ధతులు 
ది అనామక పద్ధతి అదే కార్యాచరణను అందిస్తుంది లాంబ్డా వ్యక్తీకరణ, ఇది పారామితి జాబితాను విస్మరించడానికి అనుమతిస్తుంది.
 ఉదాహరణ: 
సిస్టమ్ నేమ్‌స్పేస్ ఉపయోగించి అనామక పద్ధతులు {క్లాస్ ప్రోగ్రామ్ {పబ్లిక్ డెలిగేట్ శూన్యమైన అనామక ఫన్ () స్టాటిక్ శూన్యత ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {అనామక ఫన్ ఫన్ = డెలిగేట్ () {కన్సోల్.రైట్‌లైన్ ('ఇది అనామక ఫంక్షన్')} సరదా ()}}}
 // అవుట్పుట్: 
ఇది అనామక ఫంక్షన్
 మల్టీ-థ్రెడింగ్ 
మల్టీథ్రెడింగ్ అనేది ఒక ప్రక్రియ, ఇక్కడ బహుళ థ్రెడ్‌లు సృష్టించబడతాయి మరియు వేర్వేరు పనుల కోసం కేటాయించబడతాయి. ఇది ఒకేసారి బహుళ ఉద్యోగాలను అమలు చేయడం ద్వారా సమయాన్ని ఆదా చేస్తుంది. మల్టీథ్రెడింగ్ క్లాస్ లో అందుబాటులో ఉంది సిస్టమ్.థ్రెడింగ్ నేమ్‌స్పేస్.
 సిస్టమ్.థ్రెడింగ్ నేమ్‌స్పేస్ 
ది సిస్టమ్.థ్రెడింగ్ నేమ్‌స్పేస్‌లో మల్టీథ్రెడింగ్‌ను సులభతరం చేయడానికి తరగతులు మరియు ఇంటర్‌ఫేస్‌లు ఉన్నాయి. ఇది థ్రెడ్ వనరును సమకాలీకరించడానికి తరగతులను అందిస్తుంది. సాధారణంగా ఉపయోగించే తరగతుల జాబితా క్రింద ఇవ్వబడింది:
థ్రెడ్
మ్యూటెక్స్
టైమర్
మానిటర్
సెమాఫోర్
థ్రెడ్ లోకల్
థ్రెడ్‌పూల్
త్వరగా ఆవిరి అయ్యెడు
 ప్రాసెస్ మరియు థ్రెడ్ 
ప్రక్రియ వాస్తవానికి మరియు అప్లికేషన్ మరియు ఇది a గా పరిగణించబడుతుంది హెవీవెయిట్ భాగం. మరోవైపు, థ్రెడ్ ఒక సింగిల్ మాడ్యూల్ మొత్తం అప్లికేషన్ యొక్క. అది తేలికపాటి ప్రక్రియతో పోలిస్తే
 లైఫ్ సైకిల్ ఆఫ్ థ్రెడ్ 
ప్రతి థ్రెడ్‌కు లైఫ్ సైకిల్ ఉంటుంది. థ్రెడ్ యొక్క జీవిత చక్రం System.Threading.Thread తరగతిలో నిర్వచించబడింది. ఏదైనా థ్రెడ్ యొక్క జీవిత చక్రంలో దశలు క్రిందివి.
ప్రారంభించబడలేదు
అమలు చేయగల (అమలు చేయడానికి సిద్ధంగా ఉంది)
నడుస్తోంది
అమలు చేయబడలేదు
చనిపోయిన
థ్రెడ్ క్లాస్ ఈ క్రింది లక్షణాలను మరియు పద్ధతులను ఈ క్రింది విధంగా అందిస్తుంది.
 థ్రెడ్ గుణాలు 
 ఆస్తి 
 వివరణ 
 కరెంట్ థ్రెడ్ 
ప్రస్తుతం నడుస్తున్న థ్రెడ్ యొక్క ఉదాహరణను అందిస్తుంది.
 జీవించే ఉంది 
ప్రస్తుత థ్రెడ్ సజీవంగా ఉందో లేదో తనిఖీ చేస్తుంది.
 ఇస్బ్యాక్ గ్రౌండ్ 
ప్రస్తుత థ్రెడ్ యొక్క విలువను పొందడానికి / సెట్ చేయడానికి నేపథ్యంలో ఉంది లేదా.
 మేనేజ్డ్ థ్రెడ్ఇడ్ 
ప్రస్తుతం నిర్వహించబడుతున్న థ్రెడ్ కోసం ప్రత్యేకమైన ఐడిని పొందడానికి ఉపయోగించబడుతుంది.
 పేరు 
ప్రస్తుత థ్రెడ్ పేరును పొందడానికి లేదా సెట్ చేయడానికి ఉపయోగిస్తారు.
 ప్రాధాన్యత 
ప్రస్తుత థ్రెడ్ యొక్క ప్రాధాన్యతను పొందడానికి లేదా సెట్ చేయడానికి ఉపయోగించబడుతుంది.
 థ్రెడ్‌స్టేట్ 
థ్రెడ్ స్థితిని సూచించే విలువను తిరిగి ఇవ్వడానికి ఉపయోగిస్తారు.
 థ్రెడ్ పద్ధతులు 
 విధానం 
 వివరణ 
 గర్భస్రావం () 
థ్రెడ్‌ను ముగించడానికి ఉపయోగిస్తారు. ఇది ThreadAbortException ను పెంచుతుంది.
 అంతరాయం () 
WaitSleepJoin స్థితిలో ఉన్న థ్రెడ్‌కు అంతరాయం కలిగించడానికి ఉపయోగిస్తారు.
 చేరండి () 
ఈ థ్రెడ్ ముగిసే వరకు అన్ని కాలింగ్ థ్రెడ్లను నిరోధించడానికి ఉపయోగిస్తారు.
 రీసెట్అబోర్ట్ () 
ప్రస్తుత థ్రెడ్ కోసం రద్దు అభ్యర్థనను రద్దు చేయడానికి ఉపయోగించబడుతుంది.
 పునఃప్రారంభం() 
సస్పెండ్ చేయబడిన థ్రెడ్‌ను తిరిగి ప్రారంభించడానికి ఉపయోగిస్తారు. ఇది వాడుకలో లేదు.
 నిద్ర (Int32) 
పేర్కొన్న మిల్లీసెకన్ల కోసం ప్రస్తుత థ్రెడ్‌ను నిలిపివేయడానికి ఉపయోగిస్తారు.
 ప్రారంభం () 
థ్రెడ్ యొక్క ప్రస్తుత స్థితిని రన్ చేయదగినదిగా మారుస్తుంది.
 సస్పెండ్ () 
ప్రస్తుత థ్రెడ్ సస్పెండ్ చేయకపోతే దాన్ని నిలిపివేస్తుంది. ఇది వాడుకలో లేదు.
 దిగుబడి() 
ప్రస్తుత థ్రెడ్ యొక్క అమలును మరొక థ్రెడ్కు ఇవ్వడానికి ఉపయోగిస్తారు.
 ప్రధాన థ్రెడ్ ఉదాహరణ 
సిస్టమ్‌ను ఉపయోగించి సిస్టమ్‌ను ఉపయోగించడం. పబ్లిక్ క్లాస్ ఎడురేకా {పబ్లిక్ స్టాటిక్ శూన్యత ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {థ్రెడ్ టి = థ్రెడ్.కంటెంట్ థ్రెడ్ టి.నామ్ = 'మెయిన్‌థ్రెడ్' కన్సోల్.రైట్‌లైన్ (టి.నేమ్)}}
 // అవుట్పుట్: 
మెయిన్ థ్రెడ్
 
 మినహాయింపు నిర్వహణ 
ది మినహాయింపు ప్రోగ్రామ్ దాని రన్ టైమ్‌లో విసిరిన లోపం. మా ప్రోగ్రామ్ మినహాయింపును ఉచితంగా చేయడానికి మేము మినహాయింపు-నిర్వహణను నిర్వహిస్తాము.
 మినహాయింపు 
 వివరణ 
 System.DivideByZeroException 
సంఖ్యను సున్నాతో విభజించడం ద్వారా లోపం ఏర్పడింది.  
  
 System.NullReferenceException 
శూన్య వస్తువును సూచించడం ద్వారా ఉత్పన్నమయ్యే లోపాన్ని నిర్వహిస్తుంది.  
  
 System.InvalidCastException 
చెల్లని టైప్‌కాస్టింగ్ ద్వారా ఏర్పడిన లోపాన్ని నిర్వహిస్తుంది.  
  
 System.IO.IOException 
ఇన్పుట్ / అవుట్పుట్ లోపాలను నిర్వహిస్తుంది.
 System.FieldAccessException 
చెల్లని ప్రైవేట్ / రక్షిత ప్రాప్యత ద్వారా లోపం ఏర్పడింది.
 
C # లో, మేము ప్రదర్శించడానికి 4 కీలకపదాలను ఉపయోగిస్తాము మినహాయింపు నిర్వహణ: 
ప్రయత్నించండి
క్యాచ్
చివరకు, మరియు
త్రో
  ఉదాహరణ:  
సిస్టమ్ పబ్లిక్ క్లాస్ ఎడురెక్ఎక్సంపుల్ {పబ్లిక్ స్టాటిక్ శూన్యత ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {ప్రయత్నించండి {int a = 10 int b = 0 int x = a / b} క్యాచ్ (మినహాయింపు ఇ) {కన్సోల్.రైట్‌లైన్ (ఇ)} కన్సోల్.రైట్‌లైన్ ('ఈ సందేశం క్యాచ్ బ్లాక్ నుండి వచ్చింది')}}
 
 // అవుట్పుట్: 
System.DivideByZeroException: సున్నా ద్వారా విభజించడానికి ప్రయత్నించారు. 
 F: C # TutorialC # ProgramsConsoleApp1ConsoleApp1Program.cs: 10 వ పంక్తిలో ExExaEdurekample.Main (స్ట్రింగ్ [] అర్గ్స్) వద్ద. 
 ఈ సందేశం క్యాచ్ బ్లాక్ నుండి
 అనుకూలీకరించిన మినహాయింపు ఉదాహరణ 
సిస్టమ్ పబ్లిక్ క్లాస్ ఉపయోగించడం<18) { throw new InvalidAgeException('Sorry, Age is expected to be greater than 18') } } public static void Main(string[] args) { try { validate(12) } catch (InvalidAgeException e) { Console.WriteLine(e) } Console.WriteLine('Catch block is being executed now.') } } 
 // అవుట్పుట్: 
చెల్లని ఏజ్ ఎక్సెప్షన్: క్షమించండి, వయస్సు 18 కంటే ఎక్కువగా ఉంటుందని భావిస్తున్నారు 
 F: C # TutorialC # ProgramsConsoleApp1ConsoleApp1Program.cs: 18 వ పంక్తిలో Customized.validate (Int32 వయస్సు) వద్ద 
 F: C # TutorialC # ProgramsConsoleApp1ConsoleApp1Program.cs: 23 వ పంక్తిలో అనుకూలీకరించిన మెయిన్ (స్ట్రింగ్ [] అర్గ్స్) వద్ద 
 క్యాచ్ బ్లాక్ ఇప్పుడు అమలు చేయబడుతోంది.
 
 చివరగా ఉదాహరణను బ్లాక్ చేయండి 
సిస్టమ్ పబ్లిక్ క్లాస్ ఉపయోగించి ఫైనల్ ఎక్సెప్షన్ {పబ్లిక్ స్టాటిక్ శూన్యత ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {ప్రయత్నించండి {int a = 10 int b = 0 int x = a / b} క్యాచ్ (మినహాయింపు ఇ) {కన్సోల్.రైట్‌లైన్ (ఇ)} చివరకు {కన్సోల్ .రైట్‌లైన్ ('చివరగా బ్లాక్ అమలు అవుతుంది')} కన్సోల్.రైట్‌లైన్ ('క్యాచ్ బ్లాక్ అమలు అవుతుంది')}}
 // అవుట్పుట్: 
System.DivideByZeroException: సున్నా ద్వారా విభజించడానికి ప్రయత్నించారు. 
 F: C # TutorialC # ProgramsConsoleApp1ConsoleApp1Program.cs: 10 వ పంక్తిలో FinalExecption.Main (స్ట్రింగ్ [] అర్గ్స్) వద్ద. 
 చివరగా బ్లాక్ అమలు అవుతుంది 
 క్యాచ్ బ్లాక్ అమలు అవుతుంది
 సిస్టమ్ మినహాయింపు సంతకం 
[SerializableAttribute] [ComVisibleAttribute (true)] పబ్లిక్ క్లాస్ సిస్టమ్ఎక్సెప్షన్: మినహాయింపు
 సిస్టమ్ మినహాయింపు కన్స్ట్రక్టర్లు 
 బిల్డర్ 
 వివరణ 
 సిస్టమ్ ఎక్సెప్షన్ () 
SystemException తరగతి యొక్క క్రొత్త ఉదాహరణను ప్రారంభించడానికి ఇది ఉపయోగించబడుతుంది.
 సిస్టమ్ ఎక్సెప్షన్ 
 (సీరియలైజేషన్ ఇన్ఫో, స్ట్రీమింగ్కాంటెక్స్ట్) 
సిస్టమ్ఎక్సెప్షన్ క్లాస్ యొక్క క్రొత్త ఉదాహరణను సీరియలైజ్డ్ డేటాతో ప్రారంభించడానికి ఇది ఉపయోగించబడుతుంది.
 సిస్టమ్ ఎక్సెప్షన్ (స్ట్రింగ్) 
పేర్కొన్న లోపం సందేశంతో SystemException తరగతి యొక్క క్రొత్త ఉదాహరణను ప్రారంభించడానికి ఇది ఉపయోగించబడుతుంది.
 సిస్టమ్ ఎక్సెప్షన్ (స్ట్రింగ్, మినహాయింపు) 
సిస్టమ్ ఎక్సెప్షన్ క్లాస్ యొక్క క్రొత్త ఉదాహరణను పేర్కొన్న దోష సందేశంతో మరియు ఈ మినహాయింపుకు కారణమైన అంతర్గత మినహాయింపుకు సూచనతో ప్రారంభించడానికి ఇది ఉపయోగించబడుతుంది.
 సిస్టమ్ మినహాయింపు లక్షణాలు 
 ఆస్తి 
 వివరణ 
 సమాచారం 
మినహాయింపు గురించి అదనపు వినియోగదారు నిర్వచించిన సమాచారాన్ని అందించే కీ / విలువ జతల సేకరణను పొందడానికి ఇది ఉపయోగించబడుతుంది.
 హెల్ప్‌లింక్ 
ఈ మినహాయింపుతో అనుబంధించబడిన సహాయ ఫైల్‌కు లింక్‌ను పొందడానికి లేదా సెట్ చేయడానికి ఇది ఉపయోగించబడుతుంది.
 HResult 
ఇది ఒక నిర్దిష్ట మినహాయింపుకు కేటాయించిన కోడెడ్ సంఖ్యా విలువ అయిన HRESULT ను పొందడానికి లేదా సెట్ చేయడానికి ఉపయోగించబడుతుంది.
 ఇన్నర్ ఎక్సెప్షన్ 
ప్రస్తుత మినహాయింపుకు కారణమైన మినహాయింపు ఉదాహరణను పొందడానికి ఇది ఉపయోగించబడుతుంది.
 సందేశం 
ప్రస్తుత మినహాయింపును వివరించే సందేశాన్ని పొందడానికి ఇది ఉపయోగించబడుతుంది.
 మూలం 
లోపానికి కారణమయ్యే అనువర్తనం పేరును పొందడానికి లేదా సెట్ చేయడానికి ఇది ఉపయోగించబడుతుంది.
 స్టాక్‌ట్రేస్ 
కాల్ స్టాక్‌లో తక్షణ ఫ్రేమ్‌ల యొక్క స్ట్రింగ్ ప్రాతినిధ్యం పొందడానికి ఇది ఉపయోగించబడుతుంది.
 టార్గెట్‌సైట్ 
ప్రస్తుత మినహాయింపును విసిరే పద్ధతిని పొందడానికి ఇది ఉపయోగించబడుతుంది.
 సిస్టమ్ మినహాయింపు పద్ధతులు 
 పద్ధతులు 
 వివరణ 
 సమానం (ఆబ్జెక్ట్) 
పేర్కొన్న వస్తువు ప్రస్తుత వస్తువుతో సమానంగా ఉందో లేదో తనిఖీ చేయడానికి ఇది ఉపయోగించబడుతుంది.
 ఖరారు () 
వనరులను ఖాళీ చేయడానికి మరియు శుభ్రపరిచే కార్యకలాపాలను నిర్వహించడానికి ఇది ఉపయోగించబడుతుంది.
 GetBaseException () 
ఇది రూట్ మినహాయింపు పొందడానికి ఉపయోగించబడుతుంది.
 GetHashCode () 
ఇది హాష్ కోడ్ పొందడానికి ఉపయోగించబడుతుంది.
 GetObjectData 
 (సీరియలైజేషన్ ఇన్ఫో, స్ట్రీమింగ్కాంటెక్స్ట్) 
ఇది ఆబ్జెక్ట్ డేటాను పొందడానికి ఉపయోగించబడుతుంది.
 GetType () 
ప్రస్తుత ఉదాహరణ యొక్క రన్‌టైమ్ రకాన్ని పొందడానికి ఇది ఉపయోగించబడుతుంది.
 మెంబర్‌వైస్‌క్లోన్ () 
ప్రస్తుత ఆబ్జెక్ట్ యొక్క నిస్సార కాపీని సృష్టించడానికి ఇది ఉపయోగించబడుతుంది.
 ToString () 
ప్రస్తుత మినహాయింపు యొక్క స్ట్రింగ్ ప్రాతినిధ్యాన్ని సృష్టించడానికి మరియు తిరిగి ఇవ్వడానికి ఇది ఉపయోగించబడుతుంది.
 సిస్టమ్ మినహాయింపు ఉదాహరణ 
సిస్టమ్ నేమ్‌స్పేస్ ఉపయోగించి CSharpProgram {class SystemExceptionExample {static void Main (string [] args) {try {int [] arr = new int [5] arr [10] = 25} catch (SystemException e) {Console.WriteLine (e)} }}}
 // అవుట్పుట్: 
System.IndexOutOfRangeException: సూచిక శ్రేణి యొక్క సరిహద్దులకు వెలుపల ఉంది. 
 CSharpProgram.SystemExceptionExample.Main (స్ట్రింగ్ [] అర్గ్స్) లో F: C # TutorialC # ProgramsConsoleApp1ConsoleApp1Program.cs: line 11
 
 సమకాలీకరణ 
సమకాలీకరణ అనేది ఒక నిర్దిష్ట సమయం కోసం వనరును ప్రాప్యత చేయడానికి 1 థ్రెడ్‌ను మాత్రమే అనుమతించే ఒక సాంకేతికత కావచ్చు. నియమించబడిన థ్రెడ్ దాని పనిని పూర్తి చేసేవరకు ప్రత్యామ్నాయ థ్రెడ్ అంతరాయం కలిగించదు.
మల్టీథ్రెడింగ్ ప్రోగ్రామ్‌లో, థ్రెడ్‌లు అనుమతించబడతాయికోసం ఏదైనా వనరును యాక్సెస్ చేయడానికిపేర్కొన్న అమలుసమయం. థ్రెడ్లు వనరులను పంచుకుంటాయి మరియు అసమకాలికంగా అమలు చేస్తాయి. భాగస్వామ్య వనరులను యాక్సెస్ చేస్తోంది (డేటా)ఒక ముఖ్యమైన పని కావచ్చుసాధారణంగాఆపవచ్చువ్యవస్థ.మేము దానిని ప్రభావితం చేసే ధోరణిని కలిగి ఉన్నాముసింక్రోనస్ పద్ధతిలో థ్రెడ్లను సృష్టించడం ద్వారా.
 సమకాలీకరణ లేకుండా ఉదాహరణ 
సిస్టమ్‌ను ఉపయోగించి సిస్టమ్‌ను ఉపయోగిస్తుంది. (int i = 1 i<= 10 i++) { Thread.Sleep(100) Console.WriteLine(i) } } } class Program { public static void Main(string[] args) { Edureka p = new Edureka() Thread t1 = new Thread(new ThreadStart(p.PrintTable)) Thread t2 = new Thread(new ThreadStart(p.PrintTable)) t1.Start() t2.Start() } } 
 // అవుట్పుట్: 
 
ఒకటి 
 ఒకటి 
 2 
 2 
 3 
 3 
 4 
 4 
 5 
 5 
 6 
 6 
 7 
 7 
 8 
 8 
 9 
 9 
 10 
 10
 
 సమకాలీకరణతో ఉదాహరణ 
సిస్టమ్‌ను ఉపయోగించి సిస్టమ్‌ను ఉపయోగించడం. థ్రెడింగ్ క్లాస్ ఎడురేకా {పబ్లిక్ శూన్యమైన ప్రింట్ టేబుల్ () {లాక్ (ఇది) {కోసం (int i = 1 i<= 10 i++) { Thread.Sleep(100) Console.WriteLine(i) } } } } class Program { public static void Main(string[] args) { Edureka p = new Edureka() Thread t1 = new Thread(new ThreadStart(p.PrintTable)) Thread t2 = new Thread(new ThreadStart(p.PrintTable)) t1.Start() t2.Start() } } 
 // అవుట్పుట్: 
ఒకటి 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 ఒకటి 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10
 క్రొత్త ఫీచర్లు 
మైక్రోసాఫ్ట్ సి # భాషకు అనేక తాజా లక్షణాలను జోడించింది, వాటిలో కొన్ని క్రింద పేర్కొనబడ్డాయి.
సి # 6.0
స్టాటిక్ డైరెక్టివ్ ఉపయోగించి
మినహాయింపు ఫిల్టర్లు
క్యాచ్ / చివరికి బ్లాక్లలో వేచి ఉండండి
ఆటో ప్రాపర్టీ ఇనిషియేజర్స్
గెట్టర్-మాత్రమే లక్షణాల కోసం డిఫాల్ట్ విలువలు
వ్యక్తీకరణ-శరీర సభ్యులు
శూన్య ప్రచారకుడు
స్ట్రింగ్ ఇంటర్పోలేషన్
పేరు ఆపరేటర్
డిక్షనరీ ఇనిషియేజర్
కంపైలర్-ఎ-సర్వీస్ (రోస్లిన్)
సి # 7.0
సరళి సరిపోలిక
టుపుల్స్
డీకన్స్ట్రక్షన్
స్థానిక విధులు
అంకెల విభజన
బైనరీ అక్షరాస్యులు
Ref రాబడి మరియు స్థానికులు
వ్యక్తీకరణ శరీర నిర్మాణదారులు మరియు ఫైనలైజర్లు
వ్యక్తీకరణ శరీర గెట్టర్లు మరియు సెట్టర్లు
అవుట్ వేరియబుల్స్
సాధారణీకరించిన అసిన్క్ రిటర్న్ రకాలు
సి # 7.1
అసిన్క్ మెయిన్
డిఫాల్ట్ వ్యక్తీకరణలు
 సి # ఆధారంగా ఇంటర్వ్యూ ప్రశ్నలు 
ముఖ్యమైన ఇంటర్వ్యూ సి # ప్రోగ్రామింగ్ లాంగ్వేజ్ ఆధారంగా ప్రశ్నలు ఈ నవీకరించబడిన వాటిలో చూడవచ్చు  .
దీనితో, మేము ఈ “సి # ట్యుటోరియల్” వ్యాసం చివరకి వచ్చాము. డేటా స్ట్రక్చర్స్, సింటాక్స్, కార్యాచరణ మరియు వాటిని ఉపయోగించి చేసే ఆపరేషన్ల యొక్క ప్రాముఖ్యతను మీరు అర్థం చేసుకున్నారని నేను ఆశిస్తున్నాను. ఇప్పుడు మీరు C # లో ప్రోగ్రామింగ్ యొక్క ప్రాథమికాలను అర్థం చేసుకున్నారుసి # ట్యుటోరియల్, చూడండి  శిక్షణ అందించబడింది  జావా వంటి అనేక సాంకేతిక పరిజ్ఞానాలపై ఎడురేకా చేత, వసంత మరియు చాలాప్రపంచవ్యాప్తంగా 250,000 మందికి పైగా సంతృప్తి చెందిన అభ్యాసకుల నెట్‌వర్క్‌తో విశ్వసనీయ ఆన్‌లైన్ లెర్నింగ్ కంపెనీకి లభించింది  మాకు ప్రశ్న? ఈ “సి # ట్యుటోరియల్” బ్లాగ్ యొక్క వ్యాఖ్యల విభాగంలో పేర్కొనండి మరియు మేము వీలైనంత త్వరగా మిమ్మల్ని సంప్రదిస్తాము.