Latest version: v1.0.2.0 at 4/1/2003 9:00 PM EDT
For a complete sample demonstrating all the tags, please download the sample
application here or the latest version of the
application here.
What is it and what can it do?
What is required to enable Intellisense in your applications?
What is the minimum code needed to provide
Intellisense for your code?
Attributes Documentation
Processing Application
Command Line Application
Known Issues
Reporting Bugs
History
No longer is C# and J# the only languages that can output XML
comment files programmatically directly from your source code. With this
application anyone has the power to create the exact XML comments file that C# and J# are able to create. Once
the assembly, methods, properties and events are documented, complete Intellisense
will be available to all users of the assembly.
This application uses a series of custom attributes to markup the
source code. This enables the processing application to use reflection on the
assembly and retrieve the information needed to create the XML comment file.
The application consists of two parts, the class file containing the attributes,
and the Winform application to process the assembly file and create the XML
document. A command line application is also available for registered users.
This application can be used for languages other than VB.NET, we are just not
able to provide syntax documentation for those languages at this time. Anyone
that
would like to help create syntax documentation for C++ or any other language
should email us at vbxmlcomments@fesersoft.com.
1. Reference the Fesersoft.VB.Comments.dll in the project needing comments
2. Add the custom attributes to your code as documented in the
Attributes Documentation section or read
the next section for the minimum amount of work needed
3. Compile your application
4. Run the processing application against the assembly
5. Reference the assembly in another VS.NET project
6. The complete Intellisense information will now appear
1. Add a Summary to all classes and public methods using the
VBXC_Summary attribute
This will enable the "Summary" that is displayed while choosing a
class or method as seen below.
Class summary:
Method summary:
2. Document all the parameters for the methods using the
VBXC_Param attribute to enable the description of
each parameter to appear as the user is calling the method. An example of this
may be seen below.
Each parameter will be highlighted in bold and the "value:" will
display the information entered for that parameter using the
VBXC_Param attribute.
Additional class documentation may be found
here.
The C# documentation for the formatting and use of the attributes may be found
here if the .NET SDK is installed or may also be found at the Microsoft site
here.
A Whitepaper created by the C# team about the XML comments and all the
tags may be found as a Word Document
here.
The Fesersoft.VB.Comments.dll assembly contained in the Xml
Comments Creator application directory must be referenced by the application
needing documentation. An example of an assembly that references the comments
Fesersoft.VB.Comments.dll may be seen below.
If additional information on custom attributes is needed, the SDK
reference may be found
here or at the MSDN site
here.
The majority of the information needed to give
your application full Intellisense capability is summarized below. Multiple attributes
may exist for any given item by placing a comma
between each one.
An example of a custom attribute can be found below. A custom attribute adds
META Data to the Assembly. This META Data can be programmatically queried by
another .NET assembly or the Framework itself.
Other examples of Attributes can be seen by opening up any project and viewing
the AssemblyInfo.VB file. This file contains custom attributes to define the
copyright, version number, and other information. At compile time, the compiler
reads this information and adds the information to the .dll or .exe file to
enable the version, copyright and
other information to be seen in the properties of the file.
A Custom attribute of a Class, Method, Property, Enum or other information is
appended to the beginning of the item as seen below. In VB.NET a custom attribute
is started by using the < symbol or [ in C#. Each custom attribute is separated by a comma, allowing an
infinite
number of attributes for any object in the assembly.
The sample seen below is using the VBXmlComment tag defined by the
Fesersoft.VB.Comments assembly. This attribute provides a shortcut for the Summary and
Remarks tags. The reason for this tag is most classes and methods will
contain both a summary and remarks to be used by a documentation application
like NDOC. The remaining tag, VBXC_Param, allows information for a particular parameter of your method call. If the
VBXC_Param tag is added to the beginning of the method call and not the parameter itself,
the parameter name must be provided. The program does
not assume the order of the attributes is the same as the order of the
parameters. The name is not case sensitive since VB.NET is not case sensitive.
The VBXC_Returns tag will describe to the user what to expect back from the
method call.
Source Code Usage Example:
<VBXmlComment("Decode a Stream that contains ONE message and a Steam is returned
with the decoded results", _
"Pass in a Stream object and a Stream will be returned"), _
VBXC_Param("input", "Stream containing the information you wish to encode, at
this time, the position is set back to 0"), _
VBXC_Param("output", "Stream containing the decoded message of the input
parameter. The position is set to zero."), _
VBXC_Returns("Returns a Message")> _
Public
Function Decode(ByVal
input As
Stream,
ByVal output
As Stream)
As Message
More code here.
End
Function
What the above example demonstrates is an example of a method
that has the summary,
remarks, parameters and the
return object comments.
As seen below, the VBXC_Param attribute may be placed at
the method or parameter level.
<VBXmlComment("Decode a Stream that contains ONE message and a Steam is returned
with the decoded results", _
"Pass in a Stream object and a Stream will be returned"), _
VBXC_Param("output", "Stream containing the decoded message of the input
parameter. The position is set to zero."), _
VBXC_Returns("Returns a Message")> _
Public
Function Decode(<VBXC_Param("Stream
containing the information you wish to encode, at this time, the position is set
back to 0")>ByVal
input As
Stream,
ByVal output
As Stream)
As Message
More code here.
End
Function
In the above sample for the "input" parameter, the overloaded
VBXC_Param constructor is used to set the
description because the parameter name is already known. The application will ignore
the name parameter if it is set. If the VBXC_Param
parameter is placed at the method level that has the same name as a parameter
containing the VBXC_Param tag, the parameter takes precedence, and the method
level VBXC_Param attribute will be ignored as
shown below.
<VBXC_Param("output", "This will
be ignored because it is set on the parameter level")> _
Public
Sub Decode(<VBXC_Param("This
value will actually be used for the output parameter")>ByVal output
As Stream)
More code here.
End
Function
VBXmlCommentAttribute: Create a new VBXmlComment. This
is a shortcut for creating a summary and
remarks tag separately. The class may also have the Thread Safe value set but this is a future tag that is meant to be used by a documentation
application like NDOC. We originally saw a posting on the NDOC site asking for a
way for people to comment if the class was thread safe, and this is our response
to this request. If the NDOC xslt file was customized, the Thread
Safe information could be saved to the help file. This attribute would be used on Classes, Methods and other objects that
support summary and remarks tags.
Source Code Usage Example:
<VBXmlCommentAttribute("This class allows you to do some cool stuff.", "These
are some remarks that I want to show in the object browser."
,True)> _
Public
Class MyNewClass
End
Class
VBXC_ExampleAttribute:
The <example> attribute is used to create a new Example Attribute. The
code must be xml compliant. This would be used on a method or class to give the
user a code sample on how to call the .Net component.
Source Code Usage Example:
<VBXC_Example("This sample shows how to call the GetMe method.<code>Create
Thing{}</code>")> _
VBXC_ExceptionAttribute:
The <exception> attribute allows a cref tag to be defined for type of exception
being raised. This creates a hyperlink to the base class used for the exception.
The value must be a fully qualified class name.
Source Code Usage Example:
<VBXC_Exception("System.Exception","This is the description. The parameter
before this is the actual Object that this class refers to. What this is an
example of is a new exception that is a System.Exception.")> _
Public
Class MyException
m_description = description
End
Sub
VBXC_IncludeAttribute:
(A change was made to this object since v0.5.2.0)
This will create a new <include> attribute. This is not included in
the free version. It may be used by anyone but it will not be processed by the
free version of the application and therefore will not be included in your Xml Comments document.
The first parameter is the path to
the document containing the xml information. At this time it is a relative
location. The syntax may also include ..\ to backtrack folders if the document is not
contained in the same folder.
The second parameter is the XPath statement needed to locate the objects
document objects.
Please download the Test Sample
for an example on how the xml document should be formatted or click
here to see the sample xml document used below.
Note: The other attributes may still be used but be aware that if a <param> tag for param1 in both the source code
and include xml document are used, the xml document will take precedence. Think
of this tag as an override because the tags used in the source code are applied
and then the file is imported from the include and the values are overlaid on
top of any data that may exist.
The following xml snip is an example of the node being selected.
<docs>
-<doc for="IntentionalErrors.SameDirIncludeComments">
[Additions nodes here]
</doc>
</docs>
Source Code Usage Example:
<VBXC_Include("samedirinclude.xml",
"/docs/doc[@for='IntentionalErrors.SameDirIncludeComments'")>
_
Public
Sub
SameDirIncludeComments(ByVal
param1
As
String)
End
Sub
VBXC_ParamAttribute:
The <param> attribute is used on method calls or parameter level to create the
context sensitive help the user will see while setting the parameters for any method call.
Below is an example of the param element.
Example using the param tag before the method:
(Note: The name of the parameter must be used if the
parameter tag will be placed before the method call as seen in the following
example. This gives the application a programmatic
way to verify the parameter description exists and is not misspelled.)
<VBXC_Param("description","The
description you wish to show in the 'remarks' tag.")>_
Public
Sub
New(ByVal description
As
String)
m_description = description
End
Sub
Example using the param tag inline:
Public
Sub
New(<VBXC_Param("The
description you wish to show in the 'remarks' tag.")>
ByVal description
As
String)
m_description = description
End
Sub
VBXC_RemarksAttribute:
The <remarks> attribute is mostly used for the object browser and NDOC
while producing the documentation. This tag may be thought of as the
documentation or instructions for your particular class, or method.
Source Code Usage Example:
<VBXC_Remarks("This is just a test")> _
Public
Event Removeme()
VBXC_ReturnsAttribute:
The <returns> attribute describes what to should expect back from a function or
property get call. This is mostly used by NDOC while creating the assembly
documentation and does not have a direct impact on Intellisense.
Source Code Usage Example:
<VBXC_Returns("Returns a Message")> _
Public
Function Decode(<VBXC_Param("Stream
containing the information you wish to encode, at this time, the position is set
back to 0")>ByVal
input As Stream,
ByVal output
As Stream)
As Message
More code here.
End
Function
VBXC_SeeAlso:
The <seealso> tag is used to create additional links in the
documentation. <seealso> may be a child element of remarks and summary but NDOC
will not document them correctly. To allow easier integration with NDOC, we have
included this tag.
Using this tag, an additional link will be placed in the documentation file as
seen in the following example.
The link for
ProtectedFriendSharedFunction has been added to the
seealso list of links. No limit has been placed on the number of seealso tags
that may be used.
Source Code Usage Example:
<VBXC_Summary("SeeAlsoAttributeExample
Summary. <para>Here's how you could make a second paragraph in a description.
<see cref='TestXmlComment.TestClass.ProtectedFunction'/> for information.</para>"),
_
VBXC_Remarks("SeeAlsoAttributeExample Remarks. See also
with case issue. Here is a same class see <see cref='BadCaseParamParam1' />."),
_
VBXC_Param("param1", "SeeAlsoAttributeExample Param1"),
_
VBXC_SeeAlso("TestXmlComment.TestCLASS.ProtectedFriendSharedFunction")>
_
Public
Sub
SeeAlsoAttributeExample(ByVal
param1
As
String)
End
Sub
VBXC_SummaryAttribute:
The <summary> attribute creates a summary of a class, constant, enum, or method call.
This is the text seen in the Intellisense dropdown
while scrolling through the class list as seen below.
Source Code Usage Example:
<VBXC_Summary("This is a Const used in document app.")> _
Public
Const TestConstant
As
Integer = 12
Source Code Usage Example 2:
<VBXC_Summary("What is the length of the line for the message")> _
Public
Function LineLength()
As
Integer
'Additional code here
End
Function
VBXC_ValueAttribute:
The <value> attribute is used to describe what will be returned from a property
get call. This is mostly used by NDOC while creating the assembly documentation
and does not have a direct impact on Intellisense.
Example:
<VBXC_Summary("What is the length of the line for the message"),
VBXC_Value("Returns the value of the length of the line")> _
Public
Property LineLength()
As
Integer
Get
Return m_LineLength
End
Get
Set(<VBXC_Param("The actual line length used for the
message.")> ByVal
Value As
Integer)
m_LineLength = Value
End
Set
End Property
The Application that processes the assembly file is referred
to as the Fesersoft Xml Comments Creator. The application
performs the following functions:
1. Selects an assembly to process
2. Processes the assembly and places the processes XML comment file in the same
directory as the original assembly
3. Validates specific tags for correct referencing
4. Optionally remove the meta data and Fesersoft.VB.Comments Reference from the
Assembly.
When the application is loaded the following screen will be displayed.
Once the application is loaded the settings of
the application may be changed by clicking on the Settings button.
The following options of the application may be changed:
Load Referenced Assemblies for Validation (Registered Version only) This is
a very powerful option if validating tags are being used, especially the <seealso> tag. Setting this option will instruct the application to
import all the members of every NON BCL assembly during the validation process. A
good example of why this option would be needed is if an external assembly
contained a base class for a new assembly and a seealso
link was needed in the documentation. Unless the exact "Xml Comment" syntax
is entered, the
seealso link will be invalid. The overhead of processing all external references
is nominal and highly recommended if validation tags are used.
More information may be found by reading the /erv
switch of the "xcc.exe".
Display Events
As seen in an example below, the option of displaying a very verbose
output during the processing of the assembly file is available. This output is also
very helpful if support is required.
From here, an
assembly must be chosen to process. An assembly that uses the Fesersoft.VB.Comments
application must be selected or an error will be displayed and the processing buttons will be
disabled until a valid assembly is chosen.
Once an assembly is chosen and "Open" is pressed, the main
application screen will be displayed as seen below.
When an assembly is loaded and it is a valid assembly, the create help file and
remove references button will be enabled and the assembly's fully qualified name
will be displayed in the "Assembly Name" text box.
When "Create Help File" is chosen, the assembly is processed and the XML Comment
file is placed in the same directory as the original assembly with the same
name.
If an assembly in located in c:\temp and the name of the file is MyAssembly.dll, an XML
document will be placed in the same directory by the name of MyAssembly.xml.
If any errors or warnings were encountered while processing the assembly, they
will be displayed in the main display section of the application. Errors range
from not being able to locate a referenced assembly to application specific
errors. Warnings are validation tags that were not able to validate the tag referenced in
the application. An example is shown below with no errors or
warnings.
All questions, bugs, or requests for additional functionality
may be emailed to
vbxmlcomments@fesersoft.com.
For those out there that wish to process the Assemblies using
a command line application, we have produced a very powerful wrapper around
VB.NET Xml Comments Creator. The command line application has all the
functionality of the GUI and more. With the command line application, an infinite number of
assemblies may be processed using one configuration file.
Below is the output of the application if no parameters are passed in.
Fesersoft Xml Comments Creator v0.9.950.43135
(c) 2002 Fesersoft. All Rights Reserved. http://www.fesersoft.com/default.asp
Contact us at vbxmlcomments@fesersoft.com for additional info or support.
xcc <parameters> <log parameters>
Usage: xcc /assem:c:\temp\myfile.dll
Command parameters:
/assem:<assem path> The Assembly location (1)
/ndoc:<ndoc project> The path to an NDOC project file (2)
/config:<config file> The path to an Xml Comments Creator config file (3)
/xml Default option. Create the Xml Comment File
/removeref or /rr Remove Fesersoft.VB.Comments Reference from the Assembly
/erv Include external references for validation
/events Display all progress events
/sew Suppress all warnings and Errors to the Console (4)
Log parameters:
/log Log the results to a file (5)
/logdelete Do not append to the file if it exists, delete it first
/logpath Full path to the log if the default file will not be used
(1) <assem path> is the relative or absolute path to the assembly.
Make sure if spaces exist in the path, the path is inside double quotes.
(2) <ndoc project> is the relative or absolute path to an NDOC project file.
All Assemblies in the <assemblies> section of the file will be processed.
(3) <config file> is the relative or absolute path to a config file.
Please see the documentation for a config file example.
All additional parameters are ignored if a config file is used.
(4) Do not output the warnings and errors to the console, but log them if the
/log option is selected.
(5) The default setting for /log is a file named xcc.log in the app directory.
The file is appended and will be created if needed.
/assem, /ndoc and /config parameters may not be mixed, please choose one.
/assem
The Usage example shows the parameter needed to use the application is a valid path to the .NET Assembly. By default, the Xml Comments
file will be created. To remove the Fesersoft.VB.Comments references
and all the custom attributes, the /rr or /removeref
switches would be required.
/ndoc
If NDOC is used to process the Xml Comment File, it will be very
convenient to use the /ndoc option. Just pass the path to the NDOC
project and every assembly referenced that uses the Fesersoft.VB.Comments
assembly will be
processed. This should speed up
documentation creation time dramatically since, in most cases, the Xml
Comment file needs to be created for many assemblies before creating the NDOC Help
file.
/config
The command line version also has the ability to use an XML file. If the
/config switch is used, all other parameters are ignored.
The /removeref, /rr, /erv, /events, /log, /logdelete, and /logpath settings are
all attributes of the DocumentElement Node.
In the following example, the /erv, /log, and /logdelete flags
are set to true. If the tag is missing or set to any value other than "1", they
are assumed to be false. This follows the same rules as passing parameters to
the command line application. The log path may be relative or absolute to the "xcc.exe"
application. The filename of the log is "xcc.log" if the value is not set.
<xcc erv="1" events="0" rr="0" log="1" logdelete="1" logpath="xcc.log">
<assem>..\..\XmlCommentCreator\Registered\bin\Fesersoft.VB.Comments.dll</assem>
<ndoc>multiassembly.ndoc</ndoc>
</xcc>
The file may contain an unlimited number of <assem> or <ndoc> tags and will
process every tag containing a valid file. In the above example, we are
processing the assembly Fesersoft.VB.Comments.dll and every assembly defined in
the NDOC configuration file "multiassembly.ndoc".
A sample configuration file may be found in the zip file named "testconfig.xml".
/xml
Create the Xml Comment File. This is default unless /rr or /removeref flags are
used.
/removeref or /rr
Some people are conserved that the assembly will be "bloated" with meta data by
using this application. To solve this problem, the application has an option to
remove all the meta data and Fesersoft.VB.Comments references from the Assembly.
This is done by converting the code back to MSIL. The
Fesersoft.VB.Comments assembly is removed from the external references section
of the MSIL header and all Fesersoft.VB.Comments custom attributes and the
related data are also remove from the file. After this process is complete, the
file is compiled back to an assembly using ILASM and signed using the original
key if applicable. The file is then placed back into the original directory with an extension
of CommentParse. The original file is not touched. To use this new file, first
delete or rename the original assembly file and remove the CommentParse
extension from the newly processed file. DO NOT DEBUG in the VS.NET IDE with
this new DLL, the file will not match the pdb file and may have unexpected
results. This option is really only recommended against a release build and only
if there is a concern with the bloat created by this application.
/erv
Import all the members of the referenced assemblies for validation. This is
important if the <seealso> tags reference external assemblies and a link needs
to be created to
the new item. The application will import
all the members of the NON Framework Assemblies and these names will be used in
the validation process. Without this option, a warning will be displayed for any
member that does not resolve on validation tags using an referenced assembly.
/events
Verbosely display all the events raised by the application while the assemblies
are being processed. This is mostly used for debugging, but some people may want
to see how long different operations are taking.
/sew
Do not output the warnings and errors to the console, but log them if the /log
option is selected.
/log
Log the output that goes to the Console to an external file. By default, if no /logpath
is specified, "xcc.log" will be used to append all the application messages.
/logdelete
By default the application will append the log information to the existing file.
This setting will delete the file before writing new information.
/logpath
This is the path to the log file. Whatever value is passed in
will override the default filename of "xcc.log". The path must be valid and contained in
double quotes
if spaces exist in the path.
Updated 6/6/2002
Update 6/5/2002. The
application will locate assemblies in all sub folders on the same level as the
current project. So if a project exists in the d:\apps\mynewApp folder, it
will search for the needed assemblies in all folders under d:\apps up to 3
levels deep.
Update 6/18/2002, sped up the dynamic discovery to search the
current folder first before it starts looking on the rest of the drive.
Please verify if possible, that the Object browser in a c#
application works correctly before reporting any bugs. Sometimes the VB.Net
Object browser does not properly display the summary and remarks.
Please email vbxmlcomments@fesersoft.com
to report any bugs or request additional features.
v1.0.2.0 04/01/2003
Bug Fixes:
Fixed problem with finding external assemblies.
New Features:
None.
v1.0.1.0 12/28/2002
Bug Fixes:
None.
New Features:
Version was changed to maintain a constant version between registered and regular.
v0.9.1091.38330 12/27/2002
Bug Fixes:
All Client Bug fixes.
New Features:
Logging now takes all information and logs it to a file.
/sew switch. If this option is selected, the information is not output to
the command application except the final status. This will limit the actual output to less than one screen.
v0.9.957.22445 8/15/2002
Bug Fixes:
All Client Bug fixes.
New Features:
None
v0.9.950.43135 8/9/2002
Bug Fixes:
All Client Bug fixes.
New Features:
1. You may now use an NDOC project as a configuration file. All the
assemblies contained in the file will be processed. The option for this is /ndoc:<project
path>.
2. You may now use a configuration file to set any of the settings of the
application. The option for this is /config:<config file path>.
3. Using a configuration file, you may process multiple NDOC or Assemblies at
the same time. No limit has been enforced on the number of Assemblies or NDOC
projects that may be used as input sources.
4. Supports using referenced assemblies for tag validation. The switch for this
is /erv.
5. Supports configuration of verbose display of application progress. The switch
for this is /events.
6. Supports logging the results of the application to a log file. The switch for
this is /log.
7. Supports appending or deleting the existing log file. The switch for this is
/logdelete.
8. Supports a default log file which may be configured. The switch for this is /logpath.
v1.0.1.0 12/28/2002
Bug Fixes:
None.
New Features:
Version was changed to maintain a constant version between registered and regular.
v0.9.1091.38330 12/27/2002
Bug Fixes:
Fixed an issue when documenting a public member using the "WithEvents" keyword. For some reason the VB Compiler exposes this item with a property internally and renames the member with an "_" before it, causing the Intellisense to not work correctly.
What this Compiler option does cause is NDOC to docuement the member as a property and not a variable, which may cause some confusion to the end user reading the documentation. We need to bring this up with the NDOC team to see if this issue can be resolved.
New Features:
None.
v0.9.957.22445 8/15/2002
Bug Fixes:
Fixed an issue with Properties that reference classes outside the System
namespace. The Intellisense was not working for these items. This is now fixed.
New Features:
None.
v0.9.957.11576 8/15/2002
Bug Fixes:
Fixed an issue with processing items not contained in a namespace. We are really
surprised only one person reported this error.
New Features:
None.
v0.9.950.29419 8/9/2002
Bug Fixes:
Fixed issue with inaccurate warning information given for a <seealso> tag that
uses an external reference that can't be resolved. The problem is now fixed.
New Features:
1. Application now has settings.
2. You may set a setting for verbose display of application progress.
3. You may now set if the application should use all external references for tag
validation. This option now matches and exceeds the C# compiler when defining
the "current build environment" for validation of tags. This is especially
useful if you are using the <seealso> tag and NDOC to create a <seealso> link
for Base Classes or related classes in the same application.
v0.9.937.19344 7/26/2002
Bug Fixes:
None
New Features:
1. Added a new tag for <seealso> so you do not have to use this tag inside a
<remarks> or <summary> tag. This also fixes an NDOC issue when you create your
documentation. We are not even sure if the <seealso> tag can be a direct child
of a member node but the C# compiler allows it and NDOC and a lot of users want
this functionality.
2. The registered version now includes a command line application to process the
assemblies or remove the Fesersoft.VB.Comments reference.
3. The application has better threading and no longer has "Not Responding"
issues in the Task Manager.
v0.9.912.24737 7/1/2002 Canada Day
Bug Fixes:
Can you believe it, we finally found a solution to the Large Font size issue.
For some insane reason, the Web Browser control does not scale the same as the
rest of the controls on the form. I added some math to resize the form correctly
and not the form displays as it should.
Anyone having issues in the past with the buttons not displaying should now be
able to control the application.
New Features:
None
v0.9.908.24642 6/27/2002
Bug Fixes:
None
New Features:
1. Optimized the code
2. All late binding code has been removed, the application is now compiled as in
Release mode with Option Strict ON
3. Registered version now contains a feature to strip the XML Comments Creator
Attributes from the Assembly
v0.9.899.34996 6/20/2002
Bug Fixes:
1. Fixed issue with dynamic Discovery
2. Fixed issue with not initializing the XML Document before dynamic discovery,
attempting to append an error caused an exception
3. Removes members with no information that have parameters
New Features:
1. Optimized the code
2. Removes members with no information that have parameters. This was an issue
for items like the .equals method of an object or structure
3. Registered version will also contain the <include> feature
v0.9.891.42250 6/11/2002
Bug Fixes:
None.
New Features:
1. Optimized the code
2. Validates <exception> tag
3. Validates <permission> tag
4. Case correction for <exception> and <permission> tags
5. Will now validate <see>, <seealso>, <exception>, and <permission> in the
current Assembly and in any Class or Member in the mscorlib or System assembly.
If the project detects you are attempting to use a System.* member, the
application reflects the entire mscorlib and System assembly to obtain the
entire Class and member list
6. The Free version is now feature complete unless additional features are
requested by the users
v0.9.888.4171
6/7/2002
Bug Fixes:
None.
New Features:
1. Optimized the code. Processing can be as much as 300% faster
v0.9.886.38857
6/6/2002
Bug Fixes:
None.
New Features:
1. Validates <see> tags
2.
Validates <seealso> tags
3.
Quicker processing
4.
Case correction of Members for param, paramref, see, and seealso added
see and seealso tags follow the same rules as the c# compiler. The application
tries to validate the current value, and if one is not found, it tries to look
for the member in the same namespace. If both of these fail and the item is not
already fully qualified, then a warning is issued
v0.9.886.5240
6/5/2002
Bug Fixes:
1. Fixed a second null reference issue for no types that exist in a namespace
New Features:
None
v0.9.886.2184
6/5/2002
Bug Fixes:
1. Fixed issue with System.Data.DataSysDescription Attribute causing an
exception.
All non VB.NET Xml Comment Creator
2. Attributes are now being ignored so this problem will no longer exist
3. Fixed an issue with projects pulled from SourceSafe that may not contain
all the Assembly References in the folder. The project will now perform dynamic
discovery on all subdirectories on the same level as the application being
processed. Future versions will most likely add a discovery of the entire drive
to locate missing assemblies
4. Fixed a null reference issue for no types that exist in a namespace
New Features:
1. Added a check to make sure the parameter case is correct.
2.
The <param> tag now validates. A warning is set if an incorrectly spelled
parameter is used.
3.
The <paramref> tag now validates. A warning is set if an incorrectly spelled
parameter is used.
v0.9.885.643 6/4/2002
Totally rewrote the entire processing engine. Issues pointed out in the old
version that were fixed include: Events not being documented correctly. This is
now fixed. Now has the ability to check for updates and has a much cleaner
interface.
v0.9.880.1150 5/30/2002
The application no longer depends on the web service. Future versions may have
additional features that use remoting.
This fixes a bug in most cases where the service just returned an error, "Can't
Process Assembly". The application was unable to process any files that were
dependent on any non mscorlib assemblies. The problem is now solved since the
application will be able to resolve all assemblies in the local directory and
GAC.
v0.6.0.0 10/14/2002
This dated release fixes a few issues over the 7/26/2002 Release.
Exceptions are allowed to be applied to items other than classes.
SeeAlso is allowed to be used multiple times for one item.
Version was kept the same so the developers do not have to recompile all the existing dll's.
v0.6.0.0 7/26/2002
Added a <seealso> attribute to allow for <seealso> information not being stored
in another tag. This fixes an NDOC integration issue.
v0.5.2.0 3/29/2002
Removed copyright information to comply with
http://www.gotdotnet.com/ upload policy.
Set to static version until real updates are made.
The Fesersoft XML Comments Creator Team.
Copyright (c) 2001-2002 by Fesersoft. All Rights
Reserved
vbxmlcomments@fesersoft.com.
Last updated:
12/29/2002 12:51:58 AM