ConditionalAttribute Classe

Définition

Indique aux compilateurs qu'un appel ou un attribut de méthode doit être ignoré, sauf si un symbole de compilation conditionnelle spécifié est défini.

public ref class ConditionalAttribute sealed : Attribute
[System.AttributeUsage(System.AttributeTargets.Class | System.AttributeTargets.Method, AllowMultiple=true)]
public sealed class ConditionalAttribute : Attribute
[System.AttributeUsage(System.AttributeTargets.Method, AllowMultiple=true)]
[System.Serializable]
public sealed class ConditionalAttribute : Attribute
[System.AttributeUsage(System.AttributeTargets.Class | System.AttributeTargets.Method, AllowMultiple=true)]
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class ConditionalAttribute : Attribute
[<System.AttributeUsage(System.AttributeTargets.Class | System.AttributeTargets.Method, AllowMultiple=true)>]
type ConditionalAttribute = class
    inherit Attribute
[<System.AttributeUsage(System.AttributeTargets.Method, AllowMultiple=true)>]
[<System.Serializable>]
type ConditionalAttribute = class
    inherit Attribute
[<System.AttributeUsage(System.AttributeTargets.Class | System.AttributeTargets.Method, AllowMultiple=true)>]
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type ConditionalAttribute = class
    inherit Attribute
Public NotInheritable Class ConditionalAttribute
Inherits Attribute
Héritage
ConditionalAttribute
Attributs

Exemples

L'exemple suivant montre l'utilisation de ConditionalAttribute. L’exemple suppose que la condition est définie avec l’option du compilateur /define . Vous pouvez obtenir des résultats différents en modifiant l’option du compilateur. Vous pouvez éventuellement définir les conditions en utilisant des pragmas dans l’exemple de code au lieu de les identifier comme options du compilateur.

#define CONDITION1
#define CONDITION2
using System;
using System.Diagnostics;

class Test
{
    static void Main()
    {
        Console.WriteLine("Calling Method1");
        Method1(3);
        Console.WriteLine("Calling Method2");
        Method2();

        Console.WriteLine("Using the Debug class");
        Debug.Listeners.Add(new ConsoleTraceListener());
        Debug.WriteLine("DEBUG is defined");
    }

    [Conditional("CONDITION1")]
    public static void Method1(int x)
    {
        Console.WriteLine("CONDITION1 is defined");
    }

    [Conditional("CONDITION1"), Conditional("CONDITION2")]
    public static void Method2()
    {
        Console.WriteLine("CONDITION1 or CONDITION2 is defined");
    }
}

/*
When compiled as shown, the application (named ConsoleApp)
produces the following output.

Calling Method1
CONDITION1 is defined
Calling Method2
CONDITION1 or CONDITION2 is defined
Using the Debug class
DEBUG is defined
*/
#Const CONDITION1 = True
#Const CONDITION2 = True
Imports System.Diagnostics

Class Test

    Shared Sub Main()
        Console.WriteLine("Calling Method1")
        Method1(3)
        Console.WriteLine("Calling Method2")
        Method2()
        
        Console.WriteLine("Using the Debug class")
        Debug.Listeners.Add(New ConsoleTraceListener())
        Debug.WriteLine("DEBUG is defined")
    End Sub
       
    <ConditionalAttribute("CONDITION1")> _
    Shared Sub Method1(x As Integer)
        Console.WriteLine("CONDITION1 is defined")
    End Sub
    
    <ConditionalAttribute("CONDITION1"), ConditionalAttribute("CONDITION2")> _
    Shared Sub Method2()
        Console.WriteLine("CONDITION1 or CONDITIOIN2 is defined")
    End Sub
    
End Class


' When compiled as shown, the application (named ConsoleApp) 
' produces the following output.

'Calling Method1
'CONDITION1 is defined
'Calling Method2
'CONDITION1 or CONDITION2 is defined
'Using the Debug class
'DEBUG is defined

Remarques

