Microsoft.AspNetCore.Razor

Defines the C# Code Language for Razor

Returns the name of the language: "csharp"

Constructs a new instance of the code parser for this language

Constructs a new instance of the chunk generator for this language with the specified settings

Arguments for the DocumentParseComplete event in RazorEditorParser

Indicates if the tree structure has actually changed since the previous re-parse.

The results of the chunk generation and parsing

The TextChange which triggered the re-parse

Used to manage s encountered during the Razor parsing phase.

Instantiates a new instance of .

s collected.

Tracks the given .

The to track.

Creates and tracks a new .

of the error. A message describing the error. The length of the error.

Represents the results of parsing a Razor document

Instantiates a new instance.

The for the syntax tree. The s that apply to the current Razor document. The used to collect s encountered when parsing the current Razor document.

Instantiates a new instance.

true if parsing was successful, false otherwise. The for the syntax tree. The s that apply to the current Razor document. The used to collect s encountered when parsing the current Razor document.

Indicates if parsing was successful (no errors).

true if parsing was successful, false otherwise.

The root node in the document's syntax tree.

Used to aggregate s.

The list of errors which occurred during parsing.

The s found for the current Razor document.

Text used as a required prefix when matching HTML.

The result of attempting an incremental parse

Either the Accepted or Rejected flag is ALWAYS set. Additionally, Provisional may be set with Accepted and SpanContextChanged may be set with Rejected. Provisional may NOT be set with Rejected and SpanContextChanged may NOT be set with Accepted.

Indicates that the edit could not be accepted and that a reparse is underway.

Indicates that the edit was accepted and has been added to the parse tree

Indicates that the edit was accepted, but that a reparse should be forced when idle time is available since the edit may be misclassified

This generally occurs when a "." is typed in an Implicit Expression, since editors require that this be assigned to Code in order to properly support features like IntelliSense. However, if no further edits occur following the ".", it should be treated as Markup.

Indicates that the edit caused a change in the span's context and that if any statement completions were active prior to starting this partial parse, they should be reinitialized.

Indicates that the edit requires an auto completion to occur

Represents a code language in Razor.

Gets the list of registered languages mapped to file extensions (without a ".")

The name of the language (for use in System.Web.Compilation.BuildProvider.GetDefaultCompilerTypeForLanguage)

Gets the RazorCodeLanguage registered for the specified file extension

The extension, with or without a "." The language registered for that extension

Constructs the code parser. Must return a new instance on EVERY call to ensure thread-safety

Constructs the chunk generator. Must return a new instance on EVERY call to ensure thread-safety

Parser used by editors to avoid reparsing the entire document on each text change.

This parser is designed to allow editors to avoid having to worry about incremental parsing. The method can be called with every change made by a user in an editor and the parser will provide a result indicating if it was able to incrementally apply the change. The general workflow for editors with this parser is: User edits document. Editor builds a structure describing the edit and providing a reference to the updated text buffer. Editor calls passing in that change. Parser determines if the change can be simply applied to an existing parse tree node. If it can, the Parser updates its parse tree and returns . If it cannot, the Parser starts a background parse task and returns . NOTE: Additional flags can be applied to the , see that enum for more details. However, the or flags will ALWAYS be present. A change can only be incrementally parsed if a single, unique, (see ) in the syntax tree can be identified as owning the entire change. For example, if a change overlaps with multiple s, the change cannot be parsed incrementally and a full reparse is necessary. A "owns" a change if the change occurs either a) entirely within it's boundaries or b) it is a pure insertion (see ) at the end of a whose can accept the change (see ). When the returns , it updates immediately. However, the editor is expected to update it's own data structures independently. It can use to do this, as soon as the editor returns from , but it should (ideally) have logic for doing so without needing the new tree. When is returned by , a background parse task has already been started. When that task finishes, the event will be fired containing the new generated code, parse tree and a reference to the original that caused the reparse, to allow the editor to resolve the new tree against any changes made since calling . If a call to occurs while a reparse is already in-progress, the reparse is canceled IMMEDIATELY and is returned without attempting to reparse. This means that if a consumer calls , which returns , then calls it again before is fired, it will only receive one event, for the second change.

Constructs the editor parser. One instance should be used per active editor. This instance can be shared among reparses, but should never be shared between documents.

The which defines the environment in which the generated code will live. should be set if design-time behavior is desired. The physical path to use in line pragmas.

