Grammar csharp

start ::=

compilation_unit

(used in )
May be empty
MayStartWith: extern namespace using [ partial class struct interface enum delegate new public protected internal private abstract sealed static unsafe
MayBeFollowedBy:

compilation_unit ::=

extern_alias_directive* using_directive* global_attributes? namespace_member_declaration*

(Spec: Compilation units)
(used in start)
May be empty
MayStartWith: extern namespace using [ partial class struct interface enum delegate new public protected internal private abstract sealed static unsafe
MayBeFollowedBy:

namespace_declaration ::=

namespace qualified_identifier namespace_body ;?

(Spec: Namespace declarations)
(used in namespace_member_declaration)
Never empty
MayStartWith: namespace
MayBeFollowedBy: namespace partial class struct interface enum delegate new public protected internal private abstract sealed static [ unsafe }

qualified_identifier ::=

identifier ( . identifier )*

(Spec: Namespace declarations)
(used in namespace_declaration)
Never empty
MayStartWith: @ <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: {

namespace_body ::=

{ extern_alias_directive* using_directive* namespace_member_declaration* }

(Spec: Namespace declarations)
(used in namespace_declaration)
Never empty
MayStartWith: {
MayBeFollowedBy: ; namespace partial class struct interface enum delegate new public protected internal private abstract sealed static [ unsafe }

extern_alias_directive ::=

extern alias identifier ;

(Spec: Extern aliases)
(used in compilation_unit namespace_body)
Never empty
MayStartWith: extern
MayBeFollowedBy: namespace partial class struct interface enum delegate new public protected internal private abstract sealed static [ unsafe using extern }

(Spec: Using directives)
(used in compilation_unit namespace_body)
Never empty
MayStartWith: using
MayBeFollowedBy: namespace partial class struct interface enum delegate new public protected internal private abstract sealed static [ unsafe using }

using_alias_directive ::=

using identifier = namespace_or_type_name ;

(Spec: Using alias directives)
(used in using_directive)
Never empty
MayStartWith: using
MayBeFollowedBy: namespace partial class struct interface enum delegate new public protected internal private abstract sealed static [ unsafe using }

using_namespace_directive ::=

using namespace_name ;

(Spec: Using namespace directives)
(used in using_directive)
Never empty
MayStartWith: using
MayBeFollowedBy: namespace partial class struct interface enum delegate new public protected internal private abstract sealed static [ unsafe using }

using_static_directive ::=

using static type_name ;

(Spec: Using static directives)
(used in using_directive)
Never empty
MayStartWith: using
MayBeFollowedBy: namespace partial class struct interface enum delegate new public protected internal private abstract sealed static [ unsafe using }

namespace_member_declaration ::=

namespace_declaration
type_declaration

(Spec: Namespace members)
(used in compilation_unit namespace_body)
Never empty
MayStartWith: namespace partial class struct interface enum delegate new public protected internal private abstract sealed static [ unsafe
MayBeFollowedBy: namespace partial class struct interface enum delegate new public protected internal private abstract sealed static [ unsafe }

qualified_alias_member ::=

identifier :: identifier type_argument_list?

(Spec: Namespace alias qualifiers)
(used in namespace_or_type_name member_access named_entity_target)
Never empty
MayStartWith: @ <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: ; . ] , ( ? [ > { ) < <= >= is @ <An identifier_or_keyword that is not a keyword> this operator * where as == => != & ^ | && || ?? } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> : from select group let join orderby equals on into ascending descending by const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe object dynamic string void bool decimal sbyte byte short ushort int uint long ulong char float double fixed

namespace_name ::=

namespace_or_type_name

(Spec: Namespace and type names)
(used in using_namespace_directive)
Never empty
MayStartWith: @ <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: ;

type_name ::=

namespace_or_type_name

(Spec: Namespace and type names)
(used in using_static_directive struct_type enum_type class_type interface_type delegate_type attribute_name)
Never empty
MayStartWith: @ <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: ; ] , ( ? [ > { ) < <= >= is @ <An identifier_or_keyword that is not a keyword> this operator * where . as == => != & ^ | && || ?? } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> : from select group let join orderby equals on into ascending descending by const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe object dynamic string void bool decimal sbyte byte short ushort int uint long ulong char float double fixed

namespace_or_type_name ::=

identifier type_argument_list?
namespace_or_type_name . identifier type_argument_list?
qualified_alias_member

(Spec: Namespace and type names)
(used in using_alias_directive namespace_name type_name namespace_or_type_name)
Never empty
MayStartWith: @ <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: ; . ] , ( ? [ > { ) < <= >= is @ <An identifier_or_keyword that is not a keyword> this operator * where as == => != & ^ | && || ?? } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> : from select group let join orderby equals on into ascending descending by const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe object dynamic string void bool decimal sbyte byte short ushort int uint long ulong char float double fixed

type ::=

value_type
reference_type
type_parameter
type_unsafe

(Spec: Types)
(used in non_nullable_value_type non_array_type type_argument object_creation_expression typeof_expression default_value_expression cast_expression relational_expression explicit_anonymous_function_parameter from_clause join_clause join_into_clause local_variable_type local_constant_declaration exception_specifier constant_declaration field_declaration return_type fixed_parameter property_declaration event_declaration indexer_declarator unary_operator_declarator binary_operator_declarator conversion_operator_declarator interface_property_declaration interface_event_declaration interface_indexer_declaration unmanaged_type buffer_element_type)
Never empty
MayStartWith: object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double
MayBeFollowedBy: ? [ > , ( { ) < <= >= is @ <An identifier_or_keyword that is not a keyword> this operator * as == != & ^ | && || ?? } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let where join orderby equals on into ascending descending by ; const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe object dynamic string void bool decimal sbyte byte short ushort int uint long ulong char float double fixed

value_type ::=

struct_type
enum_type

(Spec: Value types)
(used in type)
Never empty
MayStartWith: bool @ decimal <An identifier_or_keyword that is not a keyword> sbyte byte short ushort int uint long ulong char float double object dynamic string void
MayBeFollowedBy: ? [ > , ( { ) < <= >= is @ <An identifier_or_keyword that is not a keyword> this operator * as == != & ^ | && || ?? } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let where join orderby equals on into ascending descending by ; const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe object dynamic string void bool decimal sbyte byte short ushort int uint long ulong char float double fixed

struct_type ::=

type_name
simple_type
nullable_type

(Spec: Value types)
(used in value_type)
Never empty
MayStartWith: bool @ decimal <An identifier_or_keyword that is not a keyword> sbyte byte short ushort int uint long ulong char float double object dynamic string void
MayBeFollowedBy: ? [ > , ( { ) < <= >= is @ <An identifier_or_keyword that is not a keyword> this operator * as == != & ^ | && || ?? } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let where join orderby equals on into ascending descending by ; const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe object dynamic string void bool decimal sbyte byte short ushort int uint long ulong char float double fixed

simple_type ::=

numeric_type
bool

(Spec: Value types)
(used in struct_type)
Never empty
MayStartWith: bool decimal sbyte byte short ushort int uint long ulong char float double
MayBeFollowedBy: ? [ > , ( { ) < <= >= is @ <An identifier_or_keyword that is not a keyword> this operator * as == != & ^ | && || ?? } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let where join orderby equals on into ascending descending by ; const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe object dynamic string void bool decimal sbyte byte short ushort int uint long ulong char float double fixed

numeric_type ::=

integral_type
floating_point_type
decimal

(Spec: Value types)
(used in simple_type)
Never empty
MayStartWith: decimal sbyte byte short ushort int uint long ulong char float double
MayBeFollowedBy: ? [ > , ( { ) < <= >= is @ <An identifier_or_keyword that is not a keyword> this operator * as == != & ^ | && || ?? } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let where join orderby equals on into ascending descending by ; const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe object dynamic string void bool decimal sbyte byte short ushort int uint long ulong char float double fixed

integral_type ::=

sbyte
byte
short
ushort
int
uint
long
ulong
char

(Spec: Value types)
(used in numeric_type enum_base)
Never empty
MayStartWith: sbyte byte short ushort int uint long ulong char
MayBeFollowedBy: { ? [ > , ( ) < <= >= is @ <An identifier_or_keyword that is not a keyword> this operator * as == != & ^ | && || ?? } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let where join orderby equals on into ascending descending by ; const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe object dynamic string void bool decimal sbyte byte short ushort int uint long ulong char float double fixed

floating_point_type ::=

float
double

(Spec: Value types)
(used in numeric_type)
Never empty
MayStartWith: float double
MayBeFollowedBy: ? [ > , ( { ) < <= >= is @ <An identifier_or_keyword that is not a keyword> this operator * as == != & ^ | && || ?? } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let where join orderby equals on into ascending descending by ; const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe object dynamic string void bool decimal sbyte byte short ushort int uint long ulong char float double fixed

nullable_type ::=

non_nullable_value_type ?

(Spec: Value types)
(used in struct_type)
Never empty
MayStartWith: object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double
MayBeFollowedBy: ? [ > , ( { ) < <= >= is @ <An identifier_or_keyword that is not a keyword> this operator * as == != & ^ | && || ?? } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let where join orderby equals on into ascending descending by ; const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe object dynamic string void bool decimal sbyte byte short ushort int uint long ulong char float double fixed

non_nullable_value_type ::=

type

(Spec: Value types)
(used in nullable_type)
Never empty
MayStartWith: object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double
MayBeFollowedBy: ?

enum_type ::=

type_name

(Spec: Value types)
(used in value_type)
Never empty
MayStartWith: @ <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: ? [ > , ( { ) < <= >= is @ <An identifier_or_keyword that is not a keyword> this operator * as == != & ^ | && || ?? } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let where join orderby equals on into ascending descending by ; const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe object dynamic string void bool decimal sbyte byte short ushort int uint long ulong char float double fixed

reference_type ::=

class_type
interface_type
array_type
delegate_type

(Spec: Reference types)
(used in type)
Never empty
MayStartWith: object dynamic string @ <An identifier_or_keyword that is not a keyword> void bool decimal sbyte byte short ushort int uint long ulong char float double
MayBeFollowedBy: ? [ > , ( { ) < <= >= is @ <An identifier_or_keyword that is not a keyword> this operator * as == != & ^ | && || ?? } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let where join orderby equals on into ascending descending by ; const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe object dynamic string void bool decimal sbyte byte short ushort int uint long ulong char float double fixed

class_type ::=

type_name
object
dynamic
string

(Spec: Reference types)
(used in reference_type class_base primary_constraint)
Never empty
MayStartWith: object dynamic string @ <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: { where , ? [ > ( ) < <= >= is @ <An identifier_or_keyword that is not a keyword> this operator * => ; as == != & ^ | && || ?? } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let join orderby equals on into ascending descending by const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe object dynamic string void bool decimal sbyte byte short ushort int uint long ulong char float double fixed

interface_type ::=

type_name

(Spec: Reference types)
(used in reference_type interface_type_list secondary_constraints member_name indexer_declarator)
Never empty
MayStartWith: @ <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: { where , . ? [ > ( ) < <= >= is @ <An identifier_or_keyword that is not a keyword> this operator * => ; as == != & ^ | && || ?? } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let join orderby equals on into ascending descending by const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe object dynamic string void bool decimal sbyte byte short ushort int uint long ulong char float double fixed

array_type ::=

non_array_type rank_specifier+

(Spec: Reference types)
(used in reference_type array_creation_expression parameter_array)
Never empty
MayStartWith: object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double
MayBeFollowedBy: { @ <An identifier_or_keyword that is not a keyword> ? [ > , ( ) < <= >= is this operator * as == != & ^ | && || ?? } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let where join orderby equals on into ascending descending by ; const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe object dynamic string void bool decimal sbyte byte short ushort int uint long ulong char float double fixed

non_array_type ::=

type

(Spec: Reference types)
(used in array_type array_creation_expression)
Never empty
MayStartWith: object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double
MayBeFollowedBy: [

rank_specifier ::=

[ dim_separator* ]

(Spec: Reference types)
(used in array_type array_creation_expression)
Never empty
MayStartWith: [
MayBeFollowedBy: [ { @ <An identifier_or_keyword that is not a keyword> ? > , ( ) < <= >= is this operator * . ++ -- -> as == / = += -= *= /= %= &= |= ^= <<= >>= != ; % + & - << ^ >> | && || ?? } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let where join orderby equals on into ascending descending by const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe object dynamic string void bool decimal sbyte byte short ushort int uint long ulong char float double fixed

dim_separator ::=

(Spec: Reference types)
(used in rank_specifier)
Never empty
MayStartWith: ,
MayBeFollowedBy: ] ,

delegate_type ::=

type_name

(Spec: Reference types)
(used in reference_type delegate_creation_expression)
Never empty
MayStartWith: @ <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: ( ? [ > , { ) < <= >= is @ <An identifier_or_keyword that is not a keyword> this operator * as == != & ^ | && || ?? } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let where join orderby equals on into ascending descending by ; const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe object dynamic string void bool decimal sbyte byte short ushort int uint long ulong char float double fixed

type_argument_list ::=

< type_arguments >

(Spec: Type arguments)
(used in qualified_alias_member namespace_or_type_name simple_name member_access named_entity null_conditional_operations null_conditional_member_access)
Never empty
MayStartWith: <
MayBeFollowedBy: ; ) ? } , . ] ( [ ++ -- -> * / = += -= *= /= %= &= |= ^= <<= >>= > { < <= >= is @ <An identifier_or_keyword that is not a keyword> this operator where % + as == => - << != >> & ^ | && || ?? <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> : from select group let join orderby equals on into ascending descending by const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe object dynamic string void bool decimal sbyte byte short ushort int uint long ulong char float double fixed

type_arguments ::=

type_argument ( , type_argument )*

(Spec: Type arguments)
(used in type_argument_list)
Never empty
MayStartWith: object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double
MayBeFollowedBy: >

type_argument ::=

type

(Spec: Type arguments)
(used in type_arguments)
Never empty
MayStartWith: object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double
MayBeFollowedBy: > ,

type_parameter ::=

identifier

(Spec: Type parameters)
(used in type type_parameters type_parameter_constraints_clause secondary_constraints variant_type_parameters)
Never empty
MayStartWith: @ <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: > : { where , ? [ ( ) < <= >= is @ <An identifier_or_keyword that is not a keyword> this operator * => ; as == != & ^ | && || ?? } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] from select group let join orderby equals on into ascending descending by const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe object dynamic string void bool decimal sbyte byte short ushort int uint long ulong char float double fixed

variable_reference ::=

expression

(Spec: Variable references)
(used in argument_value fixed_pointer_initializer)
Never empty
MayStartWith: + - ! ~ new ++ -- ( await from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: , ) ]

argument_list ::=

argument ( , argument )*

(Spec: Argument lists)
(used in invocation_expression object_creation_expression initializer_target null_conditional_operations null_conditional_invocation_expression constructor_initializer)
Never empty
MayStartWith: ref out @ + - ! ~ <An identifier_or_keyword that is not a keyword> new ++ -- ( await from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @"
MayBeFollowedBy: ) ]

argument ::=

argument_name? argument_value

(Spec: Argument lists)
(used in argument_list)
Never empty
MayStartWith: ref out @ + - ! ~ <An identifier_or_keyword that is not a keyword> new ++ -- ( await from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @"
MayBeFollowedBy: , ) ]

argument_name ::=

identifier :

(Spec: Argument lists)
(used in argument)
Never empty
MayStartWith: @ <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: ref out + - ! ~ new ++ -- ( await from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>

argument_value ::=

expression
ref variable_reference
out variable_reference

(Spec: Argument lists)
(used in argument)
Never empty
MayStartWith: ref out + - ! ~ new ++ -- ( await from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: , ) ]

primary_expression ::=

primary_no_array_creation_expression
array_creation_expression

(Spec: Primary expressions)
(used in member_access invocation_expression post_increment_expression post_decrement_expression unary_expression null_conditional_expression null_conditional_member_access null_conditional_invocation_expression pointer_member_access)
Never empty
MayStartWith: new <UNDEFINED> ( this base typeof checked unchecked default nameof delegate true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: . ( ++ -- ? -> * / = += -= *= /= %= &= |= ^= <<= >>= ; % + ) , - << >> < > <= >= is as == != & ^ | && || ?? } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let where join orderby equals on into ascending descending by const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe [ object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

primary_no_array_creation_expression ::=

literal
interpolated_string
simple_name
parenthesized_expression
member_access
invocation_expression
element_access
this_access
base_access
post_increment_expression
post_decrement_expression
object_creation_expression
delegate_creation_expression
anonymous_object_creation_expression
typeof_expression
checked_expression
unchecked_expression
default_value_expression
nameof_expression
anonymous_method_expression
primary_no_array_creation_expression_unsafe

(Spec: Primary expressions)
(used in primary_expression element_access pointer_element_access)
Never empty
MayStartWith: <UNDEFINED> ( this base new typeof checked unchecked default nameof delegate true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: [ . ( ++ -- ? -> * / = += -= *= /= %= &= |= ^= <<= >>= ; % + ) , - << >> < > <= >= is as == != & ^ | && || ?? } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let where join orderby equals on into ascending descending by const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

interpolated_string_expression ::=

$ interpolated_regular_string
$ interpolated_verbatim_string

(Spec: Interpolated strings)
(used in )
Never empty
MayStartWith: $
MayBeFollowedBy:

interpolated_regular_string ::=

interpolated_regular_string_whole
interpolated_regular_string_start interpolated_regular_string_body interpolated_regular_string_end

(Spec: Interpolated strings)
(used in interpolated_string_expression)
Never empty
MayStartWith: "
MayBeFollowedBy:

interpolated_regular_string_body ::=

interpolation ( interpolated_regular_string_mid interpolation )*

(Spec: Interpolated strings)
(used in interpolated_regular_string)
Never empty
MayStartWith: + - ! ~ new ++ -- ( await from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)>

interpolation ::=

expression
expression , constant_expression

(Spec: Interpolated strings)
(used in interpolated_regular_string_body interpolated_verbatim_string_body)
Never empty
MayStartWith: + - ! ~ new ++ -- ( await from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)>

interpolated_verbatim_string ::=

interpolated_verbatim_string_whole
interpolated_verbatim_string_start interpolated_verbatim_string_body interpolated_verbatim_string_end

(Spec: Interpolated strings)
(used in interpolated_string_expression)
Never empty
MayStartWith: @"
MayBeFollowedBy:

interpolated_verbatim_string_body ::=

interpolation ( interpolated_verbatim_string_mid interpolation )+

(Spec: Interpolated strings)
(used in interpolated_verbatim_string)
Never empty
MayStartWith: + - ! ~ new ++ -- ( await from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)>

simple_name ::=

identifier type_argument_list?

(Spec: Simple names)
(used in primary_no_array_creation_expression member_declarator named_entity)
Never empty
MayStartWith: @ <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: } , ) [ . ( ++ -- ? -> * / = += -= *= /= %= &= |= ^= <<= >>= ; % + - << >> < > <= >= is as == != & ^ | && || ?? <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let where join orderby equals on into ascending descending by const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

parenthesized_expression ::=

( expression )

(Spec: Parenthesized expressions)
(used in primary_no_array_creation_expression)
Never empty
MayStartWith: (
MayBeFollowedBy: [ . ( ++ -- ? -> * / = += -= *= /= %= &= |= ^= <<= >>= ; % + ) , - << >> < > <= >= is as == != & ^ | && || ?? } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let where join orderby equals on into ascending descending by const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

member_access ::=

primary_expression . identifier type_argument_list?
predefined_type . identifier type_argument_list?
qualified_alias_member . identifier

(Spec: Member access)
(used in primary_no_array_creation_expression member_declarator)
Never empty
MayStartWith: new bool byte char decimal double float int long object sbyte short string uint ulong ushort @ <UNDEFINED> ( this base typeof checked unchecked default nameof delegate <An identifier_or_keyword that is not a keyword> true false 0 1 2 3 4 5 6 7 8 9 . ' null sizeof 0x 0X " @"
MayBeFollowedBy: } , [ . ( ++ -- ? -> * / = += -= *= /= %= &= |= ^= <<= >>= ; % + ) - << >> < > <= >= is as == != & ^ | && || ?? <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let where join orderby equals on into ascending descending by const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

predefined_type ::=

bool
byte
char
decimal
double
float
int
long
object
sbyte
short
string
uint
ulong
ushort

(Spec: Member access)
(used in member_access named_entity_target)
Never empty
MayStartWith: bool byte char decimal double float int long object sbyte short string uint ulong ushort
MayBeFollowedBy: .

invocation_expression ::=

primary_expression ( argument_list? )

(Spec: Invocation expressions)
(used in primary_no_array_creation_expression statement_expression)
Never empty
MayStartWith: new <UNDEFINED> ( this base typeof checked unchecked default nameof delegate true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: ; [ . ( ++ -- ? -> ) , * / = += -= *= /= %= &= |= ^= <<= >>= % + - << >> < > <= >= is as == != & ^ | && || ?? } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let where join orderby equals on into ascending descending by const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

element_access ::=

primary_no_array_creation_expression [ expression_list ]

(Spec: Element access)
(used in primary_no_array_creation_expression)
Never empty
MayStartWith: <UNDEFINED> ( this base new typeof checked unchecked default nameof delegate true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: [ . ( ++ -- ? -> * / = += -= *= /= %= &= |= ^= <<= >>= ; % + ) , - << >> < > <= >= is as == != & ^ | && || ?? } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let where join orderby equals on into ascending descending by const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

this_access ::=

this

(Spec: This access)
(used in primary_no_array_creation_expression)
Never empty
MayStartWith: this
MayBeFollowedBy: [ . ( ++ -- ? -> * / = += -= *= /= %= &= |= ^= <<= >>= ; % + ) , - << >> < > <= >= is as == != & ^ | && || ?? } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let where join orderby equals on into ascending descending by const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

base_access ::=

base . identifier
base [ expression_list ]

(Spec: Base access)
(used in primary_no_array_creation_expression member_declarator)
Never empty
MayStartWith: base
MayBeFollowedBy: } , [ . ( ++ -- ? -> * / = += -= *= /= %= &= |= ^= <<= >>= ; % + ) - << >> < > <= >= is as == != & ^ | && || ?? <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let where join orderby equals on into ascending descending by const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

post_increment_expression ::=

primary_expression ++

(Spec: Postfix increment and decrement operators)
(used in primary_no_array_creation_expression statement_expression)
Never empty
MayStartWith: new <UNDEFINED> ( this base typeof checked unchecked default nameof delegate true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: ; [ . ( ++ -- ? -> ) , * / = += -= *= /= %= &= |= ^= <<= >>= % + - << >> < > <= >= is as == != & ^ | && || ?? } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let where join orderby equals on into ascending descending by const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

post_decrement_expression ::=

primary_expression --

(Spec: Postfix increment and decrement operators)
(used in primary_no_array_creation_expression statement_expression)
Never empty
MayStartWith: new <UNDEFINED> ( this base typeof checked unchecked default nameof delegate true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: ; [ . ( ++ -- ? -> ) , * / = += -= *= /= %= &= |= ^= <<= >>= % + - << >> < > <= >= is as == != & ^ | && || ?? } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let where join orderby equals on into ascending descending by const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

object_creation_expression ::=

new type ( argument_list? ) object_or_collection_initializer?
new type object_or_collection_initializer

(Spec: Object creation expressions)
(used in primary_no_array_creation_expression statement_expression)
Never empty
MayStartWith: new
MayBeFollowedBy: ; [ . ( ++ -- ? -> ) , * / = += -= *= /= %= &= |= ^= <<= >>= % + - << >> < > <= >= is as == != & ^ | && || ?? } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let where join orderby equals on into ascending descending by const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

object_or_collection_initializer ::=

object_initializer
collection_initializer

(Spec: Object creation expressions)
(used in object_creation_expression initializer_value)
Never empty
MayStartWith: {
MayBeFollowedBy: } , ; [ . ( ++ -- ? -> ) * / = += -= *= /= %= &= |= ^= <<= >>= % + - << >> < > <= >= is as == != & ^ | && || ?? <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let where join orderby equals on into ascending descending by const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

object_initializer ::=

{ member_initializer_list? }
{ member_initializer_list , }

(Spec: Object initializers)
(used in object_or_collection_initializer)
Never empty
MayStartWith: {
MayBeFollowedBy: } , ; [ . ( ++ -- ? -> ) * / = += -= *= /= %= &= |= ^= <<= >>= % + - << >> < > <= >= is as == != & ^ | && || ?? <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let where join orderby equals on into ascending descending by const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

member_initializer_list ::=

member_initializer ( , member_initializer )*

(Spec: Object initializers)
(used in object_initializer)
Never empty
MayStartWith: [ @ <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: } ,

member_initializer ::=

initializer_target = initializer_value

(Spec: Object initializers)
(used in member_initializer_list)
Never empty
MayStartWith: [ @ <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: } ,

initializer_target ::=

identifier
[ argument_list ]

(Spec: Object initializers)
(used in member_initializer)
Never empty
MayStartWith: [ @ <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: =

initializer_value ::=

expression
object_or_collection_initializer

(Spec: Object initializers)
(used in member_initializer)
Never empty
MayStartWith: + - ! ~ { new ++ -- ( await from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: } ,

collection_initializer ::=

{ element_initializer_list }
{ element_initializer_list , }

(Spec: Collection initializers)
(used in object_or_collection_initializer)
Never empty
MayStartWith: {
MayBeFollowedBy: } , ; [ . ( ++ -- ? -> ) * / = += -= *= /= %= &= |= ^= <<= >>= % + - << >> < > <= >= is as == != & ^ | && || ?? <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let where join orderby equals on into ascending descending by const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

element_initializer_list ::=

element_initializer ( , element_initializer )*

(Spec: Collection initializers)
(used in collection_initializer)
Never empty
MayStartWith: { + - ! ~ new ++ -- ( await from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: } ,

element_initializer ::=

non_assignment_expression
{ expression_list }

(Spec: Collection initializers)
(used in element_initializer_list)
Never empty
MayStartWith: { + - ! ~ new ++ -- ( await from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: } ,

expression_list ::=

expression ( , expression )*

(Spec: Collection initializers)
(used in element_access base_access element_initializer array_creation_expression)
Never empty
MayStartWith: + - ! ~ new ++ -- ( await from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: ] }

array_creation_expression ::=

new non_array_type [ expression_list ] rank_specifier* array_initializer?
new array_type array_initializer
new rank_specifier array_initializer

(Spec: Array creation expressions)
(used in primary_expression)
Never empty
MayStartWith: new
MayBeFollowedBy: . ( ++ -- ? -> * / = += -= *= /= %= &= |= ^= <<= >>= ; % + ) , - << >> < > <= >= is as == != & ^ | && || ?? } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let where join orderby equals on into ascending descending by const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe [ object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

delegate_creation_expression ::=

new delegate_type ( expression )

(Spec: Delegate creation expressions)
(used in primary_no_array_creation_expression)
Never empty
MayStartWith: new
MayBeFollowedBy: [ . ( ++ -- ? -> * / = += -= *= /= %= &= |= ^= <<= >>= ; % + ) , - << >> < > <= >= is as == != & ^ | && || ?? } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let where join orderby equals on into ascending descending by const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

anonymous_object_creation_expression ::=

new anonymous_object_initializer

(Spec: Anonymous object creation expressions)
(used in primary_no_array_creation_expression)
Never empty
MayStartWith: new
MayBeFollowedBy: [ . ( ++ -- ? -> * / = += -= *= /= %= &= |= ^= <<= >>= ; % + ) , - << >> < > <= >= is as == != & ^ | && || ?? } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let where join orderby equals on into ascending descending by const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

anonymous_object_initializer ::=

{ member_declarator_list? }
{ member_declarator_list , }

(Spec: Anonymous object creation expressions)
(used in anonymous_object_creation_expression)
Never empty
MayStartWith: {
MayBeFollowedBy: [ . ( ++ -- ? -> * / = += -= *= /= %= &= |= ^= <<= >>= ; % + ) , - << >> < > <= >= is as == != & ^ | && || ?? } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let where join orderby equals on into ascending descending by const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

member_declarator_list ::=

member_declarator ( , member_declarator )*

(Spec: Anonymous object creation expressions)
(used in anonymous_object_initializer)
Never empty
MayStartWith: base @ new bool byte char decimal double float int long object sbyte short string uint ulong ushort <An identifier_or_keyword that is not a keyword> <UNDEFINED> ( this typeof checked unchecked default nameof delegate true false 0 1 2 3 4 5 6 7 8 9 . ' null sizeof 0x 0X " @"
MayBeFollowedBy: } ,

member_declarator ::=

simple_name
member_access
base_access
null_conditional_member_access
identifier = expression

(Spec: Anonymous object creation expressions)
(used in member_declarator_list)
Never empty
MayStartWith: base @ new bool byte char decimal double float int long object sbyte short string uint ulong ushort <An identifier_or_keyword that is not a keyword> <UNDEFINED> ( this typeof checked unchecked default nameof delegate true false 0 1 2 3 4 5 6 7 8 9 . ' null sizeof 0x 0X " @"
MayBeFollowedBy: } ,

typeof_expression ::=

typeof ( type )
typeof ( unbound_type_name )
typeof ( void )

(Spec: The typeof operator)
(used in primary_no_array_creation_expression)
Never empty
MayStartWith: typeof
MayBeFollowedBy: [ . ( ++ -- ? -> * / = += -= *= /= %= &= |= ^= <<= >>= ; % + ) , - << >> < > <= >= is as == != & ^ | && || ?? } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let where join orderby equals on into ascending descending by const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

unbound_type_name ::=

identifier generic_dimension_specifier?
identifier :: identifier generic_dimension_specifier?
unbound_type_name . identifier generic_dimension_specifier?

(Spec: The typeof operator)
(used in typeof_expression unbound_type_name)
Never empty
MayStartWith: @ <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: ) .

generic_dimension_specifier ::=

< comma* >

(Spec: The typeof operator)
(used in unbound_type_name)
Never empty
MayStartWith: <
MayBeFollowedBy: ) .

comma ::=

(Spec: The typeof operator)
(used in generic_dimension_specifier)
Never empty
MayStartWith: ,
MayBeFollowedBy: > ,

checked_expression ::=

checked ( expression )

(Spec: The checked and unchecked operators)
(used in primary_no_array_creation_expression)
Never empty
MayStartWith: checked
MayBeFollowedBy: [ . ( ++ -- ? -> * / = += -= *= /= %= &= |= ^= <<= >>= ; % + ) , - << >> < > <= >= is as == != & ^ | && || ?? } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let where join orderby equals on into ascending descending by const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

unchecked_expression ::=

unchecked ( expression )

(Spec: The checked and unchecked operators)
(used in primary_no_array_creation_expression)
Never empty
MayStartWith: unchecked
MayBeFollowedBy: [ . ( ++ -- ? -> * / = += -= *= /= %= &= |= ^= <<= >>= ; % + ) , - << >> < > <= >= is as == != & ^ | && || ?? } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let where join orderby equals on into ascending descending by const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

default_value_expression ::=

default ( type )

(Spec: Default value expressions)
(used in primary_no_array_creation_expression)
Never empty
MayStartWith: default
MayBeFollowedBy: [ . ( ++ -- ? -> * / = += -= *= /= %= &= |= ^= <<= >>= ; % + ) , - << >> < > <= >= is as == != & ^ | && || ?? } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let where join orderby equals on into ascending descending by const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

nameof_expression ::=

nameof ( named_entity )

(Spec: Nameof expressions)
(used in primary_no_array_creation_expression)
Never empty
MayStartWith: nameof
MayBeFollowedBy: [ . ( ++ -- ? -> * / = += -= *= /= %= &= |= ^= <<= >>= ; % + ) , - << >> < > <= >= is as == != & ^ | && || ?? } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let where join orderby equals on into ascending descending by const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

named_entity ::=

simple_name
named_entity_target . identifier type_argument_list?

(Spec: Nameof expressions)
(used in nameof_expression named_entity_target)
Never empty
MayStartWith: @ this base bool byte char decimal double float int long object sbyte short string uint ulong ushort <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: ) .

named_entity_target ::=

this
base
named_entity
predefined_type
qualified_alias_member

(Spec: Nameof expressions)
(used in named_entity)
Never empty
MayStartWith: this base bool byte char decimal double float int long object sbyte short string uint ulong ushort @ <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: .

unary_expression ::=

primary_expression
null_conditional_expression
+ unary_expression
- unary_expression
! unary_expression
~ unary_expression
pre_increment_expression
pre_decrement_expression
cast_expression
await_expression
unary_expression_unsafe

(Spec: Unary operators)
(used in unary_expression pre_increment_expression pre_decrement_expression cast_expression await_expression multiplicative_expression assignment pointer_indirection_expression addressof_expression)
Never empty
MayStartWith: + - ! ~ new ++ -- ( await <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: * / = += -= *= /= %= &= |= ^= <<= >>= ; % + ) , - << >> < > <= >= is as == != & ^ | && || ?? ? } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let where join orderby equals on into ascending descending by const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe [ object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

null_conditional_expression ::=

primary_expression null_conditional_operations

(Spec: Null-conditional operator)
(used in unary_expression)
Never empty
MayStartWith: new <UNDEFINED> ( this base typeof checked unchecked default nameof delegate true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: * / = += -= *= /= %= &= |= ^= <<= >>= ; % + ) , - << >> < > <= >= is as == != & ^ | && || ?? ? } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let where join orderby equals on into ascending descending by const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe [ object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

null_conditional_operations ::=

null_conditional_operations? ? . identifier type_argument_list?
null_conditional_operations? ? [ argument_list ]
null_conditional_operations . identifier type_argument_list?
null_conditional_operations [ argument_list ]
null_conditional_operations ( argument_list? )

(Spec: Null-conditional operator)
(used in null_conditional_expression null_conditional_operations null_conditional_member_access null_conditional_invocation_expression)
Never empty
MayStartWith: ?
MayBeFollowedBy: ? . [ ( * / = += -= *= /= %= &= |= ^= <<= >>= ; % + ) , - << >> < > <= >= is as == != & ^ | && || ?? } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let where join orderby equals on into ascending descending by const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

null_conditional_member_access ::=

primary_expression null_conditional_operations? ? . identifier type_argument_list?
primary_expression null_conditional_operations . identifier type_argument_list?

(Spec: Null-conditional expressions as projection initializers)
(used in member_declarator)
Never empty
MayStartWith: new <UNDEFINED> ( this base typeof checked unchecked default nameof delegate true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: } ,

null_conditional_invocation_expression ::=

primary_expression null_conditional_operations ( argument_list? )

(Spec: Null-conditional expressions as statement expressions)
(used in statement_expression)
Never empty
MayStartWith: new <UNDEFINED> ( this base typeof checked unchecked default nameof delegate true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: ; ) ,

pre_increment_expression ::=

++ unary_expression

(Spec: Prefix increment and decrement operators)
(used in unary_expression statement_expression)
Never empty
MayStartWith: ++
MayBeFollowedBy: ; * / = += -= *= /= %= &= |= ^= <<= >>= ) , % + - << >> < > <= >= is as == != & ^ | && || ?? ? } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let where join orderby equals on into ascending descending by const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe [ object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

pre_decrement_expression ::=

-- unary_expression

(Spec: Prefix increment and decrement operators)
(used in unary_expression statement_expression)
Never empty
MayStartWith: --
MayBeFollowedBy: ; * / = += -= *= /= %= &= |= ^= <<= >>= ) , % + - << >> < > <= >= is as == != & ^ | && || ?? ? } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let where join orderby equals on into ascending descending by const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe [ object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

cast_expression ::=

( type ) unary_expression

(Spec: Cast expressions)
(used in unary_expression)
Never empty
MayStartWith: (
MayBeFollowedBy: * / = += -= *= /= %= &= |= ^= <<= >>= ; % + ) , - << >> < > <= >= is as == != & ^ | && || ?? ? } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let where join orderby equals on into ascending descending by const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe [ object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

await_expression ::=

await unary_expression

(Spec: Await expressions)
(used in unary_expression statement_expression)
Never empty
MayStartWith: await
MayBeFollowedBy: ; * / = += -= *= /= %= &= |= ^= <<= >>= ) , % + - << >> < > <= >= is as == != & ^ | && || ?? ? } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let where join orderby equals on into ascending descending by const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe [ object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

multiplicative_expression ::=

unary_expression
multiplicative_expression * unary_expression
multiplicative_expression / unary_expression
multiplicative_expression % unary_expression

(Spec: Arithmetic operators)
(used in multiplicative_expression additive_expression)
Never empty
MayStartWith: + - ! ~ new ++ -- ( await <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: * / % + - << >> < > <= >= is as == != & ^ | && || ?? ? } , <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ) ] : from select group let where join orderby equals on into ascending descending by ; const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe [ object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

additive_expression ::=

multiplicative_expression
additive_expression + multiplicative_expression
additive_expression - multiplicative_expression

(Spec: Arithmetic operators)
(used in additive_expression shift_expression)
Never empty
MayStartWith: + - ! ~ new ++ -- ( await <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: + - << >> < > <= >= is as == != & ^ | && || ?? ? } , <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ) ] : from select group let where join orderby equals on into ascending descending by ; const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe [ object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

shift_expression ::=

additive_expression
shift_expression << additive_expression
shift_expression right_shift additive_expression

(Spec: Shift operators)
(used in shift_expression relational_expression)
Never empty
MayStartWith: + - ! ~ new ++ -- ( await <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: << >> < > <= >= is as == != & ^ | && || ?? ? } , <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ) ] : from select group let where join orderby equals on into ascending descending by ; const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe [ object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

relational_expression ::=

shift_expression
relational_expression < shift_expression
relational_expression > shift_expression
relational_expression <= shift_expression
relational_expression >= shift_expression
relational_expression is type
relational_expression as type

(Spec: Relational and type-testing operators)
(used in relational_expression equality_expression)
Never empty
MayStartWith: + - ! ~ new ++ -- ( await <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: < > <= >= is as == != & ^ | && || ?? ? } , <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ) ] : from select group let where join orderby equals on into ascending descending by ; const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe [ object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

equality_expression ::=

relational_expression
equality_expression == relational_expression
equality_expression != relational_expression

(Spec: Relational and type-testing operators)
(used in equality_expression and_expression)
Never empty
MayStartWith: + - ! ~ new ++ -- ( await <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: == != & ^ | && || ?? ? } , <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ) ] : from select group let where join orderby equals on into ascending descending by ; const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe [ object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

and_expression ::=

equality_expression
and_expression & equality_expression

(Spec: Logical operators)
(used in and_expression exclusive_or_expression)
Never empty
MayStartWith: + - ! ~ new ++ -- ( await <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: & ^ | && || ?? ? } , <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ) ] : from select group let where join orderby equals on into ascending descending by ; const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe [ object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

exclusive_or_expression ::=

and_expression
exclusive_or_expression ^ and_expression

(Spec: Logical operators)
(used in exclusive_or_expression inclusive_or_expression)
Never empty
MayStartWith: + - ! ~ new ++ -- ( await <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: ^ | && || ?? ? } , <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ) ] : from select group let where join orderby equals on into ascending descending by ; const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe [ object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

inclusive_or_expression ::=

exclusive_or_expression
inclusive_or_expression | exclusive_or_expression

(Spec: Logical operators)
(used in inclusive_or_expression conditional_and_expression)
Never empty
MayStartWith: + - ! ~ new ++ -- ( await <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: | && || ?? ? } , <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ) ] : from select group let where join orderby equals on into ascending descending by ; const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe [ object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

conditional_and_expression ::=

inclusive_or_expression
conditional_and_expression && inclusive_or_expression

(Spec: Conditional logical operators)
(used in conditional_and_expression conditional_or_expression)
Never empty
MayStartWith: + - ! ~ new ++ -- ( await <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: && || ?? ? } , <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ) ] : from select group let where join orderby equals on into ascending descending by ; const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe [ object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

conditional_or_expression ::=

conditional_and_expression
conditional_or_expression || conditional_and_expression

(Spec: Conditional logical operators)
(used in conditional_or_expression null_coalescing_expression)
Never empty
MayStartWith: + - ! ~ new ++ -- ( await <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: || ?? ? } , <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ) ] : from select group let where join orderby equals on into ascending descending by ; const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe [ object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

null_coalescing_expression ::=

conditional_or_expression
conditional_or_expression ?? null_coalescing_expression

(Spec: The null coalescing operator)
(used in null_coalescing_expression conditional_expression)
Never empty
MayStartWith: + - ! ~ new ++ -- ( await <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: ? } , <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ) ] : from select group let where join orderby equals on into ascending descending by ; const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe [ object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

conditional_expression ::=

null_coalescing_expression
null_coalescing_expression ? expression : expression

(Spec: Conditional operator)
(used in non_assignment_expression)
Never empty
MayStartWith: + - ! ~ new ++ -- ( await <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: } , <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ) ] : from select group let where join orderby equals on into ascending descending by ; const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe [ object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

anonymous_method_expression ::=

delegate explicit_anonymous_function_signature? block

(Spec: Anonymous function expressions)
(used in primary_no_array_creation_expression)
Never empty
MayStartWith: delegate
MayBeFollowedBy: [ . ( ++ -- ? -> * / = += -= *= /= %= &= |= ^= <<= >>= ; % + ) , - << >> < > <= >= is as == != & ^ | && || ?? } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let where join orderby equals on into ascending descending by const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

anonymous_function_signature ::=

explicit_anonymous_function_signature
implicit_anonymous_function_signature

(Spec: Anonymous function expressions)
(used in lambda_expression)
Never empty
MayStartWith: ( @ <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: =>

explicit_anonymous_function_signature ::=

( explicit_anonymous_function_parameter_list? )

(Spec: Anonymous function expressions)
(used in anonymous_method_expression anonymous_function_signature)
Never empty
MayStartWith: (
MayBeFollowedBy: { =>

explicit_anonymous_function_parameter_list ::=

explicit_anonymous_function_parameter ( , explicit_anonymous_function_parameter )*

(Spec: Anonymous function expressions)
(used in explicit_anonymous_function_signature)
Never empty
MayStartWith: ref out object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double
MayBeFollowedBy: )

explicit_anonymous_function_parameter ::=

anonymous_function_parameter_modifier? type identifier

(Spec: Anonymous function expressions)
(used in explicit_anonymous_function_parameter_list)
Never empty
MayStartWith: ref out object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double
MayBeFollowedBy: ) ,

anonymous_function_parameter_modifier ::=

(Spec: Anonymous function expressions)
(used in explicit_anonymous_function_parameter)
Never empty
MayStartWith: ref out
MayBeFollowedBy: object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double

implicit_anonymous_function_signature ::=

( implicit_anonymous_function_parameter_list? )
implicit_anonymous_function_parameter

(Spec: Anonymous function expressions)
(used in anonymous_function_signature)
Never empty
MayStartWith: ( @ <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: =>

implicit_anonymous_function_parameter_list ::=

implicit_anonymous_function_parameter ( , implicit_anonymous_function_parameter )*

(Spec: Anonymous function expressions)
(used in implicit_anonymous_function_signature)
Never empty
MayStartWith: @ <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: )

implicit_anonymous_function_parameter ::=

identifier

(Spec: Anonymous function expressions)
(used in implicit_anonymous_function_signature implicit_anonymous_function_parameter_list)
Never empty
MayStartWith: @ <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: => ) ,

anonymous_function_body ::=

expression
block

(Spec: Anonymous function expressions)
(used in lambda_expression)
Never empty
MayStartWith: + - ! ~ { new ++ -- ( await from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: } , <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ) ] : from select group let where join orderby equals on into ascending descending by ; const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe [ object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

query_expression ::=

from_clause query_body

(Spec: Query expressions)
(used in non_assignment_expression)
Never empty
MayStartWith: from
MayBeFollowedBy: } , <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ) ] : from select group let where join orderby equals on into ascending descending by ; const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe [ object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

from_clause ::=

from type? identifier in expression

(Spec: Query expressions)
(used in query_expression query_body_clause)
Never empty
MayStartWith: from
MayBeFollowedBy: from select group let where join orderby

query_body ::=

query_body_clauses? select_or_group_clause query_continuation?

(Spec: Query expressions)
(used in query_expression query_continuation)
Never empty
MayStartWith: from select group let where join orderby
MayBeFollowedBy: } , <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ) ] : from select group let where join orderby equals on into ascending descending by ; const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe [ object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

query_body_clauses ::=

query_body_clause
query_body_clauses query_body_clause

(Spec: Query expressions)
(used in query_body query_body_clauses)
Never empty
MayStartWith: from let where join orderby
MayBeFollowedBy: select group from let where join orderby

query_body_clause ::=

from_clause
let_clause
where_clause
join_clause
join_into_clause
orderby_clause

(Spec: Query expressions)
(used in query_body_clauses)
Never empty
MayStartWith: from let where join orderby
MayBeFollowedBy: select group from let where join orderby

let_clause ::=

let identifier = expression

(Spec: Query expressions)
(used in query_body_clause)
Never empty
MayStartWith: let
MayBeFollowedBy: select group from let where join orderby

where_clause ::=

where boolean_expression

(Spec: Query expressions)
(used in query_body_clause)
Never empty
MayStartWith: where
MayBeFollowedBy: select group from let where join orderby

join_clause ::=

join type? identifier in expression on expression equals expression

(Spec: Query expressions)
(used in query_body_clause)
Never empty
MayStartWith: join
MayBeFollowedBy: select group from let where join orderby

join_into_clause ::=

join type? identifier in expression on expression equals expression into identifier

(Spec: Query expressions)
(used in query_body_clause)
Never empty
MayStartWith: join
MayBeFollowedBy: select group from let where join orderby

orderby_clause ::=

orderby orderings

(Spec: Query expressions)
(used in query_body_clause)
Never empty
MayStartWith: orderby
MayBeFollowedBy: select group from let where join orderby

orderings ::=

ordering ( , ordering )*

(Spec: Query expressions)
(used in orderby_clause)
Never empty
MayStartWith: + - ! ~ new ++ -- ( await from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: select group from let where join orderby

ordering ::=

expression ordering_direction?

(Spec: Query expressions)
(used in orderings)
Never empty
MayStartWith: + - ! ~ new ++ -- ( await from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: select group , from let where join orderby

ordering_direction ::=

ascending
descending

(Spec: Query expressions)
(used in ordering)
Never empty
MayStartWith: ascending descending
MayBeFollowedBy: select group , from let where join orderby

select_or_group_clause ::=

select_clause
group_clause

(Spec: Query expressions)
(used in query_body)
Never empty
MayStartWith: select group
MayBeFollowedBy: into } , <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ) ] : from select group let where join orderby equals on ascending descending by ; const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe [ object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

select_clause ::=

select expression

(Spec: Query expressions)
(used in select_or_group_clause)
Never empty
MayStartWith: select
MayBeFollowedBy: into } , <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ) ] : from select group let where join orderby equals on ascending descending by ; const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe [ object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

group_clause ::=

group expression by expression

(Spec: Query expressions)
(used in select_or_group_clause)
Never empty
MayStartWith: group
MayBeFollowedBy: into } , <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ) ] : from select group let where join orderby equals on ascending descending by ; const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe [ object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

query_continuation ::=

into identifier query_body

(Spec: Query expressions)
(used in query_body)
Never empty
MayStartWith: into
MayBeFollowedBy: } , <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ) ] : from select group let where join orderby equals on into ascending descending by ; const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe [ object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

assignment ::=

unary_expression assignment_operator expression

(Spec: Assignment operators)
(used in expression statement_expression)
Never empty
MayStartWith: + - ! ~ new ++ -- ( await <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: , } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ) ] : from select group let where join orderby equals on into ascending descending by ; const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe [ object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

assignment_operator ::=

=
+=
-=
*=
/=
%=
&=
|=
^=
<<=
right_shift_assignment

(Spec: Assignment operators)
(used in assignment)
Never empty
MayStartWith: = += -= *= /= %= &= |= ^= <<= >>=
MayBeFollowedBy: + - ! ~ new ++ -- ( await from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>

expression ::=

non_assignment_expression
assignment

(Spec: Expression)
(used in variable_reference argument_value interpolation parenthesized_expression initializer_value expression_list delegate_creation_expression member_declarator checked_expression unchecked_expression conditional_expression anonymous_function_body from_clause let_clause join_clause join_into_clause ordering select_clause group_clause assignment constant_expression boolean_expression local_variable_initializer switch_statement foreach_statement return_statement throw_statement exception_filter lock_statement resource_acquisition yield_statement variable_initializer method_body default_argument property_body indexer_body operator_body attribute_argument_expression pointer_element_access fixed_pointer_initializer stackalloc_initializer)
Never empty
MayStartWith: + - ! ~ new ++ -- ( await from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: , } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ) ] : from select group let where join orderby equals on into ascending descending by ; const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe [ object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

non_assignment_expression ::=

conditional_expression
lambda_expression
query_expression

(Spec: Expression)
(used in element_initializer expression)
Never empty
MayStartWith: + - ! ~ new ++ -- ( await from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: } , <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ) ] : from select group let where join orderby equals on into ascending descending by ; const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe [ object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

constant_expression ::=

expression

(Spec: Constant expressions)
(used in interpolation constant_declarator switch_label goto_statement enum_member_declaration fixed_size_buffer_declarator)
Never empty
MayStartWith: + - ! ~ new ++ -- ( await from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ; , : ]

boolean_expression ::=

expression

(Spec: Boolean expressions)
(used in where_clause if_statement while_statement do_statement for_condition)
Never empty
MayStartWith: + - ! ~ new ++ -- ( await from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: select group ) ; from let where join orderby

statement ::=

labeled_statement
declaration_statement
embedded_statement

(Spec: Statements)
(used in statement_list labeled_statement)
Never empty
MayStartWith: @ const { ; try checked unchecked lock using yield <An identifier_or_keyword that is not a keyword> var new + - ! ~ ++ -- await if switch while do for foreach break continue goto return throw unsafe fixed ( object dynamic string void <UNDEFINED> this base typeof default nameof delegate * & bool true false 0 1 2 3 4 5 6 7 8 9 . ' null byte char decimal double float int long sbyte short uint ulong ushort sizeof 0x 0X " @"
MayBeFollowedBy: } @ const { ; try checked unchecked lock using yield <An identifier_or_keyword that is not a keyword> var new + - ! ~ ++ -- await if switch while do for foreach break continue goto return throw unsafe fixed ( object dynamic string void <UNDEFINED> this base typeof default nameof delegate * & bool true false 0 1 2 3 4 5 6 7 8 9 . ' null byte char decimal double float int long sbyte short uint ulong ushort sizeof 0x 0X " @" case

embedded_statement ::=

block
empty_statement
expression_statement
selection_statement
iteration_statement
jump_statement
try_statement
checked_statement
unchecked_statement
lock_statement
using_statement
yield_statement
embedded_statement_unsafe

(Spec: Statements)
(used in statement if_statement while_statement do_statement for_statement foreach_statement lock_statement using_statement fixed_statement)
Never empty
MayStartWith: { ; try checked unchecked lock using yield new + - ! ~ ++ -- await if switch while do for foreach break continue goto return throw unsafe fixed ( <UNDEFINED> this base typeof default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: else while } @ const { ; try checked unchecked lock using yield <An identifier_or_keyword that is not a keyword> var new + - ! ~ ++ -- await if switch do for foreach break continue goto return throw unsafe fixed ( object dynamic string void <UNDEFINED> this base typeof default nameof delegate * & bool true false 0 1 2 3 4 5 6 7 8 9 . ' null byte char decimal double float int long sbyte short uint ulong ushort sizeof 0x 0X " @" case

block ::=

{ statement_list? }

(Spec: Blocks)
(used in anonymous_method_expression anonymous_function_body embedded_statement try_statement catch_clause finally_clause checked_statement unchecked_statement method_body accessor_body add_accessor_declaration remove_accessor_declaration operator_body constructor_body static_constructor_body destructor_body unsafe_statement)
Never empty
MayStartWith: {
MayBeFollowedBy: catch finally } const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe [ object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double set get remove add . ( ++ -- ? -> , <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ) ] : from select group let where join orderby equals on into ascending descending by else while { ; try checked unchecked lock using yield var + - ! await if switch do for foreach break continue goto return throw fixed <UNDEFINED> this base typeof default nameof * & true false 0 1 2 3 4 5 6 7 8 9 ' null sizeof 0x 0X " @" / = += -= *= /= %= &= |= ^= <<= >>= case % << >> < > <= >= is as == != ^ | && || ??

statement_list ::=

statement+

(Spec: Statement lists)
(used in block switch_section)
Never empty
MayStartWith: @ const { ; try checked unchecked lock using yield <An identifier_or_keyword that is not a keyword> var new + - ! ~ ++ -- await if switch while do for foreach break continue goto return throw unsafe fixed ( object dynamic string void <UNDEFINED> this base typeof default nameof delegate * & bool true false 0 1 2 3 4 5 6 7 8 9 . ' null byte char decimal double float int long sbyte short uint ulong ushort sizeof 0x 0X " @"
MayBeFollowedBy: } case default

empty_statement ::=

;

(Spec: The empty statement)
(used in embedded_statement)
Never empty
MayStartWith: ;
MayBeFollowedBy: else while } @ const { ; try checked unchecked lock using yield <An identifier_or_keyword that is not a keyword> var new + - ! ~ ++ -- await if switch do for foreach break continue goto return throw unsafe fixed ( object dynamic string void <UNDEFINED> this base typeof default nameof delegate * & bool true false 0 1 2 3 4 5 6 7 8 9 . ' null byte char decimal double float int long sbyte short uint ulong ushort sizeof 0x 0X " @" case

labeled_statement ::=

identifier : statement

(Spec: Labeled statements)
(used in statement)
Never empty
MayStartWith: @ <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: } @ const { ; try checked unchecked lock using yield <An identifier_or_keyword that is not a keyword> var new + - ! ~ ++ -- await if switch while do for foreach break continue goto return throw unsafe fixed ( object dynamic string void <UNDEFINED> this base typeof default nameof delegate * & bool true false 0 1 2 3 4 5 6 7 8 9 . ' null byte char decimal double float int long sbyte short uint ulong ushort sizeof 0x 0X " @" case

declaration_statement ::=

local_variable_declaration ;
local_constant_declaration ;

(Spec: Declaration statements)
(used in statement)
Never empty
MayStartWith: const var object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double
MayBeFollowedBy: } @ const { ; try checked unchecked lock using yield <An identifier_or_keyword that is not a keyword> var new + - ! ~ ++ -- await if switch while do for foreach break continue goto return throw unsafe fixed ( object dynamic string void <UNDEFINED> this base typeof default nameof delegate * & bool true false 0 1 2 3 4 5 6 7 8 9 . ' null byte char decimal double float int long sbyte short uint ulong ushort sizeof 0x 0X " @" case

local_variable_declaration ::=

local_variable_type local_variable_declarators

(Spec: Local variable declarations)
(used in declaration_statement for_initializer resource_acquisition)
Never empty
MayStartWith: var object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double
MayBeFollowedBy: ; )

local_variable_type ::=

type
var

(Spec: Local variable declarations)
(used in local_variable_declaration foreach_statement)
Never empty
MayStartWith: var object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double
MayBeFollowedBy: @ <An identifier_or_keyword that is not a keyword>

local_variable_declarators ::=

local_variable_declarator
local_variable_declarators , local_variable_declarator

(Spec: Local variable declarations)
(used in local_variable_declaration local_variable_declarators)
Never empty
MayStartWith: @ <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: ; , )

local_variable_declarator ::=

identifier
identifier = local_variable_initializer

(Spec: Local variable declarations)
(used in local_variable_declarators)
Never empty
MayStartWith: @ <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: ; , )

local_variable_initializer ::=

expression
array_initializer
local_variable_initializer_unsafe

(Spec: Local variable declarations)
(used in local_variable_declarator)
Never empty
MayStartWith: + - ! ~ new ++ -- ( await { from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & stackalloc true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: ; , )

local_constant_declaration ::=

const type constant_declarators

(Spec: Local constant declarations)
(used in declaration_statement)
Never empty
MayStartWith: const
MayBeFollowedBy: ;

constant_declarators ::=

constant_declarator ( , constant_declarator )*

(Spec: Local constant declarations)
(used in local_constant_declaration constant_declaration)
Never empty
MayStartWith: @ <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: ;

constant_declarator ::=

identifier = constant_expression

(Spec: Local constant declarations)
(used in constant_declarators)
Never empty
MayStartWith: @ <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: ; ,

expression_statement ::=

statement_expression ;

(Spec: Expression statements)
(used in embedded_statement)
Never empty
MayStartWith: new + - ! ~ ++ -- await ( <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: else while } @ const { ; try checked unchecked lock using yield <An identifier_or_keyword that is not a keyword> var new + - ! ~ ++ -- await if switch do for foreach break continue goto return throw unsafe fixed ( object dynamic string void <UNDEFINED> this base typeof default nameof delegate * & bool true false 0 1 2 3 4 5 6 7 8 9 . ' null byte char decimal double float int long sbyte short uint ulong ushort sizeof 0x 0X " @" case

statement_expression ::=

invocation_expression
null_conditional_invocation_expression
object_creation_expression
assignment
post_increment_expression
post_decrement_expression
pre_increment_expression
pre_decrement_expression
await_expression

(Spec: Expression statements)
(used in expression_statement statement_expression_list)
Never empty
MayStartWith: new + - ! ~ ++ -- await ( <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: ; ) ,

selection_statement ::=

if_statement
switch_statement

(Spec: Selection statements)
(used in embedded_statement)
Never empty
MayStartWith: if switch
MayBeFollowedBy: else while } @ const { ; try checked unchecked lock using yield <An identifier_or_keyword that is not a keyword> var new + - ! ~ ++ -- await if switch do for foreach break continue goto return throw unsafe fixed ( object dynamic string void <UNDEFINED> this base typeof default nameof delegate * & bool true false 0 1 2 3 4 5 6 7 8 9 . ' null byte char decimal double float int long sbyte short uint ulong ushort sizeof 0x 0X " @" case

if_statement ::=

if ( boolean_expression ) embedded_statement
if ( boolean_expression ) embedded_statement else embedded_statement

(Spec: The if statement)
(used in selection_statement)
Never empty
MayStartWith: if
MayBeFollowedBy: else while } @ const { ; try checked unchecked lock using yield <An identifier_or_keyword that is not a keyword> var new + - ! ~ ++ -- await if switch do for foreach break continue goto return throw unsafe fixed ( object dynamic string void <UNDEFINED> this base typeof default nameof delegate * & bool true false 0 1 2 3 4 5 6 7 8 9 . ' null byte char decimal double float int long sbyte short uint ulong ushort sizeof 0x 0X " @" case

switch_statement ::=

switch ( expression ) switch_block

(Spec: The switch statement)
(used in selection_statement)
Never empty
MayStartWith: switch
MayBeFollowedBy: else while } @ const { ; try checked unchecked lock using yield <An identifier_or_keyword that is not a keyword> var new + - ! ~ ++ -- await if switch do for foreach break continue goto return throw unsafe fixed ( object dynamic string void <UNDEFINED> this base typeof default nameof delegate * & bool true false 0 1 2 3 4 5 6 7 8 9 . ' null byte char decimal double float int long sbyte short uint ulong ushort sizeof 0x 0X " @" case

switch_block ::=

{ switch_section* }

(Spec: The switch statement)
(used in switch_statement)
Never empty
MayStartWith: {
MayBeFollowedBy: else while } @ const { ; try checked unchecked lock using yield <An identifier_or_keyword that is not a keyword> var new + - ! ~ ++ -- await if switch do for foreach break continue goto return throw unsafe fixed ( object dynamic string void <UNDEFINED> this base typeof default nameof delegate * & bool true false 0 1 2 3 4 5 6 7 8 9 . ' null byte char decimal double float int long sbyte short uint ulong ushort sizeof 0x 0X " @" case

switch_section ::=

switch_label+ statement_list

(Spec: The switch statement)
(used in switch_block)
Never empty
MayStartWith: case default
MayBeFollowedBy: } case default

switch_label ::=

case constant_expression :
default :

(Spec: The switch statement)
(used in switch_section)
Never empty
MayStartWith: case default
MayBeFollowedBy: @ const { ; try checked unchecked lock using yield <An identifier_or_keyword that is not a keyword> var new + - ! ~ ++ -- await if switch while do for foreach break continue goto return throw unsafe fixed ( object dynamic string void <UNDEFINED> this base typeof default nameof delegate * & bool true false 0 1 2 3 4 5 6 7 8 9 . ' null byte char decimal double float int long sbyte short uint ulong ushort sizeof 0x 0X " @" case

iteration_statement ::=

while_statement
do_statement
for_statement
foreach_statement

(Spec: Iteration statements)
(used in embedded_statement)
Never empty
MayStartWith: while do for foreach
MayBeFollowedBy: else while } @ const { ; try checked unchecked lock using yield <An identifier_or_keyword that is not a keyword> var new + - ! ~ ++ -- await if switch do for foreach break continue goto return throw unsafe fixed ( object dynamic string void <UNDEFINED> this base typeof default nameof delegate * & bool true false 0 1 2 3 4 5 6 7 8 9 . ' null byte char decimal double float int long sbyte short uint ulong ushort sizeof 0x 0X " @" case

while_statement ::=

while ( boolean_expression ) embedded_statement

(Spec: The while statement)
(used in iteration_statement)
Never empty
MayStartWith: while
MayBeFollowedBy: else while } @ const { ; try checked unchecked lock using yield <An identifier_or_keyword that is not a keyword> var new + - ! ~ ++ -- await if switch do for foreach break continue goto return throw unsafe fixed ( object dynamic string void <UNDEFINED> this base typeof default nameof delegate * & bool true false 0 1 2 3 4 5 6 7 8 9 . ' null byte char decimal double float int long sbyte short uint ulong ushort sizeof 0x 0X " @" case

do_statement ::=

do embedded_statement while ( boolean_expression ) ;

(Spec: The do statement)
(used in iteration_statement)
Never empty
MayStartWith: do
MayBeFollowedBy: else while } @ const { ; try checked unchecked lock using yield <An identifier_or_keyword that is not a keyword> var new + - ! ~ ++ -- await if switch do for foreach break continue goto return throw unsafe fixed ( object dynamic string void <UNDEFINED> this base typeof default nameof delegate * & bool true false 0 1 2 3 4 5 6 7 8 9 . ' null byte char decimal double float int long sbyte short uint ulong ushort sizeof 0x 0X " @" case

for_statement ::=

for ( for_initializer? ; for_condition? ; for_iterator? ) embedded_statement

(Spec: The for statement)
(used in iteration_statement)
Never empty
MayStartWith: for
MayBeFollowedBy: else while } @ const { ; try checked unchecked lock using yield <An identifier_or_keyword that is not a keyword> var new + - ! ~ ++ -- await if switch do for foreach break continue goto return throw unsafe fixed ( object dynamic string void <UNDEFINED> this base typeof default nameof delegate * & bool true false 0 1 2 3 4 5 6 7 8 9 . ' null byte char decimal double float int long sbyte short uint ulong ushort sizeof 0x 0X " @" case

for_initializer ::=

local_variable_declaration
statement_expression_list

(Spec: The for statement)
(used in for_statement)
Never empty
MayStartWith: var new + - ! ~ ++ -- await ( object dynamic string @ void <UNDEFINED> this base typeof checked unchecked default nameof delegate * & bool <An identifier_or_keyword that is not a keyword> true false 0 1 2 3 4 5 6 7 8 9 . ' null byte char decimal double float int long sbyte short uint ulong ushort sizeof 0x 0X " @"
MayBeFollowedBy: ;

for_condition ::=

boolean_expression

(Spec: The for statement)
(used in for_statement)
Never empty
MayStartWith: + - ! ~ new ++ -- ( await from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: ;

for_iterator ::=

statement_expression_list

(Spec: The for statement)
(used in for_statement)
Never empty
MayStartWith: new + - ! ~ ++ -- await ( <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: )

statement_expression_list ::=

statement_expression ( , statement_expression )*

(Spec: The for statement)
(used in for_initializer for_iterator)
Never empty
MayStartWith: new + - ! ~ ++ -- await ( <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: ; )

foreach_statement ::=

foreach ( local_variable_type identifier in expression ) embedded_statement

(Spec: The foreach statement)
(used in iteration_statement)
Never empty
MayStartWith: foreach
MayBeFollowedBy: else while } @ const { ; try checked unchecked lock using yield <An identifier_or_keyword that is not a keyword> var new + - ! ~ ++ -- await if switch do for foreach break continue goto return throw unsafe fixed ( object dynamic string void <UNDEFINED> this base typeof default nameof delegate * & bool true false 0 1 2 3 4 5 6 7 8 9 . ' null byte char decimal double float int long sbyte short uint ulong ushort sizeof 0x 0X " @" case

jump_statement ::=

break_statement
continue_statement
goto_statement
return_statement
throw_statement

(Spec: Jump statements)
(used in embedded_statement)
Never empty
MayStartWith: break continue goto return throw
MayBeFollowedBy: else while } @ const { ; try checked unchecked lock using yield <An identifier_or_keyword that is not a keyword> var new + - ! ~ ++ -- await if switch do for foreach break continue goto return throw unsafe fixed ( object dynamic string void <UNDEFINED> this base typeof default nameof delegate * & bool true false 0 1 2 3 4 5 6 7 8 9 . ' null byte char decimal double float int long sbyte short uint ulong ushort sizeof 0x 0X " @" case

break_statement ::=

break ;

(Spec: The break statement)
(used in jump_statement)
Never empty
MayStartWith: break
MayBeFollowedBy: else while } @ const { ; try checked unchecked lock using yield <An identifier_or_keyword that is not a keyword> var new + - ! ~ ++ -- await if switch do for foreach break continue goto return throw unsafe fixed ( object dynamic string void <UNDEFINED> this base typeof default nameof delegate * & bool true false 0 1 2 3 4 5 6 7 8 9 . ' null byte char decimal double float int long sbyte short uint ulong ushort sizeof 0x 0X " @" case

continue_statement ::=

continue ;

(Spec: The continue statement)
(used in jump_statement)
Never empty
MayStartWith: continue
MayBeFollowedBy: else while } @ const { ; try checked unchecked lock using yield <An identifier_or_keyword that is not a keyword> var new + - ! ~ ++ -- await if switch do for foreach break continue goto return throw unsafe fixed ( object dynamic string void <UNDEFINED> this base typeof default nameof delegate * & bool true false 0 1 2 3 4 5 6 7 8 9 . ' null byte char decimal double float int long sbyte short uint ulong ushort sizeof 0x 0X " @" case

goto_statement ::=

goto identifier ;
goto case constant_expression ;
goto default ;

(Spec: The goto statement)
(used in jump_statement)
Never empty
MayStartWith: goto
MayBeFollowedBy: else while } @ const { ; try checked unchecked lock using yield <An identifier_or_keyword that is not a keyword> var new + - ! ~ ++ -- await if switch do for foreach break continue goto return throw unsafe fixed ( object dynamic string void <UNDEFINED> this base typeof default nameof delegate * & bool true false 0 1 2 3 4 5 6 7 8 9 . ' null byte char decimal double float int long sbyte short uint ulong ushort sizeof 0x 0X " @" case

return_statement ::=

return expression? ;

(Spec: The return statement)
(used in jump_statement)
Never empty
MayStartWith: return
MayBeFollowedBy: else while } @ const { ; try checked unchecked lock using yield <An identifier_or_keyword that is not a keyword> var new + - ! ~ ++ -- await if switch do for foreach break continue goto return throw unsafe fixed ( object dynamic string void <UNDEFINED> this base typeof default nameof delegate * & bool true false 0 1 2 3 4 5 6 7 8 9 . ' null byte char decimal double float int long sbyte short uint ulong ushort sizeof 0x 0X " @" case

throw_statement ::=

throw expression? ;

(Spec: The throw statement)
(used in jump_statement)
Never empty
MayStartWith: throw
MayBeFollowedBy: else while } @ const { ; try checked unchecked lock using yield <An identifier_or_keyword that is not a keyword> var new + - ! ~ ++ -- await if switch do for foreach break continue goto return throw unsafe fixed ( object dynamic string void <UNDEFINED> this base typeof default nameof delegate * & bool true false 0 1 2 3 4 5 6 7 8 9 . ' null byte char decimal double float int long sbyte short uint ulong ushort sizeof 0x 0X " @" case

try_statement ::=

try block catch_clause+
try block finally_clause
try block catch_clause+ finally_clause

(Spec: The try statement)
(used in embedded_statement)
Never empty
MayStartWith: try
MayBeFollowedBy: else while } @ const { ; try checked unchecked lock using yield <An identifier_or_keyword that is not a keyword> var new + - ! ~ ++ -- await if switch do for foreach break continue goto return throw unsafe fixed ( object dynamic string void <UNDEFINED> this base typeof default nameof delegate * & bool true false 0 1 2 3 4 5 6 7 8 9 . ' null byte char decimal double float int long sbyte short uint ulong ushort sizeof 0x 0X " @" case

catch_clause ::=

catch exception_specifier? exception_filter? block

(Spec: The try statement)
(used in try_statement)
Never empty
MayStartWith: catch
MayBeFollowedBy: catch finally else while } @ const { ; try checked unchecked lock using yield <An identifier_or_keyword that is not a keyword> var new + - ! ~ ++ -- await if switch do for foreach break continue goto return throw unsafe fixed ( object dynamic string void <UNDEFINED> this base typeof default nameof delegate * & bool true false 0 1 2 3 4 5 6 7 8 9 . ' null byte char decimal double float int long sbyte short uint ulong ushort sizeof 0x 0X " @" case

exception_specifier ::=

( type identifier? )

(Spec: The try statement)
(used in catch_clause)
Never empty
MayStartWith: (
MayBeFollowedBy: { when

exception_filter ::=

when ( expression )

(Spec: The try statement)
(used in catch_clause)
Never empty
MayStartWith: when
MayBeFollowedBy: {

finally_clause ::=

finally block

(Spec: The try statement)
(used in try_statement)
Never empty
MayStartWith: finally
MayBeFollowedBy: else while } @ const { ; try checked unchecked lock using yield <An identifier_or_keyword that is not a keyword> var new + - ! ~ ++ -- await if switch do for foreach break continue goto return throw unsafe fixed ( object dynamic string void <UNDEFINED> this base typeof default nameof delegate * & bool true false 0 1 2 3 4 5 6 7 8 9 . ' null byte char decimal double float int long sbyte short uint ulong ushort sizeof 0x 0X " @" case

checked_statement ::=

checked block

(Spec: The checked and unchecked statements)
(used in embedded_statement)
Never empty
MayStartWith: checked
MayBeFollowedBy: else while } @ const { ; try checked unchecked lock using yield <An identifier_or_keyword that is not a keyword> var new + - ! ~ ++ -- await if switch do for foreach break continue goto return throw unsafe fixed ( object dynamic string void <UNDEFINED> this base typeof default nameof delegate * & bool true false 0 1 2 3 4 5 6 7 8 9 . ' null byte char decimal double float int long sbyte short uint ulong ushort sizeof 0x 0X " @" case

unchecked_statement ::=

unchecked block

(Spec: The checked and unchecked statements)
(used in embedded_statement)
Never empty
MayStartWith: unchecked
MayBeFollowedBy: else while } @ const { ; try checked unchecked lock using yield <An identifier_or_keyword that is not a keyword> var new + - ! ~ ++ -- await if switch do for foreach break continue goto return throw unsafe fixed ( object dynamic string void <UNDEFINED> this base typeof default nameof delegate * & bool true false 0 1 2 3 4 5 6 7 8 9 . ' null byte char decimal double float int long sbyte short uint ulong ushort sizeof 0x 0X " @" case

lock_statement ::=

lock ( expression ) embedded_statement

(Spec: The lock statement)
(used in embedded_statement)
Never empty
MayStartWith: lock
MayBeFollowedBy: else while } @ const { ; try checked unchecked lock using yield <An identifier_or_keyword that is not a keyword> var new + - ! ~ ++ -- await if switch do for foreach break continue goto return throw unsafe fixed ( object dynamic string void <UNDEFINED> this base typeof default nameof delegate * & bool true false 0 1 2 3 4 5 6 7 8 9 . ' null byte char decimal double float int long sbyte short uint ulong ushort sizeof 0x 0X " @" case

using_statement ::=

using ( resource_acquisition ) embedded_statement

(Spec: The using statement)
(used in embedded_statement)
Never empty
MayStartWith: using
MayBeFollowedBy: else while } @ const { ; try checked unchecked lock using yield <An identifier_or_keyword that is not a keyword> var new + - ! ~ ++ -- await if switch do for foreach break continue goto return throw unsafe fixed ( object dynamic string void <UNDEFINED> this base typeof default nameof delegate * & bool true false 0 1 2 3 4 5 6 7 8 9 . ' null byte char decimal double float int long sbyte short uint ulong ushort sizeof 0x 0X " @" case

resource_acquisition ::=

local_variable_declaration
expression

(Spec: The using statement)
(used in using_statement)
Never empty
MayStartWith: + - ! ~ var new ++ -- ( await from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & object dynamic string @ void true false 0 1 2 3 4 5 6 7 8 9 . ' null bool byte char decimal double float int long sbyte short uint ulong ushort sizeof <An identifier_or_keyword that is not a keyword> 0x 0X " @"
MayBeFollowedBy: )

yield_statement ::=

yield return expression ;
yield break ;

(Spec: The yield statement)
(used in embedded_statement)
Never empty
MayStartWith: yield
MayBeFollowedBy: else while } @ const { ; try checked unchecked lock using yield <An identifier_or_keyword that is not a keyword> var new + - ! ~ ++ -- await if switch do for foreach break continue goto return throw unsafe fixed ( object dynamic string void <UNDEFINED> this base typeof default nameof delegate * & bool true false 0 1 2 3 4 5 6 7 8 9 . ' null byte char decimal double float int long sbyte short uint ulong ushort sizeof 0x 0X " @" case

class_declaration ::=

attributes? class_modifier* partial? class identifier type_parameter_list? class_base? type_parameter_constraints_clause* class_body ;?

(Spec: Class declarations)
(used in type_declaration)
Never empty
MayStartWith: partial class new public protected internal private abstract sealed static [ unsafe
MayBeFollowedBy: namespace partial class struct interface enum delegate new public protected internal private abstract sealed static [ unsafe } const event extern ~ readonly volatile virtual override object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

class_modifier ::=

new
public
protected
internal
private
abstract
sealed
static
class_modifier_unsafe

(Spec: Class modifiers)
(used in class_declaration)
Never empty
MayStartWith: new public protected internal private abstract sealed static unsafe
MayBeFollowedBy: class partial new public protected internal private abstract sealed static unsafe

type_parameter_list ::=

< type_parameters >

(Spec: Type parameters)
(used in class_declaration method_header struct_declaration interface_method_declaration)
Never empty
MayStartWith: <
MayBeFollowedBy: { where : (

type_parameters ::=

attributes? type_parameter
type_parameters , attributes? type_parameter

(Spec: Type parameters)
(used in type_parameter_list type_parameters)
Never empty
MayStartWith: @ [ <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: > ,

class_base ::=

: class_type
: interface_type_list
: class_type , interface_type_list

(Spec: Class base specification)
(used in class_declaration)
Never empty
MayStartWith: :
MayBeFollowedBy: { where

interface_type_list ::=

interface_type ( , interface_type )*

(Spec: Class base specification)
(used in class_base struct_interfaces interface_base)
Never empty
MayStartWith: @ <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: { where

type_parameter_constraints_clause ::=

where type_parameter : type_parameter_constraints

(Spec: Type parameter constraints)
(used in class_declaration method_header struct_declaration interface_declaration interface_method_declaration delegate_declaration)
Never empty
MayStartWith: where
MayBeFollowedBy: { where => ;

type_parameter_constraints ::=

primary_constraint
secondary_constraints
constructor_constraint
primary_constraint , secondary_constraints
primary_constraint , constructor_constraint
secondary_constraints , constructor_constraint
primary_constraint , secondary_constraints , constructor_constraint

(Spec: Type parameter constraints)
(used in type_parameter_constraints_clause)
Never empty
MayStartWith: object dynamic string class struct new @ <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: { where => ;

primary_constraint ::=

class_type
class
struct

(Spec: Type parameter constraints)
(used in type_parameter_constraints)
Never empty
MayStartWith: object dynamic string class struct @ <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: { where , => ;

secondary_constraints ::=

interface_type
type_parameter
secondary_constraints , interface_type
secondary_constraints , type_parameter

(Spec: Type parameter constraints)
(used in type_parameter_constraints secondary_constraints)
Never empty
MayStartWith: @ <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: { where , => ;

constructor_constraint ::=

new ( )

(Spec: Type parameter constraints)
(used in type_parameter_constraints)
Never empty
MayStartWith: new
MayBeFollowedBy: { where => ;

class_body ::=

{ class_member_declaration* }

(Spec: Class body)
(used in class_declaration)
Never empty
MayStartWith: {
MayBeFollowedBy: namespace partial class struct interface enum delegate new public protected internal private abstract sealed static [ unsafe } ; const event extern ~ readonly volatile virtual override object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

class_member_declaration ::=

constant_declaration
field_declaration
method_declaration
property_declaration
event_declaration
indexer_declaration
operator_declaration
constructor_declaration
destructor_declaration
static_constructor_declaration
type_declaration

(Spec: Class members)
(used in class_body)
Never empty
MayStartWith: const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe [ object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double
MayBeFollowedBy: } const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe [ object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double

constant_declaration ::=

attributes? constant_modifier* const type constant_declarators ;

(Spec: Constants)
(used in class_member_declaration struct_member_declaration)
Never empty
MayStartWith: const new public protected internal private [
MayBeFollowedBy: } const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe [ object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

constant_modifier ::=

new
public
protected
internal
private

(Spec: Constants)
(used in constant_declaration)
Never empty
MayStartWith: new public protected internal private
MayBeFollowedBy: const new public protected internal private

field_declaration ::=

attributes? field_modifier* type variable_declarators ;

(Spec: Fields)
(used in class_member_declaration struct_member_declaration)
Never empty
MayStartWith: new public protected internal private static readonly volatile [ unsafe object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double
MayBeFollowedBy: } const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe [ object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

field_modifier ::=

new
public
protected
internal
private
static
readonly
volatile
field_modifier_unsafe

(Spec: Fields)
(used in field_declaration)
Never empty
MayStartWith: new public protected internal private static readonly volatile unsafe
MayBeFollowedBy: object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double new public protected internal private static readonly volatile unsafe

variable_declarators ::=

variable_declarator ( , variable_declarator )*

(Spec: Fields)
(used in field_declaration event_declaration)
Never empty
MayStartWith: @ <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: ;

variable_declarator ::=

identifier ( = variable_initializer )?

(Spec: Fields)
(used in variable_declarators)
Never empty
MayStartWith: @ <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: ; ,

variable_initializer ::=

expression
array_initializer

(Spec: Fields)
(used in variable_declarator property_initializer variable_initializer_list)
Never empty
MayStartWith: + - ! ~ new ++ -- ( await { from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: ; , } const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe [ object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

method_declaration ::=

method_header method_body

(Spec: Methods)
(used in class_member_declaration struct_member_declaration)
Never empty
MayStartWith: partial new public protected internal private static virtual sealed override abstract extern void [ unsafe object dynamic string @ bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double
MayBeFollowedBy: } const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe [ object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

method_header ::=

attributes? method_modifier* partial? return_type member_name type_parameter_list? ( formal_parameter_list? ) type_parameter_constraints_clause*

(Spec: Methods)
(used in method_declaration)
Never empty
MayStartWith: partial new public protected internal private static virtual sealed override abstract extern void [ unsafe object dynamic string @ bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double
MayBeFollowedBy: { => ;

method_modifier ::=

new
public
protected
internal
private
static
virtual
sealed
override
abstract
extern
method_modifier_unsafe

(Spec: Methods)
(used in method_header)
Never empty
MayStartWith: new public protected internal private static virtual sealed override abstract extern unsafe
MayBeFollowedBy: void object dynamic string @ bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double partial new public protected internal private static virtual sealed override abstract extern unsafe

return_type ::=

type
void

(Spec: Methods)
(used in method_header interface_method_declaration delegate_declaration)
Never empty
MayStartWith: void object dynamic string @ bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double
MayBeFollowedBy: @ <An identifier_or_keyword that is not a keyword>

member_name ::=

identifier
interface_type . identifier

(Spec: Methods)
(used in method_header property_declaration event_declaration)
Never empty
MayStartWith: @ <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: ( < { =>

method_body ::=

block
=> expression ;
;

(Spec: Methods)
(used in method_declaration)
Never empty
MayStartWith: { => ;
MayBeFollowedBy: } const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe [ object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

formal_parameter_list ::=

fixed_parameters
fixed_parameters , parameter_array
parameter_array

(Spec: Method parameters)
(used in method_header indexer_declarator constructor_declarator interface_method_declaration interface_indexer_declaration delegate_declaration)
Never empty
MayStartWith: params ref out this [ object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double
MayBeFollowedBy: ) ]

fixed_parameters ::=

fixed_parameter ( , fixed_parameter )*

(Spec: Method parameters)
(used in formal_parameter_list)
Never empty
MayStartWith: ref out this [ object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double
MayBeFollowedBy: ) , ]

fixed_parameter ::=

attributes? parameter_modifier? type identifier default_argument?

(Spec: Method parameters)
(used in fixed_parameters)
Never empty
MayStartWith: ref out this [ object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double
MayBeFollowedBy: ) , ]

default_argument ::=

= expression

(Spec: Method parameters)
(used in fixed_parameter)
Never empty
MayStartWith: =
MayBeFollowedBy: ) , ]

parameter_modifier ::=

ref
out
this

(Spec: Method parameters)
(used in fixed_parameter)
Never empty
MayStartWith: ref out this
MayBeFollowedBy: object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double

parameter_array ::=

attributes? params array_type identifier

(Spec: Method parameters)
(used in formal_parameter_list)
Never empty
MayStartWith: params [
MayBeFollowedBy: ) ]

property_modifier ::=

new
public
protected
internal
private
static
virtual
sealed
override
abstract
extern
property_modifier_unsafe

(Spec: Properties)
(used in property_declaration)
Never empty
MayStartWith: new public protected internal private static virtual sealed override abstract extern unsafe
MayBeFollowedBy: object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double new public protected internal private static virtual sealed override abstract extern unsafe

property_body ::=

{ accessor_declarations } property_initializer?
=> expression ;

(Spec: Properties)
(used in property_declaration)
Never empty
MayStartWith: { =>
MayBeFollowedBy: } const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe [ object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

property_initializer ::=

= variable_initializer

(Spec: Properties)
(used in property_body)
Never empty
MayStartWith: =
MayBeFollowedBy: } const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe [ object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

accessor_declarations ::=

get_accessor_declaration set_accessor_declaration?
set_accessor_declaration get_accessor_declaration?

(Spec: Accessors)
(used in property_body indexer_body)
Never empty
MayStartWith: get set protected internal private [
MayBeFollowedBy: }

get_accessor_declaration ::=

attributes? accessor_modifier? get accessor_body

(Spec: Accessors)
(used in accessor_declarations)
Never empty
MayStartWith: get protected internal private [
MayBeFollowedBy: } set protected internal private [

set_accessor_declaration ::=

attributes? accessor_modifier? set accessor_body

(Spec: Accessors)
(used in accessor_declarations)
Never empty
MayStartWith: set protected internal private [
MayBeFollowedBy: } get protected internal private [

accessor_modifier ::=

protected
internal
private
protected internal
internal protected

(Spec: Accessors)
(used in get_accessor_declaration set_accessor_declaration)
Never empty
MayStartWith: protected internal private
MayBeFollowedBy: get set

accessor_body ::=

block
;

(Spec: Accessors)
(used in get_accessor_declaration set_accessor_declaration)
Never empty
MayStartWith: { ;
MayBeFollowedBy: } set protected internal private [ get

event_declaration ::=

attributes? event_modifier* event type variable_declarators ;
attributes? event_modifier* event type member_name { event_accessor_declarations }

(Spec: Events)
(used in class_member_declaration struct_member_declaration)
Never empty
MayStartWith: event new public protected internal private static virtual sealed override abstract extern [ unsafe
MayBeFollowedBy: } const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe [ object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

event_modifier ::=

new
public
protected
internal
private
static
virtual
sealed
override
abstract
extern
event_modifier_unsafe

(Spec: Events)
(used in event_declaration)
Never empty
MayStartWith: new public protected internal private static virtual sealed override abstract extern unsafe
MayBeFollowedBy: event new public protected internal private static virtual sealed override abstract extern unsafe

event_accessor_declarations ::=

add_accessor_declaration remove_accessor_declaration
remove_accessor_declaration add_accessor_declaration

(Spec: Events)
(used in event_declaration)
Never empty
MayStartWith: add remove [
MayBeFollowedBy: }

add_accessor_declaration ::=

attributes? add block

(Spec: Events)
(used in event_accessor_declarations)
Never empty
MayStartWith: add [
MayBeFollowedBy: remove [ }

remove_accessor_declaration ::=

attributes? remove block

(Spec: Events)
(used in event_accessor_declarations)
Never empty
MayStartWith: remove [
MayBeFollowedBy: } add [

indexer_modifier ::=

new
public
protected
internal
private
virtual
sealed
override
abstract
extern
indexer_modifier_unsafe

(Spec: Indexers)
(used in indexer_declaration)
Never empty
MayStartWith: new public protected internal private virtual sealed override abstract extern unsafe
MayBeFollowedBy: object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double new public protected internal private virtual sealed override abstract extern unsafe

indexer_declarator ::=

type this [ formal_parameter_list ]
type interface_type . this [ formal_parameter_list ]

(Spec: Indexers)
(used in indexer_declaration)
Never empty
MayStartWith: object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double
MayBeFollowedBy: { =>

indexer_body ::=

{ accessor_declarations }
=> expression ;

(Spec: Indexers)
(used in indexer_declaration)
Never empty
MayStartWith: { =>
MayBeFollowedBy: } const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe [ object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

operator_declaration ::=

attributes? operator_modifier+ operator_declarator operator_body

(Spec: Operators)
(used in class_member_declaration struct_member_declaration)
Never empty
MayStartWith: public static extern [ unsafe
MayBeFollowedBy: } const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe [ object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

operator_modifier ::=

public
static
extern
operator_modifier_unsafe

(Spec: Operators)
(used in operator_declaration)
Never empty
MayStartWith: public static extern unsafe
MayBeFollowedBy: implicit explicit object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double public static extern unsafe

operator_declarator ::=

unary_operator_declarator
binary_operator_declarator
conversion_operator_declarator

(Spec: Operators)
(used in operator_declaration)
Never empty
MayStartWith: implicit explicit object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double
MayBeFollowedBy: { => ;

unary_operator_declarator ::=

type operator overloadable_unary_operator ( type identifier )

(Spec: Operators)
(used in operator_declarator)
Never empty
MayStartWith: object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double
MayBeFollowedBy: { => ;

overloadable_unary_operator ::=

+
-
!
~
++
--
true
false

(Spec: Operators)
(used in unary_operator_declarator)
Never empty
MayStartWith: + - ! ~ ++ -- true false
MayBeFollowedBy: (

binary_operator_declarator ::=

type operator overloadable_binary_operator ( type identifier , type identifier )

(Spec: Operators)
(used in operator_declarator)
Never empty
MayStartWith: object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double
MayBeFollowedBy: { => ;

overloadable_binary_operator ::=

+
-
*
/
%
&
|
^
<<
right_shift
==
!=
>
<
>=
<=

(Spec: Operators)
(used in binary_operator_declarator)
Never empty
MayStartWith: + - * / % & | ^ << right_shift == != > < >= <=
MayBeFollowedBy: (

conversion_operator_declarator ::=

implicit operator type ( type identifier )
explicit operator type ( type identifier )

(Spec: Operators)
(used in operator_declarator)
Never empty
MayStartWith: implicit explicit
MayBeFollowedBy: { => ;

operator_body ::=

block
=> expression ;
;

(Spec: Operators)
(used in operator_declaration)
Never empty
MayStartWith: { => ;
MayBeFollowedBy: } const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe [ object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

constructor_modifier ::=

public
protected
internal
private
extern
constructor_modifier_unsafe

(Spec: Instance constructors)
(used in constructor_declaration)
Never empty
MayStartWith: public protected internal private extern unsafe
MayBeFollowedBy: @ <An identifier_or_keyword that is not a keyword> public protected internal private extern unsafe

constructor_declarator ::=

identifier ( formal_parameter_list? ) constructor_initializer?

(Spec: Instance constructors)
(used in constructor_declaration)
Never empty
MayStartWith: @ <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: { ;

constructor_initializer ::=

: base ( argument_list? )
: this ( argument_list? )

(Spec: Instance constructors)
(used in constructor_declarator)
Never empty
MayStartWith: :
MayBeFollowedBy: { ;

constructor_body ::=

block
;

(Spec: Instance constructors)
(used in constructor_declaration)
Never empty
MayStartWith: { ;
MayBeFollowedBy: } const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe [ object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

static_constructor_declaration ::=

attributes? static_constructor_modifiers identifier ( ) static_constructor_body

(Spec: Static constructors)
(used in class_member_declaration struct_member_declaration)
Never empty
MayStartWith: extern static [ unsafe
MayBeFollowedBy: } const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe [ object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

static_constructor_modifiers ::=

extern? static
static extern?
static_constructor_modifiers_unsafe

(Spec: Static constructors)
(used in static_constructor_declaration)
Never empty
MayStartWith: extern static unsafe
MayBeFollowedBy: @ <An identifier_or_keyword that is not a keyword>

static_constructor_body ::=

block
;

(Spec: Static constructors)
(used in static_constructor_declaration)
Never empty
MayStartWith: { ;
MayBeFollowedBy: } const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe [ object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

destructor_declaration ::=

attributes? extern? ~ identifier ( ) destructor_body
destructor_declaration_unsafe

(Spec: Destructors)
(used in class_member_declaration)
Never empty
MayStartWith: extern ~ unsafe [
MayBeFollowedBy: } const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe [ object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double

destructor_body ::=

block
;

(Spec: Destructors)
(used in destructor_declaration destructor_declaration_unsafe)
Never empty
MayStartWith: { ;
MayBeFollowedBy: } const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe [ object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double

struct_declaration ::=

attributes? struct_modifier* partial? struct identifier type_parameter_list? struct_interfaces? type_parameter_constraints_clause* struct_body ;?

(Spec: Struct declarations)
(used in type_declaration)
Never empty
MayStartWith: partial struct new public protected internal private [ unsafe
MayBeFollowedBy: namespace partial class struct interface enum delegate new public protected internal private abstract sealed static [ unsafe } const event extern ~ readonly volatile virtual override object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

struct_modifier ::=

new
public
protected
internal
private
struct_modifier_unsafe

(Spec: Struct modifiers)
(used in struct_declaration)
Never empty
MayStartWith: new public protected internal private unsafe
MayBeFollowedBy: struct partial new public protected internal private unsafe

struct_interfaces ::=

: interface_type_list

(Spec: Struct interfaces)
(used in struct_declaration)
Never empty
MayStartWith: :
MayBeFollowedBy: { where

struct_body ::=

{ struct_member_declaration* }

(Spec: Struct body)
(used in struct_declaration)
Never empty
MayStartWith: {
MayBeFollowedBy: namespace partial class struct interface enum delegate new public protected internal private abstract sealed static [ unsafe } ; const event extern ~ readonly volatile virtual override object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

struct_member_declaration ::=

constant_declaration
field_declaration
method_declaration
property_declaration
event_declaration
indexer_declaration
operator_declaration
constructor_declaration
static_constructor_declaration
type_declaration
struct_member_declaration_unsafe

(Spec: Struct members)
(used in struct_body)
Never empty
MayStartWith: const event new public protected internal private static readonly volatile partial virtual sealed override abstract extern class struct interface enum delegate [ unsafe object dynamic string @ void fixed bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double
MayBeFollowedBy: } const event new public protected internal private static readonly volatile partial virtual sealed override abstract extern class struct interface enum delegate [ unsafe object dynamic string @ void fixed bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double

array_initializer ::=

{ variable_initializer_list? }
{ variable_initializer_list , }

(Spec: Array initializers)
(used in array_creation_expression local_variable_initializer variable_initializer)
Never empty
MayStartWith: {
MayBeFollowedBy: ; , . ( ++ -- ? -> ) } const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe [ object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double * / = += -= *= /= %= &= |= ^= <<= >>= fixed % + - << >> < > <= >= is as == != & ^ | && || ?? <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let where join orderby equals on into ascending descending by

variable_initializer_list ::=

variable_initializer ( , variable_initializer )*

(Spec: Array initializers)
(used in array_initializer)
Never empty
MayStartWith: + - ! ~ new ++ -- ( await { from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: } ,

interface_declaration ::=

attributes? interface_modifier* partial? interface identifier variant_type_parameter_list? interface_base? type_parameter_constraints_clause* interface_body ;?

(Spec: Interface declarations)
(used in type_declaration)
Never empty
MayStartWith: partial interface new public protected internal private [ unsafe
MayBeFollowedBy: namespace partial class struct interface enum delegate new public protected internal private abstract sealed static [ unsafe } const event extern ~ readonly volatile virtual override object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

interface_modifier ::=

new
public
protected
internal
private
interface_modifier_unsafe

(Spec: Interface modifiers)
(used in interface_declaration)
Never empty
MayStartWith: new public protected internal private unsafe
MayBeFollowedBy: interface partial new public protected internal private unsafe

variant_type_parameter_list ::=

< variant_type_parameters >

(Spec: Variant type parameter lists)
(used in interface_declaration delegate_declaration)
Never empty
MayStartWith: <
MayBeFollowedBy: { where : (

variant_type_parameters ::=

attributes? variance_annotation? type_parameter
variant_type_parameters , attributes? variance_annotation? type_parameter

(Spec: Variant type parameter lists)
(used in variant_type_parameter_list variant_type_parameters)
Never empty
MayStartWith: in out @ [ <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: > ,

variance_annotation ::=

(Spec: Variant type parameter lists)
(used in variant_type_parameters)
Never empty
MayStartWith: in out
MayBeFollowedBy: @ <An identifier_or_keyword that is not a keyword>

interface_base ::=

: interface_type_list

(Spec: Base interfaces)
(used in interface_declaration)
Never empty
MayStartWith: :
MayBeFollowedBy: { where

interface_body ::=

{ interface_member_declaration* }

(Spec: Interface body)
(used in interface_declaration)
Never empty
MayStartWith: {
MayBeFollowedBy: namespace partial class struct interface enum delegate new public protected internal private abstract sealed static [ unsafe } ; const event extern ~ readonly volatile virtual override object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

interface_member_declaration ::=

interface_method_declaration
interface_property_declaration
interface_event_declaration
interface_indexer_declaration

(Spec: Interface members)
(used in interface_body)
Never empty
MayStartWith: new void event [ object dynamic string @ bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double
MayBeFollowedBy: } new void event [ object dynamic string @ bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double

interface_method_declaration ::=

attributes? new? return_type identifier type_parameter_list ( formal_parameter_list? ) type_parameter_constraints_clause* ;

(Spec: Interface methods)
(used in interface_member_declaration)
Never empty
MayStartWith: new void [ object dynamic string @ bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double
MayBeFollowedBy: } new void event [ object dynamic string @ bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double

interface_property_declaration ::=

attributes? new? type identifier { interface_accessors }

(Spec: Interface properties)
(used in interface_member_declaration)
Never empty
MayStartWith: new [ object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double
MayBeFollowedBy: } new void event [ object dynamic string @ bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double

interface_accessors ::=

attributes? get ;
attributes? set ;
attributes? get ; attributes? set ;
attributes? set ; attributes? get ;

(Spec: Interface properties)
(used in interface_property_declaration interface_indexer_declaration)
Never empty
MayStartWith: get set [
MayBeFollowedBy: }

interface_event_declaration ::=

attributes? new? event type identifier ;

(Spec: Interface events)
(used in interface_member_declaration)
Never empty
MayStartWith: new event [
MayBeFollowedBy: } new void event [ object dynamic string @ bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double

interface_indexer_declaration ::=

attributes? new? type this [ formal_parameter_list ] { interface_accessors }

(Spec: Interface indexers)
(used in interface_member_declaration)
Never empty
MayStartWith: new [ object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double
MayBeFollowedBy: } new void event [ object dynamic string @ bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double

enum_declaration ::=

attributes? enum_modifier* enum identifier enum_base? enum_body ;?

(Spec: Enum declarations)
(used in type_declaration)
Never empty
MayStartWith: enum new public protected internal private [
MayBeFollowedBy: namespace partial class struct interface enum delegate new public protected internal private abstract sealed static [ unsafe } const event extern ~ readonly volatile virtual override object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

enum_base ::=

: integral_type

(Spec: Enum declarations)
(used in enum_declaration)
Never empty
MayStartWith: :
MayBeFollowedBy: {

enum_body ::=

{ enum_member_declarations? }
{ enum_member_declarations , }

(Spec: Enum declarations)
(used in enum_declaration)
Never empty
MayStartWith: {
MayBeFollowedBy: namespace partial class struct interface enum delegate new public protected internal private abstract sealed static [ unsafe } ; const event extern ~ readonly volatile virtual override object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

enum_modifier ::=

new
public
protected
internal
private

(Spec: Enum modifiers)
(used in enum_declaration)
Never empty
MayStartWith: new public protected internal private
MayBeFollowedBy: enum new public protected internal private

enum_member_declarations ::=

enum_member_declaration ( , enum_member_declaration )*

(Spec: Enum members)
(used in enum_body)
Never empty
MayStartWith: @ [ <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: } ,

enum_member_declaration ::=

attributes? identifier ( = constant_expression )?

(Spec: Enum members)
(used in enum_member_declarations)
Never empty
MayStartWith: @ [ <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: } ,

delegate_declaration ::=

attributes? delegate_modifier* delegate return_type identifier variant_type_parameter_list? ( formal_parameter_list? ) type_parameter_constraints_clause* ;

(Spec: Delegate declarations)
(used in type_declaration)
Never empty
MayStartWith: delegate new public protected internal private [ unsafe
MayBeFollowedBy: namespace partial class struct interface enum delegate new public protected internal private abstract sealed static [ unsafe } const event extern ~ readonly volatile virtual override object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

delegate_modifier ::=

new
public
protected
internal
private
delegate_modifier_unsafe

(Spec: Delegate declarations)
(used in delegate_declaration)
Never empty
MayStartWith: new public protected internal private unsafe
MayBeFollowedBy: delegate new public protected internal private unsafe

global_attributes ::=

global_attribute_section+

(Spec: Attribute specification)
(used in compilation_unit)
Never empty
MayStartWith: [
MayBeFollowedBy: namespace partial class struct interface enum delegate new public protected internal private abstract sealed static [ unsafe

global_attribute_section ::=

[ global_attribute_target_specifier attribute_list ]
[ global_attribute_target_specifier attribute_list , ]

(Spec: Attribute specification)
(used in global_attributes)
Never empty
MayStartWith: [
MayBeFollowedBy: namespace partial class struct interface enum delegate new public protected internal private abstract sealed static [ unsafe

global_attribute_target_specifier ::=

global_attribute_target :

(Spec: Attribute specification)
(used in global_attribute_section)
Never empty
MayStartWith: assembly module
MayBeFollowedBy: @ <An identifier_or_keyword that is not a keyword>

global_attribute_target ::=

assembly
module

(Spec: Attribute specification)
(used in global_attribute_target_specifier)
Never empty
MayStartWith: assembly module
MayBeFollowedBy: :

attributes ::=

attribute_section+

(Spec: Attribute specification)
(used in class_declaration type_parameters constant_declaration field_declaration method_header fixed_parameter parameter_array property_declaration get_accessor_declaration set_accessor_declaration event_declaration add_accessor_declaration remove_accessor_declaration indexer_declaration operator_declaration constructor_declaration static_constructor_declaration destructor_declaration struct_declaration interface_declaration variant_type_parameters interface_method_declaration interface_property_declaration interface_accessors interface_event_declaration interface_indexer_declaration enum_declaration enum_member_declaration delegate_declaration destructor_declaration_unsafe fixed_size_buffer_declaration)
Never empty
MayStartWith: [
MayBeFollowedBy: class partial new public protected internal private abstract sealed static unsafe @ <An identifier_or_keyword that is not a keyword> const object dynamic string void bool decimal sbyte byte short ushort int uint long ulong char float double readonly volatile virtual override extern ref out this params get set event add remove ~ struct interface in enum delegate fixed

attribute_section ::=

[ attribute_target_specifier? attribute_list ]
[ attribute_target_specifier? attribute_list , ]

(Spec: Attribute specification)
(used in attributes)
Never empty
MayStartWith: [
MayBeFollowedBy: class partial new public protected internal private abstract sealed static unsafe @ <An identifier_or_keyword that is not a keyword> const object dynamic string void bool decimal sbyte byte short ushort int uint long ulong char float double readonly volatile virtual override extern ref out this params get set event add remove ~ struct interface in enum delegate [ fixed

attribute_target_specifier ::=

attribute_target :

(Spec: Attribute specification)
(used in attribute_section)
Never empty
MayStartWith: field event method param property return type
MayBeFollowedBy: @ <An identifier_or_keyword that is not a keyword>

attribute_target ::=

field
event
method
param
property
return
type

(Spec: Attribute specification)
(used in attribute_target_specifier)
Never empty
MayStartWith: field event method param property return type
MayBeFollowedBy: :

attribute_list ::=

attribute ( , attribute )*

(Spec: Attribute specification)
(used in global_attribute_section attribute_section)
Never empty
MayStartWith: @ <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: ] ,

attribute ::=

attribute_name attribute_arguments?

(Spec: Attribute specification)
(used in attribute_list)
Never empty
MayStartWith: @ <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: ] ,

attribute_name ::=

type_name

(Spec: Attribute specification)
(used in attribute)
Never empty
MayStartWith: @ <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: ] , (

attribute_arguments ::=

( positional_argument_list? )
( positional_argument_list , named_argument_list )
( named_argument_list )

(Spec: Attribute specification)
(used in attribute)
Never empty
MayStartWith: (
MayBeFollowedBy: ] ,

positional_argument_list ::=

positional_argument ( , positional_argument )*

(Spec: Attribute specification)
(used in attribute_arguments)
Never empty
MayStartWith: + - ! ~ new ++ -- ( await from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: ) ,

positional_argument ::=

attribute_argument_expression

(Spec: Attribute specification)
(used in positional_argument_list)
Never empty
MayStartWith: + - ! ~ new ++ -- ( await from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: ) ,

named_argument_list ::=

named_argument ( , named_argument )*

(Spec: Attribute specification)
(used in attribute_arguments)
Never empty
MayStartWith: @ <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: )

named_argument ::=

identifier = attribute_argument_expression

(Spec: Attribute specification)
(used in named_argument_list)
Never empty
MayStartWith: @ <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: ) ,

attribute_argument_expression ::=

expression

(Spec: Attribute specification)
(used in positional_argument named_argument)
Never empty
MayStartWith: + - ! ~ new ++ -- ( await from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: ) ,

class_modifier_unsafe ::=

unsafe

(Spec: Unsafe contexts)
(used in class_modifier)
Never empty
MayStartWith: unsafe
MayBeFollowedBy: class partial new public protected internal private abstract sealed static unsafe

struct_modifier_unsafe ::=

unsafe

(Spec: Unsafe contexts)
(used in struct_modifier)
Never empty
MayStartWith: unsafe
MayBeFollowedBy: struct partial new public protected internal private unsafe

interface_modifier_unsafe ::=

unsafe

(Spec: Unsafe contexts)
(used in interface_modifier)
Never empty
MayStartWith: unsafe
MayBeFollowedBy: interface partial new public protected internal private unsafe

delegate_modifier_unsafe ::=

unsafe

(Spec: Unsafe contexts)
(used in delegate_modifier)
Never empty
MayStartWith: unsafe
MayBeFollowedBy: delegate new public protected internal private unsafe

field_modifier_unsafe ::=

unsafe

(Spec: Unsafe contexts)
(used in field_modifier)
Never empty
MayStartWith: unsafe
MayBeFollowedBy: object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double new public protected internal private static readonly volatile unsafe

method_modifier_unsafe ::=

unsafe

(Spec: Unsafe contexts)
(used in method_modifier)
Never empty
MayStartWith: unsafe
MayBeFollowedBy: void object dynamic string @ bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double partial new public protected internal private static virtual sealed override abstract extern unsafe

property_modifier_unsafe ::=

unsafe

(Spec: Unsafe contexts)
(used in property_modifier)
Never empty
MayStartWith: unsafe
MayBeFollowedBy: object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double new public protected internal private static virtual sealed override abstract extern unsafe

event_modifier_unsafe ::=

unsafe

(Spec: Unsafe contexts)
(used in event_modifier)
Never empty
MayStartWith: unsafe
MayBeFollowedBy: event new public protected internal private static virtual sealed override abstract extern unsafe

indexer_modifier_unsafe ::=

unsafe

(Spec: Unsafe contexts)
(used in indexer_modifier)
Never empty
MayStartWith: unsafe
MayBeFollowedBy: object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double new public protected internal private virtual sealed override abstract extern unsafe

operator_modifier_unsafe ::=

unsafe

(Spec: Unsafe contexts)
(used in operator_modifier)
Never empty
MayStartWith: unsafe
MayBeFollowedBy: implicit explicit object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double public static extern unsafe

constructor_modifier_unsafe ::=

unsafe

(Spec: Unsafe contexts)
(used in constructor_modifier)
Never empty
MayStartWith: unsafe
MayBeFollowedBy: @ <An identifier_or_keyword that is not a keyword> public protected internal private extern unsafe

destructor_declaration_unsafe ::=

attributes? extern? unsafe? ~ identifier ( ) destructor_body
attributes? unsafe? extern? ~ identifier ( ) destructor_body

(Spec: Unsafe contexts)
(used in destructor_declaration)
Never empty
MayStartWith: extern unsafe ~ [
MayBeFollowedBy: } const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe [ object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double

static_constructor_modifiers_unsafe ::=

extern? unsafe? static
unsafe? extern? static
extern? static unsafe?
unsafe? static extern?
static extern? unsafe?
static unsafe? extern?

(Spec: Unsafe contexts)
(used in static_constructor_modifiers)
Never empty
MayStartWith: extern unsafe static
MayBeFollowedBy: @ <An identifier_or_keyword that is not a keyword>

embedded_statement_unsafe ::=

unsafe_statement
fixed_statement

(Spec: Unsafe contexts)
(used in embedded_statement)
Never empty
MayStartWith: unsafe fixed
MayBeFollowedBy: else while } @ const { ; try checked unchecked lock using yield <An identifier_or_keyword that is not a keyword> var new + - ! ~ ++ -- await if switch do for foreach break continue goto return throw unsafe fixed ( object dynamic string void <UNDEFINED> this base typeof default nameof delegate * & bool true false 0 1 2 3 4 5 6 7 8 9 . ' null byte char decimal double float int long sbyte short uint ulong ushort sizeof 0x 0X " @" case

unsafe_statement ::=

unsafe block

(Spec: Unsafe contexts)
(used in embedded_statement_unsafe)
Never empty
MayStartWith: unsafe
MayBeFollowedBy: else while } @ const { ; try checked unchecked lock using yield <An identifier_or_keyword that is not a keyword> var new + - ! ~ ++ -- await if switch do for foreach break continue goto return throw unsafe fixed ( object dynamic string void <UNDEFINED> this base typeof default nameof delegate * & bool true false 0 1 2 3 4 5 6 7 8 9 . ' null byte char decimal double float int long sbyte short uint ulong ushort sizeof 0x 0X " @" case

type_unsafe ::=

pointer_type

(Spec: Pointer types)
(used in type)
Never empty
MayStartWith: void object dynamic string @ bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double
MayBeFollowedBy: ? [ > , ( { ) < <= >= is @ <An identifier_or_keyword that is not a keyword> this operator * as == != & ^ | && || ?? } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let where join orderby equals on into ascending descending by ; const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe object dynamic string void bool decimal sbyte byte short ushort int uint long ulong char float double fixed

pointer_type ::=

unmanaged_type *
void *

(Spec: Pointer types)
(used in type_unsafe fixed_statement)
Never empty
MayStartWith: void object dynamic string @ bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double
MayBeFollowedBy: @ <An identifier_or_keyword that is not a keyword> ? [ > , ( { ) < <= >= is this operator * as == != & ^ | && || ?? } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let where join orderby equals on into ascending descending by ; const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe object dynamic string void bool decimal sbyte byte short ushort int uint long ulong char float double fixed

unmanaged_type ::=

type

(Spec: Pointer types)
(used in pointer_type sizeof_expression stackalloc_initializer)
Never empty
MayStartWith: object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double
MayBeFollowedBy: * ) [

primary_no_array_creation_expression_unsafe ::=

pointer_member_access
pointer_element_access
sizeof_expression

(Spec: Pointers in expressions)
(used in primary_no_array_creation_expression)
Never empty
MayStartWith: sizeof new <UNDEFINED> ( this base typeof checked unchecked default nameof delegate true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort 0x 0X " @" <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: [ . ( ++ -- ? -> * / = += -= *= /= %= &= |= ^= <<= >>= ; % + ) , - << >> < > <= >= is as == != & ^ | && || ?? } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let where join orderby equals on into ascending descending by const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

unary_expression_unsafe ::=

pointer_indirection_expression
addressof_expression

(Spec: Pointers in expressions)
(used in unary_expression)
Never empty
MayStartWith: * &
MayBeFollowedBy: * / = += -= *= /= %= &= |= ^= <<= >>= ; % + ) , - << >> < > <= >= is as == != & ^ | && || ?? ? } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let where join orderby equals on into ascending descending by const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe [ object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

pointer_indirection_expression ::=

* unary_expression

(Spec: Pointer indirection)
(used in unary_expression_unsafe)
Never empty
MayStartWith: *
MayBeFollowedBy: * / = += -= *= /= %= &= |= ^= <<= >>= ; % + ) , - << >> < > <= >= is as == != & ^ | && || ?? ? } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let where join orderby equals on into ascending descending by const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe [ object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

pointer_member_access ::=

primary_expression -> identifier

(Spec: Pointer member access)
(used in primary_no_array_creation_expression_unsafe)
Never empty
MayStartWith: new <UNDEFINED> ( this base typeof checked unchecked default nameof delegate true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: [ . ( ++ -- ? -> * / = += -= *= /= %= &= |= ^= <<= >>= ; % + ) , - << >> < > <= >= is as == != & ^ | && || ?? } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let where join orderby equals on into ascending descending by const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

pointer_element_access ::=

primary_no_array_creation_expression [ expression ]

(Spec: Pointer element access)
(used in primary_no_array_creation_expression_unsafe)
Never empty
MayStartWith: <UNDEFINED> ( this base new typeof checked unchecked default nameof delegate true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: [ . ( ++ -- ? -> * / = += -= *= /= %= &= |= ^= <<= >>= ; % + ) , - << >> < > <= >= is as == != & ^ | && || ?? } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let where join orderby equals on into ascending descending by const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

addressof_expression ::=

& unary_expression

(Spec: The address-of operator)
(used in unary_expression_unsafe)
Never empty
MayStartWith: &
MayBeFollowedBy: * / = += -= *= /= %= &= |= ^= <<= >>= ; % + ) , - << >> < > <= >= is as == != & ^ | && || ?? ? } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let where join orderby equals on into ascending descending by const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe [ object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

sizeof_expression ::=

sizeof ( unmanaged_type )

(Spec: The sizeof operator)
(used in primary_no_array_creation_expression_unsafe)
Never empty
MayStartWith: sizeof
MayBeFollowedBy: [ . ( ++ -- ? -> * / = += -= *= /= %= &= |= ^= <<= >>= ; % + ) , - << >> < > <= >= is as == != & ^ | && || ?? } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let where join orderby equals on into ascending descending by const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

fixed_statement ::=

fixed ( pointer_type fixed_pointer_declarators ) embedded_statement

(Spec: The fixed statement)
(used in embedded_statement_unsafe)
Never empty
MayStartWith: fixed
MayBeFollowedBy: else while } @ const { ; try checked unchecked lock using yield <An identifier_or_keyword that is not a keyword> var new + - ! ~ ++ -- await if switch do for foreach break continue goto return throw unsafe fixed ( object dynamic string void <UNDEFINED> this base typeof default nameof delegate * & bool true false 0 1 2 3 4 5 6 7 8 9 . ' null byte char decimal double float int long sbyte short uint ulong ushort sizeof 0x 0X " @" case

fixed_pointer_declarators ::=

fixed_pointer_declarator ( , fixed_pointer_declarator )*

(Spec: The fixed statement)
(used in fixed_statement)
Never empty
MayStartWith: @ <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: )

fixed_pointer_declarator ::=

identifier = fixed_pointer_initializer

(Spec: The fixed statement)
(used in fixed_pointer_declarators)
Never empty
MayStartWith: @ <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: ) ,

fixed_pointer_initializer ::=

& variable_reference
expression

(Spec: The fixed statement)
(used in fixed_pointer_declarator)
Never empty
MayStartWith: & + - ! ~ new ++ -- ( await from <UNDEFINED> this base typeof checked unchecked default nameof delegate * true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: ) ,

struct_member_declaration_unsafe ::=

fixed_size_buffer_declaration

(Spec: Fixed size buffer declarations)
(used in struct_member_declaration)
Never empty
MayStartWith: fixed [ new public protected internal private unsafe
MayBeFollowedBy: } const event new public protected internal private static readonly volatile partial virtual sealed override abstract extern class struct interface enum delegate [ unsafe object dynamic string @ void fixed bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double

fixed_size_buffer_declaration ::=

attributes? fixed_size_buffer_modifier* fixed buffer_element_type fixed_size_buffer_declarator+ ;

(Spec: Fixed size buffer declarations)
(used in struct_member_declaration_unsafe)
Never empty
MayStartWith: fixed [ new public protected internal private unsafe
MayBeFollowedBy: } const event new public protected internal private static readonly volatile partial virtual sealed override abstract extern class struct interface enum delegate [ unsafe object dynamic string @ void fixed bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double

fixed_size_buffer_modifier ::=

new
public
protected
internal
private
unsafe

(Spec: Fixed size buffer declarations)
(used in fixed_size_buffer_declaration)
Never empty
MayStartWith: new public protected internal private unsafe
MayBeFollowedBy: fixed new public protected internal private unsafe

buffer_element_type ::=

type

(Spec: Fixed size buffer declarations)
(used in fixed_size_buffer_declaration)
Never empty
MayStartWith: object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double
MayBeFollowedBy: @ <An identifier_or_keyword that is not a keyword>

fixed_size_buffer_declarator ::=

identifier [ constant_expression ]

(Spec: Fixed size buffer declarations)
(used in fixed_size_buffer_declaration)
Never empty
MayStartWith: @ <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: ; @ <An identifier_or_keyword that is not a keyword>

local_variable_initializer_unsafe ::=

stackalloc_initializer

(Spec: Stack allocation)
(used in local_variable_initializer)
Never empty
MayStartWith: stackalloc
MayBeFollowedBy: ; , )

stackalloc_initializer ::=

stackalloc unmanaged_type [ expression ]

(Spec: Stack allocation)
(used in local_variable_initializer_unsafe)
Never empty
MayStartWith: stackalloc
MayBeFollowedBy: ; , )

single_line_doc_comment ::=

/// input_character*

(Spec: Introduction)
(used in )
Never empty
MayStartWith: ///
MayBeFollowedBy:

delimited_doc_comment ::=

/** delimited_comment_section* asterisk* /

(Spec: Introduction)
(used in )
Never empty
MayStartWith: /**
MayBeFollowedBy:

input ::=

input_section?

(Spec: Lexical analysis)
(used in )
May be empty
MayStartWith: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> # // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @"
MayBeFollowedBy:

input_section ::=

input_section_part+

(Spec: Lexical analysis)
(used in input conditional_section)
Never empty
MayStartWith: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> # // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @"
MayBeFollowedBy: <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> #

input_section_part ::=

input_element* new_line
pp_directive

(Spec: Lexical analysis)
(used in input_section)
Never empty
MayStartWith: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> # // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @"
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> # // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @"

input_element ::=

whitespace
comment
token

(Spec: Lexical analysis)
(used in input_section_part)
Never empty
MayStartWith: <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @"
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @"

new_line ::=

<Carriage return character (U+000D)>
<Line feed character (U+000A)>
<Carriage return character (U+000D) followed by line feed character (U+000A)>
<Next line character (U+0085)>
<Line separator character (U+2028)>
<Paragraph separator character (U+2029)>

(Spec: Line terminators)
(used in input_section_part pp_new_line skipped_section_part pp_message)
Never empty
MayStartWith: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)>
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> # // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" <Any input_character except #>

comment ::=

single_line_comment
delimited_comment

(Spec: Comments)
(used in input_element verbatim_balanced_text_part)
Never empty
MayStartWith: // /*
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B) and } (U+007D)> </ (U+002F), if not directly followed by / (U+002F) or * (U+002A)>

single_line_comment ::=

// input_character*

(Spec: Comments)
(used in comment pp_new_line)
Never empty
MayStartWith: //
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B) and } (U+007D)> </ (U+002F), if not directly followed by / (U+002F) or * (U+002A)>

input_character ::=

<Any Unicode character except a new_line_character>

(Spec: Comments)
(used in single_line_doc_comment single_line_comment skipped_characters pp_message)
Never empty
MayStartWith: <Any Unicode character except a new_line_character>
MayBeFollowedBy: <Any Unicode character except a new_line_character> <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B) and } (U+007D)> </ (U+002F), if not directly followed by / (U+002F) or * (U+002A)>

new_line_character ::=

<Carriage return character (U+000D)>
<Line feed character (U+000A)>
<Next line character (U+0085)>
<Line separator character (U+2028)>
<Paragraph separator character (U+2029)>

(Spec: Comments)
(used in )
Never empty
MayStartWith: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)>
MayBeFollowedBy:

delimited_comment ::=

/* delimited_comment_section* asterisk* /

(Spec: Comments)
(used in comment regular_balanced_text_part)
Never empty
MayStartWith: /*
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B), } (U+007D) and new_line_character> </ (U+002F), if not directly followed by / (U+002F) or * (U+002A)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B) and } (U+007D)>

delimited_comment_section ::=

/
asterisk* not_slash_or_asterisk

(Spec: Comments)
(used in delimited_doc_comment delimited_comment)
Never empty
MayStartWith: / * <Any Unicode character except / or *>
MayBeFollowedBy: / * <Any Unicode character except / or *>

asterisk ::=

(Spec: Comments)
(used in delimited_doc_comment delimited_comment delimited_comment_section)
Never empty
MayStartWith: *
MayBeFollowedBy: / * <Any Unicode character except / or *>

not_slash_or_asterisk ::=

<Any Unicode character except / or *>

(Spec: Comments)
(used in delimited_comment_section)
Never empty
MayStartWith: <Any Unicode character except / or *>
MayBeFollowedBy: / * <Any Unicode character except / or *>

whitespace ::=

<Any character with Unicode class Zs>
<Horizontal tab character (U+0009)>
<Vertical tab character (U+000B)>
<Form feed character (U+000C)>

(Spec: White space)
(used in input_element pp_expression pp_or_expression pp_and_expression pp_equality_expression pp_unary_expression pp_primary_expression pp_declaration pp_new_line pp_if_section pp_elif_section pp_else_section pp_endif skipped_characters pp_diagnostic pp_message pp_start_region pp_end_region pp_line line_indicator pp_pragma pragma_warning_body warning_list)
Never empty
MayStartWith: <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)>
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" <Any identifier_or_keyword except true or false> define # undef elif endif <Any input_character except #> error warning <Any Unicode character except a new_line_character> region endregion hidden line pragma disable restore

token ::=

identifier
keyword
integer_literal
real_literal
character_literal
string_literal
interpolated_string_literal
operator_or_punctuator

(Spec: Tokens)
(used in input_element)
Never empty
MayStartWith: @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @"
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @"

unicode_escape_sequence ::=

\u hex_digit hex_digit hex_digit hex_digit
\U hex_digit hex_digit hex_digit hex_digit hex_digit hex_digit hex_digit hex_digit

(Spec: Unicode character escape sequences)
(used in character regular_string_literal_character interpolated_regular_string_character)
Never empty
MayStartWith: \u \U
MayBeFollowedBy: ' " \' \" \\ \0 \a \b \f \n \r \t \v \x \u \U <Any character except " (U+0022), \ (U+005C), and new_line_character> <Any character except " (U+0022), \ (U+005C), { (U+007B), } (U+007D), and new_line_character> {{ }} {

identifier ::=

available_identifier
@ identifier_or_keyword

(Spec: Identifiers)
(used in qualified_identifier extern_alias_directive using_alias_directive qualified_alias_member namespace_or_type_name type_parameter argument_name simple_name member_access base_access initializer_target member_declarator unbound_type_name named_entity null_conditional_operations null_conditional_member_access explicit_anonymous_function_parameter implicit_anonymous_function_parameter from_clause let_clause join_clause join_into_clause query_continuation labeled_statement local_variable_declarator constant_declarator foreach_statement goto_statement exception_specifier class_declaration variable_declarator member_name fixed_parameter parameter_array unary_operator_declarator binary_operator_declarator conversion_operator_declarator constructor_declarator static_constructor_declaration destructor_declaration struct_declaration interface_declaration interface_method_declaration interface_property_declaration interface_event_declaration enum_declaration enum_member_declaration delegate_declaration named_argument destructor_declaration_unsafe pointer_member_access fixed_pointer_declarator fixed_size_buffer_declarator token)
Never empty
MayStartWith: @ <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: { . ; = < :: : ) ? } , => in select group from let where join orderby ( [ <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 ' $ ] + - * / % & | ^ ! ~ > ?? ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= <An identifier_or_keyword that is not a keyword> 0x 0X " @" >>= >> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> equals on into ascending descending by partial dynamic

available_identifier ::=

<An identifier_or_keyword that is not a keyword>

(Spec: Identifiers)
(used in identifier)
Never empty
MayStartWith: <An identifier_or_keyword that is not a keyword>
MayBeFollowedBy: { . ; = < :: : ) ? } , => in select group from let where join orderby ( [ <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 ' $ ] + - * / % & | ^ ! ~ > ?? ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= <An identifier_or_keyword that is not a keyword> 0x 0X " @" >>= >> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> equals on into ascending descending by partial dynamic

identifier_or_keyword ::=

identifier_start_character identifier_part_character*

(Spec: Identifiers)
(used in identifier regular_balanced_text_part verbatim_balanced_text_part)
Never empty
MayStartWith: _ <A Unicode character of classes Lu, Ll, Lt, Lm, Lo, or Nl> <A unicode_escape_sequence representing a character of classes Lu, Ll, Lt, Lm, Lo, or Nl>
MayBeFollowedBy: { . ; = < :: : ) ? } , => in select group from let where join orderby ( [ <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 ' $ ] + - * / % & | ^ ! ~ > ?? ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= <An identifier_or_keyword that is not a keyword> 0x 0X " @" <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B), } (U+007D) and new_line_character> </ (U+002F), if not directly followed by / (U+002F) or * (U+002A)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B) and } (U+007D)> >>= >> equals on into ascending descending by partial dynamic

identifier_start_character ::=

letter_character
_

(Spec: Identifiers)
(used in identifier_or_keyword)
Never empty
MayStartWith: _ <A Unicode character of classes Lu, Ll, Lt, Lm, Lo, or Nl> <A unicode_escape_sequence representing a character of classes Lu, Ll, Lt, Lm, Lo, or Nl>
MayBeFollowedBy: { . ; = < :: : ) ? } , => in select group from let where join orderby ( [ <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 ' $ ] + - * / % & | ^ ! ~ > ?? ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= <An identifier_or_keyword that is not a keyword> 0x 0X " @" <A Unicode character of classes Lu, Ll, Lt, Lm, Lo, or Nl> <A unicode_escape_sequence representing a character of classes Lu, Ll, Lt, Lm, Lo, or Nl> <A Unicode character of the class Nd> <A unicode_escape_sequence representing a character of the class Nd> <A Unicode character of the class Pc> <A unicode_escape_sequence representing a character of the class Pc> <A Unicode character of classes Mn or Mc> <A unicode_escape_sequence representing a character of classes Mn or Mc> <A Unicode character of the class Cf> <A unicode_escape_sequence representing a character of the class Cf> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B), } (U+007D) and new_line_character> </ (U+002F), if not directly followed by / (U+002F) or * (U+002A)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B) and } (U+007D)> >>= >> equals on into ascending descending by partial dynamic

identifier_part_character ::=

letter_character
decimal_digit_character
connecting_character
combining_character
formatting_character

(Spec: Identifiers)
(used in identifier_or_keyword)
Never empty
MayStartWith: <A Unicode character of classes Lu, Ll, Lt, Lm, Lo, or Nl> <A unicode_escape_sequence representing a character of classes Lu, Ll, Lt, Lm, Lo, or Nl> <A Unicode character of the class Nd> <A unicode_escape_sequence representing a character of the class Nd> <A Unicode character of the class Pc> <A unicode_escape_sequence representing a character of the class Pc> <A Unicode character of classes Mn or Mc> <A unicode_escape_sequence representing a character of classes Mn or Mc> <A Unicode character of the class Cf> <A unicode_escape_sequence representing a character of the class Cf>
MayBeFollowedBy: { . ; = < :: : ) ? } , => in select group from let where join orderby ( [ <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 ' $ ] + - * / % & | ^ ! ~ > ?? ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= <An identifier_or_keyword that is not a keyword> 0x 0X " @" <A Unicode character of classes Lu, Ll, Lt, Lm, Lo, or Nl> <A unicode_escape_sequence representing a character of classes Lu, Ll, Lt, Lm, Lo, or Nl> <A Unicode character of the class Nd> <A unicode_escape_sequence representing a character of the class Nd> <A Unicode character of the class Pc> <A unicode_escape_sequence representing a character of the class Pc> <A Unicode character of classes Mn or Mc> <A unicode_escape_sequence representing a character of classes Mn or Mc> <A Unicode character of the class Cf> <A unicode_escape_sequence representing a character of the class Cf> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B), } (U+007D) and new_line_character> </ (U+002F), if not directly followed by / (U+002F) or * (U+002A)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B) and } (U+007D)> >>= >> equals on into ascending descending by partial dynamic

letter_character ::=

<A Unicode character of classes Lu, Ll, Lt, Lm, Lo, or Nl>
<A unicode_escape_sequence representing a character of classes Lu, Ll, Lt, Lm, Lo, or Nl>

(Spec: Identifiers)
(used in identifier_start_character identifier_part_character)
Never empty
MayStartWith: <A Unicode character of classes Lu, Ll, Lt, Lm, Lo, or Nl> <A unicode_escape_sequence representing a character of classes Lu, Ll, Lt, Lm, Lo, or Nl>
MayBeFollowedBy: { . ; = < :: : ) ? } , => in select group from let where join orderby ( [ <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 ' $ ] + - * / % & | ^ ! ~ > ?? ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= <An identifier_or_keyword that is not a keyword> 0x 0X " @" <A Unicode character of classes Lu, Ll, Lt, Lm, Lo, or Nl> <A unicode_escape_sequence representing a character of classes Lu, Ll, Lt, Lm, Lo, or Nl> <A Unicode character of the class Nd> <A unicode_escape_sequence representing a character of the class Nd> <A Unicode character of the class Pc> <A unicode_escape_sequence representing a character of the class Pc> <A Unicode character of classes Mn or Mc> <A unicode_escape_sequence representing a character of classes Mn or Mc> <A Unicode character of the class Cf> <A unicode_escape_sequence representing a character of the class Cf> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B), } (U+007D) and new_line_character> </ (U+002F), if not directly followed by / (U+002F) or * (U+002A)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B) and } (U+007D)> >>= >> equals on into ascending descending by partial dynamic

combining_character ::=

<A Unicode character of classes Mn or Mc>
<A unicode_escape_sequence representing a character of classes Mn or Mc>

(Spec: Identifiers)
(used in identifier_part_character)
Never empty
MayStartWith: <A Unicode character of classes Mn or Mc> <A unicode_escape_sequence representing a character of classes Mn or Mc>
MayBeFollowedBy: { . ; = < :: : ) ? } , => in select group from let where join orderby ( [ <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 ' $ ] + - * / % & | ^ ! ~ > ?? ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= <An identifier_or_keyword that is not a keyword> 0x 0X " @" <A Unicode character of classes Lu, Ll, Lt, Lm, Lo, or Nl> <A unicode_escape_sequence representing a character of classes Lu, Ll, Lt, Lm, Lo, or Nl> <A Unicode character of the class Nd> <A unicode_escape_sequence representing a character of the class Nd> <A Unicode character of the class Pc> <A unicode_escape_sequence representing a character of the class Pc> <A Unicode character of classes Mn or Mc> <A unicode_escape_sequence representing a character of classes Mn or Mc> <A Unicode character of the class Cf> <A unicode_escape_sequence representing a character of the class Cf> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B), } (U+007D) and new_line_character> </ (U+002F), if not directly followed by / (U+002F) or * (U+002A)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B) and } (U+007D)> >>= >> equals on into ascending descending by partial dynamic

decimal_digit_character ::=

<A Unicode character of the class Nd>
<A unicode_escape_sequence representing a character of the class Nd>

(Spec: Identifiers)
(used in identifier_part_character)
Never empty
MayStartWith: <A Unicode character of the class Nd> <A unicode_escape_sequence representing a character of the class Nd>
MayBeFollowedBy: { . ; = < :: : ) ? } , => in select group from let where join orderby ( [ <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 ' $ ] + - * / % & | ^ ! ~ > ?? ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= <An identifier_or_keyword that is not a keyword> 0x 0X " @" <A Unicode character of classes Lu, Ll, Lt, Lm, Lo, or Nl> <A unicode_escape_sequence representing a character of classes Lu, Ll, Lt, Lm, Lo, or Nl> <A Unicode character of the class Nd> <A unicode_escape_sequence representing a character of the class Nd> <A Unicode character of the class Pc> <A unicode_escape_sequence representing a character of the class Pc> <A Unicode character of classes Mn or Mc> <A unicode_escape_sequence representing a character of classes Mn or Mc> <A Unicode character of the class Cf> <A unicode_escape_sequence representing a character of the class Cf> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B), } (U+007D) and new_line_character> </ (U+002F), if not directly followed by / (U+002F) or * (U+002A)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B) and } (U+007D)> >>= >> equals on into ascending descending by partial dynamic

connecting_character ::=

<A Unicode character of the class Pc>
<A unicode_escape_sequence representing a character of the class Pc>

(Spec: Identifiers)
(used in identifier_part_character)
Never empty
MayStartWith: <A Unicode character of the class Pc> <A unicode_escape_sequence representing a character of the class Pc>
MayBeFollowedBy: { . ; = < :: : ) ? } , => in select group from let where join orderby ( [ <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 ' $ ] + - * / % & | ^ ! ~ > ?? ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= <An identifier_or_keyword that is not a keyword> 0x 0X " @" <A Unicode character of classes Lu, Ll, Lt, Lm, Lo, or Nl> <A unicode_escape_sequence representing a character of classes Lu, Ll, Lt, Lm, Lo, or Nl> <A Unicode character of the class Nd> <A unicode_escape_sequence representing a character of the class Nd> <A Unicode character of the class Pc> <A unicode_escape_sequence representing a character of the class Pc> <A Unicode character of classes Mn or Mc> <A unicode_escape_sequence representing a character of classes Mn or Mc> <A Unicode character of the class Cf> <A unicode_escape_sequence representing a character of the class Cf> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B), } (U+007D) and new_line_character> </ (U+002F), if not directly followed by / (U+002F) or * (U+002A)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B) and } (U+007D)> >>= >> equals on into ascending descending by partial dynamic

formatting_character ::=

<A Unicode character of the class Cf>
<A unicode_escape_sequence representing a character of the class Cf>

(Spec: Identifiers)
(used in identifier_part_character)
Never empty
MayStartWith: <A Unicode character of the class Cf> <A unicode_escape_sequence representing a character of the class Cf>
MayBeFollowedBy: { . ; = < :: : ) ? } , => in select group from let where join orderby ( [ <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 ' $ ] + - * / % & | ^ ! ~ > ?? ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= <An identifier_or_keyword that is not a keyword> 0x 0X " @" <A Unicode character of classes Lu, Ll, Lt, Lm, Lo, or Nl> <A unicode_escape_sequence representing a character of classes Lu, Ll, Lt, Lm, Lo, or Nl> <A Unicode character of the class Nd> <A unicode_escape_sequence representing a character of the class Nd> <A Unicode character of the class Pc> <A unicode_escape_sequence representing a character of the class Pc> <A Unicode character of classes Mn or Mc> <A unicode_escape_sequence representing a character of classes Mn or Mc> <A Unicode character of the class Cf> <A unicode_escape_sequence representing a character of the class Cf> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B), } (U+007D) and new_line_character> </ (U+002F), if not directly followed by / (U+002F) or * (U+002A)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B) and } (U+007D)> >>= >> equals on into ascending descending by partial dynamic

keyword ::=

abstract
as
base
bool
break
byte
case
catch
char
checked
class
const
continue
decimal
default
delegate
do
double
else
enum
event
explicit
extern
false
finally
fixed
float
for
foreach
goto
if
implicit
in
int
interface
internal
is
lock
long
namespace
new
null
object
operator
out
override
params
private
protected
public
readonly
ref
return
sbyte
sealed
short
sizeof
stackalloc
static
string
struct
switch
this
throw
true
try
typeof
uint
ulong
unchecked
unsafe
ushort
using
virtual
void
volatile
while

(Spec: Keywords)
(used in token)
Never empty
MayStartWith: abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @"

literal ::=

boolean_literal
integer_literal
real_literal
character_literal
string_literal
null_literal

(Spec: Literals)
(used in primary_no_array_creation_expression)
Never empty
MayStartWith: true false 0 1 2 3 4 5 6 7 8 9 . ' null 0x 0X " @"
MayBeFollowedBy: [ . ( ++ -- ? -> * / = += -= *= /= %= &= |= ^= <<= >>= ; % + ) , - << >> < > <= >= is as == != & ^ | && || ?? } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let where join orderby equals on into ascending descending by const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

boolean_literal ::=

true
false

(Spec: Boolean literals)
(used in literal)
Never empty
MayStartWith: true false
MayBeFollowedBy: [ . ( ++ -- ? -> * / = += -= *= /= %= &= |= ^= <<= >>= ; % + ) , - << >> < > <= >= is as == != & ^ | && || ?? } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let where join orderby equals on into ascending descending by const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

integer_literal ::=

decimal_integer_literal
hexadecimal_integer_literal

(Spec: Integer literals)
(used in token literal)
Never empty
MayStartWith: 0x 0X 0 1 2 3 4 5 6 7 8 9
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" >>= >> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

decimal_integer_literal ::=

decimal_digit+ integer_type_suffix?

(Spec: Integer literals)
(used in integer_literal)
Never empty
MayStartWith: 0 1 2 3 4 5 6 7 8 9
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" >>= >> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

decimal_digit ::=

(Spec: Integer literals)
(used in decimal_integer_literal real_literal exponent_part line_indicator warning_list)
Never empty
MayStartWith: 0 1 2 3 4 5 6 7 8 9
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" U u L l UL Ul uL ul LU Lu lU lu F f D d M m e E >>= >> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

integer_type_suffix ::=

(Spec: Integer literals)
(used in decimal_integer_literal hexadecimal_integer_literal)
Never empty
MayStartWith: U u L l UL Ul uL ul LU Lu lU lu
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" >>= >> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

hexadecimal_integer_literal ::=

0x hex_digit+ integer_type_suffix?
0X hex_digit+ integer_type_suffix?

(Spec: Integer literals)
(used in integer_literal)
Never empty
MayStartWith: 0x 0X
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" >>= >> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

hex_digit ::=

(Spec: Integer literals)
(used in unicode_escape_sequence hexadecimal_integer_literal hexadecimal_escape_sequence)
Never empty
MayStartWith: 0 1 2 3 4 5 6 7 8 9 A B C D E F a b c d e f
MayBeFollowedBy: 0 1 2 3 4 5 6 7 8 9 A B C D E F a b c d e f <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" U u L l UL Ul uL ul LU Lu lU lu \' \" \\ \0 \a \b \f \n \r \t \v \x \u \U <Any character except " (U+0022), \ (U+005C), and new_line_character> <Any character except " (U+0022), \ (U+005C), { (U+007B), } (U+007D), and new_line_character> {{ }} >>= >> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

real_literal ::=

decimal_digit+ . decimal_digit+ exponent_part? real_type_suffix?
. decimal_digit+ exponent_part? real_type_suffix?
decimal_digit+ exponent_part real_type_suffix?
decimal_digit+ real_type_suffix

(Spec: Real literals)
(used in token literal)
Never empty
MayStartWith: 0 1 2 3 4 5 6 7 8 9 .
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" >>= >> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

exponent_part ::=

e sign? decimal_digit+
E sign? decimal_digit+

(Spec: Real literals)
(used in real_literal)
Never empty
MayStartWith: e E
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" F f D d M m >>= >> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

sign ::=

(Spec: Real literals)
(used in exponent_part)
Never empty
MayStartWith: + -
MayBeFollowedBy: 0 1 2 3 4 5 6 7 8 9

real_type_suffix ::=

(Spec: Real literals)
(used in real_literal)
Never empty
MayStartWith: F f D d M m
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" >>= >> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

character_literal ::=

' character '

(Spec: Character literals)
(used in token literal)
Never empty
MayStartWith: '
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" >>= >> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

character ::=

single_character
simple_escape_sequence
hexadecimal_escape_sequence
unicode_escape_sequence

(Spec: Character literals)
(used in character_literal)
Never empty
MayStartWith: \u \U <Any character except ' (U+0027), \ (U+005C), and new_line_character> \' \" \\ \0 \a \b \f \n \r \t \v \x
MayBeFollowedBy: '

single_character ::=

<Any character except ' (U+0027), \ (U+005C), and new_line_character>

(Spec: Character literals)
(used in character)
Never empty
MayStartWith: <Any character except ' (U+0027), \ (U+005C), and new_line_character>
MayBeFollowedBy: '

simple_escape_sequence ::=

(Spec: Character literals)
(used in character regular_string_literal_character interpolated_regular_string_character)
Never empty
MayStartWith: \' \" \\ \0 \a \b \f \n \r \t \v
MayBeFollowedBy: ' " \' \" \\ \0 \a \b \f \n \r \t \v \x \u \U <Any character except " (U+0022), \ (U+005C), and new_line_character> <Any character except " (U+0022), \ (U+005C), { (U+007B), } (U+007D), and new_line_character> {{ }} {

hexadecimal_escape_sequence ::=

\x hex_digit hex_digit? hex_digit? hex_digit?

(Spec: Character literals)
(used in character regular_string_literal_character interpolated_regular_string_character)
Never empty
MayStartWith: \x
MayBeFollowedBy: ' " \' \" \\ \0 \a \b \f \n \r \t \v \x \u \U <Any character except " (U+0022), \ (U+005C), and new_line_character> <Any character except " (U+0022), \ (U+005C), { (U+007B), } (U+007D), and new_line_character> {{ }} {

string_literal ::=

regular_string_literal
verbatim_string_literal

(Spec: String literals)
(used in token literal regular_balanced_text_part verbatim_balanced_text_part)
Never empty
MayStartWith: " @"
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B), } (U+007D) and new_line_character> </ (U+002F), if not directly followed by / (U+002F) or * (U+002A)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B) and } (U+007D)> >>= >> from select group let where join orderby equals on into ascending descending by partial dynamic

regular_string_literal ::=

" regular_string_literal_character* "

(Spec: String literals)
(used in string_literal)
Never empty
MayStartWith: "
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B), } (U+007D) and new_line_character> </ (U+002F), if not directly followed by / (U+002F) or * (U+002A)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B) and } (U+007D)> >>= >> from select group let where join orderby equals on into ascending descending by partial dynamic

regular_string_literal_character ::=

single_regular_string_literal_character
simple_escape_sequence
hexadecimal_escape_sequence
unicode_escape_sequence

(Spec: String literals)
(used in regular_string_literal)
Never empty
MayStartWith: \' \" \\ \0 \a \b \f \n \r \t \v \x \u \U <Any character except " (U+0022), \ (U+005C), and new_line_character>
MayBeFollowedBy: " \' \" \\ \0 \a \b \f \n \r \t \v \x \u \U <Any character except " (U+0022), \ (U+005C), and new_line_character>

single_regular_string_literal_character ::=

<Any character except " (U+0022), \ (U+005C), and new_line_character>

(Spec: String literals)
(used in regular_string_literal_character)
Never empty
MayStartWith: <Any character except " (U+0022), \ (U+005C), and new_line_character>
MayBeFollowedBy: " \' \" \\ \0 \a \b \f \n \r \t \v \x \u \U <Any character except " (U+0022), \ (U+005C), and new_line_character>

verbatim_string_literal ::=

@" verbatim_string_literal_character* "

(Spec: String literals)
(used in string_literal)
Never empty
MayStartWith: @"
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B), } (U+007D) and new_line_character> </ (U+002F), if not directly followed by / (U+002F) or * (U+002A)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B) and } (U+007D)> >>= >> from select group let where join orderby equals on into ascending descending by partial dynamic

verbatim_string_literal_character ::=

single_verbatim_string_literal_character
quote_escape_sequence

(Spec: String literals)
(used in verbatim_string_literal)
Never empty
MayStartWith: <any character except "> ""
MayBeFollowedBy: " <any character except "> ""

single_verbatim_string_literal_character ::=

<any character except ">

(Spec: String literals)
(used in verbatim_string_literal_character)
Never empty
MayStartWith: <any character except ">
MayBeFollowedBy: " <any character except "> ""

quote_escape_sequence ::=

(Spec: String literals)
(used in verbatim_string_literal_character interpolated_verbatim_string_character)
Never empty
MayStartWith: ""
MayBeFollowedBy: " <any character except "> "" {{ }} <Any character except " (U+0022), { (U+007B) and } (U+007D)> {

interpolated_string_literal ::=

$ interpolated_regular_string_literal
$ interpolated_verbatim_string_literal

(Spec: Interpolated string literals)
(used in token regular_balanced_text_part verbatim_balanced_text_part)
Never empty
MayStartWith: $
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B), } (U+007D) and new_line_character> </ (U+002F), if not directly followed by / (U+002F) or * (U+002A)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B) and } (U+007D)>

interpolated_regular_string_literal ::=

interpolated_regular_string_whole
interpolated_regular_string_start interpolated_regular_string_literal_body interpolated_regular_string_end

(Spec: Interpolated string literals)
(used in interpolated_string_literal)
Never empty
MayStartWith: "
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B), } (U+007D) and new_line_character> </ (U+002F), if not directly followed by / (U+002F) or * (U+002A)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B) and } (U+007D)>

interpolated_regular_string_whole ::=

" interpolated_regular_string_character* "

(Spec: Interpolated string literals)
(used in interpolated_regular_string interpolated_regular_string_literal)
Never empty
MayStartWith: "
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B), } (U+007D) and new_line_character> </ (U+002F), if not directly followed by / (U+002F) or * (U+002A)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B) and } (U+007D)>

interpolated_regular_string_mid ::=

interpolation_format? } interpolated_regular_string_characters_after_brace? {

(Spec: Interpolated string literals)
(used in interpolated_regular_string_body interpolated_regular_string_literal_body)
Never empty
MayStartWith: } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)>
MayBeFollowedBy: + - ! ~ new ++ -- ( await from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword> /* $ [ { <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B), } (U+007D) and new_line_character> </ (U+002F), if not directly followed by / (U+002F) or * (U+002A)>

interpolated_regular_string_end ::=

interpolation_format? } interpolated_regular_string_characters_after_brace? "

(Spec: Interpolated string literals)
(used in interpolated_regular_string interpolated_regular_string_literal)
Never empty
MayStartWith: } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)>
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B), } (U+007D) and new_line_character> </ (U+002F), if not directly followed by / (U+002F) or * (U+002A)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B) and } (U+007D)>

open_brace_escape_sequence ::=

{{

(Spec: Interpolated string literals)
(used in interpolated_regular_string_character interpolated_verbatim_string_character)
Never empty
MayStartWith: {{
MayBeFollowedBy: " \' \" \\ \0 \a \b \f \n \r \t \v \x \u \U <Any character except " (U+0022), \ (U+005C), { (U+007B), } (U+007D), and new_line_character> {{ }} { "" <Any character except " (U+0022), { (U+007B) and } (U+007D)>

close_brace_escape_sequence ::=

}}

(Spec: Interpolated string literals)
(used in interpolated_regular_string_character interpolated_verbatim_string_character)
Never empty
MayStartWith: }}
MayBeFollowedBy: " \' \" \\ \0 \a \b \f \n \r \t \v \x \u \U <Any character except " (U+0022), \ (U+005C), { (U+007B), } (U+007D), and new_line_character> {{ }} { "" <Any character except " (U+0022), { (U+007B) and } (U+007D)>

regular_balanced_text_part ::=

single_regular_balanced_text_character
delimited_comment
@ identifier_or_keyword
string_literal
interpolated_string_literal
( regular_balanced_text )
[ regular_balanced_text ]
{ regular_balanced_text }

(Spec: Interpolated string literals)
(used in regular_balanced_text)
Never empty
MayStartWith: /* @ $ ( [ { <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B), } (U+007D) and new_line_character> </ (U+002F), if not directly followed by / (U+002F) or * (U+002A)> " @"
MayBeFollowedBy: } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> /* @ $ ( [ { <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B), } (U+007D) and new_line_character> </ (U+002F), if not directly followed by / (U+002F) or * (U+002A)> " @" ) ]

single_regular_balanced_text_character ::=

<Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B), } (U+007D) and new_line_character>
</ (U+002F), if not directly followed by / (U+002F) or * (U+002A)>

(Spec: Interpolated string literals)
(used in regular_balanced_text_part)
Never empty
MayStartWith: <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B), } (U+007D) and new_line_character> </ (U+002F), if not directly followed by / (U+002F) or * (U+002A)>
MayBeFollowedBy: } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> /* @ $ ( [ { <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B), } (U+007D) and new_line_character> </ (U+002F), if not directly followed by / (U+002F) or * (U+002A)> " @" ) ]

interpolation_format ::=

interpolation_format_character+

(Spec: Interpolated string literals)
(used in interpolated_regular_string_mid interpolated_regular_string_end interpolated_verbatim_string_mid interpolated_verbatim_string_end)
Never empty
MayStartWith: <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)>
MayBeFollowedBy: }

interpolation_format_character ::=

<Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)>

(Spec: Interpolated string literals)
(used in interpolation_format)
Never empty
MayStartWith: <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)>
MayBeFollowedBy: } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)>

interpolated_verbatim_string_literal ::=

interpolated_verbatim_string_whole
interpolated_verbatim_string_start interpolated_verbatim_string_literal_body interpolated_verbatim_string_end

(Spec: Interpolated string literals)
(used in interpolated_string_literal)
Never empty
MayStartWith: @"
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B), } (U+007D) and new_line_character> </ (U+002F), if not directly followed by / (U+002F) or * (U+002A)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B) and } (U+007D)>

interpolated_verbatim_string_whole ::=

@" interpolated_verbatim_string_character* "

(Spec: Interpolated string literals)
(used in interpolated_verbatim_string interpolated_verbatim_string_literal)
Never empty
MayStartWith: @"
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B), } (U+007D) and new_line_character> </ (U+002F), if not directly followed by / (U+002F) or * (U+002A)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B) and } (U+007D)>

interpolated_verbatim_string_mid ::=

interpolation_format? } interpolated_verbatim_string_characters_after_brace? {

(Spec: Interpolated string literals)
(used in interpolated_verbatim_string_body interpolated_verbatim_string_literal_body)
Never empty
MayStartWith: } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)>
MayBeFollowedBy: + - ! ~ new ++ -- ( await from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword> $ [ { <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B) and } (U+007D)> </ (U+002F), if not directly followed by / (U+002F) or * (U+002A)> // /*

interpolated_verbatim_string_end ::=

interpolation_format? } interpolated_verbatim_string_characters_after_brace? "

(Spec: Interpolated string literals)
(used in interpolated_verbatim_string interpolated_verbatim_string_literal)
Never empty
MayStartWith: } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)>
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B), } (U+007D) and new_line_character> </ (U+002F), if not directly followed by / (U+002F) or * (U+002A)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B) and } (U+007D)>

interpolated_verbatim_string_characters_after_brace ::=

interpolated_verbatim_string_character_no_brace
interpolated_verbatim_string_characters_after_brace interpolated_verbatim_string_character

(Spec: Interpolated string literals)
(used in interpolated_verbatim_string_mid interpolated_verbatim_string_end interpolated_verbatim_string_characters_after_brace)
Never empty
MayStartWith: <Any interpolated_verbatim_string_character except close_brace_escape_sequence>
MayBeFollowedBy: { " "" {{ }} <Any character except " (U+0022), { (U+007B) and } (U+007D)>

interpolated_verbatim_string_character_no_brace ::=

<Any interpolated_verbatim_string_character except close_brace_escape_sequence>

(Spec: Interpolated string literals)
(used in interpolated_verbatim_string_characters_after_brace)
Never empty
MayStartWith: <Any interpolated_verbatim_string_character except close_brace_escape_sequence>
MayBeFollowedBy: { " "" {{ }} <Any character except " (U+0022), { (U+007B) and } (U+007D)>

single_interpolated_verbatim_string_character ::=

<Any character except " (U+0022), { (U+007B) and } (U+007D)>

(Spec: Interpolated string literals)
(used in interpolated_verbatim_string_character)
Never empty
MayStartWith: <Any character except " (U+0022), { (U+007B) and } (U+007D)>
MayBeFollowedBy: " "" {{ }} <Any character except " (U+0022), { (U+007B) and } (U+007D)> {

verbatim_balanced_text_part ::=

single_verbatim_balanced_text_character
comment
@ identifier_or_keyword
string_literal
interpolated_string_literal
( verbatim_balanced_text )
[ verbatim_balanced_text ]
{ verbatim_balanced_text }

(Spec: Interpolated string literals)
(used in verbatim_balanced_text)
Never empty
MayStartWith: @ $ ( [ { <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B) and } (U+007D)> </ (U+002F), if not directly followed by / (U+002F) or * (U+002A)> // /* " @"
MayBeFollowedBy: } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> @ $ ( [ { <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B) and } (U+007D)> </ (U+002F), if not directly followed by / (U+002F) or * (U+002A)> // /* " @" ) ]

single_verbatim_balanced_text_character ::=

<Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B) and } (U+007D)>
</ (U+002F), if not directly followed by / (U+002F) or * (U+002A)>

(Spec: Interpolated string literals)
(used in verbatim_balanced_text_part)
Never empty
MayStartWith: <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B) and } (U+007D)> </ (U+002F), if not directly followed by / (U+002F) or * (U+002A)>
MayBeFollowedBy: } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> @ $ ( [ { <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B) and } (U+007D)> </ (U+002F), if not directly followed by / (U+002F) or * (U+002A)> // /* " @" ) ]

null_literal ::=

null

(Spec: The null literal)
(used in literal)
Never empty
MayStartWith: null
MayBeFollowedBy: [ . ( ++ -- ? -> * / = += -= *= /= %= &= |= ^= <<= >>= ; % + ) , - << >> < > <= >= is as == != & ^ | && || ?? } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let where join orderby equals on into ascending descending by const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

operator_or_punctuator ::=

{
}
[
]
(
)
.
,
:
;
+
-
*
/
%
&
|
^
!
~
=
<
>
?
??
::
++
--
&&
||
->
==
!=
<=
>=
+=
-=
*=
/=
%=
&=
|=
^=
<<
<<=
=>

(Spec: Operators and punctuators)
(used in token)
Never empty
MayStartWith: { } [ ] ( ) . , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= =>
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @"

right_shift ::=

(Spec: Operators and punctuators)
(used in shift_expression)
Never empty
MayStartWith: >>
MayBeFollowedBy: + - ! ~ new ++ -- ( await <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>

right_shift_assignment ::=

(Spec: Operators and punctuators)
(used in assignment_operator)
Never empty
MayStartWith: >>=
MayBeFollowedBy: + - ! ~ new ++ -- ( await from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>

pp_directive ::=

pp_declaration
pp_conditional
pp_line
pp_diagnostic
pp_region
pp_pragma

(Spec: Pre-processing directives)
(used in input_section_part skipped_section_part)
Never empty
MayStartWith: <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> #
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> # // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" <Any input_character except #>

pp_declaration ::=

whitespace? # whitespace? define whitespace conditional_symbol pp_new_line
whitespace? # whitespace? undef whitespace conditional_symbol pp_new_line

(Spec: Declaration directives)
(used in pp_directive)
Never empty
MayStartWith: <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> #
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> # // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" <Any input_character except #>

pp_new_line ::=

whitespace? single_line_comment? new_line

(Spec: Declaration directives)
(used in pp_declaration pp_if_section pp_elif_section pp_else_section pp_endif pp_line pp_pragma)
Never empty
MayStartWith: <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)>
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> # // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" <Any input_character except #>

pp_conditional ::=

pp_if_section pp_elif_section* pp_else_section? pp_endif

(Spec: Conditional compilation directives)
(used in pp_directive)
Never empty
MayStartWith: <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> #
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> # // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" <Any input_character except #>

pp_endif ::=

whitespace? # whitespace? endif pp_new_line

(Spec: Conditional compilation directives)
(used in pp_conditional)
Never empty
MayStartWith: <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> #
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> # // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" <Any input_character except #>

conditional_section ::=

input_section
skipped_section

(Spec: Conditional compilation directives)
(used in pp_if_section pp_elif_section pp_else_section pp_region)
Never empty
MayStartWith: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> # // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <Any input_character except #> <An identifier_or_keyword that is not a keyword> 0x 0X " @"
MayBeFollowedBy: <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> #

skipped_section_part ::=

skipped_characters? new_line
pp_directive

(Spec: Conditional compilation directives)
(used in skipped_section)
Never empty
MayStartWith: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> # <Any input_character except #>
MayBeFollowedBy: <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> # <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any input_character except #>

skipped_characters ::=

whitespace? not_number_sign input_character*

(Spec: Conditional compilation directives)
(used in skipped_section_part)
Never empty
MayStartWith: <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> <Any input_character except #>
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)>

not_number_sign ::=

<Any input_character except #>

(Spec: Conditional compilation directives)
(used in skipped_characters)
Never empty
MayStartWith: <Any input_character except #>
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any Unicode character except a new_line_character>

pp_diagnostic ::=

whitespace? # whitespace? error pp_message
whitespace? # whitespace? warning pp_message

(Spec: Diagnostic directives)
(used in pp_directive)
Never empty
MayStartWith: <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> #
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> # // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" <Any input_character except #>

pp_message ::=

new_line
whitespace input_character* new_line

(Spec: Diagnostic directives)
(used in pp_diagnostic pp_start_region pp_end_region)
Never empty
MayStartWith: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)>
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> # // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" <Any input_character except #>

pp_region ::=

pp_start_region conditional_section? pp_end_region

(Spec: Region directives)
(used in pp_directive)
Never empty
MayStartWith: <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> #
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> # // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" <Any input_character except #>

pp_start_region ::=

whitespace? # whitespace? region pp_message

(Spec: Region directives)
(used in pp_region)
Never empty
MayStartWith: <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> #
MayBeFollowedBy: <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> # <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <Any input_character except #> <An identifier_or_keyword that is not a keyword> 0x 0X " @"

pp_end_region ::=

whitespace? # whitespace? endregion pp_message

(Spec: Region directives)
(used in pp_region)
Never empty
MayStartWith: <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> #
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> # // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" <Any input_character except #>

pp_line ::=

whitespace? # whitespace? line whitespace line_indicator pp_new_line

(Spec: Line directives)
(used in pp_directive)
Never empty
MayStartWith: <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> #
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> # // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" <Any input_character except #>

file_name ::=

" file_name_character+ "

(Spec: Line directives)
(used in line_indicator)
Never empty
MayStartWith: "
MayBeFollowedBy: <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)>

file_name_character ::=

<Any input_character except ">

(Spec: Line directives)
(used in file_name)
Never empty
MayStartWith: <Any input_character except ">
MayBeFollowedBy: " <Any input_character except ">

pp_pragma ::=

whitespace? # whitespace? pragma whitespace pragma_body pp_new_line

(Spec: Pragma directives)
(used in pp_directive)
Never empty
MayStartWith: <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> #
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> # // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" <Any input_character except #>

pragma_body ::=

pragma_warning_body

(Spec: Pragma directives)
(used in pp_pragma)
Never empty
MayStartWith: warning
MayBeFollowedBy: <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)>

warning_action ::=

disable
restore

(Spec: Pragma warning)
(used in pragma_warning_body)
Never empty
MayStartWith: disable restore
MayBeFollowedBy: <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)>

interpolated_string ::=

<UNDEFINED>

(used in primary_no_array_creation_expression)
Never empty
MayStartWith: <UNDEFINED>
MayBeFollowedBy: [ . ( ++ -- ? -> * / = += -= *= /= %= &= |= ^= <<= >>= ; % + ) , - << >> < > <= >= is as == != & ^ | && || ?? } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let where join orderby equals on into ascending descending by const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

'

(used in character_literal)
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" \u \U <Any character except ' (U+0027), \ (U+005C), and new_line_character> \' \" \\ \0 \a \b \f \n \r \t \v \x >>= >> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

-

(used in unary_expression additive_expression overloadable_unary_operator overloadable_binary_operator sign operator_or_punctuator)
MayBeFollowedBy: + - ! ~ new ++ -- ( await <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword> <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as break case catch class const continue do else enum event explicit extern finally fixed for foreach goto if implicit in interface internal is lock namespace operator out override params private protected public readonly ref return sealed stackalloc static struct switch throw try unsafe using virtual void volatile while $ { } [ ] ) , : ; / % | ^ = < > ? ?? :: && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= =>

--

(used in post_decrement_expression pre_decrement_expression overloadable_unary_operator operator_or_punctuator)
MayBeFollowedBy: + - ! ~ new ++ -- ( await <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword> <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as break case catch class const continue do else enum event explicit extern finally fixed for foreach goto if implicit in interface internal is lock namespace operator out override params private protected public readonly ref return sealed stackalloc static struct switch throw try unsafe using virtual void volatile while $ { } [ ] ) , : ; / % | ^ = < > ? ?? :: && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => >>= >> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

!

(used in unary_expression overloadable_unary_operator operator_or_punctuator pp_unary_expression)
MayBeFollowedBy: + - ! ~ new ++ -- ( await <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword> <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as break case catch class const continue do else enum event explicit extern finally fixed for foreach goto if implicit in interface internal is lock namespace operator out override params private protected public readonly ref return sealed stackalloc static struct switch throw try unsafe using virtual void volatile while $ { } [ ] ) , : ; / % | ^ = < > ? ?? :: && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <Any identifier_or_keyword except true or false>

!=

(used in equality_expression overloadable_binary_operator operator_or_punctuator pp_equality_expression)
MayBeFollowedBy: + - ! ~ new ++ -- ( await <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword> <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as break case catch class const continue do else enum event explicit extern finally fixed for foreach goto if implicit in interface internal is lock namespace operator out override params private protected public readonly ref return sealed stackalloc static struct switch throw try unsafe using virtual void volatile while $ { } [ ] ) , : ; / % | ^ = < > ? ?? :: && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <Any identifier_or_keyword except true or false>

"

(used in regular_string_literal verbatim_string_literal interpolated_regular_string_whole interpolated_regular_string_start interpolated_regular_string_end interpolated_verbatim_string_whole interpolated_verbatim_string_end file_name)
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" \' \" \\ \0 \a \b \f \n \r \t \v \x \u \U <Any character except " (U+0022), \ (U+005C), and new_line_character> <Any character except " (U+0022), \ (U+005C), { (U+007B), } (U+007D), and new_line_character> {{ }} <Any input_character except "> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B), } (U+007D) and new_line_character> </ (U+002F), if not directly followed by / (U+002F) or * (U+002A)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B) and } (U+007D)> >>= >> from select group let where join orderby equals on into ascending descending by partial dynamic

""

(used in quote_escape_sequence)
MayBeFollowedBy: " <any character except "> "" {{ }} <Any character except " (U+0022), { (U+007B) and } (U+007D)> {

$

(used in interpolated_string_expression interpolated_string_literal)
MayBeFollowedBy: " @"

%

(used in multiplicative_expression overloadable_binary_operator operator_or_punctuator)
MayBeFollowedBy: + - ! ~ new ++ -- ( await <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword> <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as break case catch class const continue do else enum event explicit extern finally fixed for foreach goto if implicit in interface internal is lock namespace operator out override params private protected public readonly ref return sealed stackalloc static struct switch throw try unsafe using virtual void volatile while $ { } [ ] ) , : ; / % | ^ = < > ? ?? :: && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= =>

%=

(used in assignment_operator operator_or_punctuator)
MayBeFollowedBy: + - ! ~ new ++ -- ( await from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword> <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as break case catch class const continue do else enum event explicit extern finally fixed for foreach goto if implicit in interface internal is lock namespace operator out override params private protected public readonly ref return sealed stackalloc static struct switch throw try unsafe using virtual void volatile while $ { } [ ] ) , : ; / % | ^ = < > ? ?? :: && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= =>

&

(used in and_expression overloadable_binary_operator addressof_expression fixed_pointer_initializer operator_or_punctuator)
MayBeFollowedBy: + - ! ~ new ++ -- ( await <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword> from <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as break case catch class const continue do else enum event explicit extern finally fixed for foreach goto if implicit in interface internal is lock namespace operator out override params private protected public readonly ref return sealed stackalloc static struct switch throw try unsafe using virtual void volatile while $ { } [ ] ) , : ; / % | ^ = < > ? ?? :: && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= =>

&&

(used in conditional_and_expression operator_or_punctuator pp_and_expression)
MayBeFollowedBy: + - ! ~ new ++ -- ( await <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword> <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as break case catch class const continue do else enum event explicit extern finally fixed for foreach goto if implicit in interface internal is lock namespace operator out override params private protected public readonly ref return sealed stackalloc static struct switch throw try unsafe using virtual void volatile while $ { } [ ] ) , : ; / % | ^ = < > ? ?? :: && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <Any identifier_or_keyword except true or false>

&=

(used in assignment_operator operator_or_punctuator)
MayBeFollowedBy: + - ! ~ new ++ -- ( await from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword> <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as break case catch class const continue do else enum event explicit extern finally fixed for foreach goto if implicit in interface internal is lock namespace operator out override params private protected public readonly ref return sealed stackalloc static struct switch throw try unsafe using virtual void volatile while $ { } [ ] ) , : ; / % | ^ = < > ? ?? :: && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= =>

(

(used in parenthesized_expression invocation_expression object_creation_expression delegate_creation_expression typeof_expression checked_expression unchecked_expression default_value_expression nameof_expression null_conditional_operations null_conditional_invocation_expression cast_expression explicit_anonymous_function_signature implicit_anonymous_function_signature if_statement switch_statement while_statement do_statement for_statement foreach_statement exception_specifier exception_filter lock_statement using_statement constructor_constraint method_header unary_operator_declarator binary_operator_declarator conversion_operator_declarator constructor_declarator constructor_initializer static_constructor_declaration destructor_declaration interface_method_declaration delegate_declaration attribute_arguments destructor_declaration_unsafe sizeof_expression fixed_statement regular_balanced_text_part verbatim_balanced_text_part operator_or_punctuator pp_primary_expression)
MayBeFollowedBy: + - ! ~ new ++ -- ( await from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword> ) ref out dynamic void ; var params [ /* $ { <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B), } (U+007D) and new_line_character> </ (U+002F), if not directly followed by / (U+002F) or * (U+002A)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B) and } (U+007D)> // <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> abstract as break case catch class const continue do else enum event explicit extern finally fixed for foreach goto if implicit in interface internal is lock namespace operator override private protected public readonly return sealed stackalloc static struct switch throw try unsafe using virtual volatile while } ] , : / % | ^ = < > ? ?? :: && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <Any identifier_or_keyword except true or false>

)

(used in parenthesized_expression invocation_expression object_creation_expression delegate_creation_expression typeof_expression checked_expression unchecked_expression default_value_expression nameof_expression null_conditional_operations null_conditional_invocation_expression cast_expression explicit_anonymous_function_signature implicit_anonymous_function_signature if_statement switch_statement while_statement do_statement for_statement foreach_statement exception_specifier exception_filter lock_statement using_statement constructor_constraint method_header unary_operator_declarator binary_operator_declarator conversion_operator_declarator constructor_declarator constructor_initializer static_constructor_declaration destructor_declaration interface_method_declaration delegate_declaration attribute_arguments destructor_declaration_unsafe sizeof_expression fixed_statement regular_balanced_text_part verbatim_balanced_text_part operator_or_punctuator pp_primary_expression)
MayBeFollowedBy: { ? . [ + - ! ~ new ++ -- ( await <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword> => ; try lock using yield if switch while do for foreach break continue goto return throw unsafe fixed when where : ] , } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> /* $ <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B), } (U+007D) and new_line_character> </ (U+002F), if not directly followed by / (U+002F) or * (U+002A)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B) and } (U+007D)> // <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> abstract as case catch class const else enum event explicit extern finally implicit in interface internal is namespace operator out override params private protected public readonly ref sealed stackalloc static struct virtual void volatile ) / % | ^ = < > ?? :: && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= >>= >> from select group let join orderby equals on into ascending descending by partial dynamic

*

(used in multiplicative_expression overloadable_binary_operator pointer_type pointer_indirection_expression asterisk operator_or_punctuator)
MayBeFollowedBy: + - ! ~ new ++ -- ( await <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword> / <Any Unicode character except / or *> <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as break case catch class const continue do else enum event explicit extern finally fixed for foreach goto if implicit in interface internal is lock namespace operator out override params private protected public readonly ref return sealed stackalloc static struct switch throw try unsafe using virtual void volatile while $ { } [ ] ) , : ; % | ^ = < > ? ?? :: && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

*=

(used in assignment_operator operator_or_punctuator)
MayBeFollowedBy: + - ! ~ new ++ -- ( await from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword> <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as break case catch class const continue do else enum event explicit extern finally fixed for foreach goto if implicit in interface internal is lock namespace operator out override params private protected public readonly ref return sealed stackalloc static struct switch throw try unsafe using virtual void volatile while $ { } [ ] ) , : ; / % | ^ = < > ? ?? :: && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= =>

,

(used in dim_separator type_arguments argument_list interpolation object_initializer member_initializer_list collection_initializer element_initializer_list expression_list anonymous_object_initializer member_declarator_list comma explicit_anonymous_function_parameter_list implicit_anonymous_function_parameter_list orderings local_variable_declarators constant_declarators statement_expression_list type_parameters class_base interface_type_list type_parameter_constraints secondary_constraints variable_declarators formal_parameter_list fixed_parameters binary_operator_declarator array_initializer variable_initializer_list variant_type_parameters enum_body enum_member_declarations global_attribute_section attribute_section attribute_list attribute_arguments positional_argument_list named_argument_list fixed_pointer_declarators operator_or_punctuator warning_list)
MayBeFollowedBy: ] , object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double ref out + - ! ~ new ++ -- ( await from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null sizeof 0x 0X " @" } [ { > params in <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as break case catch class const continue do else enum event explicit extern finally fixed for foreach goto if implicit interface internal is lock namespace operator override private protected public readonly return sealed stackalloc static struct switch throw try unsafe using virtual volatile while $ ) : ; / % | ^ = < ? ?? :: && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= =>

.

(used in qualified_identifier namespace_or_type_name member_access base_access unbound_type_name named_entity null_conditional_operations null_conditional_member_access member_name indexer_declarator real_literal operator_or_punctuator)
MayBeFollowedBy: @ <An identifier_or_keyword that is not a keyword> this 0 1 2 3 4 5 6 7 8 9 <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => 0x 0X " @"

/

(used in multiplicative_expression overloadable_binary_operator delimited_doc_comment delimited_comment delimited_comment_section operator_or_punctuator)
MayBeFollowedBy: + - ! ~ new ++ -- ( await <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword> <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as break case catch class const continue do else enum event explicit extern finally fixed for foreach goto if implicit in interface internal is lock namespace operator out override params private protected public readonly ref return sealed stackalloc static struct switch throw try unsafe using virtual void volatile while $ { } [ ] ) , : ; / % | ^ = < > ? ?? :: && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <Any Unicode character except / or *> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B), } (U+007D) and new_line_character> </ (U+002F), if not directly followed by / (U+002F) or * (U+002A)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B) and } (U+007D)>

/*

(used in delimited_comment)
MayBeFollowedBy: / * <Any Unicode character except / or *>

/**

(used in delimited_doc_comment)
MayBeFollowedBy: / * <Any Unicode character except / or *>

//

(used in single_line_comment)
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" <Any Unicode character except a new_line_character> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B) and } (U+007D)> </ (U+002F), if not directly followed by / (U+002F) or * (U+002A)>

///

(used in single_line_doc_comment)
MayBeFollowedBy: <Any Unicode character except a new_line_character>

/=

(used in assignment_operator operator_or_punctuator)
MayBeFollowedBy: + - ! ~ new ++ -- ( await from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword> <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as break case catch class const continue do else enum event explicit extern finally fixed for foreach goto if implicit in interface internal is lock namespace operator out override params private protected public readonly ref return sealed stackalloc static struct switch throw try unsafe using virtual void volatile while $ { } [ ] ) , : ; / % | ^ = < > ? ?? :: && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= =>

:

(used in argument_name conditional_expression labeled_statement switch_label class_base type_parameter_constraints_clause constructor_initializer struct_interfaces interface_base enum_base global_attribute_target_specifier attribute_target_specifier operator_or_punctuator)
MayBeFollowedBy: ref out + - ! ~ new ++ -- ( await from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword> const { ; try lock using yield var if switch while do for foreach break continue goto return throw unsafe fixed dynamic void case class struct <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as catch else enum event explicit extern finally implicit in interface internal is namespace operator override params private protected public readonly sealed stackalloc static virtual volatile $ } [ ] ) , : / % | ^ = < > ? ?? :: && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= =>

::

(used in qualified_alias_member unbound_type_name operator_or_punctuator)
MayBeFollowedBy: @ <An identifier_or_keyword that is not a keyword> <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => 0x 0X " @"

;

(used in namespace_declaration extern_alias_directive using_alias_directive using_namespace_directive using_static_directive empty_statement declaration_statement expression_statement do_statement for_statement break_statement continue_statement goto_statement return_statement throw_statement yield_statement class_declaration constant_declaration field_declaration method_body property_body accessor_body event_declaration indexer_body operator_body constructor_body static_constructor_body destructor_body struct_declaration interface_declaration interface_method_declaration interface_accessors interface_event_declaration enum_declaration delegate_declaration fixed_size_buffer_declaration operator_or_punctuator)
MayBeFollowedBy: namespace partial class struct interface enum delegate new public protected internal private abstract sealed static [ unsafe using extern } ) + - ! ~ ++ -- await ( <UNDEFINED> this base typeof checked unchecked default nameof * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword> ; from const event readonly volatile virtual override dynamic void set get fixed <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* as break case catch continue do else explicit finally for foreach goto if implicit in is lock operator out params ref return stackalloc switch throw try while $ { ] , : / % | ^ = < > ? ?? :: && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => yield var

?

(used in nullable_type null_conditional_operations null_conditional_member_access conditional_expression operator_or_punctuator)
MayBeFollowedBy: . [ + - ! ~ new ++ -- ( await from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword> <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as break case catch class const continue do else enum event explicit extern finally fixed for foreach goto if implicit in interface internal is lock namespace operator out override params private protected public readonly ref return sealed stackalloc static struct switch throw try unsafe using virtual void volatile while $ { } ] ) , : ; / % | ^ = < > ? ?? :: && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> select group let where join orderby equals on into ascending descending by partial dynamic

??

(used in null_coalescing_expression operator_or_punctuator)
MayBeFollowedBy: + - ! ~ new ++ -- ( await <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword> <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as break case catch class const continue do else enum event explicit extern finally fixed for foreach goto if implicit in interface internal is lock namespace operator out override params private protected public readonly ref return sealed stackalloc static struct switch throw try unsafe using virtual void volatile while $ { } [ ] ) , : ; / % | ^ = < > ? ?? :: && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= =>

@

(used in identifier regular_balanced_text_part verbatim_balanced_text_part)
MayBeFollowedBy: _ <A Unicode character of classes Lu, Ll, Lt, Lm, Lo, or Nl> <A unicode_escape_sequence representing a character of classes Lu, Ll, Lt, Lm, Lo, or Nl>

@"

(used in verbatim_string_literal interpolated_verbatim_string_whole interpolated_verbatim_string_start)
MayBeFollowedBy: " <any character except "> "" {{ }} <Any character except " (U+0022), { (U+007B) and } (U+007D)> {

[

(used in rank_specifier element_access base_access initializer_target array_creation_expression null_conditional_operations indexer_declarator interface_indexer_declaration global_attribute_section attribute_section pointer_element_access fixed_size_buffer_declarator stackalloc_initializer regular_balanced_text_part verbatim_balanced_text_part operator_or_punctuator)
MayBeFollowedBy: ] , + - ! ~ new ++ -- ( await from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword> ref out params [ dynamic void assembly module field event method param property return type /* $ { <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B), } (U+007D) and new_line_character> </ (U+002F), if not directly followed by / (U+002F) or * (U+002A)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B) and } (U+007D)> // <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> abstract as break case catch class const continue do else enum explicit extern finally fixed for foreach goto if implicit in interface internal is lock namespace operator override private protected public readonly sealed stackalloc static struct switch throw try unsafe using virtual volatile while } ) : ; / % | ^ = < > ? ?? :: && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= =>

\u

(used in unicode_escape_sequence)
MayBeFollowedBy: 0 1 2 3 4 5 6 7 8 9 A B C D E F a b c d e f

\U

(used in unicode_escape_sequence)
MayBeFollowedBy: 0 1 2 3 4 5 6 7 8 9 A B C D E F a b c d e f

\x

(used in hexadecimal_escape_sequence)
MayBeFollowedBy: 0 1 2 3 4 5 6 7 8 9 A B C D E F a b c d e f

]

(used in rank_specifier element_access base_access initializer_target array_creation_expression null_conditional_operations indexer_declarator interface_indexer_declaration global_attribute_section attribute_section pointer_element_access fixed_size_buffer_declarator stackalloc_initializer regular_balanced_text_part verbatim_balanced_text_part operator_or_punctuator)
MayBeFollowedBy: [ = { ? . => namespace partial class struct interface enum delegate new public protected internal private abstract sealed static unsafe @ <An identifier_or_keyword that is not a keyword> const object dynamic string void bool decimal sbyte byte short ushort int uint long ulong char float double readonly volatile virtual override extern ref out this params get set event add remove ~ in ; } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> /* $ ( <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B), } (U+007D) and new_line_character> </ (U+002F), if not directly followed by / (U+002F) or * (U+002A)> " @" <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B) and } (U+007D)> // <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> as base break case catch checked continue default do else explicit false finally fixed for foreach goto if implicit is lock null operator return sizeof stackalloc switch throw true try typeof unchecked using while 0 1 2 3 4 5 6 7 8 9 ' ] ) , : + - * / % & | ^ ! < > ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= 0x 0X >>= >> from select group let where join orderby equals on into ascending descending by

^

(used in exclusive_or_expression overloadable_binary_operator operator_or_punctuator)
MayBeFollowedBy: + - ! ~ new ++ -- ( await <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword> <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as break case catch class const continue do else enum event explicit extern finally fixed for foreach goto if implicit in interface internal is lock namespace operator out override params private protected public readonly ref return sealed stackalloc static struct switch throw try unsafe using virtual void volatile while $ { } [ ] ) , : ; / % | ^ = < > ? ?? :: && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= =>

^=

(used in assignment_operator operator_or_punctuator)
MayBeFollowedBy: + - ! ~ new ++ -- ( await from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword> <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as break case catch class const continue do else enum event explicit extern finally fixed for foreach goto if implicit in interface internal is lock namespace operator out override params private protected public readonly ref return sealed stackalloc static struct switch throw try unsafe using virtual void volatile while $ { } [ ] ) , : ; / % | ^ = < > ? ?? :: && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= =>

_

(used in identifier_start_character)
MayBeFollowedBy: { . ; = < :: : ) ? } , => in select group from let where join orderby ( [ <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 ' $ ] + - * / % & | ^ ! ~ > ?? ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= <An identifier_or_keyword that is not a keyword> 0x 0X " @" <A Unicode character of classes Lu, Ll, Lt, Lm, Lo, or Nl> <A unicode_escape_sequence representing a character of classes Lu, Ll, Lt, Lm, Lo, or Nl> <A Unicode character of the class Nd> <A unicode_escape_sequence representing a character of the class Nd> <A Unicode character of the class Pc> <A unicode_escape_sequence representing a character of the class Pc> <A Unicode character of classes Mn or Mc> <A unicode_escape_sequence representing a character of classes Mn or Mc> <A Unicode character of the class Cf> <A unicode_escape_sequence representing a character of the class Cf> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B), } (U+007D) and new_line_character> </ (U+002F), if not directly followed by / (U+002F) or * (U+002A)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B) and } (U+007D)> >>= >> equals on into ascending descending by partial dynamic

{

(used in namespace_body object_initializer collection_initializer element_initializer anonymous_object_initializer block switch_block class_body property_body event_declaration indexer_body struct_body array_initializer interface_body interface_property_declaration interface_indexer_declaration enum_body interpolated_regular_string_start interpolated_regular_string_mid regular_balanced_text_part interpolated_verbatim_string_start interpolated_verbatim_string_mid verbatim_balanced_text_part operator_or_punctuator)
MayBeFollowedBy: } namespace partial class struct interface enum delegate new public protected internal private abstract sealed static [ unsafe using extern @ <An identifier_or_keyword that is not a keyword> { + - ! ~ ++ -- ( await from <UNDEFINED> this base typeof checked unchecked default nameof * & true false 0 1 2 3 4 5 6 7 8 9 . ' null bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" const ; try lock yield var if switch while do for foreach break continue goto return throw fixed dynamic void case event readonly volatile virtual override get set add remove /* $ <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B), } (U+007D) and new_line_character> </ (U+002F), if not directly followed by / (U+002F) or * (U+002A)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B) and } (U+007D)> // <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> as catch else explicit finally implicit in is operator out params ref stackalloc ] ) , : / % | ^ = < > ? ?? :: && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= =>

|

(used in inclusive_or_expression overloadable_binary_operator operator_or_punctuator)
MayBeFollowedBy: + - ! ~ new ++ -- ( await <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword> <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as break case catch class const continue do else enum event explicit extern finally fixed for foreach goto if implicit in interface internal is lock namespace operator out override params private protected public readonly ref return sealed stackalloc static struct switch throw try unsafe using virtual void volatile while $ { } [ ] ) , : ; / % | ^ = < > ? ?? :: && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= =>

||

(used in conditional_or_expression operator_or_punctuator pp_or_expression)
MayBeFollowedBy: + - ! ~ new ++ -- ( await <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword> <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as break case catch class const continue do else enum event explicit extern finally fixed for foreach goto if implicit in interface internal is lock namespace operator out override params private protected public readonly ref return sealed stackalloc static struct switch throw try unsafe using virtual void volatile while $ { } [ ] ) , : ; / % | ^ = < > ? ?? :: && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <Any identifier_or_keyword except true or false>

|=

(used in assignment_operator operator_or_punctuator)
MayBeFollowedBy: + - ! ~ new ++ -- ( await from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword> <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as break case catch class const continue do else enum event explicit extern finally fixed for foreach goto if implicit in interface internal is lock namespace operator out override params private protected public readonly ref return sealed stackalloc static struct switch throw try unsafe using virtual void volatile while $ { } [ ] ) , : ; / % | ^ = < > ? ?? :: && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= =>

}

(used in namespace_body object_initializer collection_initializer element_initializer anonymous_object_initializer block switch_block class_body property_body event_declaration indexer_body struct_body array_initializer interface_body interface_property_declaration interface_indexer_declaration enum_body interpolated_regular_string_mid interpolated_regular_string_end regular_balanced_text_part interpolated_verbatim_string_mid interpolated_verbatim_string_end verbatim_balanced_text_part operator_or_punctuator)
MayBeFollowedBy: ; } , namespace partial class struct interface enum delegate new public protected internal private abstract sealed static [ unsafe const event extern ~ readonly volatile virtual override object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double = { <Any interpolated_regular_string_character except close_brace_escape_sequence and any hexadecimal_escape_sequence or unicode_escape_sequence designating } (U+007D)> " <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> /* $ ( <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B), } (U+007D) and new_line_character> </ (U+002F), if not directly followed by / (U+002F) or * (U+002A)> @" <Any interpolated_verbatim_string_character except close_brace_escape_sequence> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B) and } (U+007D)> // <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> as base break case catch checked continue default do else explicit false finally fixed for foreach goto if implicit in is lock null operator out params ref return sizeof stackalloc switch this throw true try typeof unchecked using while 0 1 2 3 4 5 6 7 8 9 . ' ] ) : + - * / % & | ^ ! < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => 0x 0X set get remove add from select group let where join orderby equals on into ascending descending by yield var await <UNDEFINED> nameof >>= >>

~

(used in unary_expression overloadable_unary_operator destructor_declaration destructor_declaration_unsafe operator_or_punctuator)
MayBeFollowedBy: + - ! ~ new ++ -- ( await <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword> <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as break case catch class const continue do else enum event explicit extern finally fixed for foreach goto if implicit in interface internal is lock namespace operator out override params private protected public readonly ref return sealed stackalloc static struct switch throw try unsafe using virtual void volatile while $ { } [ ] ) , : ; / % | ^ = < > ? ?? :: && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= =>

+

(used in unary_expression additive_expression overloadable_unary_operator overloadable_binary_operator sign operator_or_punctuator)
MayBeFollowedBy: + - ! ~ new ++ -- ( await <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword> <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as break case catch class const continue do else enum event explicit extern finally fixed for foreach goto if implicit in interface internal is lock namespace operator out override params private protected public readonly ref return sealed stackalloc static struct switch throw try unsafe using virtual void volatile while $ { } [ ] ) , : ; / % | ^ = < > ? ?? :: && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= =>

++

(used in post_increment_expression pre_increment_expression overloadable_unary_operator operator_or_punctuator)
MayBeFollowedBy: + - ! ~ new ++ -- ( await <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword> <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as break case catch class const continue do else enum event explicit extern finally fixed for foreach goto if implicit in interface internal is lock namespace operator out override params private protected public readonly ref return sealed stackalloc static struct switch throw try unsafe using virtual void volatile while $ { } [ ] ) , : ; / % | ^ = < > ? ?? :: && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => >>= >> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

+=

(used in assignment_operator operator_or_punctuator)
MayBeFollowedBy: + - ! ~ new ++ -- ( await from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword> <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as break case catch class const continue do else enum event explicit extern finally fixed for foreach goto if implicit in interface internal is lock namespace operator out override params private protected public readonly ref return sealed stackalloc static struct switch throw try unsafe using virtual void volatile while $ { } [ ] ) , : ; / % | ^ = < > ? ?? :: && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= =>

<

(used in type_argument_list generic_dimension_specifier relational_expression type_parameter_list overloadable_binary_operator variant_type_parameter_list operator_or_punctuator)
MayBeFollowedBy: object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double > , + - ! ~ new ++ -- ( await <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null sizeof 0x 0X " @" [ in out <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as break case catch class const continue do else enum event explicit extern finally fixed for foreach goto if implicit interface internal is lock namespace operator override params private protected public readonly ref return sealed stackalloc static struct switch throw try unsafe using virtual volatile while $ { } ] ) : ; / % | ^ = < ? ?? :: && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= =>

<<

(used in shift_expression overloadable_binary_operator operator_or_punctuator)
MayBeFollowedBy: + - ! ~ new ++ -- ( await <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword> <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as break case catch class const continue do else enum event explicit extern finally fixed for foreach goto if implicit in interface internal is lock namespace operator out override params private protected public readonly ref return sealed stackalloc static struct switch throw try unsafe using virtual void volatile while $ { } [ ] ) , : ; / % | ^ = < > ? ?? :: && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= =>

<<=

(used in assignment_operator operator_or_punctuator)
MayBeFollowedBy: + - ! ~ new ++ -- ( await from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword> <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as break case catch class const continue do else enum event explicit extern finally fixed for foreach goto if implicit in interface internal is lock namespace operator out override params private protected public readonly ref return sealed stackalloc static struct switch throw try unsafe using virtual void volatile while $ { } [ ] ) , : ; / % | ^ = < > ? ?? :: && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= =>

<=

(used in relational_expression overloadable_binary_operator operator_or_punctuator)
MayBeFollowedBy: + - ! ~ new ++ -- ( await <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword> <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as break case catch class const continue do else enum event explicit extern finally fixed for foreach goto if implicit in interface internal is lock namespace operator out override params private protected public readonly ref return sealed stackalloc static struct switch throw try unsafe using virtual void volatile while $ { } [ ] ) , : ; / % | ^ = < > ? ?? :: && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= =>

<A Unicode character of classes Lu, Ll, Lt, Lm, Lo, or Nl>

(used in letter_character)
MayBeFollowedBy: { . ; = < :: : ) ? } , => in select group from let where join orderby ( [ <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 ' $ ] + - * / % & | ^ ! ~ > ?? ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= <An identifier_or_keyword that is not a keyword> 0x 0X " @" <A Unicode character of classes Lu, Ll, Lt, Lm, Lo, or Nl> <A unicode_escape_sequence representing a character of classes Lu, Ll, Lt, Lm, Lo, or Nl> <A Unicode character of the class Nd> <A unicode_escape_sequence representing a character of the class Nd> <A Unicode character of the class Pc> <A unicode_escape_sequence representing a character of the class Pc> <A Unicode character of classes Mn or Mc> <A unicode_escape_sequence representing a character of classes Mn or Mc> <A Unicode character of the class Cf> <A unicode_escape_sequence representing a character of the class Cf> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B), } (U+007D) and new_line_character> </ (U+002F), if not directly followed by / (U+002F) or * (U+002A)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B) and } (U+007D)> >>= >> equals on into ascending descending by partial dynamic

<A Unicode character of classes Mn or Mc>

(used in combining_character)
MayBeFollowedBy: { . ; = < :: : ) ? } , => in select group from let where join orderby ( [ <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 ' $ ] + - * / % & | ^ ! ~ > ?? ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= <An identifier_or_keyword that is not a keyword> 0x 0X " @" <A Unicode character of classes Lu, Ll, Lt, Lm, Lo, or Nl> <A unicode_escape_sequence representing a character of classes Lu, Ll, Lt, Lm, Lo, or Nl> <A Unicode character of the class Nd> <A unicode_escape_sequence representing a character of the class Nd> <A Unicode character of the class Pc> <A unicode_escape_sequence representing a character of the class Pc> <A Unicode character of classes Mn or Mc> <A unicode_escape_sequence representing a character of classes Mn or Mc> <A Unicode character of the class Cf> <A unicode_escape_sequence representing a character of the class Cf> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B), } (U+007D) and new_line_character> </ (U+002F), if not directly followed by / (U+002F) or * (U+002A)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B) and } (U+007D)> >>= >> equals on into ascending descending by partial dynamic

<A Unicode character of the class Cf>

(used in formatting_character)
MayBeFollowedBy: { . ; = < :: : ) ? } , => in select group from let where join orderby ( [ <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 ' $ ] + - * / % & | ^ ! ~ > ?? ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= <An identifier_or_keyword that is not a keyword> 0x 0X " @" <A Unicode character of classes Lu, Ll, Lt, Lm, Lo, or Nl> <A unicode_escape_sequence representing a character of classes Lu, Ll, Lt, Lm, Lo, or Nl> <A Unicode character of the class Nd> <A unicode_escape_sequence representing a character of the class Nd> <A Unicode character of the class Pc> <A unicode_escape_sequence representing a character of the class Pc> <A Unicode character of classes Mn or Mc> <A unicode_escape_sequence representing a character of classes Mn or Mc> <A Unicode character of the class Cf> <A unicode_escape_sequence representing a character of the class Cf> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B), } (U+007D) and new_line_character> </ (U+002F), if not directly followed by / (U+002F) or * (U+002A)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B) and } (U+007D)> >>= >> equals on into ascending descending by partial dynamic

<A Unicode character of the class Nd>

(used in decimal_digit_character)
MayBeFollowedBy: { . ; = < :: : ) ? } , => in select group from let where join orderby ( [ <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 ' $ ] + - * / % & | ^ ! ~ > ?? ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= <An identifier_or_keyword that is not a keyword> 0x 0X " @" <A Unicode character of classes Lu, Ll, Lt, Lm, Lo, or Nl> <A unicode_escape_sequence representing a character of classes Lu, Ll, Lt, Lm, Lo, or Nl> <A Unicode character of the class Nd> <A unicode_escape_sequence representing a character of the class Nd> <A Unicode character of the class Pc> <A unicode_escape_sequence representing a character of the class Pc> <A Unicode character of classes Mn or Mc> <A unicode_escape_sequence representing a character of classes Mn or Mc> <A Unicode character of the class Cf> <A unicode_escape_sequence representing a character of the class Cf> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B), } (U+007D) and new_line_character> </ (U+002F), if not directly followed by / (U+002F) or * (U+002A)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B) and } (U+007D)> >>= >> equals on into ascending descending by partial dynamic

<A Unicode character of the class Pc>

(used in connecting_character)
MayBeFollowedBy: { . ; = < :: : ) ? } , => in select group from let where join orderby ( [ <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 ' $ ] + - * / % & | ^ ! ~ > ?? ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= <An identifier_or_keyword that is not a keyword> 0x 0X " @" <A Unicode character of classes Lu, Ll, Lt, Lm, Lo, or Nl> <A unicode_escape_sequence representing a character of classes Lu, Ll, Lt, Lm, Lo, or Nl> <A Unicode character of the class Nd> <A unicode_escape_sequence representing a character of the class Nd> <A Unicode character of the class Pc> <A unicode_escape_sequence representing a character of the class Pc> <A Unicode character of classes Mn or Mc> <A unicode_escape_sequence representing a character of classes Mn or Mc> <A Unicode character of the class Cf> <A unicode_escape_sequence representing a character of the class Cf> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B), } (U+007D) and new_line_character> </ (U+002F), if not directly followed by / (U+002F) or * (U+002A)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B) and } (U+007D)> >>= >> equals on into ascending descending by partial dynamic

<A unicode_escape_sequence representing a character of classes Lu, Ll, Lt, Lm, Lo, or Nl>

(used in letter_character)
MayBeFollowedBy: { . ; = < :: : ) ? } , => in select group from let where join orderby ( [ <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 ' $ ] + - * / % & | ^ ! ~ > ?? ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= <An identifier_or_keyword that is not a keyword> 0x 0X " @" <A Unicode character of classes Lu, Ll, Lt, Lm, Lo, or Nl> <A unicode_escape_sequence representing a character of classes Lu, Ll, Lt, Lm, Lo, or Nl> <A Unicode character of the class Nd> <A unicode_escape_sequence representing a character of the class Nd> <A Unicode character of the class Pc> <A unicode_escape_sequence representing a character of the class Pc> <A Unicode character of classes Mn or Mc> <A unicode_escape_sequence representing a character of classes Mn or Mc> <A Unicode character of the class Cf> <A unicode_escape_sequence representing a character of the class Cf> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B), } (U+007D) and new_line_character> </ (U+002F), if not directly followed by / (U+002F) or * (U+002A)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B) and } (U+007D)> >>= >> equals on into ascending descending by partial dynamic

<A unicode_escape_sequence representing a character of classes Mn or Mc>

(used in combining_character)
MayBeFollowedBy: { . ; = < :: : ) ? } , => in select group from let where join orderby ( [ <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 ' $ ] + - * / % & | ^ ! ~ > ?? ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= <An identifier_or_keyword that is not a keyword> 0x 0X " @" <A Unicode character of classes Lu, Ll, Lt, Lm, Lo, or Nl> <A unicode_escape_sequence representing a character of classes Lu, Ll, Lt, Lm, Lo, or Nl> <A Unicode character of the class Nd> <A unicode_escape_sequence representing a character of the class Nd> <A Unicode character of the class Pc> <A unicode_escape_sequence representing a character of the class Pc> <A Unicode character of classes Mn or Mc> <A unicode_escape_sequence representing a character of classes Mn or Mc> <A Unicode character of the class Cf> <A unicode_escape_sequence representing a character of the class Cf> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B), } (U+007D) and new_line_character> </ (U+002F), if not directly followed by / (U+002F) or * (U+002A)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B) and } (U+007D)> >>= >> equals on into ascending descending by partial dynamic

<A unicode_escape_sequence representing a character of the class Cf>

(used in formatting_character)
MayBeFollowedBy: { . ; = < :: : ) ? } , => in select group from let where join orderby ( [ <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 ' $ ] + - * / % & | ^ ! ~ > ?? ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= <An identifier_or_keyword that is not a keyword> 0x 0X " @" <A Unicode character of classes Lu, Ll, Lt, Lm, Lo, or Nl> <A unicode_escape_sequence representing a character of classes Lu, Ll, Lt, Lm, Lo, or Nl> <A Unicode character of the class Nd> <A unicode_escape_sequence representing a character of the class Nd> <A Unicode character of the class Pc> <A unicode_escape_sequence representing a character of the class Pc> <A Unicode character of classes Mn or Mc> <A unicode_escape_sequence representing a character of classes Mn or Mc> <A Unicode character of the class Cf> <A unicode_escape_sequence representing a character of the class Cf> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B), } (U+007D) and new_line_character> </ (U+002F), if not directly followed by / (U+002F) or * (U+002A)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B) and } (U+007D)> >>= >> equals on into ascending descending by partial dynamic

<A unicode_escape_sequence representing a character of the class Nd>

(used in decimal_digit_character)
MayBeFollowedBy: { . ; = < :: : ) ? } , => in select group from let where join orderby ( [ <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 ' $ ] + - * / % & | ^ ! ~ > ?? ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= <An identifier_or_keyword that is not a keyword> 0x 0X " @" <A Unicode character of classes Lu, Ll, Lt, Lm, Lo, or Nl> <A unicode_escape_sequence representing a character of classes Lu, Ll, Lt, Lm, Lo, or Nl> <A Unicode character of the class Nd> <A unicode_escape_sequence representing a character of the class Nd> <A Unicode character of the class Pc> <A unicode_escape_sequence representing a character of the class Pc> <A Unicode character of classes Mn or Mc> <A unicode_escape_sequence representing a character of classes Mn or Mc> <A Unicode character of the class Cf> <A unicode_escape_sequence representing a character of the class Cf> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B), } (U+007D) and new_line_character> </ (U+002F), if not directly followed by / (U+002F) or * (U+002A)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B) and } (U+007D)> >>= >> equals on into ascending descending by partial dynamic

<A unicode_escape_sequence representing a character of the class Pc>

(used in connecting_character)
MayBeFollowedBy: { . ; = < :: : ) ? } , => in select group from let where join orderby ( [ <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 ' $ ] + - * / % & | ^ ! ~ > ?? ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= <An identifier_or_keyword that is not a keyword> 0x 0X " @" <A Unicode character of classes Lu, Ll, Lt, Lm, Lo, or Nl> <A unicode_escape_sequence representing a character of classes Lu, Ll, Lt, Lm, Lo, or Nl> <A Unicode character of the class Nd> <A unicode_escape_sequence representing a character of the class Nd> <A Unicode character of the class Pc> <A unicode_escape_sequence representing a character of the class Pc> <A Unicode character of classes Mn or Mc> <A unicode_escape_sequence representing a character of classes Mn or Mc> <A Unicode character of the class Cf> <A unicode_escape_sequence representing a character of the class Cf> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B), } (U+007D) and new_line_character> </ (U+002F), if not directly followed by / (U+002F) or * (U+002A)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B) and } (U+007D)> >>= >> equals on into ascending descending by partial dynamic

<An identifier_or_keyword that is not a keyword>

(used in available_identifier)
MayBeFollowedBy: { . ; = < :: : ) ? } , => in select group from let where join orderby ( [ <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 ' $ ] + - * / % & | ^ ! ~ > ?? ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= <An identifier_or_keyword that is not a keyword> 0x 0X " @" >>= >> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> equals on into ascending descending by partial dynamic

<Any character except ' (U+0027), \ (U+005C), and new_line_character>

(used in single_character)
MayBeFollowedBy: '

<Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)>

(used in interpolation_format_character)
MayBeFollowedBy: } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)>

<Any character except " (U+0022), \ (U+005C), and new_line_character>

(used in single_regular_string_literal_character)
MayBeFollowedBy: " \' \" \\ \0 \a \b \f \n \r \t \v \x \u \U <Any character except " (U+0022), \ (U+005C), and new_line_character>

<Any character except " (U+0022), { (U+007B) and } (U+007D)>

(used in single_interpolated_verbatim_string_character)
MayBeFollowedBy: " "" {{ }} <Any character except " (U+0022), { (U+007B) and } (U+007D)> {

<any character except ">

(used in single_verbatim_string_literal_character)
MayBeFollowedBy: " <any character except "> ""

<Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B) and } (U+007D)>

(used in single_verbatim_balanced_text_character)
MayBeFollowedBy: } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> @ $ ( [ { <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B) and } (U+007D)> </ (U+002F), if not directly followed by / (U+002F) or * (U+002A)> // /* " @" ) ]

<Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B), } (U+007D) and new_line_character>

(used in single_regular_balanced_text_character)
MayBeFollowedBy: } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> /* @ $ ( [ { <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B), } (U+007D) and new_line_character> </ (U+002F), if not directly followed by / (U+002F) or * (U+002A)> " @" ) ]

<Any character with Unicode class Zs>

(used in whitespace)
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" <Any identifier_or_keyword except true or false> define # undef elif endif <Any input_character except #> error warning <Any Unicode character except a new_line_character> region endregion hidden line pragma disable restore

<Any identifier_or_keyword except true or false>

(used in conditional_symbol)
MayBeFollowedBy: <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> == // <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> != && || )

<Any input_character except ">

(used in file_name_character)
MayBeFollowedBy: " <Any input_character except ">

<Any input_character except #>

(used in not_number_sign)
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any Unicode character except a new_line_character>

<Any interpolated_verbatim_string_character except close_brace_escape_sequence>

(used in interpolated_verbatim_string_character_no_brace)
MayBeFollowedBy: { " "" {{ }} <Any character except " (U+0022), { (U+007B) and } (U+007D)>

<Any Unicode character except / or *>

(used in not_slash_or_asterisk)
MayBeFollowedBy: / * <Any Unicode character except / or *>

<Any Unicode character except a new_line_character>

(used in input_character)
MayBeFollowedBy: <Any Unicode character except a new_line_character> <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> <Any character except / (U+002F), @ (U+0040), " (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B) and } (U+007D)> </ (U+002F), if not directly followed by / (U+002F) or * (U+002A)>

<Carriage return character (U+000D) followed by line feed character (U+000A)>

(used in new_line)
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> # // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" <Any input_character except #>

<Carriage return character (U+000D)>

(used in new_line new_line_character)
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> # // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" <Any input_character except #>

<Form feed character (U+000C)>

(used in whitespace)
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" <Any identifier_or_keyword except true or false> define # undef elif endif <Any input_character except #> error warning <Any Unicode character except a new_line_character> region endregion hidden line pragma disable restore

<Horizontal tab character (U+0009)>

(used in whitespace)
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" <Any identifier_or_keyword except true or false> define # undef elif endif <Any input_character except #> error warning <Any Unicode character except a new_line_character> region endregion hidden line pragma disable restore

<Line feed character (U+000A)>

(used in new_line new_line_character)
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> # // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" <Any input_character except #>

<Line separator character (U+2028)>

(used in new_line new_line_character)
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> # // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" <Any input_character except #>

<Next line character (U+0085)>

(used in new_line new_line_character)
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> # // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" <Any input_character except #>

<Paragraph separator character (U+2029)>

(used in new_line new_line_character)
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> # // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" <Any input_character except #>

<UNDEFINED>

(used in interpolated_string)
MayBeFollowedBy: [ . ( ++ -- ? -> * / = += -= *= /= %= &= |= ^= <<= >>= ; % + ) , - << >> < > <= >= is as == != & ^ | && || ?? } <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> ] : from select group let where join orderby equals on into ascending descending by const event extern ~ partial class struct interface enum delegate new public protected internal private static readonly volatile virtual sealed override abstract unsafe object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double fixed

<Vertical tab character (U+000B)>

(used in whitespace)
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" <Any identifier_or_keyword except true or false> define # undef elif endif <Any input_character except #> error warning <Any Unicode character except a new_line_character> region endregion hidden line pragma disable restore

=

(used in using_alias_directive member_initializer member_declarator let_clause assignment_operator local_variable_declarator constant_declarator variable_declarator default_argument property_initializer enum_member_declaration named_argument fixed_pointer_declarator operator_or_punctuator)
MayBeFollowedBy: @ <An identifier_or_keyword that is not a keyword> + - ! ~ { new ++ -- ( await from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" stackalloc <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as break case catch class const continue do else enum event explicit extern finally fixed for foreach goto if implicit in interface internal is lock namespace operator out override params private protected public readonly ref return sealed static struct switch throw try unsafe using virtual void volatile while $ } [ ] ) , : ; / % | ^ = < > ? ?? :: && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= =>

-=

(used in assignment_operator operator_or_punctuator)
MayBeFollowedBy: + - ! ~ new ++ -- ( await from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword> <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as break case catch class const continue do else enum event explicit extern finally fixed for foreach goto if implicit in interface internal is lock namespace operator out override params private protected public readonly ref return sealed stackalloc static struct switch throw try unsafe using virtual void volatile while $ { } [ ] ) , : ; / % | ^ = < > ? ?? :: && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= =>

==

(used in equality_expression overloadable_binary_operator operator_or_punctuator pp_equality_expression)
MayBeFollowedBy: + - ! ~ new ++ -- ( await <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword> <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as break case catch class const continue do else enum event explicit extern finally fixed for foreach goto if implicit in interface internal is lock namespace operator out override params private protected public readonly ref return sealed stackalloc static struct switch throw try unsafe using virtual void volatile while $ { } [ ] ) , : ; / % | ^ = < > ? ?? :: && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <Any identifier_or_keyword except true or false>

=>

(used in lambda_expression method_body property_body indexer_body operator_body operator_or_punctuator)
MayBeFollowedBy: + - ! ~ { new ++ -- ( await from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword> <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as break case catch class const continue do else enum event explicit extern finally fixed for foreach goto if implicit in interface internal is lock namespace operator out override params private protected public readonly ref return sealed stackalloc static struct switch throw try unsafe using virtual void volatile while $ } [ ] ) , : ; / % | ^ = < > ? ?? :: && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= =>

>

(used in type_argument_list generic_dimension_specifier relational_expression type_parameter_list overloadable_binary_operator variant_type_parameter_list operator_or_punctuator)
MayBeFollowedBy: ; ) + - ! ~ new ++ -- ( await <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword> { where : <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as break case catch class const continue do else enum event explicit extern finally fixed for foreach goto if implicit in interface internal is lock namespace operator out override params private protected public readonly ref return sealed stackalloc static struct switch throw try unsafe using virtual void volatile while $ } [ ] , / % | ^ = < > ? ?? :: && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => >>= >> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let join orderby equals on into ascending descending by partial dynamic

->

(used in pointer_member_access operator_or_punctuator)
MayBeFollowedBy: @ <An identifier_or_keyword that is not a keyword> <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => 0x 0X " @"

>=

(used in relational_expression overloadable_binary_operator operator_or_punctuator)
MayBeFollowedBy: + - ! ~ new ++ -- ( await <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword> <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as break case catch class const continue do else enum event explicit extern finally fixed for foreach goto if implicit in interface internal is lock namespace operator out override params private protected public readonly ref return sealed stackalloc static struct switch throw try unsafe using virtual void volatile while $ { } [ ] ) , : ; / % | ^ = < > ? ?? :: && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= =>

>>

(used in right_shift)
MayBeFollowedBy: + - ! ~ new ++ -- ( await <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>

>>=

(used in right_shift_assignment)
MayBeFollowedBy: + - ! ~ new ++ -- ( await from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>

0

(used in decimal_digit hex_digit)
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" U u L l UL Ul uL ul LU Lu lU lu A B C D E F a b c d e f M m \' \" \\ \0 \a \b \f \n \r \t \v \x \u \U <Any character except " (U+0022), \ (U+005C), and new_line_character> <Any character except " (U+0022), \ (U+005C), { (U+007B), } (U+007D), and new_line_character> {{ }} >>= >> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

0x

(used in hexadecimal_integer_literal)
MayBeFollowedBy: 0 1 2 3 4 5 6 7 8 9 A B C D E F a b c d e f

0X

(used in hexadecimal_integer_literal)
MayBeFollowedBy: 0 1 2 3 4 5 6 7 8 9 A B C D E F a b c d e f

1

(used in decimal_digit hex_digit)
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" U u L l UL Ul uL ul LU Lu lU lu A B C D E F a b c d e f M m \' \" \\ \0 \a \b \f \n \r \t \v \x \u \U <Any character except " (U+0022), \ (U+005C), and new_line_character> <Any character except " (U+0022), \ (U+005C), { (U+007B), } (U+007D), and new_line_character> {{ }} >>= >> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

2

(used in decimal_digit hex_digit)
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" U u L l UL Ul uL ul LU Lu lU lu A B C D E F a b c d e f M m \' \" \\ \0 \a \b \f \n \r \t \v \x \u \U <Any character except " (U+0022), \ (U+005C), and new_line_character> <Any character except " (U+0022), \ (U+005C), { (U+007B), } (U+007D), and new_line_character> {{ }} >>= >> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

3

(used in decimal_digit hex_digit)
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" U u L l UL Ul uL ul LU Lu lU lu A B C D E F a b c d e f M m \' \" \\ \0 \a \b \f \n \r \t \v \x \u \U <Any character except " (U+0022), \ (U+005C), and new_line_character> <Any character except " (U+0022), \ (U+005C), { (U+007B), } (U+007D), and new_line_character> {{ }} >>= >> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

4

(used in decimal_digit hex_digit)
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" U u L l UL Ul uL ul LU Lu lU lu A B C D E F a b c d e f M m \' \" \\ \0 \a \b \f \n \r \t \v \x \u \U <Any character except " (U+0022), \ (U+005C), and new_line_character> <Any character except " (U+0022), \ (U+005C), { (U+007B), } (U+007D), and new_line_character> {{ }} >>= >> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

5

(used in decimal_digit hex_digit)
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" U u L l UL Ul uL ul LU Lu lU lu A B C D E F a b c d e f M m \' \" \\ \0 \a \b \f \n \r \t \v \x \u \U <Any character except " (U+0022), \ (U+005C), and new_line_character> <Any character except " (U+0022), \ (U+005C), { (U+007B), } (U+007D), and new_line_character> {{ }} >>= >> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

6

(used in decimal_digit hex_digit)
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" U u L l UL Ul uL ul LU Lu lU lu A B C D E F a b c d e f M m \' \" \\ \0 \a \b \f \n \r \t \v \x \u \U <Any character except " (U+0022), \ (U+005C), and new_line_character> <Any character except " (U+0022), \ (U+005C), { (U+007B), } (U+007D), and new_line_character> {{ }} >>= >> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

7

(used in decimal_digit hex_digit)
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" U u L l UL Ul uL ul LU Lu lU lu A B C D E F a b c d e f M m \' \" \\ \0 \a \b \f \n \r \t \v \x \u \U <Any character except " (U+0022), \ (U+005C), and new_line_character> <Any character except " (U+0022), \ (U+005C), { (U+007B), } (U+007D), and new_line_character> {{ }} >>= >> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

8

(used in decimal_digit hex_digit)
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" U u L l UL Ul uL ul LU Lu lU lu A B C D E F a b c d e f M m \' \" \\ \0 \a \b \f \n \r \t \v \x \u \U <Any character except " (U+0022), \ (U+005C), and new_line_character> <Any character except " (U+0022), \ (U+005C), { (U+007B), } (U+007D), and new_line_character> {{ }} >>= >> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

9

(used in decimal_digit hex_digit)
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" U u L l UL Ul uL ul LU Lu lU lu A B C D E F a b c d e f M m \' \" \\ \0 \a \b \f \n \r \t \v \x \u \U <Any character except " (U+0022), \ (U+005C), and new_line_character> <Any character except " (U+0022), \ (U+005C), { (U+007B), } (U+007D), and new_line_character> {{ }} >>= >> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

a

(used in hex_digit)
MayBeFollowedBy: 0 1 2 3 4 5 6 7 8 9 A B C D E F a b c d e f <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" U u L l UL Ul uL ul LU Lu lU lu \' \" \\ \0 \a \b \f \n \r \t \v \x \u \U <Any character except " (U+0022), \ (U+005C), and new_line_character> <Any character except " (U+0022), \ (U+005C), { (U+007B), } (U+007D), and new_line_character> {{ }} >>= >> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

A

(used in hex_digit)
MayBeFollowedBy: 0 1 2 3 4 5 6 7 8 9 A B C D E F a b c d e f <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" U u L l UL Ul uL ul LU Lu lU lu \' \" \\ \0 \a \b \f \n \r \t \v \x \u \U <Any character except " (U+0022), \ (U+005C), and new_line_character> <Any character except " (U+0022), \ (U+005C), { (U+007B), } (U+007D), and new_line_character> {{ }} >>= >> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

abstract

(used in class_modifier method_modifier property_modifier event_modifier indexer_modifier keyword)
MayBeFollowedBy: class partial new public protected internal private abstract sealed static unsafe void object dynamic string @ bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double virtual override extern event <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* as base break case catch checked const continue default delegate do else enum explicit false finally fixed for foreach goto if implicit in interface is lock namespace null operator out params readonly ref return sizeof stackalloc struct switch this throw true try typeof unchecked using volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => 0x 0X " @"

add

(used in add_accessor_declaration)
MayBeFollowedBy: {

alias

(used in extern_alias_directive)
MayBeFollowedBy: @ <An identifier_or_keyword that is not a keyword>

as

(used in relational_expression keyword)
MayBeFollowedBy: object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as base break case catch checked class const continue default delegate do else enum event explicit extern false finally fixed for foreach goto if implicit in interface internal is lock namespace new null operator out override params private protected public readonly ref return sealed sizeof stackalloc static struct switch this throw true try typeof unchecked unsafe using virtual volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => 0x 0X " @"

ascending

(used in ordering_direction)
MayBeFollowedBy: select group , from let where join orderby

assembly

(used in global_attribute_target)
MayBeFollowedBy: :

await

(used in await_expression)
MayBeFollowedBy: + - ! ~ new ++ -- ( await <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>

b

(used in hex_digit)
MayBeFollowedBy: 0 1 2 3 4 5 6 7 8 9 A B C D E F a b c d e f <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" U u L l UL Ul uL ul LU Lu lU lu \' \" \\ \0 \a \b \f \n \r \t \v \x \u \U <Any character except " (U+0022), \ (U+005C), and new_line_character> <Any character except " (U+0022), \ (U+005C), { (U+007B), } (U+007D), and new_line_character> {{ }} >>= >> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

B

(used in hex_digit)
MayBeFollowedBy: 0 1 2 3 4 5 6 7 8 9 A B C D E F a b c d e f <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" U u L l UL Ul uL ul LU Lu lU lu \' \" \\ \0 \a \b \f \n \r \t \v \x \u \U <Any character except " (U+0022), \ (U+005C), and new_line_character> <Any character except " (U+0022), \ (U+005C), { (U+007B), } (U+007D), and new_line_character> {{ }} >>= >> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

base

(used in base_access named_entity_target constructor_initializer keyword)
MayBeFollowedBy: . [ ( <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 ' $ { } ] ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @"

bool

(used in simple_type predefined_type keyword)
MayBeFollowedBy: . <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

break

(used in break_statement yield_statement keyword)
MayBeFollowedBy: ; <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @"

by

(used in group_clause)
MayBeFollowedBy: + - ! ~ new ++ -- ( await from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>

byte

(used in integral_type predefined_type keyword)
MayBeFollowedBy: . <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

c

(used in hex_digit)
MayBeFollowedBy: 0 1 2 3 4 5 6 7 8 9 A B C D E F a b c d e f <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" U u L l UL Ul uL ul LU Lu lU lu \' \" \\ \0 \a \b \f \n \r \t \v \x \u \U <Any character except " (U+0022), \ (U+005C), and new_line_character> <Any character except " (U+0022), \ (U+005C), { (U+007B), } (U+007D), and new_line_character> {{ }} >>= >> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

C

(used in hex_digit)
MayBeFollowedBy: 0 1 2 3 4 5 6 7 8 9 A B C D E F a b c d e f <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" U u L l UL Ul uL ul LU Lu lU lu \' \" \\ \0 \a \b \f \n \r \t \v \x \u \U <Any character except " (U+0022), \ (U+005C), and new_line_character> <Any character except " (U+0022), \ (U+005C), { (U+007B), } (U+007D), and new_line_character> {{ }} >>= >> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

case

(used in switch_label goto_statement keyword)
MayBeFollowedBy: + - ! ~ new ++ -- ( await from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword> <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as break case catch class const continue do else enum event explicit extern finally fixed for foreach goto if implicit in interface internal is lock namespace operator out override params private protected public readonly ref return sealed stackalloc static struct switch throw try unsafe using virtual void volatile while $ { } [ ] ) , : ; / % | ^ = < > ? ?? :: && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= =>

catch

(used in catch_clause keyword)
MayBeFollowedBy: { when ( <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ } [ ] ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @"

char

(used in integral_type predefined_type keyword)
MayBeFollowedBy: . <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

checked

(used in checked_expression checked_statement keyword)
MayBeFollowedBy: ( { <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ } [ ] ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @"

class

(used in class_declaration primary_constraint keyword)
MayBeFollowedBy: @ <An identifier_or_keyword that is not a keyword> { where , <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ } [ ] ( ) : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => 0x 0X " @"

const

(used in local_constant_declaration constant_declaration keyword)
MayBeFollowedBy: object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as base break case catch checked class const continue default delegate do else enum event explicit extern false finally fixed for foreach goto if implicit in interface internal is lock namespace new null operator out override params private protected public readonly ref return sealed sizeof stackalloc static struct switch this throw true try typeof unchecked unsafe using virtual volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => 0x 0X " @"

continue

(used in continue_statement keyword)
MayBeFollowedBy: ; <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @"

d

(used in hex_digit real_type_suffix)
MayBeFollowedBy: 0 1 2 3 4 5 6 7 8 9 A B C D E F a b c d e f <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" U u L l UL Ul uL ul LU Lu lU lu \' \" \\ \0 \a \b \f \n \r \t \v \x \u \U <Any character except " (U+0022), \ (U+005C), and new_line_character> <Any character except " (U+0022), \ (U+005C), { (U+007B), } (U+007D), and new_line_character> {{ }} >>= >> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

D

(used in hex_digit real_type_suffix)
MayBeFollowedBy: 0 1 2 3 4 5 6 7 8 9 A B C D E F a b c d e f <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" U u L l UL Ul uL ul LU Lu lU lu \' \" \\ \0 \a \b \f \n \r \t \v \x \u \U <Any character except " (U+0022), \ (U+005C), and new_line_character> <Any character except " (U+0022), \ (U+005C), { (U+007B), } (U+007D), and new_line_character> {{ }} >>= >> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

decimal

(used in numeric_type predefined_type keyword)
MayBeFollowedBy: . <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

default

(used in default_value_expression switch_label goto_statement keyword line_indicator)
MayBeFollowedBy: ( : ; <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ) , + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @"

define

(used in pp_declaration)
MayBeFollowedBy: <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)>

delegate

(used in anonymous_method_expression delegate_declaration keyword)
MayBeFollowedBy: { ( void object dynamic string @ bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as base break case catch checked class const continue default delegate do else enum event explicit extern false finally fixed for foreach goto if implicit in interface internal is lock namespace new null operator out override params private protected public readonly ref return sealed sizeof stackalloc static struct switch this throw true try typeof unchecked unsafe using virtual volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ } [ ] ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => 0x 0X " @"

descending

(used in ordering_direction)
MayBeFollowedBy: select group , from let where join orderby

disable

(used in warning_action)
MayBeFollowedBy: <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)>

do

(used in do_statement keyword)
MayBeFollowedBy: { ; try checked unchecked lock using yield new + - ! ~ ++ -- await if switch while do for foreach break continue goto return throw unsafe fixed ( <UNDEFINED> this base typeof default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword> <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as case catch class const else enum event explicit extern finally implicit in interface internal is namespace operator out override params private protected public readonly ref sealed stackalloc static struct virtual void volatile $ } [ ] ) , : / % | ^ = < > ? ?? :: && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= =>

double

(used in floating_point_type predefined_type keyword)
MayBeFollowedBy: . <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

e

(used in hex_digit exponent_part)
MayBeFollowedBy: 0 1 2 3 4 5 6 7 8 9 A B C D E F a b c d e f <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" U u L l UL Ul uL ul LU Lu lU lu \' \" \\ \0 \a \b \f \n \r \t \v \x \u \U <Any character except " (U+0022), \ (U+005C), and new_line_character> <Any character except " (U+0022), \ (U+005C), { (U+007B), } (U+007D), and new_line_character> {{ }} >>= >> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

E

(used in hex_digit exponent_part)
MayBeFollowedBy: 0 1 2 3 4 5 6 7 8 9 A B C D E F a b c d e f <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" U u L l UL Ul uL ul LU Lu lU lu \' \" \\ \0 \a \b \f \n \r \t \v \x \u \U <Any character except " (U+0022), \ (U+005C), and new_line_character> <Any character except " (U+0022), \ (U+005C), { (U+007B), } (U+007D), and new_line_character> {{ }} >>= >> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

elif

(used in pp_elif_section)
MayBeFollowedBy: <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)>

else

(used in if_statement keyword pp_else_section)
MayBeFollowedBy: { ; try checked unchecked lock using yield new + - ! ~ ++ -- await if switch while do for foreach break continue goto return throw unsafe fixed ( <UNDEFINED> this base typeof default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword> <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as case catch class const else enum event explicit extern finally implicit in interface internal is namespace operator out override params private protected public readonly ref sealed stackalloc static struct virtual void volatile $ } [ ] ) , : / % | ^ = < > ? ?? :: && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= =>

endif

(used in pp_endif)
MayBeFollowedBy: <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)>

endregion

(used in pp_end_region)
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)>

enum

(used in enum_declaration keyword)
MayBeFollowedBy: @ <An identifier_or_keyword that is not a keyword> <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => 0x 0X " @"

equals

(used in join_clause join_into_clause)
MayBeFollowedBy: + - ! ~ new ++ -- ( await from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>

error

(used in pp_diagnostic)
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)>

event

(used in event_declaration interface_event_declaration attribute_target keyword)
MayBeFollowedBy: object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double : <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as base break case catch checked class const continue default delegate do else enum event explicit extern false finally fixed for foreach goto if implicit in interface internal is lock namespace new null operator out override params private protected public readonly ref return sealed sizeof stackalloc static struct switch this throw true try typeof unchecked unsafe using virtual volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => 0x 0X " @"

explicit

(used in conversion_operator_declarator keyword)
MayBeFollowedBy: operator <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @"

extern

(used in extern_alias_directive method_modifier property_modifier event_modifier indexer_modifier operator_modifier constructor_modifier static_constructor_modifiers destructor_declaration destructor_declaration_unsafe static_constructor_modifiers_unsafe keyword)
MayBeFollowedBy: alias void object dynamic string @ bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double partial new public protected internal private static virtual sealed override abstract extern unsafe event implicit explicit ~ <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* as base break case catch checked class const continue default delegate do else enum false finally fixed for foreach goto if in interface is lock namespace null operator out params readonly ref return sizeof stackalloc struct switch this throw true try typeof unchecked using volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => 0x 0X " @"

f

(used in hex_digit real_type_suffix)
MayBeFollowedBy: 0 1 2 3 4 5 6 7 8 9 A B C D E F a b c d e f <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" U u L l UL Ul uL ul LU Lu lU lu \' \" \\ \0 \a \b \f \n \r \t \v \x \u \U <Any character except " (U+0022), \ (U+005C), and new_line_character> <Any character except " (U+0022), \ (U+005C), { (U+007B), } (U+007D), and new_line_character> {{ }} >>= >> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

F

(used in hex_digit real_type_suffix)
MayBeFollowedBy: 0 1 2 3 4 5 6 7 8 9 A B C D E F a b c d e f <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" U u L l UL Ul uL ul LU Lu lU lu \' \" \\ \0 \a \b \f \n \r \t \v \x \u \U <Any character except " (U+0022), \ (U+005C), and new_line_character> <Any character except " (U+0022), \ (U+005C), { (U+007B), } (U+007D), and new_line_character> {{ }} >>= >> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

false

(used in overloadable_unary_operator keyword boolean_literal pp_primary_expression)
MayBeFollowedBy: ( <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" >>= >> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

field

(used in attribute_target)
MayBeFollowedBy: :

finally

(used in finally_clause keyword)
MayBeFollowedBy: { <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @"

fixed

(used in fixed_statement fixed_size_buffer_declaration keyword)
MayBeFollowedBy: ( object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as base break case catch checked class const continue default delegate do else enum event explicit extern false finally fixed for foreach goto if implicit in interface internal is lock namespace new null operator out override params private protected public readonly ref return sealed sizeof stackalloc static struct switch this throw true try typeof unchecked unsafe using virtual volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => 0x 0X " @"

float

(used in floating_point_type predefined_type keyword)
MayBeFollowedBy: . <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

for

(used in for_statement keyword)
MayBeFollowedBy: ( <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @"

foreach

(used in foreach_statement keyword)
MayBeFollowedBy: ( <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @"

from

(used in from_clause)
MayBeFollowedBy: @ <An identifier_or_keyword that is not a keyword> object dynamic string void bool decimal sbyte byte short ushort int uint long ulong char float double

get

(used in get_accessor_declaration interface_accessors)
MayBeFollowedBy: { ;

goto

(used in goto_statement keyword)
MayBeFollowedBy: @ <An identifier_or_keyword that is not a keyword> case default <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as base bool break byte catch char checked class const continue decimal delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => 0x 0X " @"

group

(used in group_clause)
MayBeFollowedBy: + - ! ~ new ++ -- ( await from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>

hidden

(used in line_indicator)
MayBeFollowedBy: <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)>

if

(used in if_statement keyword pp_if_section)
MayBeFollowedBy: ( <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @"

implicit

(used in conversion_operator_declarator keyword)
MayBeFollowedBy: operator <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @"

in

(used in from_clause join_clause join_into_clause foreach_statement variance_annotation keyword)
MayBeFollowedBy: + - ! ~ new ++ -- ( await from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword> <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as break case catch class const continue do else enum event explicit extern finally fixed for foreach goto if implicit in interface internal is lock namespace operator out override params private protected public readonly ref return sealed stackalloc static struct switch throw try unsafe using virtual void volatile while $ { } [ ] ) , : ; / % | ^ = < > ? ?? :: && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= =>

int

(used in integral_type predefined_type keyword)
MayBeFollowedBy: . <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

interface

(used in interface_declaration keyword)
MayBeFollowedBy: @ <An identifier_or_keyword that is not a keyword> <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => 0x 0X " @"

internal

(used in class_modifier constant_modifier field_modifier method_modifier property_modifier accessor_modifier event_modifier indexer_modifier constructor_modifier struct_modifier interface_modifier enum_modifier delegate_modifier fixed_size_buffer_modifier keyword)
MayBeFollowedBy: class partial new public protected internal private abstract sealed static unsafe const object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double readonly volatile virtual override extern get set event struct interface enum delegate fixed <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* as base break case catch checked continue default do else explicit false finally for foreach goto if implicit in is lock namespace null operator out params ref return sizeof stackalloc switch this throw true try typeof unchecked using while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => 0x 0X " @"

into

(used in join_into_clause query_continuation)
MayBeFollowedBy: @ <An identifier_or_keyword that is not a keyword>

is

(used in relational_expression keyword)
MayBeFollowedBy: object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as base break case catch checked class const continue default delegate do else enum event explicit extern false finally fixed for foreach goto if implicit in interface internal is lock namespace new null operator out override params private protected public readonly ref return sealed sizeof stackalloc static struct switch this throw true try typeof unchecked unsafe using virtual volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => 0x 0X " @"

join

(used in join_clause join_into_clause)
MayBeFollowedBy: @ <An identifier_or_keyword that is not a keyword> object dynamic string void bool decimal sbyte byte short ushort int uint long ulong char float double

l

(used in integer_type_suffix)
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" >>= >> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

L

(used in integer_type_suffix)
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" >>= >> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

let

(used in let_clause)
MayBeFollowedBy: @ <An identifier_or_keyword that is not a keyword>

line

(used in pp_line)
MayBeFollowedBy: <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)>

lock

(used in lock_statement keyword)
MayBeFollowedBy: ( <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @"

long

(used in integral_type predefined_type keyword)
MayBeFollowedBy: . <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

lu

(used in integer_type_suffix)
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" >>= >> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

lU

(used in integer_type_suffix)
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" >>= >> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

Lu

(used in integer_type_suffix)
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" >>= >> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

LU

(used in integer_type_suffix)
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" >>= >> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

m

(used in real_type_suffix)
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" >>= >> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

M

(used in real_type_suffix)
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" >>= >> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

method

(used in attribute_target)
MayBeFollowedBy: :

module

(used in global_attribute_target)
MayBeFollowedBy: :

nameof

(used in nameof_expression)
MayBeFollowedBy: (

namespace

(used in namespace_declaration keyword)
MayBeFollowedBy: @ <An identifier_or_keyword that is not a keyword> <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => 0x 0X " @"

new

(used in object_creation_expression array_creation_expression delegate_creation_expression anonymous_object_creation_expression class_modifier constructor_constraint constant_modifier field_modifier method_modifier property_modifier event_modifier indexer_modifier struct_modifier interface_modifier interface_method_declaration interface_property_declaration interface_event_declaration interface_indexer_declaration enum_modifier delegate_modifier fixed_size_buffer_modifier keyword)
MayBeFollowedBy: object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double [ { class partial new public protected internal private abstract sealed static unsafe ( const readonly volatile virtual override extern event struct interface enum delegate fixed <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* as base break case catch checked continue default do else explicit false finally for foreach goto if implicit in is lock namespace null operator out params ref return sizeof stackalloc switch this throw true try typeof unchecked using while 0 1 2 3 4 5 6 7 8 9 . ' $ } ] ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => 0x 0X " @"

null

(used in keyword null_literal)
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" >>= >> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

object

(used in class_type predefined_type keyword)
MayBeFollowedBy: . <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" where <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let join orderby equals on into ascending descending by partial dynamic

on

(used in join_clause join_into_clause)
MayBeFollowedBy: + - ! ~ new ++ -- ( await from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>

operator

(used in unary_operator_declarator binary_operator_declarator conversion_operator_declarator keyword)
MayBeFollowedBy: + - ! ~ ++ -- true false * / % & | ^ << right_shift == != > < >= <= object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as base break case catch checked class const continue default delegate do else enum event explicit extern finally fixed for foreach goto if implicit in interface internal is lock namespace new null operator out override params private protected public readonly ref return sealed sizeof stackalloc static struct switch this throw try typeof unchecked unsafe using virtual volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; = ? ?? :: && || -> += -= *= /= %= &= |= ^= <<= => 0x 0X " @"

orderby

(used in orderby_clause)
MayBeFollowedBy: + - ! ~ new ++ -- ( await from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>

out

(used in argument_value anonymous_function_parameter_modifier parameter_modifier variance_annotation keyword)
MayBeFollowedBy: + - ! ~ new ++ -- ( await from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword> dynamic void <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as break case catch class const continue do else enum event explicit extern finally fixed for foreach goto if implicit in interface internal is lock namespace operator out override params private protected public readonly ref return sealed stackalloc static struct switch throw try unsafe using virtual volatile while $ { } [ ] ) , : ; / % | ^ = < > ? ?? :: && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= =>

override

(used in method_modifier property_modifier event_modifier indexer_modifier keyword)
MayBeFollowedBy: void object dynamic string @ bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double partial new public protected internal private static virtual sealed override abstract extern unsafe event <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* as base break case catch checked class const continue default delegate do else enum explicit false finally fixed for foreach goto if implicit in interface is lock namespace null operator out params readonly ref return sizeof stackalloc struct switch this throw true try typeof unchecked using volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => 0x 0X " @"

param

(used in attribute_target)
MayBeFollowedBy: :

params

(used in parameter_array keyword)
MayBeFollowedBy: object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as base break case catch checked class const continue default delegate do else enum event explicit extern false finally fixed for foreach goto if implicit in interface internal is lock namespace new null operator out override params private protected public readonly ref return sealed sizeof stackalloc static struct switch this throw true try typeof unchecked unsafe using virtual volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => 0x 0X " @"

pragma

(used in pp_pragma)
MayBeFollowedBy: <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)>

private

(used in class_modifier constant_modifier field_modifier method_modifier property_modifier accessor_modifier event_modifier indexer_modifier constructor_modifier struct_modifier interface_modifier enum_modifier delegate_modifier fixed_size_buffer_modifier keyword)
MayBeFollowedBy: class partial new public protected internal private abstract sealed static unsafe const object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double readonly volatile virtual override extern get set event struct interface enum delegate fixed <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* as base break case catch checked continue default do else explicit false finally for foreach goto if implicit in is lock namespace null operator out params ref return sizeof stackalloc switch this throw true try typeof unchecked using while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => 0x 0X " @"

property

(used in attribute_target)
MayBeFollowedBy: :

protected

(used in class_modifier constant_modifier field_modifier method_modifier property_modifier accessor_modifier event_modifier indexer_modifier constructor_modifier struct_modifier interface_modifier enum_modifier delegate_modifier fixed_size_buffer_modifier keyword)
MayBeFollowedBy: class partial new public protected internal private abstract sealed static unsafe const object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double readonly volatile virtual override extern get set event struct interface enum delegate fixed <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* as base break case catch checked continue default do else explicit false finally for foreach goto if implicit in is lock namespace null operator out params ref return sizeof stackalloc switch this throw true try typeof unchecked using while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => 0x 0X " @"

public

(used in class_modifier constant_modifier field_modifier method_modifier property_modifier event_modifier indexer_modifier operator_modifier constructor_modifier struct_modifier interface_modifier enum_modifier delegate_modifier fixed_size_buffer_modifier keyword)
MayBeFollowedBy: class partial new public protected internal private abstract sealed static unsafe const object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double readonly volatile virtual override extern event implicit explicit struct interface enum delegate fixed <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* as base break case catch checked continue default do else false finally for foreach goto if in is lock namespace null operator out params ref return sizeof stackalloc switch this throw true try typeof unchecked using while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => 0x 0X " @"

readonly

(used in field_modifier keyword)
MayBeFollowedBy: object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double new public protected internal private static readonly volatile unsafe <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as base break case catch checked class const continue default delegate do else enum event explicit extern false finally fixed for foreach goto if implicit in interface is lock namespace null operator out override params ref return sealed sizeof stackalloc struct switch this throw true try typeof unchecked using virtual while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => 0x 0X " @"

ref

(used in argument_value anonymous_function_parameter_modifier parameter_modifier keyword)
MayBeFollowedBy: + - ! ~ new ++ -- ( await from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword> dynamic void <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as break case catch class const continue do else enum event explicit extern finally fixed for foreach goto if implicit in interface internal is lock namespace operator out override params private protected public readonly ref return sealed stackalloc static struct switch throw try unsafe using virtual volatile while $ { } [ ] ) , : ; / % | ^ = < > ? ?? :: && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= =>

region

(used in pp_start_region)
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)>

remove

(used in remove_accessor_declaration)
MayBeFollowedBy: {

restore

(used in warning_action)
MayBeFollowedBy: <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)>

return

(used in return_statement yield_statement attribute_target keyword)
MayBeFollowedBy: ; + - ! ~ new ++ -- ( await from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword> : <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as break case catch class const continue do else enum event explicit extern finally fixed for foreach goto if implicit in interface internal is lock namespace operator out override params private protected public readonly ref return sealed stackalloc static struct switch throw try unsafe using virtual void volatile while $ { } [ ] ) , / % | ^ = < > ? ?? :: && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= =>

right_shift

(used in overloadable_binary_operator)
MayBeFollowedBy: (

sbyte

(used in integral_type predefined_type keyword)
MayBeFollowedBy: . <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

sealed

(used in class_modifier method_modifier property_modifier event_modifier indexer_modifier keyword)
MayBeFollowedBy: class partial new public protected internal private abstract sealed static unsafe void object dynamic string @ bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double virtual override extern event <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* as base break case catch checked const continue default delegate do else enum explicit false finally fixed for foreach goto if implicit in interface is lock namespace null operator out params readonly ref return sizeof stackalloc struct switch this throw true try typeof unchecked using volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => 0x 0X " @"

select

(used in select_clause)
MayBeFollowedBy: + - ! ~ new ++ -- ( await from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>

set

(used in set_accessor_declaration interface_accessors)
MayBeFollowedBy: { ;

short

(used in integral_type predefined_type keyword)
MayBeFollowedBy: . <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

sizeof

(used in sizeof_expression keyword)
MayBeFollowedBy: ( <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @"

stackalloc

(used in stackalloc_initializer keyword)
MayBeFollowedBy: object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as base break case catch checked class const continue default delegate do else enum event explicit extern false finally fixed for foreach goto if implicit in interface internal is lock namespace new null operator out override params private protected public readonly ref return sealed sizeof stackalloc static struct switch this throw true try typeof unchecked unsafe using virtual volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => 0x 0X " @"

static

(used in using_static_directive class_modifier field_modifier method_modifier property_modifier event_modifier operator_modifier static_constructor_modifiers static_constructor_modifiers_unsafe keyword)
MayBeFollowedBy: @ <An identifier_or_keyword that is not a keyword> class partial new public protected internal private abstract sealed static unsafe object dynamic string void bool decimal sbyte byte short ushort int uint long ulong char float double readonly volatile virtual override extern event implicit explicit <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* as base break case catch checked const continue default delegate do else enum false finally fixed for foreach goto if in interface is lock namespace null operator out params ref return sizeof stackalloc struct switch this throw true try typeof unchecked using while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => 0x 0X " @"

string

(used in class_type predefined_type keyword)
MayBeFollowedBy: . <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" where <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let join orderby equals on into ascending descending by partial dynamic

struct

(used in primary_constraint struct_declaration keyword)
MayBeFollowedBy: { where , @ <An identifier_or_keyword that is not a keyword> <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ } [ ] ( ) : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => 0x 0X " @"

switch

(used in switch_statement keyword)
MayBeFollowedBy: ( <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @"

this

(used in this_access named_entity_target parameter_modifier indexer_declarator constructor_initializer interface_indexer_declaration keyword)
MayBeFollowedBy: . object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double [ ( <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as base break case catch checked class const continue default delegate do else enum event explicit extern false finally fixed for foreach goto if implicit in interface internal is lock namespace new null operator out override params private protected public readonly ref return sealed sizeof stackalloc static struct switch this throw true try typeof unchecked unsafe using virtual volatile while 0 1 2 3 4 5 6 7 8 9 ' $ { } ] ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => 0x 0X " @" >>= >> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial

throw

(used in throw_statement keyword)
MayBeFollowedBy: ; + - ! ~ new ++ -- ( await from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword> <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as break case catch class const continue do else enum event explicit extern finally fixed for foreach goto if implicit in interface internal is lock namespace operator out override params private protected public readonly ref return sealed stackalloc static struct switch throw try unsafe using virtual void volatile while $ { } [ ] ) , : / % | ^ = < > ? ?? :: && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= =>

true

(used in overloadable_unary_operator keyword boolean_literal pp_primary_expression)
MayBeFollowedBy: ( <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" >>= >> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

try

(used in try_statement keyword)
MayBeFollowedBy: { <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @"

type

(used in attribute_target)
MayBeFollowedBy: :

typeof

(used in typeof_expression keyword)
MayBeFollowedBy: ( <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @"

u

(used in integer_type_suffix)
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" >>= >> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

U

(used in integer_type_suffix)
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" >>= >> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

uint

(used in integral_type predefined_type keyword)
MayBeFollowedBy: . <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

ul

(used in integer_type_suffix)
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" >>= >> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

uL

(used in integer_type_suffix)
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" >>= >> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

Ul

(used in integer_type_suffix)
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" >>= >> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

UL

(used in integer_type_suffix)
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" >>= >> <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

ulong

(used in integral_type predefined_type keyword)
MayBeFollowedBy: . <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

unchecked

(used in unchecked_expression unchecked_statement keyword)
MayBeFollowedBy: ( { <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ } [ ] ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @"

undef

(used in pp_declaration)
MayBeFollowedBy: <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)>

unsafe

(used in class_modifier_unsafe struct_modifier_unsafe interface_modifier_unsafe delegate_modifier_unsafe field_modifier_unsafe method_modifier_unsafe property_modifier_unsafe event_modifier_unsafe indexer_modifier_unsafe operator_modifier_unsafe constructor_modifier_unsafe destructor_declaration_unsafe static_constructor_modifiers_unsafe unsafe_statement fixed_size_buffer_modifier keyword)
MayBeFollowedBy: class partial new public protected internal private abstract sealed static unsafe struct interface delegate object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double readonly volatile virtual override extern event implicit explicit ~ { fixed <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* as base break case catch checked const continue default do else enum false finally for foreach goto if in is lock namespace null operator out params ref return sizeof stackalloc switch this throw true try typeof unchecked using while 0 1 2 3 4 5 6 7 8 9 . ' $ } [ ] ( ) , : ; + - * / % & | ^ ! = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => 0x 0X " @"

ushort

(used in integral_type predefined_type keyword)
MayBeFollowedBy: . <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @" <Any character except " (U+0022), : (U+003A), { (U+007B) and } (U+007D)> from select group let where join orderby equals on into ascending descending by partial dynamic

using

(used in using_alias_directive using_namespace_directive using_static_directive using_statement keyword)
MayBeFollowedBy: @ <An identifier_or_keyword that is not a keyword> static ( <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => 0x 0X " @"

var

(used in local_variable_type)
MayBeFollowedBy: @ <An identifier_or_keyword that is not a keyword>

virtual

(used in method_modifier property_modifier event_modifier indexer_modifier keyword)
MayBeFollowedBy: void object dynamic string @ bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double partial new public protected internal private static virtual sealed override abstract extern unsafe event <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* as base break case catch checked class const continue default delegate do else enum explicit false finally fixed for foreach goto if implicit in interface is lock namespace null operator out params readonly ref return sizeof stackalloc struct switch this throw true try typeof unchecked using volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => 0x 0X " @"

void

(used in typeof_expression return_type pointer_type keyword)
MayBeFollowedBy: ) @ <An identifier_or_keyword that is not a keyword> * <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( , : ; + - / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => 0x 0X " @"

volatile

(used in field_modifier keyword)
MayBeFollowedBy: object dynamic string @ void bool <An identifier_or_keyword that is not a keyword> decimal sbyte byte short ushort int uint long ulong char float double new public protected internal private static readonly volatile unsafe <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* abstract as base break case catch checked class const continue default delegate do else enum event explicit extern false finally fixed for foreach goto if implicit in interface is lock namespace null operator out override params ref return sealed sizeof stackalloc struct switch this throw true try typeof unchecked using virtual while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ( ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => 0x 0X " @"

warning

(used in pp_diagnostic pragma_warning_body)
MayBeFollowedBy: <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)>

when

(used in exception_filter)
MayBeFollowedBy: (

where

(used in where_clause type_parameter_constraints_clause)
MayBeFollowedBy: + - ! ~ new ++ -- ( await from <UNDEFINED> this base typeof checked unchecked default nameof delegate * & true false 0 1 2 3 4 5 6 7 8 9 . ' null @ bool byte char decimal double float int long object sbyte short string uint ulong ushort sizeof 0x 0X " @" <An identifier_or_keyword that is not a keyword>

while

(used in while_statement do_statement keyword)
MayBeFollowedBy: ( <Carriage return character (U+000D)> <Line feed character (U+000A)> <Carriage return character (U+000D) followed by line feed character (U+000A)> <Next line character (U+0085)> <Line separator character (U+2028)> <Paragraph separator character (U+2029)> <Any character with Unicode class Zs> <Horizontal tab character (U+0009)> <Vertical tab character (U+000B)> <Form feed character (U+000C)> // /* @ abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while 0 1 2 3 4 5 6 7 8 9 . ' $ { } [ ] ) , : ; + - * / % & | ^ ! ~ = < > ? ?? :: ++ -- && || -> == != <= >= += -= *= /= %= &= |= ^= << <<= => <An identifier_or_keyword that is not a keyword> 0x 0X " @"

yield

(used in yield_statement)
MayBeFollowedBy: return break

Grammar csharp

start ::=

compilation_unit ::=

namespace_declaration ::=

qualified_identifier ::=

namespace_body ::=

extern_alias_directive ::=

using_directive ::=

using_alias_directive ::=

using_namespace_directive ::=

using_static_directive ::=

namespace_member_declaration ::=

type_declaration ::=

qualified_alias_member ::=

namespace_name ::=

type_name ::=

namespace_or_type_name ::=

type ::=

value_type ::=

struct_type ::=

simple_type ::=

numeric_type ::=

integral_type ::=

floating_point_type ::=

nullable_type ::=

non_nullable_value_type ::=

enum_type ::=

reference_type ::=

class_type ::=

interface_type ::=

array_type ::=

non_array_type ::=

rank_specifier ::=

dim_separator ::=

delegate_type ::=

type_argument_list ::=

type_arguments ::=

type_argument ::=

type_parameter ::=

variable_reference ::=

argument_list ::=

argument ::=

argument_name ::=

argument_value ::=

primary_expression ::=

primary_no_array_creation_expression ::=

interpolated_string_expression ::=

interpolated_regular_string ::=

interpolated_regular_string_body ::=

interpolation ::=

interpolated_verbatim_string ::=

interpolated_verbatim_string_body ::=

simple_name ::=

parenthesized_expression ::=

member_access ::=

predefined_type ::=

invocation_expression ::=

element_access ::=

this_access ::=

base_access ::=

post_increment_expression ::=

post_decrement_expression ::=

object_creation_expression ::=

object_or_collection_initializer ::=

object_initializer ::=

member_initializer_list ::=

member_initializer ::=

initializer_target ::=

initializer_value ::=

collection_initializer ::=

element_initializer_list ::=

element_initializer ::=

expression_list ::=

array_creation_expression ::=

delegate_creation_expression ::=

anonymous_object_creation_expression ::=

anonymous_object_initializer ::=

member_declarator_list ::=

member_declarator ::=

typeof_expression ::=