Vous pouvez appliquer l' ConditionalAttribute attribut aux méthodes et aux classes. Toutefois, son utilisation sur les classes n’est valide que pour les types dérivés de Attribute . ConditionalAttribute l’une ou l’autre sera ignorée ou produira un message d’avertissement ou d’erreur du compilateur si vous l’appliquez à un autre type.

ConditionalAttributeL’application à une méthode indique aux compilateurs qu’un appel à la méthode ne doit pas être compilé en MSIL (Microsoft Intermediate Language) à moins que le symbole de compilation conditionnelle associé à ConditionalAttribute ne soit défini. vous obtiendrez une erreur de compilation dans Visual Studio si vous appliquez cet attribut à une méthode qui ne retourne pas void. ConditionalAttributeL’application à un attribut indique que l’attribut ne doit pas être émis vers les métadonnées, sauf si le symbole de compilation conditionnelle est défini. Les arguments passés à la méthode ou à l’attribut sont toujours de type vérifié par le compilateur.

Vous pouvez utiliser les techniques suivantes pour définir des symboles de compilation conditionnelle :

  • Utilisez les options de ligne de commande du compilateur. par exemple, /define : Debug.

  • Utilisez des variables d’environnement dans l’interpréteur de commandes du système d’exploitation. par exemple, Définissez debug = 1.

  • Utilisez des pragmas dans le code source ; par exemple, définissez la variable de compilation comme suit :

    #define DEBUG  
    
    #Const DEBUG=True  
    

    Pour annuler la définition de la variable, utilisez la commande suivante :

    #undef DEBUG  
    
    #Const DEBUG=False  
    

Les compilateurs conformes à la Common Language Specification (CLS) sont autorisés à ignorer ConditionalAttribute . les compilateurs C#, F #, Visual Basic et C++ prennent en charge ConditionalAttribute ; le compilateur JScript ne prend pas en charge l’attribut.

Notes

dans Visual Basic, l' AddressOf opérateur n’est pas affecté par cet attribut. Par exemple, Call CType(AddressOf delegate, Action) appelle toujours delegate , même si ce Call delegate() n’est pas le cas.

ConditionalAttribute est appliqué aux méthodes définies dans les Debug Trace classes et.

Pour plus d’informations sur l’utilisation des attributs, consultez attributs.

Constructeurs

ConditionalAttribute(String)

Initialise une nouvelle instance de la classe ConditionalAttribute.

Propriétés

ConditionString

Obtient le symbole de compilation conditionnelle associé à l'attribut ConditionalAttribute.

TypeId

Lors de l'implémentation dans une classe dérivée, obtient un identificateur unique pour l'objet Attribute.

(Hérité de Attribute)

Méthodes

Equals(Object)

Retourne une valeur qui indique si cette instance est égale à un objet spécifié.

(Hérité de Attribute)
GetHashCode()

Retourne le code de hachage de cette instance.

(Hérité de Attribute)
GetType()

Obtient le Type de l'instance actuelle.

(Hérité de Object)
IsDefaultAttribute()

En cas de substitution dans une classe dérivée, indique si la valeur de cette instance est la valeur par défaut pour la classe dérivée.

(Hérité de Attribute)
Match(Object)

En cas de substitution dans une classe dérivée, retourne une valeur indiquant si cette instance équivaut à un objet spécifié.

(Hérité de Attribute)
MemberwiseClone()

Crée une copie superficielle du Object actuel.

(Hérité de Object)
ToString()

Retourne une chaîne qui représente l'objet actuel.

(Hérité de Object)

Implémentations d’interfaces explicites

_Attribute.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Mappe un jeu de noms avec un jeu correspondant d'identificateurs de dispatch.

(Hérité de Attribute)
_Attribute.GetTypeInfo(UInt32, UInt32, IntPtr)

Récupère les informations de type pour un objet, qui peuvent être utilisées pour obtenir les informations de type d'une interface.

(Hérité de Attribute)
_Attribute.GetTypeInfoCount(UInt32)

Récupère le nombre d'interfaces d'informations de type fourni par un objet (0 ou 1).

(Hérité de Attribute)
_Attribute.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Fournit l'accès aux propriétés et aux méthodes exposées par un objet.

(Hérité de Attribute)

S’applique à