wx.Net.Build: wx.Build.Net.CSharpAssemblyProject Class Reference

wx.Build.Net.CSharpAssemblyProject.CSharpAssemblyProject ( )

Use only for XML serialization before ReadXml(). This will initialize an empty project of empty name that will not be offered.

wx.Build.Net.CSharpAssemblyProject.CSharpAssemblyProject ( CSharpAssemblyProject src )

Copy CTor

Parameters:

src

the source

wx.Build.Net.CSharpAssemblyProject.CSharpAssemblyProject	(	ProjectPreference	preference,
		string	name,
		string	assemblyFileToBeBuilt,
		string	description
	)

Creates an instance deriving the content type of the assembly file from the extension of the provided file name. Please note, that this CTor can distinguish DLLs from programs (extensions .dll and .exe) but fails to distinguish signed from unsigned assemblies.

Parameters:

	preference	Preference of the project
	name	Name of the project. Will occur in user information and error strings.
	assemblyFileToBeBuilt	Filename of the result. Names ending with `.exe` will create programs. Names ending with ".mod", ".module", or ".netmodule" will create .NET modules.
	description	Text description of the project - for user information.

wx.Build.Net.CSharpAssemblyProject.CSharpAssemblyProject	(	ProjectPreference	preference,
		string	name,
		ContentFile	assemblyFileToBeBuilt,
		string	description
	)

Creates an instance deriving the content type of the assembly file from the extension of the provided file name.

Parameters:

	preference	Preference of the project
	name	Name of the project. Will occur in user information and error strings.
	assemblyFileToBeBuilt	Filename of the result. The content type of this file must imply ContentType.DotNetDll or ContentType.DotNetModule.
	description	Text description of the project - for user information.

Exceptions:

System.ArgumentException Will be thrown if the content type of the assemblyFileToBeBuilt does not imply ContentType.DorNetDll.

delegate void wx.Build.BaseAction.AdderSerializable ( System.Xml.Serialization.IXmlSerializable arg ) [inherited]

Will be called in ReadCollection() if a new object has been found.

Parameters:

arg

The object that has been found.

void wx.Build.Net.CSharpAssemblyProject.AddExternalResources ( ICollection< ResourceDesignator > resources )

Adds the provided resources to the list of external resources. These resources will not be linked into the assembly but shall be available side by side to the created DLL or program. The internal name will be interpreted as a relative path that will be used to compute the desired position of the resource relatively to the created program or DLL. This will raise an error if the internal name of the resource can be interpreted as a rooted filename.

Parameters:

resources

A collection of resources, e.g. created by ResourceDesignator.SelectExternalResources().

ExternalResources

static ICollection<BuildProject> wx.Build.BuildProject.AddIncludedProjects	(	IDictionary< BuildProject, BuildProject >	result,
		ICollection< IBuildProduct >	listOfBuildProducts
	)			`[static, inherited]`

Adds all build projects from listOfBuildProjects and their prerequisites to the result (a set: value equals key).

static void wx.Build.BuildProject.AddKnownProject ( BuildProject p ) [static, inherited]

This will add the provided project to the collection of known projects. This method will create a GUID for the added project if not yet known.

Parameters:

p

The project that shall be added.

virtual bool wx.Build.BuildProject.AdoptConfig ( BuildConfig config ) [virtual, inherited]

Change the provided configuration of necessary in order to produce the targets.

Returns:: is true iff changes have been necessary. This method will be called immediately before executing the project in order to create a fixed point of the configuration. Apply only sparse changes. Returning true on parameters that have been changed by another project will stop the build process because of inconsistent demands on the configuration.

This default implementation will always return false .

Reimplemented in wx.Build.Cxx.wxWidgets.

virtual void wx.Build.BaseAction.AppendBooCode	(	List< string >	booCodeLines,
		string	indention,
		BuildToolFamilyEnv	env
	)			`[virtual, inherited]`

This implementation will look for a program start info that implements this actions. If program start info is null, this implementation will raise an exception. Overload this if you have to create another implementation providing this feature.

Parameters:

	env	This is an environment that different tools of the same family may use to exchange information. This store is typically used to save information on configuration files or thinsgs of that kind that will be shared among all tools of the same family.
	booCodeLines	The code that will actually build something will be appended to this writer.
	indention	A string that shall preceed all created lines.

Exceptions:

NotSupportedException

Will be thrown if this feature is not supported.

See also:: GetProgrammStartInfo