Event fired when a full reparse of the document completes.

Determines if a change will cause a structural change to the document and if not, applies it to the existing tree. If a structural change would occur, automatically starts a reparse.

NOTE: The initial incremental parsing check and actual incremental parsing (if possible) occurs on the caller's thread. However, if a full reparse is needed, this occurs on a background thread. The change to apply to the parse tree. A value indicating the result of the incremental parse.

Disposes of this parser. Should be called when the editor window is closed and the document is unloaded.

Defines the environment in which a Razor template will live

The host defines the following things: * What method names will be used for rendering markup, expressions etc. For example "Write", "WriteLiteral" * The namespace imports to be added to every page generated via this host * The default Base Class to inherit the generated class from * The default Class Name and Namespace for the generated class (can be overridden by parameters in RazorTemplateEngine.GeneratedCode) * The language of the code in a Razor page * The markup, code parsers and chunk generators to use (the system will select defaults, but a Host gets a change to augment them) ** See DecorateNNN methods * Additional code to add to the generated code (see PostProcessGeneratedCode)

Creates a host which uses the specified code language and the HTML markup language

The code language to use

Details about the methods and types that should be used to generate code for Razor constructs

A list of namespaces to import in the generated file

The base-class of the generated class

Indicates if the parser and chunk generator should run in design-time mode

The name of the generated class

The namespace which will contain the generated class

Boolean indicating if helper methods should be instance methods or static methods

The language of the code within the Razor template.

The used to resolve s.

Boolean indicating if instrumentation code should be injected into the output page

Gets or sets whether the design time editor is using tabs or spaces for indentation.

Tab size used by the hosting editor, when indenting with tabs.

Gets or sets the path to use for this document when generating Instrumentation calls

Constructs the markup parser. Must return a new instance on EVERY call to ensure thread-safety

Provides an opportunity for derived types to modify the instance of used by the to parse the Razor tree.

The The file name of the Razor file being parsed. Either the same code parser, after modifications, or a different code parser.

Gets an instance of the code parser and is provided an opportunity to decorate or replace it

The code parser Either the same code parser, after modifications, or a different code parser

Gets an instance of the markup parser and is provided an opportunity to decorate or replace it

The markup parser Either the same markup parser, after modifications, or a different markup parser

Gets an instance of the chunk generator and is provided an opportunity to decorate or replace it

The chunk generator Either the same chunk generator, after modifications, or a different chunk generator

Gets an instance of the code generator and is provided an opportunity to decorate or replace it

The . The . Either the same code generator, after modifications, or a different code generator.

Used only for deserialization.

Gets (or sets) the message describing the error.

Set property is only accessible for deserialization purposes.

Gets (or sets) the start position of the erroneous text.

Set property is only accessible for deserialization purposes.

Gets or sets the length of the erroneous text.

Set property is only accessible for deserialization purposes.

Entry-point to the Razor Template Engine

Constructs a new RazorTemplateEngine with the specified host

The host which defines the environment in which the generated template code will live.

The RazorEngineHost which defines the environment in which the generated template code will live

Parses the template specified by the TextBuffer and returns it's result

IMPORTANT: This does NOT need to be called before GeneratedCode! GenerateCode will automatically parse the document first. The cancel token provided can be used to cancel the parse. However, please note that the parse occurs _synchronously_, on the callers thread. This parameter is provided so that if the caller is in a background thread with a CancellationToken, it can pass it along to the parser. The input text to parse. A token used to cancel the parser. The resulting parse tree.

Parses the template specified by the TextBuffer, generates code for it, and returns the constructed code.

The cancel token provided can be used to cancel the parse. However, please note that the parse occurs _synchronously_, on the callers thread. This parameter is provided so that if the caller is in a background thread with a CancellationToken, it can pass it along to the parser. The className, rootNamespace and sourceFileName parameters are optional and override the default specified by the Host. For example, the WebPageRazorHost in System.Web.WebPages.Razor configures the Class Name, Root Namespace and Source File Name based on the virtual path of the page being compiled. However, the built-in RazorEngineHost class uses constant defaults, so the caller will likely want to change them using these parameters. The input text to parse. A token used to cancel the parser. The name of the generated class, overriding whatever is specified in the Host. The default value (defined in the Host) can be used by providing null for this argument. The namespace in which the generated class will reside, overriding whatever is specified in the Host. The default value (defined in the Host) can be used by providing null for this argument. The file name to use in line pragmas, usually the original Razor file, overriding whatever is specified in the Host. The default value (defined in the Host) can be used by providing null for this argument. The resulting parse tree AND generated code.

