Fix typo

.Net - .NET

docs/analyzers/Localizing Analyzers.md

@@ -17,7 +17,7 @@ You'll need to create a .resx file to hold your localizable resources. For the p
 Using Localized Resources in Analyzers
 --------------------------------------
 
-Normally, .Net applications can simply access the resource through the type generated from the .resx file:
+Normally, .NET applications can simply access the resource through the type generated from the .resx file:
 ``` C#
 string message = AnalyzerResources.Message;
 ```

docs/compilers/Visual Basic/Overflow In Embedded Runtime.md

 ### VB Embedded Runtime inherits overflow checking from the compilation
 
-See https://github.com/dotnet/roslyn/issues/6941. Some VB runtime methods are specified to throw an `OverflowException` when a converted value overflows the target type. When compiling a VB project with the runtime embedded (`/vbruntime*`), the compiler includes the necessary VB runtime helpers into the assembly that is produced.  These runtime helpers inherit the overflow checking behavior of the VB.NET project that they are embedded into.  As a result, if you both embed the runtime and have overflow checking disabled (`/removeintchecks+`), you will not get the specified exceptions from the runtime helpers.  Although technically it is a bug, it has long been the behavior of VB.Net and we have found that customers would be broken by having it fixed, so we do not expect to change this behavior.
+See https://github.com/dotnet/roslyn/issues/6941. Some VB runtime methods are specified to throw an `OverflowException` when a converted value overflows the target type. When compiling a VB project with the runtime embedded (`/vbruntime*`), the compiler includes the necessary VB runtime helpers into the assembly that is produced.  These runtime helpers inherit the overflow checking behavior of the VB.NET project that they are embedded into.  As a result, if you both embed the runtime and have overflow checking disabled (`/removeintchecks+`), you will not get the specified exceptions from the runtime helpers.  Although technically it is a bug, it has long been the behavior of VB.NET and we have found that customers would be broken by having it fixed, so we do not expect to change this behavior.
 
 ``` vb
 Sub Main()

docs/contributing/Building, Debugging, and Testing on Windows.md

@@ -43,7 +43,7 @@ The Test.cmd script will run our unit test on already built binaries.  It can be
 2. Navigate to the directory of your Git clone.
 3. Run `msbuild /v:m /m /nodereuse:false BuildAndTest.proj` in the command prompt.
 
-You can more precisely control how the tests are run by running the eng/build.ps1 script directly with the relevant options. For example passing in the `-test` switch will run the tests on .Net Framework, whilst passing in the `-testCoreClr` switch will run the tests on .Net Core.
+You can more precisely control how the tests are run by running the eng/build.ps1 script directly with the relevant options. For example passing in the `-test` switch will run the tests on .NET Framework, whilst passing in the `-testCoreClr` switch will run the tests on .NET Core.
 
 The results of the tests can be viewed in the artifacts/TestResults directory.
 

docs/features/deconstruction.md

@@ -73,7 +73,7 @@ If the left-hand-side is nested the process will be repeated. For instance, in `
 In the case where the expression on the right is a tuple expression, it is first given a type. So in `long x; string y; (x, y) = (1, null);` the literals on the right-hand-side are typed as `long` and `string` before the deconstruction even starts, which means that no conversions will be needed during the deconstruction steps.
 
 We noted already that tuples (which are syntactic sugar for the `System.ValueTuple` underlying type) don't need to invoke `Deconstruct`.
-The .Net framework also includes a set of `System.Tuple` types. Those are not recognized as C# tuples, and so will rely on the *Deconstruct* pattern. Those `Deconstruct` methods will be provided as extension methods for `System.Tuple` for up to 3 nestings deep (that is 21 elements).
+The .NET framework also includes a set of `System.Tuple` types. Those are not recognized as C# tuples, and so will rely on the *Deconstruct* pattern. Those `Deconstruct` methods will be provided as extension methods for `System.Tuple` for up to 3 nestings deep (that is 21 elements).
 
 A *deconstruction-assignment* returns a tuple value (with elements using default names) which is shaped and typed like the left-hand-side and holds the (converted) parts resulting from deconstruction.
 

src/Compilers/CSharp/Portable/CodeGen/EmitArrayInitializer.cs

