Logo Search packages:      
Sourcecode: ndoc version File versions  Download package

Test.cs

using System;

namespace NDoc.Test
{
      /// <summary>
      /// <p>This documentation will show up as the summary of a class
      /// <see cref="NamespaceDoc"/>, when the UseNamespaceDocSummaries
      /// configuration flag is set to <see langword="false"/>. When
      /// UseNamespaceDocSummaries is set to <see langword="true"/>,
      /// the summary will show up as the summary of the <see cref="NDoc.Test"/>
      /// namespace.</p>
      /// <p>This allows you to reference other types from within the
      /// summary documentation for the namespace, without having to use
      /// fully qualified ids. E.g. the reference to <see cref="Class"/> is
      /// created by using "&lt;see cref="Class"/&gt;" instead of
      /// "&lt;see cref="T:NDoc.Test.Class"/&gt;" as you have to say using
      /// the namespace summaries dialog.</p>
      /// </summary>
00019       public class NamespaceDoc {}

#if UNICODE_NAMES
      /// <summary>
      /// DenGrønneKasse don't work in NDoc.
      /// </summary>
      public class DenGrønneKasse
      {
            /// <summary>
            /// Not working in NDoc
            /// </summary>
            public void TilføjÆble()
            {
            }
      }
#endif

      /// <summary>Represents a normal class.</summary>
      /// <remarks>Conceptualizing random endpoints in a access matrix
      /// provides reach extentions enterprise wide. Respective divisions
      /// historically insignificant, upscale trendlines in a management
      /// inventory analysis survivabilty format.</remarks>
00041       public class Class
      {
            /// <overloads>Initializes a new instance of the Class class.</overloads>
            /// <summary>Initializes a new instance of the <see cref="Class"/> class with no param.</summary>
00045             public Class() { }

            /// <summary>Initializes a new instance of the Class class with an integer.</summary>
00048             public Class(int i) { }

            /// <summary>Initializes a new instance of the Class class with a string.</summary>
00051             public Class(string s) { }

            /// <summary>Initializes a new instance of the Class class with a double.</summary>
00054             protected Class(double d) { }

            /// <summary>Initializes a new instance of the Class class with 3 integers.</summary>
            /// <param name="i1">This is the first integer parameter.
            /// This is the first integer parameter. This is the first integer
            /// parameter. This is the first integer parameter.</param>
            /// <param name="i2">This is the second integer parameter.</param>
            /// <param name="i3">This is the third integer parameter.</param>
            /// <remarks>
            /// Yes, the <paramref name="i3"/> parameter is of type int.
            /// </remarks>
00065             public Class(int i1, int i2, int i3) { }

            /// <summary>
            /// This is the static constructor.
            /// </summary>
00070             static Class() { }

            /// <summary>Holds an <c>int</c> value.</summary>
00073             public int Field;

            /// <summary>Holds an read-only<c>int</c> value.</summary>
00076             public readonly int ReadOnlyField = 12;

            /// <summary>Holds a static <c>int</c> value.</summary>
00079             public static int StaticField;

            /// <summary>Gets a value of <see cref="Property"/>.</summary>
            /// <remarks>Gets a value of <see cref="this"/>.</remarks>
            public int Property
00084             {
                  get { return 0; }
            }

            /// <summary>Gets a static value.</summary>
            public static int StaticProperty
00090             {
                  get { return 0; }
            }

            /// <summary>This overloaded indexer accepts an int.</summary>
            /// <param name="i">The int index.</param>
            /// <value>Always returns 0.</value>
            /// <remarks>No comment.</remarks>
            public int this[int i]
00099             {
                  get { return 0; }
            }

            /// <summary>This overloaded indexer accepts a string.</summary>
            public int this[string s]
            {
                  get { return 0; }
                  set {}
            }

            /// <summary>This overloaded indexer accepts three ints.</summary>
            public int this[int i1, int i2, int i3]
            {
                  get { return 0; }
                  set {}
            }

            /// <summary>Executes some code.</summary>
00118             public void Method() { }

            /// <summary>Executes some code.</summary>
00121             public void Method(int i1, int i2, int i3) { }

            /// <summary>Executes some static code.</summary>
00124             public static void StaticMethod() { }

            /// <summary>Uses some parameter modifyers.</summary>
00127             public void ParameterModifyers( ref int refParam, out int outParam, params object[] paramArray )
            {
                  outParam = 0;
            }

            /// <summary>An overload.</summary>
00133             public void ParameterModifyers( int a, ref int refParam, out int outParam, params object[] paramArray )
            {
                  outParam = 0;
            }

            /// <summary>This is a simple event that uses the Handler delegate.</summary>
00139             public event Handler Event;

            /// <summary>
            /// Raises some events.
            /// </summary>
            /// <remarks><para>
            /// Raises the <see cref="Event"/> event when <see cref="Method"/> is called,
            /// if <see cref="Field"/> is greater than 0.
            /// </para><para>
            /// The above paragraph is only intended to test crefs on different member types...
            /// </para></remarks>
            /// <event cref="Event">Raised when something occurs.</event>
            /// <event cref="AccessorsEvent">Raised when it occurs...</event>
            /// <event cref="ProtectedEvent">Raised when something else occurs.</event>
            /// <event cref="EventWithArgs">Raised when it feels like it.</event>
            /// <event cref="System.Diagnostics.EventLog.EntryWritten">Raised when an entry was written to the event log.</event>
            /// <event cref="SomeUnknownEvent">Unknown.</event>
            /// <event cref="EventWithMoreArgs">Never raised?</event>
            /// <event cref="MultiEvent">Raised many times?</event>
            /// <exception cref="Exception">
            /// Some exception is thrown.
            /// </exception>
            /// <exception cref="MyException">
            /// Some other exception may also be thrown.
            /// </exception>
            /// <exception cref="SomeUnknownException">Unknown.</exception>
00165             public void RaisesSomeEvents()
            {
                  Event(this, new EventArgs());
                  ProtectedEvent(this, new EventArgs());
                  StaticEvent(this, new EventArgs());
                  EventWithArgs(this, new EventArgsTest());
                  EventWithMoreArgs(this, new EventArgsDerived());
                  MultiEvent(this, new EventArgsOne());
            }

            /// <summary>A private event.</summary>
00176             private event Handler _event;

            /// <summary>This event uses the <b>add</b> and <b>remove</b> accessors.</summary>
            public event Handler AccessorsEvent
00180             {
                  add { _event += value; }
                  remove { _event -= value; }
            }

            /// <summary>This event has arguments.</summary>
00186             public event HandlerWithArgs EventWithArgs;

            /// <summary>This event has more arguments.</summary>
            /// <remarks>Check the links in the Event Data table...</remarks>
00190             public event HandlerWithMoreArgs EventWithMoreArgs;

            /// <summary>This event is protected.</summary>
00193             protected event Handler ProtectedEvent;

            /// <summary>Can you do this?</summary>
00196             public static event Handler StaticEvent;

            /// <summary>An event with one property.</summary>
00199             public event MulticastHandler MultiEvent;

            /// <summary>This is my first overloaded operator.</summary>
            /// <remarks>Why do we have to declare them as static?</remarks>
00203             public static bool operator !(Class x)
            {
                  return false;
            }
      }

