Microsoft.VisualStudio.TextTemplating.15.0

Class to manage an assembly and when it was last referenced.

The assembly for the record

Date the assembly was last referenced

Class to manage a cache of compiled assemblies in the execution AppDomain.

Set of cached assemblies

Last time cache was used.

Find an assembly containing the code of the given class in the cache

An assembly containing the code of the given class or null

Class to monitor the state of the assembly cache

Returns how many assemblies the cache thinks are stale

Class to resolve assembly references in the T4 execution AppDomain

This is modeled as a separate class purely because the event seems to need its implemented class to be marked Serializable.

Resolve assembly references in the T4 execution app domain

Create a new for the given .

Language of the To be compiled Include debugging symbols and output Any specified assembly references (must be resolved to full paths). Any extra command line arguments to pass to the compilers

Create a new language specific .

Should not concern itself with references, syntax tree or compilation options as these will be set by the caller.

Create a language specific from the given source.

Compile a new Compilation using this .

Simple run host to be used when not debugging. The use of it allows both debug and non debug runs to share the same code.

The engine host

We store the host to request an AppDomain later

Create an instance of TransformationRunner in the transformDomain

Helper class with extension methods to aide in creating CodeDOM trees.

These extension methods allow a much terser and more expression-like syntax for constructing CodeDOM trees.

Simple static for the null expression

Call a static method as an expression

Call a static method as a statement

Call a method on an object as an expression

Call a method on an object as a statement

Call a method on this class as an expression

Call a method on this class as a statement

Make a basic method

Create the code for if (a==null) a = new Foo();

Make a variable declaration for a PropertyInfo initialized with a GetProperty call on a target's type. Creates code similar to: PropertyInfo name = target.GetType().GetProperty(propertyName);

Make a variable declaration for an object initialized via a call to PropertyInfo.GetValue via a given instance Creates code similar to: object name = propertyInfo.GetValue(instance, null|new object[] {parameters});

Class to compare a pair of CodeAttributeDeclarations

Class to compare a pair of CodeAttributeArguments using their string representations

Class to monitor the state of shadow copied assemblies for use by hosts

Are any of the shadow-copied assemblies obsolete with respect to their on-disk files.

Whether any assemblies are obsolete

Helper class to manage a record of the last write dates of reference assemblies that are shadow-copied in the templating appdomain.

Set of shadow-copying times by assembly's full location

Typically unlikely that the dictionary will be accessed on multiple threads so use concurrency level of one.

Record the modification time of an assembly to be shadow-copied

Are any of the shadow-copied assemblies obsolete with respect to their on-disk files.

Whether any assemblies are obsolete

Base class for a concrete DirectiveProcessor

A singleton instance of any of these classes that is required will be held by the Engine. This class implements a state machine with the Get... methods only valid after a Start...Finish pair.

Error collection for DirectiveProcessor to add Errors/Warnings to.

Initialize the processor instance

Does this DirectiveProcessor support the given directive

This call is not connected to the state machine

Begin a round of directive processing

the contents of the template being processed\ collection to report processing errors in

Process a directive from a template file

Finish a round of directive processing

Get the code to contribute to the generated template processing class as a consequence of the most recent run.

The code that this DirectiveProcessor contributes to the generated TextTemplating class

Get the code to contribute to the body of the initialize method of the generated template processing class as a consequence of the most recent run. This code will run before the base class' Initialize method

Get the code to contribute to the body of the initialize method of the generated template processing class as a consequence of the most recent run. This code will run after the base class' Initialize method

Get any references to pass to the compiler as a consequence of the most recent run.

Get any namespaces to import as a consequence of the most recent run.

Get any custom attributes to place on the template class.

A collection of custom attributes that can be null or empty. The default implementation is to produce no attributes.

Exception class for Directive Processors

Constructor.

Exception message text.

Constructor.

Exception message text. Inner exception.

Serialization constructor.

(Optional) interface that DirectiveProcessors can implement if they care about the value of the HostSpecific flag when they are generating code. Will be called immediately after Initialize

Inform the directive processor whether the run is host-specific.

