typeof expression. A generic type is considered unbound
- if all of the type argument lists in its fully qualified name are empty.
- Note that the type arguments of an unbound generic type will be returned as error
- types because they do not really have type arguments. An unbound generic type
- yields null for its BaseType and an empty result for its Interfaces.
-
- namespace NS
- {
- using o = System.Object;
- partial class C : o {}
- partial class C : object {}
- partial class C : System.Object {}
- }
-
- all three declarations for class C are equivalent and result in the same symbol table object
- for C. However, these using alias symbols do appear in the results of certain SemanticModel
- APIs. Specifically, for the base clause of the first of C's class declarations, the
- following APIs may produce a result that contains an AliasSymbol:
- - SemanticInfo SemanticModel.GetSemanticInfo(ExpressionSyntax expression); - SemanticInfo SemanticModel.BindExpression(CSharpSyntaxNode location, ExpressionSyntax expression); - SemanticInfo SemanticModel.BindType(CSharpSyntaxNode location, ExpressionSyntax type); - SemanticInfo SemanticModel.BindNamespaceOrType(CSharpSyntaxNode location, ExpressionSyntax type); -- Also, the following are affected if container==null (and, for the latter, when arity==null - or arity==0): -
- IList<string> SemanticModel.LookupNames(CSharpSyntaxNode location, NamespaceOrTypeSymbol container = null, LookupOptions options = LookupOptions.Default, List<string> result = null); - IList<Symbol> SemanticModel.LookupSymbols(CSharpSyntaxNode location, NamespaceOrTypeSymbol container = null, string name = null, int? arity = null, LookupOptions options = LookupOptions.Default, List<Symbol> results = null); --
- using (var localVariable = new StreamReader("C:\\Temp\\MyFile.txt")) { ... }
-
- typeof expression. A generic type is considered unbound
+ if all of the type argument lists in its fully qualified name are empty.
+ Note that the type arguments of an unbound generic type will be returned as error
+ types because they do not really have type arguments. An unbound generic type
+ yields null for its BaseType and an empty result for its Interfaces.
+
+ namespace NS
+ {
+ using o = System.Object;
+ partial class C : o {}
+ partial class C : object {}
+ partial class C : System.Object {}
+ }
+
+ all three declarations for class C are equivalent and result in the same symbol table object
+ for C. However, these using alias symbols do appear in the results of certain SemanticModel
+ APIs. Specifically, for the base clause of the first of C's class declarations, the
+ following APIs may produce a result that contains an AliasSymbol:
+ + SemanticInfo SemanticModel.GetSemanticInfo(ExpressionSyntax expression); + SemanticInfo SemanticModel.BindExpression(CSharpSyntaxNode location, ExpressionSyntax expression); + SemanticInfo SemanticModel.BindType(CSharpSyntaxNode location, ExpressionSyntax type); + SemanticInfo SemanticModel.BindNamespaceOrType(CSharpSyntaxNode location, ExpressionSyntax type); ++ Also, the following are affected if container==null (and, for the latter, when arity==null + or arity==0): +
+ IList<string> SemanticModel.LookupNames(CSharpSyntaxNode location, NamespaceOrTypeSymbol container = null, LookupOptions options = LookupOptions.Default, List<string> result = null); + IList<Symbol> SemanticModel.LookupSymbols(CSharpSyntaxNode location, NamespaceOrTypeSymbol container = null, string name = null, int? arity = null, LookupOptions options = LookupOptions.Default, List<Symbol> results = null); ++
null.
+
+ using (var localVariable = new StreamReader("C:\\Temp\\MyFile.txt")) { ... }
+
+ null.
+ typeof expression. A generic type is considered unbound
- if all of the type argument lists in its fully qualified name are empty.
- Note that the type arguments of an unbound generic type will be returned as error
- types because they do not really have type arguments. An unbound generic type
- yields null for its BaseType and an empty result for its Interfaces.
-
- namespace NS
- {
- using o = System.Object;
- partial class C : o {}
- partial class C : object {}
- partial class C : System.Object {}
- }
-
- all three declarations for class C are equivalent and result in the same symbol table object
- for C. However, these using alias symbols do appear in the results of certain SemanticModel
- APIs. Specifically, for the base clause of the first of C's class declarations, the
- following APIs may produce a result that contains an AliasSymbol:
- - SemanticInfo SemanticModel.GetSemanticInfo(ExpressionSyntax expression); - SemanticInfo SemanticModel.BindExpression(CSharpSyntaxNode location, ExpressionSyntax expression); - SemanticInfo SemanticModel.BindType(CSharpSyntaxNode location, ExpressionSyntax type); - SemanticInfo SemanticModel.BindNamespaceOrType(CSharpSyntaxNode location, ExpressionSyntax type); -- Also, the following are affected if container==null (and, for the latter, when arity==null - or arity==0): -
- IList<string> SemanticModel.LookupNames(CSharpSyntaxNode location, NamespaceOrTypeSymbol container = null, LookupOptions options = LookupOptions.Default, List<string> result = null); - IList<Symbol> SemanticModel.LookupSymbols(CSharpSyntaxNode location, NamespaceOrTypeSymbol container = null, string name = null, int? arity = null, LookupOptions options = LookupOptions.Default, List<Symbol> results = null); --
- using (var localVariable = new StreamReader("C:\\Temp\\MyFile.txt")) { ... }
-
- typeof expression. A generic type is considered unbound
+ if all of the type argument lists in its fully qualified name are empty.
+ Note that the type arguments of an unbound generic type will be returned as error
+ types because they do not really have type arguments. An unbound generic type
+ yields null for its BaseType and an empty result for its Interfaces.
+
+ namespace NS
+ {
+ using o = System.Object;
+ partial class C : o {}
+ partial class C : object {}
+ partial class C : System.Object {}
+ }
+
+ all three declarations for class C are equivalent and result in the same symbol table object
+ for C. However, these using alias symbols do appear in the results of certain SemanticModel
+ APIs. Specifically, for the base clause of the first of C's class declarations, the
+ following APIs may produce a result that contains an AliasSymbol:
+ + SemanticInfo SemanticModel.GetSemanticInfo(ExpressionSyntax expression); + SemanticInfo SemanticModel.BindExpression(CSharpSyntaxNode location, ExpressionSyntax expression); + SemanticInfo SemanticModel.BindType(CSharpSyntaxNode location, ExpressionSyntax type); + SemanticInfo SemanticModel.BindNamespaceOrType(CSharpSyntaxNode location, ExpressionSyntax type); ++ Also, the following are affected if container==null (and, for the latter, when arity==null + or arity==0): +
+ IList<string> SemanticModel.LookupNames(CSharpSyntaxNode location, NamespaceOrTypeSymbol container = null, LookupOptions options = LookupOptions.Default, List<string> result = null); + IList<Symbol> SemanticModel.LookupSymbols(CSharpSyntaxNode location, NamespaceOrTypeSymbol container = null, string name = null, int? arity = null, LookupOptions options = LookupOptions.Default, List<Symbol> results = null); ++
null.
+
+ using (var localVariable = new StreamReader("C:\\Temp\\MyFile.txt")) { ... }
+
+ null.
+ typeof expression. A generic type is considered unbound
+ if all of the type argument lists in its fully qualified name are empty.
+ Note that the type arguments of an unbound generic type will be returned as error
+ types because they do not really have type arguments. An unbound generic type
+ yields null for its BaseType and an empty result for its Interfaces.
+
+ namespace NS
+ {
+ using o = System.Object;
+ partial class C : o {}
+ partial class C : object {}
+ partial class C : System.Object {}
+ }
+
+ all three declarations for class C are equivalent and result in the same symbol table object
+ for C. However, these using alias symbols do appear in the results of certain SemanticModel
+ APIs. Specifically, for the base clause of the first of C's class declarations, the
+ following APIs may produce a result that contains an AliasSymbol:
+ + SemanticInfo SemanticModel.GetSemanticInfo(ExpressionSyntax expression); + SemanticInfo SemanticModel.BindExpression(CSharpSyntaxNode location, ExpressionSyntax expression); + SemanticInfo SemanticModel.BindType(CSharpSyntaxNode location, ExpressionSyntax type); + SemanticInfo SemanticModel.BindNamespaceOrType(CSharpSyntaxNode location, ExpressionSyntax type); ++ Also, the following are affected if container==null (and, for the latter, when arity==null + or arity==0): +
+ IList<string> SemanticModel.LookupNames(CSharpSyntaxNode location, NamespaceOrTypeSymbol container = null, LookupOptions options = LookupOptions.Default, List<string> result = null); + IList<Symbol> SemanticModel.LookupSymbols(CSharpSyntaxNode location, NamespaceOrTypeSymbol container = null, string name = null, int? arity = null, LookupOptions options = LookupOptions.Default, List<Symbol> results = null); ++
null.
+
+ using (var localVariable = new StreamReader("C:\\Temp\\MyFile.txt")) { ... }
+
+ null.
+ - 0.Mantissa * 10^Exponent -- The Mantissa buffer stores the mantissa digits as characters in a string. - The MantissaCount gives the number of digits present in the Mantissa buffer. - There shall be neither leading nor trailing zero digits in the Mantissa. - Note that this represents only nonnegative floating-point literals; the - negative sign in C# and VB is actually a separate unary negation operator. -
#line (C#) or #ExternalSource (VB) directives.
- #line in C# or #ExternalSource in VB).
- #line).
- #line in C# or #ExternalSource in VB).
- #line,
- otherwise it's #line directive that precedes it and that
- either specifies an explicit file path or is #line default exists and specifies an explicit path.
- + 0.Mantissa * 10^Exponent ++ The Mantissa buffer stores the mantissa digits as characters in a string. + The MantissaCount gives the number of digits present in the Mantissa buffer. + There shall be neither leading nor trailing zero digits in the Mantissa. + Note that this represents only nonnegative floating-point literals; the + negative sign in C# and VB is actually a separate unary negation operator. +
true will implement this interface.
+
+ This interface provides a common way to both easily find the root of a #line (C#) or #ExternalSource (VB) directives.
+ #line in C# or #ExternalSource in VB).
+ null.
+ null.
+ #line).
+ #line in C# or #ExternalSource in VB).
+ #line,
+ otherwise it's #line directive that precedes it and that
+ either specifies an explicit file path or is #line default exists and specifies an explicit path.
+ - 0.Mantissa * 10^Exponent -- The Mantissa buffer stores the mantissa digits as characters in a string. - The MantissaCount gives the number of digits present in the Mantissa buffer. - There shall be neither leading nor trailing zero digits in the Mantissa. - Note that this represents only nonnegative floating-point literals; the - negative sign in C# and VB is actually a separate unary negation operator. -
#line (C#) or #ExternalSource (VB) directives.
- #line in C# or #ExternalSource in VB).
- #line).
- #line in C# or #ExternalSource in VB).
- #line,
- otherwise it's #line directive that precedes it and that
- either specifies an explicit file path or is #line default exists and specifies an explicit path.
- + 0.Mantissa * 10^Exponent ++ The Mantissa buffer stores the mantissa digits as characters in a string. + The MantissaCount gives the number of digits present in the Mantissa buffer. + There shall be neither leading nor trailing zero digits in the Mantissa. + Note that this represents only nonnegative floating-point literals; the + negative sign in C# and VB is actually a separate unary negation operator. +
true will implement this interface.
+
+ This interface provides a common way to both easily find the root of a #line (C#) or #ExternalSource (VB) directives.
+ #line in C# or #ExternalSource in VB).
+ null.
+ null.
+ #line).
+ #line in C# or #ExternalSource in VB).
+ #line,
+ otherwise it's #line directive that precedes it and that
+ either specifies an explicit file path or is #line default exists and specifies an explicit path.
+ + 0.Mantissa * 10^Exponent ++ The Mantissa buffer stores the mantissa digits as characters in a string. + The MantissaCount gives the number of digits present in the Mantissa buffer. + There shall be neither leading nor trailing zero digits in the Mantissa. + Note that this represents only nonnegative floating-point literals; the + negative sign in C# and VB is actually a separate unary negation operator. +
true will implement this interface.
+
+ This interface provides a common way to both easily find the root of a #line (C#) or #ExternalSource (VB) directives.
+ #line in C# or #ExternalSource in VB).
+ null.
+ null.
+ #line).
+ #line in C# or #ExternalSource in VB).
+ #line,
+ otherwise it's #line directive that precedes it and that
+ either specifies an explicit file path or is #line default exists and specifies an explicit path.
+
- if (reader.StringComparer.Equals(typeDef.Namespace, "System") &&
- reader.StringComparer.Equals(typeDef.Name, "Object")
- {
- // found System.Object
- }
-
-
- is no less efficient than:
-
-
- var comparer = reader.StringComparer;
- if (comparer.Equals(typeDef.Namespace, "System") &&
- comparer.Equals(typeDef.Name, "Object")
- {
- // found System.Object
- }
-
-
- The choice between them is therefore one of style and not performance.
-
+ if (reader.StringComparer.Equals(typeDef.Namespace, "System") &&
+ reader.StringComparer.Equals(typeDef.Name, "Object")
+ {
+ // found System.Object
+ }
+
+
+ is no less efficient than:
+
+
+ var comparer = reader.StringComparer;
+ if (comparer.Equals(typeDef.Namespace, "System") &&
+ comparer.Equals(typeDef.Name, "Object")
+ {
+ // found System.Object
+ }
+
+
+ The choice between them is therefore one of style and not performance.
+
- if (reader.StringComparer.Equals(typeDef.Namespace, "System") &&
- reader.StringComparer.Equals(typeDef.Name, "Object")
- {
- // found System.Object
- }
-
-
- is no less efficient than:
-
-
- var comparer = reader.StringComparer;
- if (comparer.Equals(typeDef.Namespace, "System") &&
- comparer.Equals(typeDef.Name, "Object")
- {
- // found System.Object
- }
-
-
- The choice between them is therefore one of style and not performance.
-
+ if (reader.StringComparer.Equals(typeDef.Namespace, "System") &&
+ reader.StringComparer.Equals(typeDef.Name, "Object")
+ {
+ // found System.Object
+ }
+
+
+ is no less efficient than:
+
+
+ var comparer = reader.StringComparer;
+ if (comparer.Equals(typeDef.Namespace, "System") &&
+ comparer.Equals(typeDef.Name, "Object")
+ {
+ // found System.Object
+ }
+
+
+ The choice between them is therefore one of style and not performance.
+