      /// <summary>This event has one property.</summary>
00210       public class EventArgsOne
      {
            /// <summary>This is a unique event argument property.</summary>
            public bool OneProperty
00214             {
                  get { return true; }
                  set { }
            }
      }

      /// <summary>This is an event arguments class.</summary>
00221       public class EventArgsTest : System.ComponentModel.CancelEventArgs
      {
            /// <summary>This is an event arguments property.</summary>
            public string EventArgsTestProperty
00225             {
                  get { return ""; }
                  set { }
            }
      }

      /// <summary>This is a derived event arguments class.</summary>
00232       public class EventArgsDerived : EventArgsTest
      {
            /// <summary>This event arguments property is declared in the derived class.</summary>
            public string EventArgsDerivedProperty
00236             {
                  get { return ""; }
                  set { }
            }
      }

      /// <summary>This is a delegate with arguments used by Class.</summary>
      public delegate void HandlerWithArgs(object sender, EventArgsTest e);

      /// <summary>This is a delegate with more arguments used by Class.</summary>
      public delegate void HandlerWithMoreArgs(object sender, EventArgsDerived e);

      /// <summary>This is a simple delegate used by Class.</summary>
      public delegate void Handler(object sender, EventArgs e);

      /// <summary>This is a multicast delegate.</summary>
      public delegate int MulticastHandler(object sender, EventArgsOne e);

      /// <summary>This is an interface.</summary>
00255       public interface Interface
      {
            /// <summary>This is a property in an interface.</summary>
            int InterfaceProperty
00259             {
                  get;
            }

            /// <summary>This is a method in an interface.</summary>
            void InterfaceMethod();

            /// <summary>This event is declared in an interface.</summary>
00267             event Handler InterfaceEvent;
      }

      /// <summary>This interface inherits from another interface.</summary>
00271       public interface InterfaceInherited : Interface
      {
            /// <summary>This is another method declared in an inteface.</summary>
            void OtherMethod();
      }

      /// <summary>This class implements <see cref="Interface"/>.</summary>
00278       public class ImplementsInterface : Interface
      {
            /// <summary>
            /// Gets the InterfaceProperty.
            /// </summary>
            /// <value></value>
            public int InterfaceProperty
00285             {
                  get
                  {
                        return 0;
                  }
            }

            /// <summary>
            /// InterfaceMethod.
            /// </summary>
00295             public void InterfaceMethod()
            {
                  InterfaceEvent(this, new EventArgs());
            }

            /// <summary>
            /// InterfaceEvent
            /// </summary>
00303             public event Handler InterfaceEvent;

      }

      /// <summary>This class is derived from <see cref="Base"/> and implements <see cref="Interface"/>.</summary>
00308       public class ImplementsInterfaceDerivedBase : Base, Interface
      {
            /// <summary>
            /// Gets the InterfaceProperty.
            /// </summary>
            /// <value></value>
            public int InterfaceProperty
00315             {
                  get
                  {
                        return 0;
                  }
            }

            /// <summary>
            /// InterfaceMethod.
            /// </summary>
00325             public void InterfaceMethod()
            {
                  InterfaceEvent(this, new EventArgs());
            }

            /// <summary>
            /// InterfaceEvent
            /// </summary>
00333             public event Handler InterfaceEvent;

      }

      /// <summary>This is an empty interface.</summary>
00338       public interface Interface1
      {
      }

      /// <summary>This is also an empty interface.</summary>
00343       public interface Interface2
      {
      }

      /// <summary>This class implements two empty interfaces.</summary>
00348       public class ImplementsTwoInterfaces : Interface1, Interface2
      {
      }

      /// <summary>Represents an abstract class.</summary>
00353       public abstract class Abstract
      {
            /// <summary>This event is decalred in the Abstract class.</summary>
00356             public abstract event Handler InterfaceEvent;
      }

      /// <summary>Represents a base class.</summary>
00360       public class Base
      {
            /// <summary>This property is declared in the Base class.</summary>
            public int BaseProperty
00364             {
                  get { return 0; }
            }

            /// <summary>This method is declared in the Base class.</summary>
00369             public void BaseMethod() { }

            /// <summary>This method is declared in the Base class without the "new" keyword.</summary>
00372             public void NewMethod() { }

            /// <summary>This method is declared in the Base class.</summary>
00375             public void Overloaded(int i) { }

            /// <summary>This method is declared in the Base class.</summary>
00378             public void Overloaded(byte i) { }

            /// <summary>This virtual method is declared in the Base class.</summary>
00381             public virtual void TwoVirtualOverloads(string key) { }
            /// <summary>This virtual method is declared in the Base class.</summary>
00383             public virtual void TwoVirtualOverloads(int index) { }

            /// <summary>This field is declared in the Base class.</summary>
00386             public int BaseField;

            /// <summary>This event is declared in the Base class.</summary>
00389             public event Handler BaseEvent;

            private void UseBaseEvent()
            {
                  BaseEvent(this, new EventArgs());
            }

            /// <summary>A static method in the Base class.</summary>
            /// <remarks>This should not appear in derived classes.</remarks>
00398             public static void StaticBaseMethod() {}
      }

      /// <summary>Represents a derived class.</summary>
00402       public class Derived : Base
      {
            /// <summary>This property is declared in the Derived class.</summary>
            public int DerivedProperty
00406             {
                  get { return 0; }
            }

            /// <summary>This method is declared in the Derived class.</summary>
            /// <remarks>This is a reference to a parent member: <see cref="Base.BaseProperty"/></remarks>
00412             public void DerivedMethod() { }

            /// <summary>This method is declared in the Derived class with the "new" keyword.</summary>
00415             public new void NewMethod() { }

            /// <summary>This method is overloaded in the Derived class.</summary>
00418             public void Overloaded(string s) { }

            /// <summary>This method is also overloaded in the Derived class.</summary>
00421             public void Overloaded(double d) { }

            /// <summary>This method is also overloaded in the Derived class.</summary>
00424             public void Overloaded(char c) { }

            /// <summary>This method is also overloaded in the Derived class.</summary>
            /// <remarks>This method accepts a type declared in the same namespace.</remarks>
00428             public void Overloaded(Interface i) { }

            /// <summary>This method is overriden in the Derived class.</summary>
            /// <remarks>Only one of the two overloads is overriden.</remarks>
00432             public override void TwoVirtualOverloads(string key) { }

            /// <summary>A static method in the Derived class.</summary>
            /// <remarks>This should not appear in derived classes.</remarks>
00436             public static void StaticDerivedMethod() {}
      }

      /// <summary>Represents another derived class.</summary>
00440       public class Derived2 : Derived
      {
            /// <summary>
            /// This event is declared in the Derived2 class.
            /// </summary>
00445             public event Handler EventInDerived;

            private void UseDerivedEvent()
            {
                  EventInDerived(this, new EventArgs());
            }

            /// <summary>This method is overriden in the Derived class.</summary>
            /// <remarks>Both overloads are overriden in this class.</remarks>
00454             public override void TwoVirtualOverloads(string key) { }

            /// <summary>This method is overriden in the Derived class.</summary>
            /// <remarks>Both overloads are overriden in this class.</remarks>
00458             public override void TwoVirtualOverloads(int key) { }

            /// <summary>
            /// Add only one overload in Derived2 class.
            /// </summary>
00463             public void Overloaded(object o) { }
      }