Will be called after RequiresProcessingRunIsHostSpecific has been run on all directive processors to inform the processor what the final host-specifc decision is

Allow a directive processor to specify that it needs the run to be host-specific.

If any directive processor in the run sets this to be true then the engine will make the entire run host-specific.

Helper class to get the encoding of a file from its BOM

Helper method to get the encoding of a file from its BOM

Text templating engine

Hashing algorithm to create cache keys for fingerprints of templates.

CacheAssemblies option string

Processes a template

The contents of the template file to be processed The ITextTemplatingEngineHost that will host this engine The output from the processed template

Process the contents of a templated file running inline code to produce a class that represents the template.

The content of the templated file The hosting environment using this engine The name of the class to produce The namespace of the class to produce The language that the template's control code was written in The set of references required by the template

Do the main processing of the template that is shared between preprocessing and regular processing

Set up the given session with data gleaned from callback to the host.

Prepare an IDebugTransformationRun object to run the template.

The content of the templated file The hosting environment using this engine The hosting environment for the transformation run

Parse the template code and construct the generator code from it

Utility function for logging an error

Processes the directives in the template

The blocks that the template was parsed into host TemplateProcessingSession to store data for this session Collection of attributes to decorate the template class with.

Add an override to the Initialize method to contribute preInit or postInit code

Provide an attribute specifying whether optional methods from the base class should be overridden or virtual

Special visited set to encapsulate the recording of file inclusions for the "once" feature of the include directive

Record a "visit" to an include file. Return whether the file has already been visited

Absolute path to the include file in canonical form true if previously visited, or false if first visit

Process all directives handled by either extension directive processors or non built-in directives that ship with the engine.

The difference between built-in directives and custom but shipped directives is that true built-in directives are allowed to mess with the processing logic. Custom shipped directives have the same restrictions as end-user extension directives. This is subtle but helps with keeping testing down as we know when they fire in the cycle. The difference should not be apparent to end users however.

Get the type for any directive that is implemented in this assembly.

Amend the directive object to have an appropriate processor name.

Says whether a given directive is built-in (handled by the engine) or should be handled by a custom directive processor

Process an include directive by asking the host to read the included file, and parsing the contents into blocks.

Process the assembly directive by adding the assembly reference to the list of assembly references maintained by the TemplateProcessingSession

Process an import directive by adding the namespace to the list of namespaces maintained by the TemplateProcessingSession

Process the template directive

Process the output directive to get the extension of the output file

Constructs code for the generated transformation class using the CodeDomProvider for the template language.

Set the visibility of the type to public or internal

The session to take the public/internal data from The type to amend

Construct the TransformText method

Add a comment to the class in the standard format to specify that it is autogenerated.

Add a generated code marker attribute to the given class declaration

Set up the base class for the template

Create a new namespace name to ensure the generated class has a unique identity

Create a snippet member for a given block

Calculate the reference property or static class that embodies the ToStringHelper

Construct CodeDom statements for the TransformText method override on the generated transformation class

Compiles the transformation code and prepares in for running in the runFactory

Allow the host to process all assembly references in the session

Get the type of the session and any types within it's dictionary that are not in standard assemblies

Is the given type a type whose assembly will already be loaded into the transformation AppDomain?

Add a typemember code snippet to a type with the correct line pragma decorating it.

Add a statement code snippet to a list of statements with the correct line pragma decorating it.

Whether or not the template is host-specific

A strongly-typed resource class, for looking up localized strings, etc.

Returns the cached ResourceManager instance used by this class.

Overrides the current thread's CurrentUICulture property for all resource lookups using this strongly typed resource class.

Looks up a localized string similar to There was a problem loading the assembly '{0}'.

Looks up a localized string similar to This code was generated by a tool..

Looks up a localized string similar to Runtime Version: {0}.

Looks up a localized string similar to Changes to this file may cause incorrect behavior and will be lost if.

Looks up a localized string similar to the code is regenerated..

Looks up a localized string similar to Failed to load base class '{0}' from which Transformation class inherits..

