Project Class

Create a new Project with the specified file name and parent Solution.

Create a Project by parsing it from a standard VS project file.

This property is just to make debugging easier.

Annotations (comments, attributes, directives, messages) associated with the current code object.

The MonoCecilAssemblyResolver for this project.

The relative base intermediate output path of the project (such as "obj\").

The descriptive category of the code object.

All of CodeUnits in the Project.

The column number associated with the CodeObject (if any, 0 if none).

The comment for the code object (if any).

The name of the current ProjectConfiguration.

The platform of the current ProjectConfiguration.

All of the ProjectConfigurations for the Project.

The currently active ProjectConfiguration.

The currently active platform-specific ProjectConfiguration (if any).

The defined constants for this project as a delimited string.

The documentation comment for the code object (if any).

The End-Of-Line comment for the code object (if any).

The encoding of the file (normally UTF8).

True if the associated file exists.

True if the file has a UTF8 byte-order-mark.

All of ProjectFileItems in the Project.

The associated file name of the Project.

Always false for a Project. Can't be set.

The FrameworkContext for this project, which controls all loaded assemblies.

All project (assembly) level attributes defined in any code unit (such as AssemblyInfo.cs).

The global namespace for the project.

True if the code object has any annotations.

True if the code object has any attributes.

True if the code object has any comments of any kind.

True if the code object has any compiler directive annotations.

True if the code object has any documentation comments.

True if the code object has any EOL comments.

True if the code object has any EOL or Postfix annotations.

True if the code object has any error messages.

True if the code object has any annotations on separate lines.

True if the code object has any Infix comments.

True if the code object has any generated messages.

Determines if the code object has no indentation.

True if the code object has any regular (non-doc) preceding (non-EOL, non-Infix, non-Postfix) comments.

True if the code object has any postfix annotations.

Determines if the code object has a terminator character.

Any hidden reference to another CodeObject.

The infix comment for the code object (if any).

The relative intermediate output path of the project (such as "obj\Debug\").

Determines if the code object appears as the first item on a line.

True if the code object defaults to starting on a new line.

Determines if the code object is generated.

Determines if the 'grouping' (has parens or braces) status has been set.

True if the Project is newly created and hasn't been saved yet.

Determines if the newline count has been set on the code object.

True if the project is configured to use a portable class library.

Always false.

True if the project is a shared project - meaning it contains source files which are directly imported into one or more other projects via project references.

Determines if the code object only requires a single line for display.

True if the code object only requires a single line for display by default.

True if the project is a 'website' project - meaning a web-based project that has no project file and appears in the solution tree as an 'http:\' URL instead of just a project name.

The line number associated with the CodeObject (if any, 0 if none).

The name of the Project (does not include the file path or extension).

The number of newlines preceding the object (0 to N).

True if the project type is not currently supported.

The output directory of the Project.

The output path of the Project.

The parent CodeObject.

All of the platform-specific ProjectConfigurations for the Project.

The postfix comment for the code object (if any).

The path of the Project.

All of the references for the Project.

The parent Solution.

The path of the Solution file.

The GUID representing the type of the Project.

The ReferencePath from any "*.csproj.user" file.

Accept the specified visitor object for the current code object and it's children.

Accept the specified visitor object for all regular (non-EOL, non-Infix, non-Postfix) annotations (comments, attributes, compiler directives).

Accept the specified visitor object for all specified Infix or Postfix annotations (comments, compiler directives).

Accept the specified visitor object for all EOL comments.

Accept the specified visitor object for all Infix comments.

Accept the specified visitor object for all Infix EOL comments.

Add an assembly reference by name.

Add an assembly reference by name.

Add a CodeUnit to the Project, keeping the CodeUnits collection sorted alphabetically.

Add a new ProjectConfiguration to the Project.

Add default assembly references to a newly created project (System, System.Core, System.Data, System.Data.DataSetExtensions, System.Xml, System.Xml.Linq, Microsoft.CSharp).

Add default configurations to a newly created project (Debug and Release for AnyCPU).

Add an existing file to the project. A corresponding ProjectFileItem is also created.

Add the implicit reference to 'mscorlib'.

Add an implicit reference to System.Core if required.

Add a new platform-specific ProjectConfiguration to the Project.

Add a reference object.

Add the CodeObject to the specified dictionary.

Add a listed annotation to the Project.

Remove a listed annotation from the Project.

Determine if internal types in the specified assembly are visible to the current project.

Determine if internal types in the project are visible to the specified project.

Determine if the specified comment should be associated with the current code object during parsing.

Render the entire code object as a string, using LFs for newlines.

Convert the code object to text with a trailing newline, and using CR/LF pairs for newlines (file format).

Convert the code object to text using the specified flags and format (file or string).

Render all regular (non-EOL, non-Infix, non-Postfix, non-Message) annotations (comments, attributes, compiler directives).

Render all specified Infix or Postfix annotations (comments, compiler directives).

Render all EOL comments.

Render all Infix comments with the specified mask.

Render all Infix EOL comments.

Render all regular annotations on the current object, or the left most binary operator.

Determine the length of the code object if converted to a string using the specified flags.

Attach an Annotation (Comment, DocComment, Attribute, CompilerDirective, or Message) to the CodeObject.

Attach an Annotation to the CodeObject at the specified position.

Create a comment object and attach it to the code object.

Create an EOL comment object and attach it to the code object.

Create a message and attach it to the code object.

Calculate metrics for this code object and its children.

Check for alignment of any EOL comments.

Deep-clone the code object.

Clone a field of a code object, including setting the parent.

Clone a field of a code object, including setting the parent.

Compare one Project to another.

Copy formatting from another code object.

Create the list of child Annotations, or return the existing one.

Create a new CodeUnit for the specified file name, and add it to the Project along with a corresponding ProjectFileItem.

Create a new CodeUnit for a code fragment, and add it to the Project.

Create a reference to the CodeObject.

Default format the code object.

Default format the specified child field code object.

Determine a default of 1 or 2 newlines when adding items to a Block.

Define a compiler directive symbol for the current configuration.

Define a constant.

Dispose the CodeObject.

Determines whether the specified object is equal to the current object.

Evaluate any conditional attribute on the current element.

Evaluate a conditional expression.

Evaluate any $(PropertyName) macros in the input string.

Evaluate the type or namespace associated with the code object.

Allows an object to try to free resources and perform other cleanup operations before it is reclaimed by garbage collection.

Find a namespace or type with the fully-specified name.

Find a CodeUnit by name.

Find any configuration with the specified configuration name and platform name.

Find the Namespace with the fully-specified name.

Find the parent object of the specified type.

Find the parent method (or anonymous method or lambda) of the current code object.

Find the parent method (or anonymous method or lambda) or type of the current code object.

Find any platform-specifc configuration with the specified platform name.

Find a namespace or type in the global namespace with the fully specified name, returning a SymbolicRef to it. To find generic types, specify a tick mark and type argument count, such as "System.Tuple`2".

Find the RootNamespace for the Reference with the specified alias name.

Get an enumerator for all children objects of type T in the CodeObject and in any child CodeObjects (recursively).

Get an enumerator for all TypeDecls declared in the Project (does not include TypeDecls imported from other Projects).

Returns the first attribute expression (Call or ConstructorRef) with the specified name on the CodeObject.

Get the comment that satisfies the specified predicate.

Get a short text description of the CodeObject. This is generally the shortest text representation that uniquely identifies objects, even if they have the same name, for example: type or return type, name, type parameters, parameters.

Get the directory of the Project (handles website directories).

Returns the DocSummary documentation comment, or null if none exists.

Get the full name of the INamedCodeObject, including any namespace name.

Get the full output path of the Project.

Serves as the default hash function.

Get the indent level of this object.

Get the current indent in spaces.

Determine the type of an inferred ('var') type.

Get the Namespace for this CodeObject.

Get the NuGet Packages path.

Get the DLL path for the given package name and version.

Determine the RootNamespace from any '::' prefix on the specified name, defaulting to the global namespace.

Get any Solution folders for this Project.

Get the description of the target framework.

Gets the Type of the current instance.

Get a TypeRef for the type with the specified full name, with caching (generally used for System types).

Get the .NET target framework version for the specified portable profile.

Get the type of the worst attached message.

Returns true if the attribute with the specified name exists on the object, otherwise false.

Returns true if the code object is an UnresolvedRef or has any UnresolvedRef children.

Returns true if the specified child object is indented from the parent.

Returns true if the specified child object is prefixed to the current object.

Determine if a compiler directive symbol is defined for the current configuration.

Determine if the specified constant is defined.

Determine if this project depends on the specified project.

Load the specified Project file and all child code files directly (without a Solution).

Load the specified Project file and all child code files directly (without a Solution).

Load an assembly.

Load an existing file into the project. This method is used primarily during the loading process and does NOT add a corresponding ProjectFileItem. To add a new file to a project along with a FileItem, use CreateCodeUnit(String). To add an existing file to a project along with a FileItem, use AddExistingFile(String, Boolean, ActionLoadStatus, CodeObject).

Load the project assets json file, creating a map of name/version to relative DLL path.

Load all externally referenced assemblies.

Load all referenced assemblies, then load all types from them.

Load all of the (non-nested) types in the specified assembly into the appropriate namespaces under the specified root namespace, hiding any of the specified types.

Load types from all externally referenced assemblies.

Load all of the types in all referenced projects into this one.

Log the specified exception and message and also attach it as an annotation.

Log the specified text message and also attach it as an annotation.

Log the specified exception and message.

Log the specified text message with the specified severity level.

Creates a shallow copy of the current Object.

Move all (regular or EOL) comments from the specified token to the current code object, converting any EOL comments to regular comments (which will be rendered inline if necessary).

Move any annotations from the specified location to the specified destination location.

Move any non-EOL comments from the specified token to the current code object.

Move any non-EOL comments from the specified token to the current code object.

Move any non-EOL comments from the specified token to the current code object as Post comments.

Move any EOL or Postfix annotations from the specified code object to the current code object.

Move any EOL comment from the specified code object to the current code object.

Move any EOL comment from the specified token to the current code object.

Move any EOL comment from the specified token to the current code object.

Move any EOL comment from the specified token to the current code object as an Infix EOL comment.

Move formatting from the specified code object to the current object.

Move formatting from the specified token to the current object.

Move any prefix annotations on the specified code object to the current code object as the specified type of annotation.

Propagate the listed annotation to the parent Solution.

Remove the listed annotation from the parent Solution.

Parse a project from a file.

Parse a project from a file.

Parse and resolve all CodeUnits in the Project.

Parse annotations - specifically, compiler directives around things such as TypeParameters or ParameterDecls.

Parse any comments, attributes, compiler directives.

Parse all CodeUnits in the Project.

Parse the specified expected token, attaching a parse error to the current object if it doesn't exist.

Parse file items.

Parse the specified name into a NamespaceRef or TypeRef, or a Dot or Lookup expression that evaluates to one.

Parse a project file contents (either from a standard VS project file, or from an imported .props or .targets project file).

Parse annotations from the Unused list.

Parse user settings from any ".csproj.user" file.

Parse any 'Web.Config' file for configuration and references.

Parse a web site project.

Remove all annotations of the specified type from this object.

Remove all annotations from this object where the specified predicate is true.

Remove all messages from this object, or optionally only from the specified source.

Remove the attribute expression with the specified name.

Remove the specified CodeUnit from the Project, also removing the corresponding ProjectFileItem.

Remove the CodeObject from the specified dictionary.

Rename the file name of the specified CodeUnit in the Project, also renaming the corresponding ProjectFileItem.

Resolve all child symbolic references.

Resolve all child symbolic references, using the specified ResolveCategory and ResolveFlags.

Resolve any attached attributes.

Resolve all CodeUnits in the Project.

Resolve any references in attached documentation comments.

Resolve child code objects that match the specified name are valid goto targets, moving up the tree until a complete match is found.

Resolve all references.

Resolve child code objects that match the specified name, moving up the tree until a complete match is found.

Similar to ResolveRefUp(String, Resolver), but skips trying to resolve the symbol in the body or parameters of a method (used for resolving parameter types).

Save the Project.

Save the Project plus all CodeUnits.

Save the Project to the specified file name.

Set the current configuration using the specified index.

Set any defined constants from the specified string.

Set a field of a code object, including setting the parent, and optional formatting.

Set a ChildList collection field of a code object, including setting the parent.

Set a field of a code object, including setting the parent, and optional formatting.

Set the line and column numbers to those in the specified CodeObject.

Set the line and column numbers to those in the specified token.

Special method to set the newline count without setting the NewLinesSet flag.

Set the starting line and column numbers to those in the specified token (used by some code objects with prefixes such as modifiers).

Render the type of the code object and its description as a string.

Un-define a compiler direcive symbol for the current configuration.

Un-define a constant.

Unload the project - clear its global namespace and loaded assemblies.

Recursively update the dictionary of names in the specified Block by either adding or removing (as specified by the 2nd parameter) all appropriate nested INamedCodeObjects expressions in the current CodeObject tree (specifically implemented for LocalDeclExpr expression objects).

Update the line and column numbers according to the current positions in the CodeWriter, if the UpdateLineCol flag is set.

Any Annotations (Comments, DocComments, Attributes, or Messages) associated with the CodeObject (null if none).

The MonoCecilAssemblyResolver for this project (only used if using Mono Cecil to load assemblies).

Cached type objects for built-in types.

Cached SymbolicRef objects - used by FindRef() to cache results, usually for System TypeRefs.

All code units in this project.

The starting column number associated with the CodeObject if parsed from or written to text form.

The project configurations.

The currently active project configuration.

The currently active platform-specific configuration (if any).

A cached dictionary of projects which the current one depends on (used for performance).

File items (source files, content files, resource files, etc).

Formatting flags - for line feeds, braces, etc.

The FrameworkContext for this project, which keeps track of all loaded assemblies.

All project-global attributes (those with a target of assembly or module) defined in any CodeUnit (usually AssemblyInfo.cs).

The project's global namespace.

Assembly names which have internal visibility to this project.

Assembly names which have internal visibility to this project for testing purposes only.

The starting line number associated with the CodeObject if parsed from or written to text form.

Assembly/root namespace combinations for which types have already been loaded for this project.

True if the project type is not currently supported.

NuGet references.

The parent CodeObject.

Platform-specific configurations.

References to other projects, assemblies, or COM objects.

Set of file items to be removed (source files, content files, resource files, etc) by filespec.

Unhandled (unparsed or unrecognized) XML data in the project file.

A dictionary of unhandled properties (used to evaluate macros).

The ReferencePath from any "*.csproj.user" file.

Set to disable the use of multithreading for loading, parsing, resolving, etc. This option is available as a possible workaround for any threading-related bugs that might appear in certain scenarios.

Set to load internal types in addition to public types when loading types from referenced assemblies and projects, even when there isn't any InternalsVisibleTo attribute. This allows resolving namespaces and types that would otherwise not be found, allowing code analysis to then flag such references as illegal (not accessible). This option will slow things down a bit and use up more memory.