      /// <summary>Represents an outer class.</summary>
00467       public class Outer
      {
            /// <summary>Represents an inner class.</summary>
            /// <remarks>These are some remarks.</remarks>
00471             public class Inner
            {
                  /// <summary>This is a field of the inner class.</summary>
                  /// <remarks>These are some remarks</remarks>
00475                   public int InnerField;

                  /// <summary>This is a property of the inner class.</summary>
                  /// <remarks>These are some remarks</remarks>
00479                   public int InnerProperty { get { return 0; } }

                  /// <summary>This is a method of the inner class.</summary>
                  /// <remarks>These are some remarks</remarks>
00483                   public void InnerMethod() { }

                  /// <summary>This is an enumeration nested in a nested class.</summary>
00486                   public enum InnerInnerEnum
                  {
                        /// <summary>Foo</summary>
                        Foo
                  }
            }

            /// <summary>Function returning a public inner class oject.</summary>
00494             public Inner GetInnerClassObject() { return new Inner(); }

            /// <summary>Function with a public inner class oject parameter.</summary>
00497             public void TestInnerClassObject(Inner TheInner) { }

            /// <summary>Represents a private inner class.</summary>
00500             private class PrivateInner
            {
            }

            /// <summary>This is a nested enumeration.</summary>
00505             public enum InnerEnum
            {
                  /// <summary>Foo</summary>
                  Foo
            }

            /// <summary>This is a nested interface.</summary>
00512             public interface InnerInterface {}

            /// <summary>This is a nested structure.</summary>
00515             public struct InnerStruct {}

            /// <summary>This is a nested delegate.</summary>
            public delegate void InnerDelegate(string myparam);
      }

      /// <summary>This is an internal class.</summary>
00522       internal class Internal
      {
            /// <summary>This method is declared in the Internal class.</summary>
00525             internal void InternalMethod() { }
      }

      /// <summary>This is the first struct.</summary>
00529       public struct Struct1
      {
            /// <summary>This is the first field in the first struct.</summary>
00532             public int Field1;

            /// <summary>This is the second field in the first struct.</summary>
00535             public string Field2;

            /// <summary>A property in a struct.</summary>
            public int Property
00539             {
                  get { return 1; }
                  set { }
            }

            /// <summary>A method in a struct.</summary>
00545             public int Method() { return -1; }

            /// <summary>A static method in a struct.</summary>
00548             public static int StaticMethod() { return -1; }
      }

      /// <summary>This is the second struct.</summary>
00552       public struct Struct2
      {
      }

      /// <summary>This is an enumeration.</summary>
      public enum Enum
      {
            /// <summary>Represents Foo.</summary>
            Foo,
            /// <summary>Represents Bar.</summary>
            Bar,
            /// <summary>Represents Baz.</summary>
            Baz,
            /// <summary>Represents Quux.</summary>
            Quux
      }

      /// <summary>
      /// This is an enum that is not the default <see cref="System.Int32"/> type.
      /// It is an <see cref="System.Int16"/> type
      /// </summary>
      public enum EnumNonInt : short
      {
            /// <summary>
            /// The only entry in the short enum
            /// </summary>
            entry,
      }

      /// <summary>This is an enumeration with the FlagsAttribute.</summary>
      [Flags]
      public enum EnumFlags
      {
            /// <summary>Represents Foo.</summary>
            Foo=1,
            /// <summary>Represents Bar.</summary>
            Bar=2,
            /// <summary>Represents Baz.</summary>
            Baz=4,
            /// <summary>Represents Quux.</summary>
            Quux=8
      }

      /// <summary>This class has lots of &lt;see&gt; elements in the remarks.</summary>
      /// <remarks>See <see cref="Class"/>.
      /// See <see cref="Interface"/>.
      /// See <see cref="Struct1"/>.
      /// See <see cref="Base.BaseMethod"/>.
      /// See <see cref="Derived.DerivedMethod"/>.
      /// See <see cref="Outer"/>.
      /// See <see cref="Outer.Inner"/>.
      /// See <see cref="Handler"/>.
      /// See <see cref="Enum"/>.
      /// See <see cref="Enum.Bar"/>.
      /// See <see href="http://ndoc.sf.net/" />.
      /// See <see href="http://ndoc.sf.net/">NDOC</see>.
      /// </remarks>
00609       public class See
      {
            /// <summary>
            /// This field's documentation references <see cref="RefProp1"/>.
            /// </summary>
00614             public int Field1 = 0;

            /// <summary>
            /// This properties' documentation references <see cref="System.IO.TextWriter"/>.
            /// </summary>
            /// <remarks>
            /// <para>This is a link to <see cref="Prop1"/>.</para>
            /// <para>This is a labelled link to <see cref="Prop1">myself</see>.</para>
            /// <para>This is a link to <see cref="See"/>.</para>
            /// <para>This is a link to <see cref="SeeAlso"/>.</para>
            /// <para>This is also a link to <see cref="See"/>. </para>
            /// <para>This is also a link to <see cref="SeeAlso"/>. </para>
            /// <para>This is an labelled link to <see cref="See">Test.See</see>.</para>
            /// <para>This is an broken link to <see cref="something">something</see>.</para> 
            /// <para>This is an broken labelled link to <see cref="something">something</see>.</para> 
            /// </remarks>
            public string Prop1
00631             {
                  get { return "Prop1"; }
            }

            /// <summary>
            /// This method's documentation references <see cref="NDoc.Test.See.Prop1"/> and
            /// <see cref="Field1"/>.
            /// </summary>
00639             public void RefProp1()
            {
            }
      }