Reimplemented in wx.Build.FileTestAction, wx.Build.Cxx.GCC.GccAsCompiler, wx.Build.Cxx.GCC.GccAsLinker, wx.Build.Cxx.GCC.WindRes, wx.Build.Mono.Gmcs, wx.Build.MS.Cl, wx.Build.MS.Link, wx.Build.MS.RC, wx.Build.MS.Csc, wx.Build.Release.ReplaceVersionInRCFile, and wx.Build.Release.CopyFileAction.

virtual void wx.Build.BaseAction.AppendToBooPreamble	(	BuildToolFamilyEnv	env,
		List< string >	importModules,
		List< string >	booDeclarations,
		List< string >	booDefinitions
	)			`[virtual, inherited]`

This will be called for any action provider before IBuildAction.AppendBooCode() is called. This provides action providers with the opportunity to import modules and create variables for global options.

Parameters:

	importModules	List of modules that shall be imported. Add required modules here. Each module will be imported exactly once (even if it occurs more than once in the list).
	env	This is an environment that different tools of the same family may use to exchange information. This store is typically used to save information on configuration files or thinsgs of that kind that will be shared among all tools of the same family.

A typical use is the import of modules that will be used in the later BOO code that builds the project.

            void AppendToBooPreamble(System.IO.TextWriter booCodeLines)
            {
                booCodeLines.Add("import System.Diagnostics");
                booCodeLines.Add("Process=System.Diagnostics.Process");
            }

Reimplemented in wx.Build.Cxx.GCC.GccAsCompiler, wx.Build.Cxx.GCC.GccAsLinker, wx.Build.Cxx.GCC.WindRes, wx.Build.Mono.Gmcs, wx.Build.MS.Cl, wx.Build.MS.Link, wx.Build.MS.RC, and wx.Build.MS.Csc.

bool wx.Build.BaseAction.AreAllMandatoryVarsDefined ( ) [inherited]

True iff all mandatory environment variables are defined. The project cannot be made if this is false.

static int wx.Build.BuildProject.Build	(	ErrorHandler	handler,
		System.Reflection.Assembly	projectSrc,
		string[]	programOpts
	)			`[static, inherited]`

Builds projects regarding the provided options.

Parameters:

	handler	will be set as configured error handler in the BuildConfig. Output of errors and warnings via `handler` .
	programOpts	programOpts may be the name of tools/build actions or projects, or you may use one or more of the options "/help", "/vars", "/projects", "/actions", "/clean", "/disable:ACTION", "/disable:PROJECT", /set:VARNAME=VALUE, or /append:VARNAME=VALUE. Refer to class CommandLineOptions.
	projectSrc	The assembly containing the project definitions. This may be `null`.

Returns:: 0 on success and 1 on failure, that should however also be reported to the error handler.

static int wx.Build.BuildProject.Build	(	ErrorHandler	handler,
		string[]	programOpts
	)			`[static, inherited]`

Builds projects regarding the provided options. Projects will be read from the Assembly.GetCallingAssembly.

Parameters:

	handler	Output of errors and warnings using this handler.
	programOpts	programOpts may be the name of tools/build actions or projects, or you may use one or more of the options "/help", "/vars", "/targets", "/projects", "/clean", "/disable:ACTION", "/disable:PROJECT", `/set:VARNAME=VALUE`, or `/append:VARNAME=VALUE`. Refer to class CommandLineOptions.

Returns:: 0 on success and 1 on failure, that should however also be reported to the error handler.

Refer to the remarks on class BuildProject for an example of a project definition.

static int wx.Build.BuildProject.Build ( string[] programOpts ) [static, inherited]

Builds projects regarding the provided options. Projects will be read from the Assembly.GetCallingAssembly. Output of errors and warnings on System.Console.

Parameters:

programOpts programOpts may be the name of tools/build actions or projects, or you may use one or more of the options "/help", "/vars", "/targets", "/projects", "/clean", "/disable:ACTION", "/disable:PROJECT", /set:VARNAME=VALUE, or /append:VARNAME=VALUE. Refer to class CommandLineOptions.

Returns:: 0 on success and 1 on failure, that should however also be reported to the error handler.

See also:: CommandLineOptions

static void wx.Build.BuildProject.ClearKnownProjects ( ) [static, inherited]

Clear the loaded projects.

override object wx.Build.Net.CSharpAssemblyProject.Clone ( ) [virtual]

Deep copy of this instance.

Implements wx.Build.BuildProject.

void wx.Build.BaseAction.CollectChoicePoints ( IDictionary< string, ICollection< string >> collectionOfChoicePoints ) [inherited]

