//
namespace System.CodeDom {
+ [Serializable]
public class CodeArrayCreateExpression : CodeExpression {
string createType;
CodeExpressionCollection initializers;
namespace System.CodeDom {
+ [Serializable]
public class CodeAssignStatement : CodeStatement {
CodeExpression left, right;
//
namespace System.CodeDom {
+ [Serializable]
public class CodeAttachEventStatement : CodeStatement {
CodeExpression targetObject;
string eventName;
namespace System.CodeDom {
+ [Serializable]
public class CodeAttributeArgument {
string name;
CodeExpression val;
using System.Collections;
+ [Serializable]
public class CodeAttributeArgumentCollection : IList, ICollection, IEnumerable {
ArrayList attributeArgs;
namespace System.CodeDom {
+ [Serializable]
public class CodeAttributeDeclaration {
string name;
using System.Collections;
+ [Serializable]
public class CodeAttributeDeclarationCollection : IList, ICollection, IEnumerable {
ArrayList attributeDecls;
namespace System.CodeDom {
+ [Serializable]
public class CodeBaseReferenceExpression : CodeExpression {
public CodeBaseReferenceExpression () {}
}
namespace System.CodeDom {
+ [Serializable]
public class CodeBinaryOperatorExpression : CodeExpression {
CodeExpression left, right;
namespace System.CodeDom {
+ [Serializable]
public class CodeCastExpression : CodeExpression {
string targetType;
CodeExpression expression;
namespace System.CodeDom {
+ [Serializable]
public class CodeCatchClause {
CodeParameterDeclarationExpression condition;
using System.Collections;
+ [Serializable]
public class CodeCatchClauseCollection : IList, ICollection, IEnumerable {
ArrayList catchClauses;
namespace System.CodeDom {
+ [Serializable]
public class CodeCommentStatement : CodeStatement {
string text;
namespace System.CodeDom {
+ [Serializable]
public class CodeConstructor : CodeMemberMethod {
CodeExpressionCollection baseConstructorArgs;
CodeExpressionCollection chainedConstructorArgs;
namespace System.CodeDom {
+ [Serializable]
public class CodeDelegateCreateExpression : CodeExpression {
string delegateType, methodName;
CodeExpression targetObject;
namespace System.CodeDom {
+ [Serializable]
public class CodeDelegateInvokeExpression : CodeExpression {
CodeExpressionCollection parameters;
CodeExpression targetObject;
namespace System.CodeDom {
- public class CodeExpression {
+ [Serializable]
+ public class CodeExpression : CodeObject {
object userData;
//
namespace System.CodeDom {
+ [Serializable]
public class CodeFieldReferenceExpression : CodeExpression {
CodeExpression targetObject;
string fieldName;
namespace System.CodeDom {
+ [Serializable]
public class CodeIndexerExpression : CodeExpression {
CodeExpression targetObject;
CodeExpression index;
// Use objects of this class to keep track of locations where
// statements are defined
// </summary>
+ [Serializable]
public class CodeLinePragma {
string fileName;
int lineNumber;
namespace System.CodeDom {
- public class CodeMemberEvent : CodeClassMember {
+ [Serializable]
+ public class CodeMemberEvent : CodeTypeMember {
string implementsType, type;
bool privateImplements;
namespace System.CodeDom {
- public class CodeMemberMethod : CodeClassMember {
+ [Serializable]
+ public class CodeMemberMethod : CodeTypeMember {
CodeParameterDeclarationExpressionCollection parameters;
CodeStatementCollection statements;
string implementsType;
namespace System.CodeDom {
- public class CodeMemberProperty : CodeClassMember {
+ [Serializable]
+ public class CodeMemberProperty : CodeTypeMember {
CodeParameterDeclarationExpressionCollection parameters;
CodeStatementCollection getStatements, setStatements;
bool hasGet, hasSet;
namespace System.CodeDom {
+ [Serializable]
public class CodeMethodInvokeExpression : CodeExpression {
string methodName;
CodeExpression targetObject;
namespace System.CodeDom {
- public class CodeNamespace {
+ [Serializable]
+ public class CodeNamespace : CodeObject {
CodeClassCollection classes;
CodeNamespaceImportCollection imports;
bool allowLateBound, requireVariableDeclaration;
namespace System.CodeDom {
- public class CodeNamespaceImport : CodeStatement {
+ [Serializable]
+ public class CodeNamespaceImport : CodeObject {
string nameSpace;
public CodeNamespaceImport () {}
using System.Collections;
+ [Serializable]
public class CodeNamespaceImportCollection : IList, ICollection, IEnumerable {
ArrayList namespaceImports;
namespace System.CodeDom
{
+ [Serializable]
public class CodeObject
{
}
namespace System.CodeDom {
+ [Serializable]
public class CodeObjectCreateExpression : CodeExpression {
string createType;
CodeExpressionCollection parameters;
namespace System.CodeDom {
+ [Serializable]
public class CodeParameterDeclarationExpression : CodeExpression {
FieldDirection direction;
CodeAttributeBlock customAttributes;
using System.Collections;
+ [Serializable]
public class CodeParameterDeclarationExpressionCollection : IList, ICollection, IEnumerable {
ArrayList parameterDeclExprs;
namespace System.CodeDom {
+ [Serializable]
public class CodePrimitiveExpression : CodeExpression {
object value;
namespace System.CodeDom {
+ [Serializable]
public class CodePropertyReferenceExpression : CodeExpression {
CodeExpressionCollection parameters;
CodeExpression targetObject;
namespace System.CodeDom
{
+ [Serializable]
public class CodeStatement : CodeObject
{
}
using System.Collections;
+ [Serializable]
public class CodeStatementCollection : IList, ICollection, IEnumerable {
ArrayList statements;
namespace System.CodeDom {
+ [Serializable]
public class CodeThisReferenceExpression : CodeExpression {
public CodeThisReferenceExpression () { }
}
namespace System.CodeDom {
+ [Serializable]
public class CodeThrowExceptionStatement : CodeStatement {
CodeExpression toThrow;
namespace System.CodeDom {
+ [Serializable]
public class CodeTryCatchFinallyStatement : CodeStatement {
CodeStatementCollection tryStatements, finallyStatements;
CodeCatchClauseCollection catchClauses;
namespace System.CodeDom
{
+ [Serializable]
public class CodeTypeDeclaration : CodeTypeMember
{
}
namespace System.CodeDom
{
+ [Serializable]
public class CodeTypeMember : CodeObject {
private string name;
namespace System.CodeDom {
+ [Serializable]
public class CodeTypeOfExpression : CodeExpression {
string type;
namespace System.CodeDom {
+ [Serializable]
public class CodeTypeReferenceExpression : CodeExpression {
string type;
namespace System.CodeDom {
+ [Serializable]
public class CodeVariableDeclarationStatement : CodeStatement {
CodeExpression initExpression;
string type, name;
namespace System.Collections.Specialized\r
{\r
+ [Serializable]\r
public class ListDictionary : IDictionary, ICollection, IEnumerable\r
{\r
private int count;\r
\r
namespace System.Collections.Specialized\r
{\r
+ [Serializable]\r
public abstract class NameObjectCollectionBase : ICollection, IEnumerable, ISerializable, IDeserializationCallback\r
{\r
private Hashtable m_ItemsContainer;\r
/// <summary>\r
/// Implements IEnumerable interface for KeysCollection\r
/// </summary>\r
+ [Serializable]\r
internal protected /*?*/ class _KeysEnumerator : IEnumerator\r
{\r
private NameObjectCollectionBase m_collection;\r
using System.Text;
namespace System.Collections.Specialized{
+ [Serializable]
public class NameValueCollection : NameObjectCollectionBase
{
string[] cachedAllKeys = null;
using System;\r
\r
namespace System.Collections.Specialized {\r
+ [Serializable]\r
public class StringCollection : IList, ICollection, IEnumerable {\r
private static int InitialCapacity = 11;\r
private static float CapacityMultiplier = 2.0f;\r
protected ArrayList list;\r
}\r
\r
+ [Serializable]\r
public class CaptureCollection : RegexCollectionBase, ICollection, IEnumerable {\r
public Capture this[int i] {\r
get { return (Capture)list[i]; }\r
\r
namespace System.Text.RegularExpressions {\r
\r
+ [Serializable]\r
public class Capture {\r
public int Index {\r
get {\r
ECMAScript = 0x100\r
}\r
\r
+ [Serializable]\r
public class Regex : ISerializable {\r
public static void CompileToAssembly\r
(RegexCompilationInfo[] regexes, AssemblyName aname)\r
namespace System {
+ [Serializable]
public class Uri : MarshalByRefObject, ISerializable {
private string path = "";
\r
namespace System.Collections {\r
\r
+ [Serializable]\r
public class ArrayList : IList, ICollection, IEnumerable, ICloneable {\r
// constructors\r
\r
System.Array.Copy (dataArray, index, array, arrayIndex, count);\r
}\r
\r
+ [Serializable]\r
private class ArrayListEnumerator : IEnumerator {\r
private object[] data;\r
private int idx;\r
namespace System.Collections
{
// do we really need to specify IEnumerable since ICollection extends it?
+ [Serializable]
public class BitArray : ICollection, IEnumerable, ICloneable
{
private Int32[] m_array;
\r
namespace System.Collections {\r
\r
+ [Serializable]\r
public class CaseInsensitiveComparer : IComparer {\r
\r
private static CaseInsensitiveComparer singleton;\r
\r
namespace System.Collections {\r
\r
+ [Serializable]\r
public class CaseInsensitiveHashCodeProvider : IHashCodeProvider {\r
\r
private static CaseInsensitiveHashCodeProvider singleton;\r
\r
namespace System.Collections {\r
\r
+ [Serializable]\r
public abstract class CollectionBase : IList, ICollection, IEnumerable {\r
\r
// private instance properties\r
\r
namespace System.Collections {\r
\r
+ [Serializable]\r
public sealed class Comparer : IComparer {\r
\r
public static readonly Comparer Default;\r
/// The `On' members are protected and designed to be used only by derived
/// classes.
/// </remarks>
+ [Serializable]
public abstract class DictionaryBase : IDictionary, ICollection, IEnumerable {
Hashtable dictionary;
namespace System.Collections {
+ [Serializable]
public struct DictionaryEntry {
private object key;
private object val;
namespace System.Collections {\r
\r
[MonoTODO]\r
+ [Serializable]\r
public class Hashtable : IDictionary, ICollection, \r
IEnumerable, ICloneable, ISerializable\r
{\r
\r
namespace System.Collections {\r
\r
+ [Serializable]\r
public class Queue : ICollection, IEnumerable, ICloneable {\r
\r
private object[] contents;\r
}\r
}\r
\r
+ [Serializable]\r
private class QueueEnumerator : IEnumerator {\r
Queue queue;\r
private int modCount;\r
\r
namespace System.Collections {\r
\r
+ [Serializable]\r
public abstract class ReadOnlyCollectionBase : ICollection, IEnumerable {\r
\r
// private instance properties\r
/// that are sorted by the keys and are accessible by key\r
/// and by index.\r
/// </summary>\r
+ [Serializable]\r
public class SortedList : IDictionary, ICollection,\r
IEnumerable, ICloneable {\r
\r
\r
namespace System.Collections {\r
\r
+ [Serializable]\r
public class Stack : ICollection, IEnumerable, ICloneable {\r
\r
// properties\r
contents = new object[capacity];\r
}\r
\r
+ [Serializable]\r
private class SyncStack : Stack {\r
\r
Stack stack;\r
\r
namespace System.Configuration.Assemblies {\r
\r
+ [Serializable]\r
public struct AssemblyHash : System.ICloneable\r
{\r
private AssemblyHashAlgorithm _algorithm;\r
namespace System.Diagnostics \r
{\r
\r
+ [Serializable]\r
public sealed class ConditionalAttribute : System.Attribute \r
{\r
\r
/// Stack frame.
/// TODO: more information.
/// </summary>
+ [Serializable]
public class StackFrame {
/// <value>
/// Constant returned when the native or IL offset is unknown.
/// Stack trace.
/// TODO: more information.
/// </summary>
- public class StackTrace {
+ [Serializable]
+ public class StackTrace {
/// <value>
/// Uses a constant to define the number of methods that are
/// to be omitted from the stack trace.
namespace System.Globalization
{
+ [Serializable]
public class CultureInfo : IFormatProvider
{
static CultureInfo invariant_culture_info;
namespace System.Globalization \r
{
+ [Serializable]
public sealed class DateTimeFormatInfo : ICloneable, IFormatProvider {
private static readonly string MSG_READONLY = "This instance is read only";\r
private static readonly string MSG_ARRAYSIZE_MONTH = "An array with exactly 13 elements is needed";\r
namespace System.Globalization
{
+ [Serializable]
public class DaylightTime
{
DateTime start, end;
namespace System.Globalization {
+ [Serializable]
public sealed class NumberFormatInfo : ICloneable, IFormatProvider {
private bool readOnly;
namespace System.Globalization {
+ [Serializable]
public class RegionInfo {
int NLS_id;
using System.Text;
namespace System.IO {
+ [Serializable]
public class BinaryWriter : IDisposable {
public static readonly BinaryWriter Null;
\r
namespace System.IO {\r
\r
+ [Serializable]
public sealed class DirectoryInfo : FileSystemInfo {\r
\r
public DirectoryInfo (string path) {\r
namespace System.IO {
+ [Serializable]
public class DirectoryNotFoundException : IOException {
// Constructors
public DirectoryNotFoundException ()
\r
namespace System.IO {\r
\r
+ [Serializable]
public sealed class FileInfo : FileSystemInfo {\r
\r
public FileInfo (string path) {\r
namespace System.IO {
+ [Serializable]
public class FileNotFoundException : IOException {
private string fileName;
private string fusionLog;
namespace System.IO {
+ [Serializable]
public abstract class FileSystemInfo : MarshalByRefObject {
// public properties
//\r
\r
namespace System.IO {\r
+ [Serializable]\r
public class MemoryStream : Stream {\r
private bool canRead;\r
private bool canSeek;\r
using System.Text;\r
\r
namespace System.IO {\r
- \r
+ [Serializable]\r
public class StreamReader : TextReader {\r
\r
// buffering members\r
\r
namespace System.IO {\r
\r
+ [Serializable]\r
public class StreamWriter : TextWriter {\r
\r
private Encoding internalEncoding;\r
using System;
namespace System.IO {
+ [Serializable]
public class StringReader : TextReader {
protected string source;
using System.Text;\r
\r
namespace System.IO {\r
+ [Serializable]\r
public class StringWriter : TextWriter {\r
\r
protected StringBuilder internalString;\r
\r
namespace System.IO {\r
\r
- [MonoTODO]\r
+ [MonoTODO] [Serializable]\r
public abstract class TextReader : MarshalByRefObject, IDisposable {\r
\r
protected TextReader() { }\r
\r
namespace System.IO {\r
\r
- [MonoTODO]\r
+ [MonoTODO] [Serializable]\r
public abstract class TextWriter : MarshalByRefObject, IDisposable {\r
\r
protected TextWriter() {\r
/// <summary>
/// Represents the Token returned by the metadata to represent a Event.
/// </summary>
+ [Serializable]
public struct EventToken {
internal int tokValue;
/// <summary>
/// Represents the Token returned by the metadata to represent a Field.
/// </summary>
+ [Serializable]
public struct FieldToken {
internal int tokValue;
//
namespace System.Reflection.Emit {
+ [Serializable]
public struct Label {
internal int label;
/// <summary>
/// Represents the Token returned by the metadata to represent a Method.
/// </summary>
+ [Serializable]
public struct MethodToken {
internal int tokValue;
/// <summary>
/// Represents the Token returned by the metadata to represent a Parameter.
/// </summary>
+ [Serializable]
public struct ParameterToken {
internal int tokValue;
/// <summary>
/// Represents the Token returned by the metadata to represent a Property.
/// </summary>
+ [Serializable]
public struct PropertyToken {
internal int tokValue;
using System.Runtime.InteropServices;
namespace System.Reflection.Emit {
+ [Serializable]
public sealed class SignatureHelper {
internal enum SignatureHelperType {
HELPER_FIELD,
/// <summary>
/// Represents the Token returned by the metadata to represent a Signature.
/// </summary>
+ [Serializable]
public struct SignatureToken {
internal int tokValue;
/// <summary>
/// Represents the Token returned by the metadata to represent a String.
/// </summary>
+ [Serializable]
public struct StringToken {
internal int tokValue;
/// <summary>
/// Represents the Token returned by the metadata to represent a Type.
/// </summary>
+ [Serializable]
public struct TypeToken {
internal int tokValue;
namespace System.Reflection.Emit {
+ [Serializable]
public sealed class UnmanagedMarshal {
private int count;
private UnmanagedType t;
namespace System.Reflection {
+ [Serializable]
public sealed class AmbiguousMatchException : SystemException {
// Constructors
public AmbiguousMatchException ()
namespace System.Reflection {
+ [Serializable]
public class Assembly : System.Reflection.ICustomAttributeProvider,
System.Security.IEvidenceFactory, System.Runtime.Serialization.ISerializable {
private IntPtr _mono_assembly;
namespace System.Reflection {
+ [Serializable]
public class AssemblyName : ISerializable // ICloneable, , IDeserializationCallback
{
string name;
namespace System.Reflection
{
+ [Serializable]
public abstract class Binder
{
}
using System.Globalization;
namespace System.Reflection {
+ [Serializable]
public abstract class ConstructorInfo : MethodBase {
public static readonly string ConstructorName = ".ctor";
public static readonly string TypeConstructorName = ".cctor";
namespace System.Reflection {
+ [Serializable]
public sealed class DefaultMemberAttribute : Attribute {
string member_name;
namespace System.Reflection {
+ [Serializable]
public abstract class FieldInfo : MemberInfo {
public abstract FieldAttributes Attributes {get;}
namespace System.Reflection {
+ [Serializable]
public abstract class MemberInfo : ICustomAttributeProvider {
public abstract Type DeclaringType {
namespace System.Reflection {
+ [Serializable]
public abstract class MethodBase: MemberInfo {
public static MethodBase GetCurrentMethod()
using System.Security.Cryptography.X509Certificates;
namespace System.Reflection {
+ [Serializable]
public class Module : ISerializable, ICustomAttributeProvider {
public static readonly TypeFilter FilterTypeName;
namespace System.Reflection
{
+ [Serializable]
public class ParameterInfo : ICustomAttributeProvider
{
protected Type ClassImpl;
using System.Globalization;
namespace System.Reflection {
+ [Serializable]
public abstract class PropertyInfo : MemberInfo {
public abstract PropertyAttributes Attributes {get;}
namespace System.Reflection
{
+ [Serializable]
public class TargetInvocationException : ApplicationException
{
private TargetInvocationException () {}
namespace System.Reflection {
+ [Serializable]
public class TypeDelegator : Type {
protected Type typeImpl;
namespace System.Resources
{
+ [Serializable]
public class MissingManifestResourceException: SystemException
{
private string param;
namespace System.Runtime.CompilerServices {
- [AttributeUsage(AttributeTargets.Property, Inherited=false)]
+ [AttributeUsage(AttributeTargets.Property, Inherited=false)] [Serializable]
public class IndexerNameAttribute : Attribute {
public IndexerNameAttribute (string indexer_name)
{
namespace System.Runtime.CompilerServices {
- [AttributeUsage(AttributeTargets.Method, Inherited=false)]
+ [AttributeUsage(AttributeTargets.Method, Inherited=false)] [Serializable]
public class MethodImplAttribute : Attribute {
MethodImplOptions impl_options;
namespace System.Runtime.CompilerServices
{
+ [Serializable]
public sealed class RuntimeHelpers
{
private RuntimeHelpers () {}
namespace System.Runtime.Remoting.Contexts {
[AttributeUsage (AttributeTargets.Class)]
+ [Serializable]
public class ContextAttribute : Attribute, IContextAttribute, IContextProperty {
protected string AttributeName;
\r
namespace System.Runtime.Remoting.Messaging {\r
\r
+ [Serializable]\r
public class Header {\r
public Header (string name, object value) :\r
this (name, value, true)\r
namespace System.Runtime.Remoting.Messaging {\r
\r
[MonoTODO]\r
+ [Serializable]
public class LogicalCallContext : ISerializable, ICloneable {\r
internal LogicalCallContext () {}
namespace System.Runtime.Remoting {
+ [Serializable]
public class ObjRef : IObjectReference, ISerializable {
MarshalByRefObject mbr;
SerializationInfo si;
namespace System.Runtime.Serialization {
+ [Serializable]
public sealed class SerializationException : SystemException {
// Constructors
public SerializationException ()
namespace System.Runtime.Serialization {
+ [Serializable]
public struct StreamingContext {
StreamingContextStates state;
object additional;
\r
namespace System.Security.Cryptography {\r
\r
+ [Serializable]\r
public class CryptographicException : SystemException {\r
// Constructors\r
public CryptographicException ()\r
\r
namespace System.Security.Cryptography {\r
\r
+ [Serializable]\r
public class CryptographicUnexpectedOperationException : CryptographicException {\r
// Constructors\r
public CryptographicUnexpectedOperationException ()\r
/// <summary>\r
/// DSA Parameters\r
/// </summary>\r
+ [Serializable]\r
public struct DSAParameters\r
{\r
public int Counter;\r
namespace System.Security.Cryptography {\r
\r
[MonoTODO]\r
+ [Serializable]\r
public struct RSAParameters {\r
[NonSerialized]\r
public byte[] P;\r
namespace System.Security.Cryptography.X509Certificates {
+ [Serializable]
public class X509Certificate {
internal X509Certificate () {}
}
AllowMultiple=true, \r
Inherited=false)\r
]\r
+ [Serializable]
public abstract class CodeAccessSecurityAttribute : SecurityAttribute {\r
\r
public CodeAccessSecurityAttribute(SecurityAction action) : base(action) {}\r
Inherited=false)\r
]\r
\r
+ [Serializable]\r
public abstract class SecurityAttribute : Attribute {\r
\r
private SecurityAction m_Action;\r
}\r
}\r
} // public abstract class SecurityAttribute\r
-} // namespace System.Security.Permissions
\ No newline at end of file
+} // namespace System.Security.Permissions\r
namespace System.Security.Permissions {\r
\r
[MonoTODO]\r
+ [Serializable]\r
public sealed class SecurityPermission :\r
CodeAccessPermission, IUnrestrictedPermission\r
{\r
namespace System.Security.Policy
{
[MonoTODO]
+ [Serializable]
public sealed class Evidence
{
\r
namespace System.Security.Policy {\r
\r
+ [Serializable]\r
public class PolicyStatement : ISecurityEncodable, ISecurityPolicyEncodable {\r
public PolicyStatement (PermissionSet perms) :\r
this (perms, PolicyStatementAttribute.Nothing)\r
namespace System.Security.Principal {
+ [Serializable]
public class GenericIdentity : IIdentity {
string user_name;
string authentication_type;
namespace System.Security.Principal {
+ [Serializable]
public class GenericPrincipal : IPrincipal {
IIdentity identity;
string [] roles;
namespace System.Security {
+ [Serializable]
public abstract class CodeAccessPermission : IPermission, ISecurityEncodable, IStackWalk
{
///<summary>Constructs a new instance of the System.Security.CodeAccessPermission class.</summary>
namespace System.Security {\r
\r
[MonoTODO]\r
+ [Serializable]\r
public sealed class NamedPermissionSet : PermissionSet {\r
public NamedPermissionSet (string name, PermissionSet set) : base (set) {\r
this.name = name;\r
namespace System.Security\r
{\r
///<summary> Represents a collection that can contain different kinds of permissions and perform security operations.</summary>\r
+ [Serializable]\r
public class PermissionSet: ISecurityEncodable, ICollection, IEnumerable, IStackWalk, IDeserializationCallback\r
{\r
///<summary> Constructs a new instance of the System.Security.PermissionSet class with the specified value.</summary>\r
namespace System.Security {
[MonoTODO ("See bottom of the class for missing methods")]
+ [Serializable]
public sealed class SecurityElement {
string text;
string tag;
using System.Globalization;\r
\r
namespace System.Security {\r
+ [Serializable]\r
public class SecurityException : SystemException {\r
\r
// Fields\r
using System.Globalization;\r
\r
namespace System.Security {\r
+ [Serializable]\r
public class VerificationException : SystemException {\r
\r
// Constructors\r
public VerificationException(string message, Exception inner) \r
: base (message, inner) {}\r
}\r
-}
\ No newline at end of file
+}\r
using System.Globalization;\r
\r
namespace System.Security {\r
+ [Serializable]\r
public sealed class XmlSyntaxException : SystemException {\r
\r
// Constructors\r
public XmlSyntaxException(string message, Exception inner) \r
: base (message, inner) {}\r
}\r
-}
\ No newline at end of file
+}\r
namespace System.Text {
+ [Serializable]
public class ASCIIEncoding : Encoding
{
public ASCIIEncoding () : base ()
namespace System.Text
{
+ [Serializable]
public abstract class Decoder
{
namespace System.Text
{
+ [Serializable]
public abstract class Encoder
{
namespace System.Text {
+ [Serializable]
public abstract class Encoding {
private static ASCIIEncoding ascii_encoding;
private static UnicodeEncoding big_endian_unicode;
namespace System.Text {\r
\r
[MonoTODO ("Implement AppendFormat methods and IFormatProvider, IFormattable")]\r
+ [Serializable]\r
public sealed class StringBuilder {\r
\r
private const int defaultCapacity = 16;\r
namespace System.Text
{
+ [Serializable]
public class UTF8Encoding : Encoding
{
public UTF8Encoding () : base ("UTF-8", false)
namespace System.Text {
[MonoTODO]
+ [Serializable]
public class UnicodeEncoding : Encoding
{
private bool byteOrderMark;
namespace System.Threading
{
+ [Serializable]
public struct LockCookie
{
}
namespace System.Threading
{
+ [Serializable]
public class SynchronizationLockException : SystemException
{
public SynchronizationLockException()
namespace System.Threading
{
+ [Serializable]
public sealed class ThreadAbortException : SystemException
{
private ThreadAbortException () {}
namespace System.Threading
{
+ [Serializable]
public class ThreadInterruptedException : SystemException
{
public ThreadInterruptedException()
namespace System.Threading
{
+ [Serializable]
public class ThreadStateException : SystemException
{
public ThreadStateException()
namespace System {
+ [Serializable]
public sealed class AppDomainSetup : IAppDomainSetup {
string application_base;
string application_name;
namespace System {
+ [Serializable]
public class ArgumentException : SystemException {
private string param_name;
namespace System {
+ [Serializable]
public class ArgumentNullException : ArgumentException {
// Constructors
public ArgumentNullException ()
namespace System {
+ [Serializable]
public class ArgumentOutOfRangeException : ArgumentException {
private object actual_value;
namespace System
{
+ [Serializable]
public abstract class Array : ICloneable, ICollection, IList, IEnumerable
{
// Constructor
namespace System {\r
\r
[AttributeUsage(AttributeTargets.All)]\r
+ [Serializable]\r
public class AttributeUsageAttribute : Attribute {\r
AttributeTargets valid_on;\r
bool allow_multiple, inherited;\r
namespace System {
+ [Serializable]
public struct Byte : IComparable, IFormattable, IConvertible {
public const byte MinValue = 0;
/// <remarks>
/// </remarks>
[AttributeUsage(AttributeTargets.All)]
+ [Serializable]
public class CLSCompliantAttribute : Attribute {
bool is_compliant;
namespace System {
+ [Serializable]
public struct Char : IComparable, IConvertible { //, IFormattable {
public const char MaxValue = (char) 0xffff;
public const char MinValue = (char) 0;
/// Base class for all the context-bound classes
/// </summary>
[MonoTODO]
+ [Serializable]
public abstract class ContextBoundObject : MarshalByRefObject {
protected ContextBoundObject ()
/// 1-1-0001 12:00:00 AM to 31-12-9999 23:59:00 Common Era.\r
/// </summary>\r
/// \r
+ [Serializable]\r
public struct DateTime : IComparable , IFormattable , IConvertible\r
{\r
private TimeSpan ticks;\r
/// Represents a floating-point decimal data type with up to 29 significant\r
/// digits, suitable for financial and commercial calculations\r
/// </summary>\r
+ [Serializable]\r
public struct Decimal: IComparable, IFormattable\r
{\r
public static readonly Decimal MinValue = new Decimal(-1, -1, -1, true, 0);\r
using System.Globalization;
namespace System {
+ [Serializable]
public class DivideByZeroException : ArithmeticException {
// Constructors
public DivideByZeroException ()
namespace System {
+ [Serializable]
public struct Double : IComparable, IFormattable, IConvertible {
public const double Epsilon = 4.9406564584124650e-324;
public const double MaxValue = 1.7976931348623157e308;
namespace System {
+ [Serializable]
public class DuplicateWaitObjectException : ArgumentException {
// Constructors
public DuplicateWaitObjectException ()
namespace System {
+ [Serializable]
public class EventArgs
{
public static readonly EventArgs Empty = new EventArgs();
using System.Globalization;
namespace System {
+ [Serializable]
public sealed class ExecutionEngineException : SystemException {
// Constructors
public ExecutionEngineException ()
/// </remarks>
[AttributeUsage (AttributeTargets.Enum)]
+ [Serializable]
public class FlagsAttribute : Attribute {
// No methods.
namespace System {
+ [Serializable]
public class FormatException : SystemException {
// Constructors
public FormatException ()
using System.Globalization;
namespace System {
+ [Serializable]
public sealed class IndexOutOfRangeException : SystemException {
// Constructors
public IndexOutOfRangeException ()
namespace System {
+ [Serializable]
public struct Int16 : IComparable, IFormattable, IConvertible {
public const short MaxValue = 32767;
namespace System {
+ [Serializable]
public struct Int32 : IComparable, IFormattable, IConvertible {
public const int MaxValue = 0x7fffffff;
namespace System {
+ [Serializable]
public struct Int64 : IComparable, IFormattable, IConvertible {
public const long MaxValue = 0x7fffffffffffffff;
[
CLSCompliant(true)
]
+ [Serializable]
public unsafe struct IntPtr : ISerializable {
private void *value;
namespace System {
+ [Serializable]
public class InvalidCastException : SystemException {
// Constructors
public InvalidCastException ()
using System.Globalization;
namespace System {
+ [Serializable]
public sealed class InvalidProgramException : SystemException {
// Constructors
public InvalidProgramException ()
namespace System {
+ [Serializable]
public abstract class MarshalByRefObject {
public virtual ObjRef CreateObjRef (Type type)
using System.Globalization;
namespace System {
+ [Serializable]
public sealed class MulticastNotSupportedException : SystemException {
// Constructors
public MulticastNotSupportedException ()
namespace System {
+ [Serializable]
public class NotFiniteNumberException : ArithmeticException {
double offending_number;
namespace System {
+ [Serializable]
public class NotImplementedException : SystemException {
// Constructors
public NotImplementedException ()
namespace System {
+ [Serializable]
public class NotSupportedException : SystemException {
// Constructors
public NotSupportedException ()
namespace System {
+ [Serializable]
public class NullReferenceException : SystemException {
// Constructors
public NullReferenceException ()
/// <summary>\r
/// Class representing a specific operating system version for a specific platform\r
/// </summary>\r
+ [Serializable]\r
public sealed class OperatingSystem : ICloneable\r
{\r
private System.PlatformID itsPlatform;\r
namespace System {
+ [Serializable]
public class OutOfMemoryException : SystemException {
// Constructors
public OutOfMemoryException ()
namespace System {
+ [Serializable]
public class OverflowException : ArithmeticException {
// Constructors
public OverflowException ()
namespace System
{
+ [Serializable]
public class Random
{
private int S = 1;
namespace System {
+ [Serializable]
public class RankException : SystemException {
// Constructors
public RankException ()
namespace System {
[MonoTODO]
+ [Serializable]
public struct RuntimeFieldHandle : ISerializable {
IntPtr value;
namespace System {
//[MonoTODO]
+ [Serializable]
public struct RuntimeMethodHandle : ISerializable {
IntPtr value;
namespace System {
[CLSCompliant(false)]
+ [Serializable]
public struct SByte : IComparable, IFormattable, IConvertible {
public const sbyte MinValue = -128;
namespace System {
+ [Serializable]
public struct Single : IComparable, IFormattable, IConvertible {
public const float Epsilon = 1.4e-45f;
public const float MaxValue = 3.40282346638528859e38f;
namespace System {
+ [Serializable]
public class StackOverflowException : SystemException {
// Constructors
public StackOverflowException ()
namespace System {
//[DefaultMemberName("Chars")]
+ [Serializable]
public sealed class String : IComparable, ICloneable, IConvertible, IEnumerable {
public static readonly string Empty = "";
private char[] c_str;
namespace System
{
[AttributeUsage (AttributeTargets.Field)]
+ [Serializable]
public class ThreadStaticAttribute : Attribute
{
// Constructors
//
[MonoTODO]
+ [Serializable]
public abstract class Type : MemberInfo, IReflect {
internal RuntimeTypeHandle _impl;
using System.Runtime.Serialization;
namespace System {
+ [Serializable]
public class TypeInitializationException : SystemException {
string type_name;
namespace System {
[CLSCompliant(false)]
+ [Serializable]
public struct UInt16 : IComparable, IFormattable, IConvertible {
public const ushort MaxValue = 0xffff;
namespace System {
[CLSCompliant(false)]
+ [Serializable]
public struct UInt32 : IComparable, IFormattable, IConvertible {
public const uint MaxValue = 0xffffffff;
namespace System {
[CLSCompliant(false)]
+ [Serializable]
public struct UInt64 : IComparable, IFormattable, IConvertible {
public const ulong MaxValue = 0xffffffffffffffff;
public const ulong MinValue = 0;
StructLayout(LayoutKind.Auto),
CLSCompliant(false)
]
+[Serializable]
public unsafe struct UIntPtr : ISerializable
{
public static readonly UIntPtr Zero = new UIntPtr(0);
namespace System
{
+ [Serializable]
public class UnhandledExceptionEventArgs: EventArgs
{
private object exception;
namespace System {
+ [Serializable]
public struct Void {
}
}
projects / mono.git / commitdiff