// MethodImplOptions.cs
//
// This code was automatically generated from
// ECMA CLI XML Library Specification.
// Generator: libgen.xsl
// Source file: AllTypes.xml
// URL: http://msdn.microsoft.com/net/ecma/AllTypes.xml
//
// (C) 2001 Ximian, Inc. http://www.ximian.com
namespace System.Runtime.CompilerServices {
///
/// Defines the details of how a method is implemented.
///
///
/// This enumeration is used by .
///
///
public enum MethodImplOptions {
/// Specifies that the method is implemented in unmanaged code.
Unmanaged = 4,
/// Specifies that the method is declared, but its implementation is
/// provided elsewhere. For most languages, it is recommended
/// that the notion of "forward" be attached to methods using language syntax
/// instead of custom attributes.
ForwardRef = 16,
/// Specifies an internal call.An internal call
/// is a call to a method implemented within the system itself, providing
/// additional functionality that regular managed code cannot provide.
/// is an example of an internally called method.
InternalCall = 4096,
/// Specifies the method can be executed by only one thread at a time.This option specifies that before a thread can execute the target method, the
/// thread is required to acquire a lock on either the current
/// instance or the
/// object for the method's class. If the target method is an instance method, the
/// lock is on the current instance. If the target is a static method, the lock is
/// on the object. Specifying this option causes the target method to behave as though its
/// statements are enclosed by and
/// statements locking the previous described object. This option and the methods are functionally equivalent, and both
/// are functionally equivalent to enclosing the target method's code in a C# lock
/// (this)
/// statement. Because this option holds the lock for
/// the duration of the target method, it should be used only when the entire method
/// must be single threaded. Use the methods (or the C#
/// lock statement) if the object lock can be taken after the method begins, or
/// released before the method ends. Any mechanism that uses locks can cause an
/// application to experience deadlocks and performance degradation; for these
/// reasons, use this option with care. For most languages, it is recommended that the notion of
/// "synchronized" be attached to methods using language syntax instead of custom
/// attributes.
Synchronized = 32,
/// Specifies that the method is not permitted to be inlined.
NoInlining = 8,
} // MethodImplOptions
} // System.Runtime.CompilerServices