/// <summary>\r
/// Summary description for XmlSchemaCollectionEnumerator.\r
/// </summary>\r
- public class XmlSchemaCollectionEnumerator : IEnumerator\r
+ public sealed class XmlSchemaCollectionEnumerator : IEnumerator\r
{\r
private IDictionaryEnumerator xenum;\r
internal XmlSchemaCollectionEnumerator(Hashtable htable)\r
public abstract bool MoveToPrevious ();
- public abstract bool MoveToRoot ();
+ public abstract void MoveToRoot ();
[MonoTODO]
public virtual XPathNodeIterator Select (string xpath)
VariableReference\r
}\r
\r
- public class XPathScanner\r
+ public sealed class XPathScanner\r
{\r
private string xpath;\r
private int index;\r
set { data = value; }
}
- public int Length {
+ public virtual int Length {
get { return data != null ? data.Length : 0; }
}
}
[MonoTODO]
- public XmlResolver XmlResolver {
+ public virtual XmlResolver XmlResolver {
set { throw new NotImplementedException(); }
}
}
[MonoTODO]
- public virtual void SetAttribute (string localName, string namespaceURI, string value)
+ public virtual string SetAttribute (string localName, string namespaceURI, string value)
{
throw new NotImplementedException ();
}
}
[MonoTODO]
- public virtual XmlNodeList SelectNodes (string xpath)
+ public XmlNodeList SelectNodes (string xpath)
{
throw new NotImplementedException ();
}
[MonoTODO]
- public virtual XmlNodeList SelectNodes (string xpath, XmlNamespaceManager nsmgr)
+ public XmlNodeList SelectNodes (string xpath, XmlNamespaceManager nsmgr)
{
throw new NotImplementedException ();
}
[MonoTODO]
- public virtual XmlNode SelectSingleNode (string xpath)
+ public XmlNode SelectSingleNode (string xpath)
{
throw new NotImplementedException ();
}
[MonoTODO]
- public virtual XmlNode SelectSingleNode (string xpath, XmlNamespaceManager nsmgr)
+ public XmlNode SelectSingleNode (string xpath, XmlNamespaceManager nsmgr)
{
throw new NotImplementedException ();
}
return new DefaultSite (name, component, this);
}
- public virtual void Dispose ()
+ public void Dispose ()
{
Dispose (true);
GC.SuppressFinalize (this);
namespace System.ComponentModel {
[AttributeUsage (AttributeTargets.Property)]
- public class DesignOnlyAttribute : Attribute {
+ public sealed class DesignOnlyAttribute : Attribute {
bool design_only;
public static readonly DesignOnlyAttribute No;
// <remarks>
// Longer description
// </remarks>
- public class EventHandlerList : IDisposable {
+ public sealed class EventHandlerList : IDisposable {
Hashtable table;
public EventHandlerList ()
namespace System.ComponentModel {
- public class MemberDescriptor {
+ public abstract class MemberDescriptor {
string name;
Attribute [] attrs;
/// <param name="section">The XML node that contains the configuration information to be handled. section provides direct access to the XML contents of the configuration section.</param>\r
/// <returns></returns>\r
[MonoTODO]\r
- public object Create(object parent, object context, XmlNode section)\r
+ public virtual object Create(object parent, object context, XmlNode section)\r
{\r
//FIXME: Enter a meaningful error message\r
if(section == null)\r
/// <param name="section">The name of the configuration section.</param>
/// <returns></returns>
[MonoTODO]
- public object Create(object parent, object context, XmlNode section)
+ public virtual object Create(object parent, object context, XmlNode section)
{
//FIXME: I'm not quite sure how to implement 'parent' or 'context'.
//TODO: Add in proper Error Handling.
using System;
namespace System.Diagnostics {
- public class FileVersionInfo {
+ public sealed class FileVersionInfo {
[MonoTODO]
public string Comments {
get {
}\r
\r
public class MatchCollection : RegexCollectionBase, ICollection, IEnumerable {\r
- public Match this[int i] {\r
+ public virtual Match this[int i] {\r
get { return (Match)list[i]; }\r
}\r
\r
return inner; // FIXME need to sync on machine access\r
}\r
\r
- public GroupCollection Groups {\r
+ public virtual GroupCollection Groups {\r
get { return groups; }\r
}\r
\r
return new ArrayListEnumerator (start, num, data);
}
\r
- public object Current {\r
+ public virtual object Current {\r
get {\r
return data [idx];\r
}\r
}\r
- public bool MoveNext() {\r
+ public virtual bool MoveNext() {\r
if (++idx < start + num)\r
return true;\r
return false;\r
}\r
- public void Reset() {\r
+ public virtual void Reset() {\r
idx = start - 1;\r
}\r
}\r
{
// do we really need to specify IEnumerable since ICollection extends it?
[Serializable]
- public class BitArray : ICollection, IEnumerable, ICloneable
+ public sealed class BitArray : ICollection, IEnumerable, ICloneable
{
private Int32[] m_array;
private int m_length;
/* --- Public properties --- */
- public virtual int Count
+ public int Count
{
get
{
}
}
- public virtual bool IsReadOnly
+ public bool IsReadOnly
{
get
{
}
}
- public virtual bool IsSynchronized
+ public bool IsSynchronized
{
get
{
}
}
- public virtual bool this[int index]
+ public bool this[int index]
{
get
{
}
- public virtual int Length
+ public int Length
{
get
{
}
}
- public virtual object SyncRoot
+ public object SyncRoot
{
get
{
//\r
\r
[MonoTODO]\r
- public virtual int GetHashCode (object obj)\r
+ public int GetHashCode (object obj)\r
{\r
if (obj == null) {\r
throw new ArgumentNullException ("obj is null");\r
private System.Collections.ArrayList myList;\r
\r
// public instance properties\r
- public virtual int Count { get { return InnerList.Count; } }\r
+ public int Count { get { return InnerList.Count; } }\r
\r
// Public Instance Methods\r
- public virtual System.Collections.IEnumerator GetEnumerator() { return InnerList.GetEnumerator(); }\r
- public virtual void Clear() { \r
+ public System.Collections.IEnumerator GetEnumerator() { return InnerList.GetEnumerator(); }\r
+ public void Clear() { \r
OnClear();\r
InnerList.Clear(); \r
OnClearComplete();\r
}\r
- public virtual void RemoveAt (int index) {\r
+ public void RemoveAt (int index) {\r
object objectToRemove;\r
objectToRemove = InnerList[index];\r
OnValidate(objectToRemove);\r
private System.Collections.ArrayList myList;\r
\r
// public instance properties\r
- public virtual int Count { get { return InnerList.Count; } }\r
+ public int Count { get { return InnerList.Count; } }\r
\r
// Public Instance Methods\r
- public virtual System.Collections.IEnumerator GetEnumerator() { return InnerList.GetEnumerator(); }\r
+ public System.Collections.IEnumerator GetEnumerator() { return InnerList.GetEnumerator(); }\r
\r
// Protected Instance Constructors\r
protected ReadOnlyCollectionBase() {\r
}\r
\r
// Protected Instance Properties\r
- protected virtual System.Collections.ArrayList InnerList {get { return this.myList; } }\r
+ protected System.Collections.ArrayList InnerList {get { return this.myList; } }\r
\r
// ICollection methods\r
void ICollection.CopyTo(Array array, int index) {\r
}
// Fields
- public static Guid Microsoft;
+ public static readonly Guid Microsoft;
}
}
/// The era number for the Anno Mundi (A.M.) era, called
/// plain HebrewEra.
/// </summary>
- public const int HebrewEra = 1;
+ public static readonly int HebrewEra = 1;
/// <summary>
/// The
/// <summary>
/// The era number for the Anno Hegirae (A.H.) era.
/// </summary>
- public const int HijriEra = 1;
+ public static readonly int HijriEra = 1;
/// <summary>
/// The minimum fixed day number supported by the Hijri calendar.
/// The era number for the Common Era (C.E.) or Anno Domini (A.D.)
/// respective.
/// </summary>
- public const int JulianEra = 1;
+ public static readonly int JulianEra = 1;
/// <value>Overridden. Gives the eras supported by the Julian
/// calendar as an array of integers.
return new StreamReader (path);\r
}\r
\r
- public FileStream OpenWrite (string path)\r
+ public static FileStream OpenWrite (string path)\r
{\r
return new FileStream(path, FileMode.OpenOrCreate, FileAccess.Write, FileShare.None);\r
}\r
namespace System.IO
{
- public class Path
+ public sealed class Path
{
public static readonly char AltDirectorySeparatorChar;
public static readonly char DirectorySeparatorChar;
}\r
}\r
\r
- public Encoding CurrentEncoding\r
+ public virtual Encoding CurrentEncoding\r
{\r
get {\r
return internalEncoding;\r
if (sym_writer != null)
scopes.Push (sym_writer.OpenScope (code_len));
}
- public virtual LocalBuilder DeclareLocal (Type localType) {
+ public LocalBuilder DeclareLocal (Type localType) {
LocalBuilder res = new LocalBuilder (module, localType);
if (locals != null) {
LocalBuilder[] new_l = new LocalBuilder [locals.Length + 1];
cur_stack -= mparams.Length;
}
[CLSCompliant(false)]
- public virtual void Emit (OpCode opcode, sbyte val) {
+ public void Emit (OpCode opcode, sbyte val) {
make_room (3);
ll_emit (opcode);
code [code_len++] = (byte)val;
public virtual void ThrowException (Type exceptionType) {
throw new NotImplementedException ();
}
- public virtual void UsingNamespace (String usingNamespace) {
+ public void UsingNamespace (String usingNamespace) {
throw new NotImplementedException ();
}
throw new NotImplementedException ();
}
- public String[] GetManifestResourceNames ()
+ public virtual String[] GetManifestResourceNames ()
{
throw new NotImplementedException ();
}
throw new NotImplementedException ();
}
- public ManifestResourceInfo GetManifestResourceInfo (String resourceName)
+ public virtual ManifestResourceInfo GetManifestResourceInfo (String resourceName)
{
throw new NotImplementedException ();
}
namespace System.Reflection {
[Serializable]
- public class AssemblyName : ISerializable // ICloneable, , IDeserializationCallback
+ public sealed class AssemblyName : ISerializable // ICloneable, , IDeserializationCallback
{
string name;
string codebase;
version = (Version)si.GetValue ("_Version", typeof (Version));
}
- public virtual string Name {
+ public string Name {
get {
return name;
}
}
}
- public virtual string CodeBase {
+ public string CodeBase {
get {
return codebase;
}
}
}
- public virtual Version Version {
+ public Version Version {
get {
return version;
}
get {return (Attributes & FieldAttributes.InitOnly) != 0;}
}
- [MonoTODO]
- public virtual void SetValue (object obj, object val, BindingFlags invokeAttr, Binder binder,
- CultureInfo culture) {
- }
+ public abstract void SetValue (object obj, object val, BindingFlags invokeAttr, Binder binder, CultureInfo culture);
[MonoTODO]
public void SetValue( object obj, object value) {
MonoFieldInfo.get_field_info (this, out info);
return String.Format ("{0} {1}", info.type, info.name);
}
+
+ [MonoTODO]
+ public override void SetValue (object obj, object val, BindingFlags invokeAttr, Binder binder, CultureInfo culture)
+ {
+ }
}
}
namespace System.Reflection
{
[Serializable]
- public class TargetInvocationException : ApplicationException
+ public sealed class TargetInvocationException : ApplicationException
{
private TargetInvocationException () {}
}
namespace System.Reflection
{
[Serializable]
- public class TargetParameterCountException : ApplicationException
+ public sealed class TargetParameterCountException : ApplicationException
{
public TargetParameterCountException ()
: base (Locale.GetText ("Number of parameter does not match expected count."))
reader = readerToEnumerate;
}
- public DictionaryEntry Entry
+ public virtual DictionaryEntry Entry
{
get {
if (null == reader.stream)
}
}
- public object Key
+ public virtual object Key
{
get {
if (null == reader.stream)
}
}
- public object Value
+ public virtual object Value
{
get {
if (null == reader.stream)
}
}
- public object Current
+ public virtual object Current
{
get {
if (null == reader.stream)
}
}
- public bool MoveNext ()
+ public virtual bool MoveNext ()
{
if (null == reader.stream)
throw new InvalidOperationException("ResourceReader is closed.");
[Serializable]
public class ResourceSet : IDisposable
{
-
+
protected IResourceReader Reader;
protected Hashtable Table;
-
+
// Constructors
protected ResourceSet () {}
public ResourceSet (IResourceReader reader)
public ResourceSet (Stream stream)
{
Reader = new ResourceReader (stream);
- }
-
- public ResourceSet (String fileName)
- {
- Reader = new ResourceReader (fileName);
- }
-
- public virtual void Close ()
- {
- Dispose (true);
- }
-
- public void Dispose()
- {
- Dispose (true);
- }
-
- protected void Dispose (bool disposing)
+ }
+
+ public ResourceSet (String fileName)
+ {
+ Reader = new ResourceReader (fileName);
+ }
+
+ public virtual void Close ()
+ {
+ Dispose (true);
+ }
+
+ public void Dispose()
+ {
+ Dispose (true);
+ }
+
+ protected virtual void Dispose (bool disposing)
{
if (disposing) {
Reader = null;
Table = null;
}
}
-
- public virtual Type GetDefaultReader ()
- {
- return (typeof (ResourceReader));
- }
- public virtual Type GetDefaultWriter ()
- {
- return (typeof (ResourceWriter));
- }
-
- public virtual object GetObject (string name)
- {
- if (name == null)
- throw new ArgumentNullException ("The name parameter is null.");
- if (Reader == null)
- throw new InvalidOperationException ("The ResourceSet has been closed.");
- if (Table == null) {
- ReadResources ();
- return Table[name];
- } else
- return Table[name];
- }
+
+ public virtual Type GetDefaultReader ()
+ {
+ return (typeof (ResourceReader));
+ }
+ public virtual Type GetDefaultWriter ()
+ {
+ return (typeof (ResourceWriter));
+ }
+
+ public virtual object GetObject (string name)
+ {
+ if (name == null)
+ throw new ArgumentNullException ("The name parameter is null.");
+ if (Reader == null)
+ throw new InvalidOperationException ("The ResourceSet has been closed.");
+ if (Table == null) {
+ ReadResources ();
+ return Table[name];
+ } else
+ return Table[name];
+ }
public virtual object GetObject (string name, bool ignoreCase)
{
if (name == null)
public virtual string GetString (string name)
{
- Object o = GetObject (name);
- if (o is string)
- return (string) o;
- return null;
+ Object o = GetObject (name);
+ if (o is string)
+ return (string) o;
+ return null;
}
public virtual string GetString (string name, bool ignoreCase)
- {
- Object o = GetObject (name, ignoreCase);
- if (o is string)
- return (string) o;
- return null;
- }
-
+ {
+ Object o = GetObject (name, ignoreCase);
+ if (o is string)
+ return (string) o;
+ return null;
+ }
+
protected virtual void ReadResources ()
{
IDictionaryEnumerator i = Reader.GetEnumerator();
-
+
if (Table == null)
Table = new Hashtable ();
i.Reset ();
-
+
while (i.MoveNext ())
Table.Add (i.Key, i.Value);
}
namespace System.Runtime.CompilerServices {
[AttributeUsage(AttributeTargets.Property, Inherited=false)] [Serializable]
- public class IndexerNameAttribute : Attribute {
+ public sealed class IndexerNameAttribute : Attribute {
public IndexerNameAttribute (string indexer_name)
{
}
namespace System.Runtime.CompilerServices {
[AttributeUsage(AttributeTargets.Method, Inherited=false)] [Serializable]
- public class MethodImplAttribute : Attribute {
+ public sealed class MethodImplAttribute : Attribute {
MethodImplOptions impl_options;
public MethodImplAttribute ()
namespace System.Runtime.InteropServices
{
- class Marshal
+ sealed class Marshal
{
private Marshal () {}
}
}
- public IContextProperty GetProperty (string name)
+ public virtual IContextProperty GetProperty (string name)
{
if (context_properties == null)
return null;
return null;
}
- public void SetProperty (IContextProperty prop)
+ public virtual void SetProperty (IContextProperty prop)
{
if (prop == null)
throw new ArgumentNullException ("IContextProperty");
/// <summary>
/// Adds the current context property to the IConstructionCallMessage
/// </summary>
- public void GetPropertiesForNewContext (IConstructionCallMessage msg)
+ public virtual void GetPropertiesForNewContext (IConstructionCallMessage msg)
{
if (msg == null)
throw new ArgumentNullException ("IConstructionCallMessage");
// True whether the context arguments satisfies the requirements
// of the current context.
// </summary>
- public bool IsContextOK (Context ctx, IConstructionCallMessage msg)
+ public virtual bool IsContextOK (Context ctx, IConstructionCallMessage msg)
{
if (msg == null)
throw new ArgumentNullException ("IConstructionCallMessage");
return true;
}
- public bool IsNewContextOK (Context ctx)
+ public virtual bool IsNewContextOK (Context ctx)
{
return true;
}
bool completed;
bool endinvoke_called;
- public object AsyncState
+ public virtual object AsyncState
{
get {
return async_state;
}
}
- public WaitHandle AsyncWaitHandle
+ public virtual WaitHandle AsyncWaitHandle
{
get {
return handle;
}
}
- public bool CompletedSynchronously
+ public virtual bool CompletedSynchronously
{
get {
return sync_completed;
}
}
- public bool IsCompleted
+ public virtual bool IsCompleted
{
get {
return completed;
get {
return endinvoke_called;
}
+ set {
+ endinvoke_called = value;
+ }
}
- public object AsyncDelegate
+ public virtual object AsyncDelegate
{
get {
return async_delegate;
\r
[MonoTODO]\r
[Serializable]
- public class LogicalCallContext : ISerializable, ICloneable {\r
+ public sealed class LogicalCallContext : ISerializable, ICloneable {\r
internal LogicalCallContext () {}
}
}
- public object ReturnValue {
+ public virtual object ReturnValue {
get {
return msg.rval;
}
namespace System.Runtime.Serialization {
[Serializable]
- public sealed class SerializationException : SystemException {
+ public class SerializationException : SystemException {
// Constructors
public SerializationException ()
: base ("An error occurred during (de)serialization")
} // DESDecryptor
- public class DESCryptoServiceProvider {
+ public sealed class DESCryptoServiceProvider {
private byte [] iv;
private byte [] key;
// Factories
//
- public virtual ICryptoTransform CreateEncryptor()
+ public ICryptoTransform CreateEncryptor()
{
return new DESEncryptor (key, iv);
}
- public virtual ICryptoTransform CreateDecryptor()
+ public ICryptoTransform CreateDecryptor()
{
return new DESDecryptor (key, iv);
}
}
}
- public virtual byte[] IV {
+ public byte[] IV {
get {
return this.iv;
}
/// <summary>
/// </summary>
- public virtual bool CanTransformMultipleBlocks {
+ public bool CanTransformMultipleBlocks {
get {
return false;
}
/// <remarks>
/// The input block size for Base64 decoder is always 1 byte.
/// </remarks>
- public virtual int InputBlockSize {
+ public int InputBlockSize {
get {
return 1;
}
/// <remarks>
/// The value returned by this property is always 3.
/// </remarks>
- public virtual int OutputBlockSize {
+ public int OutputBlockSize {
get {
return 3;
}
/// <summary>
/// </summary>
- public virtual int TransformBlock (byte [] inputBuffer,
+ public int TransformBlock (byte [] inputBuffer,
int inputOffset,
int inputCount,
byte [] outputBuffer,
/// <summary>
/// </summary>
- public virtual byte [] TransformFinalBlock (byte [] inputBuffer,
+ public byte [] TransformFinalBlock (byte [] inputBuffer,
int inputOffset,
int inputCount)
{
/// <summary>\r
/// Computes the entire hash of all the bytes in the byte array.\r
/// </summary>\r
- public virtual byte[] ComputeHash (byte[] input) {\r
+ public byte[] ComputeHash (byte[] input) {\r
// inputData = input.Clone();\r
HashCore (input, 0, input.Length);\r
HashValue = HashFinal ();\r
/// created on - 2/23/2002 6:21:44 PM\r
/// </remarks>\r
namespace System.Security.Cryptography {\r
- public class RijndaelManaged : Rijndael {\r
+ public sealed class RijndaelManaged : Rijndael {\r
\r
/// <summary>\r
/// RijndaelManaged constructor.\r
/// C# implementation of the SHA1 cryptographic hash function.\r
/// LAMESPEC?: Basically the same thing as SHA1Managed except for how its implemented.\r
/// </summary>\r
- public class SHA1CryptoServiceProvider : SHA1 {\r
+ public sealed class SHA1CryptoServiceProvider : SHA1 {\r
private const int BLOCK_SIZE_BYTES = 64;\r
private const int HASH_SIZE_BYTES = 20;\r
private const int HASH_SIZE_BITS = 160;\r
- [CLSCompliant(false)] protected uint[] _H; // these are my chaining variables\r
- [CLSCompliant(false)] protected uint count;\r
+ [CLSCompliant(false)] private uint[] _H; // these are my chaining variables\r
+ [CLSCompliant(false)] private uint count;\r
private byte[] _ProcessingBuffer; // Used to start data when passed less than a block worth.\r
private int _ProcessingBufferCount; // Counts how much data we have stored that still needs processed.\r
\r
/// <summary>
/// </summary>
- public virtual bool CanTransformMultipleBlocks {
+ public bool CanTransformMultipleBlocks {
get {
return false;
}
/// <remarks>
/// The returned value is always 3.
/// </remarks>
- public virtual int InputBlockSize {
+ public int InputBlockSize {
get {
return 3;
}
/// <remarks>
/// The value returned by this property is always 4.
/// </remarks>
- public virtual int OutputBlockSize {
+ public int OutputBlockSize {
get {
return 4;
}
/// <summary>
/// </summary>
- public virtual int TransformBlock (byte [] inputBuffer,
+ public int TransformBlock (byte [] inputBuffer,
int inputOffset,
int inputCount,
byte [] outputBuffer,
/// <summary>
/// </summary>
- public virtual byte [] TransformFinalBlock (byte [] inputBuffer,
+ public byte [] TransformFinalBlock (byte [] inputBuffer,
int inputOffset,
int inputCount)
{
namespace System.Security.Permissions {
+ [MonoTODO ("These values are WRONG!!!, and incomplete")]
/// <summary>
/// </summary>
public enum IsolatedStorageContainment {
UnrestrictedIsolatedStorage = 7,
} // IsolatedStorageContainment
+/* here are the correct ones (from msdn)
+ [Serializable]
+ public enum IsolatedStorageContainment
+ {
+ None = 0x00,
+ DomainIsolationByUser = 0x10,
+ AssemblyIsolationByUser = 0x20,
+ DomainIsolationByRoamingUser = 0x50,
+ AssemblyIsolationByRoamingUser = 0x60,
+ AdministerIsolatedStorageByUser = 0x70,
+ UnrestrictedIsolatedStorage = 0xF0,
+ };
+*/
+
} // System.Security.Permissions
AttributeTargets.Struct | AttributeTargets.Constructor |\r
AttributeTargets.Method)]\r
[Serializable]\r
- public class IsolatedStoragePermissionAttribute : CodeAccessSecurityAttribute {\r
+ public abstract class IsolatedStoragePermissionAttribute : CodeAccessSecurityAttribute {\r
\r
public IsolatedStoragePermissionAttribute (SecurityAction action) : base (action) {\r
}\r
namespace System.Security.Policy {\r
\r
[Serializable]\r
- public class PolicyStatement : ISecurityEncodable, ISecurityPolicyEncodable {\r
+ public sealed class PolicyStatement : ISecurityEncodable, ISecurityPolicyEncodable {\r
public PolicyStatement (PermissionSet perms) :\r
this (perms, PolicyStatementAttribute.Nothing)\r
{\r
this.user_name = user_name;
}
- public string AuthenticationType {
+ public virtual string AuthenticationType {
get {
return authentication_type;
}
}
- public string Name {
+ public virtual string Name {
get {
return user_name;
}
}
- public bool IsAuthenticated {
+ public virtual bool IsAuthenticated {
get {
return true;
}
this.roles = roles;
}
- public IIdentity Identity {
+ public virtual IIdentity Identity {
get {
return identity;
}
}
- public bool IsInRole (string role)
+ public virtual bool IsInRole (string role)
{
foreach (string r in roles)
if (role == r)
namespace System.Security.Principal {
- enum WindowsAccountType {
+ internal enum WindowsAccountType {
Normal,
Guest,
System,
namespace System.Security.Principal {
- enum WindowsBuiltInRole {
+ internal enum WindowsBuiltInRole {
Administrator = 544,
User = 545,
Guest = 546,
}
[MonoTODO]
- public virtual Encoding GetEncoding (int codepage)
+ public static Encoding GetEncoding (int codepage)
{
// FIXME
return null;
}
[MonoTODO]
- public virtual Encoding GetEncoding (string name)
+ public static Encoding GetEncoding (string name)
{
// FIXME
return null;
\r
[AttributeUsage(AttributeTargets.All)]\r
[Serializable]\r
- public class AttributeUsageAttribute : Attribute {\r
+ public sealed class AttributeUsageAttribute : Attribute {\r
AttributeTargets valid_on;\r
bool allow_multiple, inherited;\r
\r
using System;
namespace System {
- public class BitConverter {
+ public sealed class BitConverter {
private BitConverter () {}
/// </remarks>
[AttributeUsage(AttributeTargets.All)]
[Serializable]
- public class CLSCompliantAttribute : Attribute {
+ public sealed class CLSCompliantAttribute : Attribute {
bool is_compliant;
namespace System {
- interface ICustomFormatter {
+ public interface ICustomFormatter {
string Format (string format, object arg, IFormatProvider formatProvider);
}
}
private void *value;
- public static IntPtr Zero;
+ public static readonly IntPtr Zero;
static IntPtr ()
{
namespace System
{
[AttributeUsage (AttributeTargets.Method)]
- public class LoaderOptimizationAttribute : Attribute
+ public sealed class LoaderOptimizationAttribute : Attribute
{
private LoaderOptimization lo;
namespace System
{
[AttributeUsage (AttributeTargets.Method)]
- public class MTAThreadAttribute : Attribute
+ public sealed class MTAThreadAttribute : Attribute
{
// Constructors
public MTAThreadAttribute () : base ()
}
// Properties
- public virtual double OffendingNumber {
+ public double OffendingNumber {
get {
return offending_number;
}
AttributeTargets.Field | AttributeTargets.Event |
AttributeTargets.Interface | AttributeTargets.Delegate)]
[Serializable]
- public class ObsoleteAttribute : Attribute
+ public sealed class ObsoleteAttribute : Attribute
{
private string message;
private bool isError = false;
namespace System
{
[AttributeUsage (AttributeTargets.Method)]
- public class STAThreadAttribute : Attribute
+ public sealed class STAThreadAttribute : Attribute
{
// Constructors
public STAThreadAttribute () : base ()
namespace System {
[Serializable]
- public class StackOverflowException : SystemException {
+ public sealed class StackOverflowException : SystemException {
// Constructors
public StackOverflowException ()
: base (Locale.GetText ("The requested operation caused a stack overflow"))
[MethodImplAttribute(MethodImplOptions.InternalCall)]
internal static extern bool type_is_subtype_of (Type a, Type b, bool check_interfaces);
- public bool IsSubclassOf (Type c)
+ public virtual bool IsSubclassOf (Type c)
{
return type_is_subtype_of (this, c, false);
}
namespace System {
[Serializable]
- public class TypeInitializationException : SystemException {
+ public sealed class TypeInitializationException : SystemException {
string type_name;
// Constructors
projects / mono.git / commitdiff