Parses the contents specified by the and returns the generated code.

A that represents the contents to be parsed. The name of the generated class. When null, defaults to (Host.DefaultClassName). The namespace in which the generated class will reside. When null, defaults to (Host.DefaultNamespace). The file name to use in line pragmas, usually the original Razor file. A that represents the results of parsing the content. This overload calculates the checksum of the contents of prior to code generation. The checksum is used for producing the #pragma checksum line pragma required for debugging.

A location in a Razor file.

An undefined .

A with , , and initialized to 0.

Initializes a new instance of .

The absolute index. The line index. The character index.

Initializes a new instance of .

The file path. The absolute index. The line index. The character index.

Path of the file.

When null, the parser assumes the location is in the file currently being processed. Set property is only accessible for deserialization purposes.

Gets the 1-based index of the line referred to by this Source Location.

Set property is only accessible for deserialization purposes. Set property is only accessible for deserialization purposes.

Advances the by the length of the .

The to advance. The to advance by. The advanced .

Adds two s.

The left operand. The right operand. A that is the sum of the left and right operands. if the of the left and right operands are different, and neither is null.

Subtracts two s.

The left operand. The right operand. A that is the difference of the left and right operands. if the of the left and right operands are different.

Determines whether the first operand is less than the second operand.

The left operand. The right operand. true if is less than .

Determines whether the first operand is greater than the second operand.

The left operand. The right operand. true if is greater than .

Determines whether the operands are equal.

The left operand. The right operand. true if and are equal.

Determines whether the operands are not equal.

The left operand. The right operand. true if and are not equal.

A used to look up s.

Text used to look up s.

A that represents a pre-allocated tag helper attribute.

The variable holding the pre-allocated attribute.

A used to look up s that should be ignored within the Razor page.

Text used to look up s that should be ignored within the Razor page.

A that represents a special HTML tag.

Instantiates a new .

The tag name associated with the tag helpers HTML element. HTML syntax of the element in the Razor source. The attributes associated with the tag helpers HTML element. The s associated with this tag helpers HTML element.

The HTML attributes.

The s that are associated with the tag helpers HTML element.

The HTML tag name.

Gets the HTML syntax of the element in the Razor source.

A for the @tagHelperPrefix directive.

Text used as a required prefix when matching HTML start and end tags in the Razor source to available tag helpers.

A responsible for generating s.

Initializes a new instance of .

Text used to look up s that should be added.

Gets the text used to look up s that should be added.

Generates s.

The responsible for this . A instance that contains information about the current chunk generation process.

A responsible for generating s.

Initializes a new instance of .

Text used to look up s that should be removed.

Generates s.

The responsible for this . A instance that contains information about the current chunk generation process.

A that is responsible for generating valid s.

Instantiates a new .

s associated with the current HTML tag.

Starts the generation of a .

The responsible for this . A instance that contains information about the current chunk generation process.

Ends the generation of a capturing all previously visited children since the method was called.

The responsible for this . A instance that contains information about the current chunk generation process.

A responsible for generating s.

Initializes a new instance of .

Text used as a required prefix when matching HTML.

Generates s.

The responsible for this . A instance that contains information about the current chunk generation process.

Context object with information used to generate a Razor page.

Instantiates a new instance of the object.

A to copy information from. The used to collect s encountered when parsing the current Razor document.

The current C# rendering mode.

forces C# generation to write s to the output page, i.e. WriteLiteral("Hello World"). writes values in their rawest form, i.g. "Hello World".

The C# writer to write information to.

If is null values will be written using a default write method i.e. WriteLiteral("Hello World"). If is not null values will be written to the given , i.e. WriteLiteralTo(myWriter, "Hello World").

Gets or sets the SHA1 based checksum for the file whose location is defined by .

Used to aggregate s.

Protected for testing.

A new instance of .

Writes a #line pragma directive for the line number at the specified .

The location to generate the line pragma for. The file to generate the line pragma for. The current instance of .

Initializes a new instance of used for generation of runtime line mappings. The constructed instance of does not track mappings between the Razor content and the generated content.

The to write output to. The of the Razor content being mapping. The input file path.

Renders tag helper rendering code.

Instantiates a new .