      /// <summary>This class has lots of &lt;seealso&gt; elements.</summary>
      /// <remarks>NDoc adds a special form of the &lt;seealso&gt; element.
      /// Instead of a cref attribute, you can specify a href attribute some text
      /// content just like a normal HTML &lt;a&gt; element.</remarks>
      /// <seealso href="http://ndoc.sf.net/">the ndoc homepage</seealso>
      /// <seealso cref="Class"/>
      /// <seealso cref="Interface"/>
      /// <seealso cref="Struct1"/>
      /// <seealso cref="Base.BaseMethod"/>
      /// <seealso cref="Derived.DerivedMethod"/>
      /// <seealso cref="Outer"/>
      /// <seealso cref="Outer.Inner"/>
      /// <seealso cref="Handler"/>
      /// <seealso cref="Enum"/>
      /// <seealso cref="Enum.Bar"/>
      /// <seealso href="http://slashdot.org/">Slashdot</seealso>
      /// <seealso cref="System.Object"/>
00661       public class SeeAlso
      {
            /// <summary>This method has lots of &lt;seealso&gt; elements.</summary>
            /// <seealso cref="Class"/>
            /// <seealso cref="Interface"/>
            /// <seealso cref="Struct1"/>
            /// <seealso cref="Base.BaseMethod"/>
            /// <seealso cref="Derived.DerivedMethod"/>
            /// <seealso cref="Outer"/>
            /// <seealso cref="Outer.Inner"/>
            /// <seealso cref="Handler"/>
            /// <seealso cref="Enum"/>
00673             public void AlsoSee() { }

            /// <summary>&lt;seealso cref="System.Object"/></summary>
            /// <seealso cref="System.Object"/>
00677             public void SeeSystemClass()
            {
            }

            /// <summary>&lt;seealso cref="System.String.Empty"/></summary>
            /// <seealso cref="System.String.Empty"/>
00683             public void SeeSystemField()
            {
            }

            /// <summary>&lt;seealso cref="System.String.Length"/></summary>
            /// <seealso cref="System.String.Length"/>
00689             public void SeeSystemProperty()
            {
            }

            /// <summary>&lt;seealso cref="System.Collections.ArrayList.Item"/></summary>
            /// <seealso cref="System.Collections.ArrayList.this"/>
00695             public void SeeSystemIndexer()
            {
            }

            /// <summary>&lt;seealso cref="System.Object.ToString"/></summary>
            /// <seealso cref="System.Object.ToString"/>
00701             public void SeeSystemMethod()
            {
            }

            /// <summary>&lt;seealso cref="System.Object.ToString"/></summary>
            /// <seealso cref="System.String.Equals"/>
00707             public void SeeSystemOverloadedMethod()
            {
            }

            /// <summary>&lt;seealso cref="System.Xml.XmlDocument.NodeChanged"/></summary>
            /// <seealso cref="System.Xml.XmlDocument.NodeChanged"/>
00713             public void SeeSystemEvent()
            {
            }

            /// <summary>&lt;seealso cref="System.IDisposable"/></summary>
            /// <seealso cref="System.IDisposable"/>
00719             public void SeeSystemInterface()
            {
            }

            /// <summary>&lt;seealso cref="System.DateTime"/></summary>
            /// <seealso cref="System.DateTime"/>
00725             public void SeeSystemStructure()
            {
            }

            /// <summary>&lt;seealso cref="System.EventHandler"/></summary>
            /// <seealso cref="System.EventHandler"/>
00731             public void SeeSystemDelegate()
            {
            }

            /// <summary>&lt;seealso cref="System.DayOfWeek"/></summary>
            /// <seealso cref="System.DayOfWeek"/>
00737             public void SeeSystemEnumeration()
            {
            }

            /// <summary>&lt;seealso cref="System.IO"/></summary>
            /// <seealso cref="System.IO"/>
00743             public void SeeSystemNamespace()
            {
            }
      }

      /// <summary>Represents a class containing properties.</summary>
00749       public abstract class Properties
      {
            /// <summary>This property has a getter and a setter.</summary>
            public int GetterAndSetter
00753             {
                  get { return 0; }
                  set { }
            }

            /// <summary>This property has a getter only.</summary>
            public int GetterOnly
00760             {
                  get { return 0; }
            }

            /// <summary>This property has a setter only.</summary>
            public int SetterOnly
00766             {
                  set { }
            }

            /// <summary>This property is abstract.</summary>
            public abstract int AbstractProperty
00772             {
                  get;
                  set;
            }

            /// <summary>This property is virtual.</summary>
            public virtual int VirtualProperty
00779             {
                  get { return 0; }
                  set { }
            }

            /// <summary>This is an overloaded indexer.</summary>
            /// <remarks>This indexer accepts an int parameter.</remarks>
            public int this[int foo]
00787             {
                  get { return 0; }
            }

            /// <summary>This is an overloaded indexer.</summary>
            /// <remarks>This indexer accepts a string parameter.</remarks>
            public int this[string foo]
            {
                  get { return 0; }
            }
      }

      /// <summary>Represents a class that has lots of links
      /// in its documentation.</summary>
00801       public class Links
      {
            /// <summary>Holds an integer.</summary>
00804             public int IntField;

            /// <summary>Gets or sets an integer.</summary>
            /// <value>an integer</value>
            public int IntProperty
00809             {
                  get { return 0; }
                  set { }
            }

            /// <summary>Returns nothing.</summary>
            /// <returns>Nada.</returns>
00816             public void VoidMethod() { }

            /// <summary>Returns an int.</summary>
00819             public int IntMethod() { return 0; }

            /// <summary>Returns a string.</summary>
00822             public string StringMethod() { return null; }

            /// <summary>This method accepts lots of parameters.</summary>
            /// <param name="i">an integer</param>
            /// <param name="s">a string</param>
            /// <param name="c">a character</param>
            /// <param name="d">a double</param>
            /// <remarks>The <paramref name="i"/> param is an integer.
            /// The <paramref name="s"/> param is a string.</remarks>
00831             public void LotsOfParams(int i, string s, char c, double d)
            {
            }
      }

      /// <summary>This class contains some example code.</summary>
      /// <example><code>
      /// public class HelloWorld {
      ///         static void Main() {
      ///               System.Console.WriteLine("Hello, World!");
      ///         }
      /// }
      /// </code></example>
00844       public class Example
      {
      }

      /// <summary>This class contains a method that throws exceptions.</summary>
00849       public class Exceptions
      {
            /// <summary>This method throws exceptions.</summary>
            /// <exception cref="Exception">A generic exception.</exception>
            /// <exception cref="ApplicationException">An application-specific exception.</exception>
00854             public void Throw()
            {
            }
      }

      /// <summary>This class contains &lt;see langword=""&gt; elements in the remarks.</summary>
      /// <remarks>The default style is <see langword="bold"/>.
      /// But <see langword="null"/>, <see langword="sealed"/>,
      /// <see langword="static"/>, <see langword="abstract"/>,
      /// and <see langword="virtual"/> do more.</remarks>
00864       public class Langword
      {
      }