Looks up a localized string similar to Loading the include file '{0}' returned a null or empty string. The transformation will not be run. .

Looks up a localized string similar to There was a problem creating and initializing the processor for a directive named '{1}'. The type of the processor is {0}. The transformation will not be run. .

Looks up a localized string similar to Unable to resolve a value for the requires parameter '{0}' for directive '{1}'..

Looks up a localized string similar to Compiling transformation: .

Looks up a localized string similar to An exception was thrown while trying to compile the transformation code..

Looks up a localized string similar to The {0} 2.0 and {0} 3.5 compilers are no longer supported. Templates will always be compiled with the version 4 compiler instead of '{1}' as specified..

Looks up a localized string similar to '{0}' directive did not provide required argument '{1}'..

Looks up a localized string similar to The directive '{0}' is not supported..

Looks up a localized string similar to The parameter '{0}' already exists in the directive. The duplicate parameter will be ignored..

Looks up a localized string similar to Encoding.GetEncoding(int) failed for '{0}'..

Looks up a localized string similar to Encoding.GetEncoding(string) failed for '{0}'..

Looks up a localized string similar to There was an error generating the transformation class. The process cannot continue. .

Looks up a localized string similar to Errors were generated when initializing the transformation object. The transformation will not be run. .

Looks up a localized string similar to There was an error loading the include file '{0}'. The transformation will not be run..

Looks up a localized string similar to ErrorGeneratingOutput.

Looks up a localized string similar to The following Exception was thrown: {0}.

Looks up a localized string similar to An Exception was thrown while trying to get the output from the processor named '{0}'. The transformation will not be run..

Looks up a localized string similar to An Exception was thrown while trying to get the namespace imports and assembly references for processing the run from a directive processor named '{0}'. The transformation will not be run..

Looks up a localized string similar to An exception was thrown by the host when trying to get the StandardImports and StandardAssemblyReferences. The transformation will not be run..

Looks up a localized string similar to Could not instantiate a TextTransformation object from the compiled assembly..

Looks up a localized string similar to An Exception was thrown while processing a directive named '{0}'. The transformation will not be run. .

Looks up a localized string similar to An Exception was thrown while processing the template. .

Looks up a localized string similar to The host threw an exception while trying to resolve the assembly reference '{0}'. The transformation will not be run..

Looks up a localized string similar to An exception was thrown while running the TransformText() method. .

Looks up a localized string similar to An exception was thrown by the host while trying to set the extension..

Looks up a localized string similar to An exception was thrown while trying to set the 'Host' property on the {0}. .

Looks up a localized string similar to An exception was thrown while trying to set the 'Session' property on the {0}. .

Looks up a localized string similar to An Exception was thrown while running the transformation code. The process cannot continue. .

Looks up a localized string similar to An expression block evaluated as Null.

Looks up a localized string similar to The file {0} was not found whilst processing a directive named '{1}'. .

Looks up a localized string similar to Class code can only be retrieved after FinishProcessingRun() is called.

Looks up a localized string similar to Imports can only be retrieved after FinishProcessingRun() is called.

Looks up a localized string similar to References can only be retrieved after FinishProcessingRun() is called.

Looks up a localized string similar to A 'Host' property was not found despite the template directive setting hostspecific='truefrombase'. Check that the base class '{0}' has a 'Host' property..

Looks up a localized string similar to The type '{0}' of the directive processor named '{1}' does not implement Microsoft.VisualStudio.TextTemplating.IDirectiveProcessor. The transformation will not be run..

Looks up a localized string similar to An invalid base class was specified for the Transformation class. The base class must implement the same members as Microsoft.VisualStudio.TextTemplating.TextTransformation..

Looks up a localized string similar to The compiler option is invalid: '{0}'..

Looks up a localized string similar to An invalid culture was specified in the 'template' directive. The culture must be in the "xx-XX" format. The invariant culture will be used..

Looks up a localized string similar to An invalid debug value '{0}' was specified in the template directive. The debug value must be either "true" or "false". The default of "false" will be used..

Looks up a localized string similar to Directive arguments should be of form 'name=value': {0}..