The used to render chunks found in the body. The used to write code. A instance that contains information about the current code generation process.

Renders the code for the given .

A to render.

Generates a unique ID for an HTML element.

A globally unique ID.

Indicates that expressions should be written to the output stream

If @foo is rendered with WriteToOutput, the code generator would output the following code: Write(foo);

Indicates that expressions should simply be placed as-is in the code, and the context in which the code exists will be used to render it

If @foo is rendered with InjectCode, the code generator would output the following code: foo

Contains necessary information for the tag helper code generation process.

Instantiates a new instance of the with default values.

The name of the method used to begin the addition of unbound, complex tag helper attributes to TagHelperExecutionContexts.

Method signature should be


            public void BeginAddHtmlAttributeValues(
                TagHelperExecutionContext executionContext,
                string attributeName)

Method name used to end addition of unbound, complex tag helper attributes to TagHelperExecutionContexts.

Method signature should be


            public void EndAddHtmlAttributeValues(
                TagHelperExecutionContext executionContext)

Method name used to add individual components of an unbound, complex tag helper attribute to TagHelperExecutionContexts.

Method signature:


            public void AddHtmlAttributeValues(
                string prefix,
                int prefixOffset,
                string value,
                int valueOffset,
                int valueLength,
                bool isLiteral)

The name of the method used to create a tag helper.

The name of the method used to run tag helpers.

The name of the method used to start a scope.

The name of the method used to end a scope.

The name of the method used to add tag helper attributes.

The name of the method used to add HTML attributes.

The name of the method used to add tag helpers.

The property name for the tag helper's output.

The name of the method used to format an error message about using an indexer when the tag helper property is null.

Method signature should be


            public string FormatInvalidIndexerAssignment(
                string attributeName,       // Name of the HTML attribute associated with the indexer.
                string tagHelperTypeName,   // Full name of the tag helper type.
                string propertyName)        // Dictionary property in the tag helper.

The name of the method used to wrap a value and mark it as HTML-encoded.

Used together with .

The name of the method used to start a new writing scope.

The name of the method used to end a writing scope.

The name of the method used to begin an attribute writing scope.

The name of the method used to end an attribute writing scope.

The name of the type used to run tag helpers.

The name of the type used to create scoped instances.

The name of the type describing a specific tag helper scope.

Contains information about in-scope tag helpers, HTML attributes, and the tag helpers' output.

The name of the type containing tag helper content.

Contains the data returned by EndTagHelperWriteScope().

The name of the property containing the HtmlEncoder.

The name of the method used to convert a TagHelperContent into a .

The name of the property used to indicate the tag helper's content has been modified.

The name of the property for the tag helper's output content.

The name of the method on the property used to execute child content and set the rendered results on its property.

The name of the type used to represent tag helper attributes.

The name of the type used to represent encoded content.

The name of the Value property of TagHelperAttribute.

The results of parsing and generating code for a Razor document.

Instantiates a new instance.

The results of parsing a document. The results of generating code for the document. A for the document.

Instantiates a new instance.

The for the syntax tree. The s that apply to the current Razor document. The used to collect s encountered when parsing the current Razor document. The results of generating code for the document. A for the document.

The generated code for the document.

s used to project code from a file during design time.

A for the document.

Renders code for tag helper property initialization.

Called during Razor's code generation process to generate code that instantiates the value of the tag helper's property. Last value written should not be or end with a semicolon.

The to generate code for. The that's used to write code. A instance that contains information about the current code generation process. that renders the raw value of the HTML attribute. Indicates whether or not the source attribute value contains more than simple text. false for plain C# expressions e.g. "PropertyName". true if the attribute value contain at least one in-line Razor construct e.g. "@(@readonly)".

Method used to write an to the current output.

Default is to HTML encode all but a few types.

Method used to write an to a specified .

Default is to HTML encode all but a few types.

Gets the method name used to generate WriteAttribute invocations in the rendered page.

Defaults to

that writes code for a non- tag helper bound attribute value.

Since attribute value is not written out as HTML, does not emit instrumentation. Further this writes identical code at design- and runtime.

Initializes a new instance of the class.

The used to write code. A instance that contains information about the current code generation process. Full name of the property for which this is writing the value.

Writes code for the given .

The to render. Tracks code mappings for all children while writing.

Writes code for the given .

The to render.

Writes code for the given .

The to render.

Writes code for the given .

