* @security(checkClassLinking=on)
*/
//This class contains only static members and does not need to be serializable.
- [ComVisible(true)]
internal static class Registry {
static Registry()
{
* @security(checkDllCalls=off)
* @security(checkClassLinking=on)
*/
- [ComVisible(true)]
internal sealed class RegistryKey : MarshalByRefObject, IDisposable
{
return InternalGetValue(name, defaultValue, false, true);
}
- [ComVisible(false)]
public Object GetValue(String name, Object defaultValue, RegistryValueOptions options) {
if( options < RegistryValueOptions.None || options > RegistryValueOptions.DoNotExpandEnvironmentNames) {
throw new ArgumentException(Environment.GetResourceString("Arg_EnumIllegalVal", (int)options), nameof(options));
SetValue(name, value, RegistryValueKind.Unknown);
}
- [ComVisible(false)]
public unsafe void SetValue(String name, Object value, RegistryValueKind valueKind) {
if (value==null)
ThrowHelper.ThrowArgumentNullException(ExceptionArgument.value);
namespace Microsoft.Win32 {
-[System.Runtime.InteropServices.ComVisible(true)]
internal enum RegistryValueKind {
String = Win32Native.REG_SZ,
ExpandString = Win32Native.REG_EXPAND_SZ,
MultiString = Win32Native.REG_MULTI_SZ,
QWord = Win32Native.REG_QWORD,
Unknown = 0, // REG_NONE is defined as zero but BCL
- [System.Runtime.InteropServices.ComVisible(false)]
None = unchecked((int)0xFFFFFFFF), // mistakingly overrode this value.
} // Now instead of using Win32Native.REG_NONE we use "-1" and play games internally.
}
using System.Diagnostics.Contracts;
using System.Runtime.ExceptionServices;
- [ComVisible(true)]
public class ResolveEventArgs : EventArgs
{
private String _Name;
}
}
- [ComVisible(true)]
public class AssemblyLoadEventArgs : EventArgs
{
private Assembly _LoadedAssembly;
}
[Serializable]
- [ComVisible(true)]
public delegate Assembly ResolveEventHandler(Object sender, ResolveEventArgs args);
[Serializable]
- [ComVisible(true)]
public delegate void AssemblyLoadEventHandler(Object sender, AssemblyLoadEventArgs args);
[Serializable]
- [ComVisible(true)]
internal delegate void AppDomainInitializer(string[] args);
internal class AppDomainInitializerInfo
namespace System {
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
internal enum LoaderOptimization
{
NotSpecified = 0,
using System.Security;
using System.Runtime.InteropServices;
- [System.Runtime.InteropServices.ComVisible(true)]
internal class AppDomainManager : MarshalByRefObject
{
public AppDomainManager () {}
[Serializable]
[ClassInterface(ClassInterfaceType.None)]
- [System.Runtime.InteropServices.ComVisible(true)]
internal sealed class AppDomainSetup
{
[Serializable]
using System.Runtime.Serialization;
- [System.Runtime.InteropServices.ComVisible(true)]
[Serializable]
internal class AppDomainUnloadedException : SystemException {
public AppDomainUnloadedException()
// The ArgumentOutOfRangeException is thrown when an argument
// is outside the legal range for that argument.
- [System.Runtime.InteropServices.ComVisible(true)]
[Serializable]
public class ArgumentOutOfRangeException : ArgumentException, ISerializable {
// Note that we make a T[] (single-dimensional w/ zero as the lower bound) implement both
// IList<U> and IReadOnlyList<U>, where T : U dynamically. See the SZArrayHelper class for details.
[Serializable]
- [ComVisible(true)]
public abstract class Array : ICloneable, IList, IStructuralComparable, IStructuralEquatable
{
// This ctor exists solely to prevent C# from generating a protected .ctor that violates the surface area. I really want this to be a
return TypedReference.InternalToObject(&elemref);
}
- [ComVisible(false)]
public Object GetValue(long index)
{
if (index > Int32.MaxValue || index < Int32.MinValue)
return this.GetValue((int) index);
}
- [ComVisible(false)]
public Object GetValue(long index1, long index2)
{
if (index1 > Int32.MaxValue || index1 < Int32.MinValue)
return this.GetValue((int) index1, (int) index2);
}
- [ComVisible(false)]
public Object GetValue(long index1, long index2, long index3)
{
if (index1 > Int32.MaxValue || index1 < Int32.MinValue)
return this.GetValue((int) index1, (int) index2, (int) index3);
}
- [ComVisible(false)]
public Object GetValue(params long[] indices)
{
if (indices == null)
InternalSetValue(&elemref,value);
}
- [ComVisible(false)]
public void SetValue(Object value, long index)
{
if (index > Int32.MaxValue || index < Int32.MinValue)
this.SetValue(value, (int) index);
}
- [ComVisible(false)]
public void SetValue(Object value, long index1, long index2)
{
if (index1 > Int32.MaxValue || index1 < Int32.MinValue)
this.SetValue(value, (int) index1, (int) index2);
}
- [ComVisible(false)]
public void SetValue(Object value, long index1, long index2, long index3)
{
if (index1 > Int32.MaxValue || index1 < Int32.MinValue)
this.SetValue(value, (int) index1, (int) index2, (int) index3);
}
- [ComVisible(false)]
public void SetValue(Object value, params long[] indices)
{
if (indices == null)
internal const int MaxArrayLength = 0X7FEFFFFF;
internal const int MaxByteArrayLength = 0x7FFFFFC7;
- [ComVisible(false)]
public extern long LongLength {
[Pure]
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
public extern int GetLength(int dimension);
[Pure]
- [ComVisible(false)]
public long GetLongLength(int dimension) {
//This method should throw an IndexOufOfRangeException for compat if dimension < 0 or >= Rank
return GetLength(dimension);
}
[Pure]
- [ComVisible(false)]
public void CopyTo(Array array, long index)
{
if (index > Int32.MaxValue || index < Int32.MinValue)
/* By default, attributes are inherited and multiple attributes are not allowed */
[Serializable]
[AttributeUsage(AttributeTargets.Class, Inherited = true)]
-[System.Runtime.InteropServices.ComVisible(true)]
public sealed class AttributeUsageAttribute : Attribute
{
internal AttributeTargets m_attributeTarget = AttributeTargets.All; // Defaults to all
using SecurityException = System.Security.SecurityException;
using System.Globalization;
- [System.Runtime.InteropServices.ComVisible(true)]
[Serializable]
public class BadImageFormatException : SystemException {
// The Boolean class provides the
// object representation of the boolean primitive type.
[Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
public struct Boolean : IComparable, IConvertible, IComparable<Boolean>, IEquatable<Boolean>
{
using nuint = System.UInt32;
#endif // BIT64
-[System.Runtime.InteropServices.ComVisible(true)]
public static class Buffer
{
// Copies from one primitive array to another primitive array without
// The Byte class extends the Value class and
// provides object representation of the byte primitive type.
//
-[System.Runtime.InteropServices.ComVisible(true)]
[Serializable]
[System.Runtime.InteropServices.StructLayout(LayoutKind.Sequential)]
public struct Byte : IComparable, IFormattable, IConvertible
using System.Diagnostics;
using System.Diagnostics.Contracts;
-[System.Runtime.InteropServices.ComVisible(true)]
[Serializable]
[System.Runtime.InteropServices.StructLayout(LayoutKind.Sequential)] public struct Char : IComparable, IConvertible
, IComparable<Char>, IEquatable<Char>
[DebuggerTypeProxy(typeof(System.Collections.ArrayList.ArrayListDebugView))]
[DebuggerDisplay("Count = {Count}")]
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
internal class ArrayList : IList, ICloneable
{
private Object[] _items;
// Useful base class for typed read/write collections where items derive from object
[Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
public abstract class CollectionBase : IList {
private ArrayList list;
using System.Diagnostics.Contracts;
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
internal sealed class Comparer : IComparer , ISerializable
{
private CompareInfo m_compareInfo;
/// All public and protected members of <see cref="ConcurrentDictionary{TKey,TValue}"/> are thread-safe and may be used
/// concurrently from multiple threads.
/// </remarks>
- [ComVisible(false)]
[DebuggerTypeProxy(typeof(Mscorlib_DictionaryDebugView<,>))]
[DebuggerDisplay("Count = {Count}")]
public class ConcurrentDictionary<TKey, TValue> : IDictionary<TKey, TValue>, IDictionary, IReadOnlyDictionary<TKey, TValue>
using System.ComponentModel;
// A DictionaryEntry holds a key and a value from a dictionary.
// It is returned by IDictionaryEnumerator::GetEntry().
-[System.Runtime.InteropServices.ComVisible(true)]
[Serializable]
public struct DictionaryEntry
{
[DebuggerTypeProxy(typeof(Mscorlib_DictionaryDebugView<,>))]
[DebuggerDisplay("Count = {Count}")]
[Serializable]
- [System.Runtime.InteropServices.ComVisible(false)]
public class Dictionary<TKey,TValue>: IDictionary<TKey,TValue>, IDictionary, IReadOnlyDictionary<TKey, TValue>, ISerializable, IDeserializationCallback {
private struct Entry {
using System.Runtime.Serialization;
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public class KeyNotFoundException : SystemException, ISerializable {
public KeyNotFoundException ()
//
[DebuggerTypeProxy(typeof(System.Collections.Hashtable.HashtableDebugView))]
[DebuggerDisplay("Count = {Count}")]
- [System.Runtime.InteropServices.ComVisible(true)]
[Serializable]
internal class Hashtable : IDictionary, ISerializable, IDeserializationCallback, ICloneable {
/*
// Base interface for all collections, defining enumerators, size, and
// synchronization methods.
- [System.Runtime.InteropServices.ComVisible(true)]
public interface ICollection : IEnumerable
{
// Interfaces are not serialable
// the Array and List classes.
//
// Interfaces are not serializable
- [System.Runtime.InteropServices.ComVisible(true)]
public interface IComparer {
// Compares two objects. An implementation of this method must return a
// value less than zero if x is less than y, zero if x is equal to y, or a
// Keys can be any non-null object. Values can be any object.
// You can look up a value in an IDictionary via the default indexed
// property, Items.
- [System.Runtime.InteropServices.ComVisible(true)]
public interface IDictionary : ICollection
{
// Interfaces are not serializable
// return the same DictionaryEntry and avoids boxing the DictionaryEntry (boxing
// is somewhat expensive).
//
-[System.Runtime.InteropServices.ComVisible(true)]
public interface IDictionaryEnumerator : IEnumerator
{
// Returns the key of the current element of the enumeration. The returned
// Implement this interface if you need to support VB's foreach semantics.
// Also, COM classes that support an enumerator will also implement this interface.
[Guid("496B0ABE-CDEE-11d3-88E8-00902754C43A")]
- [System.Runtime.InteropServices.ComVisible(true)]
public interface IEnumerable
{
// Interfaces are not serializable
// Base interface for all enumerators, providing a simple approach
// to iterating over a collection.
[Guid("496B0ABF-CDEE-11d3-88E8-00902754C43A")]
- [System.Runtime.InteropServices.ComVisible(true)]
public interface IEnumerator
{
// Interfaces are not serializable
using System;
// An IEqualityComparer is a mechanism to consume custom performant comparison infrastructure
// that can be consumed by some of the common collections.
- [System.Runtime.InteropServices.ComVisible(true)]
public interface IEqualityComparer {
bool Equals(Object x, Object y);
int GetHashCode(Object obj);
// Provides a mechanism for a hash table user to override the default
// GetHashCode() function on Objects, providing their own hash function.
[Obsolete("Please use IEqualityComparer instead.")]
- [System.Runtime.InteropServices.ComVisible(true)]
internal interface IHashCodeProvider
{
// Interfaces are not serializable
// An IList is an ordered collection of objects. The exact ordering
// is up to the implementation of the list, ranging from a sorted
// order to insertion order.
- [System.Runtime.InteropServices.ComVisible(true)]
public interface IList : ICollection
{
// The Item property provides methods to read and edit entries in the List.
using System.Runtime;
[Serializable]
- [System.Runtime.InteropServices.ComVisible(false)]
[DebuggerTypeProxy(typeof(Mscorlib_CollectionDebugView<>))]
[DebuggerDisplay("Count = {Count}")]
public class Collection<T>: IList<T>, IList, IReadOnlyList<T>
using System.Diagnostics.Contracts;
[Serializable]
- [System.Runtime.InteropServices.ComVisible(false)]
[DebuggerTypeProxy(typeof(Mscorlib_KeyedCollectionDebugView<,>))]
[DebuggerDisplay("Count = {Count}")]
public abstract class KeyedCollection<TKey,TItem>: Collection<TItem>
using System.Runtime;
[Serializable]
- [System.Runtime.InteropServices.ComVisible(false)]
[DebuggerTypeProxy(typeof(Mscorlib_CollectionDebugView<>))]
[DebuggerDisplay("Count = {Count}")]
public class ReadOnlyCollection<T>: IList<T>, IList, IReadOnlyList<T>
using System;
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public enum AssemblyHashAlgorithm
{
None = 0,
MD5 = 0x8003,
SHA1 = 0x8004,
- [ComVisible(false)]
SHA256 = 0x800c,
- [ComVisible(false)]
SHA384 = 0x800d,
- [ComVisible(false)]
SHA512 = 0x800e,
}
}
using System;
[Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
public enum AssemblyVersionCompatibility
{
SameMachine = 1,
return ToBase64String(inArray, 0, inArray.Length, Base64FormattingOptions.None);
}
- [System.Runtime.InteropServices.ComVisible(false)]
public static String ToBase64String(byte[] inArray, Base64FormattingOptions options) {
if (inArray==null) {
throw new ArgumentNullException(nameof(inArray));
return ToBase64String(inArray, offset, length, Base64FormattingOptions.None);
}
- [System.Runtime.InteropServices.ComVisible(false)]
public static unsafe String ToBase64String(byte[] inArray, int offset, int length, Base64FormattingOptions options) {
//Do data verfication
if (inArray==null)
return ToBase64CharArray(inArray, offsetIn, length, outArray, offsetOut, Base64FormattingOptions.None);
}
- [System.Runtime.InteropServices.ComVisible(false)]
public static unsafe int ToBase64CharArray(byte[] inArray, int offsetIn, int length, char[] outArray, int offsetOut, Base64FormattingOptions options) {
//Do data verfication
if (inArray==null)
using System.Runtime.Remoting;
using System.Runtime.Serialization;
using System.Security.Permissions;
- [System.Runtime.InteropServices.ComVisible(true)]
[Serializable]
public sealed class DBNull : ISerializable, IConvertible {
// the range of the Decimal type.
[StructLayout(LayoutKind.Sequential)]
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
[System.Runtime.Versioning.NonVersionable] // This only applies to field layout
public struct Decimal : IFormattable, IComparable, IConvertible, IComparable<Decimal>, IEquatable<Decimal>, IDeserializationCallback
{
[Serializable]
[ClassInterface(ClassInterfaceType.AutoDual)]
- [System.Runtime.InteropServices.ComVisible(true)]
public abstract class Delegate : ICloneable, ISerializable
{
// _target is the object we will invoke on
return a.CombineImpl(b);
}
- [System.Runtime.InteropServices.ComVisible(true)]
public static Delegate Combine(params Delegate[] delegates)
{
if (delegates == null || delegates.Length == 0)
namespace System.Diagnostics {
[Serializable]
[AttributeUsage(AttributeTargets.Method | AttributeTargets.Class, AllowMultiple=true)]
- [System.Runtime.InteropServices.ComVisible(true)]
public sealed class ConditionalAttribute : Attribute
{
public ConditionalAttribute(String conditionString)
using System.Runtime.Versioning;
// No data, does not need to be marked with the serializable attribute
- [System.Runtime.InteropServices.ComVisible(true)]
public sealed class Debugger
{
// This should have been a static class, but wasn't as of v3.5. Clearly, this is
// notification will apprise the debugger that it will need to slip a thread or abort the funceval
// in such a situation. The notification is subject to collection after this function returns.
//
- [method:System.Runtime.InteropServices.ComVisible(false)]
public static void NotifyOfCrossThreadDependency()
{
if (Debugger.IsAttached)
[Serializable]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Constructor, Inherited = false)]
- [ComVisible(true)]
public sealed class DebuggerStepThroughAttribute : Attribute
{
public DebuggerStepThroughAttribute () {}
[Serializable]
[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Constructor, Inherited = false)]
- [ComVisible(true)]
public sealed class DebuggerHiddenAttribute : Attribute
{
public DebuggerHiddenAttribute () {}
[Serializable]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Constructor |AttributeTargets.Struct, Inherited = false)]
- [ComVisible(true)]
public sealed class DebuggerNonUserCodeAttribute : Attribute
{
public DebuggerNonUserCodeAttribute () {}
// won't preserve the debugging info, which will make debugging after
// a JIT attach difficult.
[AttributeUsage(AttributeTargets.Assembly|AttributeTargets.Module, AllowMultiple = false)]
- [ComVisible(true)]
public sealed class DebuggableAttribute : Attribute
{
[Flags]
- [ComVisible(true)]
public enum DebuggingModes
{
None = 0x0,
// Please also change the code which validates DebuggerBrowsableState variable (in this file)
// if you change this enum.
- [ComVisible(true)]
public enum DebuggerBrowsableState
{
Never = 0,
// the one currently supported with the csee.dat
// (mcee.dat, autoexp.dat) file.
[AttributeUsage(AttributeTargets.Field | AttributeTargets.Property, AllowMultiple = false)]
- [ComVisible(true)]
public sealed class DebuggerBrowsableAttribute: Attribute
{
private DebuggerBrowsableState state;
// DebuggerTypeProxyAttribute
[AttributeUsage(AttributeTargets.Struct | AttributeTargets.Class | AttributeTargets.Assembly, AllowMultiple = true)]
- [ComVisible(true)]
public sealed class DebuggerTypeProxyAttribute: Attribute
{
private string typeName;
// however: there is no access to aliases, locals, or pointers.
// In addition, attributes on properties referenced in the expression are not processed.
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Delegate | AttributeTargets.Enum | AttributeTargets.Field | AttributeTargets.Property | AttributeTargets.Assembly, AllowMultiple = true)]
- [ComVisible(true)]
public sealed class DebuggerDisplayAttribute : Attribute
{
private string name;
// There is no good reason for the methods of this class to be virtual.
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public class StackFrame
{
private MethodBase method;
// StackTrace, we use an InheritanceDemand to prevent partially-trusted
// subclasses.
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public class StackTrace
{
private StackFrame[] frames;
// The nth element of this array is the same as GetFrame(n).
// The length of the array is the same as FrameCount.
//
- [ComVisible(false)]
public virtual StackFrame [] GetFrames()
{
if (frames == null || m_iNumOfFrames <= 0)
using System;
// Interface does not need to be marked with the serializable attribute
- [System.Runtime.InteropServices.ComVisible(true)]
public interface ISymbolDocumentWriter
{
// SetSource will store the raw source for a document into the
using System.Runtime.Versioning;
// Interface does not need to be marked with the serializable attribute
-[System.Runtime.InteropServices.ComVisible(true)]
internal interface ISymbolWriter
{
using System;
[Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
internal enum SymAddressKind
{
// ILOffset: addr1 = IL local var or param index.
using System;
using System.Runtime.InteropServices;
- [ComVisible(true)]
internal struct SymbolToken
{
internal int m_token;
using System;
using System.Runtime.Serialization;
- [System.Runtime.InteropServices.ComVisible(true)]
[Serializable]
public class DllNotFoundException : TypeLoadException {
public DllNotFoundException()
[Serializable]
[StructLayout(LayoutKind.Sequential)]
-[System.Runtime.InteropServices.ComVisible(true)]
public struct Double : IComparable, IFormattable, IConvertible
, IComparable<Double>, IEquatable<Double>
{
namespace System
{
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public abstract class Enum : ValueType, IComparable, IFormattable, IConvertible
{
#region Private Constants
return retValue;
}
- [System.Runtime.InteropServices.ComVisible(true)]
public static Object Parse(Type enumType, String value)
{
return Parse(enumType, value, false);
}
- [System.Runtime.InteropServices.ComVisible(true)]
public static Object Parse(Type enumType, String value, bool ignoreCase)
{
EnumResult parseResult = new EnumResult() { canThrow = true };
}
}
- [System.Runtime.InteropServices.ComVisible(true)]
public static Type GetUnderlyingType(Type enumType)
{
if (enumType == null)
return enumType.GetEnumUnderlyingType();
}
- [System.Runtime.InteropServices.ComVisible(true)]
public static Array GetValues(Type enumType)
{
if (enumType == null)
return GetCachedValuesAndNames(enumType, false).Values;
}
- [System.Runtime.InteropServices.ComVisible(true)]
public static String GetName(Type enumType, Object value)
{
if (enumType == null)
return enumType.GetEnumName(value);
}
- [System.Runtime.InteropServices.ComVisible(true)]
public static String[] GetNames(Type enumType)
{
if (enumType == null)
return GetCachedValuesAndNames(enumType, true).Names;
}
- [System.Runtime.InteropServices.ComVisible(true)]
public static Object ToObject(Type enumType, Object value)
{
if (value == null)
}
[Pure]
- [System.Runtime.InteropServices.ComVisible(true)]
public static bool IsDefined(Type enumType, Object value)
{
if (enumType == null)
return enumType.IsEnumDefined(value);
}
- [System.Runtime.InteropServices.ComVisible(true)]
public static String Format(Type enumType, Object value, String format)
{
if (enumType == null)
#region ToObject
[CLSCompliant(false)]
- [System.Runtime.InteropServices.ComVisible(true)]
public static Object ToObject(Type enumType, sbyte value)
{
if (enumType == null)
return InternalBoxEnum(rtType, value);
}
- [System.Runtime.InteropServices.ComVisible(true)]
public static Object ToObject(Type enumType, short value)
{
if (enumType == null)
return InternalBoxEnum(rtType, value);
}
- [System.Runtime.InteropServices.ComVisible(true)]
public static Object ToObject(Type enumType, int value)
{
if (enumType == null)
return InternalBoxEnum(rtType, value);
}
- [System.Runtime.InteropServices.ComVisible(true)]
public static Object ToObject(Type enumType, byte value)
{
if (enumType == null)
}
[CLSCompliant(false)]
- [System.Runtime.InteropServices.ComVisible(true)]
public static Object ToObject(Type enumType, ushort value)
{
if (enumType == null)
}
[CLSCompliant(false)]
- [System.Runtime.InteropServices.ComVisible(true)]
public static Object ToObject(Type enumType, uint value)
{
if (enumType == null)
return InternalBoxEnum(rtType, value);
}
- [System.Runtime.InteropServices.ComVisible(true)]
public static Object ToObject(Type enumType, long value)
{
if (enumType == null)
}
[CLSCompliant(false)]
- [System.Runtime.InteropServices.ComVisible(true)]
public static Object ToObject(Type enumType, ulong value)
{
if (enumType == null)
using System.Runtime.Versioning;
using System.Diagnostics.Contracts;
- [ComVisible(true)]
public enum EnvironmentVariableTarget
{
Process = 0,
Machine = 2,
}
- [ComVisible(true)]
public static partial class Environment
{
// Assume the following constants include the terminating '\0' - use <, not <=
[ClassInterface(ClassInterfaceType.None)]
[ComDefaultInterface(typeof(_Exception))]
[Serializable]
- [ComVisible(true)]
public class Exception : ISerializable, _Exception
{
private void Init()
// since most of the calendars (or all?) have the same way of calcuating hour/minute/second.
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public abstract class Calendar : ICloneable
{
// The minimum supported DateTime range for the calendar.
- [System.Runtime.InteropServices.ComVisible(false)]
public virtual DateTime MinSupportedDateTime
{
get
// The maximum supported DateTime range for the calendar.
- [System.Runtime.InteropServices.ComVisible(false)]
public virtual DateTime MaxSupportedDateTime
{
get
// Returns the type of the calendar.
//
- [System.Runtime.InteropServices.ComVisible(false)]
public virtual CalendarAlgorithmType AlgorithmType
{
get
// Detect if the object is readonly.
//
////////////////////////////////////////////////////////////////////////
- [System.Runtime.InteropServices.ComVisible(false)]
public bool IsReadOnly
{
get { return (m_isReadOnly); }
// Is the implementation of ICloneable.
//
////////////////////////////////////////////////////////////////////////
- [System.Runtime.InteropServices.ComVisible(false)]
public virtual Object Clone()
{
object o = MemberwiseClone();
// readonly.
//
////////////////////////////////////////////////////////////////////////
- [System.Runtime.InteropServices.ComVisible(false)]
public static Calendar ReadOnly(Calendar calendar)
{
if (calendar == null) { throw new ArgumentNullException(nameof(calendar)); }
// if this calendar does not have leap month, or this year is not a leap year.
//
- [System.Runtime.InteropServices.ComVisible(false)]
public virtual int GetLeapMonth(int year)
{
return (GetLeapMonth(year, CurrentEra));
// if this calendar does not have leap month, or this year is not a leap year.
//
- [System.Runtime.InteropServices.ComVisible(false)]
public virtual int GetLeapMonth(int year, int era)
{
if (!IsLeapYear(year, era))
namespace System.Globalization {
using System;
-[System.Runtime.InteropServices.ComVisible(true)]
public enum CalendarAlgorithmType {
Unknown = 0, // This is the default value to return in the Calendar base class.
SolarCalendar = 1, // Solar-base calendar, such as GregorianCalendar, jaoaneseCalendar, JulianCalendar, etc.
[Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
public enum CalendarWeekRule
{
internal static DateTime minDate = new DateTime(MIN_GREGORIAN_YEAR, MIN_GREGORIAN_MONTH, MIN_GREGORIAN_DAY);
internal static DateTime maxDate = new DateTime((new DateTime(MAX_GREGORIAN_YEAR, MAX_GREGORIAN_MONTH, MAX_GREGORIAN_DAY, 23, 59, 59, 999)).Ticks + 9999);
- [System.Runtime.InteropServices.ComVisible(false)]
public override DateTime MinSupportedDateTime {
get
{
}
- [System.Runtime.InteropServices.ComVisible(false)]
public override DateTime MaxSupportedDateTime {
get
{
}
- [System.Runtime.InteropServices.ComVisible(false)]
public override int GetEra(DateTime time) {
CheckTicksRange(time.Ticks);
return (ChineseEra);
}
- [System.Runtime.InteropServices.ComVisible(false)]
public override int[] Eras {
get {
return (new int[] {ChineseEra});
[Serializable]
[Flags]
- [System.Runtime.InteropServices.ComVisible(true)]
public enum CompareOptions
{
None = 0x00000000,
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public partial class CompareInfo : IDeserializationCallback
{
// Mask used to check if IndexOf()/LastIndexOf()/IsPrefix()/IsPostfix() has the right flags.
return CultureInfo.GetCultureInfo(name).CompareInfo;
}
- [System.Runtime.InteropServices.ComVisible(false)]
public static bool IsSortable(char ch) {
return(IsSortable(ch.ToString()));
}
- [System.Runtime.InteropServices.ComVisible(false)]
public static bool IsSortable(String text) {
if (text == null) {
// A null param is invalid here.
//
////////////////////////////////////////////////////////////////////////
- [System.Runtime.InteropServices.ComVisible(false)]
public virtual String Name
{
get
using System.Resources;
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public partial class CultureInfo : ICloneable, IFormatProvider {
//--------------------------------------------------------------------//
// Internal Information //
//
////////////////////////////////////////////////////////////////////////
#if FEATURE_USE_LCID
- [System.Runtime.InteropServices.ComVisible(false)]
public virtual int KeyboardLayoutId
{
get
}
}
- [System.Runtime.InteropServices.ComVisible(false)]
public String IetfLanguageTag
{
get
}
}
- [System.Runtime.InteropServices.ComVisible(false)]
public CultureTypes CultureTypes
{
get
}
}
- [System.Runtime.InteropServices.ComVisible(false)]
public CultureInfo GetConsoleFallbackUICulture()
{
Contract.Ensures(Contract.Result<CultureInfo>() != null);
using System.Threading;
using System.Diagnostics.Contracts;
- [System.Runtime.InteropServices.ComVisible(true)]
[Serializable]
public partial class CultureNotFoundException : ArgumentException, ISerializable
{
[Serializable]
[Flags]
- [System.Runtime.InteropServices.ComVisible(true)]
public enum CultureTypes
{
NeutralCultures = 0x0001, // Neutral cultures are cultures like "en", "de", "zh", etc, for enumeration this includes ALL neutrals regardless of other flags
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public sealed class DateTimeFormatInfo : ICloneable, IFormatProvider
{
//
// Returns the string array of the one-letter day of week names.
- [System.Runtime.InteropServices.ComVisible(false)]
public String[] ShortestDayNames
{
get
// Returns the super short day of week names for the specified day of week.
- [System.Runtime.InteropServices.ComVisible(false)]
public String GetShortestDayName(DayOfWeek dayOfWeek)
{
// String nativeName = dtfi.NativeCalendarName; // Get the Japanese name for the Japanese calendar.
// DateTimeFormatInfo dtfi = new CultureInfo("ja-JP", false).DateTimeFormat.Calendar = new GregorianCalendar(GregorianCalendarTypes.Localized);
// String nativeName = dtfi.NativeCalendarName; // Get the Japanese name for the Gregorian calendar.
- [System.Runtime.InteropServices.ComVisible(false)]
public String NativeCalendarName
{
get
// WARNING: If more validation is ever done in one place, it should be done in the other.
//
- [System.Runtime.InteropServices.ComVisible(false)]
public void SetAllDateTimePatterns(String[] patterns, char format)
{
if (IsReadOnly)
return;
}
- [System.Runtime.InteropServices.ComVisible(false)]
public String[] AbbreviatedMonthGenitiveNames
{
get
}
}
- [System.Runtime.InteropServices.ComVisible(false)]
public String[] MonthGenitiveNames
{
get
[Serializable]
[Flags]
-[System.Runtime.InteropServices.ComVisible(true)]
public enum DateTimeStyles {
// Bit flag indicating that leading whitespace is allowed. Character values
// 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, and 0x0020 are considered to be
{
// This class represents a starting/ending time for a period of daylight saving time.
[Serializable]
- [ComVisible(true)]
public class DaylightTime
{
internal DateTime m_start;
[Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
public enum DigitShapes : int {
Context = 0x0000, // The shape depends on the previous text in the same output.
[Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
public abstract class EastAsianLunisolarCalendar : Calendar {
internal const int LeapMonth = 0;
internal const int Jan1Month = 1;
// 0 CurrentEra (AD)
// 1 BeforeCurrentEra (BC)
- [System.Runtime.InteropServices.ComVisible(true)]
[Serializable]
public class GregorianCalendar : Calendar
{
}
#endregion Serialization
- [System.Runtime.InteropServices.ComVisible(false)]
public override DateTime MinSupportedDateTime
{
get
}
}
- [System.Runtime.InteropServices.ComVisible(false)]
public override DateTime MaxSupportedDateTime
{
get
// Return the type of the Gregorian calendar.
//
- [System.Runtime.InteropServices.ComVisible(false)]
public override CalendarAlgorithmType AlgorithmType
{
get
// if this calendar does not have leap month, or this year is not a leap year.
//
- [System.Runtime.InteropServices.ComVisible(false)]
public override int GetLeapMonth(int year, int era)
{
if (era != CurrentEra && era != ADEra)
using System;
[Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
public enum GregorianCalendarTypes {
Localized = Calendar.CAL_GREGORIAN,
USEnglish = Calendar.CAL_GREGORIAN_US,
[Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
public class HebrewCalendar : Calendar {
*/
[Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
public class HijriCalendar : Calendar {
internal static readonly DateTime calendarMaxValue = DateTime.MaxValue;
- [System.Runtime.InteropServices.ComVisible(false)]
public override DateTime MinSupportedDateTime
{
get
}
- [System.Runtime.InteropServices.ComVisible(false)]
public override DateTime MaxSupportedDateTime
{
get
// Return the type of the Hijri calendar.
//
- [System.Runtime.InteropServices.ComVisible(false)]
public override CalendarAlgorithmType AlgorithmType
{
get
// if this calendar does not have leap month, or this year is not a leap year.
//
- [System.Runtime.InteropServices.ComVisible(false)]
public override int GetLeapMonth(int year, int era)
{
CheckYearRange(year, era);
[Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
public class JapaneseCalendar : Calendar
{
internal static readonly DateTime calendarMinValue = new DateTime(1868, 9, 8);
- [System.Runtime.InteropServices.ComVisible(false)]
public override DateTime MinSupportedDateTime
{
get
}
}
- [System.Runtime.InteropServices.ComVisible(false)]
public override DateTime MaxSupportedDateTime
{
get
// Return the type of the Japanese calendar.
//
- [System.Runtime.InteropServices.ComVisible(false)]
public override CalendarAlgorithmType AlgorithmType
{
get
[SuppressMessage("Microsoft.Contracts", "CC1055")] // Skip extra error checking to avoid *potential* AppCompat problems.
- [System.Runtime.InteropServices.ComVisible(false)]
public override int GetWeekOfYear(DateTime time, CalendarWeekRule rule, DayOfWeek firstDayOfWeek)
{
return (helper.GetWeekOfYear(time, rule, firstDayOfWeek));
// if this calendar does not have leap month, or this year is not a leap year.
//
- [System.Runtime.InteropServices.ComVisible(false)]
public override int GetLeapMonth(int year, int era)
{
return (helper.GetLeapMonth(year, era));
//* Julia 0001/01/03 9999/10/19
[Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
public class JulianCalendar : Calendar {
internal int MaxYear = 9999;
- [System.Runtime.InteropServices.ComVisible(false)]
public override DateTime MinSupportedDateTime
{
get
}
}
- [System.Runtime.InteropServices.ComVisible(false)]
public override DateTime MaxSupportedDateTime
{
get
// Return the type of the Julian calendar.
//
- [System.Runtime.InteropServices.ComVisible(false)]
public override CalendarAlgorithmType AlgorithmType
{
get
// if this calendar does not have leap month, or this year is not a leap year.
//
- [System.Runtime.InteropServices.ComVisible(false)]
public override int GetLeapMonth(int year, int era)
{
CheckYearEraRange(year, era);
============================================================================*/
-[System.Runtime.InteropServices.ComVisible(true)]
[Serializable] public class KoreanCalendar: Calendar {
//
// The era value for the current era.
internal GregorianCalendarHelper helper;
- [System.Runtime.InteropServices.ComVisible(false)]
public override DateTime MinSupportedDateTime
{
get
}
}
- [System.Runtime.InteropServices.ComVisible(false)]
public override DateTime MaxSupportedDateTime
{
get
// Return the type of the Korean calendar.
//
- [System.Runtime.InteropServices.ComVisible(false)]
public override CalendarAlgorithmType AlgorithmType
{
get
[SuppressMessage("Microsoft.Contracts", "CC1055")] // Skip extra error checking to avoid *potential* AppCompat problems.
- [System.Runtime.InteropServices.ComVisible(false)]
public override int GetWeekOfYear(DateTime time, CalendarWeekRule rule, DayOfWeek firstDayOfWeek)
{
return (helper.GetWeekOfYear(time, rule, firstDayOfWeek));
// if this calendar does not have leap month, or this year is not a leap year.
//
- [System.Runtime.InteropServices.ComVisible(false)]
public override int GetLeapMonth(int year, int era)
{
return (helper.GetLeapMonth(year, era));
//
[Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
sealed public partial class NumberFormatInfo : ICloneable, IFormatProvider
{
// invariantInfo is constant irrespective of your current culture.
}
- [System.Runtime.InteropServices.ComVisible(false)]
public String[] NativeDigits
{
get { return (String[])nativeDigits.Clone(); }
}
}
- [System.Runtime.InteropServices.ComVisible(false)]
public DigitShapes DigitSubstitution
{
get { return (DigitShapes)digitSubstitution; }
using System;
[Serializable]
[Flags]
- [System.Runtime.InteropServices.ComVisible(true)]
public enum NumberStyles {
// Bit flag indicating that leading whitespace is allowed. Character values
// 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, and 0x0020 are considered to be
using System.Diagnostics.Contracts;
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public partial class RegionInfo
{
//--------------------------------------------------------------------//
// WARNING: You need a full locale name for this to make sense.
//
////////////////////////////////////////////////////////////////////////
- [System.Runtime.InteropServices.ComVisible(false)]
public virtual String NativeName
{
get
}
- [System.Runtime.InteropServices.ComVisible(false)]
public virtual int GeoId
{
get
// English name for this region's currency, ie: Swiss Franc
//
////////////////////////////////////////////////////////////////////////
- [System.Runtime.InteropServices.ComVisible(false)]
public virtual String CurrencyEnglishName
{
get
// WARNING: You need a full locale name for this to make sense.
//
////////////////////////////////////////////////////////////////////////
- [System.Runtime.InteropServices.ComVisible(false)]
public virtual String CurrencyNativeName
{
get
using System.Diagnostics;
using System.Diagnostics.Contracts;
- [System.Runtime.InteropServices.ComVisible(true)]
[Serializable]
public partial class SortKey
{
using System.Diagnostics.Contracts;
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public class StringInfo
{
}
#endregion Serialization
- [System.Runtime.InteropServices.ComVisible(false)]
public override bool Equals(Object value)
{
StringInfo that = value as StringInfo;
return (false);
}
- [System.Runtime.InteropServices.ComVisible(false)]
public override int GetHashCode()
{
return this.m_str.GetHashCode();
============================================================================*/
/* SSS_WARNINGS_ON */ /* SSS_DROP_END */
- [System.Runtime.InteropServices.ComVisible(true)]
[Serializable] public class TaiwanCalendar: Calendar {
//
// The era value for the current era.
internal static readonly DateTime calendarMinValue = new DateTime(1912, 1, 1);
- [System.Runtime.InteropServices.ComVisible(false)]
public override DateTime MinSupportedDateTime
{
get
}
}
- [System.Runtime.InteropServices.ComVisible(false)]
public override DateTime MaxSupportedDateTime
{
get
// Return the type of the Taiwan calendar.
//
- [System.Runtime.InteropServices.ComVisible(false)]
public override CalendarAlgorithmType AlgorithmType
{
get
[SuppressMessage("Microsoft.Contracts", "CC1055")] // Skip extra error checking to avoid *potential* AppCompat problems.
- [System.Runtime.InteropServices.ComVisible(false)]
public override int GetWeekOfYear(DateTime time, CalendarWeekRule rule, DayOfWeek firstDayOfWeek)
{
return (helper.GetWeekOfYear(time, rule, firstDayOfWeek));
// if this calendar does not have leap month, or this year is not a leap year.
//
- [System.Runtime.InteropServices.ComVisible(false)]
public override int GetLeapMonth(int year, int era)
{
return (helper.GetLeapMonth(year, era));
//
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public class TextElementEnumerator: IEnumerator
{
private String str;
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public partial class TextInfo : ICloneable, IDeserializationCallback
{
//--------------------------------------------------------------------//
////////////////////////////////////////////////////////////////////////
#if FEATURE_USE_LCID
- [System.Runtime.InteropServices.ComVisible(false)]
public int LCID
{
get
// The name of the culture associated with the current TextInfo.
//
////////////////////////////////////////////////////////////////////////
- [System.Runtime.InteropServices.ComVisible(false)]
public string CultureName
{
get
// Detect if the object is readonly.
//
////////////////////////////////////////////////////////////////////////
- [System.Runtime.InteropServices.ComVisible(false)]
public bool IsReadOnly
{
get { return (m_isReadOnly); }
// Is the implementation of ICloneable.
//
////////////////////////////////////////////////////////////////////////
- [System.Runtime.InteropServices.ComVisible(false)]
public virtual Object Clone()
{
object o = MemberwiseClone();
// readonly.
//
////////////////////////////////////////////////////////////////////////
- [System.Runtime.InteropServices.ComVisible(false)]
public static TextInfo ReadOnly(TextInfo textInfo)
{
if (textInfo == null) { throw new ArgumentNullException(nameof(textInfo)); }
return (m_listSeparator);
}
- [System.Runtime.InteropServices.ComVisible(false)]
set
{
if (value == null)
//
// Returns true if the dominant direction of text and UI such as the relative position of buttons and scroll bars
//
- [System.Runtime.InteropServices.ComVisible(false)]
public bool IsRightToLeft
{
get
============================================================================*/
-[System.Runtime.InteropServices.ComVisible(true)]
[Serializable] public class ThaiBuddhistCalendar: Calendar {
// Initialize our era info.
internal GregorianCalendarHelper helper;
- [System.Runtime.InteropServices.ComVisible(false)]
public override DateTime MinSupportedDateTime
{
get
}
}
- [System.Runtime.InteropServices.ComVisible(false)]
public override DateTime MaxSupportedDateTime
{
get
// Return the type of the Thai Buddhist calendar.
//
- [System.Runtime.InteropServices.ComVisible(false)]
public override CalendarAlgorithmType AlgorithmType
{
get
[SuppressMessage("Microsoft.Contracts", "CC1055")] // Skip extra error checking to avoid *potential* AppCompat problems.
- [System.Runtime.InteropServices.ComVisible(false)]
public override int GetWeekOfYear(DateTime time, CalendarWeekRule rule, DayOfWeek firstDayOfWeek)
{
return (helper.GetWeekOfYear(time, rule, firstDayOfWeek));
// if this calendar does not have leap month, or this year is not a leap year.
//
- [System.Runtime.InteropServices.ComVisible(false)]
public override int GetLeapMonth(int year, int era)
{
return (helper.GetLeapMonth(year, era));
namespace System.Globalization {
[Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
public enum UnicodeCategory {
UppercaseLetter = 0,
// Represents a Globally Unique Identifier.
[StructLayout(LayoutKind.Sequential)]
[Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
[System.Runtime.Versioning.NonVersionable] // This only applies to field layout
public struct Guid : IFormattable, IComparable
, IComparable<Guid>, IEquatable<Guid>
// method which is called to create a clone of the object. Object defines a method
// MemberwiseClone to support default clone operations.
//
- [System.Runtime.InteropServices.ComVisible(true)]
public interface ICloneable
{
// Interface does not need to be marked with the serializable attribute
using System.Diagnostics.Contracts;
using System.Security;
-[System.Runtime.InteropServices.ComVisible(true)]
public class BinaryReader : IDisposable
{
private const int MaxCharBytesSize = 128;
// give unique encodings.
//
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public class BinaryWriter : IDisposable
{
public static readonly BinaryWriter Null = new BinaryWriter();
namespace System.IO
{
- [ComVisible(true)]
internal static class Directory {
// Private class that holds search data that is passed around
* and STG_E_PATHNOTFOUND (0x80030003).
*/
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public class DirectoryNotFoundException : IOException {
public DirectoryNotFoundException()
: base(Environment.GetResourceString("Arg_DirectoryNotFoundException")) {
//Thrown when trying to access a drive that is not availabe.
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
internal class DriveNotFoundException : IOException {
public DriveNotFoundException()
: base(Environment.GetResourceString("Arg_DriveNotFoundException")) {
namespace System.IO {
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public class EndOfStreamException : IOException
{
public EndOfStreamException()
{
// Class for creating FileStream objects, and some basic file management
// routines such as Delete, etc.
- [ComVisible(true)]
internal static class File
{
private const int ERROR_INVALID_PARAMETER = 87;
//
[Serializable]
[Flags]
-[System.Runtime.InteropServices.ComVisible(true)]
public enum FileAccess
{
// Specifies read access to the file. Data can be read from the file and
namespace System.IO {
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public class FileLoadException : IOException {
private String _fileName; // the name of the file we could not load.
// exist, use Create.
//
[Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
public enum FileMode
{
// Creates a new file. An exception is raised if the file already exists.
namespace System.IO {
// Thrown when trying to access a file that doesn't exist on disk.
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public class FileNotFoundException : IOException {
private String _fileName; // The name of the file that isn't found.
// a number of them made sense in managed code, at least not yet.
[Serializable]
[Flags]
- [ComVisible(true)]
public enum FileOptions
{
// NOTE: any change to FileOptions enum needs to be
//
[Serializable]
[Flags]
-[System.Runtime.InteropServices.ComVisible(true)]
public enum FileShare
{
// No sharing. Any request to open the file (by this process or another
namespace System.IO {
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public class IOException : SystemException
{
// For debugging purposes, store the complete path in the IOException
// memory streams are resizable, while ones created with a byte array provide
// a stream "view" of the data.
[Serializable]
- [ComVisible(true)]
public class MemoryStream : Stream
{
private byte[] _buffer; // Either allocated internally or externally.
public override void Flush() {
}
- [ComVisible(false)]
public override Task FlushAsync(CancellationToken cancellationToken) {
if (cancellationToken.IsCancellationRequested)
return n;
}
- [ComVisible(false)]
public override Task<int> ReadAsync(Byte[] buffer, int offset, int count, CancellationToken cancellationToken)
{
if (buffer==null)
}
- [ComVisible(false)]
public override Task WriteAsync(Byte[] buffer, int offset, int count, CancellationToken cancellationToken)
{
if (buffer == null)
namespace System.IO {
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public class PathTooLongException : IOException
{
public PathTooLongException()
namespace System.IO {
[Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
public enum SearchOption
{
// Include only the current directory in the search operation
// Provides seek reference points. To seek to the end of a stream,
// call stream.Seek(0, SeekOrigin.End).
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public enum SeekOrigin
{
// These constants match Win32's FILE_BEGIN, FILE_CURRENT, and FILE_END
namespace System.IO {
[Serializable]
- [ComVisible(true)]
public abstract class Stream : MarshalByRefObject, IDisposable {
public static readonly Stream Null = new NullStream();
get;
}
- [ComVisible(false)]
public virtual bool CanTimeout {
[Pure]
get {
set;
}
- [ComVisible(false)]
public virtual int ReadTimeout {
get {
Contract.Ensures(Contract.Result<int>() >= 0);
}
}
- [ComVisible(false)]
public virtual int WriteTimeout {
get {
Contract.Ensures(Contract.Result<int>() >= 0);
}
}
- [ComVisible(false)]
public Task CopyToAsync(Stream destination)
{
int bufferSize = _DefaultCopyBufferSize;
return CopyToAsync(destination, bufferSize);
}
- [ComVisible(false)]
public Task CopyToAsync(Stream destination, Int32 bufferSize)
{
return CopyToAsync(destination, bufferSize, CancellationToken.None);
}
- [ComVisible(false)]
public virtual Task CopyToAsync(Stream destination, Int32 bufferSize, CancellationToken cancellationToken)
{
StreamHelpers.ValidateCopyToArgs(this, destination, bufferSize);
public abstract void Flush();
- [ComVisible(false)]
public Task FlushAsync()
{
return FlushAsync(CancellationToken.None);
}
- [ComVisible(false)]
public virtual Task FlushAsync(CancellationToken cancellationToken)
{
return Task.Factory.StartNew(state => ((Stream)state).Flush(), this,
}
}
- [ComVisible(false)]
public Task<int> ReadAsync(Byte[] buffer, int offset, int count)
{
return ReadAsync(buffer, offset, count, CancellationToken.None);
}
- [ComVisible(false)]
public virtual Task<int> ReadAsync(Byte[] buffer, int offset, int count, CancellationToken cancellationToken)
{
// If cancellation was requested, bail early with an already completed task.
bool ITaskCompletionAction.InvokeMayRunArbitraryCode { get { return true; } }
}
- [ComVisible(false)]
public Task WriteAsync(Byte[] buffer, int offset, int count)
{
return WriteAsync(buffer, offset, count, CancellationToken.None);
- [ComVisible(false)]
public virtual Task WriteAsync(Byte[] buffer, int offset, int count, CancellationToken cancellationToken)
{
// If cancellation was requested, bail early with an already completed task.
{
}
- [ComVisible(false)]
public override Task FlushAsync(CancellationToken cancellationToken)
{
return cancellationToken.IsCancellationRequested ?
return 0;
}
- [ComVisible(false)]
public override Task<int> ReadAsync(Byte[] buffer, int offset, int count, CancellationToken cancellationToken)
{
var nullReadTask = s_nullReadTask;
{
}
- [ComVisible(false)]
public override Task WriteAsync(Byte[] buffer, int offset, int count, CancellationToken cancellationToken)
{
return cancellationToken.IsCancellationRequested ?
get { return _stream.CanSeek; }
}
- [ComVisible(false)]
public override bool CanTimeout {
[Pure]
get {
}
}
- [ComVisible(false)]
public override int ReadTimeout {
get {
return _stream.ReadTimeout;
}
}
- [ComVisible(false)]
public override int WriteTimeout {
get {
return _stream.WriteTimeout;
// whereas the Stream class is designed for byte input and output.
//
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public class StreamReader : TextReader
{
// StreamReader.Null is threadsafe.
}
#region Task based Async APIs
- [ComVisible(false)]
public override Task<String> ReadLineAsync()
{
// If we have been inherited into a subclass, the following implementation could be incorrect
return GetStringAndReleaseSharedStringBuilder(sb);
}
- [ComVisible(false)]
public override Task<String> ReadToEndAsync()
{
// If we have been inherited into a subclass, the following implementation could be incorrect
return GetStringAndReleaseSharedStringBuilder(sb);
}
- [ComVisible(false)]
public override Task<int> ReadAsync(char[] buffer, int index, int count)
{
if (buffer==null)
return charsRead;
}
- [ComVisible(false)]
public override Task<int> ReadBlockAsync(char[] buffer, int index, int count)
{
if (buffer==null)
// This class is intended for character input, not bytes.
// There are methods on the Stream class for reading bytes.
[Serializable]
- [ComVisible(true)]
public abstract class TextReader : MarshalByRefObject, IDisposable {
public static readonly TextReader Null = new NullTextReader();
}
#region Task based Async APIs
- [ComVisible(false)]
public virtual Task<String> ReadLineAsync()
{
return Task<String>.Factory.StartNew(state =>
this, CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);
}
- [ComVisible(false)]
public async virtual Task<String> ReadToEndAsync()
{
char[] chars = new char[4096];
return sb.ToString();
}
- [ComVisible(false)]
public virtual Task<int> ReadAsync(char[] buffer, int index, int count)
{
if (buffer==null)
tuple, CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);
}
- [ComVisible(false)]
public virtual Task<int> ReadBlockAsync(char[] buffer, int index, int count)
{
if (buffer==null)
// On SyncTextReader all APIs should run synchronously, even the async ones.
//
- [ComVisible(false)]
[MethodImplAttribute(MethodImplOptions.Synchronized)]
public override Task<String> ReadLineAsync()
{
return Task.FromResult(ReadLine());
}
- [ComVisible(false)]
[MethodImplAttribute(MethodImplOptions.Synchronized)]
public override Task<String> ReadToEndAsync()
{
return Task.FromResult(ReadToEnd());
}
- [ComVisible(false)]
[MethodImplAttribute(MethodImplOptions.Synchronized)]
public override Task<int> ReadBlockAsync(char[] buffer, int index, int count)
{
return Task.FromResult(ReadBlock(buffer, index, count));
}
- [ComVisible(false)]
[MethodImplAttribute(MethodImplOptions.Synchronized)]
public override Task<int> ReadAsync(char[] buffer, int index, int count)
{
if (!_isOpen) __Error.StreamIsClosed();
}
- [ComVisible(false)]
public override Task FlushAsync(CancellationToken cancellationToken) {
if (cancellationToken.IsCancellationRequested)
return nInt;
}
- [ComVisible(false)]
public override Task<Int32> ReadAsync(Byte[] buffer, Int32 offset, Int32 count, CancellationToken cancellationToken) {
if (buffer==null)
throw new ArgumentNullException(nameof(buffer), Environment.GetResourceString("ArgumentNull_Buffer"));
return;
}
- [ComVisible(false)]
public override Task WriteAsync(Byte[] buffer, Int32 offset, Int32 count, CancellationToken cancellationToken) {
if (buffer==null)
using System.Runtime.InteropServices;
using System.Diagnostics.Contracts;
-[System.Runtime.InteropServices.ComVisible(true)]
[Serializable]
[System.Runtime.InteropServices.StructLayout(LayoutKind.Sequential)]
public struct Int16 : IComparable, IFormattable, IConvertible
[Serializable]
[System.Runtime.InteropServices.StructLayout(LayoutKind.Sequential)]
-[System.Runtime.InteropServices.ComVisible(true)]
public struct Int32 : IComparable, IFormattable, IConvertible
, IComparable<Int32>, IEquatable<Int32>
{
[Serializable]
[System.Runtime.InteropServices.StructLayout(LayoutKind.Sequential)]
-[System.Runtime.InteropServices.ComVisible(true)]
public struct Int64 : IComparable, IFormattable, IConvertible
, IComparable<Int64>, IEquatable<Int64>
{
using System.Diagnostics.Contracts;
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public struct IntPtr : IEquatable<IntPtr>, ISerializable
{
unsafe private void* m_value; // The compiler treats void* closest to uint hence explicit casts are required to preserve int behavior
/// </para>
/// </remarks>
[Serializable]
- [ComVisible(false)]
[DebuggerTypeProxy(typeof(System_LazyDebugView<>))]
[DebuggerDisplay("ThreadSafetyMode={Mode}, IsValueCreated={IsValueCreated}, IsValueFaulted={IsValueFaulted}, Value={ValueForDebugDisplay}")]
public class Lazy<T>
using System.Runtime.Serialization;
using System.Runtime.CompilerServices;
using System.Globalization;
- [System.Runtime.InteropServices.ComVisible(true)]
[Serializable]
public class MissingFieldException : MissingMemberException, ISerializable {
public MissingFieldException()
using System.Runtime.Versioning;
using System.Diagnostics.Contracts;
- [System.Runtime.InteropServices.ComVisible(true)]
[Serializable]
public class MissingMemberException : MemberAccessException, ISerializable {
public MissingMemberException()
using System.Runtime.Serialization;
using System.Runtime.CompilerServices;
using System.Globalization;
- [System.Runtime.InteropServices.ComVisible(true)]
[Serializable]
public class MissingMethodException : MissingMemberException, ISerializable {
public MissingMethodException()
using System.Reflection.Emit;
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public abstract class MulticastDelegate : Delegate
{
// This is set under 3 circumstances
using System.Reflection;
[AttributeUsage(AttributeTargets.Field, Inherited=false)]
- [System.Runtime.InteropServices.ComVisible(true)]
public sealed class NonSerializedAttribute : Attribute
{
internal static Attribute GetCustomAttribute(RuntimeFieldInfo field)
// bool IEquatable<Nullable<T>>.Equals(Nullable<T> other)
}
- [System.Runtime.InteropServices.ComVisible(true)]
public static class Nullable
{
- [System.Runtime.InteropServices.ComVisible(true)]
public static int Compare<T>(Nullable<T> n1, Nullable<T> n2) where T : struct
{
if (n1.HasValue) {
return 0;
}
- [System.Runtime.InteropServices.ComVisible(true)]
public static bool Equals<T>(Nullable<T> n1, Nullable<T> n2) where T : struct
{
if (n1.HasValue) {
//This class contains no data and does not need to be serializable
[Serializable]
[ClassInterface(ClassInterfaceType.AutoDual)]
-[System.Runtime.InteropServices.ComVisible(true)]
public class Object
{
// Creates a new instance of an Object.
[Serializable]
[ClassInterface(ClassInterfaceType.AutoDual)]
-[System.Runtime.InteropServices.ComVisible(true)]
internal class __Canon
{
}
using System.Diagnostics.Contracts;
- [ComVisible(true)]
[Serializable]
internal sealed class OperatingSystem : ICloneable , ISerializable
{
namespace System {
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public class OperationCanceledException : SystemException
{
[NonSerialized]
using System;
using System.Runtime.Serialization;
- [System.Runtime.InteropServices.ComVisible(true)]
[Serializable]
public class OutOfMemoryException : SystemException {
public OutOfMemoryException()
namespace System {
[Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
internal enum PlatformID
{
Win32S = 0,
using System.Globalization;
using System.Diagnostics.Contracts;
- [System.Runtime.InteropServices.ComVisible(true)]
[Serializable]
public class Random {
//
using SystemException = System.SystemException;
using System.Runtime.Serialization;
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public sealed class AmbiguousMatchException : SystemException
{
throw new NotImplementedException();
}
- [ComVisible(false)]
public virtual Module ManifestModule
{
get
}
}
- [ComVisible(false)]
public virtual Int64 HostContext
{
get
using System.Diagnostics.Contracts;
[AttributeUsage (AttributeTargets.Assembly, Inherited=false)]
-[System.Runtime.InteropServices.ComVisible(true)]
public sealed class AssemblyCopyrightAttribute : Attribute
{
private String m_copyright;
[AttributeUsage (AttributeTargets.Assembly, Inherited=false)]
-[System.Runtime.InteropServices.ComVisible(true)]
public sealed class AssemblyTrademarkAttribute : Attribute
{
private String m_trademark;
[AttributeUsage (AttributeTargets.Assembly, Inherited=false)]
-[System.Runtime.InteropServices.ComVisible(true)]
public sealed class AssemblyProductAttribute : Attribute
{
private String m_product;
[AttributeUsage (AttributeTargets.Assembly, Inherited=false)]
-[System.Runtime.InteropServices.ComVisible(true)]
public sealed class AssemblyCompanyAttribute : Attribute
{
private String m_company;
[AttributeUsage (AttributeTargets.Assembly, Inherited=false)]
-[System.Runtime.InteropServices.ComVisible(true)]
public sealed class AssemblyDescriptionAttribute : Attribute
{
private String m_description;
[AttributeUsage (AttributeTargets.Assembly, Inherited=false)]
-[System.Runtime.InteropServices.ComVisible(true)]
public sealed class AssemblyTitleAttribute : Attribute
{
private String m_title;
[AttributeUsage (AttributeTargets.Assembly, Inherited=false)]
-[System.Runtime.InteropServices.ComVisible(true)]
public sealed class AssemblyConfigurationAttribute : Attribute
{
private String m_configuration;
[AttributeUsage (AttributeTargets.Assembly, Inherited=false)]
-[System.Runtime.InteropServices.ComVisible(true)]
public sealed class AssemblyDefaultAliasAttribute : Attribute
{
private String m_defaultAlias;
[AttributeUsage (AttributeTargets.Assembly, Inherited=false)]
-[System.Runtime.InteropServices.ComVisible(true)]
public sealed class AssemblyInformationalVersionAttribute : Attribute
{
private String m_informationalVersion;
[AttributeUsage(AttributeTargets.Assembly, Inherited=false)]
-[System.Runtime.InteropServices.ComVisible(true)]
public sealed class AssemblyFileVersionAttribute : Attribute
{
private String _version;
[AttributeUsage (AttributeTargets.Assembly, Inherited=false)]
-[System.Runtime.InteropServices.ComVisible(true)]
public unsafe sealed class AssemblyCultureAttribute : Attribute
{
private String m_culture;
[AttributeUsage (AttributeTargets.Assembly, Inherited=false)]
-[System.Runtime.InteropServices.ComVisible(true)]
public unsafe sealed class AssemblyVersionAttribute : Attribute
{
private String m_version;
[AttributeUsage (AttributeTargets.Assembly, Inherited=false)]
-[System.Runtime.InteropServices.ComVisible(true)]
public sealed class AssemblyKeyFileAttribute : Attribute
{
private String m_keyFile;
[AttributeUsage (AttributeTargets.Assembly, Inherited=false)]
-[System.Runtime.InteropServices.ComVisible(true)]
public sealed class AssemblyDelaySignAttribute : Attribute
{
private bool m_delaySign;
[AttributeUsage(AttributeTargets.Assembly, Inherited=false)]
-[System.Runtime.InteropServices.ComVisible(true)]
public unsafe sealed class AssemblyAlgorithmIdAttribute : Attribute
{
private uint m_algId;
[AttributeUsage(AttributeTargets.Assembly, Inherited=false)]
-[System.Runtime.InteropServices.ComVisible(true)]
public unsafe sealed class AssemblyFlagsAttribute : Attribute
{
private AssemblyNameFlags m_flags;
}
[AttributeUsage (AttributeTargets.Assembly, Inherited=false)]
-[System.Runtime.InteropServices.ComVisible(true)]
public sealed class AssemblyKeyNameAttribute : Attribute
{
private String m_keyName;
}
}
- [System.Runtime.InteropServices.ComVisible(false)]
public AssemblyContentType ContentType
{
get
using System;
[Serializable]
[FlagsAttribute()]
- [System.Runtime.InteropServices.ComVisible(true)]
public enum AssemblyNameFlags
{
None = 0x0000,
}
[Serializable]
- [System.Runtime.InteropServices.ComVisible(false)]
public enum AssemblyContentType
{
Default = 0x0000,
}
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public enum ProcessorArchitecture
{
None = 0x0000,
[Serializable]
[ClassInterface(ClassInterfaceType.AutoDual)]
-[System.Runtime.InteropServices.ComVisible(true)]
public abstract class Binder
{
// Given a set of methods that match the basic criteria, select a method to
using System;
[Serializable]
[Flags]
- [System.Runtime.InteropServices.ComVisible(true)]
public enum BindingFlags
{
using System;
[Serializable]
[Flags]
- [System.Runtime.InteropServices.ComVisible(true)]
public enum CallingConventions
{
//NOTE: If you change this please update COMMember.cpp. These
public abstract class ConstructorInfo : MethodBase
{
#region Static Members
- [System.Runtime.InteropServices.ComVisible(true)]
public readonly static String ConstructorName = ".ctor";
- [System.Runtime.InteropServices.ComVisible(true)]
public readonly static String TypeConstructorName = ".cctor";
#endregion
#endregion
#region MemberInfo Overrides
- [System.Runtime.InteropServices.ComVisible(true)]
public override MemberTypes MemberType { get { return System.Reflection.MemberTypes.Constructor; } }
#endregion
{
get { return RuntimeMethodHandle.GetName(this); }
}
-[System.Runtime.InteropServices.ComVisible(true)]
public override MemberTypes MemberType { get { return MemberTypes.Constructor; } }
public override Type DeclaringType
namespace System.Reflection
{
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public class CustomAttributeData
{
#region Public Static Members
#region Public Members
public Type AttributeType { get { return Constructor.DeclaringType; } }
- [System.Runtime.InteropServices.ComVisible(true)]
public virtual ConstructorInfo Constructor { get { return m_ctor; } }
- [System.Runtime.InteropServices.ComVisible(true)]
public virtual IList<CustomAttributeTypedArgument> ConstructorArguments
{
get
}
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public struct CustomAttributeNamedArgument
{
#region Public Static Members
}
[Serializable]
- [ComVisible(true)]
public struct CustomAttributeTypedArgument
{
#region Public Static Members
public CustomAttributeEncoding EncodedType { get { return m_encodedType; } }
public CustomAttributeEncoding EncodedEnumType { get { return m_encodedEnumType; } }
public CustomAttributeEncoding EncodedArrayType { get { return m_encodedArrayType; } }
- [System.Runtime.InteropServices.ComVisible(true)]
public string EnumName { get { return m_enumName; } }
#endregion
}
using ApplicationException = System.ApplicationException;
using System.Runtime.Serialization;
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public class CustomAttributeFormatException : FormatException {
public CustomAttributeFormatException()
[Serializable]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Interface)]
-[System.Runtime.InteropServices.ComVisible(true)]
public sealed class DefaultMemberAttribute : Attribute
{
// The name of the member
/**********************************************
* Use this function if client decides to form the custom attribute blob themselves
**********************************************/
- [System.Runtime.InteropServices.ComVisible(true)]
public void SetCustomAttribute(ConstructorInfo con, byte[] binaryAttribute)
{
if (con == null)
namespace System.Reflection.Emit
{
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
[Flags]
public enum AssemblyBuilderAccess
{
get { return m_methodBuilder.Signature; }
}
- [System.Runtime.InteropServices.ComVisible(true)]
public void SetCustomAttribute(ConstructorInfo con, byte[] binaryAttribute)
{
m_methodBuilder.SetCustomAttribute(con, binaryAttribute);
PutInteger4(token);
}
- [System.Runtime.InteropServices.ComVisible(true)]
public override void Emit(OpCode opcode, ConstructorInfo con)
{
if (con == null)
}
- [System.Runtime.InteropServices.ComVisible(true)]
internal class DynamicILInfo
{
#region Private Data Members
using System.Diagnostics.Contracts;
using System.Runtime.InteropServices;
- [System.Runtime.InteropServices.ComVisible(true)]
public sealed class DynamicMethod : MethodInfo
{
private RuntimeType[] m_parameterTypes;
// Delegate and method creation
//
- [System.Runtime.InteropServices.ComVisible(true)]
public sealed override Delegate CreateDelegate(Type delegateType) {
if (m_restrictedSkipVisibility)
{
return d;
}
- [System.Runtime.InteropServices.ComVisible(true)]
public sealed override Delegate CreateDelegate(Type delegateType, Object target) {
if (m_restrictedSkipVisibility)
{
types, modifiers);
}
-[System.Runtime.InteropServices.ComVisible(true)]
public override ConstructorInfo[] GetConstructors(BindingFlags bindingAttr)
{
return m_typeBuilder.GetConstructors(bindingAttr);
return m_typeBuilder.GetMembers(bindingAttr);
}
-[System.Runtime.InteropServices.ComVisible(true)]
public override InterfaceMapping GetInterfaceMap(Type interfaceType)
{
return m_typeBuilder.GetInterfaceMap(interfaceType);
// Use this function if client decides to form the custom attribute blob themselves
-[System.Runtime.InteropServices.ComVisible(true)]
public void SetCustomAttribute(ConstructorInfo con, byte[] binaryAttribute)
{
m_typeBuilder.SetCustomAttribute(con, binaryAttribute);
// Use this function if client decides to form the custom attribute blob themselves
-[System.Runtime.InteropServices.ComVisible(true)]
public void SetCustomAttribute(ConstructorInfo con, byte[] binaryAttribute)
{
if (con == null)
using System.Reflection;
using System.Security.Permissions;
[Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
public struct EventToken
{
public static readonly EventToken Empty = new EventToken();
}
-[System.Runtime.InteropServices.ComVisible(true)]
public void SetCustomAttribute(ConstructorInfo con, byte[] binaryAttribute)
{
if (con == null)
// Module.GetFieldToken(). There are no meaningful accessors on this class,
// but it can be passed to ILGenerator which understands it's internals.
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public struct FieldToken
{
public static readonly FieldToken Empty = new FieldToken();
using System;
[Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
public enum FlowControl
{
using System.Globalization;
using System.Diagnostics.Contracts;
-[System.Runtime.InteropServices.ComVisible(true)]
public sealed class GenericTypeParameterBuilder: TypeInfo
{
public override bool IsAssignableFrom(System.Reflection.TypeInfo typeInfo){
protected override ConstructorInfo GetConstructorImpl(BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers) { throw new NotSupportedException(); }
-[System.Runtime.InteropServices.ComVisible(true)]
public override ConstructorInfo[] GetConstructors(BindingFlags bindingAttr) { throw new NotSupportedException(); }
protected override MethodInfo GetMethodImpl(String name, BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers) { throw new NotSupportedException(); }
public override MemberInfo[] GetMember(String name, MemberTypes type, BindingFlags bindingAttr) { throw new NotSupportedException(); }
-[System.Runtime.InteropServices.ComVisible(true)]
public override InterfaceMapping GetInterfaceMap(Type interfaceType) { throw new NotSupportedException(); }
public override EventInfo[] GetEvents(BindingFlags bindingAttr) { throw new NotSupportedException(); }
public override bool IsAssignableFrom(Type c) { throw new NotSupportedException(); }
- [System.Runtime.InteropServices.ComVisible(true)]
[Pure]
public override bool IsSubclassOf(Type c) { throw new NotSupportedException(); }
#endregion
m_type.SetParent(baseTypeConstraint);
}
- [System.Runtime.InteropServices.ComVisible(true)]
public void SetInterfaceConstraints(params Type[] interfaceConstraints)
{
m_type.CheckContext(interfaceConstraints);
PutInteger4(tempVal);
}
- [System.Runtime.InteropServices.ComVisible(true)]
public virtual void Emit(OpCode opcode, ConstructorInfo con)
{
if (con == null)
// Labels are created by using ILGenerator.CreateLabel and their position is set
// by using ILGenerator.MarkLabel.
[Serializable]
- [ComVisible(true)]
public struct Label {
internal int m_label;
}
-[System.Runtime.InteropServices.ComVisible(true)]
public void SetCustomAttribute(ConstructorInfo con, byte[] binaryAttribute)
{
if (con == null)
/// Describes exception handler in a method body.
/// </summary>
[StructLayout(LayoutKind.Sequential)]
- [ComVisible(false)]
internal struct ExceptionHandler : IEquatable<ExceptionHandler>
{
// Keep in sync with unmanged structure.
using System.Security.Permissions;
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public struct MethodToken
{
public static readonly MethodToken Empty = new MethodToken();
return typeList;
}
- [System.Runtime.InteropServices.ComVisible(true)]
public override Type GetType(String className)
{
return GetType(className, false, false);
}
- [System.Runtime.InteropServices.ComVisible(true)]
public override Type GetType(String className, bool ignoreCase)
{
return GetType(className, false, ignoreCase);
}
- [System.Runtime.InteropServices.ComVisible(true)]
public override Type GetType(String className, bool throwOnError, bool ignoreCase)
{
lock(SyncRoot)
}
}
- [System.Runtime.InteropServices.ComVisible(true)]
public TypeBuilder DefineType(String name, TypeAttributes attr, Type parent, Type[] interfaces)
{
Contract.Ensures(Contract.Result<TypeBuilder>() != null);
return new SymbolMethod(this, token, arrayClass, methodName, callingConvention, returnType, parameterTypes);
}
- [System.Runtime.InteropServices.ComVisible(true)]
public MethodToken GetConstructorToken(ConstructorInfo con)
{
// Return a token for the ConstructorInfo relative to the Module.
#region Other
- [System.Runtime.InteropServices.ComVisible(true)]
public void SetCustomAttribute(ConstructorInfo con, byte[] binaryAttribute)
{
if (con == null)
// If you add more opcodes here, modify OpCode.Name to handle them correctly
};
-[System.Runtime.InteropServices.ComVisible(true)]
public class OpCodes {
/// <summary>
(1 << OpCode.StackChangeShift)
);
- [System.Runtime.InteropServices.ComVisible(true)]
public static readonly OpCode Castclass = new OpCode(OpCodeValues.Castclass,
((int)OperandType.InlineType) |
((int)FlowControl.Next << OpCode.FlowControlShift) |
using System.Security.Permissions;
using System.Diagnostics.Contracts;
-[System.Runtime.InteropServices.ComVisible(true)]
public struct OpCode
{
//
using System;
[Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
public enum OpCodeType
{
using System;
[Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
public enum OperandType
{
using System;
// This Enum matchs the CorFieldAttr defined in CorHdr.h
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public enum PEFileKinds
{
Dll = 0x0001,
// Use this function if client decides to form the custom attribute blob themselves
- [System.Runtime.InteropServices.ComVisible(true)]
public void SetCustomAttribute(ConstructorInfo con, byte[] binaryAttribute)
{
if (con == null)
// The ParameterToken class is an opaque representation of the Token returned
// by the Metadata to represent the parameter.
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public struct ParameterToken {
public static readonly ParameterToken Empty = new ParameterToken();
// Use this function if client decides to form the custom attribute blob themselves
-[System.Runtime.InteropServices.ComVisible(true)]
public void SetCustomAttribute(ConstructorInfo con, byte[] binaryAttribute)
{
if (con == null)
using System.Security.Permissions;
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public struct PropertyToken {
public static readonly PropertyToken Empty = new PropertyToken();
using System.Reflection;
using System.Security.Permissions;
- [System.Runtime.InteropServices.ComVisible(true)]
public struct SignatureToken {
public static readonly SignatureToken Empty = new SignatureToken();
using System;
[Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
public enum StackBehaviour
{
using System.Security.Permissions;
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public struct StringToken {
internal int m_string;
throw new NotSupportedException(Environment.GetResourceString("NotSupported_NonReflectedType"));
}
-[System.Runtime.InteropServices.ComVisible(true)]
public override ConstructorInfo[] GetConstructors(BindingFlags bindingAttr)
{
throw new NotSupportedException(Environment.GetResourceString("NotSupported_NonReflectedType"));
throw new NotSupportedException(Environment.GetResourceString("NotSupported_NonReflectedType"));
}
-[System.Runtime.InteropServices.ComVisible(true)]
public override InterfaceMapping GetInterfaceMap(Type interfaceType)
{
throw new NotSupportedException(Environment.GetResourceString("NotSupported_NonReflectedType"));
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public enum PackingSize
{
Unspecified = 0,
return m_bakedRuntimeType.GetConstructor(bindingAttr, binder, callConvention, types, modifiers);
}
- [System.Runtime.InteropServices.ComVisible(true)]
public override ConstructorInfo[] GetConstructors(BindingFlags bindingAttr)
{
if (!IsCreated())
return m_bakedRuntimeType.GetMember(name, type, bindingAttr);
}
- [System.Runtime.InteropServices.ComVisible(true)]
public override InterfaceMapping GetInterfaceMap(Type interfaceType)
{
if (!IsCreated())
get { return false; }
}
- [System.Runtime.InteropServices.ComVisible(true)]
[Pure]
public override bool IsSubclassOf(Type c)
{
#endregion
#region Define Constructor
- [System.Runtime.InteropServices.ComVisible(true)]
public ConstructorBuilder DefineTypeInitializer()
{
lock(SyncRoot)
return constBuilder;
}
- [System.Runtime.InteropServices.ComVisible(true)]
public ConstructorBuilder DefineDefaultConstructor(MethodAttributes attributes)
{
if ((m_iAttr & TypeAttributes.Interface) == TypeAttributes.Interface)
return constBuilder;
}
- [System.Runtime.InteropServices.ComVisible(true)]
public ConstructorBuilder DefineConstructor(MethodAttributes attributes, CallingConventions callingConvention, Type[] parameterTypes)
{
return DefineConstructor(attributes, callingConvention, parameterTypes, null, null);
}
- [System.Runtime.InteropServices.ComVisible(true)]
public ConstructorBuilder DefineConstructor(MethodAttributes attributes, CallingConventions callingConvention,
Type[] parameterTypes, Type[][] requiredCustomModifiers, Type[][] optionalCustomModifiers)
{
}
}
- [System.Runtime.InteropServices.ComVisible(true)]
public TypeBuilder DefineNestedType(String name, TypeAttributes attr, Type parent, Type[] interfaces)
{
lock(SyncRoot)
}
}
- [System.Runtime.InteropServices.ComVisible(true)]
public void AddInterfaceImplementation(Type interfaceType)
{
if (interfaceType == null)
}
- [System.Runtime.InteropServices.ComVisible(true)]
public void SetCustomAttribute(ConstructorInfo con, byte[] binaryAttribute)
{
if (con == null)
}
protected override ConstructorInfo GetConstructorImpl(BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers) { throw new NotSupportedException(); }
- [System.Runtime.InteropServices.ComVisible(true)]
public override ConstructorInfo[] GetConstructors(BindingFlags bindingAttr) { throw new NotSupportedException(); }
protected override MethodInfo GetMethodImpl(String name, BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers) { throw new NotSupportedException(); }
public override MethodInfo[] GetMethods(BindingFlags bindingAttr) { throw new NotSupportedException(); }
public override Type GetNestedType(String name, BindingFlags bindingAttr) { throw new NotSupportedException(); }
public override MemberInfo[] GetMember(String name, MemberTypes type, BindingFlags bindingAttr) { throw new NotSupportedException(); }
- [System.Runtime.InteropServices.ComVisible(true)]
public override InterfaceMapping GetInterfaceMap(Type interfaceType) { throw new NotSupportedException(); }
public override EventInfo[] GetEvents(BindingFlags bindingAttr) { throw new NotSupportedException(); }
public override MemberInfo[] GetMembers(BindingFlags bindingAttr) { throw new NotSupportedException(); }
public override Type MakeGenericType(params Type[] inst) { throw new InvalidOperationException(Environment.GetResourceString("Arg_NotGenericTypeDefinition")); }
public override bool IsAssignableFrom(Type c) { throw new NotSupportedException(); }
- [System.Runtime.InteropServices.ComVisible(true)]
[Pure]
public override bool IsSubclassOf(Type c)
{
using System.Security.Permissions;
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public struct TypeToken {
public static readonly TypeToken Empty = new TypeToken();
using System;
[Serializable]
[Flags]
- [System.Runtime.InteropServices.ComVisible(true)]
public enum EventAttributes {
None = 0x0000,
// This Enum matchs the CorFieldAttr defined in CorHdr.h
[Serializable]
[Flags()]
- [System.Runtime.InteropServices.ComVisible(true)]
public enum FieldAttributes
{
// member access mask - Use this mask to retrieve accessibility information.
return f;
}
- [System.Runtime.InteropServices.ComVisible(false)]
public static FieldInfo GetFieldFromHandle(RuntimeFieldHandle handle, RuntimeTypeHandle declaringType)
{
if (handle.IsNullHandle())
using System;
// Interface does not need to be marked with the serializable attribute
-[System.Runtime.InteropServices.ComVisible(true)]
public interface ICustomAttributeProvider
{
// Interface does not need to be marked with the serializable attribute
[Guid("AFBF15E5-C37C-11d2-B88E-00A0C9B471B8")]
-[System.Runtime.InteropServices.ComVisible(true)]
public interface IReflect
{
// Return the requested method if it is implemented by the Reflection object. The
namespace System.Reflection {
using System;
-[System.Runtime.InteropServices.ComVisible(true)]
public struct InterfaceMapping {
-[System.Runtime.InteropServices.ComVisible(true)]
public Type TargetType; // The type implementing the interface
-[System.Runtime.InteropServices.ComVisible(true)]
public Type InterfaceType; // The type representing the interface
-[System.Runtime.InteropServices.ComVisible(true)]
public MethodInfo[] TargetMethods; // The methods implementing the interface
-[System.Runtime.InteropServices.ComVisible(true)]
public MethodInfo[] InterfaceMethods; // The methods defined on the interface
}
}
using System.Runtime.Serialization;
using ApplicationException = System.ApplicationException;
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public class InvalidFilterCriteriaException : ApplicationException {
public InvalidFilterCriteriaException()
: base(Environment.GetResourceString("Arg_InvalidFilterCriteriaException")) {
namespace System.Reflection {
using System;
-[System.Runtime.InteropServices.ComVisible(true)]
public class ManifestResourceInfo {
private Assembly _containingAssembly;
private String _containingFileName;
// Linked means not Embedded.
[Serializable]
[Flags]
-[System.Runtime.InteropServices.ComVisible(true)]
public enum ResourceLocation
{
Embedded = 0x1,
// Define the delegate
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public delegate bool MemberFilter(MemberInfo m, Object filterCriteria);
}
// This Enum matchs the CorTypeAttr defined in CorHdr.h
[Serializable]
[Flags()]
- [System.Runtime.InteropServices.ComVisible(true)]
public enum MemberTypes
{
// The following are the known classes which extend MemberInfo
using System;
[Serializable]
[Flags]
- [System.Runtime.InteropServices.ComVisible(true)]
public enum MethodAttributes
{
// NOTE: This Enum matchs the CorMethodAttr defined in CorHdr.h
return m;
}
- [System.Runtime.InteropServices.ComVisible(false)]
public static MethodBase GetMethodFromHandle(RuntimeMethodHandle handle, RuntimeTypeHandle declaringType)
{
if (handle.IsNullHandle())
public virtual CallingConventions CallingConvention { get { return CallingConventions.Standard; } }
- [System.Runtime.InteropServices.ComVisible(true)]
public virtual Type[] GetGenericArguments() { throw new NotSupportedException(Environment.GetResourceString("NotSupported_SubclassOverride")); }
public virtual bool IsGenericMethodDefinition { get { return false; } }
public bool IsSpecialName { get { return(Attributes & MethodAttributes.SpecialName) != 0; } }
- [System.Runtime.InteropServices.ComVisible(true)]
public bool IsConstructor
{
get
namespace System.Reflection
{
[Flags()]
- [System.Runtime.InteropServices.ComVisible(true)]
public enum ExceptionHandlingClauseOptions: int
{
Clause = 0x0,
Fault = 0x4,
}
- [System.Runtime.InteropServices.ComVisible(true)]
public class ExceptionHandlingClause
{
#region costructor
#endregion
}
- [System.Runtime.InteropServices.ComVisible(true)]
public class MethodBody
{
#region costructor
#endregion
}
- [System.Runtime.InteropServices.ComVisible(true)]
public class LocalVariableInfo
{
#region Private Data Members
using System;
// This Enum matchs the CorMethodImpl defined in CorHdr.h
[Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
public enum MethodImplAttributes
{
// code impl mask
Synchronized = 0x0020, // Method is single threaded through the body.
NoInlining = 0x0008, // Method may not be inlined.
- [System.Runtime.InteropServices.ComVisible(false)]
AggressiveInlining = 0x0100, // Method should be inlined if possible.
NoOptimization = 0x0040, // Method may not be optimized.
public abstract MethodInfo GetBaseDefinition();
- [System.Runtime.InteropServices.ComVisible(true)]
public override Type[] GetGenericArguments() { throw new NotSupportedException(Environment.GetResourceString("NotSupported_SubclassOverride")); }
- [System.Runtime.InteropServices.ComVisible(true)]
public virtual MethodInfo GetGenericMethodDefinition() { throw new NotSupportedException(Environment.GetResourceString("NotSupported_SubclassOverride")); }
public virtual MethodInfo MakeGenericMethod(params Type[] typeArguments) { throw new NotSupportedException(Environment.GetResourceString("NotSupported_SubclassOverride")); }
// This is not serializable because it is a reflection command.
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public sealed class Missing : ISerializable
{
public static readonly Missing Value = new Missing();
[Serializable]
[Flags]
- [System.Runtime.InteropServices.ComVisible(true)]
public enum PortableExecutableKinds
{
NotAPortableExecutableImage = 0x0,
Unmanaged32Bit = 0x8,
- [ComVisible(false)]
Preferred32Bit = 0x10,
}
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public enum ImageFileMachine
{
I386 = 0x014c,
throw new NotImplementedException();
}
- [System.Runtime.InteropServices.ComVisible(true)]
public virtual Type GetType(String className, bool ignoreCase)
{
return GetType(className, false, ignoreCase);
}
- [System.Runtime.InteropServices.ComVisible(true)]
public virtual Type GetType(String className) {
return GetType(className, false, false);
}
- [System.Runtime.InteropServices.ComVisible(true)]
public virtual Type GetType(String className, bool throwOnError, bool ignoreCase)
{
throw new NotImplementedException();
UnitySerializationHolder.GetUnitySerializationInfo(info, UnitySerializationHolder.ModuleUnity, this.ScopeName, this.GetRuntimeAssembly());
}
- [System.Runtime.InteropServices.ComVisible(true)]
public override Type GetType(String className, bool throwOnError, bool ignoreCase)
{
// throw on null strings regardless of the value of "throwOnError"
namespace System.Reflection
{
[AttributeUsage (AttributeTargets.Assembly, AllowMultiple=false, Inherited=false)]
-[System.Runtime.InteropServices.ComVisible(true)]
public sealed class ObfuscateAssemblyAttribute : Attribute
{
private bool m_assemblyIsPrivate;
{
[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.Property | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Enum | AttributeTargets.Delegate,
AllowMultiple = true, Inherited = false)]
-[System.Runtime.InteropServices.ComVisible(true)]
public sealed class ObfuscationAttribute: Attribute
{
private bool m_strip = true;
// This Enum matchs the CorParamAttr defined in CorHdr.h
[Serializable]
[Flags]
- [System.Runtime.InteropServices.ComVisible(true)]
public enum ParameterAttributes
{
None = 0x0000, // no flag is specified
using System;
[Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
public struct ParameterModifier
{
#region Private Data Members
[CLSCompliant(false)]
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public sealed class Pointer : ISerializable
{
unsafe private void* _ptr;
// This Enum matchs the CorPropertyAttr defined in CorHdr.h
[Serializable]
[Flags]
-[System.Runtime.InteropServices.ComVisible(true)]
public enum PropertyAttributes
{
None = 0x0000,
using System.Security.Permissions;
using System.Diagnostics.Contracts;
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public sealed class ReflectionTypeLoadException : SystemException, ISerializable {
private Type[] _classes;
private Exception[] _exceptions;
using System;
[Serializable]
[Flags]
-[System.Runtime.InteropServices.ComVisible(true)]
public enum ResourceAttributes
{
Public = 0x0001,
using System.Diagnostics.Contracts;
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public class StrongNameKeyPair : IDeserializationCallback, ISerializable
{
private bool _keyPairExported;
using System;
using System.Runtime.Serialization;
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public class TargetException : ApplicationException {
public TargetException() : base() {
SetErrorCode(__HResults.COR_E_TARGET);
using System;
using System.Runtime.Serialization;
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public sealed class TargetInvocationException : ApplicationException {
// This exception is not creatable without specifying the
// inner exception.
using SystemException = System.SystemException;
using System.Runtime.Serialization;
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public sealed class TargetParameterCountException : ApplicationException {
public TargetParameterCountException()
: base(Environment.GetResourceString("Arg_TargetParameterCountException")) {
// This Enum matchs the CorTypeAttr defined in CorHdr.h
[Serializable]
[Flags]
-[System.Runtime.InteropServices.ComVisible(true)]
public enum TypeAttributes
{
VisibilityMask = 0x00000007,
Import = 0x00001000, // Class / interface is imported
Serializable = 0x00002000, // The class is Serializable.
- [ComVisible(false)]
WindowsRuntime = 0x00004000, // Type is a Windows Runtime type.
// Use tdStringFormatMask to retrieve string information for native interop
using CultureInfo = System.Globalization.CultureInfo;
[Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
public class TypeDelegator : TypeInfo
{
public override bool IsAssignableFrom(System.Reflection.TypeInfo typeInfo){
return typeImpl.GetConstructor(bindingAttr,binder,callConvention,types,modifiers);
}
-[System.Runtime.InteropServices.ComVisible(true)]
public override ConstructorInfo[] GetConstructors(BindingFlags bindingAttr)
{
return typeImpl.GetConstructors(bindingAttr);
return typeImpl.IsDefined(attributeType, inherit);
}
-[System.Runtime.InteropServices.ComVisible(true)]
public override InterfaceMapping GetInterfaceMap(Type interfaceType)
{
return typeImpl.GetInterfaceMap(interfaceType);
// Define the delegate
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public delegate bool TypeFilter(Type m, Object filterCriteria);
}
//all today's runtime Type derivations derive now from TypeInfo
//we make TypeInfo implement IRCT - simplifies work
- [System.Runtime.InteropServices.ComVisible(true)]
[Serializable]
public abstract class TypeInfo:Type,IReflectableType
{
using System.IO;
using System.Collections;
- [System.Runtime.InteropServices.ComVisible(true)]
public interface IResourceReader : IEnumerable, IDisposable
{
// Interface does not need to be marked with the serializable attribute
[Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
public struct LooselyLinkedResourceReference {
private String _manifestResourceName;
private String _typeName;
namespace System.Resources {
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public class MissingManifestResourceException : SystemException
{
public MissingManifestResourceException()
namespace System.Resources {
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public class MissingSatelliteAssemblyException : SystemException
{
private String _cultureName;
using System.Diagnostics.Contracts;
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple=false)]
- [System.Runtime.InteropServices.ComVisible(true)]
public sealed class NeutralResourcesLanguageAttribute : Attribute
{
private String _culture;
//
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public class ResourceManager
{
return null;
}
- [ComVisible(false)]
public UnmanagedMemoryStream GetStream(String name) {
return GetStream(name, (CultureInfo)null);
}
- [ComVisible(false)]
public UnmanagedMemoryStream GetStream(String name, CultureInfo culture) {
Object obj = GetObject(name, culture, false);
UnmanagedMemoryStream ums = obj as UnmanagedMemoryStream;
}
- [System.Runtime.InteropServices.ComVisible(true)]
public sealed class ResourceReader : IResourceReader
{
// A reasonable default buffer size for reading from files, especially
// stores them in a hash table. Custom IResourceReaders can be used.
//
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public class ResourceSet : IDisposable, IEnumerable
{
[NonSerialized] protected IResourceReader Reader;
#if LOOSELY_LINKED_RESOURCE_REFERENCE
// Optional - used for resolving assembly manifest resource references.
// This can safely be null.
- [ComVisible(false)]
public Assembly Assembly {
get { return _assembly; }
/*protected*/ set { _assembly = value; }
return Type.GetType("System.Resources.ResourceWriter, System.Resources.Writer, Version=4.0.1.0, Culture=neutral, PublicKeyToken=" + AssemblyRef.MicrosoftPublicKeyToken, throwOnError: true);
}
- [ComVisible(false)]
public virtual IDictionaryEnumerator GetEnumerator()
{
return GetEnumeratorHelper();
using System.Diagnostics.Contracts;
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple=false)]
-[System.Runtime.InteropServices.ComVisible(true)]
public sealed class SatelliteContractVersionAttribute : Attribute
{
private String _version;
namespace System.Resources {
[Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
public enum UltimateResourceFallbackLocation
{
MainAssembly,
return GetMethodCandidates(null, bindingAttr, CallingConventions.Any, null, false).ToArray();
}
-[System.Runtime.InteropServices.ComVisible(true)]
public override ConstructorInfo[] GetConstructors(BindingFlags bindingAttr)
{
return GetConstructorCandidates(null, bindingAttr, CallingConventions.Any, null, false).ToArray();
return RuntimeTypeHandle.IsInstanceOfType(this, o);
}
- [System.Runtime.InteropServices.ComVisible(true)]
[Pure]
public override bool IsSubclassOf(Type type)
{
using System;
[AttributeUsage(AttributeTargets.Field)]
-[System.Runtime.InteropServices.ComVisible(true)]
public sealed class AccessedThroughPropertyAttribute : Attribute
{
private readonly string propertyName;
/// IMPORTANT: Keep this in sync with corhdr.h
[Serializable]
[Flags]
-[System.Runtime.InteropServices.ComVisible(true)]
public enum CompilationRelaxations : int
{
NoStringInterning = 0x0008, // Start in 0x0008, we had other non public flags in this enum before,
[Serializable]
[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Method)]
-[System.Runtime.InteropServices.ComVisible(true)]
public class CompilationRelaxationsAttribute : Attribute
{
private int m_relaxations; // The relaxations.
namespace System.Runtime.CompilerServices
{
#region ConditionalWeakTable
- [ComVisible(false)]
public sealed class ConditionalWeakTable<TKey, TValue> : IEnumerable<KeyValuePair<TKey, TValue>>
where TKey : class
where TValue : class
// This struct intentionally does no self-synchronization. It's up to the caller to
// to use DependentHandles in a thread-safe way.
//=========================================================================================
- [ComVisible(false)]
internal struct DependentHandle
{
#region Constructors
{
[Serializable]
[AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter, Inherited=false)]
- [System.Runtime.InteropServices.ComVisible(true)]
public abstract class CustomConstantAttribute : Attribute
{
public abstract Object Value { get; }
{
[Serializable]
[AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter, Inherited=false)]
- [System.Runtime.InteropServices.ComVisible(true)]
public sealed class DateTimeConstantAttribute : CustomConstantAttribute
{
public DateTimeConstantAttribute(long ticks)
{
[Serializable]
[AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter, Inherited=false)]
- [System.Runtime.InteropServices.ComVisible(true)]
public sealed class DecimalConstantAttribute : Attribute
{
[CLSCompliant(false)]
using System;
// Custom attribute to indicating a TypeDef is a discardable attribute
-[System.Runtime.InteropServices.ComVisible(true)]
public class DiscardableAttribute : Attribute
{
public DiscardableAttribute()
[Serializable]
[AttributeUsage(AttributeTargets.Property, Inherited = true)]
-[System.Runtime.InteropServices.ComVisible(true)]
public sealed class IndexerNameAttribute: Attribute
{
public IndexerNameAttribute(String indexerName)
namespace System.Runtime.CompilerServices
{
-[System.Runtime.InteropServices.ComVisible(true)]
public static class IsVolatile
{
// no instantiation, please!
[Serializable]
[Flags]
-[System.Runtime.InteropServices.ComVisible(true)]
public enum MethodImplOptions
{
Unmanaged = System.Reflection.MethodImplAttributes.Unmanaged,
InternalCall = System.Reflection.MethodImplAttributes.InternalCall,
Synchronized = System.Reflection.MethodImplAttributes.Synchronized,
NoInlining = System.Reflection.MethodImplAttributes.NoInlining,
- [System.Runtime.InteropServices.ComVisible(false)]
AggressiveInlining = System.Reflection.MethodImplAttributes.AggressiveInlining,
NoOptimization = System.Reflection.MethodImplAttributes.NoOptimization,
// **** If you add something, update internal MethodImplAttribute(MethodImplAttributes methodImplAttributes)! ****
}
[Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
public enum MethodCodeType
{
IL = System.Reflection.MethodImplAttributes.IL,
// Custom attribute to specify additional method properties.
[Serializable]
[AttributeUsage(AttributeTargets.Method | AttributeTargets.Constructor, Inherited = false)]
-[System.Runtime.InteropServices.ComVisible(true)]
sealed public class MethodImplAttribute : Attribute
{
internal MethodImplOptions _val;
using System.Runtime.Versioning;
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public struct ArrayWithOffset
{
//private ArrayWithOffset()
using System.Diagnostics.Contracts;
[AttributeUsage(AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
- [System.Runtime.InteropServices.ComVisible(true)]
public sealed class UnmanagedFunctionPointerAttribute : Attribute
{
CallingConvention m_callingConvention;
}
[AttributeUsage(AttributeTargets.Interface | AttributeTargets.Enum | AttributeTargets.Struct | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
- [System.Runtime.InteropServices.ComVisible(false)]
public sealed class TypeIdentifierAttribute : Attribute
{
public TypeIdentifierAttribute() { }
}
[AttributeUsage(AttributeTargets.Method | AttributeTargets.Field | AttributeTargets.Property | AttributeTargets.Event, Inherited = false)]
- [System.Runtime.InteropServices.ComVisible(true)]
public sealed class DispIdAttribute : Attribute
{
internal int _val;
}
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public enum ComInterfaceType
{
InterfaceIsDual = 0,
InterfaceIsIUnknown = 1,
InterfaceIsIDispatch = 2,
- [System.Runtime.InteropServices.ComVisible(false)]
InterfaceIsIInspectable = 3,
}
[AttributeUsage(AttributeTargets.Interface, Inherited = false)]
- [System.Runtime.InteropServices.ComVisible(true)]
public sealed class InterfaceTypeAttribute : Attribute
{
internal ComInterfaceType _val;
}
[AttributeUsage(AttributeTargets.Class, Inherited = false)]
- [System.Runtime.InteropServices.ComVisible(true)]
public sealed class ComDefaultInterfaceAttribute : Attribute
{
internal Type _val;
}
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public enum ClassInterfaceType
{
None = 0,
}
[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class, Inherited = false)]
- [System.Runtime.InteropServices.ComVisible(true)]
public sealed class ClassInterfaceAttribute : Attribute
{
internal ClassInterfaceType _val;
}
[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Interface | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Delegate | AttributeTargets.Enum | AttributeTargets.Field | AttributeTargets.Method | AttributeTargets.Property, Inherited = false)]
- [System.Runtime.InteropServices.ComVisible(true)]
public sealed class ComVisibleAttribute : Attribute
{
internal bool _val;
}
[AttributeUsage(AttributeTargets.Method, Inherited = false)]
- [System.Runtime.InteropServices.ComVisible(true)]
public sealed class LCIDConversionAttribute : Attribute
{
internal int _val;
}
[AttributeUsage(AttributeTargets.Class, Inherited = false)]
- [System.Runtime.InteropServices.ComVisible(true)]
public sealed class ProgIdAttribute : Attribute
{
internal String _val;
}
[AttributeUsage(AttributeTargets.Class, Inherited = true)]
- [System.Runtime.InteropServices.ComVisible(true)]
public sealed class ComSourceInterfacesAttribute : Attribute
{
internal String _val;
}
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public enum VarEnum
{
VT_EMPTY = 0,
}
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
// Note that this enum should remain in-sync with the CorNativeType enum in corhdr.h
public enum UnmanagedType
{
Error = 0x2d,
- [System.Runtime.InteropServices.ComVisible(false)]
IInspectable = 0x2e,
- [System.Runtime.InteropServices.ComVisible(false)]
HString = 0x2f, // Windows Runtime HSTRING
- [System.Runtime.InteropServices.ComVisible(false)]
LPUTF8Str = 0x30, // UTF8 string
}
[AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.ReturnValue, Inherited = false)]
- [System.Runtime.InteropServices.ComVisible(true)]
public unsafe sealed class MarshalAsAttribute : Attribute
{
internal static Attribute GetCustomAttribute(RuntimeParameterInfo parameter)
public int SizeConst; // constant C
// Fields used with SubType = CustomMarshaler
- [System.Runtime.InteropServices.ComVisible(true)]
public String MarshalType; // Name of marshaler class
- [System.Runtime.InteropServices.ComVisible(true)]
public Type MarshalTypeRef; // Type of marshaler class
public String MarshalCookie; // cookie to pass to marshaler
}
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface, Inherited = false)]
- [System.Runtime.InteropServices.ComVisible(true)]
public sealed class ComImportAttribute : Attribute
{
internal static Attribute GetCustomAttribute(RuntimeType type)
}
[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Interface | AttributeTargets.Class | AttributeTargets.Enum | AttributeTargets.Struct | AttributeTargets.Delegate, Inherited = false)]
- [System.Runtime.InteropServices.ComVisible(true)]
public sealed class GuidAttribute : Attribute
{
internal String _val;
}
[AttributeUsage(AttributeTargets.Method, Inherited = false)]
- [System.Runtime.InteropServices.ComVisible(true)]
public sealed class PreserveSigAttribute : Attribute
{
internal static Attribute GetCustomAttribute(RuntimeMethodInfo method)
}
[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
- [System.Runtime.InteropServices.ComVisible(true)]
public sealed class InAttribute : Attribute
{
internal static Attribute GetCustomAttribute(RuntimeParameterInfo parameter)
}
[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
- [System.Runtime.InteropServices.ComVisible(true)]
public sealed class OutAttribute : Attribute
{
internal static Attribute GetCustomAttribute(RuntimeParameterInfo parameter)
}
[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
- [System.Runtime.InteropServices.ComVisible(true)]
public sealed class OptionalAttribute : Attribute
{
internal static Attribute GetCustomAttribute(RuntimeParameterInfo parameter)
}
[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Method, AllowMultiple = false)]
- [System.Runtime.InteropServices.ComVisible(false)]
public sealed class DefaultDllImportSearchPathsAttribute : Attribute
{
internal DllImportSearchPath _paths;
}
[AttributeUsage(AttributeTargets.Method, Inherited = false)]
- [System.Runtime.InteropServices.ComVisible(true)]
public unsafe sealed class DllImportAttribute : Attribute
{
internal static Attribute GetCustomAttribute(RuntimeMethodInfo method)
}
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, Inherited = false)]
- [System.Runtime.InteropServices.ComVisible(true)]
public unsafe sealed class StructLayoutAttribute : Attribute
{
private const int DEFAULT_PACKING_SIZE = 8;
}
[AttributeUsage(AttributeTargets.Field, Inherited = false)]
- [System.Runtime.InteropServices.ComVisible(true)]
public unsafe sealed class FieldOffsetAttribute : Attribute
{
internal static Attribute GetCustomAttribute(RuntimeFieldInfo field)
}
[AttributeUsage(AttributeTargets.Interface, Inherited = false)]
- [System.Runtime.InteropServices.ComVisible(true)]
public sealed class CoClassAttribute : Attribute
{
internal Type _CoClass;
}
[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Interface | AttributeTargets.Class | AttributeTargets.Struct, Inherited = false)]
- [System.Runtime.InteropServices.ComVisible(true)]
public sealed class BestFitMappingAttribute : Attribute
{
internal bool _bestFitMapping;
}
[AttributeUsage(AttributeTargets.Module, Inherited = false)]
- [System.Runtime.InteropServices.ComVisible(true)]
public sealed class DefaultCharSetAttribute : Attribute
{
internal CharSet _CharSet;
using System.Security.Permissions;
[Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
public sealed class BStrWrapper
{
public BStrWrapper(String value)
// Exception for COM Interop errors where we don't recognize the HResult.
//
- [ComVisible(true)]
[Serializable]
public class COMException : ExternalException {
public COMException()
using System;
// Used for the CallingConvention named argument to the DllImport attribute
[Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
public enum CallingConvention
{
Winapi = 1,
// Generally you probably want to use Auto, which does the
// right thing 99% of the time.
[Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
public enum CharSet
{
None = 1, // User didn't specify how to marshal strings.
using System;
[Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
public enum ComMemberType
{
Method = 0,
using System;
[Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
public sealed class CurrencyWrapper
{
public CurrencyWrapper(Decimal obj)
using System.Security.Permissions;
[Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
public sealed class DispatchWrapper
{
public DispatchWrapper(Object obj)
using System.Security.Permissions;
[Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
public sealed class ErrorWrapper
{
public ErrorWrapper(int errorCode)
using System.Reflection;
[Guid("AFBF15E6-C37C-11d2-B88E-00A0C9B471B8")]
-[System.Runtime.InteropServices.ComVisible(true)]
internal interface IExpando : IReflect
{
// Add a new Field to the reflection object. The field has
// Base exception for COM Interop errors &; Structured Exception Handler
// exceptions.
//
- [System.Runtime.InteropServices.ComVisible(true)]
[Serializable]
public class ExternalException : SystemException {
public ExternalException()
// IMPORTANT: If new values are added to the enum the GCHandle::MaxHandleType
// constant must be updated.
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public enum GCHandleType
{
Weak = 0,
//
[StructLayout(LayoutKind.Sequential)]
- [System.Runtime.InteropServices.ComVisible(true)]
public struct GCHandle
{
// IMPORTANT: This must be kept in sync with the GCHandleType enum.
using System;
- [System.Runtime.InteropServices.ComVisible(true)]
public struct HandleRef
{
namespace System.Runtime.InteropServices {
using System;
-[System.Runtime.InteropServices.ComVisible(true)]
public interface ICustomAdapter
{
[return:MarshalAs(UnmanagedType.IUnknown)] Object GetUnderlyingObject();
using System;
-[System.Runtime.InteropServices.ComVisible(true)]
public interface ICustomFactory
{
MarshalByRefObject CreateInstance(Type serverType);
namespace System.Runtime.InteropServices {
using System;
-[System.Runtime.InteropServices.ComVisible(true)]
public interface ICustomMarshaler
{
Object MarshalNativeToManaged( IntPtr pNativeData );
// The enum of the return value of IQuerable.GetInterface
//====================================================================
[Serializable]
- [System.Runtime.InteropServices.ComVisible(false)]
public enum CustomQueryInterfaceResult
{
Handled = 0,
//====================================================================
// The interface for customizing IQueryInterface
//====================================================================
- [System.Runtime.InteropServices.ComVisible(false)]
public interface ICustomQueryInterface
{
CustomQueryInterfaceResult GetInterface([In]ref Guid iid, out IntPtr ppv);
[GuidAttribute("b36b5c63-42ef-38bc-a07e-0b34c98f164a")]
[InterfaceTypeAttribute(ComInterfaceType.InterfaceIsDual)]
[CLSCompliant(false)]
- [System.Runtime.InteropServices.ComVisible(true)]
public interface _Exception
{
//
using System;
using System.Runtime.Serialization;
- [System.Runtime.InteropServices.ComVisible(true)]
[Serializable]
public class InvalidComObjectException : SystemException {
public InvalidComObjectException()
using System;
using System.Runtime.Serialization;
- [System.Runtime.InteropServices.ComVisible(true)]
[Serializable]
public class InvalidOleVariantTypeException : SystemException {
public InvalidOleVariantTypeException()
namespace System.Runtime.InteropServices {
using System;
// Used in the StructLayoutAttribute class
- [System.Runtime.InteropServices.ComVisible(true)]
[Serializable]
public enum LayoutKind
{
//====================================================================
// SizeOf()
//====================================================================
- [System.Runtime.InteropServices.ComVisible(true)]
public static int SizeOf(Object structure)
{
if (structure == null)
// "fDeleteOld" is true, this routine will call DestroyStructure() first.
//====================================================================
[MethodImplAttribute(MethodImplOptions.InternalCall), ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
- [System.Runtime.InteropServices.ComVisible(true)]
public static extern void StructureToPtr(Object structure, IntPtr ptr, bool fDeleteOld);
public static void StructureToPtr<T>(T structure, IntPtr ptr, bool fDeleteOld)
//====================================================================
// Marshals data from a native memory block to a preallocated structure class.
//====================================================================
- [System.Runtime.InteropServices.ComVisible(true)]
public static void PtrToStructure(IntPtr ptr, Object structure)
{
PtrToStructureHelper(ptr, structure, false);
// Creates a new instance of "structuretype" and marshals data from a
// native memory block to it.
//====================================================================
- [System.Runtime.InteropServices.ComVisible(true)]
[MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
public static Object PtrToStructure(IntPtr ptr, Type structureType)
{
// "structureclass" is used to provide layout information.
//====================================================================
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- [System.Runtime.InteropServices.ComVisible(true)]
public static extern void DestroyStructure(IntPtr ptr, Type structuretype);
public static void DestroyStructure<T>(IntPtr ptr)
using System;
using System.Runtime.Serialization;
- [System.Runtime.InteropServices.ComVisible(true)]
[Serializable]
public class MarshalDirectiveException : SystemException {
public MarshalDirectiveException()
namespace System.Runtime.InteropServices
{
- [System.Runtime.InteropServices.ComVisible(true)]
static public class RuntimeEnvironment {
[MethodImplAttribute(MethodImplOptions.InternalCall)]
using System.Runtime.Serialization;
// Exception for Structured Exception Handler exceptions.
//
- [System.Runtime.InteropServices.ComVisible(true)]
[Serializable]
public class SEHException : ExternalException {
public SEHException()
using System;
using System.Runtime.Serialization;
- [System.Runtime.InteropServices.ComVisible(true)]
[Serializable]
public class SafeArrayRankMismatchException : SystemException {
public SafeArrayRankMismatchException()
using System;
using System.Runtime.Serialization;
- [System.Runtime.InteropServices.ComVisible(true)]
[Serializable]
public class SafeArrayTypeMismatchException : SystemException {
public SafeArrayTypeMismatchException()
using System;
[Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
public sealed class UnknownWrapper
{
public UnknownWrapper(Object obj)
//
// In order to be activatable via the ManagedActivationFactory type, the type must be decorated with either
// ActivatableAttribute, or StaticAttribute.
- [ComVisible(true)]
[ClassInterface(ClassInterfaceType.None)]
internal sealed class ManagedActivationFactory : IActivationFactory, IManagedActivationFactory
{
}
#if FEATURE_REFLECTION_ONLY_LOAD
- [ComVisible(false)]
public class NamespaceResolveEventArgs : EventArgs
{
private string _NamespaceName;
}
#endif //FEATURE_REFLECTION_ONLY
- [ComVisible(false)]
internal class DesignerNamespaceResolveEventArgs : EventArgs
{
private string _NamespaceName;
namespace System.Runtime.ConstrainedExecution
{
- [System.Runtime.InteropServices.ComVisible(true)]
public abstract class CriticalFinalizerObject
{
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
using System.Runtime.InteropServices;
[ClassInterface(ClassInterfaceType.AutoDual)]
- [System.Runtime.InteropServices.ComVisible(true)]
public class ObjectHandle
{
private Object WrappedObject;
using System.Globalization;
using System.Diagnostics.Contracts;
-[System.Runtime.InteropServices.ComVisible(true)]
internal class FormatterConverter : IFormatterConverter {
public FormatterConverter() {
using System.Diagnostics;
using System.Diagnostics.Contracts;
- [System.Runtime.InteropServices.ComVisible(true)]
public static class FormatterServices {
// Gets a new instance of the object. The entire object is initalized to 0 and no
using System;
// Interface does not need to be marked with the serializable attribute
- [System.Runtime.InteropServices.ComVisible(true)]
public interface IDeserializationCallback {
void OnDeserialization(Object sender);
}
using System;
[CLSCompliant(false)]
-[System.Runtime.InteropServices.ComVisible(true)]
public interface IFormatterConverter {
Object Convert(Object value, Type type);
Object Convert(Object value, TypeCode typeCode);
using System;
using System.Security.Permissions;
// Interface does not need to be marked with the serializable attribute
-[System.Runtime.InteropServices.ComVisible(true)]
public interface IObjectReference {
Object GetRealObject(StreamingContext context);
}
using System;
using System.Reflection;
- [System.Runtime.InteropServices.ComVisible(true)]
public interface ISerializable {
void GetObjectData(SerializationInfo info, StreamingContext context);
}
using System.Reflection;
[AttributeUsage(AttributeTargets.Field, Inherited=false)]
-[System.Runtime.InteropServices.ComVisible(true)]
public sealed class OptionalFieldAttribute : Attribute
{
int versionAdded = 1;
}
[AttributeUsage(AttributeTargets.Method, Inherited=false)]
-[System.Runtime.InteropServices.ComVisible(true)]
public sealed class OnSerializingAttribute : Attribute
{
}
[AttributeUsage(AttributeTargets.Method, Inherited=false)]
-[System.Runtime.InteropServices.ComVisible(true)]
public sealed class OnSerializedAttribute : Attribute
{
}
[AttributeUsage(AttributeTargets.Method, Inherited=false)]
-[System.Runtime.InteropServices.ComVisible(true)]
public sealed class OnDeserializingAttribute : Attribute
{
}
[AttributeUsage(AttributeTargets.Method, Inherited=false)]
-[System.Runtime.InteropServices.ComVisible(true)]
public sealed class OnDeserializedAttribute : Attribute
{
}
using System;
using System.Runtime.Serialization;
- [System.Runtime.InteropServices.ComVisible(true)]
[Serializable]
public class SerializationException : SystemException {
using System.Security;
using System.Runtime.CompilerServices;
- [System.Runtime.InteropServices.ComVisible(true)]
public sealed class SerializationInfo
{
private const int defaultSize = 4;
return m_data[index];
}
- [System.Runtime.InteropServices.ComVisible(true)]
private Object GetElementNoThrow(String name, out Type foundType)
{
int index = FindElement(name);
return m_converter.Convert(value, type);
}
- [System.Runtime.InteropServices.ComVisible(true)]
internal Object GetValueNoThrow(String name, Type type)
{
Type foundType;
//
// The tuple returned by SerializationInfoEnumerator.Current.
//
-[System.Runtime.InteropServices.ComVisible(true)]
public struct SerializationEntry {
private Type m_type;
private Object m_value;
// This does not snapshot the values, it just keeps pointers to the
// member variables of the SerializationInfo that created it.
//
-[System.Runtime.InteropServices.ComVisible(true)]
public sealed class SerializationInfoEnumerator : IEnumerator {
String[] m_members;
Object[] m_data;
using System.Runtime.Remoting;
using System;
[Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
public struct StreamingContext {
internal Object m_additionalContext;
internal StreamingContextStates m_state;
// **********************************************************
[Serializable]
[Flags]
-[System.Runtime.InteropServices.ComVisible(true)]
public enum StreamingContextStates {
CrossProcess=0x01,
CrossMachine=0x02,
// This corresponds to EE VARARGS cookie.
// Cannot be serialized
- [System.Runtime.InteropServices.ComVisible(true)]
public struct RuntimeArgumentHandle
{
private IntPtr m_ptr;
using StackCrawlMark = System.Threading.StackCrawlMark;
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public unsafe struct RuntimeTypeHandle : ISerializable
{
// Returns handle for interop with EE. The handle is guaranteed to be non-null.
}
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public unsafe struct RuntimeMethodHandle : ISerializable
{
// Returns handle for interop with EE. The handle is guaranteed to be non-null.
}
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public unsafe struct RuntimeFieldHandle : ISerializable
{
// Returns handle for interop with EE. The handle is guaranteed to be non-null.
}
}
-[System.Runtime.InteropServices.ComVisible(true)]
public unsafe struct ModuleHandle
{
// Returns handle for interop with EE. The handle is guaranteed to be non-null.
// A place holder class for signed bytes.
[Serializable]
[CLSCompliant(false), System.Runtime.InteropServices.StructLayout(LayoutKind.Sequential)]
-[System.Runtime.InteropServices.ComVisible(true)]
public struct SByte : IComparable, IFormattable, IConvertible
, IComparable<SByte>, IEquatable<SByte>
{
// Indicates that the target P/Invoke method(s) should skip the per-call
// security checked for unmanaged code permission.
[AttributeUsage(AttributeTargets.Method | AttributeTargets.Class | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = true, Inherited = false )]
- [System.Runtime.InteropServices.ComVisible(true)]
sealed public class SuppressUnmanagedCodeSecurityAttribute : System.Attribute
{
}
// UnverifiableCodeAttribute:
// Indicates that the target module contains unverifiable code.
[AttributeUsage(AttributeTargets.Module, AllowMultiple = true, Inherited = false )]
-[System.Runtime.InteropServices.ComVisible(true)]
sealed public class UnverifiableCodeAttribute : System.Attribute
{
}
// For v.1, this is valid only on Assemblies, but could be expanded to
// include Module, Method, class
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = false, Inherited = false )]
- [System.Runtime.InteropServices.ComVisible(true)]
sealed public class AllowPartiallyTrustedCallersAttribute : System.Attribute
{
private PartialTrustVisibilityLevel _visibilityLevel;
using System.Globalization;
using System.Diagnostics.Contracts;
- [System.Runtime.InteropServices.ComVisible(true)]
[Serializable]
public class SecurityException : SystemException
{
using System;
using System.Runtime.Serialization;
- [System.Runtime.InteropServices.ComVisible(true)]
[Serializable]
public class VerificationException : SystemException {
public VerificationException()
using System.Reflection;
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Delegate, Inherited = false)]
-[System.Runtime.InteropServices.ComVisible(true)]
public sealed class SerializableAttribute : Attribute
{
internal static Attribute GetCustomAttribute(RuntimeType type)
[Serializable]
[System.Runtime.InteropServices.StructLayout(LayoutKind.Sequential)]
-[System.Runtime.InteropServices.ComVisible(true)]
public struct Single : IComparable, IFormattable, IConvertible
, IComparable<Single>, IEquatable<Single>
{
}
[Pure]
- [ComVisible(false)]
public Boolean EndsWith(String value, StringComparison comparisonType) {
if( (Object)value == null) {
throw new ArgumentNullException(nameof(value));
}
[Pure]
- [ComVisible(false)]
public Boolean StartsWith(String value, StringComparison comparisonType) {
if( (Object)value == null) {
throw new ArgumentNullException(nameof(value));
return result;
}
- [ComVisible(false)]
public static string Concat<T>(IEnumerable<T> values)
{
if (values == null)
}
- [ComVisible(false)]
public static string Concat(IEnumerable<string> values)
{
if (values == null)
return Join(separator, value, 0, value.Length);
}
- [ComVisible(false)]
public unsafe static string Join(string separator, params object[] values)
{
separator = separator ?? string.Empty;
}
}
- [ComVisible(false)]
public unsafe static string Join<T>(string separator, IEnumerable<T> values)
{
separator = separator ?? string.Empty;
}
}
- [ComVisible(false)]
public static string Join(string separator, IEnumerable<string> values)
{
if (values == null)
return ReplaceInternal(oldValue, newValue);
}
- [ComVisible(false)]
public unsafe String[] Split(char separator, StringSplitOptions options = StringSplitOptions.None) {
Contract.Ensures(Contract.Result<String[]>() != null);
return SplitInternal(&separator, 1, int.MaxValue, options);
}
- [ComVisible(false)]
public unsafe String[] Split(char separator, int count, StringSplitOptions options = StringSplitOptions.None) {
Contract.Ensures(Contract.Result<String[]>() != null);
return SplitInternal(&separator, 1, count, options);
return SplitInternal(separator, count, StringSplitOptions.None);
}
- [ComVisible(false)]
public String[] Split(char[] separator, StringSplitOptions options) {
Contract.Ensures(Contract.Result<String[]>() != null);
return SplitInternal(separator, Int32.MaxValue, options);
}
- [ComVisible(false)]
public String[] Split(char[] separator, int count, StringSplitOptions options)
{
Contract.Ensures(Contract.Result<String[]>() != null);
}
}
- [ComVisible(false)]
public String[] Split(String separator, StringSplitOptions options = StringSplitOptions.None) {
Contract.Ensures(Contract.Result<String[]>() != null);
return SplitInternal(separator ?? String.Empty, null, Int32.MaxValue, options);
}
- [ComVisible(false)]
public String[] Split(String separator, Int32 count, StringSplitOptions options = StringSplitOptions.None) {
Contract.Ensures(Contract.Result<String[]>() != null);
return SplitInternal(separator ?? String.Empty, null, count, options);
}
- [ComVisible(false)]
public String [] Split(String[] separator, StringSplitOptions options) {
Contract.Ensures(Contract.Result<String[]>() != null);
return SplitInternal(null, separator, Int32.MaxValue, options);
}
- [ComVisible(false)]
public String[] Split(String[] separator, Int32 count, StringSplitOptions options) {
Contract.Ensures(Contract.Result<String[]>() != null);
return SplitInternal(null, separator, count, options);
// implemented as a part of String. As with arrays, character positions
// (indices) are zero-based.
- [ComVisible(true)]
[Serializable]
public sealed partial class String : IComparable, ICloneable, IConvertible, IEnumerable
, IComparable<String>, IEnumerable<char>, IEquatable<String>
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public abstract class StringComparer : IComparer, IEqualityComparer, IComparer<string>, IEqualityComparer<string>{
private static readonly StringComparer _invariantCulture = new CultureAwareComparer(CultureInfo.InvariantCulture, false);
private static readonly StringComparer _invariantCultureIgnoreCase = new CultureAwareComparer(CultureInfo.InvariantCulture, true);
//
[Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
public class ASCIIEncoding : Encoding
{
// Used by Encoding.ASCII for lazy initialization
}
[CLSCompliant(false)]
- [System.Runtime.InteropServices.ComVisible(false)]
public override unsafe int GetByteCount(char* chars, int count)
{
return EncodingForwarder.GetByteCount(this, chars, count);
}
[CLSCompliant(false)]
- [System.Runtime.InteropServices.ComVisible(false)]
public override unsafe int GetBytes(char* chars, int charCount, byte* bytes, int byteCount)
{
return EncodingForwarder.GetBytes(this, chars, charCount, bytes, byteCount);
}
[CLSCompliant(false)]
- [System.Runtime.InteropServices.ComVisible(false)]
public override unsafe int GetCharCount(byte* bytes, int count)
{
return EncodingForwarder.GetCharCount(this, bytes, count);
}
[CLSCompliant(false)]
- [System.Runtime.InteropServices.ComVisible(false)]
public unsafe override int GetChars(byte* bytes, int byteCount, char* chars, int charCount)
{
return EncodingForwarder.GetChars(this, bytes, byteCount, chars, charCount);
// True if and only if the encoding only uses single byte code points. (Ie, ASCII, 1252, etc)
- [System.Runtime.InteropServices.ComVisible(false)]
public override bool IsSingleByte
{
get
}
}
- [System.Runtime.InteropServices.ComVisible(false)]
public override Decoder GetDecoder()
{
return new DecoderNLS(this);
}
- [System.Runtime.InteropServices.ComVisible(false)]
public override Encoder GetEncoder()
{
return new EncoderNLS(this);
// class are typically obtained through calls to the GetDecoder method
// of Encoding objects.
//
- [System.Runtime.InteropServices.ComVisible(true)]
[Serializable]
public abstract class Decoder
{
// We don't call default reset because default reset probably isn't good if we aren't initialized.
}
- [System.Runtime.InteropServices.ComVisible(false)]
public DecoderFallback Fallback
{
get
// Note: we don't test for threading here because async access to Encoders and Decoders
// doesn't work anyway.
- [System.Runtime.InteropServices.ComVisible(false)]
public DecoderFallbackBuffer FallbackBuffer
{
get
//
// Virtual implimentation has to call GetChars with flush and a big enough buffer to clear a 0 byte string
// We avoid GetMaxCharCount() because a) we can't call the base encoder and b) it might be really big.
- [System.Runtime.InteropServices.ComVisible(false)]
public virtual void Reset()
{
byte[] byteTemp = Array.Empty<byte>();
//
public abstract int GetCharCount(byte[] bytes, int index, int count);
- [System.Runtime.InteropServices.ComVisible(false)]
public virtual int GetCharCount(byte[] bytes, int index, int count, bool flush)
{
return GetCharCount(bytes, index, count);
// We expect this to be the workhorse for NLS Encodings, but for existing
// ones we need a working (if slow) default implimentation)
[CLSCompliant(false)]
- [System.Runtime.InteropServices.ComVisible(false)]
public virtual unsafe int GetCharCount(byte* bytes, int count, bool flush)
{
// Validate input parameters
// could easily overflow our output buffer. Therefore we do an extra test
// when we copy the buffer so that we don't overflow charCount either.
[CLSCompliant(false)]
- [System.Runtime.InteropServices.ComVisible(false)]
public virtual unsafe int GetChars(byte* bytes, int byteCount,
char* chars, int charCount, bool flush)
{
// Note that if all of the input bytes are not consumed, then we'll do a /2, which means
// that its likely that we didn't consume as many bytes as we could have. For some
// applications this could be slow. (Like trying to exactly fill an output buffer from a bigger stream)
- [System.Runtime.InteropServices.ComVisible(false)]
public virtual void Convert(byte[] bytes, int byteIndex, int byteCount,
char[] chars, int charIndex, int charCount, bool flush,
out int bytesUsed, out int charsUsed, out bool completed)
// that its likely that we didn't consume as many bytes as we could have. For some
// applications this could be slow. (Like trying to exactly fill an output buffer from a bigger stream)
[CLSCompliant(false)]
- [System.Runtime.InteropServices.ComVisible(false)]
public virtual unsafe void Convert(byte* bytes, int byteCount,
char* chars, int charCount, bool flush,
out int bytesUsed, out int charsUsed, out bool completed)
// class are typically obtained through calls to the GetEncoder method
// of Encoding objects.
//
- [System.Runtime.InteropServices.ComVisible(true)]
[Serializable]
public abstract class Encoder
{
// We don't call default reset because default reset probably isn't good if we aren't initialized.
}
- [System.Runtime.InteropServices.ComVisible(false)]
public EncoderFallback Fallback
{
get
// Note: we don't test for threading here because async access to Encoders and Decoders
// doesn't work anyway.
- [System.Runtime.InteropServices.ComVisible(false)]
public EncoderFallbackBuffer FallbackBuffer
{
get
//
// Virtual implimentation has to call GetBytes with flush and a big enough buffer to clear a 0 char string
// We avoid GetMaxByteCount() because a) we can't call the base encoder and b) it might be really big.
- [System.Runtime.InteropServices.ComVisible(false)]
public virtual void Reset()
{
char[] charTemp = {};
// unfortunately for existing overrides, it has to call the [] version,
// which is really slow, so avoid this method if you might be calling external encodings.
[CLSCompliant(false)]
- [System.Runtime.InteropServices.ComVisible(false)]
public virtual unsafe int GetByteCount(char* chars, int count, bool flush)
{
// Validate input parameters
// could easily overflow our output buffer. Therefore we do an extra test
// when we copy the buffer so that we don't overflow byteCount either.
[CLSCompliant(false)]
- [System.Runtime.InteropServices.ComVisible(false)]
public virtual unsafe int GetBytes(char* chars, int charCount,
byte* bytes, int byteCount, bool flush)
{
// Note that if all of the input chars are not consumed, then we'll do a /2, which means
// that its likely that we didn't consume as many chars as we could have. For some
// applications this could be slow. (Like trying to exactly fill an output buffer from a bigger stream)
- [System.Runtime.InteropServices.ComVisible(false)]
public virtual void Convert(char[] chars, int charIndex, int charCount,
byte[] bytes, int byteIndex, int byteCount, bool flush,
out int charsUsed, out int bytesUsed, out bool completed)
// that its likely that we didn't consume as many chars as we could have. For some
// applications this could be slow. (Like trying to exactly fill an output buffer from a bigger stream)
[CLSCompliant(false)]
- [System.Runtime.InteropServices.ComVisible(false)]
public virtual unsafe void Convert(char* chars, int charCount,
byte* bytes, int byteCount, bool flush,
out int charsUsed, out int bytesUsed, out bool completed)
// generally executes faster.
//
- [System.Runtime.InteropServices.ComVisible(true)]
[Serializable]
public abstract class Encoding : ICloneable
{
// True if and only if the encoding only uses single byte code points. (Ie, ASCII, 1252, etc)
- [System.Runtime.InteropServices.ComVisible(false)]
public virtual bool IsSingleByte
{
get
}
- [System.Runtime.InteropServices.ComVisible(false)]
public EncoderFallback EncoderFallback
{
get
}
- [System.Runtime.InteropServices.ComVisible(false)]
public DecoderFallback DecoderFallback
{
get
}
- [System.Runtime.InteropServices.ComVisible(false)]
public virtual Object Clone()
{
Encoding newEncoding = (Encoding)this.MemberwiseClone();
}
- [System.Runtime.InteropServices.ComVisible(false)]
public bool IsReadOnly
{
get
// a 3rd party encoding.
[Pure]
[CLSCompliant(false)]
- [System.Runtime.InteropServices.ComVisible(false)]
public virtual unsafe int GetByteCount(char* chars, int count)
{
// Validate input parameters
// when we copy the buffer so that we don't overflow byteCount either.
[CLSCompliant(false)]
- [System.Runtime.InteropServices.ComVisible(false)]
public virtual unsafe int GetBytes(char* chars, int charCount,
byte* bytes, int byteCount)
{
// ones we need a working (if slow) default implimentation)
[Pure]
[CLSCompliant(false)]
- [System.Runtime.InteropServices.ComVisible(false)]
public virtual unsafe int GetCharCount(byte* bytes, int count)
{
// Validate input parameters
// when we copy the buffer so that we don't overflow charCount either.
[CLSCompliant(false)]
- [System.Runtime.InteropServices.ComVisible(false)]
public virtual unsafe int GetChars(byte* bytes, int byteCount,
char* chars, int charCount)
{
[CLSCompliant(false)]
- [System.Runtime.InteropServices.ComVisible(false)]
public unsafe string GetString(byte* bytes, int byteCount)
{
if (bytes == null)
// IsAlwaysNormalized
// Returns true if the encoding is always normalized for the specified encoding form
[Pure]
- [System.Runtime.InteropServices.ComVisible(false)]
public bool IsAlwaysNormalized()
{
return this.IsAlwaysNormalized(NormalizationForm.FormC);
}
[Pure]
- [System.Runtime.InteropServices.ComVisible(false)]
public virtual bool IsAlwaysNormalized(NormalizationForm form)
{
// Assume false unless the encoding knows otherwise
// This class overrides Encoding with the things we need for our NLS Encodings
- [System.Runtime.InteropServices.ComVisible(true)]
[Serializable]
internal abstract class EncodingNLS : Encoding
{
using System.Collections;
using System.Collections.Generic;
- [System.Runtime.InteropServices.ComVisible(true)]
public abstract class EncodingProvider
{
public EncodingProvider() { }
namespace System.Text
{
// This is the enumeration for Normalization Forms
-[System.Runtime.InteropServices.ComVisible(true)]
public enum NormalizationForm
{
FormC = 1,
// Console.WriteLine(sb1);
// Console.WriteLine(sb2);
//
- [System.Runtime.InteropServices.ComVisible(true)]
[Serializable]
public sealed class StringBuilder : ISerializable
{
}
}
- [System.Runtime.InteropServices.ComVisible(false)]
public StringBuilder AppendLine() {
Contract.Ensures(Contract.Result<StringBuilder>() != null);
return Append(Environment.NewLine);
}
- [System.Runtime.InteropServices.ComVisible(false)]
public StringBuilder AppendLine(string value) {
Contract.Ensures(Contract.Result<StringBuilder>() != null);
Append(value);
return Append(Environment.NewLine);
}
- [System.Runtime.InteropServices.ComVisible(false)]
public void CopyTo(int sourceIndex, char[] destination, int destinationIndex, int count) {
if (destination == null) {
throw new ArgumentNullException(nameof(destination));
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public class UTF7Encoding : Encoding
{
private const String base64Chars =
- [System.Runtime.InteropServices.ComVisible(false)]
public override bool Equals(Object value)
{
UTF7Encoding that = value as UTF7Encoding;
// Compared to all the other encodings, variations of UTF7 are unlikely
- [System.Runtime.InteropServices.ComVisible(false)]
public override int GetHashCode()
{
return this.CodePage + this.EncoderFallback.GetHashCode() + this.DecoderFallback.GetHashCode();
return EncodingForwarder.GetByteCount(this, chars, index, count);
}
- [System.Runtime.InteropServices.ComVisible(false)]
public override int GetByteCount(String s)
{
return EncodingForwarder.GetByteCount(this, s);
}
[CLSCompliant(false)]
- [System.Runtime.InteropServices.ComVisible(false)]
public override unsafe int GetByteCount(char* chars, int count)
{
return EncodingForwarder.GetByteCount(this, chars, count);
}
- [System.Runtime.InteropServices.ComVisible(false)]
public override int GetBytes(String s, int charIndex, int charCount,
byte[] bytes, int byteIndex)
{
}
[CLSCompliant(false)]
- [System.Runtime.InteropServices.ComVisible(false)]
public override unsafe int GetBytes(char* chars, int charCount, byte* bytes, int byteCount)
{
return EncodingForwarder.GetBytes(this, chars, charCount, bytes, byteCount);
}
[CLSCompliant(false)]
- [System.Runtime.InteropServices.ComVisible(false)]
public override unsafe int GetCharCount(byte* bytes, int count)
{
return EncodingForwarder.GetCharCount(this, bytes, count);
}
[CLSCompliant(false)]
- [System.Runtime.InteropServices.ComVisible(false)]
public unsafe override int GetChars(byte* bytes, int byteCount, char* chars, int charCount)
{
return EncodingForwarder.GetChars(this, bytes, byteCount, chars, charCount);
// Returns a string containing the decoded representation of a range of
// bytes in a byte array.
- [System.Runtime.InteropServices.ComVisible(false)]
public override String GetString(byte[] bytes, int index, int count)
{
return EncodingForwarder.GetString(this, bytes, index, count);
// switch the byte orderings.
[Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
public class UTF8Encoding : Encoding
{
/*
}
[CLSCompliant(false)]
- [System.Runtime.InteropServices.ComVisible(false)]
public override unsafe int GetByteCount(char* chars, int count)
{
return EncodingForwarder.GetByteCount(this, chars, count);
}
[CLSCompliant(false)]
- [System.Runtime.InteropServices.ComVisible(false)]
public override unsafe int GetBytes(char* chars, int charCount, byte* bytes, int byteCount)
{
return EncodingForwarder.GetBytes(this, chars, charCount, bytes, byteCount);
}
[CLSCompliant(false)]
- [System.Runtime.InteropServices.ComVisible(false)]
public override unsafe int GetCharCount(byte* bytes, int count)
{
return EncodingForwarder.GetCharCount(this, bytes, count);
}
[CLSCompliant(false)]
- [System.Runtime.InteropServices.ComVisible(false)]
public unsafe override int GetChars(byte* bytes, int byteCount, char* chars, int charCount)
{
return EncodingForwarder.GetChars(this, bytes, byteCount, chars, charCount);
// Returns a string containing the decoded representation of a range of
// bytes in a byte array.
- [System.Runtime.InteropServices.ComVisible(false)]
public override String GetString(byte[] bytes, int index, int count)
{
return EncodingForwarder.GetString(this, bytes, index, count);
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public class UnicodeEncoding : Encoding
{
// Used by Encoding.BigEndianUnicode/Unicode for lazy initialization
}
[CLSCompliant(false)]
- [System.Runtime.InteropServices.ComVisible(false)]
public override unsafe int GetByteCount(char* chars, int count)
{
return EncodingForwarder.GetByteCount(this, chars, count);
}
[CLSCompliant(false)]
- [System.Runtime.InteropServices.ComVisible(false)]
public override unsafe int GetBytes(char* chars, int charCount, byte* bytes, int byteCount)
{
return EncodingForwarder.GetBytes(this, chars, charCount, bytes, byteCount);
}
[CLSCompliant(false)]
- [System.Runtime.InteropServices.ComVisible(false)]
public override unsafe int GetCharCount(byte* bytes, int count)
{
return EncodingForwarder.GetCharCount(this, bytes, count);
}
[CLSCompliant(false)]
- [System.Runtime.InteropServices.ComVisible(false)]
public unsafe override int GetChars(byte* bytes, int byteCount, char* chars, int charCount)
{
return EncodingForwarder.GetChars(this, bytes, byteCount, chars, charCount);
// Returns a string containing the decoded representation of a range of
// bytes in a byte array.
- [System.Runtime.InteropServices.ComVisible(false)]
public override String GetString(byte[] bytes, int index, int count)
{
return EncodingForwarder.GetString(this, bytes, index, count);
}
- [System.Runtime.InteropServices.ComVisible(false)]
public override System.Text.Encoder GetEncoder()
{
return new EncoderNLS(this);
namespace System.Threading {
[Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
public enum ApartmentState
{
/*=========================================================================
using System.Security.Permissions;
using System.Runtime.InteropServices;
- [System.Runtime.InteropServices.ComVisible(true)]
public sealed class AutoResetEvent : EventWaitHandle
{
public AutoResetEvent(bool initialState) : base(initialState,EventResetMode.AutoReset){ }
/// All members of this struct are thread-safe and may be used concurrently from multiple threads.
/// </para>
/// </remarks>
- [ComVisible(false)]
[DebuggerDisplay("IsCancellationRequested = {IsCancellationRequested}")]
public struct CancellationToken
{
/// concurrently from multiple threads.
/// </para>
/// </remarks>
- [ComVisible(false)]
public class CancellationTokenSource : IDisposable
{
/// completed, and Reset, which should only be used when no other threads are
/// accessing the event.
/// </remarks>
- [ComVisible(false)]
[DebuggerDisplay("Initial Count={InitialCount}, Current Count={CurrentCount}")]
public class CountdownEvent : IDisposable
{
using System.Diagnostics.Contracts;
using System.Diagnostics.CodeAnalysis;
- [System.Runtime.InteropServices.ComVisible(true)]
public delegate void ContextCallback(Object state);
internal struct ExecutionContextSwitcher
public static extern IntPtr Exchange(ref IntPtr location1, IntPtr value);
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
- [System.Runtime.InteropServices.ComVisible(false)]
public static T Exchange<T>(ref T location1, T value) where T : class
{
_Exchange(__makeref(location1), __makeref(value));
*****************************************************************/
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
- [System.Runtime.InteropServices.ComVisible(false)]
public static T CompareExchange<T>(ref T location1, T value, T comparand) where T : class
{
// _CompareExchange() passes back the value read from location1 via local named 'value'
using System.Security.Permissions;
using System.Runtime.InteropServices;
-[System.Runtime.InteropServices.ComVisible(true)]
public sealed class ManualResetEvent : EventWaitHandle
{
public ManualResetEvent(bool initialState) : base(initialState,EventResetMode.ManualReset){}
/// completed, and Reset, which should only be used when no other threads are
/// accessing the event.
/// </remarks>
- [ComVisible(false)]
[DebuggerDisplay("Set = {IsSet}")]
public class ManualResetEventSlim : IDisposable
{
using System.Diagnostics;
using System.Diagnostics.Contracts;
- [System.Runtime.InteropServices.ComVisible(true)]
public static class Monitor
{
/*=========================================================================
using System.Diagnostics;
using System.Diagnostics.Contracts;
- [ComVisible(true)]
public sealed class Mutex : WaitHandle
{
static bool dummyBool;
// The first five matches OVERLAPPED structure.
// The remaining are reserved at the end
[System.Runtime.InteropServices.StructLayout(LayoutKind.Sequential)]
- [System.Runtime.InteropServices.ComVisible(true)]
public struct NativeOverlapped
{
public IntPtr InternalLow;
return AllocateNativeOverlapped();
}
- [ComVisible(false)]
internal IntPtr UserHandle
{
get { return m_nativeOverlapped.EventHandle; }
#region class Overlapped
/// <internalonly/>
- [System.Runtime.InteropServices.ComVisible(true)]
public class Overlapped
{
private OverlappedData m_overlappedData;
set { m_overlappedData.UserHandle = new IntPtr(value); }
}
- [ComVisible(false)]
public IntPtr EventHandleIntPtr
{
get { return m_overlappedData.UserHandle; }
return Pack (iocb, null);
}
- [CLSCompliant(false),ComVisible(false)]
+ [CLSCompliant(false)]
unsafe public NativeOverlapped* Pack(IOCompletionCallback iocb, Object userData)
{
return m_overlappedData.Pack(iocb, userData);
return UnsafePack (iocb, null);
}
- [CLSCompliant(false), ComVisible(false)]
+ [CLSCompliant(false)]
unsafe public NativeOverlapped* UnsafePack(IOCompletionCallback iocb, Object userData)
{
return m_overlappedData.UnsafePack(iocb, userData);
/// completed.
/// </para>
/// </remarks>
- [ComVisible(false)]
[DebuggerDisplay("Current Count = {m_currentCount}")]
public class SemaphoreSlim : IDisposable
{
using System;
using System.Runtime.Serialization;
- [System.Runtime.InteropServices.ComVisible(true)]
[Serializable]
public class SynchronizationLockException : SystemException {
public SynchronizationLockException()
SetStartHelper((Delegate)start, maxStackSize);
}
- [ComVisible(false)]
public override int GetHashCode()
{
return m_ManagedThreadId;
using System.Runtime.Serialization;
using System.Runtime.CompilerServices;
- [System.Runtime.InteropServices.ComVisible(true)]
[Serializable]
public sealed class ThreadAbortException : SystemException
{
using System;
using System.Runtime.Serialization;
- [System.Runtime.InteropServices.ComVisible(true)]
[Serializable]
public class ThreadInterruptedException : SystemException {
public ThreadInterruptedException()
private static extern bool UnregisterWaitNative(IntPtr handle, SafeHandle waitObject);
}
- [System.Runtime.InteropServices.ComVisible(true)]
public sealed class RegisteredWaitHandle : MarshalByRefObject {
private readonly RegisteredWaitHandleSafe internalRegisteredWait;
internalRegisteredWait.SetWaitObject(waitObject);
}
- [System.Runtime.InteropServices.ComVisible(true)]
// This is the only public method on this class
public bool Unregister(
WaitHandle waitObject // object to be notified when all callbacks to delegates have completed
}
}
- [System.Runtime.InteropServices.ComVisible(true)]
public delegate void WaitCallback(Object state);
- [System.Runtime.InteropServices.ComVisible(true)]
public delegate void WaitOrTimerCallback(Object state, bool timedOut); // signalled or timed out
//
}
[CLSCompliant(false)]
- [System.Runtime.InteropServices.ComVisible(true)]
unsafe public delegate void IOCompletionCallback(uint errorCode, // Error code
uint numBytes, // No. of bytes transferred
NativeOverlapped* pOVERLAP // ptr to OVERLAP structure
using System.Threading;
[Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
public enum ThreadPriority
{
/*=========================================================================
// Define the delegate
// NOTE: If you change the signature here, there is code in COMSynchronization
// that invokes this delegate in native.
-[System.Runtime.InteropServices.ComVisible(true)]
public delegate void ThreadStart();
}
[Serializable]
[Flags]
-[System.Runtime.InteropServices.ComVisible(true)]
public enum ThreadState
{
/*=========================================================================
namespace System.Threading {
using System;
using System.Runtime.Serialization;
- [System.Runtime.InteropServices.ComVisible(true)]
[Serializable]
public class ThreadStateException : SystemException {
public ThreadStateException()
// A constant used by methods that take a timeout (Object.Wait, Thread.Sleep
// etc) to indicate that no timeout should occur.
//
- [System.Runtime.InteropServices.ComVisible(true)]
public static class Timeout
{
- [System.Runtime.InteropServices.ComVisible(false)]
public static readonly TimeSpan InfiniteTimeSpan = new TimeSpan(0, 0, 0, 0, Timeout.Infinite);
public const int Infinite = -1;
- [System.Runtime.InteropServices.ComVisible(true)]
public delegate void TimerCallback(Object state);
//
}
- [System.Runtime.InteropServices.ComVisible(true)]
public sealed class Timer : MarshalByRefObject, IDisposable
{
private const UInt32 MAX_SUPPORTED_TIMEOUT = (uint)0xfffffffe;
using System.Diagnostics.CodeAnalysis;
using Win32Native = Microsoft.Win32.Win32Native;
- [System.Runtime.InteropServices.ComVisible(true)]
public abstract class WaitHandle : MarshalByRefObject, IDisposable {
public const int WaitTimeout = 0x102;
// details of this type should change, or new fields added, we need to remember to add
// an appropriate custom ILMarshaler to keep WInRT interop scenarios enabled.
//
- [System.Runtime.InteropServices.ComVisible(true)]
[Serializable] public struct TimeSpan : IComparable
, IComparable<TimeSpan>, IEquatable<TimeSpan>, IFormattable
{
using System.Globalization;
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
[Obsolete("System.TimeZone has been deprecated. Please investigate the use of System.TimeZoneInfo instead.")]
public abstract class TimeZone {
private static volatile TimeZone currentTimeZone = null;
// This method will search for the specified constructor. For constructors,
// unlike everything else, the default is to not look for static methods. The
// reason is that we don't typically expose the class initializer.
- [System.Runtime.InteropServices.ComVisible(true)]
public ConstructorInfo GetConstructor(BindingFlags bindingAttr,
Binder binder,
CallingConventions callConvention,
return GetConstructorImpl(bindingAttr, binder, callConvention, types, modifiers);
}
- [System.Runtime.InteropServices.ComVisible(true)]
public ConstructorInfo GetConstructor(BindingFlags bindingAttr, Binder binder, Type[] types, ParameterModifier[] modifiers)
{
if (types == null)
return GetConstructorImpl(bindingAttr, binder, CallingConventions.Any, types, modifiers);
}
- [System.Runtime.InteropServices.ComVisible(true)]
public ConstructorInfo GetConstructor(Type[] types)
{
// The arguments are checked in the called version of GetConstructor.
// This routine will return an array of all constructors supported by the class.
// Unlike everything else, the default is to not look for static methods. The
// reason is that we don't typically expose the class initializer.
- [System.Runtime.InteropServices.ComVisible(true)]
public ConstructorInfo[] GetConstructors() {
return GetConstructors(BindingFlags.Public | BindingFlags.Instance);
}
- [System.Runtime.InteropServices.ComVisible(true)]
abstract public ConstructorInfo[] GetConstructors(BindingFlags bindingAttr);
- [System.Runtime.InteropServices.ComVisible(true)]
public ConstructorInfo TypeInitializer {
get {
return GetConstructorImpl(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic,
// else returns false. If this class and c are the same class false is
// returned.
//
- [System.Runtime.InteropServices.ComVisible(true)]
[Pure]
public virtual bool IsSubclassOf(Type c)
{
// This method will return an interface mapping for the interface
// requested. It will throw an argument exception if the Type doesn't
// implemenet the interface.
- [System.Runtime.InteropServices.ComVisible(true)]
public virtual InterfaceMapping GetInterfaceMap(Type interfaceType)
{
throw new NotSupportedException(Environment.GetResourceString("NotSupported_SubclassOverride"));
using System.Diagnostics.Contracts;
[Serializable]
- [System.Runtime.InteropServices.ComVisible(true)]
public class TypeLoadException : SystemException, ISerializable {
public TypeLoadException()
using System.Runtime.Serialization;
- [System.Runtime.InteropServices.ComVisible(true)]
[Serializable]
public class TypeUnloadedException : SystemException {
public TypeUnloadedException()
using System.Diagnostics.Contracts;
[CLSCompliant(false)]
- [System.Runtime.InteropServices.ComVisible(true)]
[System.Runtime.Versioning.NonVersionable] // This only applies to field layout
public struct TypedReference
{
// Wrapper for unsigned 16 bit integers.
[Serializable]
[CLSCompliant(false), System.Runtime.InteropServices.StructLayout(LayoutKind.Sequential)]
-[System.Runtime.InteropServices.ComVisible(true)]
public struct UInt16 : IComparable, IFormattable, IConvertible
, IComparable<UInt16>, IEquatable<UInt16>
{
// * Wrapper for unsigned 32 bit integers.
[Serializable]
[CLSCompliant(false), System.Runtime.InteropServices.StructLayout(LayoutKind.Sequential)]
- [System.Runtime.InteropServices.ComVisible(true)]
public struct UInt32 : IComparable, IFormattable, IConvertible
, IComparable<UInt32>, IEquatable<UInt32>
{
// Wrapper for unsigned 64 bit integers.
[Serializable]
[CLSCompliant(false), System.Runtime.InteropServices.StructLayout(LayoutKind.Sequential)]
-[System.Runtime.InteropServices.ComVisible(true)]
public struct UInt64 : IComparable, IFormattable, IConvertible
, IComparable<UInt64>, IEquatable<UInt64>
{
[Serializable]
[CLSCompliant(false)]
- [System.Runtime.InteropServices.ComVisible(true)]
public struct UIntPtr : IEquatable<UIntPtr>, ISerializable
{
unsafe private void* m_value;
using System.Runtime.Versioning;
[Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
public abstract class ValueType {
public override bool Equals (Object obj) {
// specified component.
[Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
public sealed class Version : ICloneable, IComparable
, IComparable<Version>, IEquatable<Version>
{
using System.Diagnostics;
using System.Diagnostics.Contracts;
- [System.Runtime.InteropServices.ComVisible(true)]
[Serializable]
public class WeakReference : ISerializable
{
projects / platform / upstream / dotnet / runtime.git / commitdiff