Najbardziej przydatne atrybuty [zamknięte]

Wiem, że atrybuty są niezwykle przydatne. Istnieją pewne predefiniowane, takie jak takie, [Browsable(false)]które pozwalają ukryć właściwości na karcie właściwości. Oto dobre pytanie wyjaśniające atrybuty: Co to są atrybuty w .NET?

Jakie są predefiniowane atrybuty (i ich przestrzeń nazw), których faktycznie używasz w swoich projektach?

[DebuggerDisplay]może być naprawdę pomocny, aby szybko zobaczyć niestandardowe wyjście typu, gdy najedziesz myszką na wystąpienie typu podczas debugowania. przykład:

[DebuggerDisplay("FirstName={FirstName}, LastName={LastName}")]
class Customer
{
    public string FirstName;
    public string LastName;
}

Tak powinno to wyglądać w debuggerze:

Warto również wspomnieć, że [WebMethod]atrybut z CacheDurationzestawem właściwości może uniknąć niepotrzebnego wykonania metody usługi sieciowej.

System.Obsoletejest, moim zdaniem, jednym z najbardziej użytecznych atrybutów w ramach. Bardzo przydatna jest możliwość ostrzeżenia o kodzie, który nie powinien już być używany. Uwielbiam mieć sposób, aby powiedzieć programistom, że coś nie powinno być dłużej używane, a także mieć sposób, aby wyjaśnić, dlaczego i wskazać lepszy / nowy sposób robienia czegoś.

Jest Conditional attributeto również bardzo przydatne do debugowania. Pozwala na dodawanie do kodu metod do celów debugowania, które nie zostaną skompilowane po zbudowaniu rozwiązania do wydania.

Następnie istnieje wiele atrybutów specyficznych dla Kontrolek WWW, które uważam za przydatne, ale są one bardziej szczegółowe i nie mają żadnego zastosowania poza opracowaniem kontrolek serwera z tego, co znalazłem.

[Flags]jest całkiem przydatny. Z pewnością cukier syntaktyczny, ale wciąż całkiem przyjemny.

[Flags] 
enum SandwichStuff
{
   Cheese = 1,
   Pickles = 2,
   Chips = 4,
   Ham = 8,
   Eggs = 16,
   PeanutButter = 32,
   Jam = 64
};

public Sandwich MakeSandwich(SandwichStuff stuff)
{
   Console.WriteLine(stuff.ToString());
   // ...
}

// ...

MakeSandwich(SandwichStuff.Cheese 
   | SandwichStuff.Ham 
   | SandwichStuff.PeanutButter);
// produces console output: "Cheese, Ham, PeanutButter"

Leppie wskazuje na coś, czego nie zdawałem sobie sprawy, a to raczej tłumi mój entuzjazm dla tego atrybutu: nie instruuje kompilatora, aby zezwalał na kombinacje bitów jako prawidłowe wartości zmiennych wyliczeniowych, kompilator pozwala na to niezależnie od wyliczeń. Moje tło w C ++ pokazano przez ... westchnienie

Lubię [DebuggerStepThrough]z System.Diagnostics .

Jest to bardzo przydatne, aby uniknąć wchodzenia w te jednowierszowe metody lub właściwości „nic nie rób” (jeśli jesteś zmuszony do pracy we wczesnej wersji .Net bez właściwości automatycznych). Umieść atrybut na krótkiej metodzie lub narzędziu pobierającym lub ustawiającym właściwość, a będziesz latać tuż obok, nawet po wciśnięciu przycisku „wejdź” do debuggera.

Oto, co warto, oto lista wszystkich atrybutów .NET . Jest ich kilkaset.

Nie wiem o nikim innym, ale mam poważne RTFM do zrobienia!

Mój głos byłby za Conditional

[Conditional("DEBUG")]
public void DebugOnlyFunction()
{
    // your code here
}

Możesz użyć tego, aby dodać funkcję z zaawansowanymi funkcjami debugowania; na przykład Debug.Write, jest wywoływany tylko w kompilacjach debugowania, a zatem pozwala na enkapsulację złożonej logiki debugowania poza głównym przepływem programu.

Zawsze używać DisplayName, Descriptiona DefaultValueprzypisuje się właściwości publiczne moich własnych kontroli użytkowników, kontroli lub dowolnej klasy będę edytować poprzez siatkę nieruchomości. Znaczniki te są używane przez .NET PropertyGrid do formatowania nazwy, panelu opisu i pogrubionych wartości, które nie są ustawione na wartości domyślne.

[DisplayName("Error color")]
[Description("The color used on nodes containing errors.")]
[DefaultValue(Color.Red)]
public Color ErrorColor
{
    ...
} 

