<data name="Serialization_DateTimeTicksOutOfRange" xml:space="preserve">
<value>Invalid serialized DateTime data. Ticks must be between DateTime.MinValue.Ticks and DateTime.MaxValue.Ticks.</value>
</data>
+ <data name="Serialization_DelegatesNotSupported" xml:space="preserve">
+ <value>Serializing delegates is not supported on this platform.</value>
+ </data>
<data name="Serialization_InsufficientDeserializationState" xml:space="preserve">
<value>Insufficient state to deserialize the object. Missing field '{0}'. More information is needed.</value>
</data>
<Compile Include="$(BclSourcesRoot)\System\Currency.cs" />
<Compile Include="$(BclSourcesRoot)\System\Decimal.cs" />
<Compile Include="$(BclSourcesRoot)\System\DefaultBinder.CanConvert.cs" />
- <Compile Include="$(BclSourcesRoot)\System\DelegateSerializationHolder.cs" />
<Compile Include="$(BclSourcesRoot)\System\Double.cs" />
<Compile Include="$(BclSourcesRoot)\System\Empty.cs" />
<Compile Include="$(BclSourcesRoot)\System\Enum.cs" />
<Win32Resource Condition="'$(GenerateNativeVersionInfo)'=='true'">$(IntermediateOutputPath)\System.Private.CoreLib.res</Win32Resource>
</PropertyGroup>
<Import Project="GenerateCompilerResponseFile.targets" />
-</Project>
+</Project>
\ No newline at end of file
// ApplicationException extends but adds no new functionality to
// RecoverableException.
//
- [Serializable]
public class ApplicationException : Exception
{
// Creates a new ApplicationException with its message string set to
// the contract of the method. Ideally it should give a meaningful error
// message describing what was wrong and which parameter is incorrect.
//
- [Serializable]
public class ArgumentException : SystemException
{
private String _paramName;
// The ArgumentException is thrown when an argument
// is null when it shouldn't be.
//
- [Serializable]
public class ArgumentNullException : ArgumentException
{
// Creates a new ArgumentNullException with its message
{
// The ArgumentOutOfRangeException is thrown when an argument
// is outside the legal range for that argument.
- [Serializable]
public class ArgumentOutOfRangeException : ArgumentException
{
private Object _actualValue;
// The ArithmeticException is thrown when overflow or underflow
// occurs.
//
- [Serializable]
public class ArithmeticException : SystemException
{
// Creates a new ArithmeticException with its message string set to
// The ArrayMismatchException is thrown when an attempt to store
// an object of the wrong type within an array occurs.
//
- [Serializable]
public class ArrayTypeMismatchException : SystemException
{
// Creates a new ArrayMismatchException with its message string set to
namespace System
{
/* By default, attributes are inherited and multiple attributes are not allowed */
- [Serializable]
[AttributeUsage(AttributeTargets.Class, Inherited = true)]
public sealed class AttributeUsageAttribute : Attribute
{
namespace System
{
- [Serializable]
public partial class BadImageFormatException : SystemException
{
private String _fileName; // The name of the corrupt PE file.
namespace System
{
- [Serializable]
[AttributeUsage(AttributeTargets.All, Inherited = true, AllowMultiple = false)]
public sealed class CLSCompliantAttribute : Attribute
{
namespace System
{
- [Serializable]
public sealed class CharEnumerator : IEnumerator, IEnumerator<char>, IDisposable, ICloneable
{
private String _str;
namespace System.Collections.Generic
{
- [Serializable]
public class KeyNotFoundException : SystemException
{
public KeyNotFoundException()
namespace System
{
[Obsolete("System.CurrentSystemTimeZone has been deprecated. Please investigate the use of System.TimeZoneInfo.Local instead.")]
- [Serializable]
internal partial class CurrentSystemTimeZone : TimeZone
{
// Standard offset in ticks to the Universal time if
namespace System
{
- [Serializable]
public sealed class DBNull : ISerializable, IConvertible
{
private DBNull()
namespace System
{
- [Serializable]
public sealed class DataMisalignedException : SystemException
{
public DataMisalignedException()
namespace System
{
- //Marked serializable even though it has no state.
- [Serializable]
#if CORECLR
internal
#else
namespace System.Diagnostics
{
- [Serializable]
[AttributeUsage(AttributeTargets.Method | AttributeTargets.Class, AllowMultiple = true)]
public sealed class ConditionalAttribute : Attribute
{
/// <summary>
/// Exception that is thrown when an error occurs during EventSource operation.
/// </summary>
-#if !ES_BUILD_PCL
+#if !CORECLR && !ES_BUILD_PN && !ES_BUILD_PCL && !CORERT
[Serializable]
-#endif
+#endif // !CORECLR && !ES_BUILD_PN && !ES_BUILD_PCL && !CORERT
public class EventSourceException : Exception
{
/// <summary>
namespace System
{
- [Serializable]
public class DivideByZeroException : ArithmeticException
{
public DivideByZeroException()
namespace System
{
- [Serializable]
public class DllNotFoundException : TypeLoadException
{
public DllNotFoundException()
// The DuplicateWaitObjectException is thrown when an object
// appears more than once in the list of objects to WaitAll or WaitAny.
//
- [Serializable]
public class DuplicateWaitObjectException : ArgumentException
{
private static volatile String s_duplicateWaitObjectMessage = null;
namespace System
{
- [Serializable]
public class EntryPointNotFoundException : TypeLoadException
{
public EntryPointNotFoundException()
namespace System
{
// The base class for all event classes.
- [Serializable]
public class EventArgs
{
public static readonly EventArgs Empty = new EventArgs();
namespace System
{
[Obsolete("This type previously indicated an unspecified fatal error in the runtime. The runtime no longer raises this exception so this type is obsolete.")]
- [Serializable]
public sealed class ExecutionEngineException : SystemException
{
public ExecutionEngineException()
namespace System
{
- [Serializable]
public class FieldAccessException : MemberAccessException
{
public FieldAccessException()
// should be treated as a bitfield (or set of flags).
// An IDE may use this information to provide a richer
// development experience.
- [Serializable]
[AttributeUsage(AttributeTargets.Enum, Inherited = false)]
public class FlagsAttribute : Attribute
{
namespace System
{
- [Serializable]
public class FormatException : SystemException
{
public FormatException()
** ChineseLunisolar 1901/01/01 2100/12/29
*/
- [Serializable]
public class ChineseLunisolarCalendar : EastAsianLunisolarCalendar
{
//
namespace System.Globalization
{
- [Serializable]
public class CultureNotFoundException : ArgumentException
{
private string _invalidCultureName; // unrecognized culture name
}
- [Serializable]
public sealed class DateTimeFormatInfo : IFormatProvider, ICloneable
{
// cache for the invariant culture.
namespace System.Globalization
{
// This class represents a starting/ending time for a period of daylight saving time.
- [Serializable]
public class DaylightTime
{
private readonly DateTime _start;
namespace System.Globalization
{
- [Serializable]
public abstract class EastAsianLunisolarCalendar : Calendar
{
internal const int LeapMonth = 0;
// Gregorian to Hebrew Lunar from 1583 to 2239.
- [Serializable]
public class HebrewCalendar : Calendar
{
public static readonly int HebrewEra = 1;
** Hijri 0001/01/01 9666/04/03
*/
- [Serializable]
public partial class HijriCalendar : Calendar
{
public static readonly int HijriEra = 1;
============================================================================*/
- [Serializable]
public partial class JapaneseCalendar : Calendar
{
internal static readonly DateTime calendarMinValue = new DateTime(1868, 9, 8);
** JapaneseLunisolar 1960/01/01 2049/12/29
*/
- [Serializable]
public class JapaneseLunisolarCalendar : EastAsianLunisolarCalendar
{
//
//* Gregorian 0001/01/01 9999/12/31
//* Julia 0001/01/03 9999/10/19
- [Serializable]
public class JulianCalendar : Calendar
{
public static readonly int JulianEra = 1;
============================================================================*/
- [Serializable]
public class KoreanCalendar : Calendar
{
//
** KoreanLunisolar 918/01/01 2050/13/29
*/
- [Serializable]
public class KoreanLunisolarCalendar : EastAsianLunisolarCalendar
{
//
// CurrencySymbol "$" String used as local monetary symbol.
//
- [Serializable]
sealed public class NumberFormatInfo : IFormatProvider, ICloneable
{
// invariantInfo is constant irrespective of your current culture.
** Persian 0001/01/01 9378/10/13
*/
- [Serializable]
public class PersianCalendar : Calendar
{
public static readonly int PersianEra = 1;
namespace System.Globalization
{
- [Serializable]
public partial class SortKey
{
//--------------------------------------------------------------------//
namespace System.Globalization
{
- [Serializable]
public class StringInfo
{
[OptionalField(VersionAdded = 2)]
** Taiwan 01/01/01 8088/12/31
============================================================================*/
- [Serializable]
public class TaiwanCalendar : Calendar
{
//
** TaiwanLunisolar 1912/01/01 2050/13/29
*/
- [Serializable]
public class TaiwanLunisolarCalendar : EastAsianLunisolarCalendar
{
// Since
** Thai 0544/01/01 10542/12/31
============================================================================*/
- [Serializable]
public class ThaiBuddhistCalendar : Calendar
{
// Initialize our era info.
** UmAlQura 1318/01/01 1500/12/30
*/
- [Serializable]
public partial class UmAlQuraCalendar : Calendar
{
internal const int MinCalendarYear = 1318;
* the Win32 errorcode-as-HRESULT ERROR_PATH_NOT_FOUND (0x80070003)
* and STG_E_PATHNOTFOUND (0x80030003).
*/
- [Serializable]
public class DirectoryNotFoundException : IOException
{
public DirectoryNotFoundException()
namespace System.IO
{
- [Serializable]
public class EndOfStreamException : IOException
{
public EndOfStreamException()
namespace System.IO
{
- [Serializable]
public partial class FileLoadException : IOException
{
public FileLoadException()
namespace System.IO
{
// Thrown when trying to access a file that doesn't exist on disk.
- [Serializable]
public partial class FileNotFoundException : IOException
{
public FileNotFoundException()
namespace System.IO
{
- [Serializable]
public class PathTooLongException : IOException
{
public PathTooLongException()
namespace System
{
- [Serializable]
public sealed class IndexOutOfRangeException : SystemException
{
public IndexOutOfRangeException()
namespace System
{
- [Serializable]
public sealed class InsufficientExecutionStackException : SystemException
{
public InsufficientExecutionStackException()
namespace System
{
- [Serializable]
public class InvalidCastException : SystemException
{
public InvalidCastException()
namespace System
{
- [Serializable]
public class InvalidOperationException : SystemException
{
public InvalidOperationException()
namespace System
{
- [Serializable]
public sealed class InvalidProgramException : SystemException
{
public InvalidProgramException()
namespace System
{
- [Serializable]
public class InvalidTimeZoneException : Exception
{
public InvalidTimeZoneException()
namespace System
{
- [Serializable]
public abstract class MarshalByRefObject
{
protected MarshalByRefObject()
// The MemberAccessException is thrown when trying to access a class
// member fails.
//
- [Serializable]
public class MemberAccessException : SystemException
{
// Creates a new MemberAccessException with its message string set to
namespace System
{
- [Serializable]
public class MethodAccessException : MemberAccessException
{
public MethodAccessException()
namespace System
{
- [Serializable]
public class MissingMethodException : MissingMemberException
{
public MissingMethodException()
namespace System
{
- [Serializable]
public sealed class MulticastNotSupportedException : SystemException
{
public MulticastNotSupportedException()
namespace System
{
- [Serializable]
public class NotFiniteNumberException : ArithmeticException
{
private double _offendingNumber;
namespace System
{
- [Serializable]
public class NotImplementedException : SystemException
{
public NotImplementedException()
namespace System
{
- [Serializable]
public class NotSupportedException : SystemException
{
public NotSupportedException()
namespace System
{
- [Serializable]
public class NullReferenceException : SystemException
{
public NullReferenceException()
/// <para> The exception that is thrown when accessing an object that was
/// disposed.</para>
/// </devdoc>
- [Serializable]
public class ObjectDisposedException : InvalidOperationException
{
private String _objectName;
// error. (this would be used if the actual implementation of the obsolete
// method's implementation had changed).
//
- [Serializable]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum |
AttributeTargets.Interface | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Delegate
, Inherited = false)]
namespace System
{
- [Serializable]
public class OperationCanceledException : SystemException
{
[NonSerialized]
namespace System
{
- [Serializable]
public class OverflowException : ArithmeticException
{
public OverflowException()
namespace System
{
- [Serializable]
public class PlatformNotSupportedException : NotSupportedException
{
public PlatformNotSupportedException()
namespace System
{
- [Serializable]
public class Random
{
//
namespace System
{
- [Serializable]
public class RankException : SystemException
{
public RankException()
namespace System.Reflection
{
- [Serializable]
public sealed class AmbiguousMatchException : SystemException
{
public AmbiguousMatchException()
namespace System.Reflection
{
- [Serializable]
public class CustomAttributeFormatException : FormatException
{
public CustomAttributeFormatException()
namespace System.Reflection
{
- [Serializable]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Interface)]
public sealed class DefaultMemberAttribute : Attribute
{
namespace System.Reflection
{
- [Serializable]
public class InvalidFilterCriteriaException : ApplicationException
{
public InvalidFilterCriteriaException()
namespace System.Reflection
{
- [Serializable]
#if CORECLR
internal
#else
namespace System.Reflection
{
- [Serializable]
public sealed class Missing : ISerializable
{
public static readonly Missing Value = new Missing();
namespace System.Reflection
{
- [Serializable]
public struct ParameterModifier
{
private readonly bool[] _byRef;
namespace System.Reflection
{
- [Serializable]
[CLSCompliant(false)]
public sealed unsafe class Pointer : ISerializable
{
namespace System.Reflection
{
- [Serializable]
public sealed class ReflectionTypeLoadException : SystemException, ISerializable
{
public ReflectionTypeLoadException(Type[] classes, Exception[] exceptions)
namespace System.Reflection
{
- [Serializable]
public class StrongNameKeyPair : IDeserializationCallback, ISerializable
{
private bool _keyPairExported;
namespace System.Reflection
{
- [Serializable]
public class TargetException : ApplicationException
{
public TargetException()
namespace System.Reflection
{
- [Serializable]
public sealed class TargetInvocationException : ApplicationException
{
public TargetInvocationException(Exception inner)
namespace System.Reflection
{
- [Serializable]
public sealed class TargetParameterCountException : ApplicationException
{
public TargetParameterCountException()
namespace System.Reflection
{
- [Serializable]
public class TypeDelegator : TypeInfo
{
public override bool IsAssignableFrom(TypeInfo typeInfo)
namespace System.Resources
{
- [Serializable]
public class MissingManifestResourceException : SystemException
{
public MissingManifestResourceException()
namespace System.Resources
{
- [Serializable]
public class MissingSatelliteAssemblyException : SystemException
{
private String _cultureName;
namespace System.Runtime.CompilerServices
{
- [Serializable]
[AttributeUsage(AttributeTargets.Method, Inherited = false, AllowMultiple = false)]
public sealed class AsyncStateMachineAttribute : StateMachineAttribute
{
namespace System.Runtime.CompilerServices
{
- [Serializable]
[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Method)]
public class CompilationRelaxationsAttribute : Attribute
{
namespace System.Runtime.CompilerServices
{
- [Serializable]
[AttributeUsage(AttributeTargets.All, Inherited = true)]
public sealed class CompilerGeneratedAttribute : Attribute
{
{
// Attribute used to communicate to the VS7 debugger that a class should be treated as if it has global scope.
- [Serializable]
[AttributeUsage(AttributeTargets.Class)]
public class CompilerGlobalScopeAttribute : Attribute
{
namespace System.Runtime.CompilerServices
{
- [Serializable]
[AttributeUsage(AttributeTargets.Assembly)]
public sealed class DefaultDependencyAttribute : Attribute
{
namespace System.Runtime.CompilerServices
{
- [Serializable]
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
public sealed class DependencyAttribute : Attribute
{
namespace System.Runtime.CompilerServices
{
- [Serializable]
[AttributeUsage(AttributeTargets.Field)]
public sealed class FixedAddressValueTypeAttribute : Attribute
{
namespace System.Runtime.CompilerServices
{
- [Serializable]
[AttributeUsage(AttributeTargets.Property, Inherited = true)]
public sealed class IndexerNameAttribute : Attribute
{
namespace System.Runtime.CompilerServices
{
- [Serializable]
[AttributeUsage(AttributeTargets.Method, Inherited = false, AllowMultiple = false)]
public sealed class IteratorStateMachineAttribute : StateMachineAttribute
{
namespace System.Runtime.CompilerServices
{
- [Serializable]
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = false)]
public sealed class ReferenceAssemblyAttribute : Attribute
{
namespace System.Runtime.CompilerServices
{
- [Serializable]
[AttributeUsage(AttributeTargets.Assembly, Inherited = false, AllowMultiple = false)]
public sealed class RuntimeCompatibilityAttribute : Attribute
{
namespace System.Runtime.CompilerServices
{
- [Serializable]
[AttributeUsage(AttributeTargets.Method, Inherited = false, AllowMultiple = false)]
public class StateMachineAttribute : Attribute
{
{
// Custom attribute to indicate that strings should be frozen.
- [Serializable]
[AttributeUsage(AttributeTargets.Assembly, Inherited = false)]
public sealed class StringFreezingAttribute : Attribute
{
namespace System.Runtime.CompilerServices
{
- [Serializable]
[AttributeUsage(AttributeTargets.Struct)]
sealed public class UnsafeValueTypeAttribute : Attribute
{
// Base exception for COM Interop errors &; Structured Exception Handler
// exceptions.
//
- [Serializable]
public class ExternalException : SystemException
{
public ExternalException()
namespace System.Runtime.Serialization
{
- [Serializable]
public class SerializationException : SystemException
{
private static String s_nullMessage = SR.SerializationException;
namespace System.Runtime.Serialization
{
- [Serializable]
public struct StreamingContext
{
private readonly object _additionalContext;
namespace System.Security.Cryptography
{
- [Serializable]
public class CryptographicException : SystemException
{
public CryptographicException()
namespace System.Security
{
- [Serializable]
public class SecurityException : SystemException
{
public SecurityException()
namespace System.Security
{
- [Serializable]
public class VerificationException : SystemException
{
public VerificationException()
namespace System
{
- [Serializable]
public sealed class StackOverflowException : SystemException
{
public StackOverflowException()
namespace System
{
- [Serializable]
public class SystemException : Exception
{
public SystemException()
// Note: IsAlwaysNormalized remains false because 1/2 the code points are unassigned, so they'd
// use fallbacks, and we cannot guarantee that fallbacks are normalized.
- [Serializable]
public class ASCIIEncoding : Encoding
{
// Allow for devirtualization (see https://github.com/dotnet/coreclr/pull/9230)
- [Serializable]
internal sealed class ASCIIEncodingSealed : ASCIIEncoding { }
// Used by Encoding.ASCII for lazy initialization
// class are typically obtained through calls to the GetDecoder method
// of Encoding objects.
//
- [Serializable]
public abstract class Decoder
{
internal DecoderFallback m_fallback = null;
// class are typically obtained through calls to the GetEncoder method
// of Encoding objects.
//
- [Serializable]
public abstract class Encoder
{
internal EncoderFallback m_fallback = null;
namespace System.Text
{
- [Serializable]
public sealed class EncodingInfo
{
private int iCodePage; // Code Page #
// So if you change the wrappers in this class, you must change the wrappers in the other classes
// as well because they should have the same behavior.
- [Serializable]
internal abstract class EncodingNLS : Encoding
{
protected EncodingNLS(int codePage) : base(codePage)
// mark is used mostly to distinguish UTF-32 text from other encodings, and doesn't
// switch the byte orderings.
- [Serializable]
public sealed class UTF32Encoding : Encoding
{
/*
CodePage + (_emitUTF32ByteOrderMark ? 4 : 0) + (_bigEndian ? 8 : 0);
}
- [Serializable]
private sealed class UTF32Decoder : DecoderNLS
{
// Need a place to store any extra bytes we may have picked up
// used mostly to distinguish UTF-8 text from other encodings, and doesn't
// switch the byte orderings.
- [Serializable]
public class UTF8Encoding : Encoding
{
/*
private const int UTF8_CODEPAGE = 65001;
// Allow for devirtualization (see https://github.com/dotnet/coreclr/pull/9230)
- [Serializable]
internal sealed class UTF8EncodingSealed : UTF8Encoding
{
public UTF8EncodingSealed(bool encoderShouldEmitUTF8Identifier) : base(encoderShouldEmitUTF8Identifier) { }
UTF8_CODEPAGE + (_emitUTF8Identifier ? 1 : 0);
}
- [Serializable]
private sealed class UTF8Encoder : EncoderNLS, ISerializable
{
// We must save a high surrogate value until the next call, looking
}
}
- [Serializable]
private sealed class UTF8Decoder : DecoderNLS, ISerializable
{
// We'll need to remember the previous information. See the comments around definition
namespace System.Text
{
- [Serializable]
public class UnicodeEncoding : Encoding
{
// Used by Encoding.BigEndianUnicode/Unicode for lazy initialization
(byteOrderMark ? 4 : 0) + (bigEndian ? 8 : 0);
}
- [Serializable]
private sealed class Decoder : System.Text.DecoderNLS, ISerializable
{
internal int lastByte = -1;
namespace System
{
- [Serializable]
[AttributeUsage(AttributeTargets.Field, Inherited = false)]
public class ThreadStaticAttribute : Attribute
{
namespace System.Threading
{
- [Serializable]
public class AbandonedMutexException : SystemException
{
private int _mutexIndex = -1;
}
}
- [Serializable]
public sealed class ExecutionContext : IDisposable, ISerializable
{
internal static readonly ExecutionContext Default = new ExecutionContext();
namespace System.Threading
{
- [Serializable]
public class LockRecursionException : System.Exception
{
public LockRecursionException()
namespace System.Threading
{
- [Serializable]
public class SemaphoreFullException : SystemException
{
public SemaphoreFullException() : base(SR.Threading_SemaphoreFullException)
namespace System.Threading
{
- [Serializable]
public class SynchronizationLockException : SystemException
{
public SynchronizationLockException()
/// <summary>
/// Represents an exception used to communicate task cancellation.
/// </summary>
- [Serializable]
public class TaskCanceledException : OperationCanceledException
{
[NonSerialized]
/// Represents an exception used to communicate an invalid operation by a
/// <see cref="T:System.Threading.Tasks.TaskScheduler"/>.
/// </summary>
- [Serializable]
public class TaskSchedulerException : Exception
{
/// <summary>
namespace System.Threading
{
- [Serializable]
public sealed class ThreadAbortException : SystemException
{
private ThreadAbortException()
namespace System.Threading
{
- [Serializable]
public sealed class ThreadStartException : SystemException
{
internal ThreadStartException()
namespace System.Threading
{
- [Serializable]
public class ThreadStateException : SystemException
{
public ThreadStateException()
namespace System.Threading
{
- [Serializable]
public class WaitHandleCannotBeOpenedException : ApplicationException
{
public WaitHandleCannotBeOpenedException() : base(SR.Threading_WaitHandleCannotBeOpenedException)
namespace System
{
- [Serializable]
public class TimeZoneNotFoundException : Exception
{
public TimeZoneNotFoundException()
namespace System
{
- [Serializable]
public class TimeoutException : SystemException
{
public TimeoutException()
{
// TypeAccessException derives from TypeLoadException rather than MemberAccessException because in
// pre-v4 releases of the runtime TypeLoadException was used in lieu of a TypeAccessException.
- [Serializable]
public class TypeAccessException : TypeLoadException
{
public TypeAccessException()
namespace System
{
- [Serializable]
public sealed class TypeInitializationException : SystemException
{
private String _typeName;
namespace System
{
- [Serializable]
public class TypeUnloadedException : SystemException
{
public TypeUnloadedException()
{
// The UnauthorizedAccessException is thrown when access errors
// occur from IO or other OS methods.
- [Serializable]
public class UnauthorizedAccessException : SystemException
{
public UnauthorizedAccessException()
namespace System
{
- [Serializable]
public class UnhandledExceptionEventArgs : EventArgs
{
private Object _exception;
namespace System
{
- [Serializable]
// Holds classes (Empty, Null, Missing) for which we guarantee that there is only ever one instance of.
#if CORECLR
internal
namespace System
{
// This class represents the void return type
- [Serializable]
public struct Void
{
}
internal int bInheritHandle = 0;
}
- [Serializable]
[StructLayout(LayoutKind.Sequential)]
internal struct WIN32_FILE_ATTRIBUTE_DATA
{
}
// Win32 Structs in N/Direct style
- [Serializable]
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
[BestFitMapping(false)]
internal class WIN32_FIND_DATA
namespace System
{
- [Serializable]
public class AccessViolationException : SystemException
{
public AccessViolationException()
using System.Diagnostics.Contracts;
using System.Collections.Generic;
- [Serializable]
internal sealed class AppDomainSetup
{
internal enum LoaderInformation
namespace System
{
- [Serializable]
internal class AppDomainUnloadedException : SystemException
{
public AppDomainUnloadedException()
}
}
- [Serializable]
private sealed class SZArrayEnumerator : IEnumerator, ICloneable
{
private Array _array;
}
}
- [Serializable]
private sealed class ArrayEnumerator : IEnumerator, ICloneable
{
private Array array;
// This is a normal generic Enumerator for SZ arrays. It doesn't have any of the "this" stuff
// that SZArrayHelper does.
//
- [Serializable]
private sealed class SZGenericArrayEnumerator<T> : IEnumerator<T>
{
private T[] _array;
}
}
- [Serializable]
public struct Enumerator : IEnumerator<T>
{
private readonly T[] _array;
namespace System.Collections
{
- [Serializable]
internal sealed class Comparer : IComparer, ISerializable
{
private CompareInfo m_compareInfo;
namespace System.Collections
{
- [Serializable]
internal class CompatibleComparer : IEqualityComparer
{
private IComparer _comparer;
/// </remarks>
[DebuggerDisplay("Count = {Count}")]
[DebuggerTypeProxy(typeof(SystemCollectionsConcurrent_ProducerConsumerCollectionDebugView<>))]
- [Serializable]
internal class ConcurrentQueue<T> : IProducerConsumerCollection<T>, IReadOnlyCollection<T>
{
// This implementation provides an unbounded, multi-producer multi-consumer queue
namespace System.Collections
{
/// This is a simple implementation of IDictionary that is empty and readonly.
- [Serializable]
internal sealed class EmptyReadOnlyDictionaryInternal : IDictionary
{
// Note that this class must be agile with respect to AppDomains. See its usage in
}
}
- [Serializable()]
internal class GenericArraySortHelper<T>
: IArraySortHelper<T>
where T : IComparable<T>
// reasons. Adding another base class (even one with no fields)
// means another generic instantiation, which can be costly esp.
// for value types.
-
[Serializable]
internal sealed class GenericComparer<T> : Comparer<T> where T : IComparable<T>
{
GetType().GetHashCode();
}
- [Serializable]
internal sealed class ComparisonComparer<T> : Comparer<T>
{
private readonly Comparison<T> _comparison;
// and have a SerializationInfo/StreamingContext ctor,
// since we want to serialize as ObjectComparer for
// back-compat reasons (see below).
-
[Serializable]
internal sealed class Int32EnumComparer<T> : Comparer<T>, ISerializable where T : struct
{
}
}
- [Serializable]
public struct Enumerator : IEnumerator<KeyValuePair<TKey, TValue>>,
IDictionaryEnumerator
{
[DebuggerTypeProxy(typeof(Mscorlib_DictionaryKeyCollectionDebugView<,>))]
[DebuggerDisplay("Count = {Count}")]
- [Serializable]
public sealed class KeyCollection : ICollection<TKey>, ICollection, IReadOnlyCollection<TKey>
{
private Dictionary<TKey, TValue> dictionary;
get { return ((ICollection)dictionary).SyncRoot; }
}
- [Serializable]
public struct Enumerator : IEnumerator<TKey>, System.Collections.IEnumerator
{
private Dictionary<TKey, TValue> dictionary;
[DebuggerTypeProxy(typeof(Mscorlib_DictionaryValueCollectionDebugView<,>))]
[DebuggerDisplay("Count = {Count}")]
- [Serializable]
public sealed class ValueCollection : ICollection<TValue>, ICollection, IReadOnlyCollection<TValue>
{
private Dictionary<TKey, TValue> dictionary;
get { return ((ICollection)dictionary).SyncRoot; }
}
- [Serializable]
public struct Enumerator : IEnumerator<TValue>, System.Collections.IEnumerator
{
private Dictionary<TKey, TValue> dictionary;
}
}
- [Serializable]
public struct Enumerator : IEnumerator<T>, System.Collections.IEnumerator
{
private List<T> list;
//
[DebuggerTypeProxy(typeof(System.Collections.Hashtable.HashtableDebugView))]
[DebuggerDisplay("Count = {Count}")]
- [Serializable]
internal class Hashtable : IDictionary, ISerializable, IDeserializationCallback, ICloneable
{
/*
// Implements a Collection for the keys of a hashtable. An instance of this
// class is created by the GetKeys method of a hashtable.
- [Serializable]
private class KeyCollection : ICollection
{
private Hashtable _hashtable;
// Implements a Collection for the values of a hashtable. An instance of
// this class is created by the GetValues method of a hashtable.
- [Serializable]
private class ValueCollection : ICollection
{
private Hashtable _hashtable;
}
// Synchronized wrapper for hashtable
- [Serializable]
private class SyncHashtable : Hashtable, IEnumerable
{
protected Hashtable _table;
// Implements an enumerator for a hashtable. The enumerator uses the
// internal version number of the hashtabke to ensure that no modifications
// are made to the hashtable while an enumeration is in progress.
- [Serializable]
private class HashtableEnumerator : IDictionaryEnumerator, ICloneable
{
private Hashtable hashtable;
namespace System.Collections.ObjectModel
{
- [Serializable]
[DebuggerTypeProxy(typeof(Mscorlib_DictionaryDebugView<,>))]
[DebuggerDisplay("Count = {Count}")]
internal class ReadOnlyDictionary<TKey, TValue> : IDictionary<TKey, TValue>, IDictionary, IReadOnlyDictionary<TKey, TValue>
}
}
- [Serializable]
private struct DictionaryEnumerator : IDictionaryEnumerator
{
private readonly IDictionary<TKey, TValue> m_dictionary;
[DebuggerTypeProxy(typeof(Mscorlib_CollectionDebugView<>))]
[DebuggerDisplay("Count = {Count}")]
- [Serializable]
public sealed class KeyCollection : ICollection<TKey>, ICollection, IReadOnlyCollection<TKey>
{
private readonly ICollection<TKey> m_collection;
[DebuggerTypeProxy(typeof(Mscorlib_CollectionDebugView<>))]
[DebuggerDisplay("Count = {Count}")]
- [Serializable]
public sealed class ValueCollection : ICollection<TValue>, ICollection, IReadOnlyCollection<TValue>
{
private readonly ICollection<TValue> m_collection;
namespace System
{
- [Serializable]
internal struct Currency
{
internal long m_value;
using System.Diagnostics;
using System.Diagnostics.Contracts;
- [Serializable]
[ClassInterface(ClassInterfaceType.AutoDual)]
[System.Runtime.InteropServices.ComVisible(true)]
public abstract class Delegate : ICloneable, ISerializable
+++ /dev/null
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-
-using System;
-using System.Reflection;
-using System.Runtime.Serialization;
-using System.Globalization;
-using System.Diagnostics.Contracts;
-
-namespace System
-{
- [Serializable]
- internal sealed class DelegateSerializationHolder : IObjectReference, ISerializable
- {
- #region Static Members
- internal static DelegateEntry GetDelegateSerializationInfo(
- SerializationInfo info, Type delegateType, Object target, MethodInfo method, int targetIndex)
- {
- // Used for MulticastDelegate
-
- if (method == null)
- throw new ArgumentNullException(nameof(method));
- Contract.EndContractBlock();
-
- Type c = delegateType.BaseType;
-
- if (c == null || (c != typeof(Delegate) && c != typeof(MulticastDelegate)))
- throw new ArgumentException(SR.Arg_MustBeDelegate, "type");
-
- if (method.DeclaringType == null)
- throw new NotSupportedException(SR.NotSupported_GlobalMethodSerialization);
-
- DelegateEntry de = new DelegateEntry(delegateType.FullName, delegateType.Module.Assembly.FullName, target,
- method.ReflectedType.Module.Assembly.FullName, method.ReflectedType.FullName, method.Name);
-
- if (info.MemberCount == 0)
- {
- info.SetType(typeof(DelegateSerializationHolder));
- info.AddValue("Delegate", de, typeof(DelegateEntry));
- }
-
- // target can be an object so it needs to be added to the info, or else a fixup is needed
- // when deserializing, and the fixup will occur too late. If it is added directly to the
- // info then the rules of deserialization will guarantee that it will be available when
- // needed
-
- if (target != null)
- {
- String targetName = "target" + targetIndex;
- info.AddValue(targetName, de.target);
- de.target = targetName;
- }
-
- // Due to a number of additions (delegate signature binding relaxation, delegates with open this or closed over the
- // first parameter and delegates over generic methods) we need to send a deal more information than previously. We can
- // get this by serializing the target MethodInfo. We still need to send the same information as before though (the
- // DelegateEntry above) for backwards compatibility. And we want to send the MethodInfo (which is serialized via an
- // ISerializable holder) as a top-level child of the info for the same reason as the target above -- we wouldn't have an
- // order of deserialization guarantee otherwise.
- String methodInfoName = "method" + targetIndex;
- info.AddValue(methodInfoName, method);
-
- return de;
- }
- #endregion
-
- #region Definitions
- [Serializable]
- internal class DelegateEntry
- {
- #region Internal Data Members
- internal String type;
- internal String assembly;
- internal Object target;
- internal String targetTypeAssembly;
- internal String targetTypeName;
- internal String methodName;
- internal DelegateEntry delegateEntry;
- #endregion
-
- #region Constructor
- internal DelegateEntry(
- String type, String assembly, Object target, String targetTypeAssembly, String targetTypeName, String methodName)
- {
- this.type = type;
- this.assembly = assembly;
- this.target = target;
- this.targetTypeAssembly = targetTypeAssembly;
- this.targetTypeName = targetTypeName;
- this.methodName = methodName;
- }
- #endregion
-
- #region Internal Members
- internal DelegateEntry Entry
- {
- get { return delegateEntry; }
- set { delegateEntry = value; }
- }
- #endregion
- }
-
- #endregion
-
- #region Private Data Members
- private DelegateEntry m_delegateEntry;
- private MethodInfo[] m_methods;
- #endregion
-
- #region Constructor
- private DelegateSerializationHolder(SerializationInfo info, StreamingContext context)
- {
- if (info == null)
- throw new ArgumentNullException(nameof(info));
- Contract.EndContractBlock();
-
- bool bNewWire = true;
-
- try
- {
- m_delegateEntry = (DelegateEntry)info.GetValue("Delegate", typeof(DelegateEntry));
- }
- catch
- {
- // Old wire format
- m_delegateEntry = OldDelegateWireFormat(info, context);
- bNewWire = false;
- }
-
- if (bNewWire)
- {
- // retrieve the targets
- DelegateEntry deiter = m_delegateEntry;
- int count = 0;
- while (deiter != null)
- {
- if (deiter.target != null)
- {
- string stringTarget = deiter.target as string; //need test to pass older wire format
- if (stringTarget != null)
- deiter.target = info.GetValue(stringTarget, typeof(Object));
- }
- count++;
- deiter = deiter.delegateEntry;
- }
-
- // If the sender is as recent as us they'll have provided MethodInfos for each delegate. Look for these and pack
- // them into an ordered array if present.
- MethodInfo[] methods = new MethodInfo[count];
- int i;
- for (i = 0; i < count; i++)
- {
- String methodInfoName = "method" + i;
- methods[i] = (MethodInfo)info.GetValueNoThrow(methodInfoName, typeof(MethodInfo));
- if (methods[i] == null)
- break;
- }
-
- // If we got the info then make the array available for deserialization.
- if (i == count)
- m_methods = methods;
- }
- }
- #endregion
-
- #region Private Members
- private void ThrowInsufficientState(string field)
- {
- throw new SerializationException(
- SR.Format(SR.Serialization_InsufficientDeserializationState, field));
- }
-
- private DelegateEntry OldDelegateWireFormat(SerializationInfo info, StreamingContext context)
- {
- if (info == null)
- throw new ArgumentNullException(nameof(info));
- Contract.EndContractBlock();
-
- String delegateType = info.GetString("DelegateType");
- String delegateAssembly = info.GetString("DelegateAssembly");
- Object target = info.GetValue("Target", typeof(Object));
- String targetTypeAssembly = info.GetString("TargetTypeAssembly");
- String targetTypeName = info.GetString("TargetTypeName");
- String methodName = info.GetString("MethodName");
-
- return new DelegateEntry(delegateType, delegateAssembly, target, targetTypeAssembly, targetTypeName, methodName);
- }
-
- private Delegate GetDelegate(DelegateEntry de, int index)
- {
- Delegate d;
-
- try
- {
- if (de.methodName == null || de.methodName.Length == 0)
- ThrowInsufficientState("MethodName");
-
- if (de.assembly == null || de.assembly.Length == 0)
- ThrowInsufficientState("DelegateAssembly");
-
- if (de.targetTypeName == null || de.targetTypeName.Length == 0)
- ThrowInsufficientState("TargetTypeName");
-
- // We cannot use Type.GetType directly, because of AppCompat - assembly names starting with '[' would fail to load.
- RuntimeType type = (RuntimeType)Assembly.GetType_Compat(de.assembly, de.type);
-
- // {de.targetTypeAssembly, de.targetTypeName} do not actually refer to the type of the target, but the reflected
- // type of the method. Those types may be the same when the method is on the target's type or on a type in its
- // inheritance chain, but those types may not be the same when the method is an extension method for the
- // target's type or a type in its inheritance chain.
-
- // If we received the new style delegate encoding we already have the target MethodInfo in hand.
- if (m_methods != null)
- {
- // The method info is serialized, so the target type info is redundant. The desktop framework does no
- // additional verification on the target type info.
- d = Delegate.CreateDelegateNoSecurityCheck(type, de.target, m_methods[index]);
- }
- else
- {
- if (de.target != null)
- {
- // For consistency with the desktop framework, when the method info is not serialized for a closed
- // delegate, the method is assumed to be on the target's type or in its inheritance chain. An extension
- // method would not work on this path for the above reason and also because the delegate binds to
- // instance methods only. The desktop framework does no additional verification on the target type info.
- d = Delegate.CreateDelegate(type, de.target, de.methodName);
- }
- else
- {
- RuntimeType targetType = (RuntimeType)Assembly.GetType_Compat(de.targetTypeAssembly, de.targetTypeName);
- d = Delegate.CreateDelegate(type, targetType, de.methodName);
- }
- }
- }
- catch (Exception e)
- {
- if (e is SerializationException)
- throw e;
-
- throw new SerializationException(e.Message, e);
- }
-
- return d;
- }
- #endregion
-
- #region IObjectReference
- public Object GetRealObject(StreamingContext context)
- {
- int count = 0;
- for (DelegateEntry de = m_delegateEntry; de != null; de = de.Entry)
- count++;
-
- int maxindex = count - 1;
-
- if (count == 1)
- {
- return GetDelegate(m_delegateEntry, 0);
- }
- else
- {
- object[] invocationList = new object[count];
-
- for (DelegateEntry de = m_delegateEntry; de != null; de = de.Entry)
- {
- // Be careful to match the index we pass to GetDelegate (used to look up extra information for each delegate) to
- // the order we process the entries: we're actually looking at them in reverse order.
- --count;
- invocationList[count] = GetDelegate(de, maxindex - count);
- }
- return ((MulticastDelegate)invocationList[0]).NewMulticastDelegate(invocationList, invocationList.Length);
- }
- }
- #endregion
-
- #region ISerializable
- public void GetObjectData(SerializationInfo info, StreamingContext context)
- {
- throw new NotSupportedException(SR.NotSupported_DelegateSerHolderSerial);
- }
- #endregion
- }
-}
//
// The default filter brings up a simple Win32 dialog with 3 buttons.
- [Serializable]
abstract internal class AssertFilter
{
// Called when an assert fails. This should be overridden with logic which
}
}
- [Serializable]
[SuppressMessage("Microsoft.Design", "CA1064:ExceptionsShouldBePublic")]
internal sealed class ContractException : Exception
{
namespace System.Diagnostics
{
- [Serializable]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Constructor, Inherited = false)]
public sealed class DebuggerStepThroughAttribute : Attribute
{
public DebuggerStepThroughAttribute() { }
}
- [Serializable]
[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Constructor, Inherited = false)]
public sealed class DebuggerHiddenAttribute : Attribute
{
public DebuggerHiddenAttribute() { }
}
- [Serializable]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Constructor | AttributeTargets.Struct, Inherited = false)]
public sealed class DebuggerNonUserCodeAttribute : Attribute
{
namespace System.Diagnostics
{
- [Serializable]
internal sealed class EditAndContinueHelper
{
#pragma warning disable 169
namespace System.Diagnostics
{
- [Serializable]
internal class LogSwitch
{
// ! WARNING !
namespace System.Diagnostics
{
// There is no good reason for the methods of this class to be virtual.
- [Serializable]
public class StackFrame
{
private MethodBase method;
// Modifying the order or fields of this object may require other changes
// to the unmanaged definition of the StackFrameHelper class, in
// VM\DebugDebugger.h. The binder will catch some of these layout problems.
- [Serializable]
internal class StackFrameHelper : IDisposable
{
[NonSerialized]
// In order to ensure trusted code can trust the data it gets from a
// StackTrace, we use an InheritanceDemand to prevent partially-trusted
// subclasses.
- [Serializable]
public class StackTrace
{
private StackFrame[] frames;
namespace System
{
- [Serializable]
internal sealed class Empty : ISerializable
{
private Empty()
// The calculation of hour/minute/second is moved to Calendar from GregorianCalendar,
// since most of the calendars (or all?) have the same way of calcuating hour/minute/second.
- [Serializable]
public abstract partial class Calendar : ICloneable
{
// Number of 100ns (10E-7 second) ticks per time unit
using StringLcidDictionary = LowLevelDictionary<int, CultureInfo>;
#endif
- [Serializable]
public partial class CultureInfo : IFormatProvider, ICloneable
{
//--------------------------------------------------------------------//
namespace System.Globalization
{
- [Serializable]
internal class CodePageDataItem
{
private readonly int _codePage;
// immediately because they don't require creating an object. Creating any of the string
// names is delayed until somebody actually asks for them and the names are then cached.
- [Serializable]
internal class CodePageDataItem
{
internal int m_dataIndex;
// This calendar recognizes two era values:
// 0 CurrentEra (AD)
// 1 BeforeCurrentEra (BC)
-
- [Serializable]
-
public class GregorianCalendar : Calendar
{
/*
namespace System.Globalization
{
// Gregorian Calendars use Era Info
- [Serializable]
internal class EraInfo
{
internal int era; // The value of the era.
// This calendar recognizes two era values:
// 0 CurrentEra (AD)
// 1 BeforeCurrentEra (BC)
- [Serializable]
internal class GregorianCalendarHelper
{
// 1 tick = 100ns = 10E-7 second
namespace System.Globalization
{
- [Serializable]
public class RegionInfo
{
//--------------------------------------------------------------------//
// This is public because GetTextElement() is public.
//
- [Serializable]
public class TextElementEnumerator : IEnumerator
{
private String _str;
namespace System.Globalization
{
- [Serializable]
public partial class TextInfo : ICloneable, IDeserializationCallback
{
////--------------------------------------------------------------------//
// primitives to an arbitrary stream. A subclass can override methods to
// give unique encodings.
//
- [Serializable]
public class BinaryWriter : IDisposable
{
public static readonly BinaryWriter Null = new BinaryWriter();
namespace System.IO
{
//Thrown when trying to access a drive that is not availabe.
- [Serializable]
internal class DriveNotFoundException : IOException
{
public DriveNotFoundException()
namespace System.IO
{
- [Serializable]
public class IOException : SystemException
{
// For debugging purposes, store the complete path in the IOException
// from an unsigned byte array, or you can create an empty one. Empty
// memory streams are resizable, while ones created with a byte array provide
// a stream "view" of the data.
- [Serializable]
public class MemoryStream : Stream
{
private byte[] _buffer; // Either allocated internally or externally.
namespace System.IO
{
- [Serializable]
public abstract class Stream : MarshalByRefObject, IDisposable
{
public static readonly Stream Null = new NullStream();
SynchronousAsyncResult.EndWrite(asyncResult);
}
- [Serializable]
private sealed class NullStream : Stream
{
internal NullStream() { }
// SyncStream is a wrapper around a stream that takes
// a lock for every operation making it thread safe.
- [Serializable]
internal sealed class SyncStream : Stream, IDisposable
{
private Stream _stream;
// This is designed for character input in a particular Encoding,
// whereas the Stream class is designed for byte input and output.
//
- [Serializable]
internal class StreamReader : TextReader
{
// StreamReader.Null is threadsafe.
//
// This class is intended for character input, not bytes.
// There are methods on the Stream class for reading bytes.
- [Serializable]
internal abstract class TextReader : MarshalByRefObject, IDisposable {
public static readonly TextReader Null = new NullTextReader();
return new SyncTextReader(reader);
}
- [Serializable]
private sealed class NullTextReader : TextReader
{
public NullTextReader(){}
}
}
- [Serializable]
internal sealed class SyncTextReader : TextReader
{
internal TextReader _in;
namespace System
{
- [Serializable]
public sealed class InsufficientMemoryException : OutOfMemoryException
{
public InsufficientMemoryException()
namespace System
{
- [Serializable]
public class MissingFieldException : MissingMemberException, ISerializable
{
public MissingFieldException()
namespace System
{
- [Serializable]
public class MissingMemberException : MemberAccessException, ISerializable
{
public MissingMemberException()
namespace System
{
- [Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public abstract class MulticastDelegate : Delegate
{
public override void GetObjectData(SerializationInfo info, StreamingContext context)
{
- int targetIndex = 0;
- Object[] invocationList = _invocationList as Object[];
- if (invocationList == null)
- {
- MethodInfo method = Method;
- // A MethodInfo object can be a RuntimeMethodInfo, a RefEmit method (MethodBuilder, etc), or a DynamicMethod
- // One can only create delegates on RuntimeMethodInfo and DynamicMethod.
- // If it is not a RuntimeMethodInfo (must be a DynamicMethod) or if it is an unmanaged function pointer, throw
- if (!(method is RuntimeMethodInfo) || IsUnmanagedFunctionPtr())
- throw new SerializationException(SR.Serialization_InvalidDelegateType);
-
- // We can't deal with secure delegates either.
- if (!InvocationListLogicallyNull() && !_invocationCount.IsNull() && !_methodPtrAux.IsNull())
- throw new SerializationException(SR.Serialization_InvalidDelegateType);
-
- DelegateSerializationHolder.GetDelegateSerializationInfo(info, this.GetType(), Target, method, targetIndex);
- }
- else
- {
- DelegateSerializationHolder.DelegateEntry nextDe = null;
- int invocationCount = (int)_invocationCount;
- for (int i = invocationCount; --i >= 0;)
- {
- MulticastDelegate d = (MulticastDelegate)invocationList[i];
- MethodInfo method = d.Method;
- // If it is not a RuntimeMethodInfo (must be a DynamicMethod) or if it is an unmanaged function pointer, skip
- if (!(method is RuntimeMethodInfo) || IsUnmanagedFunctionPtr())
- continue;
-
- // We can't deal with secure delegates either.
- if (!d.InvocationListLogicallyNull() && !d._invocationCount.IsNull() && !d._methodPtrAux.IsNull())
- continue;
-
- DelegateSerializationHolder.DelegateEntry de = DelegateSerializationHolder.GetDelegateSerializationInfo(info, d.GetType(), d.Target, method, targetIndex++);
- if (nextDe != null)
- nextDe.Entry = de;
-
- nextDe = de;
- }
- // if nothing was serialized it is a delegate over a DynamicMethod, so just throw
- if (nextDe == null)
- throw new SerializationException(SR.Serialization_InvalidDelegateType);
- }
+ throw new SerializationException(SR.Serialization_DelegatesNotSupported);
}
// equals returns true IIF the delegate is not null and has the
// The name "__Canon" will never been seen by users but it will appear a lot in debugger stack traces
// involving generics so it is kept deliberately short as to avoid being a nuisance.
- [Serializable]
[ClassInterface(ClassInterfaceType.AutoDual)]
[System.Runtime.InteropServices.ComVisible(true)]
internal class __Canon
using CultureInfo = System.Globalization.CultureInfo;
// Made serializable in anticipation of this class eventually having state.
- [Serializable]
internal class OleAutBinder : DefaultBinder
{
// ChangeType
namespace System
{
- [Serializable]
public class OutOfMemoryException : SystemException
{
public OutOfMemoryException()
using System.Diagnostics.Contracts;
using System.Text;
- [Serializable]
public sealed class AssemblyName : ICloneable, ISerializable, IDeserializationCallback
{
//
namespace System.Reflection
{
- [Serializable]
public class CustomAttributeData
{
#region Public Static Members
#endregion
}
- [Serializable]
public struct CustomAttributeNamedArgument
{
#region Public Static Members
}
- [Serializable]
public struct CustomAttributeTypedArgument
{
#region Public Static Members
#endregion
}
- [Serializable]
internal struct CustomAttributeRecord
{
internal ConstArray blob;
Enum = 0x55
}
- [Serializable]
[StructLayout(LayoutKind.Auto)]
internal struct CustomAttributeEncodedArgument
{
#endregion
}
- [Serializable]
[StructLayout(LayoutKind.Auto)]
internal struct CustomAttributeNamedParameter
{
#endregion
}
- [Serializable]
[StructLayout(LayoutKind.Auto)]
internal struct CustomAttributeCtorParameter
{
#endregion
}
- [Serializable]
[StructLayout(LayoutKind.Auto)]
internal struct CustomAttributeType
{
namespace System.Reflection.Emit
{
- [Serializable]
public struct EventToken
{
public static readonly EventToken Empty = new EventToken();
// by the Metadata to represent the field. FieldTokens are generated by
// Module.GetFieldToken(). There are no meaningful accessors on this class,
// but it can be passed to ILGenerator which understands it's internals.
- [Serializable]
public struct FieldToken
{
public static readonly FieldToken Empty = new FieldToken();
// is passed to the MethodWriter.
// Labels are created by using ILGenerator.CreateLabel and their position is set
// by using ILGenerator.MarkLabel.
- [Serializable]
public struct Label
{
internal int m_label;
namespace System.Reflection.Emit
{
- [Serializable]
public struct MethodToken
{
public static readonly MethodToken Empty = new MethodToken();
// This is a package private class. This class hold all of the managed
// data member for ModuleBuilder. Note that what ever data members added to
// this class cannot be accessed from the EE.
- [Serializable]
internal class ModuleBuilderData
{
internal ModuleBuilderData(ModuleBuilder module, String strModuleName, String strFileName, int tkFile)
{
// The ParameterToken class is an opaque representation of the Token returned
// by the Metadata to represent the parameter.
- [Serializable]
public struct ParameterToken
{
public static readonly ParameterToken Empty = new ParameterToken();
namespace System.Reflection.Emit
{
- [Serializable]
public struct PropertyToken
{
public static readonly PropertyToken Empty = new PropertyToken();
namespace System.Reflection.Emit
{
- [Serializable]
public struct StringToken
{
internal int m_string;
namespace System.Reflection.Emit
{
- [Serializable]
public struct TypeToken
{
public static readonly TypeToken Empty = new TypeToken();
namespace System.Reflection
{
- [Serializable]
internal sealed unsafe class MdFieldInfo : RuntimeFieldInfo, ISerializable
{
#region Private Data Members
Invalid = 0x7FFFFFFF,
}
- [Serializable]
internal struct ConstArray
{
public IntPtr Signature { get { return m_constArray; } }
internal IntPtr m_constArray;
}
- [Serializable]
internal struct MetadataToken
{
#region Implicit Cast Operators
namespace System.Reflection
{
- [Serializable]
internal unsafe sealed class RtFieldInfo : RuntimeFieldInfo, IRuntimeFieldInfo
{
#region FCalls
namespace System.Reflection
{
- [Serializable]
internal class RuntimeAssembly : Assembly
{
#if FEATURE_APPX
namespace System.Reflection
{
- [Serializable]
internal sealed class RuntimeConstructorInfo : ConstructorInfo, ISerializable, IRuntimeMethodInfo
{
#region Private Data Members
namespace System.Reflection
{
- [Serializable]
internal unsafe sealed class RuntimeEventInfo : EventInfo, ISerializable
{
#region Private Data Members
namespace System.Reflection
{
- [Serializable]
internal abstract class RuntimeFieldInfo : FieldInfo, ISerializable
{
#region Private Data Members
namespace System.Reflection
{
- [Serializable]
internal sealed class RuntimeMethodInfo : MethodInfo, ISerializable, IRuntimeMethodInfo
{
#region Private Data Members
namespace System.Reflection
{
- [Serializable]
internal class RuntimeModule : Module
{
internal RuntimeModule() { throw new NotSupportedException(); }
namespace System.Reflection
{
- [Serializable]
internal unsafe sealed class RuntimeParameterInfo : ParameterInfo, ISerializable
{
#region Static Members
namespace System.Reflection
{
- [Serializable]
internal unsafe sealed class RuntimePropertyInfo : PropertyInfo, ISerializable
{
#region Private Data Members
// is one such example.
//
- [Serializable]
public class ResourceManager
{
internal class CultureNameResourceSetPair
// enumerates over an IResourceReader, loading every name and value, and
// stores them in a hash table. Custom IResourceReaders can be used.
//
- [Serializable]
public class ResourceSet : IDisposable, IEnumerable
{
[NonSerialized] protected IResourceReader Reader;
FullName,
}
- [Serializable]
internal class RuntimeType :
System.Reflection.TypeInfo, ISerializable, ICloneable
{
// method (RuntimeType) and an instance of this type will work around the reason to have this type in the
// first place. However given RuntimeType is not public all its methods are protected and require full trust
// to be accessed
- [Serializable]
internal class ReflectionOnlyType : RuntimeType
{
private ReflectionOnlyType() { }
namespace System.Runtime.CompilerServices
{
- [Serializable]
[AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)]
public abstract class CustomConstantAttribute : Attribute
{
namespace System.Runtime.CompilerServices
{
- [Serializable]
[AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)]
public sealed class DateTimeConstantAttribute : CustomConstantAttribute
{
namespace System.Runtime.CompilerServices
{
- [Serializable]
[AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)]
public sealed class DecimalConstantAttribute : Attribute
{
// certain method properties.
// Custom attribute to specify additional method properties.
- [Serializable]
[AttributeUsage(AttributeTargets.Method | AttributeTargets.Constructor, Inherited = false)]
sealed public class MethodImplAttribute : Attribute
{
namespace System.Runtime.CompilerServices
{
- [Serializable]
public sealed class RuntimeWrappedException : Exception
{
private RuntimeWrappedException(Object thrownObject)
namespace System.Runtime.InteropServices
{
- [Serializable]
public struct ArrayWithOffset
{
//private ArrayWithOffset()
namespace System.Runtime.InteropServices
{
- [Serializable]
public sealed class BStrWrapper
{
public BStrWrapper(String value)
{
// Exception for COM Interop errors where we don't recognize the HResult.
//
- [Serializable]
public class COMException : ExternalException
{
public COMException()
}
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
- [Serializable]
public struct TYPELIBATTR
{
public Guid guid;
namespace System.Runtime.InteropServices
{
- [Serializable]
public sealed class CurrencyWrapper
{
public CurrencyWrapper(Decimal obj)
namespace System.Runtime.InteropServices
{
- [Serializable]
public sealed class DispatchWrapper
{
public DispatchWrapper(Object obj)
namespace System.Runtime.InteropServices
{
- [Serializable]
public sealed class ErrorWrapper
{
public ErrorWrapper(int errorCode)
namespace System.Runtime.InteropServices
{
- [Serializable]
public class InvalidComObjectException : SystemException
{
public InvalidComObjectException()
namespace System.Runtime.InteropServices
{
- [Serializable]
public class InvalidOleVariantTypeException : SystemException
{
public InvalidOleVariantTypeException()
namespace System.Runtime.InteropServices
{
- [Serializable]
public class MarshalDirectiveException : SystemException
{
public MarshalDirectiveException()
{
// Exception for Structured Exception Handler exceptions.
//
- [Serializable]
public class SEHException : ExternalException
{
public SEHException()
namespace System.Runtime.InteropServices
{
- [Serializable]
public class SafeArrayRankMismatchException : SystemException
{
public SafeArrayRankMismatchException()
namespace System.Runtime.InteropServices
{
- [Serializable]
public class SafeArrayTypeMismatchException : SystemException
{
public SafeArrayTypeMismatchException()
namespace System.Runtime.InteropServices
{
- [Serializable]
public sealed class UnknownWrapper
{
public UnknownWrapper(Object obj)
namespace System.Runtime.InteropServices
{
- [Serializable]
-
public sealed class VariantWrapper
{
public VariantWrapper(Object obj)
/// </summary>
/// <typeparam name="TKey">Type of objects that act as keys.</typeparam>
/// <typeparam name="TValue">Type of objects that act as entries / values.</typeparam>
- [Serializable]
[DebuggerDisplay("Count = {Count}")]
internal sealed class ConstantSplittableMap<TKey, TValue> : IMapView<TKey, TValue>
{
#region IKeyValuePair Enumerator
- [Serializable]
internal struct IKeyValuePairEnumerator : IEnumerator<IKeyValuePair<TKey, TValue>>
{
private KeyValuePair<TKey, TValue>[] _array;
namespace System.Runtime.InteropServices.WindowsRuntime
{
- [Serializable]
[DebuggerDisplay("Count = {Count}")]
internal sealed class DictionaryKeyCollection<TKey, TValue> : ICollection<TKey>
{
} // public class DictionaryKeyCollection<TKey, TValue>
- [Serializable]
internal sealed class DictionaryKeyEnumerator<TKey, TValue> : IEnumerator<TKey>
{
private readonly IDictionary<TKey, TValue> dictionary;
namespace System.Runtime.InteropServices.WindowsRuntime
{
- [Serializable]
[DebuggerDisplay("Count = {Count}")]
internal sealed class DictionaryValueCollection<TKey, TValue> : ICollection<TValue>
{
} // public class DictionaryValueCollection<TKey, TValue>
- [Serializable]
internal sealed class DictionaryValueEnumerator<TKey, TValue> : IEnumerator<TValue>
{
private readonly IDictionary<TKey, TValue> dictionary;
}
// Note: One day we may make these return IReadOnlyCollection<T>
- [Serializable]
[DebuggerDisplay("Count = {Count}")]
internal sealed class ReadOnlyDictionaryKeyCollection<TKey, TValue> : IEnumerable<TKey>
{
} // public class ReadOnlyDictionaryKeyCollection<TKey, TValue>
- [Serializable]
internal sealed class ReadOnlyDictionaryKeyEnumerator<TKey, TValue> : IEnumerator<TKey>
{
private readonly IReadOnlyDictionary<TKey, TValue> dictionary;
} // class ReadOnlyDictionaryKeyEnumerator<TKey, TValue>
- [Serializable]
[DebuggerDisplay("Count = {Count}")]
internal sealed class ReadOnlyDictionaryValueCollection<TKey, TValue> : IEnumerable<TValue>
{
} // public class ReadOnlyDictionaryValueCollection<TKey, TValue>
- [Serializable]
internal sealed class ReadOnlyDictionaryValueEnumerator<TKey, TValue> : IEnumerator<TValue>
{
private readonly IReadOnlyDictionary<TKey, TValue> dictionary;
using System.Diagnostics.Contracts;
using StackCrawlMark = System.Threading.StackCrawlMark;
- [Serializable]
public unsafe struct RuntimeTypeHandle : ISerializable
{
// Returns handle for interop with EE. The handle is guaranteed to be non-null.
}
}
- [Serializable]
public unsafe struct RuntimeMethodHandle : ISerializable
{
// Returns handle for interop with EE. The handle is guaranteed to be non-null.
}
}
- [Serializable]
public unsafe struct RuntimeFieldHandle : ISerializable
{
// Returns handle for interop with EE. The handle is guaranteed to be non-null.
namespace System.Text
{
- [Serializable]
internal sealed class InternalDecoderBestFitFallback : DecoderFallback
{
// Our variables
namespace System.Text
{
- [Serializable]
public sealed class DecoderExceptionFallback : DecoderFallback
{
// Construction
}
// Exception for decoding unknown byte sequences.
- [Serializable]
public sealed class DecoderFallbackException : ArgumentException
{
private byte[] bytesUnknown = null;
namespace System.Text
{
- [Serializable]
public abstract class DecoderFallback
{
internal bool bIsMicrosoftBestFitFallback = false;
// of Encoding objects.
//
- [Serializable]
internal class DecoderNLS : Decoder, ISerializable
{
// Remember our encoding
namespace System.Text
{
- [Serializable]
public sealed class DecoderReplacementFallback : DecoderFallback
{
// Our variables
namespace System.Text
{
- [Serializable]
internal sealed class InternalEncoderBestFitFallback : EncoderFallback
{
// Our variables
namespace System.Text
{
- [Serializable]
public sealed class EncoderExceptionFallback : EncoderFallback
{
// Construction
}
}
- [Serializable]
public sealed class EncoderFallbackException : ArgumentException
{
private char charUnknown;
namespace System.Text
{
- [Serializable]
public abstract class EncoderFallback
{
// disable csharp compiler warning #0414: field assigned unused value
// of Encoding objects.
//
- [Serializable]
internal class EncoderNLS : Encoder, ISerializable
{
// Need a place for the last left over character, most of our encodings use this
namespace System.Text
{
- [Serializable]
public sealed class EncoderReplacementFallback : EncoderFallback
{
// Our variables
// generally executes faster.
//
- [Serializable]
public abstract class Encoding : ICloneable
{
// For netcore we use UTF8 as default encoding since ANSI isn't available
decoder.ClearMustFlush();
}
- [Serializable]
internal sealed class DefaultEncoder : Encoder, IObjectReference, ISerializable
{
private Encoding m_encoding;
}
}
- [Serializable]
internal sealed class DefaultDecoder : Decoder, IObjectReference, ISerializable
{
private Encoding m_encoding;
// Latin1Encoding is a simple override to optimize the GetString version of Latin1Encoding.
// because of the best fit cases we can't do this when encoding the string, only when decoding
//
- [Serializable]
internal class Latin1Encoding : EncodingNLS, ISerializable
{
// Used by Encoding.Latin1 for lazy initialization
namespace System.Text
{
- [Serializable]
public class UTF7Encoding : Encoding
{
private const String base64Chars =
return charCount;
}
- [Serializable]
// Of all the amazing things... This MUST be Decoder so that our com name
// for System.Text.Decoder doesn't change
private sealed class Decoder : DecoderNLS, ISerializable
}
}
- [Serializable]
// Of all the amazing things... This MUST be Encoder so that our com name
// for System.Text.Encoder doesn't change
private sealed class Encoder : EncoderNLS, ISerializable
// Preexisting UTF7 behavior for bad bytes was just to spit out the byte as the next char
// and turn off base64 mode if it was in that mode. We still exit the mode, but now we fallback.
- [Serializable]
private sealed class DecoderUTF7Fallback : DecoderFallback
{
// Construction. Default replacement fallback uses no best fit and ? replacement string
namespace System.Threading
{
- [Serializable]
public class ThreadInterruptedException : SystemException
{
public ThreadInterruptedException()
namespace System
{
- [Serializable]
public class TypeLoadException : SystemException, ISerializable
{
public TypeLoadException()
namespace System
{
- [Serializable]
[StructLayout(LayoutKind.Sequential)]
internal struct Variant
{
projects / platform / upstream / dotnet / runtime.git / commitdiff