The to render.

Writes code for the given .

The to render. Unconditionally adds a to inform user of unexpected @section directive.

Writes code for the given .

The to render. Unconditionally adds a to inform user of unexpected code block.

Writes code for the given .

The to render. Unconditionally adds a to inform user of unexpected template e.g. @paragraph@.

The that generates the code to initialize the TagHelperRunner.

Creates a new instance of .

The used to generate code. The .

Writes the TagHelperRunner initialization code to the Writer.

The .

Contract used to resolve s.

Resolves s based on the given .

used to resolve descriptors for the Razor page. An of s based on the given .

A metadata class describing a tag helper attribute.

Instantiates a new instance of the class.

Gets an indication whether this is used for dictionary indexer assignments.

If true this should be associated with all HTML attributes that have names starting with . Otherwise this is used for property assignment and is only associated with an HTML attribute that has the exact . HTML attribute names are matched case-insensitively, regardless of .

Gets or sets an indication whether this property is an .

Gets or sets an indication whether this property is of type or, if is true, whether the indexer's value is of type .

If true the is for . This causes the Razor parser to allow empty values for HTML attributes matching this . If false empty values for such matching attributes lead to errors.

The HTML attribute name or, if is true, the prefix for matching attribute names.

The name of the CLR property that corresponds to the HTML attribute.

The full name of the named (see ) property's or, if is true, the full name of the indexer's value .

The that contains design time information about this attribute.

Determines whether HTML attribute matches this .

Name of the HTML attribute to check. true if this matches . false otherwise.

A metadata class containing information about tag helper use.

A summary of how to use a tag helper.

Remarks about how to use a tag helper.

A metadata class describing a tag helper.

Text used as a required prefix when matching HTML start and end tags in the Razor source to available tag helpers.

The tag name that the tag helper should target.

The full tag name that is required for the tag helper to target an HTML element.

This is equivalent to and concatenated.

The full name of the tag helper class.

The name of the assembly containing the tag helper class.

The list of attributes the tag helper expects.

The list of required attribute names the tag helper expects to target an element.

* at the end of an attribute name acts as a prefix match.

Get the names of elements allowed as children.

null indicates all children are allowed.

Get the name of the HTML element required as the immediate parent.

null indicates no restriction on parent tag.

The expected tag structure.

If and no other tag helpers applying to the same element specify their the behavior is used:


            <my-tag-helper></my-tag-helper>
            <!-- OR -->
            <my-tag-helper />

Otherwise, if another tag helper applying to the same element does specify their behavior, that behavior is used. If HTML elements can be written in the following formats:


            <my-tag-helper>
            <!-- OR -->
            <my-tag-helper />

The that contains design time information about this tag helper.

An used to check equality between two s.

A default instance of the .

Initializes a new instance.

Determines equality based on , , , , , and . Ignores because it can be inferred directly from and .

Enables retrieval of 's.

Instantiates a new instance of the .

The descriptors that the will pull from.

Gets all tag helpers that match the given .

The name of the HTML tag to match. Providing a '*' tag name retrieves catch-all s (descriptors that target every tag). Attributes the HTML element must contain to match. The parent tag name of the given tag. s that apply to the given . Will return an empty if no s are found.

Contains information needed to resolve s.

Instantiates a new instance of .

s used to resolve s. Used to aggregate s.

s used to resolve s.

Used to aggregate s.

A metadata class containing design time information about a tag helper.

A summary of how to use a tag helper.

Remarks about how to use a tag helper.

The HTML element a tag helper may output.

In IDEs supporting IntelliSense, may override the HTML information provided at design time.

Contains information needed to resolve s.

A used to find tag helper s.

The of the directive.

The of this directive.

The type of tag helper directive.

An @addTagHelper directive.

A @removeTagHelper directive.

A @tagHelperPrefix directive.

A metadata class describing a required tag helper attribute.

The HTML attribute name.

The comparison method to use for when determining if an HTML attribute name matches.

The HTML attribute value.

The comparison method to use for when determining if an HTML attribute value matches.

Determines if the current matches the given and .

An HTML attribute name. An HTML attribute value. true if the current matches and ; false otherwise.

An used to check equality between two s.

A default instance of the .

Initializes a new instance.

Acceptable comparison modes.

HTML attribute name case insensitively matches .

HTML attribute name case insensitively starts with .

Acceptable comparison modes.

HTML attribute value always matches .

