In alcuni IDE, programmi di sviluppo o SDK, ci è capitato di notare l'utilizzo di Attributi personalizzati.

Un esempio è:

[Range=10]
public int MiddlePoint {get; set;}

Che può definire a runtime alcuni parametri da rispettare prima dell'esecuzione dello stesso.

Ci basta semplicemente sfruttare il Reflection ed ottenere l'informazione del tipo accedendo agli attributi.

Bisogna in anzitutto avere due classi.

Una che funge come Attributo personalizzato un'altra che conterrà i valori degli attributi.

un esempio è quello di creare una classe Persona, che avrà come input massimo un Nome lungo un massimo di 5 caratteri.

 [AttributeUsage(AttributeTargets.Property)]
    public class Check : Attribute
    {
        //Lunghezza massima consentita
        public int MaxLenght { get; set; }
    }

Il target dell'attributo personalizzato di questa classe è indirizzo direttamente sulla proprietà.

Ora che abbiamo la classe che funge come contenitore di Attributi per il campo di verifica, andiamo a dichiarare una classe ad esempio: Persona.

 public class Persona
    {
        [Check(MaxLenght=5)]
        public string Nome { get; set; }

    }

Alla classe persona, abbiamo costruito una proprietà di tipo String con il nostro attributo personalizzato che indica chiaramente che il limite massimo di caratteri sarà di 5.

Ora non ci resta che verifica se i dati sono inseriti correttamente da parte dell'utente.

Ad esempio sfruttiamo il void del Load del form o semplicemente la pressione di un Button.

void Form_Load()
{
     Persona pers = new Persona();
     pers.Nome = "Pierotofy";


}

Ovviamente non succederà nulla, perché non abbiamo ancora realizzato il nostro ciclo di verifica. Andiamo a creare un void esempio chiamato Verifica.

   public void Verifica(Persona p)
        {
            //Dichiaro un tipo ed ottengo le informazioni dall'argomento Persona p
            Type Tipo = p.GetType();

            //Eseguo un ciclo sul Tipo recuperato tutte le sue proprietà
            foreach (PropertyInfo prop in Tipo.GetProperties())
            {
                //Creo una variabile Attribute att  ed ottengo tutti gli Attributi Custom presenti
                //nel tipo recuperato da Persona p.
                foreach (Attribute att in prop.GetCustomAttributes(false))
                {
                    //Controllo se l'attrubito recuperato "ciclicamente" in att è uguale 
                    //al tipo di Attributo Check
                    if (att.GetType() == typeof(Check))
                    {
                        //Forzo la variabile att a diventare attributo Check
                        Check c = (Check)att;
                        
                        //Verifico che la lunghezza non sia maggiore di quella
                        //Impostata nell'attrubito
                        if (p.Nome.Length > c.MaxLenght)
                        {
                            //Se la lunghezza supera quella impostata dall'attributo
                            throw new Exception("Lunghezza superiore a quella di default");
                        }
                    }
                   
                }
            }
        }

Realizzato il nostro void di verifica, al Load del form o del click di un pulsante, O qualsiasi altra iniziativa abbiamo in mente  da dove far partire la verifica del codice, ci basta aggiungere al load esempio:

public void Form_Load()
{
 Persona pers= new Persona();
            pers.Nome = "Pierotofy";
            

            Verifica(pers);

}

In questo esempio, avremo subito l'errore perché la frase pierotofy è più lunga di 5 caratteri. In caso contrario non avremo errori.

Questo strumento può tornarci utile qual'ora stiamo realizzando un motore, o una serie di API. La verifica possiamo farla partire in diversi modi, sta a noi dicedere come. Ad esempio in un Componente. Appena il suo Handle viene creato, scatta la verifica. o tanti altri modi ancora.