@@ -286,7 +286,7 @@ private void InitializerCountRecursive(ImmutableArray<BoundExpression> inits, re
                 else
                 {
                     // NOTE: default values do not need to be initialized. 
-                    //       .Net arrays are always zero-inited.
+                    //       .NET arrays are always zero-inited.
                     if (!init.IsDefaultValue())
                     {
                         initCount += 1;

src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs

@@ -3236,7 +3236,7 @@ internal void SymbolDeclaredEvent(Symbol symbol)
         /// <remarks>
         /// In NetFx 4.0, block array initializers do not work on all combinations of {32/64 X Debug/Retail} when array elements are enums.
         /// This is fixed in 4.5 thus enabling block array initialization for a very common case.
-        /// We look for the presence of <see cref="System.Runtime.GCLatencyMode.SustainedLowLatency"/> which was introduced in .Net 4.5
+        /// We look for the presence of <see cref="System.Runtime.GCLatencyMode.SustainedLowLatency"/> which was introduced in .NET Framework 4.5
         /// </remarks>
         internal bool EnableEnumArrayBlockInitialization
         {

src/Compilers/CSharp/Test/Symbol/Compilation/CompilationAPITests.cs

@@ -2031,7 +2031,7 @@ public void AppConfig1()
         [Fact]
         public void AppConfig2()
         {
-            // Create a dll with a reference to .net system
+            // Create a dll with a reference to .NET system
             string libSource = @"
 using System.Runtime.Versioning;
 public class C { public static FrameworkName Goo() { return null; }}";

src/Compilers/CSharp/Test/Symbol/Symbols/Metadata/PE/TypeForwarders.cs

@@ -1607,7 +1607,7 @@ public class Test { }
             EntityHandle token = metadata.GetTypeRef(metadata.GetAssemblyRef("mscorlib"), "System.Runtime.CompilerServices", "AssemblyAttributesGoHereM");
             Assert.True(token.IsNil);   //could the type ref be located? If not then the attribute's not there.
 
-            // Exported types in .Net module cause PEVerify to fail.
+            // Exported types in .NET module cause PEVerify to fail.
             CompileAndVerify(appCompilation, verify: Verification.Fails,
                 symbolValidator: m =>
                 {

src/Compilers/CSharp/Test/Symbol/Symbols/SymbolErrorTests.cs

@@ -6981,7 +6981,7 @@ public class CF3<T>
                     forwardedTypes1Ref
                 }, TestOptions.ReleaseDll);
 
-            // Exported types in .Net modules cause PEVerify to fail on some platforms.
+            // Exported types in .NET modules cause PEVerify to fail on some platforms.
             CompileAndVerify(compilation, verify: Verification.Skipped).VerifyDiagnostics();
 
             compilation = CreateCompilation("[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(CF3<byte>))]",

src/Compilers/CSharp/Test/Symbol/Symbols/TypeTests.cs

@@ -515,8 +515,8 @@ public void ArrayTypes()
         }
 
         // Interfaces impl-ed by System.Array
-        // .Net 2/3.0 (7) IList&[T] -> ICollection&[T] ->IEnumerable&[T]; ICloneable;
-        // .Net 4.0 (9) IList&[T] -> ICollection&[T] ->IEnumerable&[T]; ICloneable; IStructuralComparable; IStructuralEquatable
+        // .NET 2/3.0 (7) IList&[T] -> ICollection&[T] ->IEnumerable&[T]; ICloneable;
+        // .NET 4.0 (9) IList&[T] -> ICollection&[T] ->IEnumerable&[T]; ICloneable; IStructuralComparable; IStructuralEquatable
         // Array T[] impl IList[T] only
         [Fact, WorkItem(537300, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/537300"), WorkItem(527247, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/527247")]
         public void ArrayTypeInterfaces()

src/Compilers/Core/MSBuildTask/ManagedToolTask.cs

@@ -51,7 +51,7 @@ protected sealed override string GenerateCommandLineCommands()
 
         /// <summary>
         /// This generates the path to the executable that is directly ran.
-        /// This could be the managed assembly itself (on desktop .net on Windows),
+        /// This could be the managed assembly itself (on desktop .NET on Windows),
         /// or a runtime such as dotnet.
         /// </summary>
         protected sealed override string GenerateFullPathToTool()

src/Compilers/Core/Portable/InternalUtilities/StringExtensions.cs

@@ -71,7 +71,7 @@ public static bool LooksLikeTypeParameterName(this string name)
             bool trimLeadingTypePrefix,
             Func<char, char> convert)
         {
-            // Special case the common .net pattern of "IGoo" as a type name.  In this case we
+            // Special case the common .NET pattern of "IGoo" as a type name.  In this case we
             // want to generate "goo" as the parameter name.  
             if (!string.IsNullOrEmpty(shortName))
             {

src/Compilers/VisualBasic/Portable/CodeGen/EmitArrayInitializer.vb

@@ -238,7 +238,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGen
                     InitializerCountRecursive(asArrayInit.Initializers, initCount, constInits)
                 Else
                     ' NOTE Default values Do Not need To be initialized. 
-                    '       .Net arrays are always zero-inited.
+                    '       .NET arrays are always zero-inited.
                     If Not init.IsDefaultValue() Then
                         initCount += 1
                         If init.ConstantValueOpt IsNot Nothing Then

src/Compilers/VisualBasic/Portable/Compilation/VisualBasicCompilation.vb

@@ -1278,7 +1278,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
         ''' <remarks>
         ''' In NetFx 4.0, block array initializers do not work on all combinations of {32/64 X Debug/Retail} when array elements are enums.
         ''' This is fixed in 4.5 thus enabling block array initialization for a very common case.
-        ''' We look for the presence of <see cref="System.Runtime.GCLatencyMode.SustainedLowLatency"/> which was introduced in .Net 4.5
+        ''' We look for the presence of <see cref="System.Runtime.GCLatencyMode.SustainedLowLatency"/> which was introduced in .NET Framework 4.5
         ''' </remarks>
         Friend ReadOnly Property EnableEnumArrayBlockInitialization As Boolean
             Get

src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/Metadata/PE/TypeForwarders.vb

@@ -1042,7 +1042,7 @@ End class
             token = metadata.GetTypeRef(metadata.GetAssemblyRef("mscorlib"), "System.Runtime.CompilerServices", "AssemblyAttributesGoHereM")
             Assert.True(token.IsNil)   'could the type ref be located? If not then the attribute's not there.
 
-            ' Exported types in .Net module cause PEVerify to fail.
+            ' Exported types in .NET module cause PEVerify to fail.
             CompileAndVerify(appCompilation, verify:=Verification.Fails,
                 symbolValidator:=Sub(m)
                                      Dim metadataReader1 = DirectCast(m, PEModuleSymbol).Module.GetMetadataReader()
@@ -1210,7 +1210,7 @@ End class
 
             Dim appCompilation = CreateCompilationWithMscorlib40AndReferences(app, {modRef, New VisualBasicCompilationReference(forwardedTypesCompilation)}, TestOptions.ReleaseDll)
 
-            ' Exported types in .Net module cause PEVerify to fail.
+            ' Exported types in .NET module cause PEVerify to fail.
             CompileAndVerify(appCompilation, verify:=Verification.Fails,
                 symbolValidator:=Sub(m)
                                      Dim peReader1 = DirectCast(m, PEModuleSymbol).Module.GetMetadataReader()

src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/Source/TypeTests.vb

@@ -3195,7 +3195,7 @@ BC37218: Type 'ns.CF2' forwarded to assembly 'ForwardedTypes1, Version=0.0.0.0,
                     forwardedTypes1Ref
                 }, TestOptions.ReleaseDll)
 
-            ' Exported types in .Net modules cause PEVerify to fail.
+            ' Exported types in .NET modules cause PEVerify to fail.
             CompileAndVerify(compilation, verify:=Verification.Fails).VerifyDiagnostics()
 
             compilation = CreateCompilationWithMscorlib40AndReferences(emptySource,

src/Compilers/VisualBasic/Test/Syntax/Resources/VBAllInOne.vb

@@ -341,7 +341,7 @@ CaseLabel2:
             End Set
         End Property
 
-        'vb.net can't support abstract member variable
+        'VB.NET can't support abstract member variable
         Public ReadOnly Property P2() As String
             Get
             End Get

src/Compilers/VisualBasic/Test/Syntax/Syntax/VBAllInOne.txt

@@ -315,7 +315,7 @@ CaseLabel2:
             End Set
         End Property
 
-        'vb.net can't support abstract member variable
+        'VB.NET can't support abstract member variable
         Public ReadOnly Property P2() As String
             Get
             End Get

src/Features/Core/Portable/ConvertAnonymousTypeToClass/AbstractConvertAnonymousTypeToClassCodeRefactoringProvider.cs

@@ -363,7 +363,7 @@ private static IPropertySymbol GenerateProperty(Document document, IPropertySymb
             // in the type.  Instead, we just want to generate auto-props. So we effectively clone
             // the property, just throwing aways anything we don't need for that purpose.
             // 
-            // We also want to follow general .net naming.  So that means converting to pascal
+            // We also want to follow general .NET naming.  So that means converting to pascal
             // case from camel-case.
 
             var getMethod = prop.GetMethod != null ? CreateAccessorSymbol(prop, MethodKind.PropertyGet) : null;

src/Features/Core/Portable/EmbeddedLanguages/RegularExpressions/RegexEmbeddedCompletionProvider.cs

@@ -373,7 +373,7 @@ private void ProvideEscapeCategoryCompletions(EmbeddedCompletionContext context)
                 context.AddIfMissing($@"\k<  {Regex_name_or_number}  >", Regex_named_backreference_short, Regex_named_backreference_long, parentOpt, @"\k<".Length, insertionText: @"\k<>");
 
                 // Note: we intentionally do not add `\<>` to the list.  While supported by the 
-                // .net regex engine, it is effectively deprecated and discouraged from use.  
+                // .NET regex engine, it is effectively deprecated and discouraged from use.  
                 // Instead, it is recommended that `\k<>` is used instead.
                 // 
                 // context.AddIfMissing(@"\<>", "", "", parentOpt, @"\<".Length));

src/Features/Core/Portable/GenerateType/AbstractGenerateTypeService.State.cs

@@ -110,7 +110,7 @@ private State(Compilation compilation)
 
                 if (char.IsLower(name[0]) && !semanticDocument.SemanticModel.Compilation.IsCaseSensitive)
                 {
-                    // It's near universal in .Net that types start with a capital letter.  As such,
+                    // It's near universal in .NET that types start with a capital letter.  As such,
                     // if this name starts with a lowercase letter, don't even bother to offer 
                     // "generate type".  The user most likely wants to run 'Add Import' (which will
                     // then fix up a case where they typed an existing type name in lowercase, 

src/Features/Core/Portable/NavigateTo/AbstractNavigateToSearchService.InProcess.cs

@@ -121,7 +121,7 @@ internal abstract partial class AbstractNavigateToSearchService
             }
 
             // Would like to use CWT.AddOrUpdate. But that is not available on the 
-            // version of .Net that we're using.  So we need to take lock as we're
+            // version of .NET that we're using.  So we need to take lock as we're
             // making multiple mutations.
             lock (s_lastProjectSearchCache)
             {

src/Test/Utilities/Portable/TestResource.resx

@@ -1190,7 +1190,7 @@ CaseLabel2:
             End Set
         End Property
 
-        'vb.net can't support abstract member variable
+        'VB.NET can't support abstract member variable
         Public ReadOnly Property P2() As String
             Get
             End Get
@@ -2234,7 +2234,7 @@ CaseLabel2:
             End Set
         End Property
 
-        'vb.net can't support abstract member variable
+        'VB.NET can't support abstract member variable
         Public ReadOnly Property P2() As String
             Get
             End Get

src/VisualStudio/Core/Def/Implementation/ProjectSystem/VisualStudioWorkspaceImpl.cs

@@ -383,7 +383,7 @@ internal bool IsCPSProject(CodeAnalysis.Project project)
 
             if (this.TryGetHierarchy(project.Id, out var hierarchy))
             {
-                // Currently renaming files in CPS projects (i.e. .Net Core) doesn't work proprey.
+                // Currently renaming files in CPS projects (i.e. .NET Core) doesn't work proprey.
                 // This is because the remove/add of the documents in CPS is not synchronous
                 // (despite the DTE interfaces being synchronous).  So Roslyn calls the methods
                 // expecting the changes to happen immediately.  Because they are deferred in CPS

src/VisualStudio/Core/Def/Implementation/Venus/ContainedDocument.DocumentServiceProvider.cs

@@ -21,7 +21,7 @@ namespace Microsoft.VisualStudio.LanguageServices.Implementation.Venus
     internal sealed partial class ContainedDocument
     {
         // this is to support old venus/razor case before dev16. 
-        // all new razor (asp.net core after dev16) should use thier own implementation not ours
+        // all new razor (asp.NET core after dev16) should use thier own implementation not ours
         public class DocumentServiceProvider : IDocumentServiceProvider
         {
             private readonly SpanMapper _spanMapper;

src/Workspaces/CSharp/Portable/Extensions/SimpleNameSyntaxExtensions.cs

@@ -69,7 +69,7 @@ public static bool LooksLikeStandaloneTypeName(this SimpleNameSyntax simpleName)
                 // "Standalone type name".  
                 //
                 // 1. Users are not going to name types the same name as C# keywords (contextual or otherwise).
-                // 2. Types in .Net are virtually always start with a Uppercase. While keywords are lowercase)
+                // 2. Types in .NET are virtually always start with a Uppercase. While keywords are lowercase)
                 //
                 // Having a lowercase identifier which matches a c# keyword is enough of a signal 
                 // to just not treat this as a standalone type name (even though for some identifiers

src/Workspaces/CSharpTest/EmbeddedLanguages/RegularExpressions/CSharpRegexParserTests.cs

@@ -146,25 +146,25 @@ private SyntaxToken GetStringToken(string text)
             }
             catch (IndexOutOfRangeException) when (allowIndexOutOfRange)
             {
-                // bug with .net regex parser.  Can happen with patterns like: (?<-0
+                // bug with .NET regex parser.  Can happen with patterns like: (?<-0
                 Assert.NotEmpty(tree.Diagnostics);
                 return treeAndText;
             }
             catch (NullReferenceException) when (allowNullReference)
             {
-                // bug with .net regex parser.  can happen with patterns like: (?(?S))
+                // bug with .NET regex parser.  can happen with patterns like: (?(?S))
                 return treeAndText;
             }
             catch (OutOfMemoryException) when (allowOutOfMemeory)
             {
-                // bug with .net regex parser.  can happen with patterns like: a{2147483647,}
+                // bug with .NET regex parser.  can happen with patterns like: a{2147483647,}
                 return treeAndText;
             }
             catch (ArgumentException ex)
             {
                 Assert.NotEmpty(tree.Diagnostics);
 
-                // Ensure the diagnostic we emit is the same as the .Net one.  Note: we can only
+                // Ensure the diagnostic we emit is the same as the .NET one. Note: we can only
                 // do this in en-US as that's the only culture where we control the text exactly
                 // and can ensure it exactly matches Regex.  We depend on localization to do a 
                 // good enough job here for other languages.

src/Workspaces/Core/Portable/EmbeddedLanguages/RegularExpressions/LanguageServices/RegexSyntaxClassifier.cs

@@ -316,7 +316,7 @@ public void Visit(RegexTextNode node)
 
             public void Visit(RegexPosixPropertyNode node)
             {
-                // The .net parser just interprets the [ of the node, and skips the rest. So
+                // The .NET parser just interprets the [ of the node, and skips the rest. So
                 // classify the end part as a comment.
                 Result.Add(new ClassifiedSpan(node.TextToken.VirtualChars[0].Span, ClassificationTypeNames.RegexText));
                 Result.Add(new ClassifiedSpan(

src/Workspaces/Core/Portable/EmbeddedLanguages/RegularExpressions/RegexCharClass.cs

@@ -19,7 +19,7 @@ namespace Microsoft.CodeAnalysis.EmbeddedLanguages.RegularExpressions
 
     /// <summary>
     /// Minimal copy of https://github.com/dotnet/corefx/blob/master/src/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexCharClass.cs
-    /// Used to accurately determine if something is a WordChar according to the .Net regex engine.
+    /// Used to accurately determine if something is a WordChar according to the .NET regex engine.
     /// </summary>
     internal static class RegexCharClass
     {

src/Workspaces/Core/Portable/EmbeddedLanguages/RegularExpressions/RegexLexer.cs

@@ -440,7 +440,7 @@ public RegexToken ScanOctalCharacters(RegexOptions options)
                     Position++;
 
                     // Ecmascript doesn't allow octal values above 32 (0x20 in hex). Note: we do
-                    // *not* add a diagnostic.  This is not an error situation. The .net lexer
+                    // *not* add a diagnostic.  This is not an error situation. The .NET lexer
                     // simply stops once it hits a value greater than a legal octal value.
                     if (HasOption(options, RegexOptions.ECMAScript) && currentVal >= 0x20)
                     {

src/Workspaces/Core/Portable/EmbeddedLanguages/RegularExpressions/RegexNodes.cs

@@ -263,7 +263,7 @@ public override void Accept(IRegexNodeVisitor visitor)
     }
 
     /// <summary>
-    /// Represents a ```[:...:]``` node in a character class.  Note: the .net regex parser
+    /// Represents a ```[:...:]``` node in a character class.  Note: the .NET regex parser
     /// simply treats this as the character ```[``` and ignores the rest of the ```:...:]```.
     /// They latter part has no impact on the actual match engine that is produced.
     /// </summary>

src/Workspaces/Core/Portable/EmbeddedLanguages/RegularExpressions/RegexParser.cs

@@ -23,18 +23,18 @@ namespace Microsoft.CodeAnalysis.EmbeddedLanguages.RegularExpressions
     /// Produces a <see cref="RegexTree"/> from a sequence of <see cref="VirtualChar"/> characters.
     ///
     /// Importantly, this parser attempts to replicate diagnostics with almost the exact same text
-    /// as the native .Net regex parser.  This is important so that users get an understandable
+    /// as the native .NET regex parser.  This is important so that users get an understandable
     /// experience where it appears to them that this is all one cohesive system and that the IDE
     /// will let them discover and fix the same issues they would encounter when previously trying
     /// to just compile and execute these regexes.
     /// </summary>
     /// <remarks>
-    /// Invariants we try to maintain (and should consider a bug if we do not): l 1. If the .net
+    /// Invariants we try to maintain (and should consider a bug if we do not): l 1. If the .NET
     /// regex parser does not report an error for a given pattern, we should not either. it would be
     /// very bad if we told the user there was something wrong with there pattern when there really
     /// wasn't.
     ///
-    /// 2. If the .net regex parser does report an error for a given pattern, we should either not
+    /// 2. If the .NET regex parser does report an error for a given pattern, we should either not
     /// report an error (not recommended) or report the same error at an appropriate location in the
     /// pattern.  Not reporting the error can be confusing as the user will think their pattern is
     /// ok, when it really is not.  However, it can be acceptable to do this as it's not telling
@@ -43,23 +43,23 @@ namespace Microsoft.CodeAnalysis.EmbeddedLanguages.RegularExpressions
     /// documented in <see cref="ParsePossibleEcmascriptBackreferenceEscape"/>).
     ///
     /// Note1: "report the same error" means that we will attempt to report the error using the same
-    /// text the .net regex parser uses for its error messages.  This is so that the user is not
+    /// text the .NET regex parser uses for its error messages.  This is so that the user is not
     /// confused when they use the IDE vs running the regex by getting different messages for the
     /// same issue.
     ///
     /// Note2: the above invariants make life difficult at times.  This happens due to the fact that
-    /// the .net parser is multi-pass.  Meaning it does a first scan (which may report errors), then
+    /// the .NET parser is multi-pass.  Meaning it does a first scan (which may report errors), then
     /// does the full parse.  This means that it might report an error in a later location during
     /// the initial scan than it would during the parse.  We replicate that behavior to follow the
     /// second invariant.
     ///
     /// Note3: It would be nice if we could check these invariants at runtime, so we could control
-    /// our behavior by the behavior of the real .net regex engine.  For example, if the .net regex
+    /// our behavior by the behavior of the real .NET regex engine.  For example, if the .NET regex
     /// engine did not report any issues, we could suppress any diagnostics we generated and we
     /// could log an NFW to record which pattern we deviated on so we could fix the issue for a
-    /// future release.  However, we cannot do this as the .net regex engine has no guarantees about
+    /// future release.  However, we cannot do this as the .NET regex engine has no guarantees about
     /// its performance characteristics.  For example, certain regex patterns might end up causing
-    /// that engine to consume unbounded amounts of CPU and memory.  This is because the .net regex
+    /// that engine to consume unbounded amounts of CPU and memory.  This is because the .NET regex
     /// engine is not just a parser, but something that builds an actual recognizer using techniques
     /// that are not necessarily bounded.  As such, while we test ourselves around it during our
     /// tests, we cannot do the same at runtime as part of the IDE.
@@ -67,7 +67,7 @@ namespace Microsoft.CodeAnalysis.EmbeddedLanguages.RegularExpressions
     /// This parser was based off the corefx RegexParser based at:
     /// https://github.com/dotnet/corefx/blob/f759243d724f462da0bcef54e86588f8a55352c6/src/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexParser.cs#L1
     ///
-    /// Note4: The .Net parser itself changes over time (for example to fix behavior that even it
+    /// Note4: The .NET parser itself changes over time (for example to fix behavior that even it
     /// thinks is buggy).  When this happens, we have to make a choice as to which behavior to
     /// follow. In general, the overall principle is that we should follow the more lenient
     /// behavior.  If we end up taking the more strict interpretation we risk giving people an error
@@ -104,7 +104,7 @@ internal partial struct RegexParser
         /// produce the next token after that.
         /// </summary>
         /// <param name="allowTrivia">Whether or not trivia is allowed on the next token
-        /// produced.  In the .net parser trivia is only allowed on a few constructs,
+        /// produced.  In the .NET parser trivia is only allowed on a few constructs,
         /// and our parser mimics that behavior.  Note that even if trivia is allowed,
         /// the type of trivia that can be scanned depends on the current RegexOptions.
         /// For example, if <see cref="RegexOptions.IgnorePatternWhitespace"/> is currently
@@ -135,7 +135,7 @@ public static RegexTree TryParse(VirtualCharSequence text, RegexOptions options)
                 // to then parse the tree again, as the captures will affect how we interpret
                 // certain things (i.e. escape references) and what errors will be reported.
                 //
-                // This is necessary as .net regexes allow references to *future* captures.
+                // This is necessary as .NET regexes allow references to *future* captures.
                 // As such, we don't know when we're seeing a reference if it's to something
                 // that exists or not.
                 var tree1 = new RegexParser(text, options,
@@ -235,7 +235,7 @@ private RegexExpressionNode ParseAlternatingSequences(bool consumeCloseParen)
         /// <summary>
         /// Parses out code of the form: ...|...|...
         /// This is the type of code you have at the top level of a regex, or inside any grouping
-        /// contruct.  Note that sequences can be empty in .net regex.  i.e. the following is legal:
+        /// contruct.  Note that sequences can be empty in .NET regex.  i.e. the following is legal:
         /// 
         ///     ...||...
         /// 
@@ -853,7 +853,7 @@ private void MoveBackBeforePreviousScan()
         private RegexConditionalGroupingNode ParseConditionalExpressionGrouping(
             RegexToken openParenToken, RegexToken questionToken, RegexToken innerOpenParenToken)
         {
-            // Reproduce very specific errors the .net regex parser looks for.  Technically,
+            // Reproduce very specific errors the .NET regex parser looks for.  Technically,
             // we would error out in these cases no matter what.  However, it means we can
             // stringently enforce that our parser produces the same errors as the native one.
             //
@@ -1217,7 +1217,7 @@ private static RegexOptions OptionFromCode(VirtualChar ch)
 
         private RegexBaseCharacterClassNode ParseCharacterClass()
         {
-            // Note: ScanCharClass is one of the strangest function in the .net regex parser. Code
+            // Note: ScanCharClass is one of the strangest function in the .NET regex parser. Code
             // for it is here:
             // https://github.com/dotnet/corefx/blob/6ae0da1563e6e701bac61012c62ede8f8737f065/src/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexParser.cs#L498
             //
@@ -1238,8 +1238,8 @@ private RegexBaseCharacterClassNode ParseCharacterClass()
             // ignoring that character on the right side of a character range.  So, if you had
             // ```[#-\-b]```, then this *should* be treated as the character class containing
             // the range of character from '#' to '-', unioned with the character 'b'.  However,
-            // .net will interpret this as the character class containing the range of characters
-            // from '#' to 'b'.  We follow .Net here to keep our errors in sync with them.
+            // .NET will interpret this as the character class containing the range of characters
+            // from '#' to 'b'.  We follow .NET here to keep our errors in sync with them.
             //
             // See the comment about this in ParseRightSideOfCharacterClassRange
 
@@ -1506,7 +1506,7 @@ private bool HasProblem(RegexNodeOrToken component)
         private RegexExpressionNode ParseRightSideOfCharacterClassRange()
         {
             // Parsing the right hand side of a - is extremely strange (and most likely buggy) in
-            // the .net parser. Specifically, the .net parser will still consider itself on the
+            // the .NET parser. Specifically, the .NET parser will still consider itself on the
             // right side no matter how many escaped dashes it sees.  So, for example, the following
             // is legal [a-\-] (even though \- is less than 'a'). Similarly, the following are
             // *illegal* [b-\-a] and [b-\-\-a].  That's because the range that is checked is
@@ -1601,7 +1601,7 @@ private RegexPrimaryExpressionNode ParseSingleCharacterClassComponent(bool isFir
                     ConsumeCurrentToken(allowTrivia: false));
             }
 
-            // From the .net regex code:
+            // From the .NET regex code:
             // This is code for Posix style properties - [:Ll:] or [:IsTibetan:].
             // It currently doesn't do anything other than skip the whole thing!
             if (!afterRangeMinus && _currentToken.Kind == RegexKind.OpenBracketToken && _lexer.IsAt(":"))
@@ -1751,7 +1751,7 @@ private RegexEscapeNode ParsePossibleBackreferenceEscape(RegexToken backslashTok
             RegexToken backslashToken, bool allowTriviaAfterEnd)
         {
             // Small deviation: Ecmascript allows references only to captures that precede
-            // this position (unlike .net which allows references in any direction).  However,
+            // this position (unlike .NET which allows references in any direction).  However,
             // because we don't track position, we just consume the entire back-reference.
             //
             // This is addressable if we add position tracking when we locate all the captures.
@@ -1849,7 +1849,7 @@ private RegexEscapeNode ParsePossibleKCaptureEscape(RegexToken backslashToken, b
             if (capture.IsMissing || closeToken.IsMissing)
             {
                 // Native parser falls back to normal escape scanning, if it doesn't see a capture,
-                // or close brace.  For normal .net regexes, this will then fail later (as \k is not
+                // or close brace.  For normal .NET regexes, this will then fail later (as \k is not
                 // a legal escape), but will succeed for ecmascript regexes.
                 _lexer.Position = afterBackslashPosition;
                 return ParseCharEscape(backslashToken, allowTriviaAfterEnd);
@@ -1985,17 +1985,17 @@ private RegexControlEscapeNode ParseControlEscape(RegexToken backslashToken, boo
             {
                 // From: https://github.com/dotnet/corefx/blob/80e220fc7009de0f0611ee6b52d4d5ffd25eb6c7/src/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexParser.cs#L1450
 
-                // Note: Roslyn accepts a control escape that current .Net parser does not.
+                // Note: Roslyn accepts a control escape that current .NET parser does not.
                 // Specifically: \c[
                 //
-                // It is a bug that the .Net parser does not support this construct.  The bug was
+                // It is a bug that the .NET parser does not support this construct.  The bug was
                 // reported at: https://github.com/dotnet/corefx/issues/26501 and was fixed for
                 // CoreFx with https://github.com/dotnet/corefx/commit/80e220fc7009de0f0611ee6b52d4d5ffd25eb6c7
                 //
                 // Because it was a bug, we follow the correct behavior.  That means we will not
                 // report a diagnostic for a Regex that someone might run on a previous version of
-                // .Net that ends up throwing at runtime.  That's acceptable.  Our goal is to match
-                // the latest .Net 'correct' behavior.  Not intermediary points with bugs that have
+                // .NET that ends up throwing at runtime.  That's acceptable.  Our goal is to match
+                // the latest .NET 'correct' behavior.  Not intermediary points with bugs that have
                 // since been fixed.
 
                 // \ca interpreted as \cA

src/Workspaces/Core/Portable/Formatting/FormattingOptions.cs

@@ -73,7 +73,7 @@ private static Option<T> CreateOption<T>(OptionGroup group, string name, T defau
         /// Default value of 120 was picked based on the amount of code in a github.com diff at 1080p.
         /// That resolution is the most common value as per the last DevDiv survey as well as the latest
         /// Steam hardware survey.  This also seems to a reasonable length default in that shorter
-        /// lengths can often feel too cramped for .Net languages, which are often starting with a
+        /// lengths can often feel too cramped for .NET languages, which are often starting with a
         /// default indentation of at least 16 (for namespace, class, member, plus the final construct
         /// indentation).
         /// </summary>

src/Workspaces/Core/Portable/Shared/Extensions/SyntaxTreeExtensions_SharedWithCodeStyle.cs

@@ -18,7 +18,7 @@ public static bool OverlapsHiddenPosition(this SyntaxTree tree, TextSpan span, C
 
             return text.OverlapsHiddenPosition(span, (position, cancellationToken2) =>
                 {
-                    // implements the ASP.Net IsHidden rule
+                    // implements the ASP.NET IsHidden rule
                     var lineVisibility = tree.GetLineVisibility(position, cancellationToken2);
                     return lineVisibility == LineVisibility.Hidden || lineVisibility == LineVisibility.BeforeFirstLineDirective;
                 },

src/Workspaces/Core/Portable/Shared/Utilities/BloomFilter.cs

@@ -99,7 +99,7 @@ private static int ComputeK(int expectedCount, double falsePositiveProbability)
         /// This is needed over the normal 'string.GetHashCode()' because we need to be able to generate
         /// 'k' different well distributed hashes for any given string s.  Also, we want to be able to
         /// generate these hashes without allocating any memory.  My ideal solution would be to use an
-        /// MD5 hash.  However, there appears to be no way to do MD5 in .Net where you can:
+        /// MD5 hash.  However, there appears to be no way to do MD5 in .NET where you can:
         /// 
         /// a) feed it individual values instead of a byte[]
         /// 

src/Workspaces/Core/Portable/Utilities/TaskExtensions.cs

@@ -89,7 +89,7 @@ public static T WaitAndGetResult_CanCallOnBackground<T>(this Task<T> task, Cance
             return task.Result;
         }
 
-        // NOTE(cyrusn): Once we switch over to .Net 4.5 we can make our SafeContinueWith overloads
+        // NOTE(cyrusn): Once we switch over to .NET Framework 4.5 we can make our SafeContinueWith overloads
         // simply call into task.ContinueWith(..., TaskContinuationOptions.LazyCancellation, ...) as
         // that will have the semantics that we want.  From the TPL guys:
         //

src/Workspaces/Core/Portable/Workspace/Host/Metadata/IFrameworkAssemblyPathResolver.cs

@@ -3,10 +3,10 @@
 namespace Microsoft.CodeAnalysis.Host
 {
     /// <summary>
-    /// Provides a way to map from an assembly name to the actual path of the .Net framework 
+    /// Provides a way to map from an assembly name to the actual path of the .NET Framework 
     /// assemby with that name in the context of a specified project.  For example, if the 
-    /// assembly name is "System.Data" then a project targetting .Net 2.0 would resolve this
-    /// to a different path than a project targetting .Net 4.5.
+    /// assembly name is "System.Data" then a project targetting .NET 2.0 would resolve this
+    /// to a different path than a project targetting .NET 4.5.
     /// </summary>
     internal interface IFrameworkAssemblyPathResolver : IWorkspaceService
     {