HTML attribute value case sensitively matches .

HTML attribute value case sensitively starts with .

HTML attribute value case sensitively ends with .

An that checks equality between two s using only their s and s.

This class is intended for scenarios where Reflection-based information is all important i.e. , , and related properties are not relevant.

A default instance of the .

Determines equality based on and .

Fired on the main thread.

Used within .

The default (Markup or Code) editor behavior for Statement completion should be used. Editors can always use the default behavior, even if the span is labeled with a different CompletionType.

Indicates that Virtual Path completion should be used for this span if the editor supports it. Editors need not support this mode of completion, and will use the default () behavior if they do not support it.

Provides a set of hints to editors which may be manipulating the document in which this span is located.

Returns true if the specified change is an insertion of text at the end of this span.

Returns true if the specified change is a replacement of text at the end of this span.

Returns the old text referenced by the change.

If the content has already been updated by applying the change, this data will be _invalid_

Contract for rewriting a syntax tree.

Rewrites the provided s .

Contains information on the rewriting of the syntax tree. To modify the syntax tree replace the s .

Starts a block of the specified type

The type of the block to start

Starts a block

Ends the current block

Gets a boolean indicating if any of the ancestors of the current block is of the specified type

Initializes a new instance of .

The used for parsing code content. The used for parsing markup content. The used to resolve s.

Initializes a new instance of from the specified .

The to copy values from.

Gets the used to resolve s.

Returns a sequence of s for tag helpers that are registered in the specified .

The to scan for tag helper registrations in. Used to manage s encountered during the Razor parsing phase. s that are applicable to the

Informational class for rewriting a syntax tree.

Instantiates a new .

The documents syntax tree.

Put the specified symbols back in the input stream. The provided list MUST be in the ORDER THE SYMBOLS WERE READ. The list WILL be reversed and the Putback(TSymbol) will be called on each item.

If a document contains symbols: a, b, c, d, e, f and AcceptWhile or AcceptUntil is used to collect until d the list returned by AcceptWhile/Until will contain: a, b, c IN THAT ORDER that is the correct format for providing to this method. The caller of this method would, in that case, want to put c, b and a back into the stream, so "a, b, c" is the CORRECT order

Reads the content of a tag (if present) in the MarkupDocument (or MarkupSection) context, where we don't care about maintaining a stack of tags.

Accepts the specified visitor

Calls the VisitSpan method on the specified visitor, passing in this

Checks that the specified span is equivalent to the other in that it has the same start point and content.

Returns true if this element is a block (to avoid casting)

The length of all the content contained in this node

The start point of this node

Accepts a parser visitor, calling the appropriate visit method and passing in this instance

The visitor to accept

Determines if the specified node is equivalent to this node

The node to compare this node with true if the provided node has all the same content and metadata, though the specific quantity and type of symbols may be different.

Determines a hash code for the using only information relevant in comparisons.

A hash code for the using only information relevant in comparisons.

A that reprents a special HTML element.

Instantiates a new instance of a .

A used to construct a valid .

Gets the unrewritten source start tag.

This is used by design time to properly format s.

Gets the unrewritten source end tag.

This is used by design time to properly format s.

Gets the HTML syntax of the element in the Razor source.

s for the HTML element.

The HTML attributes.

The HTML tag name.

Determines whether two s are equal by comparing the , , , and .

The to check equality against. true if the current is equivalent to the given , false otherwise.

A used to create s.

Instantiates a new instance based on the given .

The original to copy data from.

Instantiates a new instance of the class with the provided values.

An HTML tag name. HTML syntax of the element in the Razor source. Starting location of the . Attributes of the . The s associated with the current HTML tag.

Gets or sets the unrewritten source start tag.

This is used by design time to properly format s.

Gets or sets the unrewritten source end tag.

This is used by design time to properly format s.

Gets the HTML syntax of the element in the Razor source.

s for the HTML element.

The HTML attributes.

The HTML tag name.

Constructs a new .

A . Sets the to null and clears the .

The starting of the tag helper.

A that generates s from tag helper chunk generators in a Razor document.

Value cannot be null or an empty string.

Value must be between {0} and {1}.

Value must be a value from the "{0}" enumeration.

Value must be greater than {0}.

Value must be greater than or equal to {0}.

Value must be less than {0}.

Value must be less than or equal to {0}.

Value cannot be an empty string. It must either be null or a non-empty string.