Looks up a localized string similar to An invalid HostSpecific value '{0}' was specified in the template directive. The HostSpecific value must be either "true", "false" or "truefrombase". The default of "false" will be used..

Looks up a localized string similar to An invalid language '{0}' was specified in the 'template' directive. The language must be either "C#" or "VB". The default value of "C#" will be used..

Looks up a localized string similar to An invalid linePragmas value '{0}' was specified in the template directive. The value must be either "true" or "false". The default of "true" will be used..

Looks up a localized string similar to A neutral culture was specified in the 'template' directive. A specific culture must be provided. The invariant culture will be used..

Looks up a localized string similar to An invalid visibility '{0}' was specified in the 'template' directive. The visibility must be either 'internal' or 'public'. The default value of 'public' will be used..

Looks up a localized string similar to A template that specifies hostspecific='truefrombase' must also specify a base template with the 'inherits' parameter to the template directive..

Looks up a localized string similar to Multiple output directives were found in the template. All but the first one will be ignored..

Looks up a localized string similar to Multiple template directives were found in the template. All but the first one will be ignored. Multiple parameters to the template directive should be specified within one template directive..

Looks up a localized string similar to There was a problem getting an AppDomain to run the transformation from the host. The process cannot continue. .

Looks up a localized string similar to No processor was specified for a directive named '{0}'. The transformation will not be run..

Looks up a localized string similar to A processor named '{0}' could not be found for the directive named '{1}'. The transformation will not be run. .

Looks up a localized string similar to A required parameter '{0}' for the directive '{1}' was not found. The directive will be ignored. .

Looks up a localized string similar to The type '{1}' of the parameter '{0}' did not match the type of the data passed to the template..

Looks up a localized string similar to ProcessDirective() was called before StartProcessingRun(). Directive processing can only start after StartProcessingRun() is called. .

Looks up a localized string similar to The processor named '{0}' does not support the directive named '{1}'. The transformation will not be run..

Looks up a localized string similar to The include directive for file '{0}' causes an infinite loop. The directive will not be processed..

Looks up a localized string similar to Marshaling Session or Host object to secondary AppDomain failed. Check that Host and all types in Session dictionary are Serializable or derive from MarshalByReferenceObject..

Looks up a localized string similar to The host threw an exception from SetOutputEncoding()..

Looks up a localized string similar to StartProcessingRun() was called after directive processing was already started..

Looks up a localized string similar to Running transformation: .

Looks up a localized string similar to An unexpected start or end tag was found within a block. Make sure that you did not mis-type a start or end tag, and that you do not have any nested blocks in the template..

Looks up a localized string similar to Attempt to specify unsupported {1} value '{0}' for directive {2}.

Looks up a localized string similar to A {0} cannot appear after the first class feature in the template. Only boilerplate, expressions and other class features are allowed after the first class feature block..

Looks up a localized string similar to A directive was specified in the wrong format. The transformation will not be run. Please specify the directive in the format <#@ name [parameterName="parameterValue"]* #>.

Looks up a localized string similar to A template containing a class feature must end with a class feature..

Directive processor to route simple serializable parameters from callers or the host to the template.

Name of the directive provided by this processor ("parameter").

The friendly name of this processor ("ParameterDirectiveProcessor").

Whether the current processing run is host-specific

Provider for the template's language

Buffer that collates all of the code that instances of this directive processor need to run after base class initialization during a processing run

Buffer that collates all of the code that instances of this directive processor contribute during a processing run

Nothing to do as we complete our run.

Gets generated class code.

Denote which properties are supported.

Only the "parameter" directive is supported.

Create the code for the Initialize method after its call to base.Initialize

Create the code added as members to the transform class.

Starts processing run.

Target language provider. The contents of the template being processed collection to report processing errors in

Accept the host-specific value of the current processing run from the engine

This processor does not require a host-specific template.

Base class for a directive processor that follows the requires, provides pattern.

Buffer that collates all of the code that instances of this directive processor contribute during a processing run

Buffer that collates all of the code that instances of this directive processor need to run before base class initialization during a processing run