This method collects all choice points within this action. Choice points are represented by a name and a collection of alternatives.

Parameters:

collectionOfChoicePoints

The collection that will be extended by the choice points of this action.

The current implementation provides a choice point for the compilation and linking of C/C++ programs, "CppDevelopmentSystem" of the alternatives "GCC" and "MS VC". Thus, actions on C/C++ compilation will add the following choice point:

            if (!collectionOfChoicePoints.ContainsKey("CppDevelopmentSystem"))
                collectionOfChoicePoints.Add("CppDevelopmentSystem", new List&lt;string&gt;());
            collectionOfChoicePoints["CppDevelopmentSystem"].Add("GCC");
            collectionOfChoicePoints["CppDevelopmentSystem"].Add("MS VC");

virtual int wx.Build.BuildProject.CompareTo ( object obj ) [virtual, inherited]

Compares all properties, targets, and dependencies of this and the obj if the argument is a project of the same class. If the argument is of another class, this compares the full class names.

This is virtual since inheritors may overload this. However, inheritors MUST take care, that their implementation is symmetric to this one, i.e. must be of the form

            if (obj.GetType().Equals(this.GetType())
            {
                ...
            }
            else return this.GetType().FullName.CompareTo(obj.GetType().FullName);

Parameters:

obj

Object that will be compared with this.

Returns:: -1, 0, or 1 like in all the other implementations of this method.

Reimplemented in wx.Build.Release.MakeReleaseProject.

override bool wx.Build.Net.CSharpAssemblyProject.ContainsPrerequisite ( IBuildProduct prereq ) [virtual]

True iff prereq is among the GetPrerequisites().

Reimplemented from wx.Build.BaseAction.

override ICollection<IBuildAction> wx.Build.Net.CSharpAssemblyProject.CreateActionPlan ( BuildToolFamilyEnv env ) [virtual]

Looks for an applicable action to compile, link resources, and sign up. Will try to make the assembly first. Then linking and signing.

Returns:: is a collection of actions that achieve the targets or null in case of errors that shall stop the build process.

Implements wx.Build.BuildProject.

override RefToProject wx.Build.SingleFileProject.CreateRef ( ) [virtual, inherited]

Returns an instance of RefToFileProject.

Returns:

Reimplemented from wx.Build.FileProject.

override RefToFileProject wx.Build.SingleFileProject.CreateRefToFileProject ( ) [virtual, inherited]

Returns an instance of RefToFileProject.

Returns:

Reimplemented from wx.Build.FileProject.

RefToSingleFileProject wx.Build.SingleFileProject.CreateRefToSingleFileProject ( ) [inherited]

override bool wx.Build.BuildProject.Equals ( object obj ) [inherited]

Comparison refers to the implementation of IComparable.CompareTo().

static ICollection<BuildProject> wx.Build.BuildProject.GetAllProjectsDeclaredInAssembly	(	System.Reflection.Assembly	assembly,
		ICollection< ErrorObject >	errors
	)			`[static, inherited]`

Returns a collection of all projects declared in the provided assembly. Projects are declared using the attributes BuildProjectAttribute.

Parameters:

	assembly	The assembly that contains the project definitions. This method will also accept `null`. In that case, this will return the GetLoadedProjects()
	errors	This method will add encountered errors to this argument if it is not `null`.

Guid wx.Build.BuildProject.GetGuid ( ) [inherited]

This will return the Id but create one if not yet known.

Id

override int wx.Build.BuildProject.GetHashCode ( ) [inherited]

Reimplemented in wx.Build.Release.MakeReleaseProject.

static BuildProject wx.Build.BuildProject.GetKnownProject ( Guid id ) [static, inherited]

Returns the project of the provided ID.

Parameters:

id

The ID of the desired project

Returns:: The project of the desired name or null if this project is unknown.

static ICollection<BuildProject> wx.Build.BuildProject.GetKnownProjects ( ) [static, inherited]

Returns the collection of projects that have been loaded from file.

override ICollection<IBuildProduct> wx.Build.Net.CSharpAssemblyProject.GetPrerequisites ( ) [virtual]

Returns a collection containing the input files. Signature, sources, icons, references assemblies.

Implements wx.Build.BaseAction.

virtual System.Diagnostics.ProcessStartInfo wx.Build.BaseAction.GetProgramStartInfo ( BuildToolFamilyEnv env ) [virtual, inherited]

This simply returns null and may serve as standard implementation of those actions that do not use System.Diagnostics.Process.

Reimplemented in wx.Build.Cxx.GCC.GccAsCompiler, wx.Build.Cxx.GCC.GccAsLinker, wx.Build.Cxx.GCC.WindRes, wx.Build.Mono.Gmcs, wx.Build.MS.Cl, wx.Build.MS.Link, wx.Build.MS.RC, and wx.Build.MS.Csc.

System.Xml.Schema.XmlSchema wx.Build.BuildProject.GetSchema ( ) [inherited]

Returns null as suggested by the .NET framework documentation.

new CSharpAssemblyProject wx.Build.Net.CSharpAssemblyProject.GetSingleton ( )

This will make the project instance ready to be solved. The build system will only use one project instance per target. Thus, projects will be registered. This will try to register this instance. If the database of registered project already contains a project instance for the targets of this instance, this will return this instance.

After calling this method, all calls to modifiers are allowed to throw errors.

Returns:

Reimplemented from wx.Build.BuildProject.

override ICollection<IBuildProduct> wx.Build.Net.CSharpAssemblyProject.GetTargets ( ) [virtual]

Returns a collection of all affected files (that exist if this has been done). This is read only.

Implements wx.Build.BaseAction.

static ICollection<EnvironmentVarInfo> wx.Build.BuildProject.GetUsedVariables ( System.Reflection.Assembly projectSrc ) [static, inherited]

Creates a collection of all environment variables that are used either by project or actions.

Parameters:

projectSrc

An assembly that contains project definitions. This may be null. In that case, this will use all loaded problems.

Returns:

override DateTime wx.Build.BuildProject.GetValidity ( ) [virtual, inherited]

This is the timestamp representing how current the prerequisites are. The standard implementation will use be the latest validity of a prerequisite.

Reimplemented from wx.Build.BaseAction.

Reimplemented in wx.Build.Cxx.wxWidgets.

override DateTime wx.Build.BuildProject.GetValidityDemand ( ) [virtual, inherited]

This is the timestamp representing the latest change of a prerequisite. The standard implementation will use be the latest validity of a prerequisite.

Reimplemented from wx.Build.BaseAction.

Reimplemented in wx.Build.Cxx.wxWidgets.

DateTime wx.Build.BaseAction.GetValidityTargets ( ) [inherited]

This is the earliest validiy of a target.

static BuildProject wx.Build.BuildProject.LoadRefFrom ( System.Xml.XmlReader reader ) [static, inherited]

Reads a project whose properties are available by GetLoadedProject().

Parameters:

reader

The source.

Exceptions:

KeyNotFoundException

Raised if the read project cannot be found in the GetLoadedProject().

virtual void wx.Build.BuildProject.NormalizeOriginalFileName ( string nameOfAValidDirOrFile ) [virtual, inherited]

You may use this method to control the form of the file name that will be used to serialize this (the original filename). The argument is a path to an existing file or directory. This will strip a directory information from this path. After that, the original file name will change to something equivalent to the absolute filename (referring to the same file) but now relative to the directory as specified by the argument.

Use this method to prepare content file instance for serialization in such a way that all file names become relative to the same directory.

Parameters:

nameOfAValidDirOrFile The name of an existing file or directory. This name will - if relative - be expanded using the BuildConfig. If this is null, this method will return without any effect. This may also be the name of a not yet existing file. In that case, however, the directory name shall exist.

See also:: OriginalFileName

Exceptions:

System.ArgumentException

Will be raised if the argument is neither the path to an existing file nor directory.

Reimplemented in wx.Build.Release.MakeReleaseProject.

static implicit wx.Build.FileProject.operator FileProject ( RefToFileProject refToProject ) [static, inherited]

static implicit wx.Build.SingleFileProject.operator SingleFileProject ( RefToSingleFileProject refToProject ) [static, inherited]

static bool wx.Build.BaseAction.ReadCollection	(	System.Xml.XmlReader	reader,
		AdderSerializable	collectorForResults,
		string	outerElementName,
		string	innerElementName
	)			`[static, inherited]`

Reads a collection of serializable objects from the provided XML source.

Parameters:

	reader	XML source
	collectorForResults	This will add the created results to this collection.
	outerElementName	name of the XML element that will embrace all elements.
	innerElementName	Name of the XML element that contains the information of a single serialized object.

Returns:: True if the outer element name has been found. False if this has not been able to parse a term complying with the expected content.

void wx.Build.BaseAction.ReadProject ( System.Xml.XmlReader reader ) [protected, inherited]

Reads the features as serialized by WriteFeatures().

Parameters:

reader

The source of serialized data

static System.Xml.Serialization.IXmlSerializable wx.Build.BaseAction.ReadSerializable	(	System.Xml.XmlReader	reader,
		string	elementName
	)			`[static, inherited]`

This reads a serilization that has been created by WriteSerializable(). This only works if an instance of the serialized obejct can be created without arguments.

Parameters:

	reader	The serialization will be read from this source.
	elementName	Name of the XML element that encapsulates the serialization.

Returns:: The object instance that has been created from the serialized information.

WriteSerializable

void wx.Build.BuildProject.ReadStdAttributes ( System.Xml.XmlReader reader ) [protected, inherited]

Helper for XML serialization of projects. Call this immediately after reading the root element of a serialized project to read the attributes stored by WriteStdAttributes().

Parameters:

reader

The source where to read the serialization from.

override void wx.Build.Net.CSharpAssemblyProject.ReadXml ( System.Xml.XmlReader reader ) [virtual]

Reads an XML serialization that has been written by WriteXml().

Parameters:

reader

The source where the serialization will be read from.

Implements wx.Build.BuildProject.

static Guid wx.Build.BuildProject.RegisterProjectTargets ( BuildProject p ) [static, protected, inherited]

Static factory methods creating projects will use this method to decide whether a new instance of the project is justified or probably a doublette.

Parameters:

p

The project instance that shall be tested.

Returns:: The Guid of a preexisting project producing at least on of p's targets and that is of the same type. The result will be the GUID of p if p can be used.

static IList<BuildProject> wx.Build.BuildProject.ScheduleProjects ( ICollection< BuildProject > projects ) [static, inherited]

Put projects in such an order that they occur before all their prerequisites that are also projects. This will put the project into a certain order that allows later steps of processing to concatenate actions plans.

Parameters:

projects

projects to schedule.

Returns:: a list containig all projects and their prerequisites or null in case that no appropriate order exists.

void wx.Build.BuildProject.SetAsKnownProject ( Guid oldGuid ) [protected, inherited]

Register this as a loaded project. The argument is the old Id of this project that it might have had before reading from a stream or System.Guid.Empty if the project instance did not have an Id before.

Parameters:

oldGuid The old Id of this instance or System.Guid.Empty if this did not have an Id before.

This will remove this project from the collection of loaded projects if it has been registered before with Id oldGuid.

static string wx.Build.BuildProject.StringAsSymbol ( string aName ) [static, inherited]

Returns a version of the argument that may serve as a C/C++ or C# symbol.

Parameters:

aName

Returns:

virtual bool wx.Build.BaseAction.TargetsAreConsistent ( DateTime validityOfBuildSystem ) [virtual, inherited]

This simply tests whether the oldest validity of the targets is equal to or more current than the validity of the prerequisites.

Parameters:

validityOfBuildSystem

indicates the last change of either this DLL or the assembly defining the project. changes to the build system or the project definition affect of course the validity of the produced targets. Use System.DateTime.MinValue if you do not know or want this to be neglected.

Reimplemented in wx.Build.Cxx.wxWidgets.

override string wx.Build.BuildProject.ToString ( ) [inherited]

static void wx.Build.BaseAction.WriteCollectionOfSerializables	(	System.Xml.XmlWriter	writer,
		System.Collections.IEnumerable	serializables,
		string	outerElementName,
		string	innerElementName
	)			`[static, inherited]`

Serializes a collection of serializable objects.

Parameters:

	writer	This method will write the serialization to this destination.
	serializables	The collection of object to serialize. All objects must implement System.Xml.Serialization.IXmlSerializable.
	outerElementName	name of the XML element that will embrace all elements.
	innerElementName	Name of the XML element that contains the information of a single serialized object.

void wx.Build.BaseAction.WriteProject ( System.Xml.XmlWriter writer ) [protected, inherited]

This will serialize the feature list in an XML element "feature-list".

Parameters:

writer

Destination of serialized data.

void wx.Build.BuildProject.WriteRefXml ( System.Xml.XmlWriter writer ) [inherited]

Serializing only the name of the project. Read this using LoadRefFrom().

Parameters:

writer

The destinaton

static void wx.Build.BaseAction.WriteSerializable	(	System.Xml.XmlWriter	writer,
		System.Xml.Serialization.IXmlSerializable	obj,
		string	elementName
	)			`[static, inherited]`

Helper to serialize objects of unknown class. This will create an element of the provided element name and attach attributes "assembly" and "type" to this element. These elements will describe the type of the object to serialize. Then, embedded into this new element, the object will be asked to place its serialization.

Parameters:

	obj	The object that shall be serialized. May be `null`
	elementName	Name of the XML element that will be created.
	writer	The information will be written to this destination.

Use this method to serialize member variables of unknown type like e.g. wx.Build.IFileProducts. Often, projects refer to members where the only known information is: This implements wx.Build.IFileProducts. The project does not need to know more facts with one exception: When deserializing a XML serialization, the project needs to know the exact class because an object instance has to be created. This method will serialize the corresponding information in such a form, that ReadSerializable() can be used to read the written instance.

void wx.Build.BuildProject.WriteStdAttributes ( System.Xml.XmlWriter writer ) [protected, inherited]

Helper for XML serialization of projects. This will use System.Xml.XmlWriter.WriteAttributeString to write the attributes "name" and "preference". Call this immediately after starting the root element of the serialized project.

Parameters:

writer

Destination

override void wx.Build.Net.CSharpAssemblyProject.WriteXml ( System.Xml.XmlWriter writer ) [virtual]

Write an XML serialization to the provided XML writer that can be read by ReadXml().

Parameters:

writer

This will write the serialization to this destination.

Implements wx.Build.BuildProject.

readonly FeatureEntry wx.Build.Net.CSharpAssemblyProject.PlatformX32 = new FeatureEntry("Platform 32 bit", "Defines a 32 bit processor architecture. This will take effect on the platform descriptor when using MS .NET tools.", "X32") [static]

readonly FeatureEntry wx.Build.Net.CSharpAssemblyProject.PlatformX64 = new FeatureEntry("Platform 64 bit", "Defines a 64 bit processor architecture. This will take effect on the platform descriptor when using MS .NET tools.", "X64") [static]

ContentFile wx.Build.Net.CSharpAssemblyProject.AssemblyFile [get]

Returns the descriptor of the assembly file that will be created. This will also take feature "SN" StrongNameFeature into account.

IFileProducts wx.Build.Net.CSharpAssemblyProject.CSharpSources [get, set]

CSharp sources of the project (content type ContentType.CSharpCode). This will raise a System .Argument exception if the content type of assigned sources is unexpected.

override string wx.Build.Net.CSharpAssemblyProject.Description [get]

A descriptive text on the project. This will be used whenever the system explains the purpose of the project to the user. This is read-only.

Reimplemented from wx.Build.BuildProject.

ICollection<ResourceDesignator> wx.Build.Net.CSharpAssemblyProject.ExternalResources [get, set]

Assign file products to this member (that is null by defaults) to declare external resources. These resources will not be linked into the assembly but shall be available side by side to the created DLL or program. The internal name will be interpreted as a relative path that will be used to compute the desired position of the resource relatively to the created program or DLL. This will raise an error if the internal name of the resource can be interpreted as a rooted filename.

override FeatureList wx.Build.BuildProject.Features [get, inherited]

The features of the project.

Reimplemented from wx.Build.BaseAction.

Guid wx.Build.BuildProject.Id [get, inherited]

A unique identifier of the project. This will be used on serialization/deserialization to identify the project. This ID will be set on serialization. Not yet serialized projects will return an empty Guid.

See also:: GetGuild

bool wx.Build.BuildProject.IsSingleton [get, inherited]

This is true iff the project can be built. Run GetSingleton() to make this true.

string wx.Build.Net.CSharpAssemblyProject.MainClass [get, set]

The name of the main class that holds the main program if this project if this creates an executable. Use this to get or set this property.

string wx.Build.BuildProject.Name [get, inherited]

Projects always have a name. This name will be used in dialogs or menus to explain available targets.

string wx.Build.BuildProject.NameAsSymbol [get, inherited]

This is the Name but only consisting of letters, digits, and the underscore. Blancs will be replaced by underscores.

virtual ICollection<Type> wx.Build.BaseAction.ParameterTypes [get, inherited]

Returns a collection (typically an array) of relevant parameter types in the BuildConfig. This may be empty or null if instances of this class do not refer to parameter types. The return value of this implementation is null .

Reimplemented in wx.Build.Mono.Gmcs, wx.Build.MS.Cl, wx.Build.MS.Csc, and wx.Build.Cxx.wxWidgets.

IFileProducts wx.Build.Net.CSharpAssemblyProject.PInvokeDependencies [get, set]

Assign those projects producing files that have to be built before this here. This property declares dependencies to projects producing native DLLs that are referenced e.g. by the P-Invoke interface.

Only assign file products concerning ContentFileProperties.NativeDLL to this property.

ProjectPreference wx.Build.BuildProject.Preference [get, inherited]

Returns the preference of this project. This controls whether the targets of this project will be achieved or not. Some projects will be accomplished only on user input. Some project may be hidden to the end user since they will be achieved only during the build process if reuiqred by other projects or actions.

BuildProject wx.Build.BaseAction.Project [get, set, inherited]

The project that requested this action.

IFileProducts wx.Build.Net.CSharpAssemblyProject.ReferencesAssemblies [get, set]

CSharp sources of the project (content type ContentType.DotNetDll). This will raise a System .Argument exception if the content type of assigned sources is unexpected.

ICollection<ResourceDesignator> wx.Build.Net.CSharpAssemblyProject.Resources [get, set]

Resources will be linked into the assembly.

ISingleFileProduct wx.Build.Net.CSharpAssemblyProject.Signature [get, set]

Gets or defines the signature to be used to sign the assembly after building. The file must contain type "application/sn-keys" ContentType.SnKeys. This may be null if this does not create a signed assembly. If set, this will turn the content type of the target from ContentType.DotNetDll to ContentType.SnDll, or from ContentType.DotNetExe to ContentType.SnExe, respectively.

ContentType wx.Build.Net.CSharpAssemblyProject.Type [get, set]

Use this to get or set the type of the assembly to be built. This will return or accept one of the content types mentioned below. Setting another type will result into an argument exception.

virtual IDictionary<string, EnvironmentVarInfo> wx.Build.BaseAction.UsedVars [get, inherited]

This returns null since useually shell variables are not used by actions.

Reimplemented in wx.Build.Cxx.GCC.GccAsCompiler, wx.Build.Cxx.GCC.WindRes, wx.Build.MS.Cl, wx.Build.MS.Link, wx.Build.MS.RC, wx.Build.Release.MakeReleaseProject, wx.Build.Release.ReplaceVersionInRCFile, wx.Build.Release.ReplaceVersionInCSharpFile, and wx.Build.Cxx.wxWidgets.

DateTime wx.Build.BuildProject.ValidityOfDefiningAssemblies [get, inherited]

Validity of the assemblies defining the project and implementing execution. The assemblies defining the project and implementing tools and projects are standard prerequisites of the target. Whenever we change one of these assemblies, we want all targets to be rebuilt. This property returns a timestamp representing the validity of these prerequisites.

DateTime wx.Build.BuildProject.ValidityOfExecutingAssembly [static, get, inherited]

The validity (timestamp) of the assembly file containing this code (if this exists).

IFileProducts wx.Build.Net.CSharpAssemblyProject.WinIcon [get, set]


Public Member Functions
delegate void	AdderSerializable (System.Xml.Serialization.IXmlSerializable arg)
void	AddExternalResources (ICollection< ResourceDesignator > resources)
virtual bool	AdoptConfig (BuildConfig config)
virtual void	AppendBooCode (List< string > booCodeLines, string indention, BuildToolFamilyEnv env)
virtual void	AppendToBooPreamble (BuildToolFamilyEnv env, List< string > importModules, List< string > booDeclarations, List< string > booDefinitions)
bool	AreAllMandatoryVarsDefined ()
override object	Clone ()
void	CollectChoicePoints (IDictionary< string, ICollection< string >> collectionOfChoicePoints)
virtual int	CompareTo (object obj)
override bool	ContainsPrerequisite (IBuildProduct prereq)
override ICollection < IBuildAction >	CreateActionPlan (BuildToolFamilyEnv env)
override RefToProject	CreateRef ()
override RefToFileProject	CreateRefToFileProject ()
RefToSingleFileProject	CreateRefToSingleFileProject ()
	CSharpAssemblyProject (ProjectPreference preference, string name, ContentFile assemblyFileToBeBuilt, string description)
	CSharpAssemblyProject (ProjectPreference preference, string name, string assemblyFileToBeBuilt, string description)
	CSharpAssemblyProject (CSharpAssemblyProject src)
	CSharpAssemblyProject ()
override bool	Equals (object obj)
Guid	GetGuid ()
override int	GetHashCode ()
override ICollection < IBuildProduct >	GetPrerequisites ()
virtual System.Diagnostics.ProcessStartInfo	GetProgramStartInfo (BuildToolFamilyEnv env)
System.Xml.Schema.XmlSchema	GetSchema ()
new CSharpAssemblyProject	GetSingleton ()
override ICollection < IBuildProduct >	GetTargets ()
override DateTime	GetValidity ()
override DateTime	GetValidityDemand ()
DateTime	GetValidityTargets ()
virtual void	NormalizeOriginalFileName (string nameOfAValidDirOrFile)
override void	ReadXml (System.Xml.XmlReader reader)
virtual bool	TargetsAreConsistent (DateTime validityOfBuildSystem)
override string	ToString ()
void	WriteRefXml (System.Xml.XmlWriter writer)
override void	WriteXml (System.Xml.XmlWriter writer)
Static Public Member Functions
static ICollection < BuildProject >	AddIncludedProjects (IDictionary< BuildProject, BuildProject > result, ICollection< IBuildProduct > listOfBuildProducts)
static void	AddKnownProject (BuildProject p)
static int	Build (ErrorHandler handler, System.Reflection.Assembly projectSrc, string[] programOpts)
static int	Build (ErrorHandler handler, string[] programOpts)
static int	Build (string[] programOpts)
static void	ClearKnownProjects ()
static ICollection < BuildProject >	GetAllProjectsDeclaredInAssembly (System.Reflection.Assembly assembly, ICollection< ErrorObject > errors)
static BuildProject	GetKnownProject (Guid id)
static ICollection < BuildProject >	GetKnownProjects ()
static ICollection < EnvironmentVarInfo >	GetUsedVariables (System.Reflection.Assembly projectSrc)
static BuildProject	LoadRefFrom (System.Xml.XmlReader reader)
static implicit	operator FileProject (RefToFileProject refToProject)
static implicit	operator SingleFileProject (RefToSingleFileProject refToProject)
static bool	ReadCollection (System.Xml.XmlReader reader, AdderSerializable collectorForResults, string outerElementName, string innerElementName)
static System.Xml.Serialization.IXmlSerializable	ReadSerializable (System.Xml.XmlReader reader, string elementName)
static IList < BuildProject >	ScheduleProjects (ICollection< BuildProject > projects)
static string	StringAsSymbol (string aName)
static void	WriteCollectionOfSerializables (System.Xml.XmlWriter writer, System.Collections.IEnumerable serializables, string outerElementName, string innerElementName)
static void	WriteSerializable (System.Xml.XmlWriter writer, System.Xml.Serialization.IXmlSerializable obj, string elementName)
Static Public Attributes
Predefined Festures
static readonly FeatureEntry	PlatformX32 = new FeatureEntry("Platform 32 bit", "Defines a 32 bit processor architecture. This will take effect on the platform descriptor when using MS .NET tools.", "X32")
static readonly FeatureEntry	PlatformX64 = new FeatureEntry("Platform 64 bit", "Defines a 64 bit processor architecture. This will take effect on the platform descriptor when using MS .NET tools.", "X64")
Protected Member Functions
void	ReadProject (System.Xml.XmlReader reader)
void	ReadStdAttributes (System.Xml.XmlReader reader)
void	SetAsKnownProject (Guid oldGuid)
void	WriteProject (System.Xml.XmlWriter writer)
void	WriteStdAttributes (System.Xml.XmlWriter writer)
Static Protected Member Functions
static Guid	RegisterProjectTargets (BuildProject p)
Properties
ContentFile	AssemblyFile `[get]`
IFileProducts	CSharpSources `[get, set]`
override string	Description `[get]`
ICollection < ResourceDesignator >	ExternalResources `[get, set]`
override FeatureList	Features `[get]`
Guid	Id `[get]`
bool	IsSingleton `[get]`
string	MainClass `[get, set]`
string	Name `[get]`
string	NameAsSymbol `[get]`
virtual ICollection < Type >	ParameterTypes `[get]`
IFileProducts	PInvokeDependencies `[get, set]`
ProjectPreference	Preference `[get]`
BuildProject	Project `[get, set]`
IFileProducts	ReferencesAssemblies `[get, set]`
ICollection < ResourceDesignator >	Resources `[get, set]`
ISingleFileProduct	Signature `[get, set]`
ContentType	Type `[get, set]`
virtual IDictionary < string, EnvironmentVarInfo >	UsedVars `[get]`
DateTime	ValidityOfDefiningAssemblies `[get]`
static DateTime	ValidityOfExecutingAssembly `[get]`
IFileProducts	WinIcon `[get, set]`

wx.Build.Net.CSharpAssemblyProject Class Reference

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Static Protected Member Functions

Properties

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

Property Documentation