C # లో, గుణాలు తరగతులు, రకాలు, పద్ధతులు మరియు ఫీల్డ్‌లతో సహా కోడ్‌కు కేటాయించిన మెటాడేటా ట్యాగ్‌లు. ప్రతిబింబం ఉపయోగించి, మీ ప్రోగ్రామ్‌లోని ప్రవర్తనలను మార్చడానికి మీరు ట్యాగ్‌లను పరిశీలించవచ్చు. వాటిని ఎలా ఉపయోగించాలో మరియు మీ స్వంతంగా ఎలా రాయాలో మేము మీకు చూపుతాము.

గుణాలు ఏమిటి?

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

[Attribute]
void Command() 
{

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

[Attribute("name", Test=false, Number=42)]

సీరియలైజేషన్ కోసం ఫీల్డ్లను గుర్తించడం ఒక సాధారణ ఉపయోగం కేసు. సి # లో అంతర్నిర్మిత ఉంది [Serializable] ట్యాగ్, ఇది తరగతి యొక్క బైట్‌లలో సీరియలైజేషన్‌కు మద్దతు ఇస్తుంది మరియు అనేక మూడవ పార్టీ లైబ్రరీలు వారి స్వంత ట్యాగ్‌లను అమలు చేస్తాయి. ఉదాహరణకు, మొంగోడిబి కోసం సి # డ్రైవర్‌లో బిసోన్‌లో సీరియలైజేషన్ కోసం చాలా ట్యాగ్‌లు ఉన్నాయి మరియు ఒక స్ట్రింగ్‌ను డాక్యుమెంట్ ఐడిగా అర్థం చేసుకునే ప్రత్యేక ట్యాగ్ కూడా ఉంది.

సి # ఇంటిగ్రేటెడ్ [Serializable] ట్యాగ్, ఇది బైట్‌లలో తరగతి యొక్క సీరియలైజేషన్‌కు మద్దతు ఇస్తుంది.

మరొక సాధారణ ఉపయోగ సందర్భం ఉన్నత స్థాయి కమాండ్ హ్యాండ్లర్ చేత నిర్వహించబడే ట్యాగింగ్ పద్ధతులు. ఉదాహరణకు, డిస్కార్డ్ బాట్, ఎవరైనా సందేశం పంపిన ప్రతిసారీ నిర్వహించబడే ఆదేశాల జాబితాను నమోదు చేస్తుంది. మీరు క్రొత్తదాన్ని వ్రాసే ప్రతిసారీ కమాండ్ హ్యాండ్లర్‌కు ప్రతి ఆదేశాన్ని మాన్యువల్‌గా జోడించే బదులు, మీరు ఈ పద్ధతిని ట్యాగ్ చేయవచ్చు [Command("commandname")]మరియు రన్టైమ్‌లో స్వయంచాలకంగా జోడించే సాధారణ పరిష్కారాన్ని ఉపయోగించండి.

లేబులింగ్ పద్ధతులు ఉన్నత స్థాయి కమాండ్ మేనేజర్ చేత నిర్వహించబడతాయి.

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

మీ లక్షణాలను ఎలా సృష్టించాలి

వాస్తవానికి, మీ తరగతులకు వర్తింపజేయడానికి మీరు మీ స్వంత అనుకూల లక్షణాలను సులభంగా సృష్టించవచ్చు. మీరు చేయవలసిందల్లా ఒక తరగతిని సృష్టించడం System.Attribute. మీరు ఈ తరగతికి ఎలా ఉపయోగించాలో పేర్కొనే లక్షణాన్ని కూడా జోడించవచ్చు; ఉదాహరణకు, ఇది తరగతులు లేదా నిర్మాణాలకు మాత్రమే వర్తిస్తుంది.

అప్పుడు, మీరు ఫీల్డ్‌లను మరియు ఇన్‌పుట్ పారామితులను తీసుకొని ఫీల్డ్‌లను జనాదరణ చేసే కన్స్ట్రక్టర్‌ను పేర్కొనవచ్చు. మీరు ఈ లక్షణాన్ని ఉపయోగించినప్పుడు, కాల్ చేయడం లాంటిది new Attribute(params), లేకుండా తప్ప new కీవర్డ్.

[System.AttributeUsage(System.AttributeTargets.Class | System.AttributeTargets.Struct)]  
public class AuthorAttribute : System.Attribute  
{  
    private string name;  
    public double version;  
  
    public AuthorAttribute(string name)  
    {  
        this.name = name;  
        version = 1.0;  
    }  
}

కాబట్టి ఎన్కోడ్ చేసిన కోడ్‌లో లక్షణం ప్రస్తావించబడినంత వరకు, మీ కోడ్‌ను ట్యాగ్ చేయడానికి మీరు వాటిని ఉపయోగించుకోవచ్చు.

కోడ్‌ను ట్యాగ్ చేయడానికి కన్స్ట్రక్టర్‌ను ఉపయోగించడం.

ప్రోగ్రామిక్‌గా లక్షణాలను యాక్సెస్ చేయడానికి, మీరు ప్రతిబింబం ఉపయోగించాలి. పనితీరు కోసం ప్రతిబింబం గొప్పది కాదు, కానీ లక్షణ వినియోగ సందర్భాలలో, ఇది సాధారణంగా పట్టింపు లేదు. మీరు ఉపయోగించవచ్చు Attribute.GetCustomAttributes ఫైల్ను తిరిగి ఇవ్వడానికి Attribute[], తరగతి రకాన్ని దాటి:

System.Attribute.GetCustomAttributes(typeof(className));

మీరు మొత్తం అసెంబ్లీలో లక్షణాల యొక్క అన్ని సందర్భాలను యాక్సెస్ చేయాలనుకుంటే, మీరు ఉపయోగించవచ్చు Assembly.GetExecutingAssembly().GetTypes() రన్నింగ్ రకాలను జాబితా చేసి, ఆ రకమైన అన్ని అనుకూల లక్షణాలను శోధించండి, అది శోధన పరామితిని కలిగి ఉందో లేదో చూడటానికి, ఐచ్ఛికంగా ఆ జాబితాను జత చేసిన తరగతి రకం ఆధారంగా ఫిల్టర్ చేస్తుంది.

var plugins = Assembly.GetExecutingAssembly().GetTypes()
    .Where(t => t.IsClass 
            && t.BaseType == typeof(BasePlugin) 
            && Attribute.GetCustomAttributes
    .ToList();

అసెంబ్లీని ఉపయోగించండి.గెట్ఎక్సెక్యూటింగ్అసెల్బెల్ (). రన్నింగ్ రకాలను జాబితా చేయడానికి GetTypes (), ఆపై శోధన పరామితిని కలిగి ఉందో లేదో తెలుసుకోవడానికి అన్ని అనుకూల లక్షణాలను తనిఖీ చేయండి.

లక్షణ పారామితులను ప్రాప్యత చేయడానికి, వాటిని ఏ ఇతర ప్రజా ఆస్తి వలె నేరుగా గుణం తరగతి నుండి యాక్సెస్ చేయండి.

Source link