<?xml version="1.0"?>
<doc>
    <assembly>
        <name>NAnt.DotNetTasks</name>
    </assembly>
    <members>
        <member name="T:NAnt.DotNet.Tasks.AssemblyInfoTask">
            <summary>
            Generates an AssemblyInfo file using the attributes given.
            </summary>
            <example>
              <para>
              Create a C# AssemblyInfo file containing the specified assembly-level 
              attributes.
              </para>
              <code>
                <![CDATA[
            <asminfo output="AssemblyInfo.cs" language="CSharp">
                <imports>
                    <import namespace="System" />
                    <import namespace="System.Reflection" />
                    <import namespace="System.EnterpriseServices" />
                    <import namespace="System.Runtime.InteropServices" />
                </imports>
                <attributes>
                    <attribute type="ComVisibleAttribute" value="false" />
                    <attribute type="CLSCompliantAttribute" value="true" />
                    <attribute type="AssemblyVersionAttribute" value="1.0.0.0" />
                    <attribute type="AssemblyTitleAttribute" value="My fun assembly" />
                    <attribute type="AssemblyDescriptionAttribute" value="More fun than a barrel of monkeys" />
                    <attribute type="AssemblyCopyrightAttribute" value="Copyright (c) 2002, Monkeyboy, Inc." />
                    <attribute type="ApplicationNameAttribute" value="FunAssembly" />
                </attributes>
                <references>
                    <include name="System.EnterpriseServices.dll" />
                </references>
            </asminfo>
                ]]>
              </code>
            </example>
            <example>
                <para>
                Create a C# AssemblyInfo file containing an attribute with multiple
                named properties by setting the <see cref="P:NAnt.DotNet.Types.AssemblyAttribute.AsIs"/> 
                attribute on the <see cref="T:NAnt.DotNet.Types.AssemblyAttribute"/> element to 
                <see langword="true"/>.
                </para>
              <code>
                <![CDATA[
            <asminfo output="AssemblyInfo.cs" language="CSharp">
                <imports>
                    <import namespace="log4net.Config" />
                </imports>
                <attributes>
                    <attribute type="DOMConfiguratorAttribute" value="ConfigFile=&quot;config.log4net&quot;,Watch=true" asis="true" />
                </attributes>
                <references>
                    <include name="log4net.dll" />
                </references>
            </asminfo>
                ]]>
              </code>
            </example>
        </member>
        <member name="M:NAnt.DotNet.Tasks.AssemblyInfoTask.ExecuteTask">
            <summary>
            Generates an AssemblyInfo file.
            </summary>
        </member>
        <member name="M:NAnt.DotNet.Tasks.AssemblyInfoTask.NeedsPersisting(System.IO.Stream)">
            <summary>
            Determines whether the specified AssemblyInfo file in the given
            <see cref="T:System.IO.Stream"/> needs to be persisted.
            </summary>
            <param name="generatedAsmInfoStream"><see cref="T:System.IO.Stream"/> holding the newly generated AssemblyInfo source.</param>
            <returns>
            <see langword="true"/> if the generated AssemblyInfo source needs
            to be persisted; otherwise, <see langword="false"/>.
            </returns>
        </member>
        <member name="P:NAnt.DotNet.Tasks.AssemblyInfoTask.Output">
            <summary>
            Name of the AssemblyInfo file to generate.
            </summary>
            <value>
            The name of the AssemblyInfo file to generate.
            </value>
        </member>
        <member name="P:NAnt.DotNet.Tasks.AssemblyInfoTask.Language">
            <summary>
            The code language in which the AssemblyInfo file should be 
            generated.
            </summary>
        </member>
        <member name="P:NAnt.DotNet.Tasks.AssemblyInfoTask.AssemblyAttributes">
            <summary>
            The assembly-level attributes to generate.
            </summary>
            <value>
            The assembly-level attributes to generate.
            </value>
        </member>
        <member name="P:NAnt.DotNet.Tasks.AssemblyInfoTask.Imports">
            <summary>
            The namespaces to import.
            </summary>
            <value>
            The namespaces to import.
            </value>
        </member>
        <member name="P:NAnt.DotNet.Tasks.AssemblyInfoTask.References">
            <summary>
            Assembly files used to locate the types of the specified attributes.
            </summary>
        </member>
        <member name="T:NAnt.DotNet.Tasks.AssemblyInfoTask.CodeLanguage">
            <summary>
            Defines the supported code languages for generating an AssemblyInfo
            file.
            </summary>
        </member>
        <member name="F:NAnt.DotNet.Tasks.AssemblyInfoTask.CodeLanguage.CSharp">
            <summary>
            A value for generating C# code.
            </summary>
        </member>
        <member name="F:NAnt.DotNet.Tasks.AssemblyInfoTask.CodeLanguage.JScript">
            <summary>
            A value for generating JScript code.
            </summary>
        </member>
        <member name="F:NAnt.DotNet.Tasks.AssemblyInfoTask.CodeLanguage.VB">
            <summary>
            A value for generating Visual Basic code.
            </summary>
        </member>
        <member name="T:NAnt.DotNet.Tasks.AssemblyInfoTask.CodeProvider">
            <summary> 
            Encapsulates functionality to generate a code file with imports
            and assembly-level attributes.
            </summary>
        </member>
        <member name="M:NAnt.DotNet.Tasks.AssemblyInfoTask.CodeProvider.#ctor(NAnt.DotNet.Tasks.AssemblyInfoTask,NAnt.DotNet.Tasks.AssemblyInfoTask.CodeLanguage)">
            <summary>
            Initializes a new instance of the <see cref="T:NAnt.DotNet.Tasks.AssemblyInfoTask.CodeProvider"/>
            for the specified <see cref="T:NAnt.DotNet.Tasks.AssemblyInfoTask.CodeLanguage"/>.
            </summary>
            <param name="assemblyInfoTask">The <see cref="T:NAnt.DotNet.Tasks.AssemblyInfoTask"/> for which an instance of the <see cref="T:NAnt.DotNet.Tasks.AssemblyInfoTask.CodeProvider"/> class should be initialized.</param>
            <param name="codeLanguage">The <see cref="T:NAnt.DotNet.Tasks.AssemblyInfoTask.CodeLanguage"/> for which an instance of the <see cref="T:NAnt.DotNet.Tasks.AssemblyInfoTask.CodeProvider"/> class should be initialized.</param>
        </member>
        <member name="M:NAnt.DotNet.Tasks.AssemblyInfoTask.CodeProvider.GenerateImportCode(System.Collections.Specialized.StringCollection,System.IO.TextWriter)">
            <summary>
            Generates code for the specified imports.
            </summary>
            <param name="imports">The imports for which code should be generated.</param>
            <param name="writer">The <see cref="T:System.IO.TextWriter"/> to which the generated code will be written.</param>
        </member>
        <member name="M:NAnt.DotNet.Tasks.AssemblyInfoTask.CodeProvider.GenerateAssemblyAttributesCode(NAnt.DotNet.Types.AssemblyAttributeCollection,System.Collections.Specialized.StringCollection,System.Collections.Specialized.StringCollection,System.IO.TextWriter)">
            <summary>
            Generates code for the specified assembly attributes.
            </summary>
            <param name="assemblyAttributes">The assembly attributes for which code should be generated.</param>
            <param name="imports">Imports used to resolve the assembly attribute names to fully qualified type names.</param>
            <param name="assemblies">Assembly that will be used to resolve the attribute names to <see cref="T:System.Type"/> instances.</param>
            <param name="writer">The <see cref="T:System.IO.TextWriter"/> to which the generated code will be written.</param>
        </member>
        <member name="P:NAnt.DotNet.Tasks.AssemblyInfoTask.CodeProvider.Language">
            <summary>
            Gets the <see cref="T:NAnt.DotNet.Tasks.AssemblyInfoTask.CodeLanguage"/> in which the AssemblyInfo
            code will be generated.
            </summary>
        </member>
        <member name="P:NAnt.DotNet.Tasks.AssemblyInfoTask.CodeProvider.Generator">
            <summary>
            Gets the <see cref="T:System.CodeDom.Compiler.ICodeGenerator"/> that will be used to 
            generate the AssemblyInfo code.
            </summary>
        </member>
        <member name="T:NAnt.DotNet.Tasks.AssemblyInfoTask.TypedValueGatherer">
            <summary>
            Responsible for returning the specified value converted to a 
            <see cref="T:System.Type"/> accepted by a constructor for a given
            <see cref="T:System.Type"/>.
            </summary>
        </member>
        <member name="M:NAnt.DotNet.Tasks.AssemblyInfoTask.TypedValueGatherer.InitializeLifetimeService">
            <summary>
            Obtains a lifetime service object to control the lifetime policy for 
            this instance.
            </summary>
            <returns>
            An object of type <see cref="T:System.Runtime.Remoting.Lifetime.ILease"/> used to control the lifetime 
            policy for this instance. This is the current lifetime service object 
            for this instance if one exists; otherwise, a new lifetime service 
            object initialized with a lease that will never time out.
            </returns>
        </member>
        <member name="M:NAnt.DotNet.Tasks.AssemblyInfoTask.TypedValueGatherer.GetTypedValue(System.Collections.Specialized.StringCollection,System.Collections.Specialized.StringCollection,System.String,System.String)">
            <summary>
            Retrieves the specified <see cref="T:System.Type"/> corresponding with the specified 
            type name from a list of assemblies.
            </summary>
            <param name="assemblies">The collection of assemblies that the type should tried to be instantiated from.</param>
            <param name="imports">The list of imports that can be used to resolve the typename to a full typename.</param>
            <param name="typename">The typename that should be used to determine the type to which the specified value should be converted.</param>
            <param name="value">The <see cref="T:System.String"/> value that should be converted to a typed value.</param>
            <returns></returns>
            <exception cref="T:NAnt.Core.BuildException">
            <para><paramref name="value"/> is <see langword="null"/> and the <see cref="T:System.Type"/> identified by <paramref name="typename"/> has no default public constructor.</para>
            <para>-or-</para>
            <para><paramref name="value"/> cannot be converted to a value that's suitable for one of the constructors of the <see cref="T:System.Type"/> identified by <paramref name="typename"/>.</para>
            <para>-or-</para>
            <para>The <see cref="T:System.Type"/> identified by <paramref name="typename"/> has no suitable constructor.</para>
            <para>-or-</para>
            <para>A <see cref="T:System.Type"/> identified by <paramref name="typename"/> could not be located or loaded.</para>
            </exception>
        </member>
        <member name="T:NAnt.DotNet.Tasks.AssemblyLinkerTask">
            <summary>
            Wraps <c>al.exe</c>, the assembly linker for the .NET Framework.
            </summary>
            <remarks>
              <para>
              All specified sources will be embedded using the <c>/embed</c> flag.
              Other source types are not supported.
              </para>
            </remarks>
            <example>
              <para>
              Create a library containing all icon files in the current directory.
              </para>
              <code>
                <![CDATA[
            <al output="MyIcons.dll" target="lib">
                <sources>
                    <include name="*.ico" />
                </sources>
            </al>
                ]]>
              </code>
            </example>
            <example>
              <para>
              Create an executable assembly manifest from modules.
              </para>
              <code>
                <![CDATA[
            <al output="Client.exe" target="exe" main="Program.Main">
                <modules>
                    <include name="Client.netmodule" />
                    <include name="Common.netmodule" />
                </modules>
            </al>
                ]]>
              </code>
            </example>
        </member>
        <member name="M:NAnt.DotNet.Tasks.AssemblyLinkerTask.ExecuteTask">
            <summary>
            Generates an assembly manifest.
            </summary>
        </member>
        <member name="M:NAnt.DotNet.Tasks.AssemblyLinkerTask.NeedsCompiling">
            <summary>
            Determines whether the assembly manifest needs compiling or is 
            uptodate.
            </summary>
            <returns>
            <see langword="true" /> if the assembly manifest needs compiling; 
            otherwise, <see langword="false" />.
            </returns>
        </member>
        <member name="P:NAnt.DotNet.Tasks.AssemblyLinkerTask.AlgorithmID">
            <summary>
            Specifies an algorithm (in hexadecimal) to hash all files in a 
            multifile assembly except the file that contains the assembly 
            manifest. The default algorithm is CALG_SHA1.
            </summary>
        </member>
        <member name="P:NAnt.DotNet.Tasks.AssemblyLinkerTask.Company">
            <summary>
            Specifies a string for the <b>Company</b> field in the assembly.
            </summary>
            <value>
            A string for the <b>Company</b> field in the assembly.
            </value>
            <remarks>
            If <see cref="P:NAnt.DotNet.Tasks.AssemblyLinkerTask.Company"/> is an empty string (""), the Win32 
            <b>Company</b> resource appears as a single space.
            </remarks>
        </member>
        <member name="P:NAnt.DotNet.Tasks.AssemblyLinkerTask.Configuration">
            <summary>
            Specifies a string for the <b>Configuration</b> field in the assembly.
            </summary>
            <value>
            A string for the <b>Configuration</b> field in the assembly.
            </value>
            <remarks>
            If <see cref="P:NAnt.DotNet.Tasks.AssemblyLinkerTask.Configuration"/> is an empty string (""), the Win32
            <b>Configuration</b> resource appears as a single space.
            </remarks>
        </member>
        <member name="P:NAnt.DotNet.Tasks.AssemblyLinkerTask.Copyright">
            <summary>
            Specifies a string for the <b>Copyright</b> field in the assembly.
            </summary>
            <value>
            A string for the <b>Copyright</b> field in the assembly.
            </value>
            <remarks>
            If <see cref="P:NAnt.DotNet.Tasks.AssemblyLinkerTask.Copyright"/> is an empty string (""), the Win32
            <b>Copyright</b> resource appears as a single space.
            </remarks>
        </member>
        <member name="P:NAnt.DotNet.Tasks.AssemblyLinkerTask.Culture">
            <summary>
            The culture string associated with the output assembly.
            The string must be in RFC 1766 format, such as "en-US".
            </summary>
            <remarks>
            <para>
            Corresponds with the <c>/c[ulture]:</c> flag.
            </para>
            </remarks>
        </member>
        <member name="P:NAnt.DotNet.Tasks.AssemblyLinkerTask.DelaySign">
            <summary>
            Specifies whether the assembly should be partially signed. The default
            is <see langword="NAnt.DotNet.Types.DelaySign.NotSet" />.
            </summary>
        </member>
        <member name="P:NAnt.DotNet.Tasks.AssemblyLinkerTask.Description">
            <summary>
            Specifies a string for the <b>Description</b> field in the assembly.
            </summary>
            <value>
            A string for the <b>Description</b> field in the assembly.
            </value>
            <remarks>
            If <see cref="P:NAnt.DotNet.Tasks.AssemblyLinkerTask.Description"/> is an empty string (""), the Win32
            <b>Description</b> resource appears as a single space.
            </remarks>
        </member>
        <member name="P:NAnt.DotNet.Tasks.AssemblyLinkerTask.EvidenceFile">
            <summary>
            Security evidence file to embed.
            </summary>
            <value>
            The security evidence file to embed.
            </value>
            <remarks>
            <para>
            Corresponds with the <c>/e[vidence]</c> flag.
            </para>
            </remarks>
        </member>
        <member name="P:NAnt.DotNet.Tasks.AssemblyLinkerTask.FileVersion">
            <summary>
            Specifies a string for the <b>File Version</b> field in the assembly.
            </summary>
            <value>
            A string for the <b>File Version</b> field in the assembly.
            </value>
        </member>
        <member name="P:NAnt.DotNet.Tasks.AssemblyLinkerTask.Flags">
            <summary>
            Specifies a value (in hexadecimal) for the <b>Flags</b> field in 
            the assembly.
            </summary>
            <value>
            A value (in hexadecimal) for the <b>Flags</b> field in the assembly.
            </value>
        </member>
        <member name="P:NAnt.DotNet.Tasks.AssemblyLinkerTask.KeyContainer">
            <summary>
            Specifies a container that holds a key pair.
            </summary>
        </member>
        <member name="P:NAnt.DotNet.Tasks.AssemblyLinkerTask.KeyFile">
            <summary>
            Specifies a file (filename) that contains a key pair or
            just a public key to sign an assembly.
            </summary>
            <value>
            The complete path to the key file.
            </value>
            <remarks>
            <para>
            Corresponds with the <c>/keyf[ile]:</c> flag.
            </para>
            </remarks>
        </member>
        <member name="P:NAnt.DotNet.Tasks.AssemblyLinkerTask.MainMethod">
            <summary>
            Specifies the fully-qualified name (class.method) of the method to 
            use as an entry point when converting a module to an executable file.
            </summary>
            <value>
            The fully-qualified name (class.method) of the method to use as an 
            entry point when converting a module to an executable file.
            </value>
        </member>
        <member name="P:NAnt.DotNet.Tasks.AssemblyLinkerTask.ModuleSet">
            <summary>
            One or more modules to be compiled into an assembly.
            </summary>
        </member>
        <member name="P:NAnt.DotNet.Tasks.AssemblyLinkerTask.OutputFile">
            <summary>
            The name of the output file for the assembly manifest.
            </summary>
            <value>
            The complete output path for the assembly manifest.
            </value>
            <remarks>
            <para>
            Corresponds with the <c>/out</c> flag.
            </para>
            </remarks>
        </member>
        <member name="P:NAnt.DotNet.Tasks.AssemblyLinkerTask.OutputTarget">
            <summary>
            The target type (one of <c>lib</c>, <c>exe</c>, or <c>winexe</c>).
            </summary>
            <remarks>
            <para>
            Corresponds with the <c>/t[arget]:</c> flag.
            </para>
            </remarks>
        </member>
        <member name="P:NAnt.DotNet.Tasks.AssemblyLinkerTask.Product">
            <summary>
            Specifies a string for the <b>Product</b> field in the assembly.
            </summary>
            <value>
            A string for the <b>Product</b> field in the assembly.
            </value>
        </member>
        <member name="P:NAnt.DotNet.Tasks.AssemblyLinkerTask.ProductVersion">
            <summary>
            Specifies a string for the <b>Product Version</b> field in the assembly.
            </summary>
            <value>
            A string for the <b>Product Version</b> field in the assembly.
            </value>
        </member>
        <member name="P:NAnt.DotNet.Tasks.AssemblyLinkerTask.Resources">
            <summary>
            The set of resources to embed.
            </summary>
        </member>
        <member name="P:NAnt.DotNet.Tasks.AssemblyLinkerTask.EmbeddedResources">
            <summary>
            The set of compiled resources to embed.
            </summary>
            <remarks>
            Do not yet expose this to build authors.
            </remarks>
        </member>
        <member name="P:NAnt.DotNet.Tasks.AssemblyLinkerTask.SupportsTemplate">
            <summary>
            Indicates whether the assembly linker for a given target framework
            supports the "template" option, which takes an assembly from which
            to get all options except the culture field.
            The default is <see langword="true" />.
            </summary>
            <remarks>
            TODO: remove this once Mono bug #74814 is fixed.
            </remarks>
        </member>
        <member name="P:NAnt.DotNet.Tasks.AssemblyLinkerTask.TemplateFile">
            <summary>
            Specifies an assembly from which to get all options except the 
            culture field.
            </summary>
            <value>
            The complete path to the assembly template.
            </value>
            <remarks>
            <para>
            Corresponds with the <c>/template:</c> flag.
            </para>
            </remarks>
        </member>
        <member name="P:NAnt.DotNet.Tasks.AssemblyLinkerTask.Title">
            <summary>
            Specifies a string for the <b>Title</b> field in the assembly.
            </summary>
            <value>
            A string for the <b>Title</b> field in the assembly.
            </value>
        </member>
        <member name="P:NAnt.DotNet.Tasks.AssemblyLinkerTask.Trademark">
            <summary>
            Specifies a string for the <b>Trademark</b> field in the assembly.
            </summary>
            <value>
            A string for the <b>Trademark</b> field in the assembly.
            </value>
        </member>
        <member name="P:NAnt.DotNet.Tasks.AssemblyLinkerTask.Version">
            <summary>
            Specifies version information for the assembly. The format of the 
            version string is <c>major</c>.<c>minor</c>.<c>build</c>.<c>revision</c>.
            </summary>
        </member>
        <member name="P:NAnt.DotNet.Tasks.AssemblyLinkerTask.Win32Icon">
            <summary>
            Icon to associate with the assembly.
            </summary>
        </member>
        <member name="P:NAnt.DotNet.Tasks.AssemblyLinkerTask.Win32Res">
            <summary>
            Inserts a Win32 resource (.res file) in the output file.
            </summary>
        </member>
        <member name="P:NAnt.DotNet.Tasks.AssemblyLinkerTask.ProgramArguments">
            <summary>
            Gets the command-line arguments for the external program.
            </summary>
            <value>
            The command-line arguments for the external program or 
            <see langword="null" /> if the task is not being executed.
            </value>
        </member>
        <member name="T:NAnt.DotNet.Tasks.CompilerBase">
            <summary>
            Provides the abstract base class for compiler tasks.
            </summary>
        </member>
        <member name="F:NAnt.DotNet.Tasks.CompilerBase.CodebehindExtensions">
            <summary>
            Contains a list of extensions for all file types that should be treated as
            'code-behind' when looking for resources.  Ultimately this will determine
            if we use the "namespace+filename" or "namespace+classname" algorithm, since
            code-behind will use the "namespace+classname" algorithm.
            </summary>
        </member>
        <member name="F:NAnt.DotNet.Tasks.CompilerBase.CultureNames">
            <summary>
            Case-insensitive list of valid culture names for this platform.
            </summary>
            <remarks>
            The key of the <see cref="T:System.Collections.Hashtable"/> is the culture name and 
            the value is <see langword="null"/>.
            </remarks>
        </member>
        <member name="M:NAnt.DotNet.Tasks.CompilerBase.#cctor">
            <summary>
            Class constructor for <see cref="T:NAnt.DotNet.Tasks.CompilerBase"/>.
            </summary>
        </member>
        <member name="M:NAnt.DotNet.Tasks.CompilerBase.ExecuteTask">
            <summary>
            Compiles the sources and resources.
            </summary>
        </member>
        <member name="M:NAnt.DotNet.Tasks.CompilerBase.GetManifestResourceName(NAnt.DotNet.Types.ResourceFileSet,System.String,System.String,System.String)">
            <summary>
            Determines the manifest resource name of the given resource file.
            </summary>
            <param name="resources">The <see cref="T:NAnt.DotNet.Types.ResourceFileSet"/> containing information that will used to assemble the manifest resource name.</param>
            <param name="resourcePhysicalFile">The resource file of which the manifest resource name should be determined.</param>
            <param name="resourceLogicalFile">The logical location of the resource file.</param>
            <param name="dependentFile">The source file on which the resource file depends.</param>
            <returns>
            The manifest resource name of the specified resource file.
            </returns>
        </member>
        <member name="M:NAnt.DotNet.Tasks.CompilerBase.GetManifestResourceName(NAnt.DotNet.Types.ResourceFileSet,System.String)">
            <summary>
            Determines the manifest resource name of the given resource file.
            </summary>
            <param name="resources">The <see cref="T:NAnt.DotNet.Types.ResourceFileSet"/> containing information that will used to assemble the manifest resource name.</param>
            <param name="resourceFile">The resource file of which the manifest resource name should be determined.</param>
            <returns>
            The manifest resource name of the specified resource file.
            </returns>
            <remarks>
            For .resx resources, the name of the dependent is determined by
            replacing the extension of the file with the extension of the 
            source files for the compiler, and removing the culture name from
            the file name for localized resources.
            </remarks>
        </member>
        <member name="M:NAnt.DotNet.Tasks.CompilerBase.PerformSearchForResourceLinkage(System.IO.TextReader)">
            <summary>
            Extracts the associated namespace/classname linkage found in the 
            given stream.
            </summary>
            <param name="sr">The read-only stream of the source file to search.</param>
            <returns>
            The namespace/classname of the source file matching the resource.
            </returns>
        </member>
        <member name="M:NAnt.DotNet.Tasks.CompilerBase.WritePackageReferences(System.IO.TextWriter)">
            <summary>
            Writes package references to the specified <see cref="T:System.IO.TextWriter"/>.
            </summary>
            <param name="writer">The <see cref="T:System.IO.TextWriter"/> to which the package references should be written.</param>
        </member>
        <member name="M:NAnt.DotNet.Tasks.CompilerBase.WriteWarningsAsError(System.IO.TextWriter)">
            <summary>
            Writes list of warnings to (not) treat as errors to the specified 
            <see cref="T:System.IO.TextWriter"/>.
            </summary>
            <param name="writer">The <see cref="T:System.IO.TextWriter"/> to which the list of warnings should be written.</param>
        </member>
        <member name="M:NAnt.DotNet.Tasks.CompilerBase.WriteNoWarnList(System.IO.TextWriter)">
            <summary>
            Writes list of warnings to suppress to the specified 
            <see cref="T:System.IO.TextWriter"/>.
            </summary>
            <param name="writer">The <see cref="T:System.IO.TextWriter"/> to which the list of warnings to suppress should be written.</param>
        </member>
        <member name="M:NAnt.DotNet.Tasks.CompilerBase.WriteConditionalCompilationConstants(System.IO.TextWriter)">
            <summary>
            Writes conditional compilation constants to the specified
            <see cref="T:System.IO.TextWriter"/>.
            </summary>
            <param name="writer">The <see cref="T:System.IO.TextWriter"/> to which the conditional compilation constants should be written.</param>
        </member>
        <member name="M:NAnt.DotNet.Tasks.CompilerBase.WriteModuleReferences(System.IO.TextWriter)">
            <summary>
            Writes module references to the specified <see cref="T:System.IO.TextWriter"/>.
            </summary>
            <param name="writer">The <see cref="T:System.IO.TextWriter"/> to which the module references should be written.</param>
        </member>
        <member name="M:NAnt.DotNet.Tasks.CompilerBase.WriteOptions(System.IO.TextWriter)">
            <summary>
            Allows derived classes to provide compiler-specific options.
            </summary>
            <param name="writer">The <see cref="T:System.IO.TextWriter"/> to which the compiler options should be written.</param>
        </member>
        <member name="M:NAnt.DotNet.Tasks.CompilerBase.WriteOption(System.IO.TextWriter,System.String)">
            <summary>
            Writes an option using the default output format.
            </summary>
            <param name="writer">The <see cref="T:System.IO.TextWriter"/> to which the compiler options should be written.</param>
            <param name="name">The name of the option which should be passed to the compiler.</param>
        </member>
        <member name="M:NAnt.DotNet.Tasks.CompilerBase.WriteOption(System.IO.TextWriter,System.String,System.String)">
            <summary>
            Writes an option and its value using the default output format.
            </summary>
            <param name="writer">The <see cref="T:System.IO.TextWriter"/> to which the compiler options should be written.</param>
            <param name="name">The name of the option which should be passed to the compiler.</param>
            <param name="value">The value of the option which should be passed to the compiler.</param>
            <remarks>
            The combination of <paramref name="name"/> and 
            <paramref name="value"/> (separated by a colon) is quoted
            unless <paramref name="value"/> is already surrounded by quotes.
            </remarks>
        </member>
        <member name="M:NAnt.DotNet.Tasks.CompilerBase.NeedsCompiling">
            <summary>
            Determines whether compilation is needed.
            </summary>
        </member>
        <member name="M:NAnt.DotNet.Tasks.CompilerBase.GetResourceLinkage(System.String,System.Globalization.CultureInfo)">
            <summary>
            Finds the correct namespace/classname for a resource file from the 
            given dependent source file.
            </summary>
            <param name="dependentFile">The file from which the resource linkage of the resource file should be determined.</param>
            <param name="resourceCulture">The culture of the resource file for which the resource linkage should be determined.</param>
            <returns>
            The namespace/classname of the source file matching the resource or
            <see langword="null" /> if the dependent source file does not exist.
            </returns>
            <remarks>
            This behaviour may be overidden by each particular compiler to 
            support the namespace/classname syntax for that language.
            </remarks>
        </member>
        <member name="M:NAnt.DotNet.Tasks.CompilerBase.LinkResourceAssembly(System.Collections.Hashtable,System.IO.FileInfo,System.String)">
            <summary>
            Link a list of files into a resource assembly.
            </summary>
            <param name="resourceFiles">The collection of resources.</param>
            <param name="resourceAssemblyFile">Resource assembly to generate</param>
            <param name="culture">Culture of the generated assembly.</param>
        </member>
        <member name="M:NAnt.DotNet.Tasks.CompilerBase.CompileResxResources(System.Collections.Specialized.StringCollection)">
            <summary>
            Compiles a set of resx files to a .resources files.
            </summary>
            <param name="resxFiles">The set of resx files to compile.</param>
        </member>
        <member name="M:NAnt.DotNet.Tasks.CompilerBase.GetResourceCulture(System.String,System.String)">
            <summary>
            Determines the culture associated with a given resource file by
            scanning the filename for valid culture names.
            </summary>
            <param name="resourceFile">The resource file path to check for culture info.</param>
            <param name="dependentFile">The file on which the resource file depends.</param>
            <returns>
            A valid <see cref="T:System.Globalization.CultureInfo"/> instance if the resource is 
            associated with a specific culture; otherwise, <see langword="null"/>.
            </returns>
        </member>
        <member name="P:NAnt.DotNet.Tasks.CompilerBase.Debug">
            <summary>
            Generate debug output. The default is <see langword="false" />.
            </summary>
            <remarks>
            Only used for &lt;jsc&gt; tasks, but retained for backward 
            compatibility (Clover.NET).
            </remarks>
        </member>
        <member name="P:NAnt.DotNet.Tasks.CompilerBase.OutputFile">
            <summary>
            The output file created by the compiler.
            </summary>
        </member>
        <member name="P:NAnt.DotNet.Tasks.CompilerBase.OutputTarget">
            <summary>
            Output type. Possible values are <c>exe</c>, <c>winexe</c>,
            <c>library</c> or <c>module</c>.
            </summary>
        </member>
        <member name="P:NAnt.DotNet.Tasks.CompilerBase.Define">
            <summary>
            Define conditional compilation symbol(s).
            </summary>
            <remarks>
            <para>
            Corresponds to <c>/d[efine]:</c> flag.
            </para>
            </remarks>
        </member>
        <member name="P:NAnt.DotNet.Tasks.CompilerBase.Win32Icon">
            <summary>
            Icon to associate with the application.
            </summary>
            <remarks>
            <para>
            Corresponds to <c>/win32icon:</c> flag.
            </para>
            </remarks>
        </member>
        <member name="P:NAnt.DotNet.Tasks.CompilerBase.Win32Res">
            <summary>
            Specifies a Win32 resource file (.res).
            </summary>
            <remarks>
            <para>
            Corresponds to <c>/win32res[ource]:</c> flag.
            </para>
            </remarks>
        </member>
        <member name="P:NAnt.DotNet.Tasks.CompilerBase.WarnAsError">
            <summary>
            Instructs the compiler to treat all warnings as errors. The default
            is <see langword="false" />.
            </summary>
            <remarks>
            <para>
            Corresponds to the <c>/warnaserror[+|-]</c> flag of the compiler.
            </para>
            <para>
            When this property is set to <see langword="true" />, any messages
            that would ordinarily be reported as warnings will instead be
            reported as errors.
            </para>
            </remarks>
        </member>
        <member name="P:NAnt.DotNet.Tasks.CompilerBase.WarningAsError">
            <summary>
            Controls which warnings should be reported as errors.
            </summary>
        </member>
        <member name="P:NAnt.DotNet.Tasks.CompilerBase.NoWarn">
            <summary>
            Specifies a comma-separated list of warnings that should be suppressed
            by the compiler.
            </summary>
            <value>
            Comma-separated list of warnings that should be suppressed by the 
            compiler.
            </value>
            <remarks>
            <para>
            Corresponds with the <c>/nowarn</c> flag.
            </para>
            </remarks>
        </member>
        <member name="P:NAnt.DotNet.Tasks.CompilerBase.SuppressWarnings">
            <summary>
            Specifies a list of warnings that you want the compiler to suppress.
            </summary>
        </member>
        <member name="P:NAnt.DotNet.Tasks.CompilerBase.ForceRebuild">
            <summary>
            Instructs NAnt to recompile the output file regardless of the file timestamps.
            </summary>
            <remarks>
            When this parameter is to <see langword="true" />, NAnt will always
            run the compiler to rebuild the output file, regardless of the file timestamps.
            </remarks>
        </member>
        <member name="P:NAnt.DotNet.Tasks.CompilerBase.MainType">
            <summary>
            Specifies which type contains the Main method that you want to use
            as the entry point into the program.
            </summary>
            <remarks>
            <para>
            Corresponds to the <c>/m[ain]:</c> flag of the compiler.
            </para>
            <para>
            Use this property when creating an executable file. If this property
            is not set, the compiler searches for a valid Main method in all
            public classes.
            </para>
            </remarks>
        </member>
        <member name="P:NAnt.DotNet.Tasks.CompilerBase.KeyContainer">
            <summary>
            Specifies the key pair container used to strongname the assembly.
            </summary>
        </member>
        <member name="P:NAnt.DotNet.Tasks.CompilerBase.KeyFile">
            <summary>
            Specifies a strong name key file.
            </summary>
        </member>
        <member name="P:NAnt.DotNet.Tasks.CompilerBase.DelaySign">
            <summary>
            Specifies whether to delay sign the assembly using only the public
            portion of the strong name key. The default is 
            <see cref="F:NAnt.DotNet.Types.DelaySign.NotSet"/>.
            </summary>
        </member>
        <member name="P:NAnt.DotNet.Tasks.CompilerBase.Lib">
            <summary>
            Additional directories to search in for assembly references.
            </summary>
            <remarks>
            <para>
            Corresponds with the <c>/lib[path]:</c> flag.
            </para>
            </remarks>
        </member>
        <member name="P:NAnt.DotNet.Tasks.CompilerBase.References">
            <summary>
            Reference metadata from the specified assembly files.
            </summary>
        </member>
        <member name="P:NAnt.DotNet.Tasks.CompilerBase.Packages">
            <summary>
            Specifies list of packages to reference.
            </summary>
        </member>
        <member name="P:NAnt.DotNet.Tasks.CompilerBase.ResourcesList">
            <summary>
            Resources to embed.
            </summary>
            <remarks>
            <para>
            This can be a combination of resx files and file resources.
            </para>
            <para>
            .resx files will be compiled by <see cref="T:NAnt.DotNet.Tasks.ResGenTask"/> and then
            embedded into the resulting executable.
            </para>
            <para>
            The <see cref="P:NAnt.DotNet.Types.ResourceFileSet.Prefix"/> property is used to make
            up the resource name added to the assembly manifest for non-resx
            files.
            </para>
            <para>
            For .resx files the namespace from the matching source file is used
            as prefix. This matches the behaviour of Visual Studio.
            </para>
            <para>
            Multiple resources tags with different namespace prefixes may be
            specified.
            </para>
            </remarks>
        </member>
        <member name="P:NAnt.DotNet.Tasks.CompilerBase.Modules">
            <summary>
            Link the specified modules into this assembly.
            </summary>
        </member>
        <member name="P:NAnt.DotNet.Tasks.CompilerBase.Sources">
            <summary>
            The set of source files for compilation.
            </summary>
        </member>
        <member name="P:NAnt.DotNet.Tasks.CompilerBase.SupportsPackageReferences">
            <summary>
            Indicates whether package references are supported by compiler for 
            a given target framework. The default is <see langword="false" />.
            </summary>
        </member>
        <member name="P:NAnt.DotNet.Tasks.CompilerBase.SupportsWarnAsErrorList">
            <summary>
            Indicates whether the compiler for a given target framework supports
            the "warnaserror" option that takes a list of warnings. The default 
            is <see langword="false" />.
            </summary>
        </member>
        <member name="P:NAnt.DotNet.Tasks.CompilerBase.SupportsNoWarnList">
            <summary>
            Indicates whether the compiler for a given target framework supports
            a command line option that allows a list of warnings to be
            suppressed. The default is <see langword="false" />.
            </summary>
        </member>
        <member name="P:NAnt.DotNet.Tasks.CompilerBase.SupportsKeyContainer">
            <summary>
            Indicates whether the compiler for a given target framework supports
            the "keycontainer" option. The default is <see langword="false" />.
            </summary>
        </member>
        <member name="P:NAnt.DotNet.Tasks.CompilerBase.SupportsKeyFile">
            <summary>
            Indicates whether the compiler for a given target framework supports
            the "keyfile" option. The default is <see langword="false" />.
            </summary>
        </member>
        <member name="P:NAnt.DotNet.Tasks.CompilerBase.SupportsDelaySign">
            <summary>
            Indicates whether the compiler for a given target framework supports
            the "delaysign" option. The default is <see langword="false" />.
            </summary>
        </member>
        <member name="P:NAnt.DotNet.Tasks.CompilerBase.Extension">
            <summary>
            Gets the file extension required by the current compiler.
            </summary>
            <value>
            The file extension required by the current compiler.
            </value>
        </member>
        <member name="P:NAnt.DotNet.Tasks.CompilerBase.ClassNameRegex">
            <summary>
            Gets the class name regular expression for the language of the current compiler.
            </summary>
            <value> class name regular expression for the language of the current compiler</value>
        </member>
        <member name="P:NAnt.DotNet.Tasks.CompilerBase.NamespaceRegex">
            <summary>
            Gets the namespace regular expression for the language of the current compiler.
            </summary>
            <value> namespace regular expression for the language of the current compiler</value>
        </member>
        <member name="P:NAnt.DotNet.Tasks.CompilerBase.ProgramArguments">
            <summary>
            Gets the command-line arguments for the external program.
            </summary>
            <value>
            The command-line arguments for the external program.
            </value>
        </member>
        <member name="T:NAnt.DotNet.Tasks.CompilerBase.ResourceLinkage">
            <summary>
            Holds class and namespace information for resource (*.resx) linkage.
            </summary>
        </member>
        <member name="M:NAnt.DotNet.Tasks.CompilerBase.ResourceLinkage.#ctor(System.String,System.String)">
            <summary>
            Initializes a new instance of the <see cref="T:NAnt.DotNet.Tasks.CompilerBase.ResourceLinkage"/>
            class.
            </summary>
            <param name="namespaceName">The namespace the resource is under.</param>
            <param name="className">The class name the resource is associated with.</param>
        </member>
        <member name="M:NAnt.DotNet.Tasks.CompilerBase.ResourceLinkage.ToString">
            <summary>
            Returns the resource linkage as a string.
            </summary>
            <returns>
            A string representation of the resource linkage.
            </returns>
        </member>
        <member name="P:NAnt.DotNet.Tasks.CompilerBase.ResourceLinkage.IsValid">
            <summary>
            Gets a value indicating whether the <see cref="T:NAnt.DotNet.Tasks.CompilerBase.ResourceLinkage"/>
            instances contains valid data.
            </summary>
            <value>
            <see langword="true"/> if the <see cref="T:NAnt.DotNet.Tasks.CompilerBase.ResourceLinkage"/>
            instance contains valid data; otherwise, <see langword="false"/>.
            </value>
        </member>
        <member name="P:NAnt.DotNet.Tasks.CompilerBase.ResourceLinkage.HasNamespaceName">
            <summary>
            Gets a value indicating whether a namespace name is available
            for this <see cref="T:NAnt.DotNet.Tasks.CompilerBase.ResourceLinkage"/> instance.
            </summary>
            <value>
            <see langword="true"/> if a namespace name is available for 
            this <see cref="T:NAnt.DotNet.Tasks.CompilerBase.ResourceLinkage"/> instance; otherwise, 
            <see langword="false"/>.
            </value>
        </member>
        <member name="P:NAnt.DotNet.Tasks.CompilerBase.ResourceLinkage.HasClassName">
            <summary>
            Gets a value indicating whether a class name is available
            for this <see cref="T:NAnt.DotNet.Tasks.CompilerBase.ResourceLinkage"/> instance.
            </summary>
            <value>
            <see langword="true"/> if a class name is available for 
            this <see cref="T:NAnt.DotNet.Tasks.CompilerBase.ResourceLinkage"/> instance; otherwise, 
            <see langword="false"/>.
            </value>
        </member>
        <member name="P:NAnt.DotNet.Tasks.CompilerBase.ResourceLinkage.NamespaceName">
            <summary>
            Gets the name of namespace the resource is under.  
            </summary>
            <value>
            The name of namespace the resource is under.  
            </value>
        </member>
        <member name="P:NAnt.DotNet.Tasks.CompilerBase.ResourceLinkage.ClassName">
            <summary>
            Gets the name of the class (most likely a form) that the resource 
            is associated with.  
            </summary>
            <value>
            The name of the class the resource is associated with.  
            </value>
        </member>
        <member name="P:NAnt.DotNet.Tasks.CompilerBase.ResourceLinkage.Culture">
            <summary>
            Gets the culture that the resource is associated with.
            </summary>
            <value>
            The culture that the resource is associated with.
            </value>
        </member>
        <member name="T:NAnt.DotNet.Tasks.CscTask">
            <summary>
            Compiles C# programs.
            </summary>
            <remarks>
            <note>
            In order to have <see cref="T:NAnt.DotNet.Tasks.CscTask"/> generate manifest resource names
            that match those generated by Microsoft Visual Studio.NET, the value of
            the <see cref="P:NAnt.DotNet.Types.ResourceFileSet.Prefix"/> attribute of the &lt;<see cref="P:NAnt.DotNet.Tasks.CompilerBase.ResourcesList"/>&gt;
            element should match the "Default Namespace" of the C# project, and the 
            value of the <see cref="P:NAnt.DotNet.Types.ResourceFileSet.DynamicPrefix"/> attribute 
            should be set to "<see langword="true"/>".
            </note>
            </remarks>
            <example>
              <para>Compile a "HelloWorld" application, including embedded resources.</para>
              <code>
                <![CDATA[
            <csc target="exe" output="HelloWorld.exe" debug="true">
                <nowarn>
                    <!-- do not report warnings for missing XML comments -->
                    <warning number="0519" />
                </nowarn>
                <sources>
                    <include name="**/*.cs" />
                </sources>
                <resources dynamicprefix="true" prefix="HelloWorld">
                    <include name="**/*.resx" />
                </resources>
                <references>
                    <include name="System.dll" />
                    <include name="System.Data.dll" /…