Buffer that collates all of the code that instances of this directive processor need to run after base class initialization during a processing run

Gets associated text templating host.

Initializes the processors.

Starts processing run.

Target language provider. The contents of the template being processed colelction to report processing errors in

Provide a token to uniquely identify this instance of a directive processor

By default, allow an ID parameter to be used on the directive. Frequently, directive processors would choose to use one of their Provides parameters A unique id for this directive instance

Processes a single directive.

Directive name. Directive arguments.

Finishes template processing.

Gets generated class code.

Gets list of importt.

Gets list of references.

The friendly name of this processor

Method for derived classes to make any modifications to the dictionaries that they require

Method for derived classes to generate the code they wish to add to the TextTransformation generated class.

Method for derived classes to contribute additively to initialization code for the TextTransformation generated class.

Additive code is useful where there are multiple directive processor instances each needing to have some instance-specific initialization. As GenerateTransformCode can add methods, matching initialization code is often required to call those methods. This code will be added before the call to the base class.

Method for derived classes to contribute additively to initialization code for the TextTransformation generated class.

Method for derived classes to specify the requires arguments they need for each directive by putting "" in the matching dictionary slot.

Method for derived classes to specify the provides parameters they will supply for each directive by putting the default name in the matching dictionary slot.

Process an argument string consisting of parameter name value pairs formatted as below: name[=[']value[']][;name[=[']value[']]]

Return the id of the directive if it has one

the id or string.Empty

Parse a standardized argument string into a dictionary of argument name, value pairs

Values are optional, pairs are semicolon separated

Parse a template file into blocks. Each block is of type boilerplate, directive, statement, classfeature or expression. Also puts position information (line/column number) for the block into each block.

Template content. Error collection to report errors to. Name of template file.

Check to make sure that the blocks are in correct sequence i.e. * no statements after the first classfeature block, and * if the template contains a class block then it ends with a class block. If not, log errors.

Parse a directive block for the directive name and param-value pairs

Validates a directive string and makes sure it is in the right format

Whether the directive block is valid

Insert position information (line and column number) into a block

Remove unwanted newlines from the blocks. Also removes any boilerplate blocks that are empty (or that contained only new lines)

Adds warnings to the error collection if unexpected unescaped start/end tags are found within the template

A MatchEvaluator for replacing escape characters.

Strips escape characters from the block text.

Strips escape characters before " in the directive strings

Represents the type of each block in the template file

Represents a block in the template file

The type of the block

The text contained within the block, not including the opening and closing tags

The line number on which the block text starts

The column number on which the block text starts

The line number on which the block text ends

The column number on which the block text ends

The file name that this block comes from (in the case that it comes from an included file). Empty string if the block doesn't come from an include file.

Constructor

Represents a directive in the template file

The name of the directive

Parameter-Value pairs for the directive

The directive block that this directive came from

The name of the processor for this directive if it is a custom one

Make the setter for this property very explicit as it is not a normal operation.

Constructor

Class to carry the data associated with generation from one templated file

Note - this is not the same as the ITextTransformationSession which represents an end user's batched session of multiple transforms. The lifetime of this class is one call to ProcessTemplate or PreprocessTemplate.

Whether this session is for precompilation or regular transformation

List of full names of assemblies that need to be referenced when compiling/running the transformation code

List of namespaces to be imported in the transformation code

The full name of the class that will be created to do the generation

The base class for the generated transformation class

The language that the template is written in. Defaults to CSharp

Options set for the language of the template.

These options are passed directly to the CodeDOM provider

The CodeDomProvider used to build up the CodeDom tree of the code for the transformation class. This is constructed based on the Language property.

Whether the transformation code is compiled in debug-mode.

Whether the template is host-specific or not.

If it is host-specific, then a 'Host' property will be generated in the transformation code. If it is TrueFromBase then the 'Host' property will be assumed to be defined in the base class.

Is the templete host speciifc either directly or from its base class.

Whether or not we have already processed an output directive for this template file

Whether or not we have already processed a template directive for this template file

The FormatProvider to be used to convert expressions to strings. This is a CultureInfo object constructed from the culture specified in the template directive