The active parser must be the same as either the markup or code parser.

code

explicit expression

The "CancelBacktrack" method can be called only while in a look-ahead process started with the "BeginLookahead" method.

"EndBlock" was called without a matching call to "StartBlock".

The "@" character must be followed by a ":", "(", or a C# identifier. If you intended to switch to markup, use an HTML start tag, for example: @if(isLoggedIn) { Hello, @user! }

End of file was reached before the end of the block comment. All comments started with "/*" sequence must be terminated with a matching "*/" sequence.

An opening "{0}" is missing the corresponding closing "{1}".

The {0} block is missing a closing "{1}" character. Make sure you have a matching "{1}" character for all the "{2}" characters within this block, and that none of the "{1}" characters are being interpreted as markup.

Expected "{0}".

Inline markup blocks (@Content) cannot be nested. Only one level of inline markup is allowed.

Markup in a code block must start with a tag and all start tags must be matched with end tags. Do not use unclosed tags like " ". Instead use self-closing tags like " ".

The "{0}" element was not closed. All elements must be either self-closing or have a matching end tag.

Sections cannot be empty. The "@section" keyword must be followed by a block of markup surrounded by "{}". For example: @section Sidebar {  }

Namespace imports and type aliases cannot be placed within code blocks. They must immediately follow an "@" character in markup. It is recommended that you put them at the top of the page, as in the following example: @using System.Drawing; @{ // OK here to use types from System.Drawing in the page. }

Expected a "{0}" but found a "{1}". Block statements must be enclosed in "{{" and "}}". You cannot use single-statement control-flow statements in CSHTML pages. For example, the following is not allowed: @if(isLoggedIn) Hello, @user Instead, wrap the contents of the block in "{{}}": @if(isLoggedIn) {{ Hello, @user }}

Encountered end tag "{0}" with no matching start tag. Are your start/end tags properly balanced?

Unexpected {0} after section keyword. Section names must start with an "_" or alphabetic character, and the remaining characters must be either "_" or alphanumeric.

"{0}" is not valid at the start of a code block. Only identifiers, keywords, comments, "(" and "{{" are valid.

End of file or an unexpected character was reached before the "{0}" tag could be parsed. Elements inside markup blocks must be complete. They must either be self-closing (" ") or have matching end tags ("Hello"). If you intended to display a "<" character, use the "<" HTML entity.

Unterminated string literal. Strings that start with a quotation mark (") must be terminated before the end of the line. However, strings that start with @ and a quotation mark (@") can span multiple lines.

@section Header { ... }

"<text>" and "</text>" tags cannot contain attributes.

A space or line break was encountered after the "@" character. Only valid identifiers, keywords, comments, "(" and "{" are valid at the start of a code block and they must occur immediately following "@" with no space in between.

The 'inherits' keyword must be followed by a type name on the same line.

Outer tag is missing a name. The first character of a markup block must be an HTML tag with a valid name.

End of file was reached before the end of the block comment. All comments that start with the "@*" sequence must be terminated with a matching "*@" sequence.

"{0}" character

end of file

space or line break

End-of-file was found after the "@" character. "@" must be followed by a valid code block. If you want to output an "@", escape it using the sequence: "@@"

The {0} property of the {1} structure cannot be null.

Parser was started with a null Context property. The Context property must be set BEFORE calling any methods on the parser.

"{0}" is a reserved word and cannot be used in implicit expressions. An explicit expression ("@()") must be used.

Cannot resume this symbol. Only the symbol immediately preceding the current one can be resumed.

Cannot finish span, there is no current block. Call StartBlock at least once before finishing a span

Cannot complete the tree, there are still open blocks.

Cannot complete the tree, StartBlock must be called at least once.

Cannot complete action, the parser has finished. Only CompleteParse can be called to extract the final parser results after the parser has finished

Block cannot be built because a Type has not been specified in the BlockBuilder

<<character literal>>

<<comment>>

<<identifier>>

<<integer literal>>

<<keyword>>

<<newline sequence>>

<<real literal>>

<<string literal>>

<<white space>>

<<unknown>>

In order to put a symbol back, it must have been the symbol which ended at the current position. The specified symbol ends at {0}, but the current position is {1}

Unexpected "{" after "@" character. Once inside the body of a code block (@if {}, @{}, etc.) you do not need to use "@{" to switch to code.

line break

<<newline sequence>>

<<razor comment>>

<<text>>

<<white space>>

The parser provided to the ParserContext was not a Markup Parser.

Cannot use built-in RazorComment handler, language characteristics does not define the CommentStart, CommentStar and CommentBody known symbol types or parser does not override TokenizerBackedParser.OutputSpanBeforeRazorComment

[BG][{0}] Shutdown

[BG][{0}] Startup

[BG][{0}] {1} changes arrived

[BG][{0}] Discarded {1} changes

[BG][{0}] Collecting {1} discarded changes

Disabled

[P][{0}] {3} Change in {2} milliseconds: {1}

[P][{0}] Received Change: {1}

Enabled

[Razor] {0}

[BG][{0}] no changes arrived?

[BG][{0}] Parse Complete in {1} milliseconds

[M][{0}] Queuing Parse for: {1}

[Razor] Editor Tracing {0}

[BG][{0}] Trees Compared in {1} milliseconds. Different = {2}

Section blocks ("{0}") cannot be nested. Only one level of section blocks are allowed.

Tag Helper '{0}'s attributes must have names.

The tag helper '{0}' must not have C# in the element's attribute declaration area.

Directive '{0}' must have a value.

Found a malformed '{0}' tag helper. Tag helpers must have a start and end tag or be self closing.

Missing close angle for tag helper '{0}'.

TagHelper attributes must be well-formed.

The tag helper attribute '{0}' in element '{1}' is missing a key. The syntax is '<{1} {0}{{ key }}="value">'.

Non-string tag helper attribute values must not be empty. Add an expression to this attribute value.

Code blocks (e.g. @{{var variable = 23;}}) must not appear in non-string tag helper attribute values. Already in an expression (code) context. If necessary an explicit expression (e.g. @(@readonly)) may be used.

@'{0}' directives must not appear in non-string tag helper attribute values.

Inline markup blocks (e.g. @content) must not appear in non-string tag helper attribute values. Expected a '{0}' attribute value, not a string.

Attribute '{0}' on tag helper element '{1}' requires a value. Tag helper bound attributes of type '{2}' cannot be empty or contain only whitespace.

Cannot perform '{1}' operations on '{0}' instances with different file paths.

Tag helpers '{0}' and '{1}' targeting element '{2}' must not expect different {3} values.

Found an end tag (</{0}>) for tag helper '{1}' with tag structure that disallows an end tag ('{2}').

The parent <{0}> tag helper does not allow non-tag content. Only child tag helper(s) targeting tag name(s) '{1}' are allowed.

The <{0}> tag is not allowed by parent <{1}> tag helper. Only child tags with name(s) '{2}' are allowed.

The {0} directive is not supported.

Optional quote around the directive '{0}' is missing the corresponding opening or closing quote.

The mode in which an element should render.

Include both start and end tags.

A self-closed tag.

Only a start tag.

The structure the element should be written in.

If no other tag helper applies to the same element and specifies a , will be used.

Element can be written as <my-tag-helper></my-tag-helper> or <my-tag-helper />.

Element can be written as <my-tag-helper> or <my-tag-helper />.

Elements with a structure will never have any content.

Constructor for changes where the position hasn't moved (primarily for tests)

Note: This property is not thread safe, and will move position on the textbuffer while being read. https://aspnetwebstack.codeplex.com/workitem/1317, tracks making this immutable and improving the access to ITextBuffer to be thread safe. Note: This property is not thread safe, and will move position on the textbuffer while being read. https://aspnetwebstack.codeplex.com/workitem/1317, tracks making this immutable and improving the access to ITextBuffer to be thread safe.

Applies the text change to the content of the span and returns the new content. This method doesn't update the span content.

Removes a common prefix from the edit to turn IntelliSense replacements into insertions where possible

A normalized text change

Returns a result indicating that the machine should stop executing and return null output.

Returns a result indicating that this state has no output and the machine should immediately invoke the specified state

By returning no output, the state machine will invoke the next state immediately, before returning controller to the caller of

Returns a result containing the specified output and indicating that the next call to should invoke the provided state.

Returns a result indicating that this state has no output and the machine should remain in this state

By returning no output, the state machine will re-invoke the current state again before returning controller to the caller of

Returns a result containing the specified output and indicating that the next call to should re-invoke the current state.

Internal for unit testing

Converts the generic to a and finds the first with type .

The instance this method extends. The to search for. The first of type .