      /// <summary>The remarks in this class contains examples of list elements.</summary>
00869       public class Lists
      {
            /// <summary>BulletMethodSummary</summary>
            /// <remarks>
            ///  <list type="bullet">
            ///   <item><description>Item One</description></item>
            ///   <item><description>Item Two</description></item>
            ///   <item><description>Item Three</description></item>
            ///  </list>
            /// </remarks>
00879             public void BulletMethod()
            {
            }

            /// <summary>NumberMethodSummary</summary>
            /// <remarks>
            ///  <list type="number">
            ///   <item><description>Item One</description></item>
            ///   <item><description>Item Two</description></item>
            ///   <item><description>Item Three</description></item>
            ///  </list>
            /// </remarks>
00891             public void NumberMethod()
            {
            }

            /// <summary>TermMethodSummary</summary>
            /// <remarks>
            ///  <list type="bullet">
            ///   <item><term>Term One</term><description>Item One</description></item>
            ///   <item><term>Term Two</term><description>Item Two</description></item>
            ///   <item><term>Term Three</term><description>Item Three</description></item>
            ///  </list>
            /// </remarks>
00903             public void TermMethod()
            {
            }

            /// <summary>TableMethodSummary</summary>
            /// <remarks>
            ///         <list type="table">
            ///               <item><description>Cell One</description></item>
            ///               <item><description>Cell Two</description></item>
            ///               <item><description>Cell Three</description></item>
            ///         </list>
            /// </remarks>
00915             public void TableMethod()
            {
            }

            /// <summary>TableWithHeaderMethodSummary</summary>
            /// <remarks>
            ///         <list type="table">
            ///               <listheader><description>Header</description></listheader>
            ///               <item><description>Cell One</description></item>
            ///               <item><description>Cell Two</description></item>
            ///               <item><description>Cell Three</description></item>
            ///         </list>
            /// </remarks>
00928             public void TableWithHeaderMethod()
            {
            }

            /// <summary>TwoColumnTableMethodSummary</summary>
            /// <remarks>
            ///         <list type="table">
            ///               <listheader>
            ///                     <term>Something</term>
            ///                     <description>Details</description>
            ///               </listheader>
            ///               <item>
            ///                     <term>Item 1</term>
            ///                     <description>This is the first item</description>
            ///               </item>
            ///               <item>
            ///                     <term>Item 2</term>
            ///                     <description>This is the second item</description>
            ///               </item>
            ///               <item>
            ///                     <term>Item 3</term>
            ///                     <description>This is the third item</description>
            ///               </item>
            ///         </list>
            /// </remarks>
00953             public void TwoColumnTableMethod()
            {
            }

            /// <summary>DefinitionMethodSummary</summary>
            /// <remarks>
            ///  <list type="definition">
            ///   <item><term>Term 1</term><description>Definition One</description></item>
            ///   <item><term>Term 2</term><description>Definition Two</description></item>
            ///   <item><term>Term 3</term><description>Definition Three</description></item>
            ///  </list>
            /// </remarks>
00965             public void DefinitionMethod()
            {
            }

      }

      /// <summary>This class has para elements in its remarks.</summary>
      /// <remarks><para>This is the first paragraph.</para>
      /// <para>This is the second paragraph.</para></remarks>
00974       public class Paragraphs
      {
      }

      /// <summary>This class shows how permission elements are used.</summary>
      /// <permission cref="System.Security.PermissionSet">to inherit from this class.</permission>
00980       public class Permissions
      {
            /// <summary>This constructor has permissions.</summary>
            /// <permission cref="System.Security.PermissionSet">to instanciate the <see cref="Permissions"/> class.</permission>
00984             public Permissions()
            {
            }
            /// <summary>This field has permissions.</summary>
            /// <permission cref="System.Security.PermissionSet">to access this field.</permission>
00989             public string RestrictedField;

            /// <summary>This property has permissions.</summary>
            /// <permission cref="System.Security.PermissionSet">to access this property.</permission>
            public string RestrictedProperty
00994             {
                  get { return ""; }
            }
            /// <summary>This method has permissions.</summary>
            /// <permission cref="System.Security.PermissionSet">to execute this method.</permission>
00999             public void RestrictedMethod()
            {
                  RestrictedEvent(this, new EventArgs());
            }
            /// <summary>This event has permissions.</summary>
            /// <permission cref="System.Security.PermissionSet">to register with this event.</permission>
01005             public event Handler RestrictedEvent;
      }

      /// <summary>This is a sealed class.</summary>
01009       public sealed class SealedClass
      {
      }

      /// <summary>This class covers all member visibilities.</summary>
01014       public class VisibilityTester
      {
            /// <summary>Public constructor</summary>
01017             public VisibilityTester() {}

            /// <summary>Public method</summary>
01020             public void PublicMethod() {}

            /// <summary>Public read-only property</summary>
            public bool PublicReadOnlyProperty
01024             {
                  get { return false; }
            }

            /// <summary>Public write-only property</summary>
            public bool PublicWriteOnlyProperty
01030             {
                  set {}
            }

            /// <summary>Public field</summary>
01035             public bool publicField;

            /// <summary>Public event</summary>
01038             public event Handler PublicEvent;

            /// <summary>Protected constructor</summary>
01041             protected VisibilityTester(bool a) {}

            /// <summary>Protected method</summary>
01044             protected void ProtectedMethod() {}

            /// <summary>Protected read-only property</summary>
            protected bool ProtectedReadOnlyProperty
01048             {
                  get { return false; }
            }

            /// <summary>Protected write-only property</summary>
            protected bool ProtectedWriteOnlyProperty
01054             {
                  set {}
            }

            /// <summary>Protected field</summary>
01059             protected bool protectedField;

            /// <summary>Protected event</summary>
01062             protected event Handler ProtectedEvent;

            /// <summary>Private constructor</summary>
01065             private VisibilityTester(int a) {}

            /// <summary>Private method</summary>
01068             private void PrivateMethod() {}

            /// <summary>Private read-only property</summary>
            private bool PrivateReadOnlyProperty
01072             {
                  get { return false; }
            }

            /// <summary>Private write-only property</summary>
            private bool PrivateWriteOnlyProperty
01078             {
                  set {}
            }

            /// <summary>Private field</summary>
01083             private bool privateField = false;

            /// <summary>Private event</summary>
01086             private event Handler PrivateEvent;

            /// <summary>Protected Internal constructor</summary>
01089             protected internal VisibilityTester(short a) {}

            /// <summary>Protected Internal method</summary>
01092             protected internal void ProtectedInternalMethod() {}

            /// <summary>Protected Internal read-only property</summary>
            protected internal bool ProtectedInternalReadOnlyProperty
01096             {
                  get { return false; }
            }

            /// <summary>Protected Internal write-only property</summary>
            protected internal bool ProtectedInternalWriteOnlyProperty
01102             {
                  set {}
            }

            /// <summary>Protected Internal field</summary>
01107             protected internal bool protectedInternalField;

            /// <summary>Protected Internal event</summary>
01110             protected internal event Handler ProtectedInternalEvent;

            /// <summary>Internal constructor</summary>
01113             internal VisibilityTester(long a) {}

            /// <summary>Internal method</summary>
01116             internal bool InternalMethod()
            {
                  return (PublicEvent != null ||
                        ProtectedEvent != null ||
                        PrivateEvent != null ||
                        ProtectedInternalEvent != null ||
                        InternalEvent != null ||
                        publicField ||
                        protectedField ||
                        privateField ||
                        protectedInternalField ||
                        internalField);
            }

            /// <summary>Internal read-only property</summary>
            internal bool InternalReadOnlyProperty
01132             {
                  get { return false; }
            }

            /// <summary>Internal write-only property</summary>
            internal bool InternalWriteOnlyProperty
01138             {
                  set {}
            }

            /// <summary>Internal field</summary>
01143             internal bool internalField = false;

            /// <summary>Internal event</summary>
01146             internal event Handler InternalEvent;
      }

      /// <summary>
      /// </summary>
01151       public class MissingDocumentationBase
      {
            /// <summary>
            /// This one's documented!
            /// </summary>
            /// <param name="a">A param</param>
            /// <param name="b">Anotner param</param>
            /// <returns>returns something</returns>
            /// <remarks><para>
            /// This is a remark.
            /// </para></remarks>
01162             public int SomeMethod( int a, bool b ) { return 0; }

            /// <summary>
            /// This one's overloaded and documented!
            /// </summary>
            /// <param name="a">A param</param>
            /// <param name="b">Anotner param</param>
            /// <returns>returns something</returns>
            /// <remarks><para>
            /// This is a remark.
            /// </para></remarks>
01173             public int SomeMethod( int a, int b ) { return 0; }

            /// <summary>
            ///
            /// </summary>
            /// <param name="a"></param>
            /// <param name="b"></param>
            /// <returns></returns>
            /// <remarks> </remarks>
01182             public int MethodWithEmptyDoc(int a, int b) { return 0; }
      }

