Betydning af firkantede parenteser

Det er en attribut for main metoden (firkant parentesen angiver at det er en attribut, ligesom [WebMethod] er det).

http://www.syncfusion.com/faq/winforms/search/967.asp

http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemSTAThreadAttributeClassTopic.asp

Den her giver også en del gode hints:

http://groups.google.dk/groups?hl=da&lr=&threadm=%237ZLpffTCHA.4280%40tkmsftngp09&rnum=4&prev=/groups%3Fq%3DSTAThread%26hl%3Dda%26lr%3D%26selm%3D%25237ZLpffTCHA.4280%2540tkmsftngp09%26rnum%3D4

ja okay...Men det var sådan mere syntaxen. Jeg ved at man også selv kan lave noget der gør brug af det.

Se fx. denne her kode
[AttributeUsage(AttributeTargets.Property, Inherited = true, AllowMultiple = true)]

    public abstract class ValidatorAttribute : Attribute

    {

        protected ValidatorAttribute() {}



        protected string _errorMessage;



        public string ErrorMessage {

            get { return this._errorMessage; }

            set { this._errorMessage = value; }

        }

    }

Der er også skrevet noget inde i [] i toppen. Hvad betyder det?
Det syntaxen jeg ikke forstår

her er et andet eksempel


        [MapToControl("NickName", ControlMappingDirection.ReadWrite)]

        [MapToControl("Blah")]

        public string Name {

            get { return this._name; }

            set { this._name = value; }

        }



        [UIBrokerIgnore()]

        public string Wilma {

            get { return this._wilma; }

            set { this._wilma = value; }

det inde i []'en henviser til en type du har et sted... dvs. at når der står noget inde i paranteserne kommer der argumenter med til types constructor.

derudover har jeg fået indtryk at hvis man ikke skriver () i enden på klassenavnen, bliver den parameterløse constructor kaldet. Jeg har dog ikke umiddelbart kunne finde noget omkring lige det på nettet.

Men f.eks. WebMethod - det er en klasse, helt exact System.Web.Services.WebMethod

Ved at oprette en instans af den klasse og sende med som property giver man compileren noget at arbejde med.

rettelse: det er ikke kun compileren der bruger attribut'erne... de kan også aflæses senere, af f.eks. CLR'en

STAThread henviser ligeledes til System.STAThreadAttribute-klassen

ms-help://MS.NETFrameworkSDKv1.1/cpref/html/frlrfsystemstathreadattributeclasstopic.htm

AttriuteUsage er ligeledes en klasse:, nemlig System.AttributeUsage

ms-help://MS.NETFrameworkSDKv1.1/cpref/html/frlrfsystemattributeusageattributeclasstopic.htm

og her står der at

Specifies the usage of another attribute class

Så når f.eks. at STAThreadAttribute-klassen ser sådan her ud

[AttributeUsage(AttributeTargets.Method)]
public sealed class STAThreadAttribute : Attribute

betyder det at den attribute kun må bruges på en Metode. Compileren vil altså få en instans af AttributeUsageAttribute'n, og kan ved hjælp af den aflæse hvordan at STAThreadAttributen må bruges.
Og dybere nede får selve .Net CLR'en at vide at programmet skal starte i Single-threaded Apartment da der er brugt en STAThread-property på Main()-metoden.

osv. osv.

jeg har nogle eksempler jeg kan vise hvor man i sin egen kode også kan aflæse værdierne af de evt forskellige attributer der måtte findes, hvis du er interreseret.

cyberprofessor det ville jeg meget gerne se hvis det var muligt.

:) whe.. en måned, bedre sent end aldrig *pudser glorien*

nå, lad os se... eksemplet består af tre dele. Først laver vi vores attribut-klasse, som samtidig indeholder mulighed for at aflæse attributerne og dernæst skal den bruges. (Eksemplet er fra bogen C# af Bo Brink (rædsom bog)).

[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = true)]
    public class Forfatter : System.Attribute
    {
        public string Navn;
        public string Aar;

        public Forfatter(string navn, string aar)
        {
            this.Navn = navn;
            this.Aar = aar;
        }

        public static void PrintAttributes(Type t)
        {
            Console.WriteLine("Attribute \n\n");

            object[] arr = t.GetCustomAttributes(false);

            foreach (Attribute att in arr)
            {
                if (att is Forfatter)
                {
                    Forfatter fAtt = (Forfatter)att;

                    Console.WriteLine("Klasse: {0}, Forfatter: {1}, År: {2}\n", t.Name, fAtt.Navn, fAtt.Aar);
                }
            }

            MethodInfo[] miArr = t.GetMethods();

            for (int i = 0; i < miArr.GetLength(0); i++)
            {
                MethodInfo mi = miArr[i];
                arr = mi.GetCustomAttributes(true);

                foreach (Attribute att in arr)
                {
                    if (att is Forfatter)
                    {
                        Forfatter fAtt = (Forfatter)att;

                        Console.WriteLine("Metode: {0}, Forfatter: {1}, År: {2}\n", t.Name, fAtt.Navn, fAtt.Aar);
                    }
                }
            }
        }
    }

og så tester vi:

[Forfatter("Pauli", "2005")]
    public class TestClass
    {
        [Forfatter("Pauli", "1998")]
        public void EnTest() {}

        [Forfatter("En anden", "2004")]
        public void EnAndenTest() {}
    }

static void Main(string[] args)
        {
            Forfatter.PrintAttributes(typeof(TestClass));

            Console.ReadLine();
        }

Output:

Klasse: TestClass, Forfatter: Pauli, År: 2005

Metode: TestClass, Forfatter: Pauli, År: 1998

Metode: TestClass, Forfatter: En anden, År: 2004