RuntimeInfrastructure mscorlib [00 00 00 00 00 00 00 00 04 00 00 00 00 00 00 00 ] 1.0.5000.0 2.0.0.0 4.0.0.0 All public static members of this type are safe for multithreaded operations. No instance members are guaranteed to be thread safe. System.Object

The types in are intended primarily for use by compilers, not application programmers. They allow compilers to easily implement certain language features that are not directly visible to programmers.

Provides a set of static methods and properties that provide support for compilers. This class cannot be inherited.

- Method
  4.0.0.0
  System.Runtime.ConstrainedExecution.ReliabilityContract(System.Runtime.ConstrainedExecution.Consistency.WillNotCorruptState, System.Runtime.ConstrainedExecution.Cer.Success)
  System.Void

  provides information about an artificially limited stack that preserves enough space for an exception to be raised and recovery action to be taken. The artificial stack limit is chosen by the common language runtime to ensure that enough space remains to throw an exception safely.

  This method is useful in situations where stack overflow might occur as a result of unbounded recursion. It is intended for use in compiler services scenarios, although it can also be used safely in other development scenarios.

  If the stack space is sufficient, the exception is not thrown, and most .NET Framework types and members can still be called.

  This method is not part of the constrained execution region (CER) support, and should not be confused with the method.

  Ensures that the remaining stack space is large enough to execute the average .NET Framework function.

- Method
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Boolean `` ``

  This method is used by compilers.

  Determines whether the specified instances are considered equal.

  true if the parameter is the same instance as the parameter, or if both are null, or if o1.Equals(o2) returns true; otherwise, false.

  The first object to compare. The second object to compare.
- Method
  2.0.0.0
  4.0.0.0
  System.Void `` `` `` To be added. To be added. To be added. To be added. To be added.
- Method
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Int32 ``

  The method always calls the method non-virtually, even if the object's type has overridden the method. Therefore, using might differ from calling GetHashCode directly on the object with the method.

  Although the method returns identical hash codes for identical object references, you should not use this method to test for object identity, because this hash code does not uniquely identify an object reference. To test for object identify (that is, to test that two objects reference the same object in memory), call the method. Nor should you use to test whether two strings represent equal object references, because the string is interned. To test for string interning, call the method.

  The and methods differ as follows:

  returns a hash code that is based on the object's definition of equality. For example, two strings with identical contents will return the same value for .

  returns a hash code that indicates object identity. That is, two string variables whose contents are identical and that represent a string that is interned (see the String Interning section) or that represent a single string in memory return identical hash codes.

  Note that always returns identical hash codes for equal object references. However, the reverse is not true: equal hash codes do not indicate equal object references. A particular hash code value is not unique to a particular object reference; different object references can generate identical hash codes.

  This method is used by compilers.

  ## String Interning

  The common language runtime (CLR) maintains an internal pool of strings and stores literals in the pool. If two strings (for example, str1 and str2) are formed from an identical string literal, the CLR will set str1 and str2 to point to the same location on the managed heap to conserve memory. Calling on these two string objects will produce the same hash code, contrary to the second bulleted item in the previous section.

  The CLR adds only literals to the pool. Results of string operations such as concatenation are not added to the pool, unless the compiler resolves the string concatenation as a single string literal. Therefore, if str2 was created as the result of a concatenation operation, and str2 is identical to str1, using on these two string objects will not produce the same hash code.

  If you want to add a concatenated string to the pool explicitly, use the method.

  You can also use the method to check whether a string has an interned reference.

  Serves as a hash function for a particular object, and is suitable for use in algorithms and data structures that use hash codes, such as a hash table.

  A hash code for the object identified by the parameter.

  An object to retrieve the hash code for.
- Method
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Object ``

  Boxing a value type creates an object and performs a shallow copy of the fields of the specified value type into the new object.

  This method allows a value class to be manipulated as an object while it retains the aliasing behavior of a value class.

  The return value depends on whether the value class is mutable or immutable:

  If the value being assigned is a mutable value class, the method returns a shallow copy of the class, because value classes have copy semantics.

  If the value being assigned is an immutable value class, the method returns the object itself, instead of a copy of the class.

  Compilers of dynamically typed languages can use this method to make sure that boxed value types work identically to unboxed value types. That is, boxed value types get cloned when you pass them around, and they are always passed by value. The compiler can call to assign a value type to an object or to pass a value type as a parameter of a type object.

  This method is used by compilers.

  Boxes a value type.

  A boxed copy of if it is a value class; otherwise, itself.

  The value type to be boxed.
- Method
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Void `` ``

  This method is used by compilers.

  Provides a fast way to initialize an array from data that is stored in a module.

  The array to be initialized. A field handle that specifies the location of the data used to initialize the array. 0