      /// <summary>
      /// </summary>
01187       public class MissingDocumentationDerived : MissingDocumentationBase
      {
      }

      /// <summary>
      /// This is an exception.
      /// </summary>
01194       public class MyException : ApplicationException
      {
            /// <summary>
            /// This is a constructor for the exception.
            /// </summary>
            /// <param name="message">Message for this exception.</param>
01200             public MyException( string message ) : base( message ) {}
      }

      /// <summary>This class has custom attributes on it.</summary>
      [CLSCompliant(false)]
01205       public class CustomAttributes
      {
      }

      /// <summary>This class contains just an indexer so that we can see
      /// if that's what causes the DefaultMemberAttribute attribute to appear.</summary>
01211       public class JustIndexer
      {
            /// <summary>Am I the default member?</summary>
            public int this[int i]
01215             {
                  get { return 0; }
            }
      }

      /// <summary>The remarks contain some &lt;para> and &lt;code> elements with lang attributes.</summary>
      /// <remarks>
      ///         <para>This paragraph has no lang attribute.</para>
      ///         <para lang="Visual Basic">This paragraph has a Visual Basic lang attribute.</para>
      ///         <para lang="VB">This paragraph has a VB lang attribute.</para>
      ///         <para lang="C#">This paragraph has a C# lang attribute.</para>
      ///         <para lang="C++, JScript">This paragraph has a C++, JScript lang attribute.</para>
      ///         <code lang="Visual Basic">
      ///               ' This is some Visual Basic code.
      ///         </code>
      ///         <code lang="VB">
      ///               ' This is some VB code.
      ///         </code>
      ///         <code lang="C#">
      ///               // This is some C# code.
      ///         </code>
      ///         <code lang="C++, JScript">
      ///               // This is either C++ or JScript code.
      ///         </code>
      /// </remarks>
01240       public class LangAttributes
      {
      }

      /// <include file='include.xml' path='documentation/class[@name="IncludeExample"]/*'/>
      public class IncludeExample
      {
      }

      /// <summary>This class has two methods with the same name but one is an instance method
      /// and the other is static.</summary>
01251       public class BothInstanceAndStaticOverloads
      {
            /// <summary>This is the instance method.</summary>
01254             public void Foo()
            {
            }

            /// <summary>This is the static method.</summary>
01259             public static void Foo(int i)
            {
            }
      }

      /// <summary>This class has two methods with the same name but one is an instance method
      /// and the other is static.</summary>
01266       public class BothInstanceAndStaticOverloads2
      {
            /// <summary>This is the instance method.</summary>
01269             public void Foo()
            {
            }
            /// <summary>This is another instance method.</summary>
01273             public void Foo(string name)
            {
            }

            /// <summary>This is the static method.</summary>
01278             public static void Foo(int i)
            {
            }
            /// <summary>This is another static method.</summary>
01282             public static void Foo(object o)
            {
            }
      }

      // The following two examples were submitted by Ross.Nelson@devnet.ato.gov.au
      // in order to demonstrate two bugs.

      /// <summary> this is fred </summary>
      public enum fred 
      {
            /// <summary>aaaa</summary>
            valuea,
            /// <summary>bbbb</summary>
            valueb
      }

      /// <summary>this is jjj</summary>
01300       public class jjj
      {
            /// <summary> this is fred </summary>
01303             public enum fred {
                  /// <summary>aaaa</summary>
                  valuea,
                  /// <summary>bbbb</summary>
                  valueb
            }

            /// <summary>jjj constructor</summary>
            /// <remarks>jjj blah</remarks>
            /// <param name="f">f blah</param>
01313             public jjj(fred f)
            {
            }

            /// <summary>mmm method</summary>
            /// <remarks>mmm blah</remarks>
            /// <param name="f">f blah</param>
01320             public void mmm(fred f)
            {
            }
      }

      /// <summary>This class has an event that throws an exception.</summary>
01326       public class EventWithException
      {
            /// <exception cref="System.Exception">Thrown when... .</exception>
            public event EventHandler ServiceRequest
01330             {
                  add {}
                  remove {}
            }
      }

      /// <summary>This class has a method that's overloaded where one of the
      /// overloads doesn't have any parameters.</summary>
01338       public class OverloadedWithNoParameters
      {
            /// <summary>This is an overloaded method.</summary>
            /// <remarks>This overload has no parameters.</remarks>
01342             public void Method() {}

            /// <summary>This is an overloaded method.</summary>
            /// <remarks>This overload has one parameter.</remarks>
01346             public void Method(int i) {}
      }

      /// <summary>This class wants to ref the method with no parameters
      /// in the OverloadedWithNoParameters class.
      /// See <see cref="OverloadedWithNoParameters.Method" />
      /// ("OverloadedWithNoParameters.Method").
      /// See <see cref="OverloadedWithNoParameters.Method()" />
      /// ("OverloadedWithNoParameters.Method()").
      /// See <see cref="OverloadedWithNoParameters.Method(int)" />
      /// ("OverloadedWithNoParameters.Method(int)").
      /// </summary>
      /// <remarks>
      /// The link to the method with parameters should point to that correct page.
      /// </remarks>
01361       public class CRefToOverloadWithNoParameters
      {
      }

      /// <summary>Explicit interface test (public)</summary>
01366       public interface ExplicitInterface
      {
            /// <summary>Explicit method test</summary>
01369             int ExplicitProperty { get; }

            /// <summary>Implicit method test</summary>
01372             int ImplicitProperty { get; }

            /// <summary>Explicit method test</summary>
            void ExplicitMethod();

            /// <summary>Implicit method test</summary>
            void ImplicitMethod();
      }

      /// <summary>Explicit interface test (internal)</summary>
01382       internal interface ExplicitInternalInterface
      {
            /// <summary>Explicit method test</summary>
            void ExplicitMethodOfInternalInterface();
      }

      /// <summary>Testing explicit interface implementations</summary>
01389       public class ExplicitImplementation : ExplicitInterface, ExplicitInternalInterface
      {
            /// <summary>an explicitly implemented property</summary>
            int ExplicitInterface.ExplicitProperty
01393             {
                  get { return 0; }
            }

            /// <summary>an implicitely implemented property</summary>
01398             public int ImplicitProperty { get { return -1; } }

            /// <summary>an explicitly implemented method</summary>
01401             void ExplicitInterface.ExplicitMethod()
            {
            }

            /// <summary>an implicitely implemented method</summary>
01406             public void ImplicitMethod()
            {
            }

            /// <summary>an explicitly implemented method of an internal interface</summary>
01411             void ExplicitInternalInterface.ExplicitMethodOfInternalInterface()
            {
            }
      }

