Wat is die eienskappe in .NETTO?

Question

Wat is die eienskappe in .NET, wat is dit goed vir, en hoe skep ek my eie eienskappe?

Answer 1

Metadata. Data oor jou voorwerpe / metodes / eienskappe.

Byvoorbeeld ek dalk 'n kenmerk genaamd verklaar: DisplayOrder so ek kan maklik beheer in watter volgorde eiendomme in die UI moet verskyn. Ek kan dan voeg dit by 'n klas en skryf 'n paar GUI komponente wat die eienskappe te onttrek en bestel die UI elemente gepas.

public class DisplayWrapper
{
    private UnderlyingClass underlyingObject;

    public DisplayWrapper(UnderlyingClass u)
    {
        underlyingObject = u;
    }

    [DisplayOrder(1)]
    public int SomeInt
    {
        get
        {
            return underlyingObject .SomeInt;
        }
    }

    [DisplayOrder(2)]
    public DateTime SomeDate
    {
        get
        {
            return underlyingObject .SomeDate;
        }
    }
}

daardeur te verseker dat SomeInt is altyd vertoon voordat SomeDate wanneer daar met my persoonlike GUI komponente.

Maar, sal jy sien hulle mees gebruikte buite die direkte kodering omgewing. Byvoorbeeld gebruik die Windows Designer hulle op groot skaal sodat dit weet hoe om te gaan met custom made voorwerpe. Die gebruik van die BrowsableAttribute soos so:

[Browsable(false)]
public SomeCustomType DontShowThisInTheDesigner
{
    get{/*do something*/}
}

Vertel die ontwerper nie by hierdie lys in die beskikbare eiendomme in die venster Properties by ontwerp tyd byvoorbeeld.

Jy kan ook hulle gebruik vir kode-generasie, pre-stel bedrywighede (soos Na-Skerp) of hardloop-time bedrywighede soos Reflection.Emit. Byvoorbeeld, kan jy 'n bietjie van die kode vir profilering wat deursigtig toegedraai elke enkele roep jou kode maak en keer dit skryf. Jy kan "opt-out" van die tydsberekening via 'n kenmerk wat jy op spesifieke metodes te plaas.

public void SomeProfilingMethod(MethodInfo targetMethod, object target, params object[] args)
{
    bool time = true;
    foreach (Attribute a in target.GetCustomAttributes())
    {
        if (a.GetType() is NoTimingAttribute)
        {
            time = false;
            break;
        }
    }
    if (time)
    {
        StopWatch stopWatch = new StopWatch();
        stopWatch.Start();
        targetMethod.Invoke(target, args);
        stopWatch.Stop();
        HandleTimingOutput(targetMethod, stopWatch.Duration);
    }
    else
    {
        targetMethod.Invoke(target, args);
    }
}

verkondig hulle is maklik, net 'n klas wat erf vanaf kenmerk.

public class DisplayOrderAttribute : Attribute
{
    private int order;

    public DisplayOrderAttribute(int order)
    {
        this.order = order;
    }

    public int Order
    {
        get { return order; }
    }
}

En onthou dat wanneer jy die kenmerk gebruik, kan jy die agtervoegsel "kenmerk" die samesteller sal byvoeg dat vir jou laat.