Chciałbym tylko, żeby IntelliSense z Visual Studio wziął ten Descriptionatrybut pod uwagę, gdyby nie znaleziono komentarza XML. Pozwoliłoby to uniknąć powtarzania tego samego zdania dwa razy.

[Serializable]jest używany przez cały czas do serializacji i deserializacji obiektów do i z zewnętrznych źródeł danych, takich jak xml lub ze zdalnego serwera. Więcej o tym tutaj.

W duchu Hofstadtian ten [Attribute]atrybut jest bardzo przydatny, ponieważ jest to sposób tworzenia własnych atrybutów. Użyłem atrybutów zamiast interfejsów do implementacji systemów wtyczek, dodawania opisów do Enums, symulacji wielu wysyłek i innych sztuczek.

Oto post o interesującym atrybucie InternalsVisibleTo . Zasadniczo to, co robi, naśladuje funkcjonalność dostępu znajomych w C ++. Jest bardzo przydatny do testowania jednostkowego.

Stwierdziłem, [DefaultValue]że jest całkiem przydatny.

Sugerowałbym [TestFixture]i [Test]- z biblioteki nUnit .

Testy jednostkowe w kodzie zapewniają bezpieczeństwo w refaktoryzacji i skodyfikowanej dokumentacji.

[XmlIgnore]

ponieważ pozwala to zignorować (w dowolnej serializacji xml) obiekty „nadrzędne”, które w przeciwnym razie spowodowałyby wyjątki podczas zapisywania.

Nie jest dobrze nazwany, nie jest dobrze obsługiwany w środowisku i nie powinien wymagać parametru, ale ten atrybut jest przydatnym markerem dla niezmiennych klas:

[ImmutableObject(true)]

Lubię używać tego [ThreadStatic]atrybutu w połączeniu z programowaniem opartym na wątkach i stosach. Na przykład, jeśli chcę wartość, którą chcę podzielić z resztą sekwencji wywołania, ale chcę to zrobić poza pasmem (tj. Poza parametrami wywołania), mogę zastosować coś takiego.

class MyContextInformation : IDisposable {
    [ThreadStatic] private static MyContextInformation current;

    public static MyContextInformation Current {
        get { return current; }
    }

    private MyContextInformation previous;


    public MyContextInformation(Object myData) {
       this.myData = myData;
       previous = current;
       current = this;
    }

    public void Dispose() {
       current = previous;
    }
}

Później w moim kodzie mogę tego użyć, aby przekazać informacje kontekstowe poza pasmem osobom znajdującym się poniżej mojego kodu. Przykład:

using(new MyContextInformation(someInfoInContext)) {
   ...
}

Atrybut ThreadStatic pozwala mi zawęzić wywołanie tylko do danego wątku, unikając bałaganu związanego z dostępem do danych w wątkach.

DebuggerHiddenAttribute co pozwala na uniknięcie krok do kodu, który nie powinien być debugowane.

public static class CustomDebug
{
    [DebuggerHidden]
    public static void Assert(Boolean condition, Func<Exception> exceptionCreator) { ... }
}

...

// The following assert fails, and because of the attribute the exception is shown at this line
// Isn't affecting the stack trace
CustomDebug.Assert(false, () => new Exception()); 

Zapobiega także wyświetlaniu metod w stosie śledzenia, co jest przydatne, gdy metoda zawiera tylko inną metodę:

[DebuggerHidden]
public Element GetElementAt(Vector2 position)
{
    return GetElementAt(position.X, position.Y);
}

public Element GetElementAt(Single x, Single y) { ... }

Jeśli teraz wywołujesz, GetElementAt(new Vector2(10, 10))a błąd jest zawijany w metodzie opakowanej, stos wywołań nie pokazuje metody, która wywołuje metodę zgłaszającą błąd.

DesignerSerializationVisibilityAttributejest bardzo przydatne. Gdy umieścisz właściwość środowiska wykonawczego w formancie lub komponencie i nie chcesz, aby projektant serializował ją, używasz jej w następujący sposób:

[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public Foo Bar {
    get { return baz; }
    set { baz = value; }
}

Tylko kilka atrybutów jest wspieranych przez kompilator, ale jedno bardzo interesujące użycie atrybutów znajduje się w AOP: PostSharp używa twoich niestandardowych atrybutów do wstrzykiwania IL do metod, pozwalając na wszystkie możliwości ... log / trace są trywialnymi przykładami - ale kilka innych dobrych przykładów są rzeczy takie jak automatyczna implementacja INotifyPropertyChanged ( tutaj ).

Niektóre z nich mają bezpośredni wpływ na kompilator lub środowisko wykonawcze :

• [Conditional("FOO")] - wywołania tej metody (w tym oceny argumentów) występują tylko wtedy, gdy podczas kompilacji zdefiniowano symbol „FOO”
• [MethodImpl(...)] - używany do wskazania kilku rzeczy, takich jak synchronizacja, wstawianie
• [PrincipalPermission(...)] - używane do automatycznego wprowadzania kontroli bezpieczeństwa do kodu
• [TypeForwardedTo(...)]- służy do przenoszenia typów między złożeniami bez odbudowywania wywołujących

W przypadku rzeczy, które są sprawdzane ręcznie przez odbicie - jestem wielkim fanem System.ComponentModelatrybutów; rzeczy takie jak [TypeDescriptionProvider(...)], [TypeConverter(...)]i [Editor(...)]które mogą całkowicie zmienić zachowanie typów w scenariuszach wiązania danych (tj. właściwości dynamiczne itp.).

Gdybym miał wykonać indeksowanie pokrycia kodu, myślę, że te dwa byłyby najlepsze:

 [Serializable]
 [WebMethod]

I zostały z wykorzystaniem [DataObjectMethod]ostatnio. Opisuje metodę, dzięki której możesz używać swojej klasy z ObjectDataSource (lub innymi kontrolkami).

[DataObjectMethod(DataObjectMethodType.Select)] 
[DataObjectMethod(DataObjectMethodType.Delete)] 
[DataObjectMethod(DataObjectMethodType.Update)] 
[DataObjectMethod(DataObjectMethodType.Insert)] 

Więcej informacji

W naszym obecnym projekcie korzystamy

[ComVisible(false)]

Kontroluje dostępność pojedynczego zarządzanego typu lub elementu lub wszystkich typów w zespole do modelu COM.

Więcej informacji

[TypeConverter(typeof(ExpandableObjectConverter))]

Mówi projektantowi, aby rozwinął właściwości, które są klasami (twojej kontroli)

[Obfuscation]

Nakazuje narzędziom zaciemniającym wykonanie określonych działań dla złożenia, typu lub elementu. (Chociaż zwykle używasz poziomu asemblera[assembly:ObfuscateAssemblyAttribute(true)]

Atrybuty, których najczęściej używam, to te związane z serializacją XML.

XmlRoot

XmlElement

XmlAttribute

itp...

Niezwykle przydatny podczas szybkiego i brudnego analizowania lub serializacji XML.

Jako programista średniego poziomu lubię

System.ComponentModel.EditorBrowsableAttribute Pozwala mi ukrywać właściwości, aby programista interfejsu użytkownika nie był przytłoczony właściwościami, których nie muszą widzieć.

System.ComponentModel.BindableAttributeNiektóre rzeczy nie muszą być danymi. Ponownie zmniejsza pracę, którą muszą wykonać programiści interfejsu użytkownika.

Podoba mi się także wspomniany DefaultValueprzez Lawrence'a Johnstona.

System.ComponentModel.BrowsableAttributei Flagssą używane regularnie.

Używam w System.STAThreadAttribute System.ThreadStaticAttribute razie potrzeby.

Tak poza tym. I są one tak samo cenne dla wszystkich programistów .NET Framework.

[EditorBrowsable(EditorBrowsableState.Never)]pozwala ukryć właściwości i metody przed IntelliSense, jeśli projekt nie jest w twoim rozwiązaniu. Bardzo pomocne w ukrywaniu nieprawidłowych przepływów dla płynnych interfejsów. Jak często chcesz GetHashCode () lub Equals ()?

Dla MVC [ActionName("Name")]pozwala mieć akcję Get i Post z tą samą sygnaturą metody lub użycie myślników w nazwie akcji, co w innym przypadku nie byłoby możliwe bez utworzenia dla niej trasy.

Uważam, że należy tutaj wspomnieć, że następujące atrybuty są również bardzo ważne:

STAThreadAttribute 

Wskazuje, że model wątkowania COM dla aplikacji to jedno-wątkowy apartament (STA).

Na przykład ten atrybut jest używany w aplikacjach Windows Forms:

static class Program
{
    /// <summary>
    /// The main entry point for the application.
    /// </summary>
    [STAThread]
    static void Main()
    {
        Application.EnableVisualStyles();
        Application.SetCompatibleTextRenderingDefault(false);
        Application.Run(new Form1());
    }
}

I również ...

SuppressMessageAttribute

Pomija zgłaszanie naruszenia określonych reguł narzędzia analizy statycznej, umożliwiając wielokrotne pomijanie pojedynczego artefaktu kodu.

Na przykład:

[SuppressMessage("Microsoft.Performance", "CA1801:ReviewUnusedParameters", MessageId = "isChecked")]
[SuppressMessage("Microsoft.Performance", "CA1804:RemoveUnusedLocals", MessageId = "fileIdentifier")]
static void FileNode(string name, bool isChecked)
{
    string fileIdentifier = name;
    string fileName = name;
    string version = String.Empty;
}

Z góry mojej głowy znajduje się krótka lista, z grubsza posortowana według częstotliwości użycia, predefiniowanych atrybutów, których faktycznie używam w dużym projekcie (~ 500 tys. LoC):

Flagi, Serializable, WebMethod, COMVisible, TypeConverter, Conditional, ThreadStatic, Przestarzałe, InternalsVisibleTo, DebuggerStepThrough.

Generuję klasę danych za pomocą CodeSmith i używam atrybutów do niektórych procedur sprawdzania poprawności. Oto przykład:

/// <summary>
/// Firm ID
/// </summary>
[ChineseDescription("送样单位编号")]
[ValidRequired()]
public string FirmGUID
{
    get { return _firmGUID; }
    set { _firmGUID = value; }
}

Mam klasę narzędziową do sprawdzania poprawności na podstawie atrybutów dołączonych do klasy encji danych. Oto kod:

namespace Reform.Water.Business.Common
{
/// <summary>
/// Validation Utility
/// </summary>
public static class ValidationUtility
{
    /// <summary>
    /// Data entity validation
    /// </summary>
    /// <param name="data">Data entity object</param>
    /// <returns>return true if the object is valid, otherwise return false</returns>
    public static bool Validate(object data)
    {
        bool result = true;
        PropertyInfo[] properties = data.GetType().GetProperties();
        foreach (PropertyInfo p in properties)
        {
            //Length validatioin
            Attribute attribute = Attribute.GetCustomAttribute(p,typeof(ValidLengthAttribute), false);
            if (attribute != null)
            {
                ValidLengthAttribute validLengthAttribute = attribute as ValidLengthAttribute;
                if (validLengthAttribute != null)
                {
                    int maxLength = validLengthAttribute.MaxLength;
                    int minLength = validLengthAttribute.MinLength;
                    string stringValue = p.GetValue(data, null).ToString();
                    if (stringValue.Length < minLength || stringValue.Length > maxLength)
                    {
                        return false;
                    }
                }
            }
            //Range validation
            attribute = Attribute.GetCustomAttribute(p,typeof(ValidRangeAttribute), false);
            if (attribute != null)
            {
                ValidRangeAttribute validRangeAttribute = attribute as ValidRangeAttribute;
                if (validRangeAttribute != null)
                {
                    decimal maxValue = decimal.MaxValue;
                    decimal minValue = decimal.MinValue;
                    decimal.TryParse(validRangeAttribute.MaxValueString, out maxValue);
                    decimal.TryParse(validRangeAttribute.MinValueString, out minValue);
                    decimal decimalValue = 0;
                    decimal.TryParse(p.GetValue(data, null).ToString(), out decimalValue);
                    if (decimalValue < minValue || decimalValue > maxValue)
                    {
                        return false;
                    }
                }
            }
            //Regex validation
            attribute = Attribute.GetCustomAttribute(p,typeof(ValidRegExAttribute), false);
            if (attribute != null)
            {
                ValidRegExAttribute validRegExAttribute = attribute as ValidRegExAttribute;
                if (validRegExAttribute != null)
                {
                    string objectStringValue = p.GetValue(data, null).ToString();
                    string regExString = validRegExAttribute.RegExString;
                    Regex regEx = new Regex(regExString);
                    if (regEx.Match(objectStringValue) == null)
                    {
                        return false;
                    }
                }
            }
            //Required field validation
            attribute = Attribute.GetCustomAttribute(p,typeof(ValidRequiredAttribute), false);
            if (attribute != null)
            {
                ValidRequiredAttribute validRequiredAttribute = attribute as ValidRequiredAttribute;
                if (validRequiredAttribute != null)
                {
                    object requiredPropertyValue = p.GetValue(data, null);
                    if (requiredPropertyValue == null || string.IsNullOrEmpty(requiredPropertyValue.ToString()))
                    {
                        return false;
                    }
                }
            }
        }
        return result;
    }
}
}

[DeploymentItem("myFile1.txt")] Dokument MSDN na DeploymentItem

Jest to bardzo przydatne, jeśli testujesz plik lub używasz go jako danych wejściowych do testu.

[System.Security.Permissions.PermissionSetAttribute] zezwala na stosowanie działań zabezpieczających dla pakietu PermissionSet do kodu przy użyciu deklaratywnych zabezpieczeń.

// usage:
public class FullConditionUITypeEditor : UITypeEditor
{
    // The immediate caller is required to have been granted the FullTrust permission.
    [PermissionSetAttribute(SecurityAction.LinkDemand, Name = "FullTrust")]
    public FullConditionUITypeEditor() { }
}