      /// <summary>Test the new overloads tag.</summary>
01417       public class OverloadsTag
      {
            /// <overloads>This constructor is overloaded.</overloads>
            /// 
            /// <summary>This overloaded constructor accepts no parameters.</summary>
01422             public OverloadsTag()
            {
            }
            /// <summary>This overloaded constructor accepts one int parameter.</summary>
01426             public OverloadsTag(int i)
            {
            }

            /// <overloads>This indexer is overloaded.</overloads>
            /// 
            /// <summary>This overloaded indexer accepts one int parameter.</summary>
            public int this[int i]
01434             {
                  get { return 0; }
            }
            /// <summary>This overloaded indexer accepts one string parameter.</summary>
            public int this[string s]
            {
                  get { return 0; }
            }

            /// <overloads>
            /// This method is overloaded.
            /// </overloads>
            /// 
            /// <summary>This overload accepts no parameters.</summary>
01448             public void OverloadedMethod()
            {
            }
            /// <summary>This overload accepts one int parameter.</summary>
01452             public void OverloadedMethod(int i)
            {
            }

            /// <summary>This method is not overloaded and should not override
            /// the OverloadedMethod(int i) page.</summary>
01458             public void OverloadedMethod2()
            {
            }

            /// <overloads>
            ///   <summary>This method is overloaded.</summary>
            ///   <remarks>
            ///         <para>This remark should also appear.</para>
            ///     <note>This is a note.</note>
            ///   </remarks>
            ///   <example>
            ///     <para>This is some example code.</para>
            ///     <code>Foo.Bar.Baz.Quux();</code>
            ///   </example>
            /// </overloads>
            /// 
            /// <summary>This overload accepts no parameters.</summary>
01475             public void FullDocOverloadedMethod()
            {
            }
            /// <summary>This overload accepts one int parameter.</summary>
01479             public void FullDocOverloadedMethod(int i1)
            {
            }
            /// <summary>This overload accepts one int parameter.</summary>
01483             public void FullDocOverloadedMethod(int i1, int i2)
            {
            }
            /// <summary>This overload accepts one int parameter.</summary>
01487             public void FullDocOverloadedMethod(int i1, int i2, int i3)
            {
            }

            /// <overloads>The Addition for <b>OverloadsTag</b>.</overloads>
            /// 
            /// <summary>
            /// Addition that takes two <b>OverloadsTag</b>.
            /// </summary>
01496             public static OverloadsTag operator +(OverloadsTag x, OverloadsTag y)
            {
                  return new OverloadsTag();
            }
            /// <summary>
            /// Addition that takes an <b>OverloadsTag</b> and an <b>Int32</b>.
            /// </summary>
01503             public static OverloadsTag operator +(OverloadsTag x, int i)
            {
                  return new OverloadsTag(i);
            }
      }

      /// <summary>This class uses note elements on its members.</summary>
01510       public class NotesTest
      {
            /// <summary>
            ///   <para>This summary has a note.</para>
            ///   <note>This is a test of a note tag which has lots of text in it and so should, if we are lucky, wrap to more than one line. To ensure this, here is another extremely long sentence that is probably gramatically incorrect and may have terrible spelling, but who cares, it is long isn't it?</note>
            /// </summary>
01516             public void NoteInSummary()
            {
            }

            /// <summary>This method has a note in its remarks.</summary>
            /// <remarks>
            ///   <para>These remarks have a note.</para>
            ///   <note>This is a test of a note tag which has lots of text in it and so should, if we are lucky, wrap to more than one line. To ensure this, here is another extremely long sentence that is probably gramatically incorrect and may have terrible spelling, but who cares, it is long isn't it?</note>
            /// </remarks>
01525             public void NoteInRemarks()
            {
            }

            /// <summary>This method has cautionary note in its remarks.</summary>
            /// <remarks>
            ///   <para>These remarks have a cautionary note.</para>
            ///   <note type="caution">This is a test of a note tag which has lots of text in it and so should, if we are lucky, wrap to more than one line. To ensure this, here is another extremely long sentence that is probably gramatically incorrect and may have terrible spelling, but who cares, it is long isn't it?</note>
            /// </remarks>
01534             public void CautionNote()
            {
            }

            /// <summary>This method has a note in its remarks.</summary>
            /// <remarks>
            ///   <para>These remarks have a note.</para>
            ///   <note style="background-color:PaleGoldenrod;">This is a test of a note tag which has lots of text in it and so should, if we are lucky, wrap to more than one line. To ensure this, here is another extremely long sentence that is probably gramatically incorrect and may have terrible spelling, but who cares, it is long isn't it?</note>
            /// </remarks>
01543             public void NoteInRemarksColored()
            {
            }

      }

      /// <summary>This class has an indexer with a name other than Item.</summary>
01550       public class IndexerNotNamedItem
      {
            /// <summary>This indexer is not named Item.</summary>
            [System.Runtime.CompilerServices.IndexerName("MyItem")]
            public int this[int i]
01555             {
                  get { return 0; }
            }
      }

      /// <summary>This is a private class.</summary>
01561       class PrivateClass
      {
            /// <summary>This is a public enum nested in a private class.</summary>
            /// <remarks>This type should not appear when DocumentInternals is false.</remarks>
01565             public enum PublicEnumInPrivateClass
            {
                  /// <summary>Foo</summary>
                  Foo,
                  /// <summary>Bar</summary>
                  Bar
            }
      }

      /// <summary>This class has a member that uses 2D rectangular arrays.</summary>
01575       public class Matrix
      {
            /// <summary>Returns the inverse of a matrix.</summary>
            /// <param name="matrix">A matrix.</param>
            /// <returns>The inverted matrix.</returns>
01580             public static double[,] Inverse2(double[,] matrix)
            {
                  return null;
            }

            /// <summary>Returns the inverse of a matrix.</summary>
            /// <param name="matrix">A matrix.</param>
            /// <returns>The inverted matrix.</returns>
01588             public static double[,,] Inverse3(double[,,] matrix)
            {
                  return null;
            }
      }

      /// <summary>This public class contains a private enum.</summary>
01595       public class PublicClassWithPrivateEnum
      {
            /// <summary>This is a private enum in a public class.</summary>
01598             private enum PrivateEnum
            {
                  /// <summary>foo</summary>
                  Foo
            }
      }

      /// <summary>This class has a method that accepts a ref to a byte array.</summary>
01606       public class RefToByteArrayTest
      {
            /// <summary>This method that accepts a ref to a byte array.</summary>
            /// <param name="array">A ref to a byte array.</param>
01610             public void RefToByteArray(ref byte[] array)
            {
            }
      }

      /// <summary>This class causes the &lt;PrivateImplementationDetails> 
      /// class to appear in the compiled assembly.</summary>
01617       public class PrivateImplementationDetails
      {
            static byte[] bar = new byte[] {1,2,3};
      }

      /// <summary>See <see cref="Enum.Foo" />.</summary>
      /// <remarks>The summary contains a cref to an enum member.</remarks>
01624       public class LinkToEnumMember
      {
      }