The stack of files included

The contents of the template being processed

The path of the outermost template being processed

May be null for non file-based hosts.

Whether to cache assemblies for this session.

Options to send to the compiler for the template control block code

Client-provided session object to flow through to the runtime AppDomain.

Whether the generated class is public or internal.

Whether the generated class contains line pragmas to redirect errors and the debugger to the template.

The languages that are supported in the template file

Base class for generated text transformations

Any class specified in an inherits directive must match this class in a duck-typing style. Note that this class therefore specifies an implicit contract with the transformation object. The object doesn't have to derive from any specific type or interface, but it must have a) A void Initialize() method. b) A string TransformText() method c) An Errors property that's duck-compatible with CompilerErrorCollection d) A GeneratonEnvironment property that's duck-compatible with StringBuilder. e) A void Write(string) method Using any further features of T4 such as expression blocks will require the class to have further methods, such as ToStringHelper, but those will produce regular compiler errors at transform time that the base class author can address. These few methods together form a subset of the TextTransformation default base class' API. If you change this pseudo-contract to add more requirements, you should consider this a breaking change. It's OK, however, to change the contract to have fewer requirements.

The string builder that generation-time code is using to assemble generated output

The error collection for the generation process

A list of the lengths of each indent that was added with PushIndent

Gets the current indent we use when adding lines to the output

Current transformation session

Generate the output text of the transformation

Initialize the templating class

Derived classes are allowed to return errors from initialization

Finaizlier.

Disposes the state of this object.

Dispose implementation.

Write text directly into the generated output

Write formatted text directly into the generated output

Raise an error

Raise a warning

Increase the indent

indent string

Remove the last indent that was added with PushIndent

The removed indent string

Remove any indentation

Get a set of CodeDOM members that match the real members on this class

If you add a member to this class, consider adding it to the list returned by this method.

Trivial implementation of text transformation session interface

Basic constructor that creates a unique Id.

Constructor to allow a specific Id to be used

Potential use for other serialization schemes

The identity of the session

Serialization constructor

Serialize the object

Utility class to produce culture-oriented representation of an object as a string.

Gets or sets format provider to be used by ToStringWithCulture method.

This is called from the compile/run appdomain to convert objects within an expression block to a string

The object to convert to a string The object converted to a string using the template's culture

Get a set of CodeDOM members that provides the same functionality as this class as a property exposing a nested class.

The default value of the format provider to use

Provide a nested class to handle converting to string in a culture-sensitive manner

Class that is instantiated in the secondary app-domain and is responsible for compiling and running the transformation code. It has to be a MarshalByRefObject

Set of paths that are shadow copied for this appdomain.

Marker object to allow sync on the shadowCopyPaths set.

The session we're currently in.

The compiled template.

The host.

A collection of the errors that are raised

This allows our object to live forever without it dying after 5 minutes of inactivity. Since it's contained in a temporary AppDomain, this shouldn't cause any issues.

Utility method for logging an error/warning

Since the errors collection is not marshalled by reference, we need to provide a method for the engine to call to clear them after it has reported preparation errors to the host.

Cached expression built from resources from the environment assembly.

Cache a resource from the manager or cache the fallback string if there's a problem.

Utility method for parsing a line number from an exception stacktrace

This code is fragile at runtime to changes in StackTrace formatting from mscorlib, but falls back gracefully, so we can tolerate the coupling.

Load the set of assemblies that we will need into the AppDomain

This is the method called from the other AppDomain to compile and prepare the transformation code for running

Note that this method uses an implicit contract with the transformation object. See the DocComment on TextTransformation for details before changing the dynamic calls from this method. True if the transformation run has been properly prepared.

This is the method called from the other AppDomain to run the transformation

Find or compile an assembly with the correct code for the given source

Ensures that the given paths are being shadow copied.

Instantiates an object of the generated transformation class from the compiled assembly.

Get the named property as close to the most-derived class as possible.

Compiles the source into an assembly using the given CodeDomProvider and the assembly references

Try to load an assembly by path

null if no assembly found