Nota: Eienskappe niks doen deur self - daar moet 'n ander kode wat hulle gebruik word. Soms dat kode is geskryf vir jou, maar soms moet jy dit self skryf. Byvoorbeeld, die C # samesteller omgee oor 'n paar en sekere raamwerke raamwerke gebruik sommige (bv NUnit lyk vir [TestFixture] op 'n klas en [Test] op 'n toets metode tydens die laai van 'n vergadering).
So wanneer die skep van jou eie persoonlike kenmerk daarvan bewus wees dat dit die gedrag van jou kode nie sal 'n impak op alle. Jy moet die ander deel wat eienskappe tjeks (via besinning) skryf en op te tree op hulle.

Answer 2

Baie mense het geantwoord, maar niemand het dit genoem tot dusver ...

kenmerke is swaar gebruik met nadenke. Weerspieëling is reeds redelik stadig.

Dit is baie moeite werd merk jou persoonlike eienskappe as sealed klasse aan hul runtime prestasie te verbeter.

Dit is ook 'n goeie idee om te oorweeg waar dit gepas om te gebruik plaas so 'n kenmerk, en om jou kenmerk (!) Toe te skryf aan hierdie aandui via AttributeUsage . Die lys van beskikbare kenmerk gebruike kan jy verras:

• Vergadering
• Module
• Klas
• struct
• Enum
• Constructor
• Metode
• Eiendom
• Veld
• Event
• Interface
• Parameter
• Delegeer
• ReturnValue
• GenericParameter
• Alle

Dit is ook cool dat die AttributeUsage kenmerk is deel van ondertekening van die AttributeUsage kenmerk se. Whoa vir omsendbrief afhanklikhede!

[AttributeUsageAttribute(AttributeTargets.Class, Inherited = true)]
public sealed class AttributeUsageAttribute : Attribute

Answer 3

eienskappe is 'n soort van meta data vir kodering klasse. Dit word dikwels gebruik in Winforms byvoorbeeld om beheer verberg die nutsbalk, maar kan in jou eie aansoek geïmplementeer word om gevalle van verskillende klasse in staat stel om op te tree in spesifieke maniere.

Begin deur die skep van 'n kenmerk:

[AttributeUsage(AttributeTargets.Class, AllowMultiple=false, Inherited=true)]
public class SortOrderAttribute : Attribute
{
    public int SortOrder { get; set; }

    public SortOrderAttribute(int sortOrder)
    {
        this.SortOrder = sortOrder;
    }
}

Alle kenmerk klasse moet die agtervoegsel "kenmerk" het om geldig te wees.
Na dit gedoen word, skep 'n klas wat die kenmerk gebruik.

[SortOrder(23)]
public class MyClass
{
    public MyClass()
    {
    }
}

Nou kan jy 'n spesifieke klas 'SortOrderAttribute kyk (as dit 'n mens) deur die volgende te doen:

public class MyInvestigatorClass
{
    public void InvestigateTheAttribute()
    {
        // Get the type object for the class that is using
        // the attribute.
        Type type = typeof(MyClass);

        // Get all custom attributes for the type.
        object[] attributes = type.GetCustomAttributes(
            typeof(SortOrderAttribute), true);

        // Now let's make sure that we got at least one attribute.
        if (attributes != null && attributes.Length > 0)
        {
            // Get the first attribute in the list of custom attributes
            // that is of the type "SortOrderAttribute". This should only
            // be one since we said "AllowMultiple=false".
            SortOrderAttribute attribute = 
                attributes[0] as SortOrderAttribute;

            // Now we can get the sort order for the class "MyClass".
            int sortOrder = attribute.SortOrder;
        }
    }
}

As jy meer wil weet oor hierdie lees, kan jy altyd kyk na MSDN wat 'n goeie beskrywing het.
Ek hoop dit het gehelp jy uit!

Answer 4

'n kenmerk is'n klas wat bevat'n paar bietjie van die funksies wat jy kan aansoek doen om voorwerpe in jou kode.Om een te skep, skep'n klas wat afgelei van die Stelsel.Kenmerk.

Soos vir wat hulle is goed vir...daar is byna onbeperkte gebruik vir hulle.

http://www.codeproject.com/KB/cs/dotnetattributes.aspx

Answer 5

eienskappe is soos metadata toegepas klasse, metodes of gemeentes.

Dit is goed vir 'n aantal van die dinge (debugger visualisering, merk dinge as verouderde, merk dinge as serialiseerbaar, die lys is eindeloos).

Die skep van jou eie persoonlike mense is maklik as pie. Begin hier:

http://msdn.microsoft.com/ en-ons / library / sw480ze8 (VS.71) Aspx

Answer 6

In die projek wat ek werk op die oomblik, daar is'n stel van die UI voorwerpe van verskillende geure en'n redakteur te vergadering hierdie voorwerpe te skep bladsye vir gebruik in die hoof aansoek, 'n bietjie soos die vorm ontwerper in DevStudio.Hierdie voorwerpe bestaan in hul eie gemeente en elke voorwerp is'n klas afgelei van UserControl en het'n persoonlike kenmerk.Hierdie kenmerk is gedefinieer soos hierdie:

[AttributeUsage (AttributeTargets::Class)]
public ref class ControlDescriptionAttribute : Attribute
{
public:
  ControlDescriptionAttribute (String ^name, String ^description) :
    _name (name),
    _description (description)
  {
  }

  property String ^Name
  {
    String ^get () { return _name; }
  }

  property String ^Description
  {
    String ^get () { return _description; }
  }

private:
  String
    ^ _name,
    ^ _description;
};

en ek pas dit aan'n klas soos hierdie:

[ControlDescription ("Pie Chart", "Displays a pie chart")]
public ref class PieControl sealed : UserControl
{
  // stuff
};

dit is wat die vorige plakkate het gesê.

Gebruik die eienskap, die redakteur het'n Generic::List <Type> met die beheer tipes.Daar is'n lys boks wat die gebruiker kan sleep en laat val op die bladsy te skep'n geval van die beheer.Om te vul die lys boks, ek kry die ControlDescriptionAttribute vir die beheer en vul'n inskrywing in die lys:

// done for each control type
array <Object ^>
  // get all the custom attributes
  ^attributes = controltype->GetCustomAttributes (true);

Type
  // this is the one we're interested in
  ^attributetype = ECMMainPageDisplay::ControlDescriptionAttribute::typeid;

// iterate over the custom attributes
for each (Object ^attribute in attributes)
{
  if (attributetype->IsInstanceOfType (attribute))
  {
    ECMMainPageDisplay::ControlDescriptionAttribute
      ^description = safe_cast <ECMMainPageDisplay::ControlDescriptionAttribute ^> (attribute);

    // get the name and description and create an entry in the list
    ListViewItem
      ^item = gcnew ListViewItem (description->Name);

    item->Tag = controltype->Name;
    item->SubItems->Add (description->Description);

    mcontrols->Items->Add (item);
    break;
  }
}

Let daarop:die bogenoemde is C++/CLI maar dit is nie moeilik om te skakel na die C# (ja, ek weet, C++/CLI is'n gruwel, maar dit is wat ek het om te werk met :-( )

Jy kan sit eienskappe op die meeste dinge en daar is'n hele reeks van vooraf gedefinieerde eienskappe.Die redakteur hierbo lyk ook vir persoonlike eienskappe op eiendomme wat beskryf die eiendom en hoe om dit te wysig.

Sodra jy die hele idee, sal jy wonder hoe jy ooit geleef het sonder hulle.

Answer 7

As gesê eienskappe is relatief maklik om te skep. Die ander deel van die werk is die skep van kode wat dit gebruik. In die meeste gevalle sal jy weerspieëling gebruik tydens looptyd om gedrag te verander op grond van die teenwoordigheid van 'n kenmerk of sy eienskappe. Daar is ook gevalle waar jy eienskappe sal inspekteer op saamgestel kode om 'n soort van statiese ontleding doen. Byvoorbeeld, kan parameters as nie-nul gemerk en die analise-instrument kan dit gebruik as 'n wenk.

Die gebruik van die eienskappe en die wete dat die toepaslike scenario's vir die gebruik daarvan is die grootste deel van die werk.

Answer 8

kenmerke is, in wese, stukkies data wat jy wil om te heg aan jou tipes (klasse, metodes, gebeure, enums, ens.)

Die idee is dat te hardloop tyd 'n ander tipe / raamwerk / instrument sal navraag jou tipe vir die inligting in die kenmerk en daad op dit .

So, byvoorbeeld, Visual Studio kan die eienskappe van 'n 3de party beheer navraag om uit te vind wat die eienskappe van die beheer in die paneel Properties by ontwerp tyd moet verskyn.

eienskappe kan ook gebruik word in aspekte georiënteerd programmering te spuit / voorwerpe te hardloop tyd wat gebaseer is op die eienskappe wat hulle versier en voeg validering, aan te meld, ens om die voorwerpe sonder dat die besigheid logika van die voorwerp te manipuleer.

Answer 9

Jy kan persoonlike gebruik eienskappe as 'n eenvoudige manier om tag waardes in sub-klasse te definieer sonder om dieselfde kode oor en oor weer skryf vir elke subklas. Ek het afgekom op 'n mooi bondige voorbeeld deur John Waters van hoe om te definieer en gebruik persoonlike eienskappe in jou eie kode.

Daar is 'n handleiding by http: // MSDN .microsoft.com / af-ons / library / aa288454 (VS.71) Aspx

Answer 10

As jy wil begin skep van 'n kenmerk, maak 'n C # bron lêer, tipe attribute en druk [TAB]. Dit sal uit te brei na 'n sjabloon vir 'n nuwe kenmerk.

Answer 11

kenmerke is ook algemeen gebruik word vir aspekte georiënteerd programmering. Vir 'n voorbeeld van hierdie check die PostSharp projek.