1mdoc(5) File Formats Manual mdoc(5)
2
6 mdoc - Mono Documentation XML Format
7
9 The assorted Mono documentation programs generate or manipulate XML
10 files following the mono documentation schema:
11 mdoc update
13 Creates or updates mono documentation XML for a set of assem‐
14 blies.
15 mdoc validate
17 Validates the mono documentation XML against the mono documenta‐
18 tion XML schema.
19 mdoc assemble
21 Converts the mono documentation XML within a directory structure
22 into a set of files for use with monodoc(1).
23 mdoc export-html
25 Converts the mono documentation XML within a directory structure
26 into a set of HTML files that can be viewed with a web browser.
27 All of these tools (and more) use the common XML schema described in
29 this man page.
30
32 There are three sets of Mono documentation XML files:
33 * index.xml: contains a list of all assemblies within the contain‐
35 ing directory, and all types and namespaces within those assem‐
36 blies.
37 * ns-*.xml: There is one ns-*.xml file for each namespace within
39 the assembly; these files are siblings to index.xml .
40 Examples of ns-*.xml files include: ns-System.xml, ns-Sys‐
42 tem.Collections.xml, and ns-.xml (for the root namespace, though
43 it is recommended to NOT place types into the root namespace, as
44 monodoc(1) doesn't display them).
45 The ns-*.xml files contain per-namespace documentation.
47 * NamespaceName/TypeName.xml: These files are within a dotted
49 NamespaceName directory, and TypeName is the name of the type.
50 Examples include: RootType.xml (if the type has no namespace),
52 System/String.xml, System.Collections/IEnumerable.xml, and Sys‐
53 tem.Collections.Generic/List`1+Enumerator.xml (the `1 is the
54 number of generic type parameters the type accepts, and every‐
55 thing after the + is a nested type).
56 Thus, typical directory contents would resemble:
58 index.xml
60 ns-System.xml
61 ns-System.Collections.Generic.xml
62 System/String.xml
63 System.Collections.Generic/List`1.xml
64
66 index.xml File Format
67 The index.xml file contains a list of the assemblies nested under the
68 directory containing index.xml and all namespaces and types within
69 those assemblies. It looks something like this:
70 <Overview>
72 <Assemblies>
73 <Assembly Name="mscorlib" Version="2.0.0.0" />
74 <!-- other <Assembly/> elements... -->
75 </Assemblies>
76 <Remarks>To be added.</Remarks>
77 <Copyright>To be added.</Copyright>
78 <Types>
79 <Namespace Name="System">
80 <Type Name="String" />
81 <!-- Other <Type/> elements -->
82 </Namespace>
83 <Namespace Name="System.Collections.Generic">
84 <Type Name="List`1" DisplayName="List<T>" />
85 <!-- Other <Type/> elements -->
86 </Namespace>
87 <!-- other <Namespace/> elements -->
88 </Types>
89 <Title>DocTest</Title>
90 </Overview>
91 Most of this is maintained automatically, in particular the /Over‐
93 view/Assemblies and /Overview/Types elements.
94 The //Namespace/@Name attribute corresponds to a directory which con‐
96 tains files named //Type/@Name.xml, while the //Type/@DisplayName
97 attribute contains a C# type name (if //Type/@DisplayName isn't found,
98 then //Type/@Name is used as the display name). There should also be a
99 ns-[//Namespace/@Name].xml file.
100 There are three elements of interest to authors: /Overview/Remarks,
102 /Overview/Copyright, and /Overview/Title, which contain assembly-level
103 documentation. These elements can contain any of the following XML
104 elements (documented in the Documentation XML Elements section): block,
105 code, example, list, para, paramref, typeparamref, see, and ul.
106 ns-*.xml File Format
108 The ns-*.xml files contain namespace documentation:
109 <Namespace Name="System">
111 <Docs>
112 <summary>To be added.</summary>
113 <remarks>To be added.</remarks>
114 </Docs>
115 </Namespace>
116 The /Namespace/Docs/summary and /Namespace/Docs/remarks elements should
118 contain namespace documentation.
119 The remarks and summary elements are documented in the Documentation
121 XML Elements section.
122 NamespaceName/TypeName.xml File Format
124 The mono documentation format is similar to the Ecma documentation for‐
125 mat, as described in ECMA-335 3rd Edition, Partition IV, Chapter 7.
126 The principal difference from the ECMA format is that each type gets
127 its own file, within a directory identical to the namespace of the
128 type. There is a lot of information that is maintained automatically
129 by mdoc(1); Most of the information within the documentation should not
130 be edited. This includes the type name (/Type/@FullName), implemented
131 interfaces (/Type/Interfaces), member information (/Type/Members/Mem‐
132 ber/@MemberName, /Type/Members/Member/MemberSignature, /Type/Mem‐
133 bers/Member/MemberType, /Type/Members/Member/Parameters, etc.).
134 <Type Name="DocAttribute" FullName="Mono.DocTest.DocAttribute">
136 <TypeSignature Language="C#" Value="public class DocAttribute : Attribute" />
137 <AssemblyInfo>
138 <AssemblyName>DocTest</AssemblyName>
139 <AssemblyVersion>0.0.0.0</AssemblyVersion>
140 </AssemblyInfo>
141 <Base>
142 <BaseTypeName>System.Attribute</BaseTypeName>
143 </Base>
144 <Interfaces />
145 <Attributes>
146 <Attribute>
147 <AttributeName>System.AttributeUsage(System.AttributeTargets.All)</AttributeName>
148 </Attribute>
149 </Attributes>
150 <Docs>
151 <summary>To be added.</summary>
152 <remarks>To be added.</remarks>
153 </Docs>
154 <Members>
155 <Member MemberName=".ctor">
156 <MemberSignature Language="C#" Value="public DocAttribute (string docs);" />
157 <MemberType>Constructor</MemberType>
158 <AssemblyInfo>
159 <AssemblyVersion>0.0.0.0</AssemblyVersion>
160 </AssemblyInfo>
161 <Parameters>
162 <Parameter Name="docs" Type="System.String" />
163 </Parameters>
164 <Docs>
165 <param name="docs">To be added.</param>
166 <summary>To be added.</summary>
167 <remarks>To be added.</remarks>
168 </Docs>
169 </Member>
170 </Members>
171 </Type>
172 The only elements that normally need to be edited are children of the
174 //Docs elements, which usually contain the text To be added. The
175 /Type/Docs element contains type-level documentation, while the
176 /Type/Members/Member/Docs element contains per-member documentation.
177 The //Docs elements can contain the following elements: altcompliant,
179 altmember, example, exception, param, permission, remarks, returns,
180 since, summary, threadsafe, typeparam, and value.
181 Nested types are not members; they are types, and are documented in
183 their own file. Consequently, the NamespaceName/TypeName.xml files are
184 not recursive; you do not store a <Type/> element within a <Type/> ele‐
185 ment.
186 Documentation XML Elements
188 The contents of the Docs element is identical in semantics and struc‐
189 ture to the inline C# documentation format, consisting of these ele‐
190 ments (listed in ECMA-334 3rd Edition, Annex E, Section 2). The fol‐
191 lowing are used within the element descriptions:
192 CREF Refers to a class (or member) reference, and is a string in the
194 format described below in the CREF FORMAT section.
195 TEXT Non-XML text, and XML should not be nested.
197 XML Only XML elements should be nested (which indirectly may contain
199 text), but non-whitespace text should not be an immediate child
200 node.
201 XML_TEXT
203 Free-form text and XML, so that other XML elements may be
204 nested.
205 The following elements are used in documentation:
207 <altmember cref="CREF" />
209 <altmember/> is a top-level element, and should be nested
210 directly under the <Docs/> element.
211 Allows an entry to be generated for the See Also section. Use
213 <see/> to specify a link from within text.
214 <altmember cref="P:System.Exception.Message" />
216 <block subset="SUBSET" type="TYPE">XML_TEXT</block>
218 Create a block of text, similar in concept to a paragraph, but
219 is used to create divisions within the text. To some extent, a
220 <block/> is equivalent to the HTML <h2/> tag.
221 SUBSET should always be the value "none".
223 TYPE specifies the heading and formatting to use. Recognized
225 types are:
226 behaviors Creates a section with the heading Operation.
228 note Creates a section with the heading Note:.
230 overrides Creates a section with the heading Note to Inheritors.
232 usage Creates a section with the heading Usage.
234 The block element can contain the following elements: block, c,
236 code, list, para, paramref, see, subscript, sup, and typeparam‐
237 ref.
238 <c>XML_TEXT</c>
240 Set text in a code-like font (similar to the HTML <tt/> ele‐
241 ment).
242 The c element can contain the following elements: code, para,
244 paramref, see, and typeparamref.
245 <code lang="LANGUAGE" src="SOURCE">TEXT</code>
247 Display multiple lines of text in a code-like font (similar to
248 the HTML <pre/> element).
249 LANGUAGE is the language this code block is for. For example,
251 if LANGUAGE is C#, then TEXT will get syntax highlighting for
252 the C# language within the Mono Documentation Browser.
253 SOURCE is only interpreted by mdoc-update(1). If the src
255 attribute is present when mdoc-update(1) is run, then SOURCE is
256 a file (relative to mdoc-update(1)'s --out directory) that
257 should be inserted as the value for TEXT. The contents of TEXT
258 will be ignored by mdoc-update(1) and replaced on every invoca‐
259 tion. SOURCE can also contain an "anchor", e.g.
260 src="path/to/file.cs#RegionMarker". If an anchor is present,
261 and LANGUAGE is C#, then #region RegionMarker will be searched
262 for, and the contents between the #region and the following
263 #endregion will be inserted as the value for TEXT element.
264 <example>XML_TEXT</example>
266 Indicates an example that should be displayed specially. For
267 example:
268 <example>
270 <para>An introductory paragraph.</para>
271 <code lang="C#">
272 class Example {
273 public static void Main ()
274 {
275 System.Console.WriteLine ("Hello, World!");
276 }
277 }
278 </code>
279 </example>
280 The example element can contain the following elements: c, code,
282 list, para, and see.
283 <exception cref="CREF">XML_TEXT</exception>
285 Identifies an exception that can be thrown by the documented
286 member.
287 <exception/> is a top-level element, and should be nested
289 directly under the <Docs/> element.
290 CREF is the exception type that is thrown, while XML_TEXT con‐
292 tains the circumstances that would cause CREF to be thrown.
293 <exception cref="T:System.ArgumentNullException">
295 <paramref name="foo" /> was <see langword="null" />.
296 </exception>
297 The exception element can contain the following elements: block,
299 para, paramref, see, and typeparamref.
300 <format type="TYPE">XML_TEXT</format>
302 The <format/> element is an "escape hatch," for including (pos‐
303 sibly XML) content that is not valid mdoc(5) content. It's the
304 moral equivalent of perlpod(1) =begin format blocks.
305 TYPE is the mime type of XML_TEXT. mdoc(5) processors may skip
307 format/> blocks of they use a type that isn't supported.
308 For example:
310 <format type="text/html">
312 <table width="100%">
313 <tr><td style="color:red">Hello, world!</td></tr>
314 </table>
315 </format>
316 would cause the embedded HTML <table/> element to be inserted
318 inline into the resulting HTML document when mdoc-export-html(1)
319 processes the file. (Likewise, it may be skipped if processed
320 by another program.)
321 format/> is intended to simplify importing documentation from
323 existing documentation sources. It should not be relied upon,
324 if at all possible.
325 <list>XML</list>
327 Create a list or table of items. <list/> makes use of nested
328 <item>XML</item>, <listheader>XML</listheader>,
329 <term>XML_TEXT</term>, and <description>XML_TEXT</description>
330 elements.
331 Lists have the syntax:
333 <list type="bullet"> <!-- or type="number" -->
335 <item><term>Bullet 1</term></item>
336 <item><term>Bullet 2</term></item>
337 <item><term>Bullet 3</term></item>
338 </list>
339 Tables have the syntax:
341 <list type="table">
343 <listheader> <!-- listheader bolds this row -->
344 <term>Column 1</term>
345 <description>Column 2</description>
346 <description>Column 3</description>
347 </listheader>
348 <item>
349 <term>Item 1-A</term>
350 <description>Item 1-B</description>
351 <description>Item 1-C</description>
352 </item>
353 <item>
354 <term>Item 2-A</term>
355 <description>Item 2-B</description>
356 <description>Item 2-C</description>
357 </item>
358 </list>
359 The item and description elements can each contain text and the
361 following elements: block, c, para, paramref, see, sup, and
362 typeparamref.
363 <para>XML_TEXT</para>
365 Insert a paragraph of XML_TEXT. For example,
366 <para>
368 This is a paragraph of text.
369 </para>
370 The para element can contain the following elements: block, c,
372 example, link, list, onequarter, paramref, see, sub, sup, type‐
373 paramref, and ul.
374 <param name="NAME">XML_TEXT</param>
376 <param/> is a top-level element, and should be nested directly
377 under the <Docs/> element.
378 Describes the parameter NAME of the current constructor, method,
380 or property:
381 <param name="count">
383 A <see cref="T:System.Int32" /> containing the number
384 of widgets to process.
385 </param>
386 The param element can contain the following elements: block, c,
389 example, para, paramref, see, and typeparamref.
390 <paramref name="NAME" />
392 Indicates that NAME is a parameter.
393 This usually renders NAME as italic text, so it is frequently
395 (ab)used as an equivalent to the HTML <i/> element. See the
396 <exception/> documentation (above) for an example.
397 <permission cref="CREF">XML_TEXT</permission>
400 Documents the security accessibility requirements of the current
401 member.
402 <permission/> is a top-level element, and should be nested
404 directly under the <Docs/> element.
405 CREF is a type reference to the security permission required,
407 while XML_TEXT is a description of why the permission is
408 required.
409 <permission cref="T:System.Security.Permissions.FileIOPermission">
411 Requires permission for reading and writing files. See
412 <see cref="F:System.Security.Permissions.FileIOPermissionAccess.Read" />,
413 <see cref="F:System.Security.Permissions.FileIOPermissionAccess.Write" />.
414 </permission>
415 The permission element can contain the following elements:
417 block, para, paramref, see, and typeparamref.
418 <remarks>XML_TEXT</remarks>
420 Contains detailed information about a member.
421 <remarks/> is a top-level element, and should be nested directly
423 under the <Docs/> element.
424 <remarks>
426 Insert detailed information here.
427 </remarks>
428 The remarks element can contain the following elements: block,
430 c, code, example, list, para, paramref, see, and typeparamref.
431 <returns>XML_TEXT</returns>
433 <returns/> is a top-level element, and should be nested directly
435 under the <Docs/> element.
436 Describes the return value of a method:
438 <returns>
440 A <see cref="T:System.Boolean" /> specifying whether
441 or not the process can access
442 <see cref="P:Mono.Unix.UnixFileSystemInfo.FullName" />.
443 </returns>
444 The returns element can contain the following elements: list,
446 para, paramref, see, and typeparamref.
447 <see cref="CREF" />, <see langword="LANGWORD" />
449 Creates a link to the specified member within the current text:
450 <see cref="M:Some.Namespace.With.Type.Method" />
452 or specifies that LANGWORD is a language keyword:
454 <see langword="null" />
456 <seealso cref="CREF" />
459 Do not use seealso, use altmember.
460 <since version="VERSION" />
462 <since/> is a top-level element, and should be nested directly
464 under the <Docs/> element.
465 Permits specification of which version introduced the specified
467 type or member.
468 <since version="Gtk# 2.4" />
470 This generally isn't required, as the //AssemblyInfo/Assem‐
472 blyVersion elements track which assembly versions contain type
473 or member.
474 <summary>XML_TEXT</summary>
476 <summary/> is a top-level element, and should be nested directly
478 under the <Docs/> element.
479 Provides a (brief!) overview about a type or type member.
481 This is usually displayed as part of a class declaration, and
483 should be a reasonably short description of the type/member.
484 Use <remarks/> for more detailed information.
485 The summary element can contain the following elements: block,
487 list, para, paramref, see, and typeparamref.
488 <typeparam name="NAME">XML_TEXT</typeparam>
490 <typeparam/> is a top-level element, and should be nested
491 directly under the <Docs/> element.
492 This is used to document a type parameter for a generic type or
494 generic method.
495 NAME is the name of the type parameter, while XML_TEXT contains
497 a description of the parameter (what it's used for, what
498 restrictions it must meet, etc.).
499 <typeparam name="T">
501 The type of the underlying collection
502 </typeparam>
503 The typeparam element can contain the following elements: block,
505 c, para, paramref, see, and typeparamref.
506 <typeparamref name="NAME">
508 Used to indicate that NAME is a type parameter.
509 <value>XML_TEXT</value>
511 <value/> is a top-level element, and should be nested directly
512 under the <Docs/> element.
513 Allows a property to be described.
515 <value>
517 A <see cref="T:System.String" /> containing a widget name.
518 </value>
519 The value element can contain the following elements: block, c,
521 example, list, para, paramref, see, and typeparamref.
522
524 String IDs (CREFs) are used to refer to a type or member of a type.
525 String IDs are documented in ECMA-334 3rd Edition, Annex E.3.1. They
526 consist of a member type prefix, the full type name (namespace + name,
527 separated by .), possibly followed by the member name and other infor‐
528 mation.
529 Member type prefixes:
531 C: The CREF refers to a constructor. The (optional) parameter list
533 is enclosed in parenthesis and follows the type name: C:Sys‐
534 tem.String(System.Char,System.Int32).
535 E: The CREF refers to an event. The event name follows the type
537 name: E:System.AppDomain.AssemblyLoad.
538 F: The CREF refers to a field. The field name follows the type
540 name: F:System.Runtime.InteropServices.DllImportAttribute.Set‐
541 LastError.
542 M: Refers to a constructor or method. Constructors may append
544 .ctor to the type name (instead of using the above C: construc‐
545 tor format), while methods append the method name and an
546 (optional) count of the number of generic parameters. Both con‐
547 structors and methods may append the method parameter list
548 enclosed in parenthesis.
549 Examples: M:System.Object..ctor, M:System.String..ctor(Sys‐
551 tem.Char[]), M:System.String.Concat(System.Object), M:Sys‐
552 tem.Array.Sort``1(``0[]), M:System.Collec‐
553 tions.Generic.List`1..ctor, M:System.Collec‐
554 tions.Generic.List`1.Add(`0).
555 N: Refers to a namespace, e.g. N:System.
557 P: Refers to a property. If the property is an indexer or takes
559 parameters, the parameter types are appended to the property
560 name and enclosed with paranthesis: P:System.String.Length,
561 P:System.String.Chars(System.Int32).
562 T: The CREF refers to a type, with the number of generic types
564 appended: T:System.String, T:System.Collections.Generic.List`1,
565 T:System.Collections.Generic.List`1.Enumerator.
566 To make matters more interesting, generic types & members have two rep‐
568 resentations: the "unbound" representation (shown in examples above),
569 in which class names have the count of generic parameters appended to
570 their name. There is also a "bound" representation, in which the bind‐
571 ing of generic parameters is listed within '{' and '}' or '<' and '>'.
572 (Use of '<' and '>' is less common, as within an XML document their
573 escaped character entities must instead be used, leading to '<' and
574 '>'.)
575 Unbound:
577 * T:System.Collections.Generic.List`1
579 * T:System.Collections.Generic.Dictionary`2
581 Bound:
583 * T:System.Collections.Generic.List{System.Int32}
585 * T:System.Collections.Generic.List<System.Int32>
587 * T:System.Collections.Generic.List<System.Int32>
589 * T:System.Predicate{System.Action{System.String}}
591 As you can see, bound variants can be arbitrarily complex (just like
593 generics).
594 Furthermore, if a generic parameter is bound to the generic parameter
596 of a type or method, the "index" of the type/method's generic parameter
597 is used as the binding, so given
598 class FooType {
600 public static void Foo<T> (System.Predicate<T> predicate)
601 {
602 }
603 }
604 The CREF for this method is M:FooType.Foo``1(System.Predicate{``0}),
606 ``0 is the 0th generic parameter index which is bound to System.Predi‐
607 cate<T>.
608
610 mdoc(1), monodocer(1)
611
613 Visit http://lists.ximian.com/mailman/listinfo/mono-docs-list for
614 details.
615
617 Visit http://www.mono-project.com for details
618 mdoc(5)