#include "stdafx.h" #include "TestClass.h" #include <string> #include <vector> using namespace std; using namespace cli; using namespace System::Collections::ObjectModel; using namespace System; using namespace Runtime::InteropServices; using namespace System::Runtime::InteropServices; namespace Generic1 = System::Collections::Generic; using namespace System::Runtime::CompilerServices; //using namespace System::att; TestClass::TestClass() { } TestClass::~TestClass() { } /// <summary>Namespace Test: [<see cref="N:Mono.DocTest" />] <see href="http://www.mono-project.com/">Mono Project</see></summary> /// <remarks><c>T:NoNamespace</c></remarks> public ref class NoNamespace {}; namespace System { /// <remarks><c>T:System.Action`1</c></remarks> generic<typename T> [SerializableAttribute] public delegate void Action(T obj); //TODO: Env1 name as not supported /// <remarks><c>T:System.Environment</c></remarks> public ref class Environment1 abstract sealed { //public: Environment1() {}; public: /// <remarks><c>T:System.Environment+SpecialFolder</c></remarks> enum class SpecialFolder {}; /// <param name="folder"> /// A <see cref="T:System.Environment+SpecialFolder" /> instance. /// </param> /// <remarks> /// <c>M:System.Environment.GetFolderPath(System.Environment+SpecialFolder)</c> /// </remarks> public: static SpecialFolder GetFolderPath(SpecialFolder folder) { //throw std::runtime_error("error"); return folder; }; // Testing whether this extension method shows up for System.Array public: generic<typename T> where T : value class [System::Runtime::CompilerServices::Extension] static bool IsAligned(cli::array<T>^ vect, int index) { return false; }; }; // to test ECMA doc importing... //todo: array1 instad real name public ref class Array1 { // the ECMA docs have a different return type than .NET -- skip. public: //todo: cli::array or std::array generic<typename T> static ReadOnlyCollection<T> ^ AsReadOnly(cli::array<T>^ array) { throw gcnew NotImplementedException(); } // ECMA docs use <T,U> instead of <TInput,TOutput> --> map them. public: generic<typename TInput, typename TOutput> static cli::array<TOutput>^ ConvertAll(cli::array<TInput>^ array, Converter<TInput, TOutput>^ converter) { throw gcnew InvalidOperationException(); }; // ECMA docs *incorrectly* document parameter -- skip public: generic<typename T> static void Resize(cli::array<T> ^ % array, int newSize) { throw gcnew Exception(); } }; // to test ECMA doc importing... //public delegate void AsyncCallback(IAsyncResult^ ar); } //todo: no dot in namespace name namespace Mono_DocTest { //todo: no internal modifier class Internal { class ShouldNotBeDocumented { }; }; //todo: no internal modifier ref class MonoTODOAttribute : public System::Attribute { }; public ref class CustomException : System::Exception { protected: System::ArgumentNullException ArgumentNullExceptionField; }; public delegate void DelegateWithNetSystemType(System::Exception parameter); generic<typename T> [SerializableAttribute] public delegate void Action22(T obj); /// <remarks> /// <para> /// cref=<c>T:Mono.DocTest.DocAttribute</c>. /// </para> /// <format type="text/html"> /// <table width="100%"> /// <tr> /// <td style="color:red">red</td> /// <td style="color:blue">blue</td> /// <td style="color:green">green</td> /// </tr> /// </table> /// </format> /// <code lang="C#" src="../DocTest.cs#DocAttribute Example" /> /// </remarks> [AttributeUsageAttribute(AttributeTargets::All)] public ref class DocAttribute : Attribute { /// <remarks><c>C:Mono.DocTest.DocAttribute(System.String)</c></remarks> public: DocAttribute(String ^ docs) { if (String::IsNullOrEmpty(docs)) throw gcnew ArgumentNullException(); }; private: Type^ quantity; /// <remarks><c>P:Mono.DocTest.DocAttribute.Property</c></remarks> public: property Type^ Property { Type^ get() { return quantity; } void set(Type^ value) { quantity = value; }}; /// <remarks><c>F:Mono.DocTest.DocAttribute.Field</c></remarks> bool Field; /// <remarks><c>F:Mono.DocTest.DocAttribute.FlagsEnum</c></remarks> ConsoleModifiers FlagsEnum; /// <remarks><c>F:Mono.DocTest.DocAttribute.NonFlagsEnum</c></remarks> Color NonFlagsEnum; }; /// <summary>Possible colors</summary> /// <remarks> /// <see cref="T:Mono.DocTest.Color"/>. /// Namespace Test: [<see cref="N:Mono.DocTest" />] /// </remarks> /*[MonoTODO] public enum Color { /// <summary>Insert Red summary here</summary> ///<remarks><c>F:Mono.DocTest.Color.Red</c>.</remarks> Red, ///<summary>Insert Blue summary here</summary> ///<remarks><c>F:Mono.DocTest.Color.Blue</c>.</remarks> Blue, ///<summary>Insert Green summary here</summary> ///<remarks><c>F:Mono.DocTest.Color.Green</c>.</remarks> Green, AnotherGreen = Green, };*/ /// <summary>Process interface</summary> /// <remarks><c>T:Mono.DocTest.IProcess</c>.</remarks> public interface class IProcess { }; /// <summary>Process interface</summary> /// <remarks><c>T:Mono.DocTest.DocValueType</c>.</remarks> public value class DocValueType : IProcess { public: /// <remarks><c>F:Mono.DocTest.DocValueType.total</c>.</remarks> int total; public: /// <param name="i">A <see cref="T:System.Int32" />.</param> /// <remarks><see cref="M:Mono.DocTest.DocValueType.M(System.Int32)"/>.</remarks> void M(int i) { if (((gcnew Random())->Next() % 2) == 0) throw gcnew SystemException(); throw gcnew ApplicationException(); } }; public value class ValueClassSpecificField { public: DocValueType ExceptionField; }; /// <remarks><c>T:Mono.DocTest.D</c></remarks> public delegate Object ^ D(Func<String ^ , Object ^ , Object ^ > ^ value ); /// <remarks><c>T:Mono.DocTest.Widget</c>.</remarks> /// <seealso cref="P:Mono.DocTest.Widget.Item(System.Int32)" /> /// <extra>Some extra tag value</extra> public ref class Widget : IProcess { //public: virtual double getVolume() { return 0; }; /// <remarks><c>T:Mono.DocTest.Widget.NestedClass</c>.</remarks> public: ref class NestedClass { /// <remarks><c>F:Mono.DocTest.Widget.NestedClass.value</c>.</remarks> public: int value; /// <param name="i">Some <see cref="T:System.Int32" />.</param> /// <remarks><c>M:Mono.DocTest.Widget.NestedClass.M(System.Int32)</c>.</remarks> void M(int i) {}; /// <remarks><c>T:Mono.DocTest.Widget.NestedClass.Double</c>.</remarks> ref class Double { /// <remarks><c>T:Mono.DocTest.Widget.NestedClass.Double.Triple</c>.</remarks> public: ref class Triple { /// <remarks><c>T:Mono.DocTest.Widget.NestedClass.Double.Triple.Quadruple</c>.</remarks> public: ref class Quadruple {};// for good measure }; }; }; public: enum class NestedEnum { Value1, Value2}; /// <remarks><c>T:Mono.DocTest.Widget.NestedClass`1</c>.</remarks> public: //todo: cannot use the same class name here with generic par-r generic<typename T> ref class NestedClass1 { /// <remarks><c>F:Mono.DocTest.Widget.NestedClass`1.value</c>.</remarks> public: int value; /// <param name="i">Another <see cref="T:System.Int32" />.</param> /// <remarks><c>M:Mono.DocTest.Widget.NestedClass`1.M(System.Int32)</c>.</remarks> public: void M(int i) {}; }; /// <remarks><c>F:Mono.DocTest.Widget.classCtorError</c>.</remarks> public: static initonly cli::array<String^>^ classCtorError = CreateArray(); private: static cli::array<String^>^ CreateArray() { throw gcnew NotSupportedException(); }; /// <remarks><c>F:Mono.DocTest.Widget.message</c>.</remarks> public: String^ message; /// <remarks><c>F:Mono.DocTest.Widget.defaultColor</c>.</remarks> protected: static Color defaultColor; /// <remarks><c>F:Mono.DocTest.Widget.PI</c>.</remarks> //TODO: no internal protected: const double PI = 3.14159; /// <remarks><c>F:Mono.DocTest.Widget.monthlyAverage</c>.</remarks> protected public: initonly double monthlyAverage; /// <remarks><c>F:Mono.DocTest.Widget.array1</c>.</remarks> public: cli::array<long^>^ array1; /// <remarks><c>F:Mono.DocTest.Widget.array2</c>.</remarks> //todo: check if works correctly public: cli::array<Widget^, 2> ^ array2; //TODO: no possibiiti for unsafe /// <remarks><c>F:Mono.DocTest.Widget.pCount</c>.</remarks> public: int *pCount; //TODO: no possibiiti for unsafe /// <remarks><c>F:Mono.DocTest.Widget.ppValues</c>.</remarks> public: float** ppValues; /// <remarks><c>T:Mono.DocTest.Widget.IMenuItem</c>.</remarks> public: interface class IMenuItem { /// <remarks><c>M:Mono.DocTest.Widget.IMenuItem.A</c>.</remarks> void A(); /// <remarks><c>P:Mono.DocTest.Widget.IMenuItem.P</c>.</remarks> property int B { int get(); void set(int value); }; }; /// <remarks><c>T:Mono.DocTest.Widget.Del</c>.</remarks> public: delegate void Del(int i); /// <remarks><c>T:Mono.DocTest.Widget.Direction</c>.</remarks> //todo: no internal protected: [FlagsAttribute] /*internal*/ enum class Direction { /// <remarks><c>T:Mono.DocTest.Widget.Direction.North</c>.</remarks> North, /// <remarks><c>T:Mono.DocTest.Widget.Direction.South</c>.</remarks> South, /// <remarks><c>T:Mono.DocTest.Widget.Direction.East</c>.</remarks> East, /// <remarks><c>T:Mono.DocTest.Widget.Direction.West</c>.</remarks> West, }; /// <remarks> /// <para><c>C:Mono.DocTest.Widget</c>.</para> /// <para><c>M:Mono.DocTest.Widget.#ctor</c>.</para> /// <para><see cref="C:Mono.DocTest.Widget(System.String)" /></para> /// <para><see cref="C:Mono.DocTest.Widget(System.Converter{System.String,System.String})" /></para> /// </remarks> public: Widget() {}; /// <param name="s">A <see cref="T:System.String" />.</param> /// <remarks> /// <para><c>C:Mono.DocTest.Widget(System.String)</c>.</para> /// <para><c>M:Mono.DocTest.Widget.#ctor(System.String)</c>.</para> /// </remarks> public: Widget(String^ s) {}; /// <param name="c">A <see cref="T:System.Converter{System.String,System.String}" />.</param> /// <remarks> /// <para><c>C:Mono.DocTest.Widget(System.Converter{System.String,System.String})</c>.</para> /// </remarks> public: Widget(Converter<String^, String^>^ c) {}; /// <remarks><c>M:Mono.DocTest.Widget.M0</c>.</remarks> public: static void M0() {}; /// <param name="c">A <see cref="T:System.Char" />.</param> /// <param name="f">A <see cref="T:System.Single" />.</param> /// <param name="v">A <see cref="T:Mono.DocTest.DocValueType" />.</param> /// <remarks><c>M:Mono.DocTest.Widget.M1(System.Char,System.Signle@,Mono.DocTest.DocValueType@)</c>.</remarks> /// //TODO: doc attribute is not working public: [DocAttribute("normal DocAttribute", Field = true)] //[return:Doc("return:DocAttribute", Property = typeof(Widget))] void M1([Doc("c", FlagsEnum = ConsoleModifiers::Alt | ConsoleModifiers::Control)] long c, [Doc("f", NonFlagsEnum = Color::Red)][Runtime::InteropServices::Out] float % f, [DocAttribute("v")] DocValueType % v) { f = 0; }; /// <param name="x1">A <see cref="T:System.Int16" /> array.</param> /// <param name="x2">A <see cref="T:System.Int32" /> array.</param> /// <param name="x3">A <see cref="T:System.Int64" /> array.</param> /// <remarks><c>M:Mono.DocTest.Widget.M2(System.Int16[],System.Int32[0:,0:],System.Int64[][])</c>.</remarks> public: void M2(cli::array<short>^ x1, cli::array<int, 2>^ x2, cli::array<cli::array<long >^ >^ x3) {}; /// <param name="x3">Another <see cref="T:System.Int64" /> array.</param> /// <param name="x4">A <see cref="T:Mono.DocTest.Widget" /> array.</param> /// <remarks><c>M:Mono.DocTest.Widget.M3(System.Int64[][],Mono.DocTest.Widget[0:,0:,0:][])</c>.</remarks> protected: void M3(cli::array<cli::array<long >^ >^ x3, cli::array<cli::array<Widget^, 3>^>^ x4) {}; //TODO: no unsafe /// <param name="pc">A <see cref="T:System.Char" /> pointer.</param> /// <param name="ppf">A <see cref="T:Mono.DocTest.Color" /> pointer.</param> /// <remarks><c>M:Mono.DocTest.Widget.M4(System.Char*,Mono.DocTest.Color**)</c>.</remarks> protected: void M4(char *pc, Color **ppf) {}; //TODO: no unsafe /// <param name="pv">A <see cref="T:System.Void" /> pointer.</param> /// <param name="pd">A <see cref="T:System.Double" /> array.</param> /// <remarks><c>M:Mono.DocTest.Widget.M5(System.Void*,System.Double*[0:,0:][])</c>.</remarks> protected: void M5(void *pv, cli::array<cli::array<double, 2>^>^*pd) {}; protected: void M55(void *pv, System::String ^ *pd) {}; /// <param name="i">Yet another <see cref="T:System.Int32" />.</param> /// <param name="args">An <see cref="T:System.Object" /> array.</param> /// <remarks><c>M:Mono.DocTest.Widget.M6(System.Int32,System.Object[])</c>.</remarks> protected: void M6(int i, ... cli::array<Object^>^ args) {}; /// <remarks><c>M:Mono.DocTest.Widget.M7(Mono.DocTest.Widget.NestedClass.Double.Triple.Quadruple)</c>.</remarks> public: void M7(Widget::NestedClass::Double::Triple::Quadruple ^ a) {}; /// <value>A <see cref="T:System.Int32" /> value...</value> /// <remarks><c>P:Mono.DocTest.Widget.Width</c>.</remarks> public: [DocAttribute("Width property")] property int Width { [Doc("Width get accessor")] int get() { return 0; }; protected: [Doc("Width set accessor")] void set(int value) {}; }; /// <value>A <see cref="T:System.Int64" /> value...</value> /// <remarks><c>P:Mono.DocTest.Widget.Height</c>.</remarks> protected: [Doc("Height property")] property long Height { long get() { return 0; }; }; /// <value>A <see cref="T:System.Int16" /> value...</value> /// <remarks><c>P:Mono.DocTest.Widget.X</c>.</remarks> //todo: no internal (protected internal) protected: property short X { void set(short value) {}; }; /// <value>A <see cref="T:System.Double" /> value...</value> /// <remarks><c>P:Mono.DocTest.Widget.Y</c>.</remarks> //todo: no internal(protected internal) protected: property double Y { double get() { return 0; }; void set(double value) {}; }; /// <param name="i">TODO</param> /// <remarks><c>P:Mono.DocTest.Widget.Item(System.Int32)</c>.</remarks> /// <value>A <see cref="T:System.Int32" /> instance.</value> public: [DocAttribute("Item property")] property int default[int]{ int get(int index) { return 0; }; [Doc("Item property set accessor")] void set(int index, int value) {}; }; public: [DocAttribute("Item property")] property long indexedProperty[long]{ long get(long index) { return 0; }; [Doc("Item property set accessor")] void set(long index, long value) {}; }; /// <param name="s">Some <see cref="T:System.String" />.</param> /// <param name="i">I love <see cref="T:System.Int32" />s.</param> /// <remarks><c>P:Mono.DocTest.Widget.Item(System.String,System.Int32)</c>.</remarks> /// <value>A <see cref="T:System.Int32" /> instance.</value> public: property int default[System::String ^, int] { int get(System::String ^ s, int i) { return 0; } void set(System::String ^ s, int i, int value) {}; }; /// <remarks><c>E:Mono.DocTest.Widget.AnEvent</c>.</remarks> public: [Doc("Del event")] event Del^ AnEvent { [Doc("Del add accessor")] void add(Del^ name) {}; [Doc("Del remove accessor")] void remove(Del^ name) {}; void raise(int i) {}; }; /// <remarks><c>E:Mono.DocTest.Widget.AnotherEvent</c>.</remarks> protected: event Del^ AnotherEvent; /// <param name="x">Another <see cref="T:Mono.DocTest.Widget" />.</param> /// <remarks><c>M:Mono.DocTest.Widget.op_UnaryPlus(Mono.DocTest.Widget)</c>.</remarks> /// <returns>A <see cref="T:Mono.DocTest.Widget" /> instance.</returns> public: static Widget^ operator + (Widget x) { return nullptr; } /// <remarks><c>M:Mono.DocTest.Widget.op_Division</c>.</remarks> /// <returns>A <see cref="T:Mono.DocTest.Widget" /> instance.</returns> //todo": added 1 to compile public: static Widget^ op_Division1 = nullptr; /// <param name="x1">Yet Another <see cref="T:Mono.DocTest.Widget" />.</param> /// <param name="x2">Yay, <see cref="T:Mono.DocTest.Widget" />s.</param> /// <remarks><c>M:Mono.DocTest.Widget.op_Addition(Mono.DocTest.Widget,Mono.DocTest.Widget)</c>.</remarks> /// <returns>A <see cref="T:Mono.DocTest.Widget" /> instance (2).</returns> public: static Widget^ operator+ (Widget x1, Widget x2) { return nullptr; } /// <param name="x"><see cref="T:Mono.DocTest.Widget" />s are fun!.</param> /// <remarks><c>M:Mono.DocTest.Widget.op_Explicit(Mono.DocTest.Widget)~System.Int32</c>.</remarks> /// <returns>A <see cref="T:System.Int32" /> instance.</returns> public: static explicit operator int(Widget^ x) { return 0; } /// <param name="x"><c>foo</c>; <see cref="T:Mono.DocTest.Widget" />.</param> /// <remarks><c>M:Mono.DocTest.Widget.op_Implicit(Mono.DocTest.Widget)~System.Int64</c>.</remarks> /// <returns>A <see cref="T:System.Int64" /> instance.</returns> //todo: no implicit(default behavior) public: static operator long(Widget x) { return 0; } /// <remarks><c>M:Mono.DocTest.Widget.Default(System.Int32,System.Int32)</c></remarks>c //todo: no default value public: void Default( [System::Runtime::InteropServices::Optional] /*[System::Runtime::InteropServices::DefaultParameterValueAttribute(1)]*/int a, [System::Runtime::InteropServices::Optional] /*[System::Runtime::InteropServices::DefaultParameterValueAttribute(2)]*/int b) {}; /// <remarks><c>M:Mono.DocTest.Widget.Default(System.String,System.Char)</c></remarks> //todo: no default value public: void Default(/*[System::Runtime::InteropServices::DefaultParameterValueAttribute("a")]*/string a, /*[System::Runtime::InteropServices::DefaultParameterValueAttribute('b')]*/char b) {}; //TODO: no dynamics - use Object instead/ + no + operator /// <remarks><c>M:Mono.DocTest.Widget.Dynamic0(System.Object,System.Object)</c></remarks> public: Object^ Dynamic0(Object^ a, Object^ b) { return gcnew Object(); } //TODO: no dynamics - use Object instead /// <remarks><c>M:Mono.DocTest.Widget.Dynamic1(System.Collections.Generic.Dictionary{System.Object,System.Object})</c></remarks> public: Generic1::Dictionary<Object^, System::String^> ^ Dynamic1(Generic1::Dictionary<Object^, System::String^>^ value) { return value; }; //TODO: no dynamics - use Object instead /// <remarks><c>M:Mono.DocTest.Widget.Dynamic2(System.Func{System.String,System.Object})</c></remarks> public: Func<String^, Object^>^ Dynamic2(Func<String^, Object^>^ value) { return value; }; //TODO: no dynamics - use Object instead /// <remarks><c>M:Mono.DocTest.Widget.Dynamic3(System.Func{System.Func{System.String,System.Object},System.Func{System.Object,System.String}})</c></remarks> public: Func<Func<String^, Object^>^, Func< Object^, String^>^>^ Dynamic3( Func<Func<String^, Object^>^, Func< Object^, String^>^>^ value) { return value; }; //TODO: no dynamics - use Object instead /// <remarks><c>P:Mono.DocTest.Widget.DynamicP</c></remarks> /*public: property Func<Func<String^, Object^, String^>^, Func<Object^, Func<Object^>, String^>^> ^DynamicP{ Func<Func<String^, Object^, String^>^, Func<Object^, Func<Object^>, String^>^> get(){ return nullptr; }; };*/ //TODO: no dynamics - use Object instead /// <remarks><c>F:Mono.DocTest.Widget.DynamicF</c></remarks> public: Func<Func<String^, Object^, String^>^, Func<Object^, Func<Object^>^, String^>^> ^DynamicF; //TODO: no dynamics - use Object instead + use delegate as pure Func cannot be used /// <remarks><c>E:Mono.DocTest.Widget.DynamicE1</c></remarks> public: [Obsolete("why not")] event Func<Object^>^ DynamicE1; //TODO: no dynamics - use Object instead /// <remarks><c>E:Mono.DocTest.Widget.DynamicE2</c></remarks> public: event Func<Object^>^ DynamicE2 { [Doc("Del add accessor")] void add(Func<Object^>^ name) {}; [Doc("Del remove accessor")] void remove(Func<Object^>^ name) {}; Object^ raise() { return gcnew Object(); }; }; }; /// <remarks><c>T:Mono.DocTest.UseLists</c>.</remarks> public ref class UseLists { /// <param name="list">A <see cref="T:Mono.DocTest.Generic.MyList{System.Int32}" />.</param> /// <remarks><c>M:Mono.DocTest.UseLists.Process(Mono.DocTest.MyList{System.Int32})</c>.</remarks> public: void Process(Mono_DocTest_Generic::MyList<int> ^ list) {}; /// <param name="value">A <c>T</c>.</param> /// <typeparam name="T">Something</typeparam> /// <remarks><c>M:Mono.DocTest.UseLists.GetValues``1(``0)</c>.</remarks> /// <returns>A <see cref="T:Mono.DocTest.Generic.MyList`1" /> instance.</returns> public: generic<typename T> where T : value class Mono_DocTest_Generic::MyList<T>^ GetValues(T value) { return nullptr; }; /// <param name="list">Another <see cref="T:Mono.DocTest.Generic.MyList{System.Int32}" />.</param> /// <remarks> /// <para><c>M:Mono.DocTest.UseLists.Process(System.Collections.Generic.List{System.Int32})</c>.</para> /// <para><see cref="M:System.Collections.Generic.List{System.Int32}.Remove(`0)" /></para> /// </remarks> /// <exception name="Whatever">text!</exception> /// <exception invalid="foo">text!</exception> public: void Process(Generic1::List<int> list) { // Bug: only creation is looked for, so this generates an <exception/> // node: gcnew Exception(); // Bug? We only look at "static" types, so we can't follow // delegates/interface calls: //todo:uncomment /*Func<int, int>^ a = x = > {throw gcnew InvalidOperationException(); }; a(1);*/ // Multi-dimensional arrays have "phantom" methods that Cecil can't // resolve, as they're provided by the runtime. These should be // ignored. cli::array<int, 2>^ array = gcnew cli::array<int, 2>(1, 1); array[0, 0] = 42; }; /// <param name="list">A <see cref="T:Mono.DocTest.Generic.MyList{System.Predicate{System.Int32}}" />.</param> /// <remarks><c>M:Mono.DocTest.UseLists.Process(System.Collections.Generic.List{System.Predicate{System.Int32}})</c>.</remarks> public: void Process(Generic1::List<Predicate<int>^>^ list) { if (list == nullptr) throw gcnew ArgumentNullException("list"); Process<int>(list); }; /// <param name="list">A <see cref="T:Mono.DocTest.Generic.MyList{System.Predicate{``0}}" />.</param> /// <typeparam name="T">Something Else</typeparam> /// <remarks><c>M:Mono.DocTest.UseLists.Process``1(System.Collections.Generic.List{System.Predicate{``0}})</c>.</remarks> public: generic<typename T> void Process(Generic1::List<Predicate<T>^>^ list) { if (list->Contains(nullptr)) throw gcnew ArgumentException("predicate null"); }; /// <param name="helper">A <see cref="T:Mono.DocTest.Generic.MyList{``0}.Helper{``1,``2}" />.</param> /// <typeparam name="T"><c>T</c></typeparam> /// <typeparam name="U"><c>U</c></typeparam> /// <typeparam name="V"><c>V</c></typeparam> /// <remarks><c>M:Mono.DocTest.UseLists.UseHelper``3(Mono.DocTest.Generic.MyList{``0}.Helper{``1,``2})</c>.</remarks> public: generic<typename T, typename U, typename V> void UseHelper(Mono_DocTest_Generic::MyList<T>::Helper<U, V>^ helper) {}; }; };