      /// <summary>See <see cref="SeeOverloadedStatic.StaticOverload" />.</summary>
01629       public class SeeOverloadedStatic
      {
            /// <summary>Overload one.</summary>
01632             public static void StaticOverload(int i)
            {
            }

            /// <summary>Overload two.</summary>
01637             public static void StaticOverload(string s)
            {
            }
      }

      /// <summary>This class contains constant fields.</summary>
01643       public class ConstFields
      {
            /// <summary>This is a constant string.</summary>
01646             public const string ConstString = "ConstString";
            /// <summary>This is a constant int.</summary>
01648             public const int    ConstInt = 5;
            /// <summary>This is a constant int.</summary>
01650             public const double ConstDouble1 = 3.14159265358979323846d;
            /// <summary>This is a constant int.</summary>
01652             public const double ConstDouble2 = 314159265358979323846d;
            /// <summary>This is a constant enum.</summary>
01654             public const EnumFlags ConstEnum =  EnumFlags.Foo;
            /// <summary>This is a constant with 2 enum flags.</summary>
01656             public const EnumFlags ConstEnum2 =  EnumFlags.Foo|EnumFlags.Bar;

#if( !MONO ) //This causes the MONO compiler to abend! :-(
            /// <summary>This is a constant decimal.</summary>
01660             public const decimal ConstDecimal = 3.14159265358979323846m;
            /// <summary>This is a constant decimal.</summary>
01662             public const decimal ConstDecimal2 = 314159265358979323846m;
#endif

      }

      /// <summary>
      /// A class that inherits fields from a System class.
      /// </summary>
01670       public class InheritedFields : System.Resources.ResourceManager
      {
            /// <summary>
            /// This field is added for comparison.
            /// </summary>
01675             public static readonly int MyField = 5;
      }

      /// <summary>
      /// Demonstrates overloads with different access.
      /// </summary>
01681       public class OverloadsWithDifferentAccess
      {
            /// <summary>
            /// Public method with int param.
            /// </summary>
            /// <param name="index">Some int value</param>
01687             public void SomeMethod(int index)
            {
            }
            /// <summary>
            /// Protected method with string param.
            /// </summary>
            /// <param name="name">Some string value</param>
01694             protected void SomeMethod(string name)
            {
            }
            /// <summary>
            /// Public static method with double param.
            /// </summary>
            /// <param name="index">Some double value</param>
01701             public static void SomeMethod(double index)
            {
            }
            /// <summary>
            /// Protected static method with Type param.
            /// </summary>
            /// <param name="name">Some Type value</param>
01708             protected static void SomeMethod(Type name)
            {
            }
      }
      /// <summary>
      /// This class should be visible - it does not have an exclude tag
      /// </summary>
01715       public class VisibleClass
      {
            /// <summary>
            /// This should be visible
            /// </summary>
01720             public int VisibleField;

            /// <summary>
            /// This should NOT be visible
            /// </summary>
            /// <exclude/>
01726             public int NotVisibleField;

            /// <summary>
            /// This should NOT be visible
            /// </summary>
            /// <exclude />
01732             public int NotVisibleField2;

            /// <summary>
            /// This should be visible
            /// </summary>
01737             public string VisibleProperty {
                  get { return ""; }
                  set { }
            }

            /// <summary>
            /// This should NOT be visible
            /// </summary>
            /// <exclude />
01746             public string NotVisibleProperty {
                  get { return ""; }
                  set { }
            }

            /// <summary>
            /// This should be visible
            /// </summary>
            /// <returns></returns>
01755             public int VisibleMethod(){return 0;}

            /// <summary>
            /// This should NOT be visible
            /// </summary>
            /// <returns></returns>
            /// <exclude/>
01762             public int NotVisibleMethod(){return 0;}

            /// <overloads>There should only be two overloads visible</overloads>
            /// <summary>
            /// This should be visible
            /// </summary>
            /// <returns></returns>
01769             public int Overload1(){return 0;}
            /// <summary>
            /// This should NOT be visible
            /// </summary>
            /// <param name="a"></param>
            /// <returns></returns>
            /// <exclude />
01776             public int Overload1(int a){return 0;}
            /// <summary>
            /// This should be visible
            /// </summary>
            /// <param name="a"></param>
            /// <returns></returns>
01782             public int Overload1(long a){return 0;}
      }

      /// <summary>
      /// This class should NOT be visible - it has an exclude tag
      /// </summary>
      /// <exclude/>
01789       public class NotVisibleClass
      {
            /// <summary>
            /// This should NOT be visible
            /// </summary>
01794             public int VisibleField;

      }

      /// <summary>
      /// This class has html tags in the remarks
      /// </summary>
      /// <remarks>
      /// <para><b>This text is surrounded by &lt;b&gt;</b></para>
      /// <para><i>This text is surrounded by &lt;i&gt;</i></para>
      /// <para><em>This text is surrounded by &lt;em&gt;</em></para>
      /// <para><strong>This text is surrounded by &lt;strong&gt;</strong></para>
      /// <para>this line has a break<br/>here</para>
      /// <para align="center">this line is centered</para>
      /// <para style="padding 2px;border:2px solid red;background-color:PaleGoldenrod">this has a red border and PaleGoldenrod background.</para>
      /// </remarks>
01810       public class HtmlTags
      {
      }

      /// <summary>
      /// This class has ecma block tags in the remarks
      /// </summary>
      /// <remarks>
      /// <block type="note">This is a test of an ECMA "note" block tag which has lots of text in it and so should, if we are lucky, wrap to more than one line. To ensure this, here is another extremely long sentence that is probably gramatically incorrect and may have terrible spelling, but who cares, it is long isn't it?</block>
      /// <block type="example">This is a test of an ECMA "example" block tag which has lots of text in it and so should, if we are lucky, wrap to more than one line. To ensure this, here is another extremely long sentence that is probably gramatically incorrect and may have terrible spelling, but who cares, it is long isn't it?</block>
      /// <block type="behaviors">This is a test of an ECMA "behaviors" block tag which has lots of text in it and so should, if we are lucky, wrap to more than one line. To ensure this, here is another extremely long sentence that is probably gramatically incorrect and may have terrible spelling, but who cares, it is long isn't it?</block>
      /// <block type="overrides">This is a test of an ECMA "overrides" block tag which has lots of text in it and so should, if we are lucky, wrap to more than one line. To ensure this, here is another extremely long sentence that is probably gramatically incorrect and may have terrible spelling, but who cares, it is long isn't it?</block>
      /// <block type="usage">This is a test of an ECMA "usage" block tag which has lots of text in it and so should, if we are lucky, wrap to more than one line. To ensure this, here is another extremely long sentence that is probably gramatically incorrect and may have terrible spelling, but who cares, it is long isn't it?</block>
      /// <block type="default">This is a test of an ECMA "default" block tag which has lots of text in it and so should, if we are lucky, wrap to more than one line. To ensure this, here is another extremely long sentence that is probably gramatically incorrect and may have terrible spelling, but who cares, it is long isn't it?</block>
      /// </remarks>
01825       public class EcmaBlocks
      {
      }
}

///// <summary>
///// This class is in the global (unqualified) namespace.
///// </summary>
//public class GlobalNamespaceClass
//{
//}










Generated by  Doxygen 1.6.0   Back to index