ConditionalAttribute Třída

Definice

Určuje kompilátory, které by volání metody nebo atributu měly být ignorovány, pokud není definován zadaný symbol podmíněné kompilace.Indicates to compilers that a method call or attribute should be ignored unless a specified conditional compilation symbol is defined.

public ref class ConditionalAttribute sealed : Attribute
[System.AttributeUsage(System.AttributeTargets.Class | System.AttributeTargets.Method, AllowMultiple=true)]
public sealed class ConditionalAttribute : Attribute
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
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
Dědičnost
ConditionalAttribute
Atributy

Příklady

Následující příklad ukazuje použití ConditionalAttribute .The following example demonstrates the use of ConditionalAttribute. V příkladu se předpokládá, že podmínka je definovaná pomocí možnosti kompilátoru /define .The example assumes that the condition is defined with the /define compiler option. Můžete získat různé výsledky změnou možnosti kompilátoru.You can obtain different results by changing the compiler option. Volitelně můžete definovat podmínky pomocí direktiv pragma v ukázkovém kódu a nemusíte je identifikovat jako možnosti kompilátoru.You can optionally define the conditions by using pragmas in the sample code instead of identifying them as compiler options.

#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

Poznámky

Můžete použít ConditionalAttribute atribut na metody a třídy.You can apply the ConditionalAttribute attribute to methods and classes. Použití třídy na třídy je však platné pouze pro typy, které jsou odvozeny z Attribute .However, its use on classes is valid only for types that are derived from Attribute. ConditionalAttribute buď se bude ignorovat, nebo vytvoří upozornění kompilátoru nebo chybovou zprávu, pokud ji použijete na jiný typ.ConditionalAttribute either will be ignored or will produce a compiler warning or error message if you apply it to any other type.

Použití ConditionalAttribute na metodu označuje kompilátory, které by volání metody nemělo být zkompilováno do jazyka MSIL (Microsoft Intermediate Language), pokud není definován symbol podmíněné kompilace, který je spojen s ConditionalAttribute .Applying ConditionalAttribute to a method indicates to compilers that a call to the method should not be compiled into Microsoft intermediate language (MSIL) unless the conditional compilation symbol that is associated with ConditionalAttribute is defined. V aplikaci Visual Studio se zobrazí chyba kompilace, pokud použijete tento atribut na metodu, která nevrací typ void.You will get a compilation error in Visual Studio if you apply this attribute to a method that does not return void. Použití ConditionalAttribute u atributu znamená, že atribut by neměl být generován do metadat, pokud není definován symbol podmíněné kompilace.Applying ConditionalAttribute to an attribute indicates that the attribute should not be emitted to metadata unless the conditional compilation symbol is defined. Všechny argumenty předané metodě nebo atributu jsou stále typu zkontrolovány kompilátorem.Any arguments passed to the method or attribute are still type-checked by the compiler.

Pomocí následujících postupů můžete definovat symboly podmíněné kompilace:You can use the following techniques to define conditional compilation symbols:

  • Použití možností příkazového řádku kompilátoru; například /define: Debug.Use compiler command-line options; for example, /define:DEBUG.

  • Použijte proměnné prostředí v prostředí operačního systému. například nastavte Debug = 1.Use environment variables in the operating system shell; for example, set DEBUG=1.

  • Použít direktivy pragma ve zdrojovém kódu; například definujte proměnnou kompilace následujícím způsobem:Use pragmas in the source code; for example, define the compilation variable as follows:

    #define DEBUG  
    
    #Const DEBUG=True  
    

    Chcete-li zrušit definici proměnné, použijte následující:To undefine the variable, use the following:

    #undef DEBUG  
    
    #Const DEBUG=False  
    

Kompilátory, které vyhovují specifikaci CLS (Common Language Specification), mají povoleno ignorovat ConditionalAttribute .Compilers that comply with the Common Language Specification (CLS) are permitted to ignore ConditionalAttribute. Kompilátory jazyka C#, F #, Visual Basic a C++ podporují ConditionalAttribute ; kompilátor JScript nepodporuje tento atribut.The C#, F#, Visual Basic, and C++ compilers support ConditionalAttribute; the JScript compiler does not support the attribute.

Poznámka

V Visual Basic AddressOf nemá operátor vliv na tento atribut.In Visual Basic, the AddressOf operator is not affected by this attribute. Například Call CType(AddressOf delegate, Action) vždy vyvolá delegate , i když nemusí Call delegate() .For example, Call CType(AddressOf delegate, Action) always invokes delegate, although Call delegate() might not.

ConditionalAttribute je aplikován na metody, které jsou definovány v Debug Trace třídách a.ConditionalAttribute is applied to the methods that are defined in the Debug and Trace classes.

Další informace o použití atributů naleznete v tématu Attributes.For more information about how to use attributes, see Attributes.

Konstruktory

ConditionalAttribute(String)

Inicializuje novou instanci ConditionalAttribute třídy.Initializes a new instance of the ConditionalAttribute class.

Vlastnosti

ConditionString

Získá symbol podmíněné kompilace, který je přidružen k ConditionalAttribute atributu.Gets the conditional compilation symbol that is associated with the ConditionalAttribute attribute.

TypeId

Při implementaci v odvozené třídě získá jedinečný identifikátor Attribute .When implemented in a derived class, gets a unique identifier for this Attribute.

(Zděděno od Attribute)

Metody

Equals(Object)

Vrací hodnotu, která určuje, zda je tato instance rovna zadanému objektu.Returns a value that indicates whether this instance is equal to a specified object.

(Zděděno od Attribute)
GetHashCode()

Vrátí hodnotu hash pro tuto instanci.Returns the hash code for this instance.

(Zděděno od Attribute)
GetType()

Získá Type aktuální instanci.Gets the Type of the current instance.

(Zděděno od Object)
IsDefaultAttribute()

Při přepsání v odvozené třídě označuje, zda je hodnota této instance výchozí hodnotou pro odvozenou třídu.When overridden in a derived class, indicates whether the value of this instance is the default value for the derived class.

(Zděděno od Attribute)
Match(Object)

Při přepsání v odvozené třídě vrátí hodnotu, která označuje, zda je tato instance rovna zadanému objektu.When overridden in a derived class, returns a value that indicates whether this instance equals a specified object.

(Zděděno od Attribute)
MemberwiseClone()

Vytvoří kopii aktuálního seznamu Object .Creates a shallow copy of the current Object.

(Zděděno od Object)
ToString()

Vrátí řetězec, který představuje aktuální objekt.Returns a string that represents the current object.

(Zděděno od Object)

Explicitní implementace rozhraní

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

Mapuje sadu názvů na odpovídající sadu identifikátorů pro rozesílání.Maps a set of names to a corresponding set of dispatch identifiers.

(Zděděno od Attribute)
_Attribute.GetTypeInfo(UInt32, UInt32, IntPtr)

Načte informace o typu pro objekt, který lze použít k získání informací o typu pro rozhraní.Retrieves the type information for an object, which can be used to get the type information for an interface.

(Zděděno od Attribute)
_Attribute.GetTypeInfoCount(UInt32)

Získá počet rozhraní typu informací, které objekt poskytuje (0 nebo 1).Retrieves the number of type information interfaces that an object provides (either 0 or 1).

(Zděděno od Attribute)
_Attribute.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Poskytuje přístup k vlastnostem a metodám vystaveným objektem.Provides access to properties and methods exposed by an object.

(Zděděno od Attribute)

Platí pro