- Property
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Int32 12

  A containing the number of bytes between the start of a and the first in the string.

  Compilers use this property for unsafe, but efficient, pointer operations on the characters in a managed string. Compilers should pin the string against movement by the garbage collector before use. Note that common language runtime strings are immutable; that is, their contents can be read but not changed.

  Gets the offset, in bytes, to the data in the given string.

  0
- Method
  2.0.0.0
  4.0.0.0
  System.Runtime.ConstrainedExecution.ReliabilityContract(System.Runtime.ConstrainedExecution.Consistency.WillNotCorruptState, System.Runtime.ConstrainedExecution.Cer.MayFail)
  System.Void

  Compilers use this method to mark catch, finally, and fault blocks as constrained execution regions (CERs). Code that is marked as a constrained region must only call other code with strong reliability contracts. It should not allocate or make virtual calls to unprepared or unreliable methods unless it is prepared to handle failures.

  Note that no intermediate language opcodes, except NOP, are allowed between a call to the method and the try block. For more information about CERs, see the classes in the namespace.

  CERs that are marked using the method do not work perfectly when a is generated from the try block. For more information, see the method.

  The method calls the method.

  Designates a body of code as a constrained execution region (CER).

- Method
  2.0.0.0
  4.0.0.0
  System.Runtime.ConstrainedExecution.ReliabilityContract(System.Runtime.ConstrainedExecution.Consistency.WillNotCorruptState, System.Runtime.ConstrainedExecution.Cer.MayFail)
  System.Void

  Compilers should not call this method directly. Instead, define a CER by calling the method.

  Designates a body of code as a constrained execution region (CER) without performing any probing.

- Method
  2.0.0.0
  4.0.0.0
  System.Void ``

  Compilers use this method to prepare a delegate's invocation method and to prepare the target of that invocation (and the delegate's statically determinable call graph) as a constrained execution region (CER).

  Indicates that the specified delegate should be prepared for inclusion in a constrained execution region (CER).

  The delegate type to prepare.
- Method
  2.0.0.0
  4.0.0.0
  System.Void ``

  Compilers use the method to handle virtual calls that are made inside a constrained execution region (CER). At JIT compilation time, the common language runtime does not usually have enough information about the target of a virtual call. Therefore, the runtime does not initially prepare that segment of the call graph. If the code that is using the CER has enough knowledge to determine the target at any point in time before the CER is actually entered, it can call to perform the same runtime preparation normally done for a CER rooted at the method specified as an argument.

  Prepares a method for inclusion in a constrained execution region (CER).

  A handle to the method to prepare.
- Method
  2.0.0.0
  4.0.0.0
  System.Void `` ``

  You can provide generics support for compilers by using the method. The common language runtime cannot prepare constrained execution regions (CERs) rooted in a method that has generic type parameters (either a type parameter on the class containing the method or one on the method itself) when those type parameters are instantiated as reference types.

  You can use this overload to pass a specific instantiation (such as an array of types), specifying class type parameters first (if any), followed by method type parameters (if any). The runtime prepares that instantiation of the method. (This is necessary only if the instantiations you use contain at least one reference type parameter.) Thus, you can use a CER-style try clause in a generic method (or a nongeneric method on a generic class) and it will work reliably with instantiations of or other value types. To instantiate reference types such as , you must use an explicit method on the CER root method first.

  Prepares a method for inclusion in a constrained execution region (CER) with the specified instantiation.

  A handle to the method to prepare. The instantiation to pass to the method.
- Method
  2.0.0.0
  4.0.0.0
  System.Runtime.ConstrainedExecution.ReliabilityContract(System.Runtime.ConstrainedExecution.Consistency.WillNotCorruptState, System.Runtime.ConstrainedExecution.Cer.MayFail)
  System.Void

  This method is used by the constrained execution region (CER) infrastructure when running in hosts that are resilient to stack overflow such as Microsoft SQL Server and Microsoft Exchange Server. This method currently probes for 48 KB of stack space on the x86 platform, but the exact amount may change over time and may vary on other platforms.

  This method is also used by compilers.

  Instead of using the method, you should use a standard CER. That is, if you are planning to use a moderate amount of stack space, call the method immediately before your try/finally or try/catch block. If you are calling a recursive method or plan to use a lot of stack space, you must use the method.

  Probes for a certain amount of stack space to ensure that a stack overflow cannot happen within a subsequent block of code (assuming that your code uses only a finite and moderate amount of stack space). We recommend that you use a constrained execution region (CER) instead of this method.

- Method
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Void ``

  This method is used by compilers.

  Runs a specified class constructor method.

  A type handle that specifies the class constructor method to run. 0
- Method
  2.0.0.0
  System.Void `` To be added. To be added. To be added.
- Method
  2.0.0.0
  4.0.0.0
  System.Void ``

  This method is used by compilers.

  Runs a specified module constructor method.

  A handle that specifies the module constructor method to run.
0