From 55879ab28f617debcb7cacb41e38ef6ee7de94e4 Mon Sep 17 00:00:00 2001
From: "Tom Pratt (Aquent LLC)" <v-thprat@microsoft.com>
Date: Fri, 24 Mar 2017 12:13:56 -0700
Subject: [PATCH 1/2] Update language identifiers and styleguide.

---
 docs/core/deploying/index.md                  |  4 +-
 .../testing/unit-testing-with-dotnet-test.md  |  8 +--
 docs/core/testing/unit-testing-with-mstest.md |  8 +--
 .../using-on-mac-vs-full-solution.md          |  4 +-
 docs/csharp/delegate-class.md                 | 14 ++---
 docs/csharp/delegates-patterns.md             | 24 ++++-----
 docs/csharp/delegates-strongly-typed.md       |  8 +--
 docs/csharp/event-pattern.md                  | 26 ++++-----
 docs/csharp/events-overview.md                |  8 +--
 docs/csharp/expression-classes.md             |  4 +-
 docs/csharp/expression-trees-building.md      | 24 ++++-----
 docs/csharp/expression-trees-execution.md     |  8 +--
 docs/csharp/expression-trees-explained.md     |  4 +-
 docs/csharp/expression-trees-interpreting.md  | 22 ++++----
 docs/csharp/expression-trees-translating.md   | 10 ++--
 .../debugging-with-visual-studio-2017.md      |  4 +-
 .../testing-library-with-visual-studio.md     |  2 +-
 .../getting-started/with-visual-studio.md     |  2 +-
 docs/csharp/indexers.md                       | 14 ++---
 docs/csharp/iterators.md                      | 28 +++++-----
 docs/csharp/lambda-expressions.md             |  4 +-
 .../compiler-messages/cs0015.md               |  2 +-
 .../compiler-messages/cs0052.md               |  2 +-
 .../compiler-messages/cs0103.md               |  4 +-
 .../compiler-messages/cs0163.md               |  2 +-
 .../compiler-messages/cs0165.md               |  4 +-
 .../compiler-messages/cs0173.md               |  4 +-
 .../compiler-messages/cs0246.md               |  6 +--
 .../compiler-messages/cs0260.md               |  2 +-
 .../compiler-messages/cs0266.md               |  2 +-
 .../compiler-messages/cs0269.md               |  4 +-
 .../compiler-messages/cs0304.md               |  8 +--
 .../compiler-messages/cs0417.md               |  2 +-
 .../compiler-messages/cs0445.md               |  2 +-
 .../compiler-messages/cs0467.md               |  2 +-
 .../compiler-messages/cs0579.md               |  2 +-
 .../compiler-messages/cs1009.md               |  6 +--
 .../compiler-messages/cs1019.md               |  4 +-
 .../compiler-messages/cs1061.md               |  2 +-
 .../compiler-messages/cs1501.md               |  2 +-
 .../compiler-messages/cs1519.md               |  2 +-
 .../compiler-messages/cs1540.md               |  2 +-
 .../compiler-messages/cs1612.md               |  6 +--
 .../compiler-messages/cs1705.md               |  8 +--
 .../compiler-messages/cs1708.md               |  2 +-
 .../compiler-messages/cs1729.md               |  2 +-
 .../compiler-messages/cs1956.md               |  2 +-
 .../compiler-messages/cs2032.md               |  2 +-
 .../compiler-messages/cs4014.md               |  6 +--
 .../compiler-options/link-compiler-option.md  |  2 +-
 .../preferreduilang-compiler-option.md        |  2 +-
 .../language-reference/keywords/async.md      |  4 +-
 .../language-reference/keywords/await.md      |  6 +--
 .../language-reference/keywords/decimal.md    |  2 +-
 .../language-reference/keywords/dynamic.md    |  2 +-
 .../keywords/fixed-statement.md               |  2 +-
 .../language-reference/keywords/float.md      |  2 +-
 .../csharp/language-reference/keywords/for.md |  2 +-
 .../keywords/group-clause.md                  |  2 +-
 .../language-reference/keywords/if-else.md    |  4 +-
 .../csharp/language-reference/keywords/int.md |  6 +--
 .../keywords/interpolated-strings.md          |  4 +-
 docs/csharp/language-reference/keywords/is.md |  8 +--
 .../language-reference/keywords/long.md       | 12 ++---
 .../language-reference/keywords/nameof.md     | 14 ++---
 .../keywords/out-parameter-modifier.md        |  2 +-
 .../language-reference/keywords/sbyte.md      | 14 ++---
 .../language-reference/keywords/short.md      | 14 ++---
 .../language-reference/keywords/sizeof.md     |  2 +-
 .../language-reference/keywords/static.md     |  2 +-
 .../language-reference/keywords/string.md     | 16 +++---
 .../language-reference/keywords/switch.md     | 10 ++--
 .../language-reference/keywords/throw.md      |  2 +-
 .../language-reference/keywords/try-catch.md  | 14 ++---
 .../language-reference/keywords/uint.md       |  6 +--
 .../language-reference/keywords/ulong.md      |  8 +--
 .../language-reference/keywords/ushort.md     | 14 ++---
 .../keywords/using-directive.md               |  8 +--
 .../keywords/using-static.md                  |  2 +-
 .../language-reference/keywords/when.md       |  4 +-
 .../keywords/where-generic-type-constraint.md |  6 +--
 .../language-reference/keywords/yield.md      |  4 +-
 .../operators/lambda-operator.md              |  6 +--
 .../operators/null-conditional-operators.md   |  4 +-
 .../preprocessor-define.md                    |  2 +-
 .../language-reference/tokens/verbatim.md     |  2 +-
 ...ly-specify-predicate-filters-at-runtime.md |  2 +-
 .../linq/join-by-using-composite-keys.md      |  4 +-
 docs/csharp/linq/write-linq-queries.md        |  6 +--
 docs/csharp/methods.md                        | 10 ++--
 docs/csharp/misc/cs0168.md                    |  2 +-
 docs/csharp/misc/cs0415.md                    |  2 +-
 docs/csharp/misc/cs0428.md                    |  2 +-
 docs/csharp/misc/cs0542.md                    |  6 +--
 docs/csharp/misc/cs0625.md                    |  2 +-
 docs/csharp/misc/cs0626.md                    |  2 +-
 docs/csharp/misc/cs0662.md                    |  2 +-
 docs/csharp/misc/cs0664.md                    |  2 +-
 docs/csharp/misc/cs0668.md                    |  2 +-
 docs/csharp/misc/cs0669.md                    |  2 +-
 docs/csharp/misc/cs1944.md                    |  2 +-
 docs/csharp/modern-events.md                  |  4 +-
 .../classes-and-structs/anonymous-types.md    |  4 +-
 .../auto-implemented-properties.md            |  2 +-
 ...-access-a-collection-class-with-foreach.md |  4 +-
 ...-class-with-auto-implemented-properties.md |  2 +-
 .../how-to-override-the-tostring-method.md    |  2 +-
 ...g-when-to-use-override-and-new-keywords.md | 36 ++++++-------
 .../classes-and-structs/methods.md            |  4 +-
 ...static-classes-and-static-class-members.md |  2 +-
 .../assemblies-gac/friend-assemblies.md       |  2 +-
 ...d-use-assemblies-using-the-command-line.md | 14 ++---
 .../how-to-create-signed-friend-assemblies.md |  8 +--
 ...ow-to-create-unsigned-friend-assemblies.md |  8 +--
 ...mation-from-microsoft-office-assemblies.md |  2 +-
 ...rom-managed-assemblies-in-visual-studio.md | 12 ++---
 .../concepts/async/async-return-types.md      | 20 +++----
 ...cancel-an-async-task-or-a-list-of-tasks.md | 24 ++++-----
 ...ncel-async-tasks-after-a-period-of-time.md |  4 +-
 ...ining-async-tasks-after-one-is-complete.md | 14 ++---
 .../async/control-flow-in-async-programs.md   | 16 +++---
 .../handling-reentrancy-in-async-apps.md      | 26 ++++-----
 ...async-walkthrough-by-using-task-whenall.md | 24 ++++-----
 ...ts-in-parallel-by-using-async-and-await.md | 12 ++---
 .../programming-guide/concepts/async/index.md |  8 +--
 ...tasks-and-process-them-as-they-complete.md | 12 ++---
 .../async/using-async-for-file-access.md      | 10 ++--
 ...essing-the-web-by-using-async-and-await.md | 42 +++++++--------
 ...ccessing-attributes-by-using-reflection.md |  6 +--
 .../concepts/attributes/attributeusage.md     | 20 +++----
 .../concepts/attributes/common-attributes.md  | 18 +++----
 .../attributes/creating-custom-attributes.md  |  8 +--
 ...reate-a-c-cpp-union-by-using-attributes.md |  4 +-
 .../concepts/attributes/index.md              | 20 +++----
 .../concepts/caller-information.md            |  2 +-
 .../programming-guide/concepts/collections.md | 28 +++++-----
 .../creating-variant-generic-interfaces.md    | 22 ++++----
 .../covariance-contravariance/index.md        |  8 +--
 ...e-for-func-and-action-generic-delegates.md |  4 +-
 .../using-variance-in-delegates.md            |  4 +-
 ...e-in-interfaces-for-generic-collections.md |  4 +-
 .../variance-in-delegates.md                  | 22 ++++----
 .../variance-in-generic-interfaces.md         |  8 +--
 .../how-to-execute-expression-trees.md        |  2 +-
 .../how-to-modify-expression-trees.md         |  4 +-
 ...pression-trees-to-build-dynamic-queries.md |  2 +-
 .../concepts/expression-trees/index.md        | 10 ++--
 .../programming-guide/concepts/iterators.md   | 10 ++--
 ...nts-attributes-and-nodes-to-an-xml-tree.md |  2 +-
 ...name-and-xnamespace-objects-linq-to-xml.md |  4 +-
 .../concepts/linq/chaining-queries-example.md |  2 +-
 ...ining-standard-query-operators-together.md |  2 +-
 .../concepts/linq/cloning-vs-attaching.md     |  2 +-
 .../comparison-of-xpath-and-linq-to-xml.md    |  4 +-
 .../concepts/linq/converting-data-types.md    |  2 +-
 .../linq/creating-xml-trees-linq-to-xml-2.md  | 16 +++---
 .../linq/deferred-execution-example.md        |  2 +-
 ...-outputs-office-open-xml-document-parts.md |  2 +-
 .../concepts/linq/filtering-data.md           |  2 +-
 .../linq/finding-text-in-word-documents.md    |  4 +-
 .../finding-the-default-paragraph-style.md    |  2 +-
 .../functional-construction-linq-to-xml.md    |  4 +-
 .../concepts/linq/grouping-data.md            |  2 +-
 ...-to-add-custom-methods-for-linq-queries.md | 22 ++++----
 .../linq/how-to-build-linq-to-xml-examples.md |  2 +-
 .../how-to-calculate-intermediate-values.md   |  4 +-
 .../linq/how-to-catch-parsing-errors.md       |  2 +-
 ...-to-chain-axis-method-calls-linq-to-xml.md |  6 +--
 ...ge-the-namespace-for-an-entire-xml-tree.md |  2 +-
 ...ine-and-compare-string-collections-linq.md |  2 +-
 ...e-linq-queries-with-regular-expressions.md |  2 +-
 ...ompare-the-contents-of-two-folders-linq.md |  2 +-
 ...e-column-values-in-a-csv-text-file-linq.md |  2 +-
 ...-control-namespace-prefixes-linq-to-xml.md |  2 +-
 ...how-to-control-the-type-of-a-projection.md |  2 +-
 ...-occurrences-of-a-word-in-a-string-linq.md |  2 +-
 ...-a-document-with-namespaces-linq-to-xml.md | 10 ++--
 .../how-to-create-a-tree-from-an-xmlreader.md |  2 +-
 .../how-to-create-hierarchy-using-grouping.md |  2 +-
 .../how-to-debug-empty-query-results-sets.md  |  4 +-
 ...ilter-on-an-attribute-xpath-linq-to-xml.md |  2 +-
 .../how-to-filter-on-an-optional-element.md   |  4 +-
 ...-to-filter-on-element-names-linq-to-xml.md |  4 +-
 ...-find-a-child-element-xpath-linq-to-xml.md |  2 +-
 ...ist-of-child-elements-xpath-linq-to-xml.md |  2 +-
 ...descendant-using-the-descendants-method.md |  4 +-
 ...of-two-location-paths-xpath-linq-to-xml.md |  2 +-
 .../how-to-find-all-nodes-in-a-namespace.md   |  4 +-
 ...tribute-of-the-parent-xpath-linq-to-xml.md |  2 +-
 ...nd-an-element-with-a-specific-attribute.md |  4 +-
 ...n-element-with-a-specific-child-element.md |  4 +-
 ...-with-a-specific-name-xpath-linq-to-xml.md |  2 +-
 ...nts-based-on-position-xpath-linq-to-xml.md |  2 +-
 ...d-descendant-elements-xpath-linq-to-xml.md |  2 +-
 ...ts-of-a-child-element-xpath-linq-to-xml.md |  2 +-
 ...escendants-with-a-specific-element-name.md |  4 +-
 ...ements-in-a-namespace-xpath-linq-to-xml.md |  2 +-
 ...-a-specific-attribute-xpath-linq-to-xml.md |  2 +-
 ...nd-preceding-siblings-xpath-linq-to-xml.md |  2 +-
 ...find-related-elements-xpath-linq-to-xml.md |  2 +-
 ...to-find-sibling-nodes-xpath-linq-to-xml.md |  2 +-
 ...ate-preceding-sibling-xpath-linq-to-xml.md |  2 +-
 ...find-the-root-element-xpath-linq-to-xml.md |  2 +-
 ...e-set-difference-between-two-lists-linq.md |  2 +-
 .../how-to-generate-text-files-from-xml.md    |  2 +-
 .../how-to-generate-xml-from-csv-files.md     |  2 +-
 .../how-to-group-files-by-extension-linq.md   |  2 +-
 ...join-content-from-dissimilar-files-linq.md |  2 +-
 ...how-to-join-two-collections-linq-to-xml.md |  2 +-
 .../linq/how-to-list-all-nodes-in-a-tree.md   |  2 +-
 .../linq/how-to-load-xml-from-a-file.md       |  2 +-
 ...w-to-modify-an-office-open-xml-document.md |  2 +-
 .../concepts/linq/how-to-parse-a-string.md    |  2 +-
 ...eaming-transform-of-large-xml-documents.md |  4 +-
 ...treaming-transformations-of-text-to-xml.md |  2 +-
 ...pulate-an-xml-tree-from-the-file-system.md |  2 +-
 ...-xml-tree-with-an-xmlwriter-linq-to-xml.md |  2 +-
 ...-collections-from-multiple-sources-linq.md |  4 +-
 .../how-to-project-a-new-type-linq-to-xml.md  |  2 +-
 .../linq/how-to-project-an-anonymous-type.md  |  2 +-
 .../linq/how-to-project-an-object-graph.md    |  2 +-
 .../how-to-query-an-arraylist-with-linq.md    |  2 +-
 ...ssembly-s-metadata-with-reflection-linq.md |  2 +-
 ...o-query-for-characters-in-a-string-linq.md |  2 +-
 ...uplicate-files-in-a-directory-tree-linq.md |  2 +-
 ...iles-with-a-specified-attribute-or-name.md |  2 +-
 ...t-contain-a-specified-set-of-words-linq.md |  2 +-
 ...-file-or-files-in-a-directory-tree-linq.md |  2 +-
 ...umber-of-bytes-in-a-set-of-folders-linq.md |  2 +-
 .../how-to-query-linq-to-xml-using-xpath.md   |  2 +-
 ...y-the-contents-of-files-in-a-folder-lin.md |  2 +-
 ...w-to-read-and-write-an-encoded-document.md |  2 +-
 ...der-the-fields-of-a-delimited-file-linq.md |  2 +-
 ...-a-collection-of-attributes-linq-to-xml.md |  2 +-
 ...ve-a-collection-of-elements-linq-to-xml.md |  2 +-
 ...retrieve-a-single-attribute-linq-to-xml.md |  6 +--
 ...ieve-a-single-child-element-linq-to-xml.md |  4 +-
 ...graphs-from-an-office-open-xml-document.md |  2 +-
 ...etrieve-the-shallow-value-of-an-element.md |  2 +-
 ...e-the-value-of-an-attribute-linq-to-xml.md |  4 +-
 ...eve-the-value-of-an-element-linq-to-xml.md |  8 +--
 ...-serialize-using-datacontractserializer.md |  2 +-
 .../how-to-serialize-using-xmlserializer.md   |  2 +-
 .../how-to-sort-elements-on-multiple-keys.md  |  4 +-
 .../concepts/linq/how-to-sort-elements.md     |  4 +-
 ...ter-text-data-by-any-word-or-field-linq.md |  2 +-
 ...le-into-many-files-by-using-groups-linq.md |  2 +-
 ...-stream-xml-fragments-from-an-xmlreader.md |  2 +-
 ...ments-with-access-to-header-information.md |  2 +-
 ...w-to-transform-the-shape-of-an-xml-tree.md |  4 +-
 ...form-linq-to-xml-trees-in-an-xslt-style.md |  8 +--
 .../how-to-validate-using-xsd-linq-to-xml.md  |  4 +-
 ...ork-with-dictionaries-using-linq-to-xml.md |  4 +-
 .../how-to-write-a-linq-to-xml-axis-method.md |  2 +-
 ...ry-that-finds-elements-based-on-context.md |  4 +-
 ...w-to-write-queries-on-xml-in-namespaces.md |  4 +-
 ...to-write-queries-with-complex-filtering.md |  4 +-
 ...-vs-functional-construction-linq-to-xml.md |  4 +-
 .../linq/intermediate-materialization.md      |  2 +-
 .../linq/introduction-to-linq-queries.md      |  2 +-
 .../concepts/linq/linq-to-xml-events.md       |  2 +-
 .../concepts/linq/linq-to-xml-overview.md     |  6 +--
 .../concepts/linq/linq-to-xml-vs-dom.md       |  6 +--
 .../linq/maintaining-name-value-pairs.md      |  4 +-
 ...e-code-imperative-code-bugs-linq-to-xml.md | 14 ++---
 ...formance-of-chained-queries-linq-to-xml.md |  2 +-
 ...tomization-of-xname-objects-linq-to-xml.md |  8 +--
 .../concepts/linq/programming-with-nodes.md   | 14 ++---
 .../projecting-xml-in-a-different-shape.md    |  2 +-
 .../concepts/linq/projection-operations.md    |  6 +--
 ...ng-an-xdocument-vs-querying-an-xelement.md |  6 +--
 .../linq/refactoring-into-pure-functions.md   |  6 +--
 .../linq/refactoring-using-a-pure-function.md |  2 +-
 .../refactoring-using-an-extension-method.md  |  6 +--
 ...s-attributes-and-nodes-from-an-xml-tree.md |  2 +-
 ...rieving-the-paragraphs-and-their-styles.md |  6 +--
 .../retrieving-the-text-of-the-paragraphs.md  |  2 +-
 .../linq/scope-of-default-namespaces.md       |  4 +-
 ...rializing-to-an-xmlreader-invoking-xslt.md |  2 +-
 .../serializing-with-an-xml-declaration.md    |  4 +-
 .../shape-of-wordprocessingml-documents.md    |  2 +-
 .../concepts/linq/sorting-data.md             |  8 +--
 .../linq/standard-query-operators-overview.md |  2 +-
 ...statically-compiled-queries-linq-to-xml.md |  8 +--
 .../using-xslt-to-transform-an-xml-tree.md    |  2 +-
 .../linq/xattribute-class-overview.md         |  4 +-
 .../concepts/linq/xdocument-class-overview.md |  2 +-
 .../concepts/linq/xelement-class-overview.md  |  4 +-
 .../concepts/object-oriented-programming.md   | 50 ++++++++---------
 .../programming-guide/concepts/reflection.md  |  4 +-
 ...ow-to-read-object-data-from-an-xml-file.md |  2 +-
 ...how-to-write-object-data-to-an-xml-file.md |  2 +-
 ...h-persisting-an-object-in-visual-studio.md | 18 +++----
 .../threading/how-to-use-a-thread-pool.md     |  2 +-
 .../threading/multithreaded-applications.md   |  6 +--
 ...urn-values-for-multithreaded-procedures.md |  8 +--
 .../concepts/threading/thread-pooling.md      |  2 +-
 .../threading/thread-synchronization.md       |  8 +--
 .../concepts/threading/thread-timers.md       |  2 +-
 ...ing-with-the-backgroundworker-component.md | 10 ++--
 .../programming-guide/enumeration-types.md    |  2 +-
 ...hat-conform-to-net-framework-guidelines.md | 12 ++---
 .../how-to-create-a-file-or-folder.md         |  4 +-
 ...ormation-about-files-folders-and-drives.md |  2 +-
 ...how-to-iterate-through-a-directory-tree.md |  2 +-
 .../nullable-types/boxing-nullable-types.md   | 10 ++--
 .../how-to-safely-cast-from-bool-to-bool.md   |  2 +-
 .../equality-comparisons.md                   |  2 +-
 .../lambda-expressions.md                     | 30 +++++------
 .../operators.md                              |  2 +-
 .../overloadable-operators.md                 |  4 +-
 .../how-to-convert-a-string-to-a-datetime.md  |  2 +-
 ...how-to-parse-strings-using-string-split.md |  2 +-
 .../types/casting-and-type-conversions.md     |  4 +-
 docs/csharp/programming-guide/types/index.md  | 10 ++--
 docs/csharp/properties.md                     | 22 ++++----
 docs/csharp/tutorials/console-teleprompter.md | 38 ++++++-------
 docs/csharp/tutorials/console-webapiclient.md | 54 +++++++++----------
 docs/csharp/tutorials/inheritance.md          |  8 +--
 docs/csharp/tutorials/microservices.md        |  4 +-
 docs/csharp/tutorials/string-interpolation.md |  4 +-
 docs/csharp/tutorials/working-with-linq.md    | 38 ++++++-------
 .../async.md                                  | 10 ++--
 docs/standard/delegates-lambdas.md            | 10 ++--
 .../garbagecollection/implementing-dispose.md | 16 +++---
 .../garbagecollection/using-objects.md        |  8 +--
 docs/standard/generics.md                     |  2 +-
 docs/standard/native-interop.md               | 18 +++----
 docs/standard/using-linq.md                   | 28 +++++-----
 ...ith-the-lineshape-control-visual-studio.md |  2 +-
 ...e-ovalshape-and-rectangleshape-controls.md |  2 +-
 ...le-tabbing-between-shapes-visual-studio.md |  2 +-
 ...-the-datarepeater-control-visual-studio.md |  2 +-
 samples/README.md                             |  2 +-
 styleguide/template.md                        | 30 ++++++++++-
 335 files changed, 1058 insertions(+), 1032 deletions(-)

diff --git a/docs/core/deploying/index.md b/docs/core/deploying/index.md
index a77890dcb1e10..5b51a3d67cc74 100644
--- a/docs/core/deploying/index.md
+++ b/docs/core/deploying/index.md
@@ -47,7 +47,7 @@ Deploying a framework-dependent deployment with no third-party dependencies simp
 
 2. Open the `Program.cs` file in an editor, and replace the auto-generated code with the following code. It prompts the user to enter text, and then displays the individual words entered by the user. It uses the regular expression `\w+` to separate the words in the input text.
 
-    ```cs
+    ```csharp
     using System;
     using System.Text.RegularExpressions;
 
@@ -142,7 +142,7 @@ Deploying a self-contained deployment with no third-party dependencies involves
 
 2. Open the `Program.cs` file in an editor, and replace the auto-generated code with the following code. It prompts the user to enter text, and then displays the individual words entered by the user. It uses the regular expression `\w+` to separate the words in the input text.
 
-    ```cs
+    ```csharp
     using System;
     using System.Text.RegularExpressions;
 
diff --git a/docs/core/testing/unit-testing-with-dotnet-test.md b/docs/core/testing/unit-testing-with-dotnet-test.md
index 27984d557df4b..0e79f2b629425 100644
--- a/docs/core/testing/unit-testing-with-dotnet-test.md
+++ b/docs/core/testing/unit-testing-with-dotnet-test.md
@@ -26,7 +26,7 @@ Open a shell window. Create a directory called *unit-testing-using-dotnet-test*
 
 Make *PrimeService* the current directory and run [`dotnet new classlib`](../tools/dotnet-new.md) to create the source project. Rename *Class1.cs* to *PrimeService.cs*. To use test-driven development (TDD), you'll create a failing implementation of the `PrimeService` class:
 
-```cs
+```csharp
 using System;
 
 namespace Prime.Services
@@ -97,7 +97,7 @@ Before building the library or the tests, execute [`dotnet restore`](../tools/do
 
 The TDD approach calls for writing one failing test, making it pass, then repeating the process. Remove *UnitTest1.cs* from the *PrimeService.Tests* directory and create a new C# file named *PrimeService_IsPrimeShould.cs* with the following content:
 
-```cs
+```csharp
 using Xunit;
 using Prime.Services;
 
@@ -128,7 +128,7 @@ The `[Fact]` attribute denotes a method as a single test. Execute [`dotnet test`
 
 Your test fails. You haven't created the implementation yet. Write the simplest code in the `PrimeService` class to make this test pass:
 
-```cs
+```csharp
 public bool IsPrime(int candidate) 
 {
     if (candidate == 1) 
@@ -151,7 +151,7 @@ Instead of creating new tests, leverage these two attributes to create a single
 
 Run `dotnet test`, and two of these tests fail. To make all of the tests pass, change the `if` clause at the beginning of the method:
 
-```cs
+```csharp
 if (candidate < 2)
 ```
 
diff --git a/docs/core/testing/unit-testing-with-mstest.md b/docs/core/testing/unit-testing-with-mstest.md
index 288e6a9a8d199..16bfb2d9cb1b5 100644
--- a/docs/core/testing/unit-testing-with-mstest.md
+++ b/docs/core/testing/unit-testing-with-mstest.md
@@ -26,7 +26,7 @@ Open a shell window. Create a directory called *unit-testing-using-dotnet-test*
 
 Make *PrimeService* the current directory and run [`dotnet new classlib`](../tools/dotnet-new.md) to create the source project. Rename *Class1.cs* to *PrimeService.cs*. To use test-driven development (TDD), you'll create a failing implementation of the `PrimeService` class:
 
-```cs
+```csharp
 using System;
 
 namespace Prime.Services
@@ -97,7 +97,7 @@ Before building the library or the tests, execute [`dotnet restore`](../tools/do
 
 The TDD approach calls for writing one failing test, making it pass, then repeating the process. Remove *UnitTest1.cs* from the *PrimeService.Tests* directory and create a new C# file named *PrimeService_IsPrimeShould.cs* with the following content:
 
-```cs
+```csharp
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using Prime.Services;
 
@@ -130,7 +130,7 @@ Save this file and execute [`dotnet test`](../tools/dotnet-test.md) to build the
 
 Your test fails. You haven't created the implementation yet. Write the simplest code in the `PrimeService` class to make this test pass:
 
-```cs
+```csharp
 public bool IsPrime(int candidate) 
 {
     if (candidate == 1) 
@@ -153,7 +153,7 @@ Instead of creating new tests, leverage these two attributes to create a single
 
 Run `dotnet test`, and two of these tests fail. To make all of the tests pass, change the `if` clause at the beginning of the method:
 
-```cs
+```csharp
 if (candidate < 2)
 ```
 
diff --git a/docs/core/tutorials/using-on-mac-vs-full-solution.md b/docs/core/tutorials/using-on-mac-vs-full-solution.md
index df443b54b9a17..4e1cbd41cd0cb 100644
--- a/docs/core/tutorials/using-on-mac-vs-full-solution.md
+++ b/docs/core/tutorials/using-on-mac-vs-full-solution.md
@@ -88,7 +88,7 @@ Unit tests provide automated software testing during your development and publis
 
 1. Open the file and replace the code with the following:
 
-   ```cs
+   ```csharp
    using Xunit;
    using TextUtils;
    using System.Diagnostics;
@@ -128,7 +128,7 @@ Unit tests provide automated software testing during your development and publis
 
 1. Testing individual return values with a `Fact` is only the beginning of what you can do with unit testing. Another powerful technique allows you to test several values at once using a `Theory`. Add the following method to your `TextUtils_GetWordCountShould` class. You have two methods in the class after you add this method:
 
-   ```cs
+   ```csharp
    [Theory]
    [InlineData(0, "Ting", "Does not appear in the string.")]
    [InlineData(1, "Ting", "Ting appears once.")]
diff --git a/docs/csharp/delegate-class.md b/docs/csharp/delegate-class.md
index 15752ee476da9..9eaf89adc560d 100644
--- a/docs/csharp/delegate-class.md
+++ b/docs/csharp/delegate-class.md
@@ -35,7 +35,7 @@ definition.
 Let's continue to use the List.Sort() method as our example. The first
 step is to create a type for the comparison delegate:
 
-```cs
+```csharp
 // From the .NET Core library
 
 // Define the delegate type:
@@ -69,7 +69,7 @@ After defining the delegate, you can create an instance of that type.
 Like all variables in C#, you cannot declare delegate instances directly
 in a namespace, or in the global namespace.
 
-```cs
+```csharp
 // inside a class definition:
 
 // Declare an instance of that type:
@@ -88,7 +88,7 @@ You invoke the methods that are in the invocation list of a delegate by calling
 that delegate. Inside the `Sort()` method, the code will call the
 comparison method to determine which order to place objects:
 
-```cs
+```csharp
 int result = comparator(left, right);
 ```
 
@@ -115,7 +115,7 @@ adds the method to the invocation list of that delegate object.
 Suppose you wanted to sort a list of strings by their length. Your
 comparison function might be the following:
 
-```cs
+```csharp
 private static int CompareLength(string left, string right)
 {
     return left.Length.CompareTo(right.Length);
@@ -131,7 +131,7 @@ the delegate object, and can access it through that delegate.
 You create that relationship by passing that method to the
 `List.Sort()` method:
 
-```cs
+```csharp
 phrases.Sort(CompareLength);
 ```
 
@@ -143,7 +143,7 @@ an invocation target.
 You could also have been explicit by declaring a variable of type
 'Comparison<string>` and doing an assignment:
 
-```cs
+```csharp
 Comparison<string> comparer = CompareLength;
 phrases.Sort(comparer);
 ```
@@ -152,7 +152,7 @@ In uses where the method being used as a delegate target is a small method,
 it's common to use [Lambda Expression](lambda-expressions.md) syntax
 to perform the assignment:
 
-```cs
+```csharp
 Comparison<string> comparer = (left, right) => left.Length.CompareTo(right.Length);
 phrases.Sort(comparer);
 ```
diff --git a/docs/csharp/delegates-patterns.md b/docs/csharp/delegates-patterns.md
index a3caf7efd4b9d..340ba2f03697c 100644
--- a/docs/csharp/delegates-patterns.md
+++ b/docs/csharp/delegates-patterns.md
@@ -23,7 +23,7 @@ One excellent example for this kind of design is LINQ. The LINQ
 Query Expression Pattern relies on delegates for all of its
 features. Consider this simple example:
 
-```cs
+```csharp
 var smallNumbers = numbers.Where(n => n < 10);
 ```
 
@@ -34,7 +34,7 @@ implementation of the delegate for this specific purpose.
 
 The prototype for the Where method is:
 
-```cs
+```csharp
 public static IEnumerable<TSource> Where<in TSource> (IEnumerable<TSource> source, Func<TSource, bool> predicate);
 ```
 
@@ -85,7 +85,7 @@ Let's start small: the initial implementation will accept new messages,
 and write them using any attached delegate. You can start with one delegate
 that writes messages to the console.
 
-```cs
+```csharp
 public static class Logger
 {
     public static Action<string> WriteMessage;
@@ -101,7 +101,7 @@ The static class above is the simplest thing that can work. We need to
 write the single implementation for the method that writes messages
 to the console: 
 
-```cs
+```csharp
 public static void LogToConsole(string message)
 {
     Console.Error.WriteLine(message);
@@ -111,7 +111,7 @@ public static void LogToConsole(string message)
 Finally, you need to hook up the delegate by attaching it to
 the WriteMessage delegate declared in the logger:
 
-```cs
+```csharp
 Logger.WriteMessage += LogToConsole;
 ```
 
@@ -137,7 +137,7 @@ creating other logging mechanisms.
 Next, let's add a few arguments to the `LogMessage()` method so that
 your log class creates more structured messages:
 
-```cs
+```csharp
 // Logger implementation two
 public enum Severity
 {
@@ -164,7 +164,7 @@ public static class Logger
 Next, let's make use of that `Severity` argument to filter the messages
 that are sent to the log's output. 
 
-```cs
+```csharp
 public static class Logger
 {
     public static Action<string> WriteMessage;
@@ -205,7 +205,7 @@ each message is generated.
 
 Here is that file based logger:
 
-```cs
+```csharp
 public class FileLogger
 {
     private readonly string logPath;
@@ -238,14 +238,14 @@ public class FileLogger
 Once you've created this class, you can instantiate it and it attaches
 its LogMessage method to the Logger component:
 
-```cs
+```csharp
 var file = new FileLogger("log.txt");
 ```
 
 These two are not mutually exclusive. You could attach both log
 methods and generate messages to the console and a file:
 
-```cs
+```csharp
 var fileOutput = new FileLogger("log.txt");
 Logger.WriteMessage += LogToConsole;
 ```
@@ -253,7 +253,7 @@ Logger.WriteMessage += LogToConsole;
 Later, even in the same application, you can remove one of the
 delegates without any other issues to the system:
 
-```cs
+```csharp
 Logger.WriteMessage -= LogToConsole;
 ```
 
@@ -295,7 +295,7 @@ You may prefer a design that silently continues when no methods
 have been attached. This is easy using the null conditional operator,
 combined with the `Delegate.Invoke()` method:
 
-```cs
+```csharp
 public static void LogMessage(string msg)
 {
     WriteMessage?.Invoke(msg);
diff --git a/docs/csharp/delegates-strongly-typed.md b/docs/csharp/delegates-strongly-typed.md
index 4968af31b3811..bb66cded2bb8b 100644
--- a/docs/csharp/delegates-strongly-typed.md
+++ b/docs/csharp/delegates-strongly-typed.md
@@ -36,7 +36,7 @@ when you need new method declarations.
 
 The first of these types is the @System.Action type, and several variations:
 
-```cs
+```csharp
 public delegate void Action();
 public delegate void Action<in T>(T arg);
 public delegate void Action<in T1, in T2>(T1 arg1, T2 arg2);
@@ -56,7 +56,7 @@ Use one of the `Action` types for any delegate type that has a void return type.
 The framework also includes several generic delegate types that you can use for
 delegate types that return values:
 
-```cs
+```csharp
 public delegate TResult Func<out TResult>();
 public delegate TResult Func<in T1, out TResult>(T1 arg);
 public delegate TResult Func<in T1, in T2, out TResult>(T1 arg1, T2 arg2);
@@ -77,14 +77,14 @@ There's also a specialized
 @System.Predicate%601 
 type for a delegate that returns a test on a single value:
 
-```cs
+```csharp
 public delegate bool Predicate<in T>(T obj);
 ```
 
 You may notice that for any `Predicate` type, a structurally equivalent `Func`
 type exists For example:
 
-```cs
+```csharp
 Func<string, bool> TestForString;
 Predicate<string> AnotherTestForString;
 ```
diff --git a/docs/csharp/event-pattern.md b/docs/csharp/event-pattern.md
index aeeb398d5ae05..464c9a9ef5678 100644
--- a/docs/csharp/event-pattern.md
+++ b/docs/csharp/event-pattern.md
@@ -28,7 +28,7 @@ subscribe and process standard events in your code.
 
 The standard signature for a .NET event delegate is:
 
-```cs
+```csharp
 void OnEventRaised(object sender, EventArgs args);
 ```
 
@@ -65,7 +65,7 @@ robust algorithms.
 Here is the initial event argument declaration for finding a sought
 file: 
 
-```cs
+```csharp
 public class FileFoundArgs : EventArgs
 {
     public string FoundFile { get; }
@@ -94,7 +94,7 @@ specialization.
 Let's fill out the FileSearcher class to search for files that match
 a pattern, and raise the correct event when a match is discovered.
 
-```cs
+```csharp
 public class FileSearcher
 {
     public event EventHandler<FileFoundArgs> FileFound;
@@ -114,7 +114,7 @@ public class FileSearcher
 The simplest way to add an event to your class is to declare that
 event as a public field, as in the above example:
 
-```cs
+```csharp
 public event EventHandler<FileFoundArgs> FileFound;
 ```
 
@@ -125,7 +125,7 @@ practice, the code generated by the compiler does create wrappers so
 that the event objects can only be accessed in safe ways. The only
 operations available on a field-like event are add handler:
 
-```cs
+```csharp
 EventHandler<FileFoundArgs> onFileFound = (sender, eventArgs) =>
     Console.WriteLine(eventArgs.FoundFile);
 lister.FileFound += onFIleFound;
@@ -133,7 +133,7 @@ lister.FileFound += onFIleFound;
 
 and remove handler:
 
-```cs
+```csharp
 lister.FileFound -= onFileFound;
 ```
 
@@ -180,7 +180,7 @@ indicate a cancel incorrectly.
 Let's implement the first version for this sample. You need to add a
 boolean field to the FileFoundEventArgs type:
 
-```cs
+```csharp
 public class FileFoundArgs : EventArgs
 {
     public string FoundFile { get; }
@@ -199,7 +199,7 @@ happens automatically. The only other change to the component is to
 check the flag after raising the event to see if any of the
 subscribers have requested a cancellation:
 
-```cs
+```csharp
 public void List(string directory, string searchPattern)
 {
     foreach (var file in Directory.EnumerateFiles(directory, searchPattern))
@@ -220,7 +220,7 @@ support the new cancel protocol. It's very loosely coupled.
 Let's update the subscriber so that it requests a cancellation once
 it finds the first executable:
 
-```cs
+```csharp
 EventHandler<FileFoundArgs> onFileFound = (sender, eventArgs) =>
 {
     Console.WriteLine(eventArgs.FoundFile);
@@ -244,7 +244,7 @@ can also make the types used for the arguments internal as well.
 You'll start by creating the new EventArgs derived class for
 reporting the new directory and progress. 
 
-```cs
+```csharp
 internal class SearchDirectoryArgs : EventArgs
 {
     internal string CurrentSearchDirectory { get; }
@@ -269,7 +269,7 @@ property, with add and remove handlers. In this sample, you won't
 need extra code in those handlers in this project, but this shows how
 you would create them.
 
-```cs
+```csharp
 internal event EventHandler<SearchDirectoryArgs> DirectoryChanged
 {
     add { directoryChanged += value; }
@@ -292,7 +292,7 @@ subdirectories and raises both events. The easiest way to accomplish
 this is to use a default argument to specify that you want to search
 all directories:
 
-```cs
+```csharp
 public void Search(string directory, string searchPattern, bool searchSubDirs = false)
 {
     if (searchSubDirs)
@@ -338,7 +338,7 @@ that this works correctly.
  Let's add a handler to write a line that shows the progress in the
  console window. 
 
-```cs
+```csharp
 lister.DirectoryChanged += (sender, eventArgs) =>
 {
     Console.Write($"Entering '{eventArgs.CurrentSearchDirectory}'.");
diff --git a/docs/csharp/events-overview.md b/docs/csharp/events-overview.md
index 5537f4f3ecc61..85c211e6b25e3 100644
--- a/docs/csharp/events-overview.md
+++ b/docs/csharp/events-overview.md
@@ -64,7 +64,7 @@ an extension of the syntax for delegates.
 
 To define an event you use the `event` keyword:
 
-```cs
+```csharp
 public event EventHandler<FileListArgs> Progress;
 ```
 
@@ -87,7 +87,7 @@ argument.
 When you want to raise the event, you call the event handlers using the delegate invocation
 syntax:
 
-```cs
+```csharp
 Progress?.Invoke(this, new FileListArgs(file));
 ```
 
@@ -97,7 +97,7 @@ when there are no subscribers to that event.
  
 You subscribe to an event by using the `+=` operator:
 
-```cs
+```csharp
 EventHandler<FileListArgs> onProgress = (sender, eventArgs) => 
     Console.WriteLine(eventArgs.FoundFile);
 lister.Progress += OnProgress;
@@ -108,7 +108,7 @@ by the event name, as shown above.
 
 You unsubscribe using the `-=` operator:
 
-```cs
+```csharp
 lister.Progress -= onProgress;
 ```
 
diff --git a/docs/csharp/expression-classes.md b/docs/csharp/expression-classes.md
index 77f33cd4210ec..1bb10f340add1 100644
--- a/docs/csharp/expression-classes.md
+++ b/docs/csharp/expression-classes.md
@@ -46,7 +46,7 @@ expression. I've followed the practice of checking the node type, then
 casting to a variable access expression and then checking the properties of
 the specific expression type:
 
-```cs
+```csharp
 Expression<Func<int, int>> addFive = (num) => num + 5;
 
 if (addFive.NodeType == ExpressionType.Lambda)
@@ -66,7 +66,7 @@ The `System.Linq.Expression` class also contains many static methods to create e
 methods create an expression node using the arguments supplied for its children. In this way,
 you build an expression up from its leaf nodes. For example, this code builds an Add expression:
 
-```cs
+```csharp
 // Addition is an add expression for "1 + 2"
 var one = Expression.Constant(1, typeof(int));
 var two = Expression.Constant(2, typeof(int));
diff --git a/docs/csharp/expression-trees-building.md b/docs/csharp/expression-trees-building.md
index bbcac783de615..16bfb46320ce7 100644
--- a/docs/csharp/expression-trees-building.md
+++ b/docs/csharp/expression-trees-building.md
@@ -35,7 +35,7 @@ a few examples to show you the techniques.
 Let's start relatively simply again. We'll use the addition
 expression I've been working with throughout these sections:
 
-```cs
+```csharp
 Expression<Func<int>> sum = () => 1 + 2;
 ```
 
@@ -43,21 +43,21 @@ To construct that expression tree, you must construct the leaf nodes.
 The leaf nodes are constants, so you can use the `Expression.Constant`
 method to create the nodes:
 
-```cs
+```csharp
 var one = Expression.Constant(1, typeof(int));
 var two = Expression.Constant(2, typeof(int));
 ```
 
 Next, you'll build the addition expression:
 
-```cs
+```csharp
 var addition = Expression.Add(one, two);
 ```
 
 Once you've got the addition expression, you can create the lambda
 expression:
 
-```cs
+```csharp
 var lamdba = Expression.Lambda(addition);
 ```
 
@@ -68,7 +68,7 @@ and build more complicated expressions.
 For expressions that are as simple as this one, you may combine all the
 calls into a single statement:
 
-```cs
+```csharp
 var lambda = Expression.Lambda(
     Expression.Add(
         Expression.Constant(1, typeof(int)),
@@ -87,14 +87,14 @@ the argument nodes, and method call nodes.
 
 Let's build an expression tree to create this expression:
 
-```cs
+```csharp
 Expression<Func<double, double, double>> distanceCalc =
     (x, y) => Math.Sqrt(x * x + y * y);
 ```
  
 You'll start by creating parameter expressions for `x` and `y`:
 
-```cs
+```csharp
 var xParameter = Expression.Parameter(typeof(double), "x");
 var yParameter = Expression.Parameter(typeof(double), "y");
 ```
@@ -102,7 +102,7 @@ var yParameter = Expression.Parameter(typeof(double), "y");
 Creating the multiplication and addition expressions follows the pattern
 you've already seen:
 
-```cs
+```csharp
 var xSquared = Expression.Multiply(xParameter, xParameter);
 var ySquared = Expression.Multiply(yParameter, yParameter);
 var sum = Expression.Add(xSquared, ySquared);
@@ -111,7 +111,7 @@ var sum = Expression.Add(xSquared, ySquared);
 Next, you need to create a method call expression for the call to
 `Math.Sqrt`.
 
-```cs
+```csharp
 var sqrtMethod = typeof(Math).GetMethod("Sqrt", new[] { typeof(double) });
 var distance = Expression.Call(sqrtMethod, sum);
 ```
@@ -119,7 +119,7 @@ var distance = Expression.Call(sqrtMethod, sum);
 And  then finally, you put the method call into a lambda expression,
 and make sure to define the arguments to the lambda expression:
 
-```cs
+```csharp
 var distanceLambda = Expression.Lambda(
     distance,
     xParameter,
@@ -146,7 +146,7 @@ the code is to manage and to read.
 
 Let's build an expression tree that is the equivalent of this code:
 
-```cs
+```csharp
 Func<int, int> factorialFunc = (n) =>
 {
     var res = 1;
@@ -165,7 +165,7 @@ to build the same functionality. It's complicated by the fact that there isn't a
 a `while` loop, instead you need to build a loop that contains a conditional test, and a label
 target to break out of the loop. 
 
-```cs
+```csharp
 var nArgument = Expression.Parameter(typeof(int), "n");
 var result = Expression.Variable(typeof(int), "result");
 
diff --git a/docs/csharp/expression-trees-execution.md b/docs/csharp/expression-trees-execution.md
index 89b13c1bbeb06..eb89f36cf30ee 100644
--- a/docs/csharp/expression-trees-execution.md
+++ b/docs/csharp/expression-trees-execution.md
@@ -61,7 +61,7 @@ generated delegate.
 You would convert an expression into a delegate using the following
 code:
 
-```cs
+```csharp
 Expression<Func<int>> add = () => 1 + 2;
 var func = add.Compile(); // Create Delegate
 var answer = func(); // Invoke Delegate
@@ -119,7 +119,7 @@ is still held by the expression tree.
 For example, this code works fine, because `int` does not implement
 `IDisposable`:
 
-```cs
+```csharp
 private static Func<int, int> CreateBoundFunc()
 {
     var constant = 5; // constant is captured by the expression tree
@@ -136,7 +136,7 @@ by `CreateBoundFunc` executes.
 However, consider this (rather contrived) class that implements
 `IDisposable`:
 
-```cs
+```csharp
 public class Resource : IDisposable
 {
     private bool isDisposed = false;
@@ -161,7 +161,7 @@ If you use it in an expression as shown below, you'll get an
 `ObjectDisposedException` when you execute the code referenced
 by the `Resource.Argument` property:
 
-```cs
+```csharp
 private static Func<int, int> CreateBoundResource()
 {
     using (var constant = new Resource()) // constant is captured by the expression tree
diff --git a/docs/csharp/expression-trees-explained.md b/docs/csharp/expression-trees-explained.md
index 268acd523cc9c..d755d98117a9e 100644
--- a/docs/csharp/expression-trees-explained.md
+++ b/docs/csharp/expression-trees-explained.md
@@ -28,7 +28,7 @@ Trees are based on a totally different set of classes and APIs than the Roslyn A
     
 Let's look at a simple example.
 Here's a line of code:
-```cs
+```csharp
 var sum = 1 + 2;
 ```
 If you were to analyze this as an expression tree, the tree contains several nodes.
@@ -58,7 +58,7 @@ each node in the tree to see the code that makes up the statement:
 
 This may look complicated, but it is very powerful. Following the same process, you can decompose
 much more complicated expressions. Consider this expression:
-```cs
+```csharp
 var finalAnswer = this.SecretSauceFuncion(
     currentState.createInterimResult(), currentState.createSecondValue(1, 2),
     decisionServer.considerFinalOptions("hello")) +
diff --git a/docs/csharp/expression-trees-interpreting.md b/docs/csharp/expression-trees-interpreting.md
index a7ef1f8705a52..8037f369aafe8 100644
--- a/docs/csharp/expression-trees-interpreting.md
+++ b/docs/csharp/expression-trees-interpreting.md
@@ -33,7 +33,7 @@ Let's start by visiting each node in a very simple expression tree.
 Here's the code that creates a constant expression and then
 examines its properties:
 
-```cs
+```csharp
 var constant = Expression.Constant(24, typeof(int));
 
 Console.WriteLine($"This is a/an {constant.NodeType} expression type");
@@ -57,7 +57,7 @@ out some important properties about it. Here's that code:
 Let's start with the addition sample from the
 introduction to this section.
 
-```cs
+```csharp
 Expression<Func<int>> sum = () => 1 + 2;
 ```
 
@@ -74,7 +74,7 @@ type of the `LambdaExpression`.
 To examine each node in this expression, we'll need to recursively
 visit a number of nodes. Here's a simple first implementation:
 
-```cs
+```csharp
 Expression<Func<int, int, int>> addition = (a, b) => a + b;
 
 Console.WriteLine($"This expression is a {addition.NodeType} expression type");
@@ -120,7 +120,7 @@ Any node that has children requires us to visit those children
 and determine what that node is. Here's the cleaned up version
 that utilizes recursion to visit the addition operations:
 
-```cs
+```csharp
 // Base Visitor class:
 public abstract class Visitor
 {
@@ -258,7 +258,7 @@ can visit and process many more different types of expressions.
 Let's try a more complicated example,
 yet still limit the node types to addition only:
 
-```cs
+```csharp
 Expression<Func<int>> sum = () => 1 + 2 + 3 + 4;
 ```
 
@@ -269,7 +269,7 @@ children, representing the left and right operands. There
 are several possible ways to construct a tree that 
 could be correct:
 
-```cs
+```csharp
 Expression<Func<int>> sum1 = () => 1 + (2 + (3 + 4));
 Expression<Func<int>> sum2 = () => ((1 + 2) + 3) + 4;
 
@@ -295,7 +295,7 @@ value of `10`. The compiler performs all the addition and reduces the
 expression to its simplest form. Simply adding one variable in the expression
 is sufficient to see the original tree:
 
-```cs
+```csharp
 Expression<Func<int, int>> sum = (a) => 1 + a + 3 + 4;
 ```
 
@@ -336,7 +336,7 @@ and see what tree it represents. Here's an example of the `sum3`
 expression above (with an additional parameter to prevent the compiler from
 computing the constant):
 
-```cs
+```csharp
 Expression<Func<int, int, int>> sum3 = (a, b) => (1 + a) + (3 + b);
 ```
 
@@ -385,7 +385,7 @@ you've seen in this section only handles constant integers and the binary
 `+` operator. As a final sample, let's update the visitor to handle a more
 complicated expression. Let's make it work for this:
 
-```cs
+```csharp
 Expression<Func<int, int>> factorial = (n) =>
     n == 0 ? 
     1 : 
@@ -414,7 +414,7 @@ the node type every time you reach your `default` clause. After a few
 iterations, you'll have seen each of the potential nodes. Then, you have
 all you need. The result would be something like this:
 
-```cs
+```csharp
 public static Visitor CreateFromExpression(Expression node)
 {
     switch(node.NodeType)
@@ -442,7 +442,7 @@ public static Visitor CreateFromExpression(Expression node)
 
 The ConditionalVisitor and MethodCallVisitor process those two nodes:
 
-```cs
+```csharp
 public class ConditionalVisitor : Visitor
 {
     private readonly ConditionalExpression node;
diff --git a/docs/csharp/expression-trees-translating.md b/docs/csharp/expression-trees-translating.md
index 806f3cf9c28c0..5afc4b0d61a49 100644
--- a/docs/csharp/expression-trees-translating.md
+++ b/docs/csharp/expression-trees-translating.md
@@ -45,7 +45,7 @@ Here, once you find a constant node, you create a new multiplication
 node whose children are the original constant, and the constant
 `10`:
 
-```cs
+```csharp
 private static Expression ReplaceNodes(Expression original)
 {
     if (original.NodeType == ExpressionType.Constant)
@@ -67,7 +67,7 @@ By replacing the original node with the substitute, a new tree
 is formed that contains our modifications. We can verify that by
 compiling and executing the replaced tree.
 
-```cs
+```csharp
 var one = Expression.Constant(1, typeof(int));
 var two = Expression.Constant(2, typeof(int));
 var addition = Expression.Add(one, two);
@@ -103,7 +103,7 @@ that is simply the value of the constant expression. For an addition
 expression, the result is the sum of the left and right operands, once
 those trees have been traversed.
 
-```cs
+```csharp
 var one = Expression.Constant(1, typeof(int));
 var two = Expression.Constant(2, typeof(int));
 var three= Expression.Constant(3, typeof(int));
@@ -139,7 +139,7 @@ Let's make it easier to trace how the nodes are analyzed and how the sum
 is computed by travsersing the tree. Here's an updated version of the
 Aggregate method that includes quite a bit of tracing information:
 
-```cs
+```csharp
 private static int Aggregate(Expression exp)
 {
     if (exp.NodeType == ExpressionType.Constant)
@@ -202,7 +202,7 @@ through the tree and finds the sum.
 
 Now, let's look at a different run, with the expression given by `sum1`:
 
-```cs
+```csharp
 Expression<Func<int> sum1 = () => 1 + (2 + (3 + 4));
 ```
 
diff --git a/docs/csharp/getting-started/debugging-with-visual-studio-2017.md b/docs/csharp/getting-started/debugging-with-visual-studio-2017.md
index 7923df5cf96bf..78d102c2ef39b 100644
--- a/docs/csharp/getting-started/debugging-with-visual-studio-2017.md
+++ b/docs/csharp/getting-started/debugging-with-visual-studio-2017.md
@@ -70,7 +70,7 @@ To set a conditional breakpoint and test what happens when the user fails to ent
 
 1. In the text box that reads "e.g. x == 5", enter the following:
 
-   ```cs
+   ```csharp
    String.IsNullOrEmpty(name)
    ```
 
@@ -88,7 +88,7 @@ To set a conditional breakpoint and test what happens when the user fails to ent
 
 1. Note that the value of the `name` variable is "", or [String.Empty](xref:System.String.Empty). Confirm this by entering the following statement in the **Immediate window**:
 
-   ```cs
+   ```csharp
    ? name == String.Empty
    ```
 
diff --git a/docs/csharp/getting-started/testing-library-with-visual-studio.md b/docs/csharp/getting-started/testing-library-with-visual-studio.md
index b693c450d9ec3..923f6ad4f794e 100644
--- a/docs/csharp/getting-started/testing-library-with-visual-studio.md
+++ b/docs/csharp/getting-started/testing-library-with-visual-studio.md
@@ -96,7 +96,7 @@ Our test run had no failures, so let's change it slightly so that one of the tes
 
 1. Modify the `words` array in the `TestDoesNotStartWithUpper` method to include the string "Error", so that the statement reads as follows:
 
-   ```cs
+   ```csharp
    string[] words = { "alphabet", "Error", "zebra", "abc", "αυτοκινητοβιομηχανία", "государство",
                       "1234", ".", ";", " " };
    ```
diff --git a/docs/csharp/getting-started/with-visual-studio.md b/docs/csharp/getting-started/with-visual-studio.md
index 3f5bc26d634d2..5e2e862c73027 100644
--- a/docs/csharp/getting-started/with-visual-studio.md
+++ b/docs/csharp/getting-started/with-visual-studio.md
@@ -40,7 +40,7 @@ Let's begin by creating a simple "Hello World" console application. Here are the
 
 4. Let's have our existing application pause before it closes the console window. Add the following code immediately after the call to the @System.Console.WriteLine(System.String) method:
 
-   ```cs
+   ```csharp
    Console.Write("Press any key to continue...");
    Console.ReadKey(true);
    ```
diff --git a/docs/csharp/indexers.md b/docs/csharp/indexers.md
index 9e2a209201dba..b39f0b4db3feb 100644
--- a/docs/csharp/indexers.md
+++ b/docs/csharp/indexers.md
@@ -25,7 +25,7 @@ of values.
 You access an indexer through a variable name and square brackets . You place the indexer
 arguments inside the brackets:
 
-```cs
+```csharp
 var item = someObject["key"];
 someObject["AnotherKey"] = item;
 ```
@@ -34,7 +34,7 @@ You declare indexers using the `this` keyword as the property name, and
 declaring the arguments within square brackets. This declaration would match
 the usage shown in the previous paragraph:
 
-```cs
+```csharp
 public int this[string key]
 {
     get { return storage.Find(key); }
@@ -94,7 +94,7 @@ this behavior. It reports on how many data points exist. It creates
 pages to hold sections of the data on demand. It removes pages
 from memory to make room for pages needed by more recent requests.
 
-```cs
+```csharp
 public class DataSamples
 {
     private class Page
@@ -230,7 +230,7 @@ class that maps a command line option to an `Action` delegate, and an
 `ArgsProcessor` that uses the `ArgsActions` to execute each `Action` when
 it encounters that option.
 
-```cs
+```csharp
 public class ArgsProcessor
 {
     private readonly ArgsActions actions;
@@ -292,7 +292,7 @@ is in the set, and the class's maxIterations value is returned. (The computer
 generated images popularized for the Mandelbrot set define colors for the
 number of iterations necessary to determine that a point is outside the set.
 
-```cs
+```csharp
 public class Mandelbrot
 {
     readonly private int maxIterations;
@@ -334,7 +334,7 @@ of different types. Consider a program that manages historical temperature
 data. This indexer uses a city and a date to set or get the high and low 
 temperatures for that location:
 
-```cs
+```csharp
 using DateMeasurements = 
     System.Collections.Generic.Dictionary<System.DateTime, IndexersSamples.Common.Measurements>;
 using CityDataMeasurements = 
@@ -389,7 +389,7 @@ the underlying storage must use different core collection types.
 There are two parts of this code that may be unfamiliar
 to some developers. These two `using` statements:
 
-```cs
+```csharp
 using DateMeasurements = System.Collections.Generic.Dictionary<System.DateTime, IndexersSamples.Common.Measurements>;
 using CityDataMeasurements = System.Collections.Generic.Dictionary<string, System.Collections.Generic.Dictionary<System.DateTime, IndexersSamples.Common.Measurements>>;
 ```
diff --git a/docs/csharp/iterators.md b/docs/csharp/iterators.md
index 78efc9ad7039f..38435e3d74c87 100644
--- a/docs/csharp/iterators.md
+++ b/docs/csharp/iterators.md
@@ -37,7 +37,7 @@ Enumerating a collection is simple: The `foreach` keyword enumerates
 a collection, executing the embedded statement once for each element
 in the collection:
  
-```cs
+```csharp
 foreach (var item in collection)
 {
    Console.WriteLine(item.ToString());
@@ -62,7 +62,7 @@ use the `yield return` contextual keywords to define an iterator method.
 
 You could write this method to produce the sequence of integers from 0 through 9:
 
-```cs
+```csharp
 public IEnumerable<int> GetSingleDigitNumbers()
 {
     yield return 0;
@@ -84,7 +84,7 @@ You can (and often do) use other language constructs to simplify the code of an
 iterator method. The method definition below produces the exact same sequence
 of numbers:
 
-```cs
+```csharp
 public IEnumerable<int> GetSingleDigitNumbers()
 {
     int index = 0;
@@ -96,7 +96,7 @@ public IEnumerable<int> GetSingleDigitNumbers()
 You don't have to decide one or the other. You can have as many `yield return`
 statements as necessary to meet the needs of your method:
 
-```cs
+```csharp
 public IEnumerable<int> GetSingleDigitNumbers()
 {
     int index = 0;
@@ -117,7 +117,7 @@ sensors generate a very large stream of data. To get a feel for the data, you
 might write a method that samples every Nth data element. This small iterator
 method does the trick:
 
-```cs
+```csharp
 public static IEnumerable<T> Sample(this IEnumerable<T> sourceSequence, int interval)
 {
     int index = 0;
@@ -133,7 +133,7 @@ There is one important restriction on iterator methods: you can't have both a
 `return` statement and a `yield return` statement in the same method. The following
 will not compile:
 
-```cs
+```csharp
 public IEnumerable<int> GetSingleDigitNumbers()
 {
     int index = 0;
@@ -154,7 +154,7 @@ multiple methods, some using `return`, and some using `yield return`.
 
 You can modify the last method slightly to use `yield return` everywhere:
 
-```cs
+```csharp
 public IEnumerable<int> GetSingleDigitNumbers()
 {
     int index = 0;
@@ -175,7 +175,7 @@ a situation where you might want to return an empty collection, or the first 5
 odd numbers, based on a boolean argument. You could write that as these two
 methods:
 
-```cs
+```csharp
 public IEnumerable<int> GetSingleDigitOddNumbers(bool getCollection)
 {
     if (getCollection == false)
@@ -207,7 +207,7 @@ by not properly managing resources.
 The compiler translates the `foreach` loop shown in the first
 example into something similar to this construct:
 
-```cs
+```csharp
 IEnumerator<int> enumerator = collection.GetEnumerator();
 while (enumerator.MoveNext())
 {
@@ -219,7 +219,7 @@ while (enumerator.MoveNext())
 The construct above represents the code generated by the C# compiler as of
 version 5 and above. Prior to version 5, the `item` variable had a different scope:
 
-```cs
+```csharp
 // C# versions 1 through 4:
 IEnumerator<int> enumerator = collection.GetEnumerator();
 int item = default(int);
@@ -238,7 +238,7 @@ The exact code generated by the compiler is somewhat more complicated, and
 handles situations where the object returned by `GetEnumerator()` implements
 the `IDisposable` interface. The full expansion generates code more like this:
 
-```cs
+```csharp
 {
     var enumerator = collection.GetEnumerator();
     try 
@@ -258,7 +258,7 @@ the `IDisposable` interface. The full expansion generates code more like this:
 The manner in which the enumerator is disposed of depends on the characteristics of
 the type of `enumerator`. In the general case, the `finally` clause expands to:
 
-```cs
+```csharp
 finally 
 {
    (enumerator as IDisposable)?.Dispose();
@@ -268,7 +268,7 @@ finally
 However, if the type of `enumerator` is a sealed type and there is no implicit
 conversion from the type of `enumerator` to `IDisposable`, the `finally` clause
 expands to an empty block:
-```cs
+```csharp
 finally 
 {
 } 
@@ -277,7 +277,7 @@ finally
 If there is an implicit conversion from the type of `enumerator` to `IDisposable`,
 and `enumerator` is a non-nullable value type, the `finally` clause expands to:
 
-```cs
+```csharp
 finally 
 {
    ((IDisposable)enumerator).Dispose();
diff --git a/docs/csharp/lambda-expressions.md b/docs/csharp/lambda-expressions.md
index bac8057f8b8d3..a2d5af1dd66ca 100644
--- a/docs/csharp/lambda-expressions.md
+++ b/docs/csharp/lambda-expressions.md
@@ -36,7 +36,7 @@ Or you can pass it directly as a method argument:
 
  A lambda expression with an expression on the right side of the => operator is called an *expression lambda*. Expression lambdas are used extensively in the construction of [expression trees](expression-trees.md). An expression lambda returns the result of the expression and takes the following basic form:
 
-```cs
+```csharp
 (input parameters) => expression
 ```
 
@@ -58,7 +58,7 @@ Note in the previous example that the body of an expression lambda can consist o
 
 A statement lambda resembles an expression lambda except that the statement(s) is enclosed in braces:
 
-```cs
+```csharp
 (input parameters) => { statement; }
 ```
 
diff --git a/docs/csharp/language-reference/compiler-messages/cs0015.md b/docs/csharp/language-reference/compiler-messages/cs0015.md
index 2fefb0e73965b..23ed214483b87 100644
--- a/docs/csharp/language-reference/compiler-messages/cs0015.md
+++ b/docs/csharp/language-reference/compiler-messages/cs0015.md
@@ -38,7 +38,7 @@ The name of type 'type' is too long
   
  The following sample generates CS0015:  
   
-```cs  
+```csharp  
 // CS0015.cs  
   
 // Remove a C from one of the namespace names or the class name to resolve the error by  
diff --git a/docs/csharp/language-reference/compiler-messages/cs0052.md b/docs/csharp/language-reference/compiler-messages/cs0052.md
index 8e0760866e8ca..919e235f20897 100644
--- a/docs/csharp/language-reference/compiler-messages/cs0052.md
+++ b/docs/csharp/language-reference/compiler-messages/cs0052.md
@@ -38,7 +38,7 @@ Inconsistent accessibility: field type 'type' is less accessible than field 'fie
 ## Example  
  The following sample generates CS0052:  
   
-```cs  
+```csharp  
 // CS0052.cs  
 public class MyClass2  
 {  
diff --git a/docs/csharp/language-reference/compiler-messages/cs0103.md b/docs/csharp/language-reference/compiler-messages/cs0103.md
index 436f776d940e5..d3e13580e37a1 100644
--- a/docs/csharp/language-reference/compiler-messages/cs0103.md
+++ b/docs/csharp/language-reference/compiler-messages/cs0103.md
@@ -37,7 +37,7 @@ The name 'identifier' does not exist in the current context
   
  This error frequently occurs if you declare a variable in a loop or a `try` or `if` block and then attempt to access it from an enclosing code block or a separate code block, as shown in the following example.  
   
-```cs  
+```csharp  
 using System;  
   
 class MyClass1  
@@ -63,7 +63,7 @@ class MyClass1
   
  The following example resolves the error.  
   
-```cs  
+```csharp  
   
 using System;  
   
diff --git a/docs/csharp/language-reference/compiler-messages/cs0163.md b/docs/csharp/language-reference/compiler-messages/cs0163.md
index 9816f0bba9657..48d85baaddae2 100644
--- a/docs/csharp/language-reference/compiler-messages/cs0163.md
+++ b/docs/csharp/language-reference/compiler-messages/cs0163.md
@@ -50,7 +50,7 @@ Control cannot fall through from one case label ('label') to another
   
  The following sample generates CS0163.  
   
-```cs  
+```csharp  
 // CS0163.cs  
 public class MyClass  
 {  
diff --git a/docs/csharp/language-reference/compiler-messages/cs0165.md b/docs/csharp/language-reference/compiler-messages/cs0165.md
index bbec2ebfe4009..c3e41286fc218 100644
--- a/docs/csharp/language-reference/compiler-messages/cs0165.md
+++ b/docs/csharp/language-reference/compiler-messages/cs0165.md
@@ -40,7 +40,7 @@ Use of unassigned local variable 'name'
 ## Example  
  The following sample generates CS0165:  
   
-```cs  
+```csharp  
 // CS0165.cs  
 using System;  
   
@@ -93,7 +93,7 @@ class MyClass2
 ## Example  
  Compiler error CS0165 can occur in recursive delegate definitions. You can avoid the error by defining the delegate in two statements so that the variable is not used before it is initialized. The following example demonstrates the error and the resolution.  
   
-```cs  
+```csharp  
 class Program  
 {  
     delegate void Del();  
diff --git a/docs/csharp/language-reference/compiler-messages/cs0173.md b/docs/csharp/language-reference/compiler-messages/cs0173.md
index eb6a6d605956f..3e4e832e85f31 100644
--- a/docs/csharp/language-reference/compiler-messages/cs0173.md
+++ b/docs/csharp/language-reference/compiler-messages/cs0173.md
@@ -40,7 +40,7 @@ Type of conditional expression cannot be determined because there is no implicit
 ## Example  
  The following sample generates CS0173:  
   
-```cs  
+```csharp  
 // CS0173.cs  
 public class C {}  
   
@@ -84,7 +84,7 @@ public class MyClass
 ## Example  
  The following code does not produce CS0173 in Visual Studio 2005, but does in later versions.  
   
-```cs  
+```csharp  
 //cs0173_2.cs  
 class M  
 {  
diff --git a/docs/csharp/language-reference/compiler-messages/cs0246.md b/docs/csharp/language-reference/compiler-messages/cs0246.md
index 361de5ee54d1b..d6450cb6e38ea 100644
--- a/docs/csharp/language-reference/compiler-messages/cs0246.md
+++ b/docs/csharp/language-reference/compiler-messages/cs0246.md
@@ -50,7 +50,7 @@ The type or namespace name 'type/namespace' could not be found (are you missing
   
 -   Did you use a *using alias directive* without fully qualifying the type name? A `using` alias directive does not use the `using` directives in the source code file to resolve types. The following example generates CS0246 because the type `List<int>` is not fully qualified. The `using` directive for `System.Collections.Generic` does not prevent the error.  
   
-    ```cs  
+    ```csharp  
     using System.Collections.Generic;  
   
     // The following declaration generates CS0246.  
@@ -67,7 +67,7 @@ The type or namespace name 'type/namespace' could not be found (are you missing
   
  The following example generates CS0246 because a necessary `using` directive is missing.  
   
-```cs  
+```csharp  
 // CS0246.cs  
 //using System.Diagnostics;  
   
@@ -89,7 +89,7 @@ public class MyClass
   
  The following example causes CS0246 because an object of type `Type` was used where an actual type was expected.  
   
-```cs  
+```csharp  
 // CS0246b.cs  
 using System;  
   
diff --git a/docs/csharp/language-reference/compiler-messages/cs0260.md b/docs/csharp/language-reference/compiler-messages/cs0260.md
index 1e4f0fd8ff0ab..e1700fab080c6 100644
--- a/docs/csharp/language-reference/compiler-messages/cs0260.md
+++ b/docs/csharp/language-reference/compiler-messages/cs0260.md
@@ -39,7 +39,7 @@ Missing partial modifier on declaration of type 'type'; another partial declarat
   
  The following sample generates CS0260:  
   
-```cs  
+```csharp  
 // CS0260.cs  
 // You must mark both parts of the definition of class C   
 // by using the partial keyword.  
diff --git a/docs/csharp/language-reference/compiler-messages/cs0266.md b/docs/csharp/language-reference/compiler-messages/cs0266.md
index ff14c67c7dcb8..68175d45ca284 100644
--- a/docs/csharp/language-reference/compiler-messages/cs0266.md
+++ b/docs/csharp/language-reference/compiler-messages/cs0266.md
@@ -37,7 +37,7 @@ Cannot implicitly convert type 'type1' to 'type2'. An explicit conversion exists
   
  The following code shows examples that generate CS0266.  
   
-```cs  
+```csharp  
 // CS0266.cs  
 class MyClass  
 {  
diff --git a/docs/csharp/language-reference/compiler-messages/cs0269.md b/docs/csharp/language-reference/compiler-messages/cs0269.md
index d806a376f9475..01f660f98882b 100644
--- a/docs/csharp/language-reference/compiler-messages/cs0269.md
+++ b/docs/csharp/language-reference/compiler-messages/cs0269.md
@@ -38,7 +38,7 @@ Use of unassigned out parameter 'parameter'
 ## Example  
  The following sample generates CS0269:  
   
-```cs  
+```csharp  
 // CS0269.cs  
 class C  
 {  
@@ -69,7 +69,7 @@ class C
 ## Example  
  This could also occur if the initialization of a variable occurs in a try block, which the compiler is unable to verify will execute successfully:  
   
-```cs  
+```csharp  
 // CS0269b.cs  
 class C  
 {  
diff --git a/docs/csharp/language-reference/compiler-messages/cs0304.md b/docs/csharp/language-reference/compiler-messages/cs0304.md
index d0b8bbfb44633..3947f5fcd4752 100644
--- a/docs/csharp/language-reference/compiler-messages/cs0304.md
+++ b/docs/csharp/language-reference/compiler-messages/cs0304.md
@@ -35,7 +35,7 @@ Cannot create an instance of the variable type 'type' because it does not have t
   
  When you implement a generic class, and you want to use the `new` keyword to create a new instance of any type that is supplied for a type parameter `T`, you must apply the [new() constraint](../../../csharp/language-reference/keywords/new.md) to `T` in the class declaration, as shown in the following example.  
   
-```cs  
+```csharp  
 class C<T> where T : new()  
 ```  
   
@@ -43,7 +43,7 @@ class C<T> where T : new()
   
  The following example generates CS0304.  
   
-```cs  
+```csharp  
   
 // CS0304.cs  
 // Compile with: /target:library.  
@@ -57,7 +57,7 @@ class C<T>
   
  The `new` operator also is not allowed in methods of the class.  
   
-```cs  
+```csharp  
   
 // Compile with: /target:library.  
 class C<T>  
@@ -73,7 +73,7 @@ class C<T>
   
  To avoid the error, declare the class by using the `new()` constraint, as shown in the following example.  
   
-```cs  
+```csharp  
   
 // Compile with: /target:library.  
 class C<T> where T : new()  
diff --git a/docs/csharp/language-reference/compiler-messages/cs0417.md b/docs/csharp/language-reference/compiler-messages/cs0417.md
index 4ee3d648507e1..9f1d8823fafc3 100644
--- a/docs/csharp/language-reference/compiler-messages/cs0417.md
+++ b/docs/csharp/language-reference/compiler-messages/cs0417.md
@@ -38,7 +38,7 @@ translation.priority.ht:
 ## Example  
  The following example generates CS0417:  
   
-```cs  
+```csharp  
 // CS0417  
 class ExampleClass<T> where T : new()  
 {  
diff --git a/docs/csharp/language-reference/compiler-messages/cs0445.md b/docs/csharp/language-reference/compiler-messages/cs0445.md
index 0abea96d3c24a..556e01d193e41 100644
--- a/docs/csharp/language-reference/compiler-messages/cs0445.md
+++ b/docs/csharp/language-reference/compiler-messages/cs0445.md
@@ -37,7 +37,7 @@ Cannot modify the result of an unboxing conversion
   
  The following code generates CS0455.  
   
-```cs  
+```csharp  
   
 // CS0445.CS  
 class UnboxingTest  
diff --git a/docs/csharp/language-reference/compiler-messages/cs0467.md b/docs/csharp/language-reference/compiler-messages/cs0467.md
index aacff5b19ca94..82e70b71e1370 100644
--- a/docs/csharp/language-reference/compiler-messages/cs0467.md
+++ b/docs/csharp/language-reference/compiler-messages/cs0467.md
@@ -39,7 +39,7 @@ Ambiguity between method 'method' and non-method 'non-method'.Using method group
 ## Example  
  The following example generates CS0467.  
   
-```cs  
+```csharp  
 // CS0467.cs  
 interface IList   
 {  
diff --git a/docs/csharp/language-reference/compiler-messages/cs0579.md b/docs/csharp/language-reference/compiler-messages/cs0579.md
index f4005f91b8a3f..47969a659b33e 100644
--- a/docs/csharp/language-reference/compiler-messages/cs0579.md
+++ b/docs/csharp/language-reference/compiler-messages/cs0579.md
@@ -38,7 +38,7 @@ Duplicate 'attribute' attribute
 ## Example  
  The following example generates CS0579.  
   
-```cs  
+```csharp  
 // CS0579.cs  
 using System;  
 public class MyAttribute : Attribute  
diff --git a/docs/csharp/language-reference/compiler-messages/cs1009.md b/docs/csharp/language-reference/compiler-messages/cs1009.md
index fed87dae27b69..df5d71db59b88 100644
--- a/docs/csharp/language-reference/compiler-messages/cs1009.md
+++ b/docs/csharp/language-reference/compiler-messages/cs1009.md
@@ -37,7 +37,7 @@ Unrecognized escape sequence
   
  The following sample generates CS1009.  
   
-```cs  
+```csharp  
 // CS1009-a.cs  
 class MyClass  
 {  
@@ -53,13 +53,13 @@ class MyClass
   
  A common cause of this error is using the backslash character in a file name, as the following example shows.  
   
-```cs  
+```csharp  
 string filename = "c:\myFolder\myFile.txt";  
 ```  
   
  To resolve this error, use "\\\\" or the @-quoted string literal, as the following example shows.  
   
-```cs  
+```csharp  
 // CS1009-b.cs  
 class MyClass  
 {  
diff --git a/docs/csharp/language-reference/compiler-messages/cs1019.md b/docs/csharp/language-reference/compiler-messages/cs1019.md
index b800804fd4c85..f3d9c9979101f 100644
--- a/docs/csharp/language-reference/compiler-messages/cs1019.md
+++ b/docs/csharp/language-reference/compiler-messages/cs1019.md
@@ -38,7 +38,7 @@ Overloadable unary operator expected
   
  A *unary operator* is an operator that operates on a single operand. For example, `++` is a unary operator. You can overload some unary operators by using the `operator` keyword and specifying a single parameter of the type that the operator operates on. For example, if you want to overload the operator `++` for a user-defined class `Temperature` so that you can write `Temperature++`, you can define it in this way:  
   
-```cs  
+```csharp  
 public static  Temperature operator ++ (Temperature temp)  
 {  
     temp.Degrees++;  
@@ -50,7 +50,7 @@ public static  Temperature operator ++ (Temperature temp)
   
  The following code generates CS1019:  
   
-```cs  
+```csharp  
 // CS1019.cs  
 public class ii  
 {  
diff --git a/docs/csharp/language-reference/compiler-messages/cs1061.md b/docs/csharp/language-reference/compiler-messages/cs1061.md
index 35b0cd62cb938..a785b7f0428f7 100644
--- a/docs/csharp/language-reference/compiler-messages/cs1061.md
+++ b/docs/csharp/language-reference/compiler-messages/cs1061.md
@@ -38,7 +38,7 @@ translation.priority.ht:
 ## Example  
  The following example generates CS1061 because `TestClass1` does not have a `DisplaySomething` method. It does have a method that is called `WriteSomething`. Perhaps that is what the author of this source code meant to write.  
   
-```cs  
+```csharp  
 // cs1061.cs  
 public class TestClass1  
 {  
diff --git a/docs/csharp/language-reference/compiler-messages/cs1501.md b/docs/csharp/language-reference/compiler-messages/cs1501.md
index 8ef5cbd70cc73..ed895840b34ec 100644
--- a/docs/csharp/language-reference/compiler-messages/cs1501.md
+++ b/docs/csharp/language-reference/compiler-messages/cs1501.md
@@ -39,7 +39,7 @@ No overload for method 'method' takes 'number' arguments
 ## Example  
  The following sample generates CS1501.  
   
-```cs  
+```csharp  
 using System;  
   
 namespace ConsoleApplication1  
diff --git a/docs/csharp/language-reference/compiler-messages/cs1519.md b/docs/csharp/language-reference/compiler-messages/cs1519.md
index 27afd1c03a371..53220bba343ff 100644
--- a/docs/csharp/language-reference/compiler-messages/cs1519.md
+++ b/docs/csharp/language-reference/compiler-messages/cs1519.md
@@ -39,7 +39,7 @@ Invalid token 'token' in class, struct, or interface member declaration
   
  The following sample generates CS1519 in five places because tokens are placed in locations where they are not valid:  
   
-```cs  
+```csharp  
 // CS1519.cs  
 // Generates CS1519 because a class name cannot be a number:  
 class Test 42   
diff --git a/docs/csharp/language-reference/compiler-messages/cs1540.md b/docs/csharp/language-reference/compiler-messages/cs1540.md
index 2eec3d1a3eda1..ee812b30a8afd 100644
--- a/docs/csharp/language-reference/compiler-messages/cs1540.md
+++ b/docs/csharp/language-reference/compiler-messages/cs1540.md
@@ -38,7 +38,7 @@ Cannot access protected member 'member' via a qualifier of type 'type1'; the qua
   
  In the `Employee` class in the following example, `emp2` and `emp3` both have type `Person` at compile time, but `emp2` has type `Manager` at run time. Because `Employee` is not derived from `Manager`, it cannot access the protected members of the base class, `Person`, through an instance of the `Manager` class. The compiler cannot determine what the run-time type of the two `Person` objects will be. Therefore, both the call from `emp2` and the call from `emp3` cause compiler error CS1540.  
   
-```cs  
+```csharp  
 using System;  
 using System.Text;  
   
diff --git a/docs/csharp/language-reference/compiler-messages/cs1612.md b/docs/csharp/language-reference/compiler-messages/cs1612.md
index 2eb093041e354..9b67b5ae8644d 100644
--- a/docs/csharp/language-reference/compiler-messages/cs1612.md
+++ b/docs/csharp/language-reference/compiler-messages/cs1612.md
@@ -35,14 +35,14 @@ Cannot modify the return value of 'expression' because it is not a variable
   
  An attempt was made to modify a value type that is produced as the result of an intermediate expression but is not stored in a variable. This error can occur when you attempt to directly modify a struct in a generic collection, as shown in the following example:  
   
-```cs  
+```csharp  
 List<myStruct> list = {…};  
 list[0].Name = "MyStruct42"; //CS1612  
 ```  
   
  To modify the struct, first assign it to a local variable, modify the variable, then assign the variable back to the item in the collection.  
   
-```cs  
+```csharp  
 List<myStruct> list = {…};  
 MyStruct ms = list[0];  
 ms.Name = "MyStruct42";  
@@ -58,7 +58,7 @@ list[0] = ms;
 ## Example  
  CS1612 also occurs when you attempt to access the member of a struct through a property on an enclosing class that is returning the entire struct, as shown in the following example:  
   
-```cs  
+```csharp  
 // CS1612.cs  
 using System;  
   
diff --git a/docs/csharp/language-reference/compiler-messages/cs1705.md b/docs/csharp/language-reference/compiler-messages/cs1705.md
index cadbcda3b88e1..a3e10ec748038 100644
--- a/docs/csharp/language-reference/compiler-messages/cs1705.md
+++ b/docs/csharp/language-reference/compiler-messages/cs1705.md
@@ -48,7 +48,7 @@ Assembly 'AssemblyName1' uses 'TypeName' which has a higher version than referen
   
  The following code creates the first of the identical DLLs. For information about how to generate a key file, see [/keyfile (C# Compiler Options)](../../../csharp/language-reference/compiler-options/keyfile-compiler-option.md).  
   
-```cs  
+```csharp  
 // CS1705a.cs  
   
 // Compile by using the following command:   
@@ -68,7 +68,7 @@ public class Class1
 ## Example  
  The following code defines version 2.0 of the assembly, as specified by the <xref:System.Reflection.AssemblyVersionAttribute> attribute.  
   
-```cs  
+```csharp  
 // CS1705b.cs  
   
 // Compile by using the following command:   
@@ -89,7 +89,7 @@ public class Class1
 ## Example  
  The following code references the two DLL versions that are defined in the preceding code. `AssemblyA` refers to the DLL created by CS1705a.cs (version 1.0). `AssemblyB` refers to the DLL created by CS1705b.cs (version 2.0). In `ClassC`, two methods are defined. The first, `Return1A`, returns an object of type `Class1A`, which is an alias for `Class1` from version 1.0 of the DLL. The second, `Return1B`, returns an object of type `Class1B`, which is an alias for `Class1` from version 2.0 of the DLL. The definition of `Return1A` creates a dependency on version 1.0; the definition of `Return1B` creates a dependency on version 2.0.  
   
-```cs  
+```csharp  
 // CS1705c.cs  
   
 // Compile by using the following command. AssemblyA refers to the DLL created by  
@@ -132,7 +132,7 @@ public class ClassC
 ## Example  
  The following code generates compiler error CS1705. It references the DLL created by CS1705a.cs (version 1.0). However, in the `Main` method, the code accesses `ClassC` from CS1705c.cs. `ClassC` uses a type that is defined in CS1705b.cs (version 2.0). This causes compiler error CS1705 because the type has a version number for CS1705.dll that is higher than the referenced version of CS1705.dll.  
   
-```cs  
+```csharp  
 // CS1705d.cs  
   
 // Compile by using the following command:  
diff --git a/docs/csharp/language-reference/compiler-messages/cs1708.md b/docs/csharp/language-reference/compiler-messages/cs1708.md
index 239d4fc8b9628..9a366e54b6bcc 100644
--- a/docs/csharp/language-reference/compiler-messages/cs1708.md
+++ b/docs/csharp/language-reference/compiler-messages/cs1708.md
@@ -41,7 +41,7 @@ Fixed size buffers can only be accessed through locals or fields
 ## Example  
  The following sample generates CS1708.  
   
-```cs  
+```csharp  
 // CS1708.cs  
 // compile with: /unsafe  
 using System;  
diff --git a/docs/csharp/language-reference/compiler-messages/cs1729.md b/docs/csharp/language-reference/compiler-messages/cs1729.md
index 7d4507394a4b4..e5aa38ececfc8 100644
--- a/docs/csharp/language-reference/compiler-messages/cs1729.md
+++ b/docs/csharp/language-reference/compiler-messages/cs1729.md
@@ -46,7 +46,7 @@ translation.priority.ht:
 ## Example  
  The following example generates CS1729:  
   
-```cs  
+```csharp  
 // cs1729.cs  
 class Test  
 {  
diff --git a/docs/csharp/language-reference/compiler-messages/cs1956.md b/docs/csharp/language-reference/compiler-messages/cs1956.md
index a4e5b2f2f0381..f2a19af960e0d 100644
--- a/docs/csharp/language-reference/compiler-messages/cs1956.md
+++ b/docs/csharp/language-reference/compiler-messages/cs1956.md
@@ -44,7 +44,7 @@ Member 'name' implements interface member 'name' in type 'type'. There are multi
 ## Example  
  The following code generates CS1956 because the two `Test` methods in `Base` differ only by the `ref`/`out` modifier on the first parameter.  
   
-```cs  
+```csharp  
 // cs1956.cs  
 class Base<T, S>  
 {  
diff --git a/docs/csharp/language-reference/compiler-messages/cs2032.md b/docs/csharp/language-reference/compiler-messages/cs2032.md
index 0ed6c2d1c0f43..200039cbb9b8d 100644
--- a/docs/csharp/language-reference/compiler-messages/cs2032.md
+++ b/docs/csharp/language-reference/compiler-messages/cs2032.md
@@ -41,7 +41,7 @@ Character 'character' is not allowed on the command-line or in response files
   
 1.  In the **My Documents** folder, create a text file that is named CS2032.rsp, and then enter the following compiler options in it:  
   
-    ```cs  
+    ```csharp  
     /target:exe /out:cs|2032.exe cs2032.cs  
     ```  
   
diff --git a/docs/csharp/language-reference/compiler-messages/cs4014.md b/docs/csharp/language-reference/compiler-messages/cs4014.md
index 87d8eb873b121..4b22da70b31b8 100644
--- a/docs/csharp/language-reference/compiler-messages/cs4014.md
+++ b/docs/csharp/language-reference/compiler-messages/cs4014.md
@@ -44,7 +44,7 @@ Because this call is not awaited, execution of the current method continues befo
   
  The following example shows how to cause the warning, how to suppress it, and how to await the call.  
   
-```cs  
+```csharp  
   
 async Task CallingMethodAsync()  
 {  
@@ -122,7 +122,7 @@ Exiting the Click event handler.
   
 3.  Replace the code in the **XAML** view of MainWindow.xaml with the following code.  
   
-    ```cs  
+    ```csharp  
     <Window x:Class="AsyncWarning.MainWindow"  
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"  
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"  
@@ -140,7 +140,7 @@ Exiting the Click event handler.
   
 4.  Replace the code in MainWindow.xaml.cs with the following code.  
   
-    ```cs  
+    ```csharp  
     using System;  
     using System.Collections.Generic;  
     using System.Linq;  
diff --git a/docs/csharp/language-reference/compiler-options/link-compiler-option.md b/docs/csharp/language-reference/compiler-options/link-compiler-option.md
index 23810c74e8892..3e825f3f0c1ba 100644
--- a/docs/csharp/language-reference/compiler-options/link-compiler-option.md
+++ b/docs/csharp/language-reference/compiler-options/link-compiler-option.md
@@ -94,7 +94,7 @@ Causes the compiler to make COM type information in the specified assemblies ava
 ## Example  
  The following code compiles source file `OfficeApp.cs` and reference assemblies from `COMData1.dll` and `COMData2.dll` to produce `OfficeApp.exe`.  
   
-```cs  
+```csharp  
 csc /link:COMData1.dll,COMData2.dll /out:OfficeApp.exe OfficeApp.cs  
 ```  
   
diff --git a/docs/csharp/language-reference/compiler-options/preferreduilang-compiler-option.md b/docs/csharp/language-reference/compiler-options/preferreduilang-compiler-option.md
index e89a546228c6d..1695ee96be113 100644
--- a/docs/csharp/language-reference/compiler-options/preferreduilang-compiler-option.md
+++ b/docs/csharp/language-reference/compiler-options/preferreduilang-compiler-option.md
@@ -48,7 +48,7 @@ By using the `/preferreduilang` compiler option, you can specify the language in
 ## Remarks  
  You can use the `/preferreduilang` compiler option to specify the language that you want the C# compiler to use for error messages and other command-line output. If the language pack for the language is not installed, the language setting of the operating system is used instead, and no error is reported.  
   
-```cs  
+```csharp  
 csc.exe /preferreduilang:ja-JP  
 ```  
   
diff --git a/docs/csharp/language-reference/keywords/async.md b/docs/csharp/language-reference/keywords/async.md
index cb06666959b10..f19e0b424f47a 100644
--- a/docs/csharp/language-reference/keywords/async.md
+++ b/docs/csharp/language-reference/keywords/async.md
@@ -35,7 +35,7 @@ translation.priority.ht:
 # async (C# Reference)
 Use the `async` modifier to specify that a method, [lambda expression](../../../csharp/programming-guide/statements-expressions-operators/lambda-expressions.md), or [anonymous method](../../../csharp/programming-guide/statements-expressions-operators/anonymous-methods.md) is asynchronous. If you use this modifier on a method or expression, it's referred to as an async method.  
   
-```cs  
+```csharp  
 public async Task<int> ExampleMethodAsync()  
 {  
     // . . . .  
@@ -58,7 +58,7 @@ string contents = await contentsTask;
 ## Example  
  The following example shows the structure and flow of control between an async event handler, `StartButton_Click`, and an async method, `ExampleMethodAsync`. The result from the async method is the length of a downloaded website. The code is suitable for a Windows Presentation Foundation (WPF) app or Windows Store app that you create in [!INCLUDE[vs_dev12](../../../csharp/getting-started/includes/vs_dev12_md.md)]; see the code comments for setting up the app.  
   
-```cs  
+```csharp  
 // You can run this code in Visual Studio 2013 as a WPF app or a Windows Store app.  
 // You need a button (StartButton) and a textbox (ResultsTextBox).  
 // Remember to set the names and handler so that you have something like this:  
diff --git a/docs/csharp/language-reference/keywords/await.md b/docs/csharp/language-reference/keywords/await.md
index 496ceaadc3801..23aafeb7a7958 100644
--- a/docs/csharp/language-reference/keywords/await.md
+++ b/docs/csharp/language-reference/keywords/await.md
@@ -43,7 +43,7 @@ The `await` operator is applied to a task in an asynchronous method to suspend t
   
  In the following code, the <xref:System.Net.Http.HttpClient> method <xref:System.Net.Http.HttpClient.GetByteArrayAsync%2A> returns a `Task\<byte[]>`, `getContentsTask`. The task is a promise to produce the actual byte array when the task is complete. The `await` operator is applied to `getContentsTask` to suspend execution in `SumPageSizesAsync` until `getContentsTask` is complete. In the meantime, control is returned to the caller of `SumPageSizesAsync`. When `getContentsTask` is finished, the `await` expression evaluates to a byte array.  
   
-```cs  
+```csharp  
   
 private async Task SumPageSizesAsync()  
 {  
@@ -66,7 +66,7 @@ private async Task SumPageSizesAsync()
   
  As shown in the previous example, if `await` is applied to the result of a method call that returns a `Task<TResult>`, then the type of the `await` expression is TResult. If `await` is applied to the result of a method call that returns a `Task`, then the type of the `await` expression is void. The following example illustrates the difference.  
   
-```cs  
+```csharp  
 // Keyword await used with a method that returns a Task<TResult>.  
 TResult result = await AsyncMethodThatReturnsTaskTResult();  
   
@@ -93,7 +93,7 @@ await AsyncMethodThatReturnsTask();
 ## Example  
  The following Windows Forms example illustrates the use of `await` in an async method, `WaitAsynchronouslyAsync`. Contrast the behavior of that method with the behavior of `WaitSynchronously`. Without an `await` operator applied to a task, `WaitSynchronously` runs synchronously despite the use of the `async` modifier in its definition and a call to <xref:System.Threading.Thread.Sleep%2A?displayProperty=fullName> in its body.  
   
-```cs  
+```csharp  
   
 private async void button1_Click(object sender, EventArgs e)  
 {  
diff --git a/docs/csharp/language-reference/keywords/decimal.md b/docs/csharp/language-reference/keywords/decimal.md
index cc4da8ad11617..c884e7b45f365 100644
--- a/docs/csharp/language-reference/keywords/decimal.md
+++ b/docs/csharp/language-reference/keywords/decimal.md
@@ -77,7 +77,7 @@ myMoney = (decimal)x;
 ## Example  
  The following example causes a compiler error by trying to add [double](../../../csharp/language-reference/keywords/double.md) and `decimal` variables.  
   
-```cs  
+```csharp  
 double dub = 9;  
 // The following line causes an error that reads "Operator '+' cannot be applied to   
 // operands of type 'double' and 'decimal'"  
diff --git a/docs/csharp/language-reference/keywords/dynamic.md b/docs/csharp/language-reference/keywords/dynamic.md
index 099bed9f283d3..8f72d1a986363 100644
--- a/docs/csharp/language-reference/keywords/dynamic.md
+++ b/docs/csharp/language-reference/keywords/dynamic.md
@@ -48,7 +48,7 @@ The `dynamic` type enables the operations in which it occurs to bypass compile-t
   
  To see the difference between `dyn` and `obj` at compile time, add the following two lines between the declarations and the `WriteLine` statements in the previous example.  
   
-```cs  
+```csharp  
 dyn = dyn + 3;  
 obj = obj + 3;  
 ```  
diff --git a/docs/csharp/language-reference/keywords/fixed-statement.md b/docs/csharp/language-reference/keywords/fixed-statement.md
index 38a51891d12d4..20face37880ad 100644
--- a/docs/csharp/language-reference/keywords/fixed-statement.md
+++ b/docs/csharp/language-reference/keywords/fixed-statement.md
@@ -44,7 +44,7 @@ The `fixed` statement prevents the garbage collector from relocating a movable v
   
  You can initialize multiple pointers, as long as they are all of the same type.  
   
-```cs
+```csharp
 fixed (byte* ps = srcarray, pd = dstarray) {...}  
 ```
   
diff --git a/docs/csharp/language-reference/keywords/float.md b/docs/csharp/language-reference/keywords/float.md
index f0347476e616f..92b854bda792e 100644
--- a/docs/csharp/language-reference/keywords/float.md
+++ b/docs/csharp/language-reference/keywords/float.md
@@ -42,7 +42,7 @@ The `float` keyword signifies a simple type that stores 32-bit floating-point va
 ## Literals  
  By default, a real numeric literal on the right side of the assignment operator is treated as [double](double.md). Therefore, to initialize a float variable, use the suffix `f` or `F`, as in the following example:  
   
-```cs
+```csharp
 float x = 3.5F;  
 ```
   
diff --git a/docs/csharp/language-reference/keywords/for.md b/docs/csharp/language-reference/keywords/for.md
index 4cdcfaaad292a..6816864558bec 100644
--- a/docs/csharp/language-reference/keywords/for.md
+++ b/docs/csharp/language-reference/keywords/for.md
@@ -59,7 +59,7 @@ By using a `for` loop, you can run a statement or a block of statements repeated
   
  Every `for` statement defines initializer, condition, and iterator sections. These sections usually determine how many times the loop iterates.  
   
-```cs  
+```csharp  
 for (initializer; condition; iterator)  
     body  
 ```  
diff --git a/docs/csharp/language-reference/keywords/group-clause.md b/docs/csharp/language-reference/keywords/group-clause.md
index 6b55d044bd2ed..e18430f8eb9d5 100644
--- a/docs/csharp/language-reference/keywords/group-clause.md
+++ b/docs/csharp/language-reference/keywords/group-clause.md
@@ -71,7 +71,7 @@ The `group` clause returns a sequence of <xref:System.Linq.IGrouping%602> object
 ### Grouping by Composite Keys  
  Use a composite key when you want to group elements according to more than one key. You create a composite key by using an anonymous type or a named type to hold the key element. In the following example, assume that a class `Person` has been declared with members named `surname` and `city`. The `group` clause causes a separate group to be created for each set of persons with the same last name and the same city.  
   
-```cs  
+```csharp  
 group person by new {name = person.surname, city = person.city};  
 ```  
   
diff --git a/docs/csharp/language-reference/keywords/if-else.md b/docs/csharp/language-reference/keywords/if-else.md
index 30b576bf0fc74..78dd4bda05c7c 100644
--- a/docs/csharp/language-reference/keywords/if-else.md
+++ b/docs/csharp/language-reference/keywords/if-else.md
@@ -44,7 +44,7 @@ An `if` statement identifies which statement to run based on the value of a `Boo
   
  An `if` statement in C# can take two forms, as the following example shows.  
   
-```cs  
+```csharp  
   
 // if-else statement  
 if (condition)  
@@ -98,7 +98,7 @@ if (condition)
   
  Just as a statement in the else block or the then block can be any valid statement, you can use any valid Boolean expression for the condition. You can use logical operators such as [&&](../../../csharp/language-reference/operators/conditional-and-operator.md), [&](../../../csharp/language-reference/operators/and-operator.md), [&#124;&#124;](../../../csharp/language-reference/operators/conditional-or-operator.md), [&#124;](../../../csharp/language-reference/operators/or-operator.md) and [!](../../../csharp/language-reference/operators/logical-negation-operator.md) to make compound conditions. The following code shows examples.  
   
-```cs  
+```csharp  
 // NOT  
 bool result = true;  
 if (!result)  
diff --git a/docs/csharp/language-reference/keywords/int.md b/docs/csharp/language-reference/keywords/int.md
index 6a1aaf4a76b95..e25cba3aa3052 100644
--- a/docs/csharp/language-reference/keywords/int.md
+++ b/docs/csharp/language-reference/keywords/int.md
@@ -66,14 +66,14 @@ In these examples, the literal 90946 is of type `int`.
 ## Conversions  
  There is a predefined implicit conversion from `int` to [long](../../../csharp/language-reference/keywords/long.md), [float](../../../csharp/language-reference/keywords/float.md), [double](../../../csharp/language-reference/keywords/double.md), or [decimal](../../../csharp/language-reference/keywords/decimal.md). For example:  
   
-```cs  
+```csharp  
 // '123' is an int, so an implicit conversion takes place here:  
 float f = 123;  
 ```  
   
  There is a predefined implicit conversion from [sbyte](../../../csharp/language-reference/keywords/sbyte.md), [byte](../../../csharp/language-reference/keywords/byte.md), [short](../../../csharp/language-reference/keywords/short.md), [ushort](../../../csharp/language-reference/keywords/ushort.md), or [char](../../../csharp/language-reference/keywords/char.md) to `int`. For example, the following assignment statement will produce a compilation error without a cast:  
   
-```cs  
+```csharp  
 long aLong = 22;  
 int i1 = aLong;       // Error: no implicit conversion from long.  
 int i2 = (int)aLong;  // OK: explicit conversion.  
@@ -81,7 +81,7 @@ int i2 = (int)aLong;  // OK: explicit conversion.
   
  Notice also that there is no implicit conversion from floating-point types to `int`. For example, the following statement generates a compiler error unless an explicit cast is used:  
   
-```cs  
+```csharp  
 int x = 3.0;         // Error: no implicit conversion from double.  
 int y = (int)3.0;    // OK: explicit conversion.  
 ```  
diff --git a/docs/csharp/language-reference/keywords/interpolated-strings.md b/docs/csharp/language-reference/keywords/interpolated-strings.md
index 66ee9bdda7604..3f3c75026f2ab 100644
--- a/docs/csharp/language-reference/keywords/interpolated-strings.md
+++ b/docs/csharp/language-reference/keywords/interpolated-strings.md
@@ -33,12 +33,12 @@ Used to construct strings.  An interpolated string looks like a template string
 
 The arguments of an interpolated string are easier to understand than a [composite format string](../../../standard/base-types/composite-format.md#composite-format-string).  For example, the interpolated string  
   
-```cs  
+```csharp  
 Console.WriteLine($"Name = {name}, hours = {hours:hh}"); 
 ```  
 contains two interpolated expressions, '{name}' and '{hours:hh}'. The equivalent composite format string is:
 
-```cs
+```csharp
 Console.WriteLine("Name = {0}, hours = {1:hh}", name, hours);  
 ```  
 
diff --git a/docs/csharp/language-reference/keywords/is.md b/docs/csharp/language-reference/keywords/is.md
index 4005a2759d28e..20866d3c71bc2 100644
--- a/docs/csharp/language-reference/keywords/is.md
+++ b/docs/csharp/language-reference/keywords/is.md
@@ -40,7 +40,7 @@ Checks if an object is compatible with a given type, or (starting with C# 7) tes
 
 The `is` keyword evaluates type compatibility at runtime. It determines whether an object instance or the result of an expression can be converted to a specified type. It has the syntax
 
-```cs
+```csharp
    expr is type
 ```
 
@@ -87,7 +87,7 @@ Starting with C# 7, the `is` and [switch](../../../csharp/language-reference/key
 
 When using the type pattern to perform pattern matching, `is` tests whether an expression can be converted to a specified type and, if it can be, casts it to a variable of that type. It is a straightforward extension of the `is` statement that enables concise type evaluation and conversion. The general form of the `is` type pattern is:
 
-```cs
+```csharp
    expr is type varname 
 ```
 
@@ -125,7 +125,7 @@ The equivalent code without pattern matching requires a separate assignment that
 
 When performing pattern matching with the constant pattern, `is` tests whether an expression equals a specified constant. In C# 6 and earlier versions, the constant pattern is supported by the [switch](switch.md) statement. Starting with C# 7, it is supported by the `is` statement as well. Its syntax is:
 
-```cs
+```csharp
    expr is constant
 ```
 
@@ -151,7 +151,7 @@ The following example combines the type and constant patterns to test whether an
 
 A pattern match with the var pattern always succeeds. Its syntax is
 
-```cs 
+```csharp 
    expr is var varname
 ```
 
diff --git a/docs/csharp/language-reference/keywords/long.md b/docs/csharp/language-reference/keywords/long.md
index 594b16cc7d57e..7df4e73b536e5 100644
--- a/docs/csharp/language-reference/keywords/long.md
+++ b/docs/csharp/language-reference/keywords/long.md
@@ -56,7 +56,7 @@ Starting with C# 7, you can also use the underscore character, `_`, as a digit s
  
  Integer literals can also include a suffix that denotes the type. The suffix `L` denotes a `long`. The following example uses the `L` suffix to denote a long integer:
  
-```cs
+```csharp
 long value = 4294967296L;  
 ```  
 
@@ -67,14 +67,14 @@ long value = 4294967296L;
   
  A common use of the suffix is to call overloaded methods. For example, the following overloaded methods have parameters of type `long` and [int](../../../csharp/language-reference/keywords/int.md):  
   
-```cs
+```csharp
 public static void SampleMethod(int i) {}  
 public static void SampleMethod(long l) {}  
 ```  
   
  The `L` suffix guarantees that the correct overload is called:  
   
-```cs  
+```csharp  
 SampleMethod(5);    // Calls the method with the int parameter  
 SampleMethod(5L);   // Calls the method with the long parameter  
 ```  
@@ -89,7 +89,7 @@ The literal 4294967296 in the previous examples is of type `long`, because it ex
   
  If you use the `long` type with other integral types in the same expression, the expression is evaluated as `long` (or [bool](../../../csharp/language-reference/keywords/bool.md) in the case of relational or Boolean expressions). For example, the following expression evaluates as `long`:  
   
-```cs  
+```csharp  
 898L + 88  
 ```  
   
@@ -98,7 +98,7 @@ The literal 4294967296 in the previous examples is of type `long`, because it ex
 ## Conversions  
  There is a predefined implicit conversion from `long` to [float](../../../csharp/language-reference/keywords/float.md), [double](../../../csharp/language-reference/keywords/double.md), or [decimal](../../../csharp/language-reference/keywords/decimal.md). Otherwise a cast must be used. For example, the following statement will produce a compilation error without an explicit cast:  
   
-```cs  
+```csharp  
 int x = 8L;        // Error: no implicit conversion from long to int  
 int x = (int)8L;   // OK: explicit conversion to int  
 ```  
@@ -107,7 +107,7 @@ int x = (int)8L;   // OK: explicit conversion to int
   
  Notice also that there is no implicit conversion from floating-point types to `long`. For example, the following statement generates a compiler error unless an explicit cast is used:  
   
-```cs  
+```csharp  
 long x = 3.0;         // Error: no implicit conversion from double  
 long y = (long)3.0;   // OK: explicit conversion  
 ```  
diff --git a/docs/csharp/language-reference/keywords/nameof.md b/docs/csharp/language-reference/keywords/nameof.md
index fd7faa70b4dc8..45fed9ad21bc2 100644
--- a/docs/csharp/language-reference/keywords/nameof.md
+++ b/docs/csharp/language-reference/keywords/nameof.md
@@ -37,7 +37,7 @@ When reporting errors in code, hooking up model-view-controller (MVC) links, fir
   
  A `nameof` expression has this form:  
   
-```cs  
+```csharp  
 if (x == null) throw new ArgumentNullException(nameof(x));  
 WriteLine(nameof(person.Address.ZipCode)); // prints "ZipCode”  
   
@@ -47,7 +47,7 @@ WriteLine(nameof(person.Address.ZipCode)); // prints "ZipCode”
  These examples show the key use cases for `nameof`.  
   
  Validate parameters:  
- ```cs  
+ ```csharp  
 void f(string s) {  
     if (s == null) throw new ArgumentNullException(nameof(s));  
 }  
@@ -64,7 +64,7 @@ void f(string s) {
 ```  
   
  INotifyPropertyChanged:  
- ```cs  
+ ```csharp  
 int p {  
     get { return this.p; }  
     set { this.p = value; PropertyChanged(this, new PropertyChangedEventArgs(nameof(this.p)); } // nameof(p) works too  
@@ -73,13 +73,13 @@ int p {
 ```  
   
  XAML dependency property:  
- ```cs  
+ ```csharp  
 public static DependencyProperty AgeProperty = DependencyProperty.Register(nameof(Age), typeof(int), typeof(C));  
   
 ```  
   
  Logging:  
- ```cs  
+ ```csharp  
 void f(int i) {  
     Log(nameof(f), "method entry");  
 }  
@@ -87,7 +87,7 @@ void f(int i) {
 ```  
   
  Attributes:  
- ```cs  
+ ```csharp  
 [DebuggerDisplay("={" + nameof(GetString) + "()}")]  
 class C {  
     string GetString() { }  
@@ -97,7 +97,7 @@ class C {
 ## Examples  
  Some C# examples:  
   
-```cs  
+```csharp  
 using Stuff = Some.Cool.Functionality  
 class C {  
     static int Method1 (string x, int y) {}  
diff --git a/docs/csharp/language-reference/keywords/out-parameter-modifier.md b/docs/csharp/language-reference/keywords/out-parameter-modifier.md
index 43a4cb5aa90f4..2942e1cbfa437 100644
--- a/docs/csharp/language-reference/keywords/out-parameter-modifier.md
+++ b/docs/csharp/language-reference/keywords/out-parameter-modifier.md
@@ -41,7 +41,7 @@ The `out` keyword causes arguments to be passed by reference. It is like the [re
   
  Although the `ref` and `out` keywords cause different run-time behavior, they are not considered part of the method signature at compile time. Therefore, methods cannot be overloaded if the only difference is that one method takes a `ref` argument and the other takes an `out` argument. The following code, for example, will not compile:  
   
-```cs
+```csharp
 class CS0663_Example
 {
     // Compiler error CS0663: "Cannot define overloaded 
diff --git a/docs/csharp/language-reference/keywords/sbyte.md b/docs/csharp/language-reference/keywords/sbyte.md
index 0dc9900f0ddbc..04467e4cea85e 100644
--- a/docs/csharp/language-reference/keywords/sbyte.md
+++ b/docs/csharp/language-reference/keywords/sbyte.md
@@ -60,14 +60,14 @@ If the integer literal is outside the range of `sbyte` (that is, if it is less t
 
  A cast must be used when calling overloaded methods. Consider, for example, the following overloaded methods that use `sbyte` and [int](../../../csharp/language-reference/keywords/int.md) parameters:  
   
-```cs  
+```csharp  
 public static void SampleMethod(int i) {}  
 public static void SampleMethod(sbyte b) {}  
 ```  
   
  Using the `sbyte` cast guarantees that the correct type is called, for example:  
   
-```cs 
+```csharp 
 // Calling the method with the int parameter:  
 SampleMethod(5);  
 // Calling the method with the sbyte parameter:  
@@ -79,25 +79,25 @@ SampleMethod((sbyte)5);
   
  You cannot implicitly convert nonliteral numeric types of larger storage size to `sbyte` (see [Integral Types Table](../../../csharp/language-reference/keywords/integral-types-table.md) for the storage sizes of integral types). Consider, for example, the following two `sbyte` variables `x` and `y`:  
   
-```cs  
+```csharp  
 sbyte x = 10, y = 20;  
 ```  
   
  The following assignment statement will produce a compilation error, because the arithmetic expression on the right side of the assignment operator evaluates to [int](../../../csharp/language-reference/keywords/int.md) by default.  
   
-```cs  
+```csharp  
 sbyte z = x + y;   // Error: conversion from int to sbyte  
 ```  
   
  To fix this problem, cast the expression as in the following example:  
   
-```cs  
+```csharp  
 sbyte z = (sbyte)(x + y);   // OK: explicit conversion  
 ```  
   
  It is possible though to use the following statements, where the destination variable has the same storage size or a larger storage size:  
   
-```cs
+```csharp
 sbyte x = 10, y = 20;  
 int m = x + y;  
 long n = x + y;  
@@ -105,7 +105,7 @@ long n = x + y;
   
  Notice also that there is no implicit conversion from floating-point types to `sbyte`. For example, the following statement generates a compiler error unless an explicit cast is used:  
   
-```cs  
+```csharp  
 sbyte x = 3.0;         // Error: no implicit conversion from double  
 sbyte y = (sbyte)3.0;  // OK: explicit conversion  
 ```  
diff --git a/docs/csharp/language-reference/keywords/short.md b/docs/csharp/language-reference/keywords/short.md
index 85de65ea632ec..9242214eef1d1 100644
--- a/docs/csharp/language-reference/keywords/short.md
+++ b/docs/csharp/language-reference/keywords/short.md
@@ -58,14 +58,14 @@ Starting with C# 7, you can also use the underscore character, `_`, as a digit s
 
  A cast must be used when calling overloaded methods. Consider, for example, the following overloaded methods that use `short` and [int](../../../csharp/language-reference/keywords/int.md) parameters:  
   
-```cs  
+```csharp  
 public static void SampleMethod(int i) {}  
 public static void SampleMethod(short s) {}  
 ```  
   
  Using the `short` cast guarantees that the correct type is called, for example:  
   
-```cs  
+```csharp  
 SampleMethod(5);         // Calling the method with the int parameter  
 SampleMethod((short)5);  // Calling the method with the short parameter  
 ```  
@@ -76,32 +76,32 @@ SampleMethod((short)5);  // Calling the method with the short parameter
   
  You cannot implicitly convert nonliteral numeric types of larger storage size to `short` (see [Integral Types Table](../../../csharp/language-reference/keywords/integral-types-table.md) for the storage sizes of integral types). Consider, for example, the following two `short` variables `x` and `y`:  
   
-```cs  
+```csharp  
 short x = 5, y = 12;  
 ```  
   
  The following assignment statement produces a compilation error because the arithmetic expression on the right-hand side of the assignment operator evaluates to [int](../../../csharp/language-reference/keywords/int.md) by default.  
   
-```cs
+```csharp
 short z  = x + y;        // Compiler error CS0266: no conversion from int to short
 ```
 
  To fix this problem, use a cast:  
   
-```cs
+```csharp
 short z  = (short)(x + y);   // Explicit conversion
 ```
   
  It is also possible to use the following statements, where the destination variable has the same storage size or a larger storage size:  
   
-```cs  
+```csharp  
 int m = x + y;  
 long n = x + y;  
 ```  
   
  There is no implicit conversion from floating-point types to `short`. For example, the following statement generates a compiler error unless an explicit cast is used:  
   
-```cs  
+```csharp  
 short x = 3.0;          // Error: no implicit conversion from double  
 short y = (short)3.0;   // OK: explicit conversion  
 ```  
diff --git a/docs/csharp/language-reference/keywords/sizeof.md b/docs/csharp/language-reference/keywords/sizeof.md
index 803cc8c15d7c1..43b0dccd4d7a1 100644
--- a/docs/csharp/language-reference/keywords/sizeof.md
+++ b/docs/csharp/language-reference/keywords/sizeof.md
@@ -42,7 +42,7 @@ Used to obtain the size in bytes for an unmanaged type. Unmanaged types include
   
  The following example shows how to retrieve the size of an `int`:  
   
-```cs  
+```csharp  
 // Constant value 4:  
 int intSize = sizeof(int);   
 ```  
diff --git a/docs/csharp/language-reference/keywords/static.md b/docs/csharp/language-reference/keywords/static.md
index 725dc85293eca..542f0e67bd18f 100644
--- a/docs/csharp/language-reference/keywords/static.md
+++ b/docs/csharp/language-reference/keywords/static.md
@@ -47,7 +47,7 @@ Use the `static` modifier to declare a static member, which belongs to the type
   
  To refer to the static member `x`, use the fully qualified name, `MyBaseC.MyStruct.x`, unless the member is accessible from the same scope:  
   
-```cs  
+```csharp  
 Console.WriteLine(MyBaseC.MyStruct.x);  
 ```  
   
diff --git a/docs/csharp/language-reference/keywords/string.md b/docs/csharp/language-reference/keywords/string.md
index d82d0a3fdecde..ebb57d20304f7 100644
--- a/docs/csharp/language-reference/keywords/string.md
+++ b/docs/csharp/language-reference/keywords/string.md
@@ -40,7 +40,7 @@ The `string` type represents a sequence of zero or more Unicode characters. `str
   
  Although `string` is a reference type, the equality operators (`==` and `!=`) are defined to compare the values of `string` objects, not references. This makes testing for string equality more intuitive. For example:  
   
-```cs  
+```csharp  
   
       string a = "hello";  
 string b = "h";  
@@ -54,7 +54,7 @@ Console.WriteLine((object)a == (object)b);
   
  The + operator concatenates strings:  
   
-```cs  
+```csharp  
   
 string a = "good " + "morning";  
 ```  
@@ -63,7 +63,7 @@ string a = "good " + "morning";
   
  Strings are *immutable*--the contents of a string object cannot be changed after the object is created, although the syntax makes it appear as if you can do this. For example, when you write this code, the compiler actually creates a new string object to hold the new sequence of characters, and that new object is assigned to b. The string "h" is then eligible for garbage collection.  
   
-```cs  
+```csharp  
   
       string b = "h";  
 b += "ello";  
@@ -71,7 +71,7 @@ b += "ello";
   
  The [] operator can be used for readonly access to individual characters of a `string`:  
   
-```cs  
+```csharp  
   
       string str = "test";  
 char x = str[2];  // x = 's';  
@@ -79,7 +79,7 @@ char x = str[2];  // x = 's';
   
  String literals are of type `string` and can be written in two forms, quoted and @-quoted. Quoted string literals are enclosed in double quotation marks ("):  
   
-```cs  
+```csharp  
 "good morning"  // a string literal  
 ```  
   
@@ -96,19 +96,19 @@ Console.WriteLine(a);
   
  Verbatim string literals start with @ and are also enclosed in double quotation marks. For example:  
   
-```cs  
+```csharp  
 @"good morning"  // a string literal  
 ```  
   
  The advantage of verbatim strings is that escape sequences are *not* processed, which makes it easy to write, for example, a fully qualified file name:  
   
-```cs  
+```csharp  
 @"c:\Docs\Source\a.txt"  // rather than "c:\\Docs\\Source\\a.txt"  
 ```  
   
  To include a double quotation mark in an @-quoted string, double it:  
   
-```cs  
+```csharp  
 @"""Ahoy!"" cried the captain." // "Ahoy!" cried the captain.  
 ```  
   
diff --git a/docs/csharp/language-reference/keywords/switch.md b/docs/csharp/language-reference/keywords/switch.md
index f19032ab5022e..6d29c333525fa 100644
--- a/docs/csharp/language-reference/keywords/switch.md
+++ b/docs/csharp/language-reference/keywords/switch.md
@@ -54,7 +54,7 @@ It is equivalent to the following example that uses an `if`-`else` construct.
 
 The match expression provides the value to match against the patterns in `case` labels. Its syntax is:
 
-```cs
+```csharp
    switch (expr)
 ```
 
@@ -78,7 +78,7 @@ Starting with C# 7, the match expression can be any non-null expression.
 
  Only one switch section in a switch statement executes. C# does not allow execution to continue from one switch section to the next. Because of this, the following code generates a compiler error, CS0163: "Control cannot fall through from one case label (<case label>) to another."   
 
-```cs  
+```csharp  
 switch (caseSwitch)  
 {  
     // The following switch section causes an error.  
@@ -130,7 +130,7 @@ Each `case` statement defines a pattern that, if it matches the match expression
 
 The constant pattern tests whether the match expression equals a specified constant. Its syntax is:
 
-```cs
+```csharp
    case constant:
 ```
 
@@ -161,7 +161,7 @@ The following example uses the constant pattern to handle user input in a consol
 
 The type pattern enables concise type evaluation and conversion. When used with the `switch` statement to perform pattern matching, it tests whether an expression can be converted to a specified type and, if it can be, casts it to a variable of that type. Its syntax is:
 
-```cs
+```csharp
    case type varname 
 ```
 where *type* is the name of the type to which the result of *expr* is to be converted, and *varname* is the object to which the result of *expr* is converted if the match succeeds. 
@@ -180,7 +180,7 @@ If the case expression is true, *varname* is definitely assigned and has local s
 
 Note that `null` does not match a type. To match a `null`, you use the following `case` label:
 
-```cs
+```csharp
 case null:
 ```
  
diff --git a/docs/csharp/language-reference/keywords/throw.md b/docs/csharp/language-reference/keywords/throw.md
index e85ff4e35abbf..fa3c0e30d91aa 100644
--- a/docs/csharp/language-reference/keywords/throw.md
+++ b/docs/csharp/language-reference/keywords/throw.md
@@ -40,7 +40,7 @@ Signals the occurrence of an exception during program execution.
 
 The syntax of `throw` is:
 
-```cs
+```csharp
 throw [e]
 ```
 where `e` is an instance of a class derived from <xref:System.Exception?displayProperty=fullName>. The following example uses the `throw` statement to throw an @System.IndexOutOfRangeException if the argument passed to a method named `GetNumber` does not correspond to a valid index of an internal array.
diff --git a/docs/csharp/language-reference/keywords/try-catch.md b/docs/csharp/language-reference/keywords/try-catch.md
index 818abbe35d439..bc7904fe11ed8 100644
--- a/docs/csharp/language-reference/keywords/try-catch.md
+++ b/docs/csharp/language-reference/keywords/try-catch.md
@@ -43,7 +43,7 @@ The try-catch statement consists of a `try` block followed by one or more `catch
   
  The `try` block contains the guarded code that may cause the exception. The block is executed until an exception is thrown or it is completed successfully. For example, the following attempt to cast a `null` object raises the <xref:System.NullReferenceException> exception:  
   
-```cs  
+```csharp  
 object o2 = null;  
 try  
 {  
@@ -53,7 +53,7 @@ try
   
  Although the `catch` clause can be used without arguments to catch any type of exception, this usage is not recommended. In general, you should only catch those exceptions that you know how to recover from. Therefore, you should always specify an object argument derived from <xref:System.Exception?displayProperty=fullName> For example:  
   
-```cs  
+```csharp  
 catch (InvalidCastException e)   
 {  
 }  
@@ -63,7 +63,7 @@ catch (InvalidCastException e)
   
  Using `catch` arguments is one way to filter for the exceptions you want to handle.  You can also use a predicate expression that further examines the exception to decide whether to handle it.  If the predicate expression returns false, then the search for a handler continues.  
   
-```cs  
+```csharp  
 catch (ArgumentException e) when (e.ParamName == “…”)  
 {  
 }  
@@ -73,7 +73,7 @@ catch (ArgumentException e) when (e.ParamName == “…”)
   
  A [throw](../../../csharp/language-reference/keywords/throw.md) statement can be used in a `catch` block to re-throw the exception that is caught by the `catch` statement. The following example extracts source information from an <xref:System.IO.IOException> exception, and then throws the exception to the parent method.  
   
-```cs  
+```csharp  
 catch (FileNotFoundException e)  
 {  
     // FileNotFoundExceptions are handled here.  
@@ -90,7 +90,7 @@ catch (IOException e)
   
  You can catch one exception and throw a different exception. When you do this, specify the exception that you caught as the inner exception, as shown in the following example.  
   
-```cs  
+```csharp  
 catch (InvalidCastException e)   
 {  
     // Perform some action here, and then throw a new exception.  
@@ -100,7 +100,7 @@ catch (InvalidCastException e)
   
  You can also re-throw an exception when a specified condition is true, as shown in the following example.  
   
-```cs  
+```csharp  
   
 catch (InvalidCastException e)  
 {  
@@ -117,7 +117,7 @@ catch (InvalidCastException e)
   
  From inside a `try` block, initialize only variables that are declared therein. Otherwise, an exception can occur before the execution of the block is completed. For example, in the following code example, the variable `n` is initialized inside the `try` block. An attempt to use this variable outside the `try` block in the `Write(n)` statement will generate a compiler error.  
   
-```cs  
+```csharp  
 static void Main()   
 {  
     int n;  
diff --git a/docs/csharp/language-reference/keywords/uint.md b/docs/csharp/language-reference/keywords/uint.md
index 74d92c1932e13..97d64eed50fb5 100644
--- a/docs/csharp/language-reference/keywords/uint.md
+++ b/docs/csharp/language-reference/keywords/uint.md
@@ -70,13 +70,13 @@ If an integer literal has no suffix, its type is the first of the following type
 ## Conversions  
  There is a predefined implicit conversion from `uint` to [long](../../../csharp/language-reference/keywords/long.md), [ulong](../../../csharp/language-reference/keywords/ulong.md), [float](../../../csharp/language-reference/keywords/float.md), [double](../../../csharp/language-reference/keywords/double.md), or [decimal](../../../csharp/language-reference/keywords/decimal.md). For example:  
   
-```cs  
+```csharp  
 float myFloat = 4294967290;   // OK: implicit conversion to float  
 ```  
   
  There is a predefined implicit conversion from [byte](../../../csharp/language-reference/keywords/byte.md), [ushort](../../../csharp/language-reference/keywords/ushort.md), or [char](../../../csharp/language-reference/keywords/char.md) to `uint`. Otherwise you must use a cast. For example, the following assignment statement will produce a compilation error without a cast:  
   
-```cs  
+```csharp  
 long aLong = 22;  
 // Error -- no implicit conversion from long:  
 uint uInt1 = aLong;   
@@ -86,7 +86,7 @@ uint uInt2 = (uint)aLong;
   
  Notice also that there is no implicit conversion from floating-point types to `uint`. For example, the following statement generates a compiler error unless an explicit cast is used:  
   
-```cs  
+```csharp  
 // Error -- no implicit conversion from double:  
 uint x = 3.0;  
 // OK -- explicit conversion:  
diff --git a/docs/csharp/language-reference/keywords/ulong.md b/docs/csharp/language-reference/keywords/ulong.md
index 62dc2849764cf..425015d803cef 100644
--- a/docs/csharp/language-reference/keywords/ulong.md
+++ b/docs/csharp/language-reference/keywords/ulong.md
@@ -69,14 +69,14 @@ If an integer literal has no suffix, its type is the first of the following type
   
  A common use of the suffix is with calling overloaded methods. Consider, for example, the following overloaded methods that use `ulong` and [int](../../../csharp/language-reference/keywords/int.md) parameters:  
   
-```cs  
+```csharp  
 public static void SampleMethod(int i) {}  
 public static void SampleMethod(ulong l) {}  
 ```  
   
  Using a suffix with the `ulong` parameter guarantees that the correct type is called, for example:  
   
-```cs  
+```csharp  
 SampleMethod(5);    // Calling the method with the int parameter  
 SampleMethod(5UL);  // Calling the method with the ulong parameter  
 ```  
@@ -86,7 +86,7 @@ SampleMethod(5UL);  // Calling the method with the ulong parameter
   
  There is no implicit conversion from `ulong` to any integral type. For example, the following statement will produce a compilation error without an explicit cast:  
   
-```cs  
+```csharp  
 long long1 = 8UL;   // Error: no implicit conversion from ulong  
 ```  
   
@@ -94,7 +94,7 @@ long long1 = 8UL;   // Error: no implicit conversion from ulong
   
  Also, there is no implicit conversion from floating-point types to `ulong`. For example, the following statement generates a compiler error unless an explicit cast is used:  
   
-```cs  
+```csharp  
 // Error -- no implicit conversion from double:  
 ulong x = 3.0;  
 // OK -- explicit conversion:  
diff --git a/docs/csharp/language-reference/keywords/ushort.md b/docs/csharp/language-reference/keywords/ushort.md
index 2667263963fb0..3e4bd9a9e0eab 100644
--- a/docs/csharp/language-reference/keywords/ushort.md
+++ b/docs/csharp/language-reference/keywords/ushort.md
@@ -58,14 +58,14 @@ Starting with C# 7, you can also use the underscore character, `_`, as a digit s
   
  A cast must be used when you call overloaded methods. Consider, for example, the following overloaded methods that use `ushort` and [int](../../../csharp/language-reference/keywords/int.md) parameters:  
   
-```cs  
+```csharp  
 public static void SampleMethod(int i) {}  
 public static void SampleMethod(ushort s) {}  
 ```  
  
  Using the `ushort` cast guarantees that the correct type is called, for example:  
   
-```cs  
+```csharp  
 // Calls the method with the int parameter:  
 SampleMethod(5);  
 // Calls the method with the ushort parameter:  
@@ -77,32 +77,32 @@ SampleMethod((ushort)5);
   
  There is a predefined implicit conversion from [byte](../../../csharp/language-reference/keywords/byte.md) or [char](../../../csharp/language-reference/keywords/char.md) to `ushort`. Otherwise a cast must be used to perform an explicit conversion. Consider, for example, the following two `ushort` variables `x` and `y`:  
   
-```cs 
+```csharp 
 ushort x = 5, y = 12;  
 ```  
   
  The following assignment statement will produce a compilation error, because the arithmetic expression on the right side of the assignment operator evaluates to `int` by default.  
   
-```cs  
+```csharp  
 ushort z = x + y;   // Error: conversion from int to ushort  
 ```  
   
  To fix this problem, use a cast:  
   
-```cs 
+```csharp 
 ushort z = (ushort)(x + y);   // OK: explicit conversion   
 ```  
   
  It is possible though to use the following statements, where the destination variable has the same storage size or a larger storage size:  
   
-```cs
+```csharp
 int m = x + y;  
 long n = x + y;  
 ```  
   
  Notice also that there is no implicit conversion from floating-point types to `ushort`. For example, the following statement generates a compiler error unless an explicit cast is used:  
   
-```cs  
+```csharp  
 // Error -- no implicit conversion from double:  
 ushort x = 3.0;   
 // OK -- explicit conversion:  
diff --git a/docs/csharp/language-reference/keywords/using-directive.md b/docs/csharp/language-reference/keywords/using-directive.md
index b1d98787d0088..65220ed2005e6 100644
--- a/docs/csharp/language-reference/keywords/using-directive.md
+++ b/docs/csharp/language-reference/keywords/using-directive.md
@@ -33,13 +33,13 @@ The `using` directive has three uses:
   
 -   To allow the use of types in a namespace so that you do not have to qualify the use of a type in that namespace:  
   
-    ```cs  
+    ```csharp  
     using System.Text;  
     ```  
   
 -   To allow you to access static members of a type without having to qualify the access with the type name. 
   
-    ```cs  
+    ```csharp  
     using static System.Math;  
     ```  
      
@@ -47,7 +47,7 @@ The `using` directive has three uses:
 
 -   To create an alias for a namespace or a type. This is called a *using alias directive*.  
   
-    ```cs  
+    ```csharp  
     using Project = PC.MyCompany.Project;  
     ```  
   
@@ -56,7 +56,7 @@ The `using` directive has three uses:
 ## Using Static Type  
  You can access static members of a type without having to qualify the access with the type name:  
   
-```cs  
+```csharp  
 using static System.Console;   
 using static System.Math;  
 class Program   
diff --git a/docs/csharp/language-reference/keywords/using-static.md b/docs/csharp/language-reference/keywords/using-static.md
index 9de26666c6a4d..2a12f9daf483d 100644
--- a/docs/csharp/language-reference/keywords/using-static.md
+++ b/docs/csharp/language-reference/keywords/using-static.md
@@ -31,7 +31,7 @@ translation.priority.ht:
 
 The `using static` directive designates a type whose static members you can access without specifying a type name. Its syntax is:
 
-```cs
+```csharp
 using static <fully-qualified-type-name>
 ```
 
diff --git a/docs/csharp/language-reference/keywords/when.md b/docs/csharp/language-reference/keywords/when.md
index 9ee9d5f26e287..a06872dfec43b 100644
--- a/docs/csharp/language-reference/keywords/when.md
+++ b/docs/csharp/language-reference/keywords/when.md
@@ -42,7 +42,7 @@ You can use the `when` contextual keyword to specify a filter condition in two c
 
 Starting with C# 6, `When` can be used in a `catch` statement to specify a condition that must be true for the handler for a specific exception to execute. Its syntax is:
 
-```cs
+```csharp
 catch ExceptionType [e] when (expr)
 ```
 where *expr* is an expression that evaluates to a Boolean value. If it returns `true`, the exception handler executes; if `false`, it does not. 
@@ -55,7 +55,7 @@ The following example uses the `when` keyword to conditionally execute handlers
 
 Starting with 7, `case` labels no longer need be mutually exclusive, and the order in which `case` labels appear in a `switch` statement can determine which switch block executes. The `when` keyword can be used to specify a filter condition that causes its associated case label to be true only if the filter condition is also true. Its syntax is:
 
-```cs
+```csharp
 case (expr) where (when-condition):
 ```
 where *expr* is a constant pattern or type pattern that is compared to the match expression, and *when-condition* is any Boolean expression. 
diff --git a/docs/csharp/language-reference/keywords/where-generic-type-constraint.md b/docs/csharp/language-reference/keywords/where-generic-type-constraint.md
index a9fd3fd892aed..24b046414388e 100644
--- a/docs/csharp/language-reference/keywords/where-generic-type-constraint.md
+++ b/docs/csharp/language-reference/keywords/where-generic-type-constraint.md
@@ -34,7 +34,7 @@ translation.priority.ht:
 # where (generic type constraint) (C# Reference)
 In a generic type definition, the `where` clause is used to specify constraints on the types that can be used as arguments for a type parameter defined in a generic declaration. For example, you can declare a generic class, `MyGenericClass`, such that the type parameter `T` implements the <xref:System.IComparable%601> interface:  
   
-```cs  
+```csharp  
 public class MyGenericClass<T> where T:IComparable { }  
 ```  
   
@@ -57,13 +57,13 @@ public class MyGenericClass<T> where T:IComparable { }
   
  You can also attach constraints to type parameters of generic methods, like this:  
   
-```cs  
+```csharp  
 public bool MyMethod<T>(T t) where T : IMyInterface { }  
 ```  
   
  Notice that the syntax to describe type parameter constraints on delegates is the same as that of methods:  
   
-```cs  
+```csharp  
 delegate T MyDelegate<T>() where T : new()  
 ```  
   
diff --git a/docs/csharp/language-reference/keywords/yield.md b/docs/csharp/language-reference/keywords/yield.md
index 867e3d8599dd2..6f02119340bc1 100644
--- a/docs/csharp/language-reference/keywords/yield.md
+++ b/docs/csharp/language-reference/keywords/yield.md
@@ -36,7 +36,7 @@ When you use the `yield` keyword in a statement, you indicate that the method, o
   
  The following example shows the two forms of the `yield` statement.  
   
-```cs  
+```csharp  
 yield return <expression>;  
 yield break;  
 ```  
@@ -75,7 +75,7 @@ yield break;
 ## Technical Implementation  
  The following code returns an `IEnumerable<string>` from an iterator method and then iterates through its elements.  
   
-```cs  
+```csharp  
 IEnumerable<string> elements = MyIteratorMethod();  
 foreach (string element in elements)  
 {  
diff --git a/docs/csharp/language-reference/operators/lambda-operator.md b/docs/csharp/language-reference/operators/lambda-operator.md
index f65714c568bdd..076d0786ee491 100644
--- a/docs/csharp/language-reference/operators/lambda-operator.md
+++ b/docs/csharp/language-reference/operators/lambda-operator.md
@@ -38,7 +38,7 @@ The `=>` token is called the lambda operator. It is used in *lambda expressions*
   
  The following example shows two ways to find and display the length of the shortest string in an array of strings. The first part of the example applies a lambda expression (`w => w.Length`) to each element of the `words` array and then uses the <xref:System.Linq.Enumerable.Min%2A> method to find the smallest length. For comparison, the second part of the example shows a longer solution that uses query syntax to do the same thing.  
   
-```cs  
+```csharp  
 string[] words = { "cherry", "apple", "blueberry" };  
   
 // Use method syntax to apply a lambda expression to each element  
@@ -64,14 +64,14 @@ Console.WriteLine(shortestWordLength2);
   
  You can specify the type of the input variable explicitly or let the compiler infer it; in either case, the variable is strongly typed at compile time. When you specify a type, you must enclose the type name and the variable name in parentheses, as the following example shows.  
   
-```cs  
+```csharp  
 int shortestWordLength = words.Min((string w) => w.Length);  
 ```  
   
 ## Example  
  The following example shows how to write a lambda expression for the overload of the standard query operator <xref:System.Linq.Enumerable.Where%2A?displayProperty=fullName> that takes two arguments. Because the lambda expression has more than one parameter, the parameters must be enclosed in parentheses. The second parameter, `index`, represents the index of the current element in the collection. The `Where` expression returns all the strings whose lengths are less than their index positions in the array.  
   
-```cs  
+```csharp  
 static void Main(string[] args)  
 {  
     string[] digits = { "zero", "one", "two", "three", "four", "five",   
diff --git a/docs/csharp/language-reference/operators/null-conditional-operators.md b/docs/csharp/language-reference/operators/null-conditional-operators.md
index 8c054d4c879d3..39a85ea2bd4d3 100644
--- a/docs/csharp/language-reference/operators/null-conditional-operators.md
+++ b/docs/csharp/language-reference/operators/null-conditional-operators.md
@@ -29,7 +29,7 @@ translation.priority.ht:
 # Null-conditional Operators (C# and Visual Basic)
 Used to test for null before performing a member access (`?.`) or index (`?[`) operation.  These operators help you write less code to handle null checks, especially for descending into data structures.  
   
-```cs  
+```csharp  
 int? length = customers?.Length; // null if customers is null   
 Customer first = customers?[0];  // null if customers is null  
 int? count = customers?[0]?.Orders?.Count();  // null if customers, the first customer, or Orders is null  
@@ -53,7 +53,7 @@ A?.B?.C?[0] == E
   
  Another use for the null-condition member access is invoking delegates in a thread-safe way with much less code.  The old way requires code like the following:  
   
-```cs  
+```csharp  
 var handler = this.PropertyChanged;  
 if (handler != null)  
     handler(…)  
diff --git a/docs/csharp/language-reference/preprocessor-directives/preprocessor-define.md b/docs/csharp/language-reference/preprocessor-directives/preprocessor-define.md
index e1d47095f73fd..3bac2de04d072 100644
--- a/docs/csharp/language-reference/preprocessor-directives/preprocessor-define.md
+++ b/docs/csharp/language-reference/preprocessor-directives/preprocessor-define.md
@@ -52,7 +52,7 @@ You use `#define` to define a symbol. When you use the symbol as the expression
   
  As the following example shows, you must put `#define` directives at the top of the file.  
   
-```cs  
+```csharp  
 #define DEBUG  
 //#define TRACE  
 #undef TRACE  
diff --git a/docs/csharp/language-reference/tokens/verbatim.md b/docs/csharp/language-reference/tokens/verbatim.md
index db1524b9f9686..b0f3f51105adb 100644
--- a/docs/csharp/language-reference/tokens/verbatim.md
+++ b/docs/csharp/language-reference/tokens/verbatim.md
@@ -49,7 +49,7 @@ The `@` special character serves as a verbatim identifier. It can be used in the
 
 1. To enable the compiler to distinguish between attributes in cases of a naming conflict. An attribute is a type that derives from @System.Attribute. Its type name typically includes the suffix **Attribute**, although the compiler does not enforce this convention. The attribute can then be referenced in code either by its full type name (for example, `[InfoAttribute]` or its shortened name (for example, `[Info]`). However, a naming conflict occurs if two shortened attribute type names are identical, and one type name includes the **Attribute** suffix but the other does not. For example, the following code fails to compile because the compiler cannot determine whether the `Info` or `InfoAttribute` attribute is applied to the `Main` method.
 
-   ```cs
+   ```csharp
    using System;
 
    [AttributeUsage(AttributeTargets.Class)]
diff --git a/docs/csharp/linq/dynamically-specify-predicate-filters-at-runtime.md b/docs/csharp/linq/dynamically-specify-predicate-filters-at-runtime.md
index 57f6b0ff93b0f..4a0142282e838 100644
--- a/docs/csharp/linq/dynamically-specify-predicate-filters-at-runtime.md
+++ b/docs/csharp/linq/dynamically-specify-predicate-filters-at-runtime.md
@@ -30,7 +30,7 @@ In some cases you do not know until run time how many predicates you have to app
   
 5.  Add the following line to the `Main` method in class `DynamicPredicates`, under the declaration of `ids`.  
   
-     ```cs
+     ```csharp
      QueryById(ids);
      ```
 
diff --git a/docs/csharp/linq/join-by-using-composite-keys.md b/docs/csharp/linq/join-by-using-composite-keys.md
index e3431e0c0a414..251906e783922 100644
--- a/docs/csharp/linq/join-by-using-composite-keys.md
+++ b/docs/csharp/linq/join-by-using-composite-keys.md
@@ -19,7 +19,7 @@ This example shows how to perform join operations in which you want to use more
 ## Example  
  The following example demonstrates how to use a composite key to join data from three tables:  
   
-```cs  
+```csharp  
 var query = from o in db.Orders  
     from p in db.Products  
     join d in db.OrderDetails   
@@ -30,7 +30,7 @@ var query = from o in db.Orders
   
  Type inference on composite keys depends on the names of the properties in the keys, and the order in which they occur. If the properties in the source sequences do not have the same names, you must assign new names in the keys. For example, if the `Orders` table and `OrderDetails` table each used different names for their columns, you could create composite keys by assigning identical names in the anonymous types:  
   
-```cs  
+```csharp  
 join...on new {Name = o.CustomerName, ID = o.CustID} equals   
     new {Name = d.CustName, ID = d.CustID }  
 ```  
diff --git a/docs/csharp/linq/write-linq-queries.md b/docs/csharp/linq/write-linq-queries.md
index 3c03e0d7834c1..d09b9ddc603a2 100644
--- a/docs/csharp/linq/write-linq-queries.md
+++ b/docs/csharp/linq/write-linq-queries.md
@@ -70,19 +70,19 @@ This topic shows the three ways in which you can write a LINQ query in C#:
   
  The previous query can be written by using implicit typing with `var`, as follows:  
   
-```cs  
+```csharp  
 var numCount = (from num in numbers...  
 ```  
   
  It can be written in method syntax as follows:  
   
-```cs  
+```csharp  
 var numCount = numbers.Where(n => n < 3 || n > 7).Count();  
 ```  
   
  It can be written by using explicit typing, as follows:  
   
-```cs  
+```csharp  
 int numCount = numbers.Where(n => n < 3 || n > 7).Count();  
 ```  
   
diff --git a/docs/csharp/methods.md b/docs/csharp/methods.md
index 3ab8b62b43336..f12d3125de504 100644
--- a/docs/csharp/methods.md
+++ b/docs/csharp/methods.md
@@ -192,7 +192,7 @@ Using a local variable, in this case, `result`, to store a value is optional. It
 
 Sometimes, you want your method to return more than a single value. Starting with C# 7.0, you can do this easily by using *tuple types* and *tuple literals*. The tuple type defines the data types of the tuple's elements. Tuple literals provide the actual values of the returned tuple. In teh following example, `(string, string, string, int)` defines the tuple type that is returned by the `GetPersonalInfo` method. The expression `(per.FirstName, per.MiddleName, per.LastName, per.Age)` is the tuple literal; the method returns the first, middle, and last name, along with the age, of a `PersonInfo` object.
 
-```cs
+```csharp
 public (string, string, string, int) GetPersonalInfo(string id)
 {
     PersonInfo per = PersonInfo.RetrieveInfoById(id);
@@ -205,7 +205,7 @@ public (string, string, string, int) GetPersonalInfo(string id)
 
 The caller can then consume the returned tuple with code like the following:
 
-```cs
+```csharp
 var person = GetPersonalInfo("111111111")
 if (person != null)
    Console.WriteLine("{person.Item1} {person.Item3}: age = {person.Item4}");
@@ -213,7 +213,7 @@ if (person != null)
 
 Names can also be assigned to the tuple elements in the tuple type definition. The following example shows an alternate version of the `GetPersonalInfo` method that uses named elements:
 
-```cs
+```csharp
 public (string FName, string MName, string LName, int Age) GetPersonalInfo(string id)
 {
     PersonInfo per = PersonInfo.RetrieveInfoById(id);
@@ -226,7 +226,7 @@ public (string FName, string MName, string LName, int Age) GetPersonalInfo(strin
 
 The previous call to the `GetPersonInfo` method can then be modified as follows:
 
-```cs
+```csharp
 var person = GetPersonalInfo("111111111");
 if (person != null)
    Console.WriteLine("{person.FName} {person.LName}: age = {person.Age}");
@@ -273,7 +273,7 @@ An async method can't declare any [ref](https://msdn.microsoft.com/library/14akc
 
 It is common to have method definitions that simply return immediately with the result of an expression, or that have a single statement as the body of the method.  There is a syntax shortcut for defining such methods using `=>`:
 
-```cs
+```csharp
 
 public Point Move(int dx, int dy) => new Point(x + dx, y + dy);
 public void Print() => Console.WriteLine(First + " " + Last);
diff --git a/docs/csharp/misc/cs0168.md b/docs/csharp/misc/cs0168.md
index 555ebc4477042..9be6e5884e8ac 100644
--- a/docs/csharp/misc/cs0168.md
+++ b/docs/csharp/misc/cs0168.md
@@ -37,7 +37,7 @@ The compiler issues a level-three warning when you declare a variable, but do no
   
 The following sample generates a CS0168 warning:  
   
-```cs
+```csharp
 // CS0168.cs  
 // compile with: /W:3  
 public class clx
diff --git a/docs/csharp/misc/cs0415.md b/docs/csharp/misc/cs0415.md
index d4d659ba9f1aa..064d0eb87b1e5 100644
--- a/docs/csharp/misc/cs0415.md
+++ b/docs/csharp/misc/cs0415.md
@@ -43,7 +43,7 @@ The 'IndexerName' attribute is valid only on an indexer that is not an explicit
   
  The following sample generates CS0415:  
   
-```cs
+```csharp
 // CS0415.cs  
 using System;  
 using System.Runtime.CompilerServices;  
diff --git a/docs/csharp/misc/cs0428.md b/docs/csharp/misc/cs0428.md
index 10f1871afe796..d42a2b3ec18a7 100644
--- a/docs/csharp/misc/cs0428.md
+++ b/docs/csharp/misc/cs0428.md
@@ -44,7 +44,7 @@ Cannot convert method group 'Identifier' to non-delegate type 'type'.  Did you
 ## Example  
  The following sample generates CS0428:  
   
-```cs  
+```csharp  
 // CS0428.cs  
 namespace ConsoleApplication1  
 {  
diff --git a/docs/csharp/misc/cs0542.md b/docs/csharp/misc/cs0542.md
index ddd524215204e..9d64aa0c3864d 100644
--- a/docs/csharp/misc/cs0542.md
+++ b/docs/csharp/misc/cs0542.md
@@ -43,7 +43,7 @@ translation.priority.mt:
   
  The following sample generates CS0542:  
   
-```cs  
+```csharp  
 // CS0542.cs  
 class C  
 {  
@@ -53,7 +53,7 @@ class C
   
  This error might be caused if you inadvertently put a return type on a constructor, which in effect makes it into an ordinary method. The following example generates CS0542 because `F` is a method, not a constructor, because it has a return type:  
   
-```cs  
+```csharp  
 // CS0542.cs  
 class F  
 {  
@@ -73,7 +73,7 @@ class MyClass
   
  If your class is named 'Item' and has an indexer declared as `this`, you may get this error. A default indexer is given the name 'Item' in the emitted code, creating the conflict.  
   
-```cs  
+```csharp  
 // CS0542b.cs  
 class Item  
 {  
diff --git a/docs/csharp/misc/cs0625.md b/docs/csharp/misc/cs0625.md
index 4db51fecf0730..25785a8d50785 100644
--- a/docs/csharp/misc/cs0625.md
+++ b/docs/csharp/misc/cs0625.md
@@ -43,7 +43,7 @@ When a struct is marked with an explicit **StructLayout** attribute, all fields
 
 The following sample generates CS0625:  
   
-```cs  
+```csharp  
 // CS0625.cs  
 // compile with: /target:library  
 using System;  
diff --git a/docs/csharp/misc/cs0626.md b/docs/csharp/misc/cs0626.md
index c88d22943806d..f8190d3b87426 100644
--- a/docs/csharp/misc/cs0626.md
+++ b/docs/csharp/misc/cs0626.md
@@ -45,7 +45,7 @@ Method, operator, or accessor 'method' is marked external and has no attributes
   
  The following sample generates CS0626:  
   
-```cs
+```csharp
 // CS0626.cs  
 // compile with: /warnaserror  
 using System.Runtime.InteropServices;  
diff --git a/docs/csharp/misc/cs0662.md b/docs/csharp/misc/cs0662.md
index 95719ef955717..e945b69c78e0a 100644
--- a/docs/csharp/misc/cs0662.md
+++ b/docs/csharp/misc/cs0662.md
@@ -43,7 +43,7 @@ translation.priority.mt:
   
  The following sample generates CS0662:  
   
-```cs
+```csharp
 // CS0662.cs  
 using System.Runtime.InteropServices;  
   
diff --git a/docs/csharp/misc/cs0664.md b/docs/csharp/misc/cs0664.md
index 6456ce77c6f62..8922b5cced9c1 100644
--- a/docs/csharp/misc/cs0664.md
+++ b/docs/csharp/misc/cs0664.md
@@ -43,7 +43,7 @@ Literal of type double cannot be implicitly converted to type 'type'; use an 'su
   
  The following sample generates CS0664:  
   
-```cs  
+```csharp  
 // CS0664.cs  
 class Example  
 {  
diff --git a/docs/csharp/misc/cs0668.md b/docs/csharp/misc/cs0668.md
index 74f3f862e034a..1a434d74e547b 100644
--- a/docs/csharp/misc/cs0668.md
+++ b/docs/csharp/misc/cs0668.md
@@ -43,7 +43,7 @@ Two indexers have different names; the IndexerName attribute must be used with t
   
  The following sample generates CS0668:  
   
-```cs
+```csharp
 // CS0668.cs  
 using System;  
 using System.Runtime.CompilerServices;  
diff --git a/docs/csharp/misc/cs0669.md b/docs/csharp/misc/cs0669.md
index 4f38a306f5534..597afe8ea4c27 100644
--- a/docs/csharp/misc/cs0669.md
+++ b/docs/csharp/misc/cs0669.md
@@ -43,7 +43,7 @@ A class with the ComImport attribute cannot have a user-defined constructor.
   
  The following sample generates CS0669:  
   
-```cs
+```csharp
 // CS0669.cs  
 using System.Runtime.InteropServices;  
 [ComImport, Guid("00000000-0000-0000-0000-000000000001")]  
diff --git a/docs/csharp/misc/cs1944.md b/docs/csharp/misc/cs1944.md
index e78ab395f4f57..749adade180b6 100644
--- a/docs/csharp/misc/cs1944.md
+++ b/docs/csharp/misc/cs1944.md
@@ -48,7 +48,7 @@ An expression tree may not contain an unsafe pointer operation
 ## Example  
  The following example generates CS1944:  
   
-```cs  
+```csharp  
 // cs1944.cs  
 // Compile with: /unsafe  
 using System.Linq.Expressions;  
diff --git a/docs/csharp/modern-events.md b/docs/csharp/modern-events.md
index 92480a3c1eb6f..cdca8855a3b25 100644
--- a/docs/csharp/modern-events.md
+++ b/docs/csharp/modern-events.md
@@ -36,7 +36,7 @@ The program will work exactly the same.
 You could also change the `SearchDirectoryArgs` to a struct, if you
 also make one more change:
 
-```cs  
+```csharp  
 internal struct SearchDirectoryArgs  
 {  
     internal string CurrentSearchDirectory { get; }  
@@ -92,7 +92,7 @@ You need to reconcile this opposing guidance. Somehow, you must
 create a safe `async void` method. The basics of the pattern you need
 to implement are below:
 
-```cs
+```csharp
 worker.StartWorking += async (sender, eventArgs) =>
 {
     try 
diff --git a/docs/csharp/programming-guide/classes-and-structs/anonymous-types.md b/docs/csharp/programming-guide/classes-and-structs/anonymous-types.md
index 8a9918e80e603..3bbaa0f2cb4e1 100644
--- a/docs/csharp/programming-guide/classes-and-structs/anonymous-types.md
+++ b/docs/csharp/programming-guide/classes-and-structs/anonymous-types.md
@@ -41,7 +41,7 @@ Anonymous types provide a convenient way to encapsulate a set of read-only prope
   
  The following example shows an anonymous type that is initialized with two properties named `Amount` and `Message`.  
   
-```cs  
+```csharp  
   
 var v = new { Amount = 108, Message = "Hello" };  
   
@@ -65,7 +65,7 @@ Console.WriteLine(v.Amount + v.Message);
   
  You can create an array of anonymously typed elements by combining an implicitly typed local variable and an implicitly typed array, as shown in the following example.  
   
-```cs  
+```csharp  
 var anonArray = new[] { new { name = "apple", diam = 4 }, new { name = "grape", diam = 1 }};  
 ```  
   
diff --git a/docs/csharp/programming-guide/classes-and-structs/auto-implemented-properties.md b/docs/csharp/programming-guide/classes-and-structs/auto-implemented-properties.md
index 35faac02c655e..8b34d354653f8 100644
--- a/docs/csharp/programming-guide/classes-and-structs/auto-implemented-properties.md
+++ b/docs/csharp/programming-guide/classes-and-structs/auto-implemented-properties.md
@@ -44,7 +44,7 @@ In C# 3.0 and later, auto-implemented properties make property-declaration more
   
  In C# 6 and later, you can initialize auto-implemented properties similarly to fields:  
   
-```cs  
+```csharp  
 public string FirstName { get; set; } = "Jane";  
 ```  
   
diff --git a/docs/csharp/programming-guide/classes-and-structs/how-to-access-a-collection-class-with-foreach.md b/docs/csharp/programming-guide/classes-and-structs/how-to-access-a-collection-class-with-foreach.md
index 3776536625f72..24348a18014d5 100644
--- a/docs/csharp/programming-guide/classes-and-structs/how-to-access-a-collection-class-with-foreach.md
+++ b/docs/csharp/programming-guide/classes-and-structs/how-to-access-a-collection-class-with-foreach.md
@@ -52,7 +52,7 @@ The following code example illustrates how to write a non-generic collection cla
   
  For example, change the following lines in the previous example.  
   
-```cs  
+```csharp  
   
 // Change the Tokens class so that it no longer implements IEnumerable.  
 public class Tokens  
@@ -78,7 +78,7 @@ public class Tokens
   
  Because `Current` returns a string, the compiler can detect when an incompatible type is used in a `foreach` statement, as shown in the following code.  
   
-```cs  
+```csharp  
   
 // Error: Cannot convert type string to int.  
 foreach (int item in f)    
diff --git a/docs/csharp/programming-guide/classes-and-structs/how-to-implement-a-lightweight-class-with-auto-implemented-properties.md b/docs/csharp/programming-guide/classes-and-structs/how-to-implement-a-lightweight-class-with-auto-implemented-properties.md
index 9c2f34673da18..c181dddf2c989 100644
--- a/docs/csharp/programming-guide/classes-and-structs/how-to-implement-a-lightweight-class-with-auto-implemented-properties.md
+++ b/docs/csharp/programming-guide/classes-and-structs/how-to-implement-a-lightweight-class-with-auto-implemented-properties.md
@@ -44,7 +44,7 @@ This example shows how to create an immutable lightweight class that serves only
 ## Example  
  The following example shows two ways to implement an immutable class that has auto-implemented properties. Each way declares one of the properties with a private `set` and one of the properties with a `get` only.  The first class uses a constructor only to initialize the properties, and the second class uses a static factory method that calls a constructor.  
   
-```cs  
+```csharp  
 // This class is immutable. After an object is created,   
     // it cannot be modified from outside the class. It uses a   
     // constructor to initialize its properties.   
diff --git a/docs/csharp/programming-guide/classes-and-structs/how-to-override-the-tostring-method.md b/docs/csharp/programming-guide/classes-and-structs/how-to-override-the-tostring-method.md
index 49abc29a7d23b..6eb20dcfd2c4d 100644
--- a/docs/csharp/programming-guide/classes-and-structs/how-to-override-the-tostring-method.md
+++ b/docs/csharp/programming-guide/classes-and-structs/how-to-override-the-tostring-method.md
@@ -50,7 +50,7 @@ Every class or struct in C# implicitly inherits the <xref:System.Object> class.
   
 1.  Declare a `ToString` method with the following modifiers and return type:  
   
-    ```cs  
+    ```csharp  
     public override string ToString(){}  
     ```  
   
diff --git a/docs/csharp/programming-guide/classes-and-structs/knowing-when-to-use-override-and-new-keywords.md b/docs/csharp/programming-guide/classes-and-structs/knowing-when-to-use-override-and-new-keywords.md
index 3fd1d6ed8763d..3873d2fa0643c 100644
--- a/docs/csharp/programming-guide/classes-and-structs/knowing-when-to-use-override-and-new-keywords.md
+++ b/docs/csharp/programming-guide/classes-and-structs/knowing-when-to-use-override-and-new-keywords.md
@@ -40,7 +40,7 @@ In C#, a method in a derived class can have the same name as a method in the bas
   
  In a console application, declare the following two classes, `BaseClass` and `DerivedClass`. `DerivedClass` inherits from `BaseClass`.  
   
-```cs  
+```csharp  
 class BaseClass  
 {  
     public void Method1()  
@@ -69,7 +69,7 @@ class DerivedClass : BaseClass
   
  Because `bc` and `bcdc` have type `BaseClass`, they can only directly access `Method1`, unless you use casting. Variable `dc` can access both `Method1` and `Method2`. These relationships are shown in the following code.  
   
-```cs  
+```csharp  
 class Program  
 {  
     static void Main(string[] args)  
@@ -94,7 +94,7 @@ class Program
   
  Next, add the following `Method2` method to `BaseClass`. The signature of this method matches the signature of the `Method2` method in `DerivedClass`.  
   
-```cs  
+```csharp  
 public void Method2()  
 {  
     Console.WriteLine("Base - Method2");  
@@ -104,7 +104,7 @@ public void Method2()
   
  Because `BaseClass` now has a `Method2` method, a second calling statement can be added for `BaseClass` variables `bc` and `bcdc`, as shown in the following code.  
   
-```cs  
+```csharp  
 bc.Method1();  
 bc.Method2();  
 dc.Method1();  
@@ -118,7 +118,7 @@ bcdc.Method2();
   
  Before adding `new`, run the program to see the output produced by the additional calling statements. The following results are displayed.  
   
-```cs  
+```csharp  
 // Output:  
 // Base - Method1  
 // Base - Method2  
@@ -133,7 +133,7 @@ bcdc.Method2();
   
  To suppress the warning, add the `new` modifier to the definition of `Method2` in `DerivedClass`, as shown in the following code. The modifier can be added before or after `public`.  
   
-```cs  
+```csharp  
 public new void Method2()  
 {  
     Console.WriteLine("Derived - Method2");  
@@ -145,7 +145,7 @@ public new void Method2()
   
  To contrast this behavior to the effects of using `override`, add the following method to `DerivedClass`. The `override` modifier can be added before or after `public`.  
   
-```cs  
+```csharp  
 public override void Method1()  
 {  
     Console.WriteLine("Derived - Method1");  
@@ -155,7 +155,7 @@ public override void Method1()
   
  Add the `virtual` modifier to the definition of `Method1` in `BaseClass`. The `virtual` modifier can be added before or after `public`.  
   
-```cs  
+```csharp  
 public virtual void Method1()  
 {  
     Console.WriteLine("Base - Method1");  
@@ -165,7 +165,7 @@ public virtual void Method1()
   
  Run the project again. Notice especially the last two lines of the following output.  
   
-```cs  
+```csharp  
 // Output:  
 // Base - Method1  
 // Base - Method2  
@@ -180,7 +180,7 @@ public virtual void Method1()
   
  The following code contains the full example.  
   
-```cs  
+```csharp  
 using System;  
 using System.Text;  
   
@@ -251,7 +251,7 @@ namespace OverrideAndNew
   
  The following example illustrates similar behavior in a different context. The example defines three classes: a base class named `Car` and two classes that are derived from it, `ConvertibleCar` and `Minivan`. The base class contains a `DescribeCar` method. The method displays a basic description of a car, and then calls `ShowDetails` to provide additional information. Each of the three classes defines a `ShowDetails` method. The `new` modifier is used to define `ShowDetails` in the `ConvertibleCar` class. The `override` modifier is used to define `ShowDetails` in the `Minivan` class.  
   
-```cs  
+```csharp  
 // Define the base class, Car. The class defines two methods,  
 // DescribeCar and ShowDetails. DescribeCar calls ShowDetails, and each derived  
 // class also defines a ShowDetails method. The example tests which version of  
@@ -296,7 +296,7 @@ class Minivan : Car
   
  The example tests which version of `ShowDetails` is called. The following method, `TestCars1`, declares an instance of each class, and then calls `DescribeCar` on each instance.  
   
-```cs  
+```csharp  
 public static void TestCars1()  
 {  
     System.Console.WriteLine("\nTestCars1");  
@@ -323,7 +323,7 @@ public static void TestCars1()
   
  `TestCars1` produces the following output. Notice especially the results for `car2`, which probably are not what you expected. The type of the object is `ConvertibleCar`, but `DescribeCar` does not access the version of `ShowDetails` that is defined in the `ConvertibleCar` class because that method is declared with the `new` modifier, not the `override` modifier. As a result, a `ConvertibleCar` object displays the same description as a `Car` object. Contrast the results for `car3`, which is a `Minivan` object. In this case, the `ShowDetails` method that is declared in the `Minivan` class overrides the `ShowDetails` method that is declared in the `Car` class, and the description that is displayed describes a minivan.  
   
-```cs  
+```csharp  
   
 // TestCars1  
 // ----------  
@@ -341,7 +341,7 @@ public static void TestCars1()
   
  `TestCars2` creates a list of objects that have type `Car`. The values of the objects are instantiated from the `Car`, `ConvertibleCar`, and `Minivan` classes. `DescribeCar` is called on each element of the list. The following code shows the definition of `TestCars2`.  
   
-```cs  
+```csharp  
 public static void TestCars2()  
 {  
     System.Console.WriteLine("\nTestCars2");  
@@ -361,7 +361,7 @@ public static void TestCars2()
   
  The following output is displayed. Notice that it is the same as the output that is displayed by `TestCars1`. The `ShowDetails` method of the `ConvertibleCar` class is not called, regardless of whether the type of the object is `ConvertibleCar`, as in `TestCars1`, or `Car`, as in `TestCars2`. Conversely, `car3` calls the `ShowDetails` method from the `Minivan` class in both cases, whether it has type `Minivan` or type `Car`.  
   
-```cs  
+```csharp  
 // TestCars2  
 // ----------  
 // Four wheels and an engine.  
@@ -378,7 +378,7 @@ public static void TestCars2()
   
  Methods `TestCars3` and `TestCars4` complete the example. These methods call `ShowDetails` directly, first from objects declared to have type `ConvertibleCar` and `Minivan` (`TestCars3`), then from objects declared to have type `Car` (`TestCars4`). The following code defines these two methods.  
   
-```cs  
+```csharp  
   
 public static void TestCars3()  
 {  
@@ -404,7 +404,7 @@ public static void TestCars4()
   
  The methods produce the following output, which corresponds to the results from the first example in this topic.  
   
-```cs  
+```csharp  
 // TestCars3  
 // ----------  
 // A roof that opens up.  
@@ -419,7 +419,7 @@ public static void TestCars4()
   
  The following code shows the complete project and its output.  
   
-```cs  
+```csharp  
 using System;  
 using System.Collections.Generic;  
 using System.Linq;  
diff --git a/docs/csharp/programming-guide/classes-and-structs/methods.md b/docs/csharp/programming-guide/classes-and-structs/methods.md
index 8e361d8cb9269..6d12f3941e72e 100644
--- a/docs/csharp/programming-guide/classes-and-structs/methods.md
+++ b/docs/csharp/programming-guide/classes-and-structs/methods.md
@@ -93,7 +93,7 @@ A method is a code block that contains a series of statements. A program causes
   
  Returning a multi-dimensional array from a method, M, that modifies the array's contents is not necessary if the calling function passed the array into M.  You may return the resulting array from M for good style or functional flow of values, but it is not necessary.  The reason you do not need to return the modified array is that C# passes all reference types by value, and the value of an array reference is the pointer to the array. In the method M, any changes to the array's contents are observable by any code that has a reference to the array, as shown in the following example.  
   
-```cs  
+```csharp  
 static void Main(string[] args)  
         {  
             int[,] matrix = new int[2, 2];  
@@ -139,7 +139,7 @@ static void Main(string[] args)
 ## Expression Body Definitions  
  It is common to have method definitions that simply return immediately with the result of an expression, or that have a single statement as the body of the method.  There is a syntax shortcut for defining such methods using `=>`:  
   
-```cs  
+```csharp  
 public Point Move(int dx, int dy) => new Point(x + dx, y + dy);   
 public void Print() => Console.WriteLine(First + " " + Last);  
 // Works with operators, properties, and indexers too.  
diff --git a/docs/csharp/programming-guide/classes-and-structs/static-classes-and-static-class-members.md b/docs/csharp/programming-guide/classes-and-structs/static-classes-and-static-class-members.md
index 284dd233067b1..6fe489dbe9f91 100644
--- a/docs/csharp/programming-guide/classes-and-structs/static-classes-and-static-class-members.md
+++ b/docs/csharp/programming-guide/classes-and-structs/static-classes-and-static-class-members.md
@@ -40,7 +40,7 @@ translation.priority.ht:
 # Static Classes and Static Class Members (C# Programming Guide)
 A [static](../../../csharp/language-reference/keywords/static.md) class is basically the same as a non-static class, but there is one difference: a static class cannot be instantiated. In other words, you cannot use the [new](../../../csharp/language-reference/keywords/new.md) keyword to create a variable of the class type. Because there is no instance variable, you access the members of a static class by using the class name itself. For example, if you have a static class that is named `UtilityClass` that has a public method named `MethodA`, you call the method as shown in the following example:  
   
-```cs  
+```csharp  
 UtilityClass.MethodA();  
 ```  
   
diff --git a/docs/csharp/programming-guide/concepts/assemblies-gac/friend-assemblies.md b/docs/csharp/programming-guide/concepts/assemblies-gac/friend-assemblies.md
index 7f5137e0fdec0..42228de7930e5 100644
--- a/docs/csharp/programming-guide/concepts/assemblies-gac/friend-assemblies.md
+++ b/docs/csharp/programming-guide/concepts/assemblies-gac/friend-assemblies.md
@@ -35,7 +35,7 @@ A *friend assembly* is an assembly that can access another assembly's [internal]
 > [!NOTE]
 >  When you compile an assembly (assembly `AssemblyB`) that will access internal types or internal members of another assembly (assembly *A*), you must explicitly specify the name of the output file (.exe or .dll) by using the **/out** compiler option. This is required because the compiler has not yet generated the name for the assembly it is building at the time it is binding to external references. For more information, see [/out (C#)](../../../../csharp/language-reference/compiler-options/out-compiler-option.md) .  
   
-```cs  
+```csharp  
 using System.Runtime.CompilerServices;  
 using System;  
   
diff --git a/docs/csharp/programming-guide/concepts/assemblies-gac/how-to-create-and-use-assemblies-using-the-command-line.md b/docs/csharp/programming-guide/concepts/assemblies-gac/how-to-create-and-use-assemblies-using-the-command-line.md
index 05c2dc6723524..b5d40f14c049e 100644
--- a/docs/csharp/programming-guide/concepts/assemblies-gac/how-to-create-and-use-assemblies-using-the-command-line.md
+++ b/docs/csharp/programming-guide/concepts/assemblies-gac/how-to-create-and-use-assemblies-using-the-command-line.md
@@ -35,7 +35,7 @@ An assembly, or a dynamic linking library (DLL), is linked to your program at ru
   
 ## Example  
   
-```cs  
+```csharp  
 // File: Add.cs   
 namespace UtilityMethods  
 {  
@@ -49,7 +49,7 @@ namespace UtilityMethods
 }  
 ```  
   
-```cs  
+```csharp  
 // File: Mult.cs  
 namespace UtilityMethods   
 {  
@@ -63,7 +63,7 @@ namespace UtilityMethods
 }  
 ```  
   
-```cs  
+```csharp  
 // File: TestCode.cs  
   
 using UtilityMethods;  
@@ -101,13 +101,13 @@ class TestCode
   
  Notice that the `using` directive at the beginning of the file enables you to use the unqualified class names to reference the DLL methods at compile time, as follows:  
   
-```cs  
+```csharp  
 MultiplyClass.Multiply(num1, num2);  
 ```  
   
  Otherwise, you have to use the fully qualified names, as follows:  
   
-```cs  
+```csharp  
 UtilityMethods.MultiplyClass.Multiply(num1, num2);  
 ```  
   
@@ -119,7 +119,7 @@ UtilityMethods.MultiplyClass.Multiply(num1, num2);
 ## Compiling the Code  
  To build the file `MathLibrary.DLL`, compile the two files `Add` and `Mult` by using the following command line.  
   
-```cs  
+```csharp  
 csc /target:library /out:MathLibrary.DLL Add.cs Mult.cs  
 ```  
   
@@ -127,7 +127,7 @@ csc /target:library /out:MathLibrary.DLL Add.cs Mult.cs
   
  To build the executable file, `TestCode.exe`, use the following command line:  
   
-```cs  
+```csharp  
 csc /out:TestCode.exe /reference:MathLibrary.DLL TestCode.cs  
 ```  
   
diff --git a/docs/csharp/programming-guide/concepts/assemblies-gac/how-to-create-signed-friend-assemblies.md b/docs/csharp/programming-guide/concepts/assemblies-gac/how-to-create-signed-friend-assemblies.md
index 0f2ad0125e40e..a9d3b5f0fd9ad 100644
--- a/docs/csharp/programming-guide/concepts/assemblies-gac/how-to-create-signed-friend-assemblies.md
+++ b/docs/csharp/programming-guide/concepts/assemblies-gac/how-to-create-signed-friend-assemblies.md
@@ -47,7 +47,7 @@ This example shows how to use friend assemblies with assemblies that have strong
   
      The Strong Name tool generates a new public key every time it runs. Therefore, you must replace the public key in the following code with the public key you just generated, as shown in the following example.  
   
-    ```cs  
+    ```csharp  
     // friend_signed_A.cs  
     // Compile with:   
     // csc /target:library /keyfile:FriendAssemblies.snk friend_signed_A.cs  
@@ -66,13 +66,13 @@ This example shows how to use friend assemblies with assemblies that have strong
   
 4.  Compile and sign friend_signed_A by using the following command.  
   
-    ```cs  
+    ```csharp  
     csc /target:library /keyfile:FriendAssemblies.snk friend_signed_A.cs  
     ```  
   
 5.  Create a C# file that is named `friend_signed_B` and contains the following code. Because friend_signed_A specifies friend_signed_B as a friend assembly, the code in friend_signed_B can access `internal` types and members from friend_signed_A. The file contains the following code.  
   
-    ```cs  
+    ```csharp  
     // friend_signed_B.cs  
     // Compile with:   
     // csc /keyfile:FriendAssemblies.snk /r:friend_signed_A.dll /out:friend_signed_B.exe friend_signed_B.cs  
@@ -88,7 +88,7 @@ This example shows how to use friend assemblies with assemblies that have strong
   
 6.  Compile and sign friend_signed_B by using the following command.  
   
-    ```cs  
+    ```csharp  
     csc /keyfile:FriendAssemblies.snk /r:friend_signed_A.dll /out:friend_signed_B.exe friend_signed_B.cs  
     ```  
   
diff --git a/docs/csharp/programming-guide/concepts/assemblies-gac/how-to-create-unsigned-friend-assemblies.md b/docs/csharp/programming-guide/concepts/assemblies-gac/how-to-create-unsigned-friend-assemblies.md
index 3279713162da0..8db7fabb3a3a6 100644
--- a/docs/csharp/programming-guide/concepts/assemblies-gac/how-to-create-unsigned-friend-assemblies.md
+++ b/docs/csharp/programming-guide/concepts/assemblies-gac/how-to-create-unsigned-friend-assemblies.md
@@ -31,7 +31,7 @@ This example shows how to use friend assemblies with assemblies that are unsigne
   
 2.  Create a C# file named `friend_signed_A.` that contains the following code. The code uses the <xref:System.Runtime.CompilerServices.InternalsVisibleToAttribute> attribute to declare friend_signed_B as a friend assembly.  
   
-    ```cs  
+    ```csharp  
     // friend_unsigned_A.cs  
     // Compile with:   
     // csc /target:library friend_unsigned_A.cs  
@@ -61,13 +61,13 @@ This example shows how to use friend assemblies with assemblies that are unsigne
   
 3.  Compile and sign friend_signed_A by using the following command.  
   
-    ```cs  
+    ```csharp  
     csc /target:library friend_unsigned_A.cs  
     ```  
   
 4.  Create a C# file named `friend_unsigned_B` that contains the following code. Because friend_unsigned_A specifies friend_unsigned_B as a friend assembly, the code in friend_unsigned_B can access `internal` types and members from friend_unsigned_A.  
   
-    ```cs  
+    ```csharp  
     // friend_unsigned_B.cs  
     // Compile with:   
     // csc /r:friend_unsigned_A.dll /out:friend_unsigned_B.exe friend_unsigned_B.cs  
@@ -90,7 +90,7 @@ This example shows how to use friend assemblies with assemblies that are unsigne
   
 5.  Compile friend_signed_B by using the following command.  
   
-    ```cs  
+    ```csharp  
     csc /r:friend_unsigned_A.dll /out:friend_unsigned_B.exe friend_unsigned_B.cs  
     ```  
   
diff --git a/docs/csharp/programming-guide/concepts/assemblies-gac/walkthrough-embedding-type-information-from-microsoft-office-assemblies.md b/docs/csharp/programming-guide/concepts/assemblies-gac/walkthrough-embedding-type-information-from-microsoft-office-assemblies.md
index 0996c575e9557..65d89f8df779d 100644
--- a/docs/csharp/programming-guide/concepts/assemblies-gac/walkthrough-embedding-type-information-from-microsoft-office-assemblies.md
+++ b/docs/csharp/programming-guide/concepts/assemblies-gac/walkthrough-embedding-type-information-from-microsoft-office-assemblies.md
@@ -53,7 +53,7 @@ If you embed type information in an application that references COM objects, you
   
 7.  Open the **Program.cs** file. Replace the code in the file with the following code:  
   
-    ```cs  
+    ```csharp  
     using System;  
     using System.Collections.Generic;  
     using System.Linq;  
diff --git a/docs/csharp/programming-guide/concepts/assemblies-gac/walkthrough-embedding-types-from-managed-assemblies-in-visual-studio.md b/docs/csharp/programming-guide/concepts/assemblies-gac/walkthrough-embedding-types-from-managed-assemblies-in-visual-studio.md
index a2fd239aa616c..34f6bfa0d959c 100644
--- a/docs/csharp/programming-guide/concepts/assemblies-gac/walkthrough-embedding-types-from-managed-assemblies-in-visual-studio.md
+++ b/docs/csharp/programming-guide/concepts/assemblies-gac/walkthrough-embedding-types-from-managed-assemblies-in-visual-studio.md
@@ -77,7 +77,7 @@ If you embed type information from a strong-named managed assembly, you can loos
   
 6.  Open the ISampleInterface.cs file. Add the following code to the ISampleInterface class file to create the ISampleInterface interface.  
   
-    ```cs  
+    ```csharp  
     using System;  
     using System.Runtime.InteropServices;  
   
@@ -99,7 +99,7 @@ If you embed type information from a strong-named managed assembly, you can loos
   
 9. In **Solution Explorer**, expand the **Properties** folder. Double-click the AssemblyInfo.cs file. Add the following attribute to the file.  
   
-    ```cs  
+    ```csharp  
     [assembly: ImportedFromTypeLib("")]  
     ```  
   
@@ -129,7 +129,7 @@ If you embed type information from a strong-named managed assembly, you can loos
   
 8.  Add the following code to the SampleClass class file to create the SampleClass class.  
   
-    ```cs  
+    ```csharp  
     using System;  
     using System.Collections.Generic;  
     using System.Linq;  
@@ -172,7 +172,7 @@ If you embed type information from a strong-named managed assembly, you can loos
   
 6.  Add the following code to the Program.cs file to create the client program.  
   
-    ```cs  
+    ```csharp  
     using System;  
     using System.Collections.Generic;  
     using System.Linq;  
@@ -210,7 +210,7 @@ If you embed type information from a strong-named managed assembly, you can loos
   
 3.  Open the SampleInterface.cs file. Add the following line of code to the ISampleInterface interface.  
   
-    ```cs  
+    ```csharp  
     DateTime GetDate();  
     ```  
   
@@ -230,7 +230,7 @@ If you embed type information from a strong-named managed assembly, you can loos
   
 3.  Open the SampleClass.cs file. Add the following lines of code to the SampleClass class.  
   
-    ```cs  
+    ```csharp  
     public DateTime GetDate()  
     {  
         return DateTime.Now;  
diff --git a/docs/csharp/programming-guide/concepts/async/async-return-types.md b/docs/csharp/programming-guide/concepts/async/async-return-types.md
index b0b745597995e..b9e3720822c3d 100644
--- a/docs/csharp/programming-guide/concepts/async/async-return-types.md
+++ b/docs/csharp/programming-guide/concepts/async/async-return-types.md
@@ -35,7 +35,7 @@ Async methods have three possible return types: <xref:System.Threading.Tasks.Tas
   
  In the following example, the `TaskOfT_MethodAsync` async method contains a return statement that returns an integer. Therefore, the method declaration must specify a return type of `Task<int>`.  
   
-```cs  
+```csharp  
 // TASK<T> EXAMPLE  
 async Task<int> TaskOfT_MethodAsync()  
 {  
@@ -61,7 +61,7 @@ async Task<int> TaskOfT_MethodAsync()
   
  The following code calls and awaits method `TaskOfT_MethodAsync`. The result is assigned to the `result1` variable.  
   
-```cs  
+```csharp  
 // Call and await the Task<T>-returning async method in the same statement.  
 int result1 = await TaskOfT_MethodAsync();  
 ```  
@@ -71,7 +71,7 @@ int result1 = await TaskOfT_MethodAsync();
 > [!WARNING]
 >  The <xref:System.Threading.Tasks.Task%601.Result%2A> property is a blocking property. If you try to access it before its task is finished, the thread that's currently active is blocked until the task completes and the value is available. In most cases, you should access the value by using `await` instead of accessing the property directly.  
   
-```cs  
+```csharp  
 // Call and await in separate statements.  
 Task<int> integerTask = TaskOfT_MethodAsync();  
   
@@ -83,7 +83,7 @@ int result2 = await integerTask;
   
  The display statements in the following code verify that the values of the `result1` variable, the `result2` variable, and the `Result` property are the same. Remember that the `Result` property is a blocking property and shouldn't be accessed before its task has been awaited.  
   
-```cs  
+```csharp  
 // Display the values of the result1 variable, the result2 variable, and  
 // the integerTask.Result property.  
 textBox1.Text += String.Format("\r\nValue of result1 variable:   {0}\r\n", result1);  
@@ -96,7 +96,7 @@ textBox1.Text += String.Format("Value of integerTask.Result: {0}\r\n", integerTa
   
  In the following example, async method `Task_MethodAsync` doesn't contain a return statement. Therefore, you specify a return type of `Task` for the method, which enables `Task_MethodAsync` to be awaited. The definition of the `Task` type doesn't include a `Result` property to store a return value.  
   
-```cs  
+```csharp  
 // TASK EXAMPLE  
 async Task Task_MethodAsync()  
 {  
@@ -115,7 +115,7 @@ async Task Task_MethodAsync()
   
  The following code calls and awaits method `Task_MethodAsync`.  
   
-```cs  
+```csharp  
 // Call and await the Task-returning async method in the same statement.  
 await Task_MethodAsync();  
 ```  
@@ -124,7 +124,7 @@ await Task_MethodAsync();
   
  The following code separates calling `Task_MethodAsync` from awaiting the task that `Task_MethodAsync` returns.  
   
-```cs  
+```csharp  
 // Call and await in separate statements.  
 Task simpleTask = Task_MethodAsync();  
   
@@ -143,7 +143,7 @@ await simpleTask;
   
  The following code defines an async event handler.  
   
-```cs  
+```csharp  
 // VOID EXAMPLE  
 private async void button1_Click(object sender, RoutedEventArgs e)  
 {  
@@ -181,7 +181,7 @@ private async void button1_Click(object sender, RoutedEventArgs e)
   
 6.  In the **XAML** window of MainWindow.xaml, replace the code with the following code.  
   
-    ```cs  
+    ```csharp  
     <Window x:Class="AsyncReturnTypes.MainWindow"  
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"  
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"  
@@ -201,7 +201,7 @@ private async void button1_Click(object sender, RoutedEventArgs e)
   
 8.  Replace the code in MainWindow.xaml.cs with the following code.  
   
-    ```cs  
+    ```csharp  
     using System;  
     using System.Collections.Generic;  
     using System.Linq;  
diff --git a/docs/csharp/programming-guide/concepts/async/cancel-an-async-task-or-a-list-of-tasks.md b/docs/csharp/programming-guide/concepts/async/cancel-an-async-task-or-a-list-of-tasks.md
index f3d4ba17266f4..4c2b4c9e2de6e 100644
--- a/docs/csharp/programming-guide/concepts/async/cancel-an-async-task-or-a-list-of-tasks.md
+++ b/docs/csharp/programming-guide/concepts/async/cancel-an-async-task-or-a-list-of-tasks.md
@@ -59,7 +59,7 @@ You can set up a button that you can use to cancel an async application if you d
   
 1.  Declare a `CancellationTokenSource` variable, `cts`, that’s in scope for all methods that access it.  
   
-    ```cs  
+    ```csharp  
     public partial class MainWindow : Window  
     {  
         // ***Declare a System.Threading.CancellationTokenSource.  
@@ -68,7 +68,7 @@ You can set up a button that you can use to cancel an async application if you d
   
 2.  Add the following event handler for the **Cancel** button. The event handler uses the <xref:System.Threading.CancellationTokenSource.Cancel%2A?displayProperty=fullName> method to notify `cts` when the user requests cancellation.  
   
-    ```cs  
+    ```csharp  
     // ***Add an event handler for the Cancel button.  
     private void cancelButton_Click(object sender, RoutedEventArgs e)  
     {  
@@ -83,14 +83,14 @@ You can set up a button that you can use to cancel an async application if you d
   
     -   Instantiate the `CancellationTokenSource`, `cts`.  
   
-        ```cs  
+        ```csharp  
         // ***Instantiate the CancellationTokenSource.  
         cts = new CancellationTokenSource();  
         ```  
   
     -   In the call to `AccessTheWebAsync`, which downloads the contents of a specified website, send the <xref:System.Threading.CancellationTokenSource.Token%2A?displayProperty=fullName> property of `cts` as an argument. The `Token` property propagates the message if cancellation is requested. Add a catch block that displays a message if the user chooses to cancel the download operation. The following code shows the changes.  
   
-        ```cs  
+        ```csharp  
         try  
         {  
             // ***Send a token to carry the message if cancellation is requested.  
@@ -113,7 +113,7 @@ You can set up a button that you can use to cancel an async application if you d
   
      The following code shows the changes in `AccessTheWebAsync`.  
   
-    ```cs  
+    ```csharp  
     // ***Provide a parameter for the CancellationToken.  
     async Task<int> AccessTheWebAsync(CancellationToken ct)  
     {  
@@ -176,7 +176,7 @@ You can set up a button that you can use to cancel an async application if you d
   
 1.  Add a method to create a list of web addresses.  
   
-    ```cs  
+    ```csharp  
     // ***Add a method that creates a list of web addresses.  
     private List<string> SetUpURLList()  
     {  
@@ -196,14 +196,14 @@ You can set up a button that you can use to cancel an async application if you d
   
 2.  Call the method in `AccessTheWebAsync`.  
   
-    ```cs  
+    ```csharp  
     // ***Call SetUpURLList to make a list of web addresses.  
     List<string> urlList = SetUpURLList();  
     ```  
   
 3.  Add the following loop in `AccessTheWebAsync` to process each web address in the list.  
   
-    ```cs  
+    ```csharp  
     // ***Add a loop to process the list of web addresses.  
     foreach (var url in urlList)  
     {  
@@ -222,13 +222,13 @@ You can set up a button that you can use to cancel an async application if you d
   
 4.  Because `AccessTheWebAsync` displays the lengths, the method doesn't need to return anything. Remove the return statement, and change the return type of the method to <xref:System.Threading.Tasks.Task> instead of <xref:System.Threading.Tasks.Task%601>.  
   
-    ```cs  
+    ```csharp  
     async Task AccessTheWebAsync(CancellationToken ct)  
     ```  
   
      Call the method from `startButton_Click` by using a statement instead of an expression.  
   
-    ```cs  
+    ```csharp  
     await AccessTheWebAsync(cts.Token);  
     ```  
   
@@ -275,7 +275,7 @@ You can set up a button that you can use to cancel an async application if you d
 ### Cancel a Task Example  
  The following code is the complete MainWindow.xaml.cs file for the example that cancels a single task.  
   
-```cs  
+```csharp  
 using System;  
 using System.Collections.Generic;  
 using System.Linq;  
@@ -386,7 +386,7 @@ namespace CancelATask
 ### Cancel a List of Tasks Example  
  The following code is the complete MainWindow.xaml.cs file for the example that cancels a list of tasks.  
   
-```cs  
+```csharp  
 using System;  
 using System.Collections.Generic;  
 using System.Linq;  
diff --git a/docs/csharp/programming-guide/concepts/async/cancel-async-tasks-after-a-period-of-time.md b/docs/csharp/programming-guide/concepts/async/cancel-async-tasks-after-a-period-of-time.md
index 1cae4a83569f5..f06109e83db7e 100644
--- a/docs/csharp/programming-guide/concepts/async/cancel-async-tasks-after-a-period-of-time.md
+++ b/docs/csharp/programming-guide/concepts/async/cancel-async-tasks-after-a-period-of-time.md
@@ -56,7 +56,7 @@ You can cancel an asynchronous operation after a period of time by using the  <x
   
  To specify a maximum time before the tasks are marked as canceled, add a call to `CancelAfter` to `startButton_Click`, as the following example shows. The addition is marked with asterisks.  
   
-```cs  
+```csharp  
 private async void startButton_Click(object sender, RoutedEventArgs e)  
 {  
     // Instantiate the CancellationTokenSource.  
@@ -105,7 +105,7 @@ Downloads canceled.
   
  You can download the project from [Async Sample: Fine Tuning Your Application](http://go.microsoft.com/fwlink/?LinkId=255046).  
   
-```cs  
+```csharp  
 using System;  
 using System.Collections.Generic;  
 using System.Linq;  
diff --git a/docs/csharp/programming-guide/concepts/async/cancel-remaining-async-tasks-after-one-is-complete.md b/docs/csharp/programming-guide/concepts/async/cancel-remaining-async-tasks-after-one-is-complete.md
index 86790425f1973..2cd8ed331a4cd 100644
--- a/docs/csharp/programming-guide/concepts/async/cancel-remaining-async-tasks-after-one-is-complete.md
+++ b/docs/csharp/programming-guide/concepts/async/cancel-remaining-async-tasks-after-one-is-complete.md
@@ -56,7 +56,7 @@ By using the <xref:System.Threading.Tasks.Task.WhenAny%2A?displayProperty=fullNa
   
  In the MainWindow.xaml.cs file of the **CancelAListOfTasks** project, start the transition by moving the processing steps for each website from the loop in `AccessTheWebAsync` to the following async method.  
   
-```cs  
+```csharp  
 / ***Bundle the processing steps for a website into one async method.  
 async Task<int> ProcessURLAsync(string url, HttpClient client, CancellationToken ct)  
 {  
@@ -78,7 +78,7 @@ async Task<int> ProcessURLAsync(string url, HttpClient client, CancellationToken
   
 2.  Create a query that, when executed, produces a collection of generic tasks. Each call to `ProcessURLAsync` returns a <xref:System.Threading.Tasks.Task%601> where `TResult` is an integer.  
   
-    ```cs  
+    ```csharp  
     // ***Create a query that, when executed, returns a collection of tasks.  
     IEnumerable<Task<int>> downloadTasksQuery =  
         from url in urlList select ProcessURLAsync(url, client, ct);  
@@ -86,14 +86,14 @@ async Task<int> ProcessURLAsync(string url, HttpClient client, CancellationToken
   
 3.  Call `ToArray` to execute the query and start the tasks. The application of the `WhenAny` method in the next step would execute the query and start the tasks without using `ToArray`, but other methods might not. The safest practice is to force execution of the query explicitly.  
   
-    ```cs  
+    ```csharp  
     // ***Use ToArray to execute the query and start the download tasks.   
     Task<int>[] downloadTasks = downloadTasksQuery.ToArray();  
     ```  
   
 4.  Call `WhenAny` on the collection of tasks. `WhenAny` returns a `Task(Of Task(Of Integer))` or `Task<Task<int>>`.  That is, `WhenAny` returns a task that evaluates to a single `Task(Of Integer)` or `Task<int>` when it’s awaited. That single task is the first task in the collection to finish. The task that finished first is assigned to `firstFinishedTask`. The type of `firstFinishedTask` is <xref:System.Threading.Tasks.Task%601> where `TResult` is an integer because that's the return type of `ProcessURLAsync`.  
   
-    ```cs  
+    ```csharp  
     // ***Call WhenAny and then await the result. The task that finishes   
     // first is assigned to firstFinishedTask.  
     Task<int> firstFinishedTask = await Task.WhenAny(downloadTasks);  
@@ -101,14 +101,14 @@ async Task<int> ProcessURLAsync(string url, HttpClient client, CancellationToken
   
 5.  In this example, you’re interested only in the task that finishes first. Therefore, use <xref:System.Threading.CancellationTokenSource.Cancel%2A?displayProperty=fullName> to cancel the remaining tasks.  
   
-    ```cs  
+    ```csharp  
     // ***Cancel the rest of the downloads. You just want the first one.  
     cts.Cancel();  
     ```  
   
 6.  Finally, await `firstFinishedTask` to retrieve the length of the downloaded content.  
   
-    ```cs  
+    ```csharp  
     var length = await firstFinishedTask;  
     resultsTextBox.Text += String.Format("\r\nLength of the downloaded website:  {0}\r\n", length);  
     ```  
@@ -122,7 +122,7 @@ async Task<int> ProcessURLAsync(string url, HttpClient client, CancellationToken
   
  You can download the project from [Async Sample: Fine Tuning Your Application](http://go.microsoft.com/fwlink/?LinkId=255046).  
   
-```cs  
+```csharp  
 using System;  
 using System.Collections.Generic;  
 using System.Linq;  
diff --git a/docs/csharp/programming-guide/concepts/async/control-flow-in-async-programs.md b/docs/csharp/programming-guide/concepts/async/control-flow-in-async-programs.md
index 3fecbff9414b7..669b87fef94a9 100644
--- a/docs/csharp/programming-guide/concepts/async/control-flow-in-async-programs.md
+++ b/docs/csharp/programming-guide/concepts/async/control-flow-in-async-programs.md
@@ -40,7 +40,7 @@ You can write and maintain asynchronous programs more easily by using the `async
   
  The following code shows an outline of the program.  
   
-```cs  
+```csharp  
   
 public partial class MainWindow : Window  
 {  
@@ -144,7 +144,7 @@ Length of the downloaded string: 33946.
   
 6.  In the **XAML** view of MainWindow.xaml, replace the code with the following code.  
   
-    ```cs  
+    ```csharp  
     <Window  
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"  
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"  
@@ -167,7 +167,7 @@ Length of the downloaded string: 33946.
   
 9. In MainWindow.xaml.cs, replace the code with the following code.  
   
-    ```cs  
+    ```csharp  
     using System;  
     using System.Collections.Generic;  
     using System.Linq;  
@@ -300,7 +300,7 @@ Length of the downloaded string: 33946.
   
  The `client.GetStringAsync` method returns a task of string that’s assigned to the `getStringTask` variable in `AccessTheWebAsync`. The following line in the example program shows the call to `client.GetStringAsync` and the assignment.  
   
-```cs  
+```csharp  
 Task<string> getStringTask = client.GetStringAsync("http://msdn.microsoft.com");  
 ```  
   
@@ -316,7 +316,7 @@ THREE: Back in AccessTheWebAsync.
   
  The following statement suspends progress in `AccessTheWebAsync` when `getStringTask` is awaited.  
   
-```cs  
+```csharp  
 string urlContents = await getStringTask;  
 ```  
   
@@ -336,7 +336,7 @@ string urlContents = await getStringTask;
   
  The following statement assigns this task to the `getLengthTask` variable.  
   
-```cs  
+```csharp  
 Task<int> getLengthTask = AccessTheWebAsync();  
 ```  
   
@@ -352,7 +352,7 @@ FOUR:  Back in startButton_Click.
   
  Progress in `startButton_Click` is suspended when `getLengthTask` is awaited. The following assignment statement suspends `startButton_Click` until `AccessTheWebAsync` is complete.  
   
-```cs  
+```csharp  
 int contentLength = await getLengthTask;  
 ```  
   
@@ -396,7 +396,7 @@ SIX:   Back in startButton_Click.
   
  The await expression retrieves from `getLengthTask` the integer value that’s the operand of the return statement in `AccessTheWebAsync`. The following statement assigns that value to the `contentLength` variable.  
   
-```cs  
+```csharp  
 int contentLength = await getLengthTask;  
 ```  
   
diff --git a/docs/csharp/programming-guide/concepts/async/handling-reentrancy-in-async-apps.md b/docs/csharp/programming-guide/concepts/async/handling-reentrancy-in-async-apps.md
index acff72c1ec54e..718d810606400 100644
--- a/docs/csharp/programming-guide/concepts/async/handling-reentrancy-in-async-apps.md
+++ b/docs/csharp/programming-guide/concepts/async/handling-reentrancy-in-async-apps.md
@@ -119,7 +119,7 @@ TOTAL bytes returned:  890591
   
  The following code shows these changes, which are marked with asterisks. You can add the changes to the code at the end of this topic, or you can download the finished app from [Async Samples: Reentrancy in .NET Desktop Apps](http://go.microsoft.com/fwlink/?LinkId=266571). The project name is DisableStartButton.  
   
-```cs  
+```csharp  
 private async void StartButton_Click(object sender, RoutedEventArgs e)  
 {  
     // This line is commented out to make the results clearer in the output.  
@@ -155,7 +155,7 @@ private async void StartButton_Click(object sender, RoutedEventArgs e)
   
 1.  Declare a <xref:System.Threading.CancellationTokenSource> variable, `cts`, that’s in scope for all methods.  
   
-    ```cs  
+    ```csharp  
     public partial class MainWindow : Window   // Or class MainPage  
     {  
         // *** Declare a System.Threading.CancellationTokenSource.  
@@ -164,7 +164,7 @@ private async void StartButton_Click(object sender, RoutedEventArgs e)
   
 2.  In `StartButton_Click`, determine whether an operation is already underway. If the value of `cts` is null, no operation is already active. If the value isn't null, the operation that is already running is canceled.  
   
-    ```cs  
+    ```csharp  
     // *** If a download process is already underway, cancel it.  
     if (cts != null)  
     {  
@@ -174,7 +174,7 @@ private async void StartButton_Click(object sender, RoutedEventArgs e)
   
 3.  Set `cts` to a different value that represents the current process.  
   
-    ```cs  
+    ```csharp  
     // *** Now set cts to a new value that you can use to cancel the current process  
     // if the button is chosen again.  
     CancellationTokenSource newCTS = new CancellationTokenSource();  
@@ -183,7 +183,7 @@ private async void StartButton_Click(object sender, RoutedEventArgs e)
   
 4.  At the end of `StartButton_Click`, the current process is complete, so set the value of `cts` back to null.  
   
-    ```cs  
+    ```csharp  
     // *** When the process is complete, signal that another process can begin.  
     if (cts == newCTS)  
         cts = null;  
@@ -191,7 +191,7 @@ private async void StartButton_Click(object sender, RoutedEventArgs e)
   
  The following code shows all the changes in `StartButton_Click`. The additions are marked with asterisks.  
   
-```cs  
+```csharp  
 private async void StartButton_Click(object sender, RoutedEventArgs e)  
 {  
     // This line is commented out to make the results clearer in the output.  
@@ -238,7 +238,7 @@ private async void StartButton_Click(object sender, RoutedEventArgs e)
   
  The following code shows these changes, which are marked with asterisks.  
   
-```cs  
+```csharp  
 // *** Provide a parameter for the CancellationToken from StartButton_Click.  
 async Task AccessTheWebAsync(CancellationToken ct)  
 {  
@@ -398,7 +398,7 @@ TOTAL bytes returned:  920526
 #### Global Definitions  
  The sample code contains the following two global declarations that are visible from all methods.  
   
-```cs  
+```csharp  
 public partial class MainWindow : Window  // Class MainPage in Windows Store app.  
 {  
     // ***Declare the following variables where all methods can access them.   
@@ -411,7 +411,7 @@ public partial class MainWindow : Window  // Class MainPage in Windows Store app
 #### The Click Event Handler  
  The event handler, `StartButton_Click`, increments the group letter each time the user chooses the **Start** button. Then the handler calls `AccessTheWebAsync` to run the downloading operation.  
   
-```cs  
+```csharp  
 private async void StartButton_Click(object sender, RoutedEventArgs e)  
 {  
     // ***Verify that each group's results are displayed together, and that  
@@ -442,7 +442,7 @@ private async void StartButton_Click(object sender, RoutedEventArgs e)
   
  `FinishOneGroupAsync` returns a task that's assigned to `pendingWork` in `AccessTheWebAsync`. That value prevents interruption by another operation before the task is complete.  
   
-```cs  
+```csharp  
 private async Task<char> AccessTheWebAsync(char grp)  
 {  
     HttpClient client = new HttpClient();  
@@ -472,7 +472,7 @@ private async Task<char> AccessTheWebAsync(char grp)
   
  The first statement in `FinishOneGroupAsync` uses `pendingWork` to make sure that entering the method doesn't interfere with an operation that is already in the display process or that's already waiting. If such an operation is in progress, the entering operation must wait its turn.  
   
-```cs  
+```csharp  
 private async Task FinishOneGroupAsync(List<string> urls, Task<byte[]>[] contentTasks, char grp)  
 {  
     // ***Wait for the previous group to finish displaying results.  
@@ -595,7 +595,7 @@ private async Task FinishOneGroupAsync(List<string> urls, Task<byte[]>[] content
   
 7.  In the **XAML** view of MainWindow.xaml, replace the code with the following code.  
   
-    ```cs  
+    ```csharp  
     <Window x:Class="WebsiteDownloadWPF.MainWindow"  
         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"  
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"  
@@ -619,7 +619,7 @@ private async Task FinishOneGroupAsync(List<string> urls, Task<byte[]>[] content
   
 10. In MainWindow.xaml.cs, replace the code with the following code.  
   
-    ```cs  
+    ```csharp  
     using System;  
     using System.Collections.Generic;  
     using System.Linq;  
diff --git a/docs/csharp/programming-guide/concepts/async/how-to-extend-the-async-walkthrough-by-using-task-whenall.md b/docs/csharp/programming-guide/concepts/async/how-to-extend-the-async-walkthrough-by-using-task-whenall.md
index b0c2fbeb95bf0..dfc5757f758c6 100644
--- a/docs/csharp/programming-guide/concepts/async/how-to-extend-the-async-walkthrough-by-using-task-whenall.md
+++ b/docs/csharp/programming-guide/concepts/async/how-to-extend-the-async-walkthrough-by-using-task-whenall.md
@@ -44,7 +44,7 @@ You can improve the performance of the async solution in [Walkthrough: Accessing
   
      The `ProcessURLAsync` method consolidates the actions in the body of the `foreach` loop in `SumPageSizesAsync` in the original walkthrough. The method asynchronously downloads the contents of a specified website as a byte array, and then displays and returns the length of the byte array.  
   
-    ```cs  
+    ```csharp  
     private async Task<int> ProcessURLAsync(string url)  
     {  
         var byteArray = await GetURLContentsAsync(url);  
@@ -55,7 +55,7 @@ You can improve the performance of the async solution in [Walkthrough: Accessing
   
 2.  Comment out or delete the `foreach` loop in `SumPageSizesAsync`, as the following code shows.  
   
-    ```cs  
+    ```csharp  
     //var total = 0;  
     //foreach (var url in urlList)  
     //{  
@@ -78,7 +78,7 @@ You can improve the performance of the async solution in [Walkthrough: Accessing
   
      Add the following code to method `SumPageSizesAsync` after the declaration of `urlList`.  
   
-    ```cs  
+    ```csharp  
     // Create a query.   
     IEnumerable<Task<int>> downloadTasksQuery =   
         from url in urlList select ProcessURLAsync(url);  
@@ -91,7 +91,7 @@ You can improve the performance of the async solution in [Walkthrough: Accessing
   
      In the following example, the `await` expression awaits the completion of the single task that `WhenAll` returns. The expression evaluates to an array of integers, where each integer is the length of a downloaded website. Add the following code to `SumPageSizesAsync`, just after the code that you added in the previous step.  
   
-    ```cs  
+    ```csharp  
     // Await the completion of all the running tasks.  
     int[] lengths = await Task.WhenAll(downloadTasks);  
   
@@ -102,7 +102,7 @@ You can improve the performance of the async solution in [Walkthrough: Accessing
   
 5.  Finally, use the <xref:System.Linq.Enumerable.Sum%2A> method to calculate the sum of the lengths of all the websites. Add the following line to `SumPageSizesAsync`.  
   
-    ```cs  
+    ```csharp  
     int total = lengths.Sum();  
     ```  
   
@@ -118,7 +118,7 @@ You can improve the performance of the async solution in [Walkthrough: Accessing
   
      The only difference from the `ProcessURLAsync` method in the previous procedure is the use of the <xref:System.Net.Http.HttpClient> instance, `client`.  
   
-    ```cs  
+    ```csharp  
     async Task<int> ProcessURL(string url, HttpClient client)  
     {  
         byte[] byteArray = await client.GetByteArrayAsync(url);  
@@ -129,7 +129,7 @@ You can improve the performance of the async solution in [Walkthrough: Accessing
   
 2.  Comment out or delete the `For Each` or `foreach` loop in `SumPageSizesAsync`, as the following code shows.  
   
-    ```cs  
+    ```csharp  
     //var total = 0;  
     //foreach (var url in urlList)  
     //{  
@@ -153,7 +153,7 @@ You can improve the performance of the async solution in [Walkthrough: Accessing
   
      Add the following code to method `SumPageSizesAsync` after the declaration of `client` and `urlList`.  
   
-    ```cs  
+    ```csharp  
     // Create a query.  
     IEnumerable<Task<int>> downloadTasksQuery =   
         from url in urlList select ProcessURL(url, client);  
@@ -166,7 +166,7 @@ You can improve the performance of the async solution in [Walkthrough: Accessing
   
      In the following example, the `await` expression awaits the completion of the single task that `WhenAll` returns. When complete, the `await` expression evaluates to an array of integers, where each integer is the length of a downloaded website. Add the following code to `SumPageSizesAsync`, just after the code that you added in the previous step.  
   
-    ```cs  
+    ```csharp  
     // Await the completion of all the running tasks.  
     int[] lengths = await Task.WhenAll(downloadTasks);  
   
@@ -177,7 +177,7 @@ You can improve the performance of the async solution in [Walkthrough: Accessing
   
 5.  Finally, use the <xref:System.Linq.Enumerable.Sum%2A> method to get the sum of the lengths of all the websites. Add the following line to `SumPageSizesAsync`.  
   
-    ```cs  
+    ```csharp  
     int total = lengths.Sum();
     ```  
   
@@ -188,7 +188,7 @@ You can improve the performance of the async solution in [Walkthrough: Accessing
 ## Example  
  The following code shows the extensions to the project that uses the `GetURLContentsAsync` method to download content from the web.  
   
-```cs  
+```csharp  
 // Add the following using directives, and add a reference for System.Net.Http.  
 using System.Net.Http;  
 using System.IO;  
@@ -330,7 +330,7 @@ namespace AsyncExampleWPF_WhenAll
 ## Example  
  The following code shows the extensions to the project that uses method `HttpClient.GetByteArrayAsync` to download content from the web.  
   
-```cs  
+```csharp  
 // Add the following using directives, and add a reference for System.Net.Http.  
 using System.Net.Http;  
 using System.IO;  
diff --git a/docs/csharp/programming-guide/concepts/async/how-to-make-multiple-web-requests-in-parallel-by-using-async-and-await.md b/docs/csharp/programming-guide/concepts/async/how-to-make-multiple-web-requests-in-parallel-by-using-async-and-await.md
index 93beb6a417c0f..7805b1899b294 100644
--- a/docs/csharp/programming-guide/concepts/async/how-to-make-multiple-web-requests-in-parallel-by-using-async-and-await.md
+++ b/docs/csharp/programming-guide/concepts/async/how-to-make-multiple-web-requests-in-parallel-by-using-async-and-await.md
@@ -25,13 +25,13 @@ translation.priority.mt:
 # How to: Make Multiple Web Requests in Parallel by Using async and await (C#)
 In an async method, tasks are started when they’re created. The [await](../../../../csharp/language-reference/keywords/await.md) operator is applied to the task at the point in the method where processing can’t continue until the task finishes. Often a task is awaited as soon as it’s created, as the following example shows.  
   
-```cs  
+```csharp  
 var result = await someWebAccessMethodAsync(url);  
 ```  
   
  However, you can separate creating the task from awaiting the task if your program has other work to accomplish that doesn’t depend on the completion of the task.  
   
-```cs  
+```csharp  
 // The following line creates and starts the task.  
 var myTask = someWebAccessMethodAsync(url);  
   
@@ -71,7 +71,7 @@ var result = await myTask;
   
 2.  Copy the following code, and paste it into the body of `startButton_Click` in MainWindow.xaml.cs.  
   
-    ```cs  
+    ```csharp  
     resultsTextBox.Clear();  
     await CreateMultipleTasksAsync();  
     resultsTextBox.Text += "\r\n\r\nControl returned to startButton_Click.\r\n";  
@@ -87,7 +87,7 @@ var result = await myTask;
   
      Copy the following methods, and paste them after the `startButton_Click` event handler in MainWindow.xaml.cs.  
   
-    ```cs  
+    ```csharp  
     async Task<int> ProcessURLAsync(string url, HttpClient client)  
     {  
         var byteArray = await client.GetByteArrayAsync(url);  
@@ -119,7 +119,7 @@ var result = await myTask;
   
      Copy the following method, and paste it into your solution.  
   
-    ```cs  
+    ```csharp  
     private async Task CreateMultipleTasksAsync()  
     {  
         // Declare an HttpClient object, and increase the buffer size. The  
@@ -156,7 +156,7 @@ var result = await myTask;
 ## Example  
  The following code contains the full example.  
   
-```cs  
+```csharp  
 using System;  
 using System.Collections.Generic;  
 using System.Linq;  
diff --git a/docs/csharp/programming-guide/concepts/async/index.md b/docs/csharp/programming-guide/concepts/async/index.md
index 4c224f258b8a3..886611df19cf4 100644
--- a/docs/csharp/programming-guide/concepts/async/index.md
+++ b/docs/csharp/programming-guide/concepts/async/index.md
@@ -54,7 +54,7 @@ Asynchrony proves especially valuable for applications that access the UI thread
   
  You can find a complete Windows Presentation Foundation (WPF) example file at the end of this topic, and you can download the sample from [Async Sample: Example from "Asynchronous Programming with Async and Await"](http://go.microsoft.com/fwlink/?LinkID=261549).  
   
-```cs  
+```csharp  
 // Three things to note in the signature:  
 //  - The method has an async modifier.   
 //  - The return type is Task or Task<T>. (See "Return Types" section.)  
@@ -87,7 +87,7 @@ async Task<int> AccessTheWebAsync()
   
  If `AccessTheWebAsync` doesn't have any work that it can do between calling `GetStringAsync` and awaiting its completion, you can simplify your code by calling and awaiting in the following single statement.  
   
-```cs  
+```csharp  
 string urlContents = await client.GetStringAsync();  
 ```  
   
@@ -187,7 +187,7 @@ string urlContents = await client.GetStringAsync();
   
  The following example shows how you declare and call a method that returns a <xref:System.Threading.Tasks.Task%601> or a <xref:System.Threading.Tasks.Task>.  
   
-```cs  
+```csharp  
 // Signature specifies Task<TResult>  
 async Task<int> TaskOfTResult_MethodAsync()  
 {  
@@ -265,7 +265,7 @@ await Task_MethodAsync();
 ##  <a name="BKMK_CompleteExample"></a> Complete Example  
  The following code is the MainWindow.xaml.cs file from the Windows Presentation Foundation (WPF) application that this topic discusses. You can download the sample from [Async Sample: Example from "Asynchronous Programming with Async and Await"](http://go.microsoft.com/fwlink/p/?LinkID=261549).  
   
-```cs  
+```csharp  
 using System;  
 using System.Collections.Generic;  
 using System.Linq;  
diff --git a/docs/csharp/programming-guide/concepts/async/start-multiple-async-tasks-and-process-them-as-they-complete.md b/docs/csharp/programming-guide/concepts/async/start-multiple-async-tasks-and-process-them-as-they-complete.md
index d3905e3f2f879..8da7e49657c39 100644
--- a/docs/csharp/programming-guide/concepts/async/start-multiple-async-tasks-and-process-them-as-they-complete.md
+++ b/docs/csharp/programming-guide/concepts/async/start-multiple-async-tasks-and-process-them-as-they-complete.md
@@ -56,7 +56,7 @@ By using <xref:System.Threading.Tasks.Task.WhenAny%2A?displayProperty=fullName>,
   
  The **CancelAfterOneTask** project already includes a query that, when executed, creates a collection of tasks. Each call to `ProcessURLAsync` in the following code returns a <xref:System.Threading.Tasks.Task%601> where `TResult` is an integer.  
   
-```cs  
+```csharp  
 IEnumerable<Task<int>> downloadTasksQuery =  
     from url in urlList select ProcessURL(url, client, ct);  
 ```  
@@ -65,7 +65,7 @@ IEnumerable<Task<int>> downloadTasksQuery =
   
 -   Execute the query by applying <xref:System.Linq.Enumerable.ToList%2A?displayProperty=fullName> instead of <xref:System.Linq.Enumerable.ToArray%2A>.  
   
-    ```cs  
+    ```csharp  
     List<Task<int>> downloadTasks = downloadTasksQuery.ToList();  
     ```  
   
@@ -73,19 +73,19 @@ IEnumerable<Task<int>> downloadTasksQuery =
   
     1.  Awaits a call to `WhenAny` to identify the first task in the collection to finish its download.  
   
-        ```cs  
+        ```csharp  
         Task<int> firstFinishedTask = await Task.WhenAny(downloadTasks);  
         ```  
   
     2.  Removes that task from the collection.  
   
-        ```cs  
+        ```csharp  
         downloadTasks.Remove(firstFinishedTask);  
         ```  
   
     3.  Awaits `firstFinishedTask`, which is returned by a call to `ProcessURLAsync`. The `firstFinishedTask` variable is a <xref:System.Threading.Tasks.Task%601> where `TReturn` is an integer. The task is already complete, but you await it to retrieve the length of the downloaded website, as the following example shows.  
   
-        ```cs  
+        ```csharp  
         int length = await firstFinishedTask;  
         resultsTextBox.Text += String.Format("\r\nLength of the download:  {0}", length);  
         ```  
@@ -102,7 +102,7 @@ IEnumerable<Task<int>> downloadTasksQuery =
   
  You can download the project from [Async Sample: Fine Tuning Your Application](http://go.microsoft.com/fwlink/?LinkId=255046).  
   
-```cs  
+```csharp  
 using System;  
 using System.Collections.Generic;  
 using System.Linq;  
diff --git a/docs/csharp/programming-guide/concepts/async/using-async-for-file-access.md b/docs/csharp/programming-guide/concepts/async/using-async-for-file-access.md
index d03bd5cc3bd0a..865419e059fca 100644
--- a/docs/csharp/programming-guide/concepts/async/using-async-for-file-access.md
+++ b/docs/csharp/programming-guide/concepts/async/using-async-for-file-access.md
@@ -42,7 +42,7 @@ You can use the async feature to access files. By using the async feature, you c
   
  In the following examples, include the following `using` statements.  
   
-```cs  
+```csharp  
 using System;  
 using System.Collections.Generic;  
 using System.Diagnostics;  
@@ -59,7 +59,7 @@ using System.Threading.Tasks;
 ## Writing Text  
  The following example writes text to a file. At each await statement, the method immediately exits. When the file I/O is complete, the method resumes at the statement that follows the await statement. Note that the async modifier is in the definition of methods that use the await statement.  
   
-```cs  
+```csharp  
 public async void ProcessWrite()  
 {  
     string filePath = @"temp2.txt";  
@@ -83,7 +83,7 @@ private async Task WriteTextAsync(string filePath, string text)
   
  The original example has the statement `await sourceStream.WriteAsync(encodedText, 0, encodedText.Length);`, which is a contraction of the following two statements:  
   
-```cs  
+```csharp  
 Task theTask = sourceStream.WriteAsync(encodedText, 0, encodedText.Length);  
 await theTask;  
 ```  
@@ -93,7 +93,7 @@ await theTask;
 ## Reading Text  
  The following example reads text from a file. The text is buffered and, in this case, placed into a <xref:System.Text.StringBuilder>. Unlike in the previous example, the evaluation of the await produces a value. The <xref:System.IO.Stream.ReadAsync%2A> method returns a <xref:System.Threading.Tasks.Task>\<<xref:System.Int32>>, so the evaluation of the await produces an `Int32` value (`numRead`) after the operation completes. For more information, see [Async Return Types (C#)](../../../../csharp/programming-guide/concepts/async/async-return-types.md).  
   
-```cs  
+```csharp  
 public async void ProcessRead()  
 {  
     string filePath = @"temp2.txt";  
@@ -144,7 +144,7 @@ private async Task<string> ReadTextAsync(string filePath)
   
  Note that any performance boost is almost entirely from the parallel processing and not the asynchronous processing. The advantages of asynchrony are that it doesn’t tie up multiple threads, and that it doesn’t tie up the user interface thread.  
   
-```cs  
+```csharp  
 public async void ProcessWriteMult()  
 {  
     string folder = @"tempfolder\";  
diff --git a/docs/csharp/programming-guide/concepts/async/walkthrough-accessing-the-web-by-using-async-and-await.md b/docs/csharp/programming-guide/concepts/async/walkthrough-accessing-the-web-by-using-async-and-await.md
index aa81a5c9421d4..7ef5b807542b9 100644
--- a/docs/csharp/programming-guide/concepts/async/walkthrough-accessing-the-web-by-using-async-and-await.md
+++ b/docs/csharp/programming-guide/concepts/async/walkthrough-accessing-the-web-by-using-async-and-await.md
@@ -127,7 +127,7 @@ You can write asynchronous programs more easily and intuitively by using feature
   
 2.  Add the following `using` directives at the top of the code file if they’re not already present.  
   
-    ```cs  
+    ```csharp  
     using System.Net.Http;  
     using System.Net;  
     using System.IO;  
@@ -140,7 +140,7 @@ You can write asynchronous programs more easily and intuitively by using feature
   
 2.  In MainWindow.xaml.cs, copy the following code into the body of `startButton_Click`:  
   
-    ```cs  
+    ```csharp  
     resultsTextBox.Clear();  
     SumPageSizes();  
     resultsTextBox.Text += "\r\nControl returned to startButton_Click.";  
@@ -160,7 +160,7 @@ You can write asynchronous programs more easily and intuitively by using feature
   
      Copy the following four methods, and then paste them under the `startButton_Click` event handler in MainWindow.xaml.cs:  
   
-    ```cs  
+    ```csharp  
     private void SumPageSizes()  
     {  
         // Make a list of web addresses.  
@@ -278,7 +278,7 @@ You can write asynchronous programs more easily and intuitively by using feature
   
      Change the method that's called in the third line of `GetURLContents` from `GetResponse` to the asynchronous, task-based <xref:System.Net.WebRequest.GetResponseAsync%2A> method.  
   
-    ```cs  
+    ```csharp  
     using (WebResponse response = webReq.GetResponseAsync())  
     ```  
   
@@ -286,7 +286,7 @@ You can write asynchronous programs more easily and intuitively by using feature
   
      To retrieve the `WebResponse` value from the task, apply an [await](../../../../csharp/language-reference/keywords/await.md) operator to the call to `GetResponseAsync`, as the following code shows.  
   
-    ```cs  
+    ```csharp  
     using (WebResponse response = await webReq.GetResponseAsync())  
     ```  
   
@@ -294,7 +294,7 @@ You can write asynchronous programs more easily and intuitively by using feature
   
      The previous statement can be separated into the following two statements to clarify what happens.  
   
-    ```cs  
+    ```csharp  
     //Task<WebResponse> responseTask = webReq.GetResponseAsync();  
     //using (WebResponse response = await responseTask)  
     ```  
@@ -309,13 +309,13 @@ You can write asynchronous programs more easily and intuitively by using feature
   
     -   The `CopyTo` or `CopyToAsync` method copies bytes to its argument, `content`, and doesn’t return a meaningful value. In the synchronous version, the call to `CopyTo` is a simple statement that doesn't return a value. The asynchronous version, `CopyToAsync`, returns a <xref:System.Threading.Tasks.Task>. The task functions like "Task(void)" and enables the method to be awaited. Apply `Await` or `await` to the call to `CopyToAsync`, as the following code shows.  
   
-        ```cs  
+        ```csharp  
         await responseStream.CopyToAsync(content);  
         ```  
   
          The previous statement abbreviates the following two lines of code.  
   
-        ```cs  
+        ```csharp  
         // CopyToAsync returns a Task, not a Task<T>.  
         //Task copyTask = responseStream.CopyToAsync(content);  
   
@@ -326,7 +326,7 @@ You can write asynchronous programs more easily and intuitively by using feature
   
 4.  All that remains to be done in `GetURLContents` is to adjust the method signature. You can use the `await` operator only in methods that are marked with the [async](../../../../csharp/language-reference/keywords/async.md) modifier. Add the modifier to mark the method as an *async method*, as the following code shows.  
   
-    ```cs  
+    ```csharp  
     private async byte[] GetURLContents(string url)  
     ```  
   
@@ -342,7 +342,7 @@ You can write asynchronous programs more easily and intuitively by using feature
   
      The following code shows these changes.  
   
-    ```cs  
+    ```csharp  
     private async Task<byte[]> GetURLContentsAsync(string url)  
     ```  
   
@@ -359,13 +359,13 @@ You can write asynchronous programs more easily and intuitively by using feature
   
      The following code shows these changes.  
   
-    ```cs  
+    ```csharp  
     byte[] urlContents = await GetURLContentsAsync(url);  
     ```  
   
      The previous assignment abbreviates the following two lines of code.  
   
-    ```cs  
+    ```csharp  
     // GetURLContentsAsync returns a Task<T>. At completion, the task  
     // produces a byte array.  
     //Task<byte[]> getContentsTask = GetURLContentsAsync(url);  
@@ -382,7 +382,7 @@ You can write asynchronous programs more easily and intuitively by using feature
   
      The following code shows these changes.  
   
-    ```cs  
+    ```csharp  
     private async Task SumPageSizesAsync()  
     ```  
   
@@ -399,7 +399,7 @@ You can write asynchronous programs more easily and intuitively by using feature
   
      As in previous procedures, you can convert the call by using one statement or two statements. The following code shows these changes.  
   
-    ```cs  
+    ```csharp  
     // One-step async call.  
     await SumPageSizesAsync();  
   
@@ -410,14 +410,14 @@ You can write asynchronous programs more easily and intuitively by using feature
   
 3.  To prevent accidentally reentering the operation, add the following statement at the top of `startButton_Click` to disable the **Start** button.  
   
-    ```cs  
+    ```csharp  
     // Disable the button until the operation is complete.  
     startButton.IsEnabled = false;  
     ```  
   
      You can reenable the button at the end of the event handler.  
   
-    ```cs  
+    ```csharp  
     // Reenable the button in case you want to run the operation again.  
     startButton.IsEnabled = true;  
     ```  
@@ -426,7 +426,7 @@ You can write asynchronous programs more easily and intuitively by using feature
   
 4.  Finally, add the `async` modifier to the declaration so that the event handler can await `SumPagSizesAsync`.  
   
-    ```cs  
+    ```csharp  
     private async void startButton_Click(object sender, RoutedEventArgs e)  
     ```  
   
@@ -452,7 +452,7 @@ You can write asynchronous programs more easily and intuitively by using feature
   
      The first step is to create an `HttpClient` object in method `SumPageSizesAsync`. Add the following declaration at the start of the method.  
   
-    ```cs  
+    ```csharp  
     // Declare an HttpClient object and increase the buffer size. The  
     // default buffer size is 65,536.  
     HttpClient client =  
@@ -461,7 +461,7 @@ You can write asynchronous programs more easily and intuitively by using feature
   
 2.  In `SumPageSizesAsync,` replace the call to your `GetURLContentsAsync` method with a call to the `HttpClient` method.  
   
-    ```cs  
+    ```csharp  
     byte[] urlContents = await client.GetByteArrayAsync(url);  
     ```  
   
@@ -474,7 +474,7 @@ You can write asynchronous programs more easily and intuitively by using feature
 ##  <a name="BKMK_CompleteCodeExamples"></a> Example  
  The following code contains the full example of the conversion from a synchronous to an asynchronous solution by using the asynchronous `GetURLContentsAsync` method that you wrote. Notice that it strongly resembles the original, synchronous solution.  
   
-```cs  
+```csharp  
 using System;  
 using System.Collections.Generic;  
 using System.Linq;  
@@ -623,7 +623,7 @@ namespace AsyncExampleWPF
   
  The following code contains the full example of the solution that uses the `HttpClient` method, `GetByteArrayAsync`.  
   
-```cs  
+```csharp  
 using System;  
 using System.Collections.Generic;  
 using System.Linq;  
diff --git a/docs/csharp/programming-guide/concepts/attributes/accessing-attributes-by-using-reflection.md b/docs/csharp/programming-guide/concepts/attributes/accessing-attributes-by-using-reflection.md
index 58e96cd239bc9..99e7fce9441bd 100644
--- a/docs/csharp/programming-guide/concepts/attributes/accessing-attributes-by-using-reflection.md
+++ b/docs/csharp/programming-guide/concepts/attributes/accessing-attributes-by-using-reflection.md
@@ -27,14 +27,14 @@ The fact that you can define custom attributes and place them in your source cod
   
  An attribute specification such as:  
   
-```cs  
+```csharp  
 [Author("P. Ackerman", version = 1.1)]  
 class SampleClass  
 ```  
   
  is conceptually equivalent to this:  
   
-```cs  
+```csharp  
 Author anonymousAuthorObject = new Author("P. Ackerman");  
 anonymousAuthorObject.version = 1.1;  
 ```  
@@ -44,7 +44,7 @@ anonymousAuthorObject.version = 1.1;
 ## Example  
  Here is a complete example. A custom attribute is defined, applied to several entities, and retrieved via reflection.  
   
-```cs  
+```csharp  
 // Multiuse attribute.  
 [System.AttributeUsage(System.AttributeTargets.Class |  
                        System.AttributeTargets.Struct,  
diff --git a/docs/csharp/programming-guide/concepts/attributes/attributeusage.md b/docs/csharp/programming-guide/concepts/attributes/attributeusage.md
index 124cd0a6908a6..577d58a8f5b5b 100644
--- a/docs/csharp/programming-guide/concepts/attributes/attributeusage.md
+++ b/docs/csharp/programming-guide/concepts/attributes/attributeusage.md
@@ -25,7 +25,7 @@ translation.priority.mt:
 # AttributeUsage (C#)
 Determines how a custom attribute class can be used. `AttributeUsage` is an attribute that can be applied to custom attribute definitions to control how the new attribute can be applied. The default settings look like this when applied explicitly:  
   
-```cs  
+```csharp  
 [System.AttributeUsage(System.AttributeTargets.All,  
                    AllowMultiple = false,  
                    Inherited = true)]  
@@ -36,29 +36,29 @@ class NewAttribute : System.Attribute { }
   
  The `AllowMultiple` and `Inherited` arguments are optional, so this code has the same effect:  
   
-```cs  
+```csharp  
 [System.AttributeUsage(System.AttributeTargets.All)]  
 class NewAttribute : System.Attribute { }  
 ```  
   
  The first `AttributeUsage` argument must be one or more elements of the <xref:System.AttributeTargets> enumeration. Multiple target types can be linked together with the OR operator, like this:  
   
-```cs  
+```csharp  
 using System;  
 ```  
   
-```cs  
+```csharp  
 [AttributeUsage(AttributeTargets.Property | AttributeTargets.Field)]  
 class NewPropertyOrFieldAttribute : Attribute { }  
 ```  
   
  If the `AllowMultiple` argument is set to `true`, then the resulting attribute can be applied more than once to a single entity, like this:  
   
-```cs  
+```csharp  
 using System;  
 ```  
   
-```cs  
+```csharp  
 [AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]  
 class MultiUseAttr : Attribute { }  
   
@@ -74,11 +74,11 @@ class Class2 { }
   
  If `Inherited` is set to `false`, then the attribute is not inherited by classes that are derived from a class that is attributed. For example:  
   
-```cs  
+```csharp  
 using System;  
 ```  
   
-```cs  
+```csharp  
 [AttributeUsage(AttributeTargets.Class, Inherited = false)]  
 class Attr1 : Attribute { }  
   
@@ -98,11 +98,11 @@ class DClass : BClass { }
 ## Example  
  The following example demonstrates the effect of the `Inherited` and `AllowMultiple` arguments to the `AttributeUsage` attribute, and how the custom attributes applied to a class can be enumerated.  
   
-```cs  
+```csharp  
 using System;  
 ```  
   
-```cs  
+```csharp  
 // Create some custom attributes:  
 [AttributeUsage(System.AttributeTargets.Class, Inherited = false)]  
 class A1 : System.Attribute { }  
diff --git a/docs/csharp/programming-guide/concepts/attributes/common-attributes.md b/docs/csharp/programming-guide/concepts/attributes/common-attributes.md
index dc3efeef84c93..9304affcbf6f9 100644
--- a/docs/csharp/programming-guide/concepts/attributes/common-attributes.md
+++ b/docs/csharp/programming-guide/concepts/attributes/common-attributes.md
@@ -36,7 +36,7 @@ This topic describes the attributes that are most commonly used in C# programs.
 ##  <a name="Global"></a> Global Attributes  
  Most attributes are applied to specific language elements such as classes or methods; however, some attributes are global—they apply to an entire assembly or module. For example, the <xref:System.Reflection.AssemblyVersionAttribute> attribute can be used to embed version information into an assembly, like this:  
   
-```cs  
+```csharp  
 [assembly: AssemblyVersion("1.0.0.0")]  
 ```  
   
@@ -88,7 +88,7 @@ This topic describes the attributes that are most commonly used in C# programs.
 ##  <a name="Obsolete"></a> Obsolete Attribute  
  The `Obsolete` attribute marks a program entity as one that is no longer recommended for use. Each use of an entity marked obsolete will subsequently generate a warning or an error, depending on how the attribute is configured. For example:  
   
-```cs  
+```csharp  
 [System.Obsolete("use class B")]  
 class A  
 {  
@@ -106,7 +106,7 @@ class B
   
  The string provided as the first argument to attribute constructor will be displayed as part of the warning or error. For example, when you use it with the previous definitions, the following code generates two warnings and one error:  
   
-```cs  
+```csharp  
 // Generates 2 warnings:  
 // A a = new A();  
   
@@ -129,7 +129,7 @@ b.NewMethod();
   
  In this example, `Conditional` is applied to a method to enable or disable the display of program-specific diagnostic information:  
   
-```cs  
+```csharp  
 #define TRACE_ON  
 using System;  
 using System.Diagnostics;  
@@ -157,7 +157,7 @@ public class ProgramClass
   
  The `Conditional` attribute is often used with the `DEBUG` identifier to enable trace and logging features for debug builds but not in release builds, like this:  
   
-```cs  
+```csharp  
 [Conditional("DEBUG")]  
 static void DebugMethod()  
 {  
@@ -166,7 +166,7 @@ static void DebugMethod()
   
  When a method marked as conditional is called, the presence or absence of the specified preprocessing symbol determines whether the call is included or omitted. If the symbol is defined, the call is included; otherwise, the call is omitted. Using `Conditional` is a cleaner, more elegant, and less error-prone alternative to enclosing methods inside `#if…#endif` blocks, like this:  
   
-```cs  
+```csharp  
 #if DEBUG  
     void ConditionalMethod()  
     {  
@@ -179,7 +179,7 @@ static void DebugMethod()
 ### Using Multiple Identifiers  
  If a method has multiple `Conditional` attributes, a call to the method is included if at least one of the conditional symbols is defined (in other words, the symbols are logically linked together by using the OR operator). In this example, the presence of either `A` or `B` will result in a method call:  
   
-```cs  
+```csharp  
 [Conditional("A"), Conditional("B")]  
 static void DoIfAorB()  
 {  
@@ -189,7 +189,7 @@ static void DoIfAorB()
   
  To achieve the effect of logically linking symbols by using the AND operator, you can define serial conditional methods. For example, the second method below will execute only if both `A` and `B` are defined:  
   
-```cs  
+```csharp  
 <Conditional("A")>   
 Shared Sub DoIfA()  
     DoIfAandB()  
@@ -204,7 +204,7 @@ End Sub
 ### Using Conditional with Attribute Classes  
  The `Conditional` attribute can also be applied to an attribute class definition. In this example, the custom attribute `Documentation` will only add information to the metadata if DEBUG is defined.  
   
-```cs  
+```csharp  
 [Conditional("DEBUG")]  
 public class Documentation : System.Attribute  
 {  
diff --git a/docs/csharp/programming-guide/concepts/attributes/creating-custom-attributes.md b/docs/csharp/programming-guide/concepts/attributes/creating-custom-attributes.md
index b26f767df753f..cc58d387aad1e 100644
--- a/docs/csharp/programming-guide/concepts/attributes/creating-custom-attributes.md
+++ b/docs/csharp/programming-guide/concepts/attributes/creating-custom-attributes.md
@@ -25,7 +25,7 @@ translation.priority.mt:
 # Creating Custom Attributes (C#)
 You can create your own custom attributes by defining an attribute class, a class that derives directly or indirectly from <xref:System.Attribute>, which makes identifying attribute definitions in metadata fast and easy. Suppose you want to tag types with the name of the programmer who wrote the type. You might define a custom `Author` attribute class:  
   
-```cs  
+```csharp  
 [System.AttributeUsage(System.AttributeTargets.Class |  
                        System.AttributeTargets.Struct)  
 ]  
@@ -46,7 +46,7 @@ public class Author : System.Attribute
   
  You could use this new attribute as follows:  
   
-```cs  
+```csharp  
 [Author("P. Ackerman", version = 1.1)]  
 class SampleClass  
 {  
@@ -56,7 +56,7 @@ class SampleClass
   
  `AttributeUsage` has a named parameter, `AllowMultiple`, with which you can make a custom attribute single-use or multiuse. In the following code example, a multiuse attribute is created.  
   
-```cs  
+```csharp  
 [System.AttributeUsage(System.AttributeTargets.Class |  
                        System.AttributeTargets.Struct,  
                        AllowMultiple = true)  // multiuse attribute  
@@ -66,7 +66,7 @@ public class Author : System.Attribute
   
  In the following code example, multiple attributes of the same type are applied to a class.  
   
-```cs  
+```csharp  
 [Author("P. Ackerman", version = 1.1)]  
 [Author("R. Koch", version = 1.2)]  
 class SampleClass  
diff --git a/docs/csharp/programming-guide/concepts/attributes/how-to-create-a-c-cpp-union-by-using-attributes.md b/docs/csharp/programming-guide/concepts/attributes/how-to-create-a-c-cpp-union-by-using-attributes.md
index 7e63b11457bd1..88300f15aeb9f 100644
--- a/docs/csharp/programming-guide/concepts/attributes/how-to-create-a-c-cpp-union-by-using-attributes.md
+++ b/docs/csharp/programming-guide/concepts/attributes/how-to-create-a-c-cpp-union-by-using-attributes.md
@@ -28,7 +28,7 @@ By using attributes you can customize how structs are laid out in memory. For ex
 ## Example  
  In this code segment, all of the fields of `TestUnion` start at the same location in memory.  
   
-```cs  
+```csharp  
 // Add a using directive for System.Runtime.InteropServices.  
   
        [System.Runtime.InteropServices.StructLayout(LayoutKind.Explicit)]  
@@ -51,7 +51,7 @@ By using attributes you can customize how structs are laid out in memory. For ex
 ## Example  
  The following is another example where fields start at different explicitly set locations.  
   
-```cs  
+```csharp  
 // Add a using directive for System.Runtime.InteropServices.  
   
        [System.Runtime.InteropServices.StructLayout(LayoutKind.Explicit)]  
diff --git a/docs/csharp/programming-guide/concepts/attributes/index.md b/docs/csharp/programming-guide/concepts/attributes/index.md
index 9f9ecdf862bbb..332194da094fa 100644
--- a/docs/csharp/programming-guide/concepts/attributes/index.md
+++ b/docs/csharp/programming-guide/concepts/attributes/index.md
@@ -40,7 +40,7 @@ Attributes provide a powerful method of associating metadata, or declarative inf
   
  In this example, the <xref:System.SerializableAttribute> attribute is used to apply a specific characteristic to a class:  
   
-```cs  
+```csharp  
 [System.Serializable]  
 public class SampleClass  
 {  
@@ -50,22 +50,22 @@ public class SampleClass
   
  A method with the attribute <xref:System.Runtime.InteropServices.DllImportAttribute> is declared like this:  
   
-```cs  
+```csharp  
 using System.Runtime.InteropServices;  
 ```  
   
-```cs  
+```csharp  
 [System.Runtime.InteropServices.DllImport("user32.dll")]  
 extern static void SampleMethod();  
 ```  
   
  More than one attribute can be placed on a declaration:  
   
-```cs  
+```csharp  
 using System.Runtime.InteropServices;  
 ```  
   
-```cs  
+```csharp  
 void MethodA([In][Out] ref double x) { }  
 void MethodB([Out][In] ref double x) { }  
 void MethodC([In, Out] ref double x) { }  
@@ -73,7 +73,7 @@ void MethodC([In, Out] ref double x) { }
   
  Some attributes can be specified more than once for a given entity. An example of such a multiuse attribute is <xref:System.Diagnostics.ConditionalAttribute>:  
   
-```cs  
+```csharp  
 [Conditional("DEBUG"), Conditional("TEST1")]  
 void TraceMethod()  
 {  
@@ -87,7 +87,7 @@ void TraceMethod()
 ### Attribute Parameters  
  Many attributes have parameters, which can be positional, unnamed, or named. Any positional parameters must be specified in a certain order and cannot be omitted; named parameters are optional and can be specified in any order. Positional parameters are specified first. For example, these three attributes are equivalent:  
   
-```cs  
+```csharp  
 [DllImport("user32.dll")]  
 [DllImport("user32.dll", SetLastError=false, ExactSpelling=false)]  
 [DllImport("user32.dll", ExactSpelling=false, SetLastError=false)]  
@@ -100,7 +100,7 @@ void TraceMethod()
   
  To explicitly identify an attribute target, use the following syntax:  
   
-```cs  
+```csharp  
 [target : attribute-list]  
 ```  
   
@@ -120,7 +120,7 @@ void TraceMethod()
   
  The following example shows how to apply attributes to assemblies and modules. For more information, see [Common Attributes (C#)](../../../../csharp/programming-guide/concepts/attributes/common-attributes.md).  
   
-```cs  
+```csharp  
 using System;  
 using System.Reflection;  
 [assembly: AssemblyTitleAttribute("Production assembly 4")]  
@@ -129,7 +129,7 @@ using System.Reflection;
   
  The following example shows how to apply attributes to methods, method parameters, and method return values in C#.  
   
-```cs  
+```csharp  
 // default: applies to method  
 [SomeAttr]  
 int Method1() { return 0; }  
diff --git a/docs/csharp/programming-guide/concepts/caller-information.md b/docs/csharp/programming-guide/concepts/caller-information.md
index 2f56edf4f27d7..da17b867d91a5 100644
--- a/docs/csharp/programming-guide/concepts/caller-information.md
+++ b/docs/csharp/programming-guide/concepts/caller-information.md
@@ -36,7 +36,7 @@ By using Caller Info attributes, you can obtain information about the caller to
 ## Example  
  The following example shows how to use Caller Info attributes. On each call to the `TraceMessage` method, the caller information is substituted as arguments to the optional parameters.  
   
-```cs  
+```csharp  
 public void DoProcessing()  
 {  
     TraceMessage("Something happened.");  
diff --git a/docs/csharp/programming-guide/concepts/collections.md b/docs/csharp/programming-guide/concepts/collections.md
index 22fefc04af082..4c76e0eb455f7 100644
--- a/docs/csharp/programming-guide/concepts/collections.md
+++ b/docs/csharp/programming-guide/concepts/collections.md
@@ -64,7 +64,7 @@ For many applications, you want to create and manage groups of related objects.
   
  The following example creates a list of strings and then iterates through the strings by using a or [foreach](../../../csharp/language-reference/keywords/foreach-in.md) statement.  
   
-```cs  
+```csharp  
 // Create a list of strings.  
 var salmons = new List<string>();  
 salmons.Add("chinook");  
@@ -84,7 +84,7 @@ foreach (var salmon in salmons)
   
  The following example is the same as the previous example, except a collection initializer is used to add elements to the collection.  
   
-```cs  
+```csharp  
 // Create a list of strings by using a  
 // collection initializer.  
 var salmons = new List<string> { "chinook", "coho", "pink", "sockeye" };  
@@ -101,7 +101,7 @@ foreach (var salmon in salmons)
   
  The following example iterates through the elements of a collection by using `for` instead of `foreach`.  
   
-```cs  
+```csharp  
 // Create a list of strings by using a  
 // collection initializer.  
 var salmons = new List<string> { "chinook", "coho", "pink", "sockeye" };  
@@ -115,7 +115,7 @@ for (var index = 0; index < salmons.Count; index++)
   
  The following example removes an element from the collection by specifying the object to remove.  
   
-```cs  
+```csharp  
 // Create a list of strings by using a  
 // collection initializer.  
 var salmons = new List<string> { "chinook", "coho", "pink", "sockeye" };  
@@ -134,7 +134,7 @@ foreach (var salmon in salmons)
   
  The following example removes elements from a generic list. Instead of a `foreach` statement, a [for](../../../csharp/language-reference/keywords/for.md) statement that iterates in descending order is used. This is because the <xref:System.Collections.Generic.List%601.RemoveAt%2A> method causes elements after a removed element to have a lower index value.  
   
-```cs  
+```csharp  
 var numbers = new List<int> { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };  
   
 // Remove odd numbers.  
@@ -158,7 +158,7 @@ numbers.ForEach(
   
  For the type of elements in the <xref:System.Collections.Generic.List%601>, you can also define your own class. In the following example, the `Galaxy` class that is used by the <xref:System.Collections.Generic.List%601> is defined in the code.  
   
-```cs  
+```csharp  
 private static void IterateThroughList()  
 {  
     var theGalaxies = new List<Galaxy>  
@@ -247,7 +247,7 @@ public class Galaxy
   
  The following example creates a `Dictionary` collection and iterates through the dictionary by using a `foreach` statement.  
   
-```cs  
+```csharp  
 private static void IterateThruDictionary()  
 {  
     Dictionary<string, Element> elements = BuildDictionary();  
@@ -296,7 +296,7 @@ public class Element
   
  To instead use a collection initializer to build the `Dictionary` collection, you can replace the `BuildDictionary` and `AddToDictionary` methods with the following method.  
   
-```cs  
+```csharp  
 private static Dictionary<string, Element> BuildDictionary2()  
 {  
     return new Dictionary<string, Element>  
@@ -315,7 +315,7 @@ private static Dictionary<string, Element> BuildDictionary2()
   
  The following example uses the <xref:System.Collections.Generic.Dictionary%602.ContainsKey%2A> method and the <xref:System.Collections.Generic.Dictionary%602.Item%2A> property of `Dictionary` to quickly find an item by key. The `Item` property enables you to access an item in the `elements` collection by using the `elements[symbol]` in C#.  
   
-```cs  
+```csharp  
 private static void FindInDictionary(string symbol)  
 {  
     Dictionary<string, Element> elements = BuildDictionary();  
@@ -334,7 +334,7 @@ private static void FindInDictionary(string symbol)
   
  The following example instead uses the <xref:System.Collections.Generic.Dictionary%602.TryGetValue%2A> method quickly find an item by key.  
   
-```cs  
+```csharp  
 private static void FindInDictionary2(string symbol)  
 {  
     Dictionary<string, Element> elements = BuildDictionary();  
@@ -353,7 +353,7 @@ private static void FindInDictionary2(string symbol)
   
  The following example runs a LINQ query against a generic `List`. The LINQ query returns a different collection that contains the results.  
   
-```cs  
+```csharp  
 private static void ShowLINQ()  
 {  
     List<Element> elements = BuildList();  
@@ -402,7 +402,7 @@ public class Element
   
  In the `ListCars` method, the `cars.Sort()` statement sorts the list. This call to the <xref:System.Collections.Generic.List%601.Sort%2A> method of the <xref:System.Collections.Generic.List%601> causes the `CompareTo` method to be called automatically for the `Car` objects in the `List`.  
   
-```cs  
+```csharp  
 private static void ListCars()  
 {  
     var cars = new List<Car>  
@@ -482,7 +482,7 @@ public class Car : IComparable<Car>
   
  The `GetEnumerator` method returns an instance of the `ColorEnumerator` class. `ColorEnumerator` implements the <xref:System.Collections.IEnumerator> interface, which requires that the <xref:System.Collections.IEnumerator.Current%2A> property, <xref:System.Collections.IEnumerator.MoveNext%2A> method, and <xref:System.Collections.IEnumerator.Reset%2A> method be implemented.  
   
-```cs  
+```csharp  
 private static void ListColors()  
 {  
     var colors = new AllColors();  
@@ -563,7 +563,7 @@ public class Color
   
  The following example uses an iterator method. The iterator method has a `yield return` statement that is inside a [for](../../../csharp/language-reference/keywords/for.md) loop. In the `ListEvenNumbers` method, each iteration of the `foreach` statement body creates a call to the iterator method, which proceeds to the next `yield return` statement.  
   
-```cs  
+```csharp  
 private static void ListEvenNumbers()  
 {  
     foreach (int number in EvenSequence(5, 18))  
diff --git a/docs/csharp/programming-guide/concepts/covariance-contravariance/creating-variant-generic-interfaces.md b/docs/csharp/programming-guide/concepts/covariance-contravariance/creating-variant-generic-interfaces.md
index 7b2789fafc862..90b150b8796be 100644
--- a/docs/csharp/programming-guide/concepts/covariance-contravariance/creating-variant-generic-interfaces.md
+++ b/docs/csharp/programming-guide/concepts/covariance-contravariance/creating-variant-generic-interfaces.md
@@ -38,7 +38,7 @@ You can declare generic type parameters in interfaces as covariant or contravari
   
 -   The type is used only as a return type of interface methods and not used as a type of method arguments. This is illustrated in the following example, in which the type `R` is declared covariant.  
   
-    ```cs  
+    ```csharp  
     interface ICovariant<out R>  
     {  
         R GetSomething();  
@@ -50,7 +50,7 @@ You can declare generic type parameters in interfaces as covariant or contravari
   
      There is one exception to this rule. If you have a contravariant generic delegate as a method parameter, you can use the type as a generic type parameter for the delegate. This is illustrated by the type `R` in the following example. For more information, see [Variance in Delegates (C#)](../../../../csharp/programming-guide/concepts/covariance-contravariance/variance-in-delegates.md) and [Using Variance for Func and Action Generic Delegates (C#)](../../../../csharp/programming-guide/concepts/covariance-contravariance/using-variance-for-func-and-action-generic-delegates.md).  
   
-    ```cs  
+    ```csharp  
     interface ICovariant<out R>  
     {  
         void DoSomething(Action<R> callback);  
@@ -59,7 +59,7 @@ You can declare generic type parameters in interfaces as covariant or contravari
   
 -   The type is not used as a generic constraint for the interface methods. This is illustrated in the following code.  
   
-    ```cs  
+    ```csharp  
     interface ICovariant<out R>  
     {  
         // The following statement generates a compiler error  
@@ -71,7 +71,7 @@ You can declare generic type parameters in interfaces as covariant or contravari
   
  You can declare a generic type parameter contravariant by using the `in` keyword. The contravariant type can be used only as a type of method arguments and not as a return type of interface methods. The contravariant type can also be used for generic constraints. The following code shows how to declare a contravariant interface and use a generic constraint for one of its methods.  
   
-```cs  
+```csharp  
 interface IContravariant<in A>  
 {  
     void SetSomething(A sampleArg);  
@@ -83,7 +83,7 @@ interface IContravariant<in A>
   
  It is also possible to support both covariance and contravariance in the same interface, but for different type parameters, as shown in the following code example.  
   
-```cs  
+```csharp  
 interface IVariant<out R, in A>  
 {  
     R GetSomething();  
@@ -95,7 +95,7 @@ interface IVariant<out R, in A>
 ## Implementing Variant Generic Interfaces  
  You implement variant generic interfaces in classes by using the same syntax that is used for invariant interfaces. The following code example shows how to implement a covariant interface in a generic class.  
   
-```cs  
+```csharp  
 interface ICovariant<out R>  
 {  
     R GetSomething();  
@@ -112,7 +112,7 @@ class SampleImplementation<R> : ICovariant<R>
   
  Classes that implement variant interfaces are invariant. For example, consider the following code.  
   
-```cs  
+```csharp  
 // The interface is covariant.  
 ICovariant<Button> ibutton = new SampleImplementation<Button>();  
 ICovariant<Object> iobj = ibutton;  
@@ -127,7 +127,7 @@ SampleImplementation<Button> button = new SampleImplementation<Button>();
 ## Extending Variant Generic Interfaces  
  When you extend a variant generic interface, you have to use the `in` and `out` keywords to explicitly specify whether the derived interface supports variance. The compiler does not infer the variance from the interface that is being extended. For example, consider the following interfaces.  
   
-```cs  
+```csharp  
 nterface ICovariant<out T> { }  
 interface IInvariant<T> : ICovariant<T> { }  
 interface IExtCovariant<out T> : ICovariant<T> { }  
@@ -137,7 +137,7 @@ interface IExtCovariant<out T> : ICovariant<T> { }
   
  You can create an interface that extends both the interface where the generic type parameter `T` is covariant and the interface where it is contravariant if in the extending interface the generic type parameter `T` is invariant. This is illustrated in the following code example.  
   
-```cs  
+```csharp  
 interface ICovariant<out T> { }  
 interface IContravariant<in T> { }  
 interface IInvariant<T> : ICovariant<T>, IContravariant<T> { }  
@@ -145,7 +145,7 @@ interface IInvariant<T> : ICovariant<T>, IContravariant<T> { }
   
  However, if a generic type parameter `T` is declared covariant in one interface, you cannot declare it contravariant in the extending interface, or vice versa. This is illustrated in the following code example.  
   
-```cs  
+```csharp  
 interface ICovariant<out T> { }  
 // The following statement generates a compiler error.  
 // interface ICoContraVariant<in T> : ICovariant<T> { }  
@@ -156,7 +156,7 @@ interface ICovariant<out T> { }
   
  For example, if you explicitly implement the same variant generic interface with different generic type parameters in one class, it can create ambiguity. The compiler does not produce an error in this case, but it is not specified which interface implementation will be chosen at runtime. This could lead to subtle bugs in your code. Consider the following code example.  
   
-```cs  
+```csharp  
 // Simple class hierarchy.  
 class Animal { }  
 class Cat : Animal { }  
diff --git a/docs/csharp/programming-guide/concepts/covariance-contravariance/index.md b/docs/csharp/programming-guide/concepts/covariance-contravariance/index.md
index e82269d66412a..6cca4a1819148 100644
--- a/docs/csharp/programming-guide/concepts/covariance-contravariance/index.md
+++ b/docs/csharp/programming-guide/concepts/covariance-contravariance/index.md
@@ -27,7 +27,7 @@ In C#, covariance and contravariance enable implicit reference conversion for ar
   
  The following code demonstrates the difference between assignment compatibility, covariance, and contravariance.  
   
-```cs  
+```csharp  
 // Assignment compatibility.   
 string str = "test";  
 // An object of a more derived type is assigned to an object of a less derived type.   
@@ -52,7 +52,7 @@ Action<string> actString = actObject;
   
  Covariance for arrays enables implicit conversion of an array of a more derived type to an array of a less derived type. But this operation is not type safe, as shown in the following code example.  
   
-```cs  
+```csharp  
 object[] array = new String[10];  
 // The following statement produces a run-time exception.  
 // array[0] = 10;  
@@ -62,7 +62,7 @@ object[] array = new String[10];
   
  The following code example shows covariance and contravariance support for method groups.  
   
-```cs  
+```csharp  
 static object GetObject() { return null; }  
 static void SetObject(object obj) { }  
   
@@ -85,7 +85,7 @@ static void Test()
   
  The following code example shows implicit reference conversion for generic interfaces.  
   
-```cs  
+```csharp  
 IEnumerable<String> strings = new List<String>();  
 IEnumerable<Object> objects = strings;  
 ```  
diff --git a/docs/csharp/programming-guide/concepts/covariance-contravariance/using-variance-for-func-and-action-generic-delegates.md b/docs/csharp/programming-guide/concepts/covariance-contravariance/using-variance-for-func-and-action-generic-delegates.md
index 64cc4fedfb46d..4070b9bb73bb9 100644
--- a/docs/csharp/programming-guide/concepts/covariance-contravariance/using-variance-for-func-and-action-generic-delegates.md
+++ b/docs/csharp/programming-guide/concepts/covariance-contravariance/using-variance-for-func-and-action-generic-delegates.md
@@ -30,7 +30,7 @@ These examples demonstrate how to use covariance and contravariance in the `Func
 ## Using Delegates with Covariant Type Parameters  
  The following example illustrates the benefits of covariance support in the generic `Func` delegates. The `FindByTitle` method takes a parameter of the `String` type and returns an object of the `Employee` type. However, you can assign this method to the `Func<String, Person>` delegate because `Employee` inherits `Person`.  
   
-```cs  
+```csharp  
 // Simple hierarchy of classes.  
 public class Person { }  
 public class Employee : Person { }  
@@ -64,7 +64,7 @@ class Program
 ## Using Delegates with Contravariant Type Parameters  
  The following example illustrates the benefits of contravariance support in the generic `Action` delegates. The `AddToContacts` method takes a parameter of the `Person` type. However, you can assign this method to the `Action<Employee>` delegate because `Employee` inherits `Person`.  
   
-```cs  
+```csharp  
 public class Person { }  
 public class Employee : Person { }  
 class Program  
diff --git a/docs/csharp/programming-guide/concepts/covariance-contravariance/using-variance-in-delegates.md b/docs/csharp/programming-guide/concepts/covariance-contravariance/using-variance-in-delegates.md
index bed40669e9f8f..a0bef68e801e5 100644
--- a/docs/csharp/programming-guide/concepts/covariance-contravariance/using-variance-in-delegates.md
+++ b/docs/csharp/programming-guide/concepts/covariance-contravariance/using-variance-in-delegates.md
@@ -32,7 +32,7 @@ When you assign a method to a delegate, *covariance* and *contravariance* provid
   
 ### Code  
   
-```cs  
+```csharp  
 class Mammals{}  
 class Dogs : Mammals{}  
   
@@ -68,7 +68,7 @@ class Program
   
 ### Code  
   
-```cs  
+```csharp  
 // Event hander that accepts a parameter of the EventArgs type.  
 private void MultiHandler(object sender, System.EventArgs e)  
 {  
diff --git a/docs/csharp/programming-guide/concepts/covariance-contravariance/using-variance-in-interfaces-for-generic-collections.md b/docs/csharp/programming-guide/concepts/covariance-contravariance/using-variance-in-interfaces-for-generic-collections.md
index ea198798cb752..31706014a9e07 100644
--- a/docs/csharp/programming-guide/concepts/covariance-contravariance/using-variance-in-interfaces-for-generic-collections.md
+++ b/docs/csharp/programming-guide/concepts/covariance-contravariance/using-variance-in-interfaces-for-generic-collections.md
@@ -32,7 +32,7 @@ A covariant interface allows its methods to return more derived types than those
 ## Converting Generic Collections  
  The following example illustrates the benefits of covariance support in the <xref:System.Collections.Generic.IEnumerable%601> interface. The `PrintFullName` method accepts a collection of the `IEnumerable<Person>` type as a parameter. However, you can reuse it for a collection of the `IEnumerable<Employee>` type because `Employee` inherits `Person`.  
   
-```cs  
+```csharp  
 // Simple hierarchy of classes.  
 public class Person  
 {  
@@ -70,7 +70,7 @@ class Program
 ## Comparing Generic Collections  
  The following example illustrates the benefits of contravariance support in the <xref:System.Collections.Generic.IComparer%601> interface. The `PersonComparer` class implements the `IComparer<Person>` interface. However, you can reuse this class to compare a sequence of objects of the `Employee` type because `Employee` inherits `Person`.  
   
-```cs  
+```csharp  
 // Simple hierarchy of classes.  
 public class Person  
 {  
diff --git a/docs/csharp/programming-guide/concepts/covariance-contravariance/variance-in-delegates.md b/docs/csharp/programming-guide/concepts/covariance-contravariance/variance-in-delegates.md
index 4c037af64fffb..00cd5a2df837c 100644
--- a/docs/csharp/programming-guide/concepts/covariance-contravariance/variance-in-delegates.md
+++ b/docs/csharp/programming-guide/concepts/covariance-contravariance/variance-in-delegates.md
@@ -27,7 +27,7 @@ translation.priority.mt:
   
  For example, consider the following code, which has two classes and two delegates: generic and non-generic.  
   
-```cs  
+```csharp  
 public class First { }  
 public class Second : First { }  
 public delegate First SampleDelegate(Second a);  
@@ -36,7 +36,7 @@ public delegate R SampleGenericDelegate<A, R>(A a);
   
  When you create delegates of the `SampleDelegate` or `SampleGenericDelegate<A, R>` types, you can assign any one of the following methods to those delegates.  
   
-```cs  
+```csharp  
 // Matching signature.  
 public static First ASecondRFirst(Second first)  
 { return new First(); }  
@@ -57,7 +57,7 @@ public static Second AFirstRSecond(First first)
   
  The following code example illustrates the implicit conversion between the method signature and the delegate type.  
   
-```cs  
+```csharp  
 // Assigning a method with a matching signature   
 // to a non-generic delegate. No conversion is necessary.  
 SampleDelegate dNonGeneric = ASecondRFirst;  
@@ -84,7 +84,7 @@ SampleGenericDelegate<Second, First> dGenericConversion = AFirstRSecond;
   
  The following code example shows how you can create a delegate that has a covariant generic type parameter.  
   
-```cs  
+```csharp  
 // Type T is declared covariant by using the out keyword.  
 public delegate T SampleGenericDelegate <out T>();  
   
@@ -102,7 +102,7 @@ public static void Test()
   
  In the following code example, `SampleGenericDelegate<String>` cannot be explicitly converted to `SampleGenericDelegate<Object>`, although `String` inherits `Object`. You can fix this problem by marking the generic parameter `T` with the `out` keyword.  
   
-```cs  
+```csharp  
 public delegate T SampleGenericDelegate<T>();  
   
 public static void Test()  
@@ -142,13 +142,13 @@ public static void Test()
   
  You can declare a generic type parameter covariant in a generic delegate by using the `out` keyword. The covariant type can be used only as a method return type and not as a type of method arguments. The following code example shows how to declare a covariant generic delegate.  
   
-```cs  
+```csharp  
 public delegate R DCovariant<out R>();  
 ```  
   
  You can declare a generic type parameter contravariant in a generic delegate by using the `in` keyword. The contravariant type can be used only as a type of method arguments and not as a method return type. The following code example shows how to declare a contravariant generic delegate.  
   
-```cs  
+```csharp  
 public delegate void DContravariant<in A>(A a);  
 ```  
   
@@ -157,14 +157,14 @@ public delegate void DContravariant<in A>(A a);
   
  It is also possible to support both variance and covariance in the same delegate, but for different type parameters. This is shown in the following example.  
   
-```cs  
+```csharp  
 public delegate R DVariant<in A, out R>(A a);  
 ```  
   
 ### Instantiating and Invoking Variant Generic Delegates  
  You can instantiate and invoke variant delegates just as you instantiate and invoke invariant delegates. In the following example, the delegate is instantiated by a lambda expression.  
   
-```cs  
+```csharp  
 DVariant<String, String> dvariant = (String str) => str + " ";  
 dvariant("test");  
 ```  
@@ -172,7 +172,7 @@ dvariant("test");
 ### Combining Variant Generic Delegates  
  You should not combine variant delegates. The <xref:System.Delegate.Combine%2A> method does not support variant delegate conversion and expects delegates to be of exactly the same type. This can lead to a run-time exception when you combine delegates either by using the <xref:System.Delegate.Combine%2A> method or by using the `+` operator, as shown in the following code example.  
   
-```cs  
+```csharp  
 Action<object> actObj = x => Console.WriteLine("object: {0}", x);  
 Action<string> actStr = x => Console.WriteLine("string: {0}", x);  
 // All of the following statements throw exceptions at run time.  
@@ -186,7 +186,7 @@ Action<string> actStr = x => Console.WriteLine("string: {0}", x);
   
  The following example demonstrates that variance in generic type parameters is not supported for value types.  
   
-```cs  
+```csharp  
 // The type T is covariant.  
 public delegate T DVariant<out T>();  
   
diff --git a/docs/csharp/programming-guide/concepts/covariance-contravariance/variance-in-generic-interfaces.md b/docs/csharp/programming-guide/concepts/covariance-contravariance/variance-in-generic-interfaces.md
index 42ed1a50ae0f9..afa804094094a 100644
--- a/docs/csharp/programming-guide/concepts/covariance-contravariance/variance-in-generic-interfaces.md
+++ b/docs/csharp/programming-guide/concepts/covariance-contravariance/variance-in-generic-interfaces.md
@@ -41,7 +41,7 @@ translation.priority.mt:
   
  Covariance permits a method to have a more derived return type than that defined by the generic type parameter of the interface. To illustrate the covariance feature, consider these generic interfaces: `IEnumerable<Object>` and `IEnumerable<String>`. The `IEnumerable<String>` interface does not inherit the `IEnumerable<Object>` interface. However, the `String` type does inherit the `Object` type, and in some cases you may want to assign objects of these interfaces to each other. This is shown in the following code example.  
   
-```cs  
+```csharp  
 IEnumerable<String> strings = new List<String>();  
 IEnumerable<Object> objects = strings;  
 ```  
@@ -50,7 +50,7 @@ IEnumerable<Object> objects = strings;
   
  Contravariance permits a method to have argument types that are less derived than that specified by the generic parameter of the interface. To illustrate contravariance, assume that you have created a `BaseComparer` class to compare instances of the `BaseClass` class. The `BaseComparer` class implements the `IEqualityComparer<BaseClass>` interface. Because the <xref:System.Collections.Generic.IEqualityComparer%601> interface is now contravariant, you can use `BaseComparer` to compare instances of classes that inherit the `BaseClass` class. This is shown in the following code example.  
   
-```cs  
+```csharp  
 // Simple hierarchy of classes.  
 class BaseClass { }  
 class DerivedClass : BaseClass { }  
@@ -84,7 +84,7 @@ class Program
   
  Variance in generic interfaces is supported for reference types only. Value types do not support variance. For example, `IEnumerable<int>` cannot be implicitly converted to `IEnumerable<object>`, because integers are represented by a value type.  
   
-```cs  
+```csharp  
 IEnumerable<int> integers = new List<int>();  
 // The following statement generates a compiler errror,  
 // because int is a value type.  
@@ -93,7 +93,7 @@ IEnumerable<int> integers = new List<int>();
   
  It is also important to remember that classes that implement variant interfaces are still invariant. For example, although <xref:System.Collections.Generic.List%601> implements the covariant interface <xref:System.Collections.Generic.IEnumerable%601>, you cannot implicitly convert `List<Object>` to `List<String>`. This is illustrated in the following code example.  
   
-```cs  
+```csharp  
 // The following line generates a compiler error  
 // because classes are invariant.  
 // List<Object> list = new List<String>();  
diff --git a/docs/csharp/programming-guide/concepts/expression-trees/how-to-execute-expression-trees.md b/docs/csharp/programming-guide/concepts/expression-trees/how-to-execute-expression-trees.md
index af21c8338def8..3907226bae23c 100644
--- a/docs/csharp/programming-guide/concepts/expression-trees/how-to-execute-expression-trees.md
+++ b/docs/csharp/programming-guide/concepts/expression-trees/how-to-execute-expression-trees.md
@@ -35,7 +35,7 @@ This topic shows you how to execute an expression tree. Executing an expression
 ## Example  
  The following code example demonstrates how to execute an expression tree that represents raising a number to a power by creating a lambda expression and executing it. The result, which represents the number raised to the power, is displayed.  
   
-```cs  
+```csharp  
 // The expression tree to execute.  
 BinaryExpression be = Expression.Power(Expression.Constant(2D), Expression.Constant(3D));  
   
diff --git a/docs/csharp/programming-guide/concepts/expression-trees/how-to-modify-expression-trees.md b/docs/csharp/programming-guide/concepts/expression-trees/how-to-modify-expression-trees.md
index d406454c697fd..9eac12fa97201 100644
--- a/docs/csharp/programming-guide/concepts/expression-trees/how-to-modify-expression-trees.md
+++ b/docs/csharp/programming-guide/concepts/expression-trees/how-to-modify-expression-trees.md
@@ -33,7 +33,7 @@ This topic shows you how to modify an expression tree. Expression trees are immu
   
 3.  Add the `AndAlsoModifier` class to your project.  
   
-    ```cs  
+    ```csharp  
     public class AndAlsoModifier : ExpressionVisitor  
     {  
         public Expression Modify(Expression expression)  
@@ -63,7 +63,7 @@ This topic shows you how to modify an expression tree. Expression trees are immu
   
 5.  Add code to the `Main` method in the Program.cs file to create an expression tree and pass it to the method that will modify it.  
   
-    ```cs  
+    ```csharp  
     Expression<Func<string, bool>> expr = name => name.Length > 10 && name.StartsWith("G");  
     Console.WriteLine(expr);  
   
diff --git a/docs/csharp/programming-guide/concepts/expression-trees/how-to-use-expression-trees-to-build-dynamic-queries.md b/docs/csharp/programming-guide/concepts/expression-trees/how-to-use-expression-trees-to-build-dynamic-queries.md
index 12c1a7a5f7638..9907369427ab2 100644
--- a/docs/csharp/programming-guide/concepts/expression-trees/how-to-use-expression-trees-to-build-dynamic-queries.md
+++ b/docs/csharp/programming-guide/concepts/expression-trees/how-to-use-expression-trees-to-build-dynamic-queries.md
@@ -36,7 +36,7 @@ In LINQ, expression trees are used to represent structured queries that target s
   
  The factory methods in the <xref:System.Linq.Expressions> namespace are used to create expression trees that represent the expressions that make up the overall query. The expressions that represent calls to the standard query operator methods refer to the <xref:System.Linq.Queryable> implementations of these methods. The final expression tree is passed to the <xref:System.Linq.IQueryProvider.CreateQuery%60%601%28System.Linq.Expressions.Expression%29> implementation of the provider of the `IQueryable` data source to create an executable query of type `IQueryable`. The results are obtained by enumerating that query variable.  
   
-```cs  
+```csharp  
 // Add a using directive for System.Linq.Expressions.  
   
 string[] companies = { "Consolidated Messenger", "Alpine Ski House", "Southridge Video", "City Power & Light",  
diff --git a/docs/csharp/programming-guide/concepts/expression-trees/index.md b/docs/csharp/programming-guide/concepts/expression-trees/index.md
index c1dbfc3288c6b..e43cc28ec58c1 100644
--- a/docs/csharp/programming-guide/concepts/expression-trees/index.md
+++ b/docs/csharp/programming-guide/concepts/expression-trees/index.md
@@ -38,7 +38,7 @@ Expression trees represent code in a tree-like data structure, where each node i
   
  The following code examples demonstrate how to have the C# compiler create an expression tree that represents the lambda expression `num => num < 5`.  
   
-```cs  
+```csharp  
 Expression<Func<int, bool>> lambda = num => num < 5;  
 ```  
   
@@ -47,7 +47,7 @@ Expression<Func<int, bool>> lambda = num => num < 5;
   
  The following code example demonstrates how to create an expression tree that represents the lambda expression `num => num < 5` by using the API.  
   
-```cs  
+```csharp  
 // Add the following using directive to your code file:  
 // using System.Linq.Expressions;  
   
@@ -64,7 +64,7 @@ Expression<Func<int, bool>> lambda1 =
   
  In .NET Framework 4 or later, the expression trees API also supports assignments and control flow expressions such as loops, conditional blocks, and `try-catch` blocks. By using the API, you can create expression trees that are more complex than those that can be created from lambda expressions by the C# compiler. The following example demonstrates how to create an expression tree that calculates the factorial of a number.  
   
-```cs  
+```csharp  
 // Creating a parameter expression.  
 ParameterExpression value = Expression.Parameter(typeof(int), "value");  
   
@@ -109,7 +109,7 @@ Console.WriteLine(factorial);
 ## Parsing Expression Trees  
  The following code example demonstrates how the expression tree that represents the lambda expression `num => num < 5` can be decomposed into its parts.  
   
-```cs  
+```csharp  
 // Add the following using directive to your code file:  
 // using System.Linq.Expressions;  
   
@@ -138,7 +138,7 @@ Console.WriteLine("Decomposed expression: {0} => {1} {2} {3}",
   
  The following code example demonstrates how to compile an expression tree and run the resulting code.  
   
-```cs  
+```csharp  
 // Creating an expression tree.  
 Expression<Func<int, bool>> expr = num => num < 5;  
   
diff --git a/docs/csharp/programming-guide/concepts/iterators.md b/docs/csharp/programming-guide/concepts/iterators.md
index ed2348045b6e6..614c3496c1014 100644
--- a/docs/csharp/programming-guide/concepts/iterators.md
+++ b/docs/csharp/programming-guide/concepts/iterators.md
@@ -31,7 +31,7 @@ An *iterator* can be used to step through collections such as lists and arrays.
   
  In the following example, the first iteration of the `foreach` loop causes execution to proceed  in the `SomeNumbers` iterator method until the first `yield return` statement is reached. This iteration returns a value of 3, and the current location in the iterator method is retained. On the next iteration of the loop, execution in the iterator method continues from where it left off, again stopping when it reaches a `yield return` statement. This iteration returns a value of 5, and the current location in the iterator method is again retained. The loop completes when the end of the iterator method is reached.  
   
-```cs  
+```csharp  
 static void Main()  
 {  
     foreach (int number in SomeNumbers())  
@@ -76,7 +76,7 @@ public static System.Collections.IEnumerable SomeNumbers()
 ##  <a name="BKMK_SimpleIterator"></a> Simple Iterator  
  The following example has a single `yield return` statement that is inside a [for](../../../csharp/language-reference/keywords/for.md) loop. In `Main`, each iteration of the `foreach` statement body creates a call to the iterator function, which proceeds to the next `yield return` statement.  
   
-```cs  
+```csharp  
 static void Main()  
 {  
     foreach (int number in EvenSequence(5, 18))  
@@ -106,7 +106,7 @@ public static System.Collections.Generic.IEnumerable<int>
   
  The `GetEnumerator` method returns each string one at a time by using the `yield return` statement.  
   
-```cs  
+```csharp  
 static void Main()  
 {  
     DaysOfTheWeek days = new DaysOfTheWeek();  
@@ -138,7 +138,7 @@ public class DaysOfTheWeek : IEnumerable
   
  The `foreach` statement that refers to the class instance (`theZoo`) implicitly calls the `GetEnumerator` method. The `foreach` statements that refer to the `Birds` and `Mammals` properties use the `AnimalsForType` named iterator method.  
   
-```cs  
+```csharp  
 static void Main()  
 {  
     Zoo theZoo = new Zoo();  
@@ -239,7 +239,7 @@ public class Zoo : IEnumerable
   
  The `BottomToTop` property uses an iterator in a `get` accessor.  
   
-```cs  
+```csharp  
 static void Main()  
 {  
     Stack<int> theStack = new Stack<int>();  
diff --git a/docs/csharp/programming-guide/concepts/linq/adding-elements-attributes-and-nodes-to-an-xml-tree.md b/docs/csharp/programming-guide/concepts/linq/adding-elements-attributes-and-nodes-to-an-xml-tree.md
index cd7dd084cea46..f4099458e7466 100644
--- a/docs/csharp/programming-guide/concepts/linq/adding-elements-attributes-and-nodes-to-an-xml-tree.md
+++ b/docs/csharp/programming-guide/concepts/linq/adding-elements-attributes-and-nodes-to-an-xml-tree.md
@@ -42,7 +42,7 @@ You can add content (elements, attributes, comments, processing instructions, te
   
 ### Code  
   
-```cs  
+```csharp  
 XElement srcTree = new XElement("Root",   
     new XElement("Element1", 1),  
     new XElement("Element2", 2),  
diff --git a/docs/csharp/programming-guide/concepts/linq/atomized-xname-and-xnamespace-objects-linq-to-xml.md b/docs/csharp/programming-guide/concepts/linq/atomized-xname-and-xnamespace-objects-linq-to-xml.md
index c8a8d0d7ccc1e..579e2fdfe4bb8 100644
--- a/docs/csharp/programming-guide/concepts/linq/atomized-xname-and-xnamespace-objects-linq-to-xml.md
+++ b/docs/csharp/programming-guide/concepts/linq/atomized-xname-and-xnamespace-objects-linq-to-xml.md
@@ -30,7 +30,7 @@ ms.author: "wiwagn"
 ## Example  
  The following code creates some <xref:System.Xml.Linq.XElement> objects and demonstrates that identical names share the same instance.  
   
-```cs  
+```csharp  
 XElement r1 = new XElement("Root", "data1");  
 XElement r2 = XElement.Parse("<Root>data2</Root>");  
   
@@ -58,7 +58,7 @@ The name of r1 and the name in 'n' refer to the same instance.
   
  The following example passes an <xref:System.Xml.Linq.XName> to the <xref:System.Xml.Linq.XContainer.Descendants%2A> method call, which then has better performance because of the atomization pattern.  
   
-```cs  
+```csharp  
 XElement root = new XElement("Root",  
     new XElement("C1", 1),  
     new XElement("Z1",  
diff --git a/docs/csharp/programming-guide/concepts/linq/chaining-queries-example.md b/docs/csharp/programming-guide/concepts/linq/chaining-queries-example.md
index acb3e10e02fbd..5ba74cf5d9b02 100644
--- a/docs/csharp/programming-guide/concepts/linq/chaining-queries-example.md
+++ b/docs/csharp/programming-guide/concepts/linq/chaining-queries-example.md
@@ -23,7 +23,7 @@ This example builds on the previous example and shows what happens when you chai
 ## Example  
  In this example, another extension method is introduced, `AppendString`, which appends a specified string onto every string in the source collection, and then yields the new strings.  
   
-```cs  
+```csharp  
 public static class LocalExtensions  
 {  
     public static IEnumerable<string>  
diff --git a/docs/csharp/programming-guide/concepts/linq/chaining-standard-query-operators-together.md b/docs/csharp/programming-guide/concepts/linq/chaining-standard-query-operators-together.md
index 37754b1747ceb..8809330e595da 100644
--- a/docs/csharp/programming-guide/concepts/linq/chaining-standard-query-operators-together.md
+++ b/docs/csharp/programming-guide/concepts/linq/chaining-standard-query-operators-together.md
@@ -33,7 +33,7 @@ This is the final topic in the [Tutorial: Chaining Queries Together (C#)](../../
   
  All of the examples in this section that are querying Office Open XML documents use the same principle. Deferred execution and lazy evaluation are some of the fundamental concepts that you must understand  to use LINQ (and LINQ to XML) effectively.  
   
-```cs  
+```csharp  
 public static class LocalExtensions  
 {  
     public static IEnumerable<string>  
diff --git a/docs/csharp/programming-guide/concepts/linq/cloning-vs-attaching.md b/docs/csharp/programming-guide/concepts/linq/cloning-vs-attaching.md
index 830a294d9c496..ea94e0bf01468 100644
--- a/docs/csharp/programming-guide/concepts/linq/cloning-vs-attaching.md
+++ b/docs/csharp/programming-guide/concepts/linq/cloning-vs-attaching.md
@@ -28,7 +28,7 @@ When adding <xref:System.Xml.Linq.XNode> (including <xref:System.Xml.Linq.XEleme
 ## Example  
  The following code demonstrates the behavior when you add a parented element to a tree, and when you add an element with no parent to a tree.  
   
-```cs  
+```csharp  
 // Create a tree with a child element.  
 XElement xmlTree1 = new XElement("Root",  
     new XElement("Child1", 1)  
diff --git a/docs/csharp/programming-guide/concepts/linq/comparison-of-xpath-and-linq-to-xml.md b/docs/csharp/programming-guide/concepts/linq/comparison-of-xpath-and-linq-to-xml.md
index 300b1cfba1225..e1b08c2023498 100644
--- a/docs/csharp/programming-guide/concepts/linq/comparison-of-xpath-and-linq-to-xml.md
+++ b/docs/csharp/programming-guide/concepts/linq/comparison-of-xpath-and-linq-to-xml.md
@@ -71,13 +71,13 @@ XPath and [!INCLUDE[sqltecxlinq](../../../../csharp/programming-guide/concepts/l
   
  For example, if you have an element in a variable named `customers`, and you want to find a grandchild element named `CompanyName` under all child elements named `Customer`, you would write an XPath expression as follows:  
   
-```cs  
+```csharp  
 customers.XPathSelectElements("./Customer/CompanyName");  
 ```  
   
  The equivalent [!INCLUDE[sqltecxlinq](../../../../csharp/programming-guide/concepts/linq/includes/sqltecxlinq_md.md)] query is:  
   
-```cs  
+```csharp  
 customers.Element("Customer").Elements("CompanyName");  
 ```  
   
diff --git a/docs/csharp/programming-guide/concepts/linq/converting-data-types.md b/docs/csharp/programming-guide/concepts/linq/converting-data-types.md
index b376b0f5784a6..8b2a1d052b972 100644
--- a/docs/csharp/programming-guide/concepts/linq/converting-data-types.md
+++ b/docs/csharp/programming-guide/concepts/linq/converting-data-types.md
@@ -52,7 +52,7 @@ Conversion methods change the type of input objects.
 ## Query Expression Syntax Example  
  The following code example uses an explicitly-typed range variable  to cast a type to a subtype before accessing a member that is available only on the subtype.  
   
-```cs  
+```csharp  
 class Plant  
 {  
     public string Name { get; set; }  
diff --git a/docs/csharp/programming-guide/concepts/linq/creating-xml-trees-linq-to-xml-2.md b/docs/csharp/programming-guide/concepts/linq/creating-xml-trees-linq-to-xml-2.md
index aed881317f164..702daa446ee86 100644
--- a/docs/csharp/programming-guide/concepts/linq/creating-xml-trees-linq-to-xml-2.md
+++ b/docs/csharp/programming-guide/concepts/linq/creating-xml-trees-linq-to-xml-2.md
@@ -34,7 +34,7 @@ This section provides information about creating XML trees in C#.
   
  To create a `contacts`<xref:System.Xml.Linq.XElement>, you could use the following code:  
   
-```cs  
+```csharp  
 XElement contacts =  
     new XElement("Contacts",  
         new XElement("Contact",  
@@ -78,7 +78,7 @@ XElement contacts =
 ### Creating an XElement with Content  
  You can create an <xref:System.Xml.Linq.XElement> that contains simple content with a single method call. To do this, specify the content as the second parameter, as follows:  
   
-```cs  
+```csharp  
 XElement n = new XElement("Customer", "Adventure Works");  
 Console.WriteLine(n);  
 ```  
@@ -91,7 +91,7 @@ Console.WriteLine(n);
   
  You can pass any type of object as the content. For example, the following code creates an element that contains a floating point number as content:  
   
-```cs  
+```csharp  
 XElement n = new XElement("Cost", 324.50);  
 Console.WriteLine(n);  
 ```  
@@ -107,7 +107,7 @@ Console.WriteLine(n);
 ### Creating an XElement with a Child Element  
  If you pass an instance of the <xref:System.Xml.Linq.XElement> class for the content argument, the constructor creates an element with a child element:  
   
-```cs  
+```csharp  
 XElement shippingUnit = new XElement("ShippingUnit",  
     new XElement("Cost", 324.50)  
 );  
@@ -125,7 +125,7 @@ Console.WriteLine(shippingUnit);
 ### Creating an XElement with Multiple Child Elements  
  You can pass in a number of <xref:System.Xml.Linq.XElement> objects for the content. Each of the <xref:System.Xml.Linq.XElement> objects is included as a child element.  
   
-```cs  
+```csharp  
 XElement address = new XElement("Address",  
     new XElement("Street1", "123 Main St"),  
     new XElement("City", "Mercer Island"),  
@@ -148,7 +148,7 @@ Console.WriteLine(address);
   
  By extending the above example, you can create an entire XML tree, as follows:  
   
-```cs  
+```csharp  
 XElement contacts =  
     new XElement("Contacts",  
         new XElement("Contact",  
@@ -185,7 +185,7 @@ Console.WriteLine(contacts);
 ### Creating an Empty Element  
  To create an empty <xref:System.Xml.Linq.XElement>, you do not pass any content to the constructor. The following example creates an empty element:  
   
-```cs  
+```csharp  
 XElement n = new XElement("Customer");  
 Console.WriteLine(n);  
 ```  
@@ -199,7 +199,7 @@ Console.WriteLine(n);
 ### Attaching vs. Cloning  
  As mentioned previously, when adding <xref:System.Xml.Linq.XNode> (including <xref:System.Xml.Linq.XElement>) or <xref:System.Xml.Linq.XAttribute> objects, if the new content has no parent, the objects are simply attached to the XML tree. If the new content already is parented and is part of another XML tree, the new content is cloned, and the newly cloned content is attached to the XML tree.  
   
-```cs  
+```csharp  
 // Create a tree with a child element.  
 XElement xmlTree1 = new XElement("Root",  
     new XElement("Child1", 1)  
diff --git a/docs/csharp/programming-guide/concepts/linq/deferred-execution-example.md b/docs/csharp/programming-guide/concepts/linq/deferred-execution-example.md
index 933bd17595046..f0d26e2451b40 100644
--- a/docs/csharp/programming-guide/concepts/linq/deferred-execution-example.md
+++ b/docs/csharp/programming-guide/concepts/linq/deferred-execution-example.md
@@ -23,7 +23,7 @@ This topic shows how deferred execution and lazy evaluation affect the execution
 ## Example  
  The following example shows the order of execution when using an extension method that uses deferred execution. The example declares an array of three strings. It then iterates through the collection returned by `ConvertCollectionToUpperCase`.  
   
-```cs  
+```csharp  
 public static class LocalExtensions  
 {  
     public static IEnumerable<string>  
diff --git a/docs/csharp/programming-guide/concepts/linq/example-that-outputs-office-open-xml-document-parts.md b/docs/csharp/programming-guide/concepts/linq/example-that-outputs-office-open-xml-document-parts.md
index 74ec171037ad3..ea40b0b1eded0 100644
--- a/docs/csharp/programming-guide/concepts/linq/example-that-outputs-office-open-xml-document-parts.md
+++ b/docs/csharp/programming-guide/concepts/linq/example-that-outputs-office-open-xml-document-parts.md
@@ -25,7 +25,7 @@ This topic shows how to open an Office Open XML document and access parts within
   
  This example uses classes from the WindowsBase assembly. It uses types in the <xref:System.IO.Packaging?displayProperty=fullName> namespace.  
   
-```cs  
+```csharp  
 const string fileName = "SampleDoc.docx";  
   
 const string documentRelationshipType =  
diff --git a/docs/csharp/programming-guide/concepts/linq/filtering-data.md b/docs/csharp/programming-guide/concepts/linq/filtering-data.md
index e0e6a4cb0cd80..9ee80ef32c162 100644
--- a/docs/csharp/programming-guide/concepts/linq/filtering-data.md
+++ b/docs/csharp/programming-guide/concepts/linq/filtering-data.md
@@ -41,7 +41,7 @@ Filtering refers to the operation of restricting the result set to contain only
 ## Query Expression Syntax Example  
  The following example uses the `where` clause to filter from an array those strings that have a specific length.  
   
-```cs  
+```csharp  
 string[] words = { "the", "quick", "brown", "fox", "jumps" };  
   
 IEnumerable<string> query = from word in words  
diff --git a/docs/csharp/programming-guide/concepts/linq/finding-text-in-word-documents.md b/docs/csharp/programming-guide/concepts/linq/finding-text-in-word-documents.md
index eb231d7a8cfe0..91d71a8900f94 100644
--- a/docs/csharp/programming-guide/concepts/linq/finding-text-in-word-documents.md
+++ b/docs/csharp/programming-guide/concepts/linq/finding-text-in-word-documents.md
@@ -27,7 +27,7 @@ This topic extends the previous queries to do something useful: find all occurre
   
  This example uses classes found in the WindowsBase assembly. It uses types in the <xref:System.IO.Packaging?displayProperty=fullName> namespace.  
   
-```cs  
+```csharp  
 public static class LocalExtensions  
 {  
     public static string StringConcatenate(this IEnumerable<string> source)  
@@ -182,7 +182,7 @@ StyleName:Code >Hello World<
   
  You can, of course, modify the search so that it searches for lines with a specific style. The following query finds all blank lines that have the Code style:  
   
-```cs  
+```csharp  
 public static class LocalExtensions  
 {  
     public static string StringConcatenate(this IEnumerable<string> source)  
diff --git a/docs/csharp/programming-guide/concepts/linq/finding-the-default-paragraph-style.md b/docs/csharp/programming-guide/concepts/linq/finding-the-default-paragraph-style.md
index bc8d8b45bf19b..c538e84a30010 100644
--- a/docs/csharp/programming-guide/concepts/linq/finding-the-default-paragraph-style.md
+++ b/docs/csharp/programming-guide/concepts/linq/finding-the-default-paragraph-style.md
@@ -31,7 +31,7 @@ The first task in the Manipulating Information in a WordprocessingML Document tu
   
 ### Code  
   
-```cs  
+```csharp  
 const string fileName = "SampleDoc.docx";  
   
 const string documentRelationshipType =  
diff --git a/docs/csharp/programming-guide/concepts/linq/functional-construction-linq-to-xml.md b/docs/csharp/programming-guide/concepts/linq/functional-construction-linq-to-xml.md
index 98f666a478b87..9973621fd4ea6 100644
--- a/docs/csharp/programming-guide/concepts/linq/functional-construction-linq-to-xml.md
+++ b/docs/csharp/programming-guide/concepts/linq/functional-construction-linq-to-xml.md
@@ -35,7 +35,7 @@ translation.priority.mt:
   
  These features enable you to write code to create an XML tree. The following is an example:  
   
-```cs  
+```csharp  
 XElement contacts =  
     new XElement("Contacts",  
         new XElement("Contact",  
@@ -53,7 +53,7 @@ XElement contacts =
   
  These features also enable you to write code that uses the results of [!INCLUDE[vbteclinq](../../../../csharp/includes/vbteclinq_md.md)] queries when you create an XML tree, as follows:  
   
-```cs  
+```csharp  
 XElement srcTree = new XElement("Root",  
     new XElement("Element", 1),  
     new XElement("Element", 2),  
diff --git a/docs/csharp/programming-guide/concepts/linq/grouping-data.md b/docs/csharp/programming-guide/concepts/linq/grouping-data.md
index 2116637176a41..61213f8f19c58 100644
--- a/docs/csharp/programming-guide/concepts/linq/grouping-data.md
+++ b/docs/csharp/programming-guide/concepts/linq/grouping-data.md
@@ -41,7 +41,7 @@ Grouping refers to the operation of putting data into groups so that the element
 ## Query Expression Syntax Example  
  The following code example uses the `group by` clause to group integers in a list according to whether they are even or odd.  
   
-```cs  
+```csharp  
 List<int> numbers = new List<int>() { 35, 44, 200, 84, 3987, 4, 199, 329, 446, 208 };  
   
 IEnumerable<IGrouping<int, int>> query = from number in numbers  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-add-custom-methods-for-linq-queries.md b/docs/csharp/programming-guide/concepts/linq/how-to-add-custom-methods-for-linq-queries.md
index 800626d3506cb..bcc804ce54278 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-add-custom-methods-for-linq-queries.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-add-custom-methods-for-linq-queries.md
@@ -32,7 +32,7 @@ You can extend the set of methods that you can use for LINQ queries by adding ex
   
  The following code example shows how to create an extension method called `Median` to compute a median for a sequence of numbers of type `double`.  
   
-```cs  
+```csharp  
 public static class LINQExtension  
 {  
     public static double Median(this IEnumerable<double> source)  
@@ -66,7 +66,7 @@ public static class LINQExtension
   
  The following code example shows how to use the `Median` method for an array of type `double`.  
   
-```cs  
+```csharp  
 double[] numbers1 = { 1.9, 2, 8, 4, 5.7, 6, 7.2, 0 };  
   
 var query1 = numbers1.Median();  
@@ -74,7 +74,7 @@ var query1 = numbers1.Median();
 Console.WriteLine("double: Median = " + query1);  
 ```  
 
-```cs  
+```csharp  
 /*  
  This code produces the following output:  
   
@@ -88,7 +88,7 @@ Console.WriteLine("double: Median = " + query1);
 #### To create an overload for each type  
  You can create a specific overload for each type that you want to support. The following code example shows an overload of the `Median` method for the `integer` type.  
   
-```cs  
+```csharp  
 //int overload  
   
 public static double Median(this IEnumerable<int> source)  
@@ -98,7 +98,7 @@ public static double Median(this IEnumerable<int> source)
 ```   
  You can now call the `Median` overloads for both `integer` and `double` types, as shown in the following code:  
   
-```cs  
+```csharp  
 double[] numbers1 = { 1.9, 2, 8, 4, 5.7, 6, 7.2, 0 };  
   
 var query1 = numbers1.Median();  
@@ -106,7 +106,7 @@ var query1 = numbers1.Median();
 Console.WriteLine("double: Median = " + query1);  
 ```  
   
-```cs  
+```csharp  
 int[] numbers2 = { 1, 2, 3, 4, 5 };  
   
 var query2 = numbers2.Median();  
@@ -114,7 +114,7 @@ var query2 = numbers2.Median();
 Console.WriteLine("int: Median = " + query2);  
 ```  
   
-```cs  
+```csharp  
 /*  
  This code produces the following output:  
   
@@ -128,7 +128,7 @@ Console.WriteLine("int: Median = " + query2);
   
  The following code shows an overload of the `Median` method that takes the <xref:System.Func%602> delegate as a parameter. This delegate takes an object of generic type T and returns an object of type `double`.  
   
-```cs  
+```csharp  
 // Generic overload.  
   
 public static double Median<T>(this IEnumerable<T> numbers,  
@@ -142,7 +142,7 @@ public static double Median<T>(this IEnumerable<T> numbers,
   
  The following example code shows how to call the `Median` method for an array of integers and an array of strings. For strings, the median for the lengths of strings in the array is calculated. The example shows how to pass the <xref:System.Func%602> delegate parameter to the `Median` method for each case.  
   
-```cs  
+```csharp  
 int[] numbers3 = { 1, 2, 3, 4, 5 };  
   
 /*   
@@ -175,7 +175,7 @@ Console.WriteLine("String: Median = " + query4);
   
  The following example shows how to create an extension method named `AlternateElements` that returns every other element in a collection, starting from the first element.  
   
-```cs  
+```csharp  
 // Extension method for the IEnumerable<T> interface.   
 // The method returns every other element of a sequence.  
   
@@ -200,7 +200,7 @@ public static IEnumerable<T> AlternateElements<T>(this IEnumerable<T> source)
 ```  
  You can call this extension method for any enumerable collection just as you would call other methods from the <xref:System.Collections.Generic.IEnumerable%601> interface, as shown in the following code:  
   
-```cs  
+```csharp  
 string[] strings = { "a", "b", "c", "d", "e" };  
   
 var query = strings.AlternateElements();  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-build-linq-to-xml-examples.md b/docs/csharp/programming-guide/concepts/linq/how-to-build-linq-to-xml-examples.md
index 61e5b8a1c5d1e..78f92112823fc 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-build-linq-to-xml-examples.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-build-linq-to-xml-examples.md
@@ -28,7 +28,7 @@ The various snippets and examples in this documentation use classes and types fr
 ## Example  
  The following code contains the `using` directives that the C# examples require to build and run. Not all `using` directives are required for every example.  
   
-```cs  
+```csharp  
 using System;  
 using System.Diagnostics;  
 using System.Collections;  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-calculate-intermediate-values.md b/docs/csharp/programming-guide/concepts/linq/how-to-calculate-intermediate-values.md
index 891e85838f22f..6c8a1861537c8 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-calculate-intermediate-values.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-calculate-intermediate-values.md
@@ -25,7 +25,7 @@ This example shows how to calculate intermediate values that can be used in sort
   
  This example uses the following XML document: [Sample XML File: Numerical Data (LINQ to XML)](../../../../csharp/programming-guide/concepts/linq/sample-xml-file-numerical-data-linq-to-xml.md).  
   
-```cs  
+```csharp  
 XElement root = XElement.Load("Data.xml");  
 IEnumerable<decimal> extensions =  
     from el in root.Elements("Data")  
@@ -52,7 +52,7 @@ foreach (decimal ex in extensions)
   
  This example uses the following XML document: [Sample XML File: Numerical Data in a Namespace](../../../../csharp/programming-guide/concepts/linq/sample-xml-file-numerical-data-in-a-namespace.md).  
   
-```cs  
+```csharp  
 XElement root = XElement.Load("DataInNamespace.xml");  
 XNamespace ad = "http://www.adatum.com";  
 IEnumerable<decimal> extensions =  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-catch-parsing-errors.md b/docs/csharp/programming-guide/concepts/linq/how-to-catch-parsing-errors.md
index 13ed0abcb5a67..89ca033e64dfd 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-catch-parsing-errors.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-catch-parsing-errors.md
@@ -30,7 +30,7 @@ This topic shows how to detect badly formed or invalid XML.
 ## Example  
  The following code tries to parse invalid XML:  
   
-```cs  
+```csharp  
 try {  
     XElement contacts = XElement.Parse(  
         @"<Contacts>  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-chain-axis-method-calls-linq-to-xml.md b/docs/csharp/programming-guide/concepts/linq/how-to-chain-axis-method-calls-linq-to-xml.md
index d64a2b7b35173..bd3558de2fcb9 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-chain-axis-method-calls-linq-to-xml.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-chain-axis-method-calls-linq-to-xml.md
@@ -27,7 +27,7 @@ A common pattern that you will use in your code is to call an axis method, then
   
  This example uses the following XML document: [Sample XML File: Multiple Purchase Orders (LINQ to XML)](../../../../csharp/programming-guide/concepts/linq/sample-xml-file-multiple-purchase-orders-linq-to-xml.md).  
   
-```cs  
+```csharp  
 XElement purchaseOrders = XElement.Load("PurchaseOrders.xml");  
 IEnumerable<XElement> names =  
     from el in purchaseOrders  
@@ -79,7 +79,7 @@ foreach (XElement e in names)
   
  To do this, you can use the <xref:System.Xml.Linq.Extensions.Elements%2A?displayProperty=fullName> axis, as follows:  
   
-```cs  
+```csharp  
 XElement root = XElement.Load("Irregular.xml");  
 IEnumerable<XElement> configParameters =   
     root.Elements("Customer").Elements("Config").  
@@ -100,7 +100,7 @@ foreach (XElement cp in configParameters)
   
  This example uses the following XML document: [Sample XML File: Multiple Purchase Orders in a Namespace](../../../../csharp/programming-guide/concepts/linq/sample-xml-file-multiple-purchase-orders-in-a-namespace.md).  
   
-```cs  
+```csharp  
 XNamespace aw = "http://www.adventure-works.com";  
 XElement purchaseOrders = XElement.Load("PurchaseOrdersInNamespace.xml");  
 IEnumerable<XElement> names =  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-change-the-namespace-for-an-entire-xml-tree.md b/docs/csharp/programming-guide/concepts/linq/how-to-change-the-namespace-for-an-entire-xml-tree.md
index c455ea65ea754..a6d6a474e0776 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-change-the-namespace-for-an-entire-xml-tree.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-change-the-namespace-for-an-entire-xml-tree.md
@@ -25,7 +25,7 @@ You sometimes have to programmatically change the namespace for an element or an
 ## Example  
  The following code creates two XML trees in no namespace. It then changes the namespace of each of the trees, and combines them into a single tree.  
   
-```cs  
+```csharp  
 XElement tree1 = new XElement("Data",  
     new XElement("Child", "content",  
         new XAttribute("MyAttr", "content")  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-combine-and-compare-string-collections-linq.md b/docs/csharp/programming-guide/concepts/linq/how-to-combine-and-compare-string-collections-linq.md
index 4ba1c6146dc5e..e6fec99569570 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-combine-and-compare-string-collections-linq.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-combine-and-compare-string-collections-linq.md
@@ -59,7 +59,7 @@ This example shows how to merge files that contain lines of text and then sort t
   
 ## Example  
   
-```cs  
+```csharp  
 class MergeStrings  
     {  
         static void Main(string[] args)  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-combine-linq-queries-with-regular-expressions.md b/docs/csharp/programming-guide/concepts/linq/how-to-combine-linq-queries-with-regular-expressions.md
index 4140a8d4ff7fe..2e9a245ab050d 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-combine-linq-queries-with-regular-expressions.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-combine-linq-queries-with-regular-expressions.md
@@ -27,7 +27,7 @@ This example shows how to use the <xref:System.Text.RegularExpressions.Regex> cl
   
 ## Example  
   
-```cs  
+```csharp  
 class QueryWithRegEx  
 {  
     public static void Main()  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-compare-the-contents-of-two-folders-linq.md b/docs/csharp/programming-guide/concepts/linq/how-to-compare-the-contents-of-two-folders-linq.md
index a2f25be82cbfb..724bc05204f62 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-compare-the-contents-of-two-folders-linq.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-compare-the-contents-of-two-folders-linq.md
@@ -38,7 +38,7 @@ This example demonstrates three ways to compare two file listings:
   
 ## Example  
   
-```cs  
+```csharp  
 namespace QueryCompareTwoDirs  
 {  
     class CompareDirs  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-compute-column-values-in-a-csv-text-file-linq.md b/docs/csharp/programming-guide/concepts/linq/how-to-compute-column-values-in-a-csv-text-file-linq.md
index 2ee45854b8389..fe047809577c8 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-compute-column-values-in-a-csv-text-file-linq.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-compute-column-values-in-a-csv-text-file-linq.md
@@ -46,7 +46,7 @@ This example shows how to perform aggregate computations such as Sum, Average, M
   
 ## Example  
   
-```cs  
+```csharp  
 class SumColumns  
 {  
     static void Main(string[] args)  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-control-namespace-prefixes-linq-to-xml.md b/docs/csharp/programming-guide/concepts/linq/how-to-control-namespace-prefixes-linq-to-xml.md
index 561e000202caf..de3ebd502b6e6 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-control-namespace-prefixes-linq-to-xml.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-control-namespace-prefixes-linq-to-xml.md
@@ -40,7 +40,7 @@ This topic describes how you can control namespace prefixes when serializing an
 ## Example  
  This example declares two namespaces. It specifies that the `http://www.adventure-works.com` namespace has the prefix of `aw`, and that the `www.fourthcoffee.com` namespace has the prefix of `fc`.  
   
-```cs  
+```csharp  
 XNamespace aw = "http://www.adventure-works.com";  
 XNamespace fc = "www.fourthcoffee.com";  
 XElement root = new XElement(aw + "Root",  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-control-the-type-of-a-projection.md b/docs/csharp/programming-guide/concepts/linq/how-to-control-the-type-of-a-projection.md
index 7cf93bfdfe2a7..c04963df20aaf 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-control-the-type-of-a-projection.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-control-the-type-of-a-projection.md
@@ -25,7 +25,7 @@ Projection is the process of taking one set of data, filtering it, changing its
   
  This example uses the following XML document: [Sample XML File: Customers and Orders (LINQ to XML)](../../../../csharp/programming-guide/concepts/linq/sample-xml-file-customers-and-orders-linq-to-xml-2.md).  
   
-```cs  
+```csharp  
 public class Customer  
 {  
     private string customerID;  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-count-occurrences-of-a-word-in-a-string-linq.md b/docs/csharp/programming-guide/concepts/linq/how-to-count-occurrences-of-a-word-in-a-string-linq.md
index 94a95deb5953a..04ab62b27f827 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-count-occurrences-of-a-word-in-a-string-linq.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-count-occurrences-of-a-word-in-a-string-linq.md
@@ -27,7 +27,7 @@ This example shows how to use a LINQ query to count the occurrences of a specifi
   
 ## Example  
   
-```cs  
+```csharp  
 class CountWords  
 {  
     static void Main()  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-create-a-document-with-namespaces-linq-to-xml.md b/docs/csharp/programming-guide/concepts/linq/how-to-create-a-document-with-namespaces-linq-to-xml.md
index 5f7b619d2587a..8988aa143a43c 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-create-a-document-with-namespaces-linq-to-xml.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-create-a-document-with-namespaces-linq-to-xml.md
@@ -30,7 +30,7 @@ This topic shows how to create documents with namespaces.
   
  The following example creates a document with one namespace. By default, [!INCLUDE[sqltecxlinq](../../../../csharp/programming-guide/concepts/linq/includes/sqltecxlinq_md.md)] serializes this document with a default namespace.  
   
-```cs  
+```csharp  
 // Create an XML tree in a namespace.  
 XNamespace aw = "http://www.adventure-works.com";  
 XElement root = new XElement(aw + "Root",  
@@ -50,7 +50,7 @@ Console.WriteLine(root);
 ## Example  
  The following example creates a document with one namespace. It also creates an attribute that declares the namespace with a namespace prefix. To create an attribute that declares a namespace with a prefix, you create an attribute where the name of the attribute is the namespace prefix, and this name is in the <xref:System.Xml.Linq.XNamespace.Xmlns%2A> namespace. The value of this attribute is the URI of the namespace.  
   
-```cs  
+```csharp  
 // Create an XML tree in a namespace, with a specified prefix  
 XNamespace aw = "http://www.adventure-works.com";  
 XElement root = new XElement(aw + "Root",  
@@ -73,7 +73,7 @@ Console.WriteLine(root);
   
  By including namespace attributes in the root element, the namespaces are serialized so that http://www.adventure-works.com is the default namespace, and www.fourthcoffee.com is serialized with a prefix of "fc". To create an attribute that declares a default namespace, you create an attribute with the name "xmlns", without a namespace. The value of the attribute is the default namespace URI.  
   
-```cs  
+```csharp  
 // The http://www.adventure-works.com namespace is forced to be the default namespace.  
 XNamespace aw = "http://www.adventure-works.com";  
 XNamespace fc = "www.fourthcoffee.com";  
@@ -104,7 +104,7 @@ Console.WriteLine(root);
 ## Example  
  The following example creates a document that contains two namespaces, both with namespace prefixes.  
   
-```cs  
+```csharp  
 XNamespace aw = "http://www.adventure-works.com";  
 XNamespace fc = "www.fourthcoffee.com";  
 XElement root = new XElement(aw + "Root",  
@@ -138,7 +138,7 @@ Console.WriteLine(root);
   
  If performance is an important issue, see [Pre-Atomization of XName Objects (LINQ to XML) (C#)](../../../../csharp/programming-guide/concepts/linq/pre-atomization-of-xname-objects-linq-to-xml.md) for more information  
   
-```cs  
+```csharp  
 // Create an XML tree in a namespace, with a specified prefix  
 XElement root = new XElement("{http://www.adventure-works.com}Root",  
     new XAttribute(XNamespace.Xmlns + "aw", "http://www.adventure-works.com"),  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-create-a-tree-from-an-xmlreader.md b/docs/csharp/programming-guide/concepts/linq/how-to-create-a-tree-from-an-xmlreader.md
index d2fda49a6aec4..031c4517a96dc 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-create-a-tree-from-an-xmlreader.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-create-a-tree-from-an-xmlreader.md
@@ -30,7 +30,7 @@ This topic shows how to create an XML tree directly from an <xref:System.Xml.Xml
   
  The following code creates an `T:System.Xml.XmlReader` object, and then reads nodes until it finds the first element node. It then loads the <xref:System.Xml.Linq.XElement> object.  
   
-```cs  
+```csharp  
 XmlReader r = XmlReader.Create("books.xml");  
 while (r.NodeType != XmlNodeType.Element)  
     r.Read();  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-create-hierarchy-using-grouping.md b/docs/csharp/programming-guide/concepts/linq/how-to-create-hierarchy-using-grouping.md
index 796a8a94fb417..364311ded69b3 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-create-hierarchy-using-grouping.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-create-hierarchy-using-grouping.md
@@ -25,7 +25,7 @@ This example shows how to group data, and then generate XML based on the groupin
   
  This example uses the following XML document: [Sample XML File: Numerical Data (LINQ to XML)](../../../../csharp/programming-guide/concepts/linq/sample-xml-file-numerical-data-linq-to-xml.md).  
   
-```cs  
+```csharp  
 XElement doc = XElement.Load("Data.xml");  
 var newData =  
     new XElement("Root",  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-debug-empty-query-results-sets.md b/docs/csharp/programming-guide/concepts/linq/how-to-debug-empty-query-results-sets.md
index 26d2b61e29b73..cd94fb58d8337 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-debug-empty-query-results-sets.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-debug-empty-query-results-sets.md
@@ -29,7 +29,7 @@ One of the most common problems when querying XML trees is that if the XML tree
 ## Example  
  This example shows creation of XML in a namespace, and a query that returns an empty result set.  
   
-```cs  
+```csharp  
 XElement root = XElement.Parse(  
 @"<Root xmlns='http://www.adventure-works.com'>  
     <Child>1</Child>  
@@ -60,7 +60,7 @@ End of result set
   
  The solution is to declare and initialize an <xref:System.Xml.Linq.XNamespace> object, and to use it when specifying <xref:System.Xml.Linq.XName> objects. In this case, the argument to the <xref:System.Xml.Linq.XElement.Elements%2A> method is an <xref:System.Xml.Linq.XName> object.  
   
-```cs  
+```csharp  
 XElement root = XElement.Parse(  
 @"<Root xmlns='http://www.adventure-works.com'>  
     <Child>1</Child>  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-filter-on-an-attribute-xpath-linq-to-xml.md b/docs/csharp/programming-guide/concepts/linq/how-to-filter-on-an-attribute-xpath-linq-to-xml.md
index 4aeacf757fee4..0913eba7ada00 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-filter-on-an-attribute-xpath-linq-to-xml.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-filter-on-an-attribute-xpath-linq-to-xml.md
@@ -29,7 +29,7 @@ This topic shows how to get the descendant elements with a specified name, and w
   
  This example uses the following XML document: [Sample XML File: Multiple Purchase Orders (LINQ to XML)](../../../../csharp/programming-guide/concepts/linq/sample-xml-file-multiple-purchase-orders-linq-to-xml.md).  
   
-```cs  
+```csharp  
 XDocument po = XDocument.Load("PurchaseOrders.xml");  
   
 // LINQ to XML query  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-filter-on-an-optional-element.md b/docs/csharp/programming-guide/concepts/linq/how-to-filter-on-an-optional-element.md
index c77debd76aa27..9d07ee9208012 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-filter-on-an-optional-element.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-filter-on-an-optional-element.md
@@ -23,7 +23,7 @@ Sometimes you want to filter for an element even though you are not sure it exis
 ## Example  
  This example uses the <xref:System.Xml.Linq.Extensions.Elements%2A> extension method.  
   
-```cs  
+```csharp  
 XElement root = XElement.Parse(@"<Root>  
   <Child1>  
     <Text>Child One Text</Text>  
@@ -64,7 +64,7 @@ Child Four Text
 ## Example  
  The following example shows the same query for XML that is in a namespace. For more information, see [Working with XML Namespaces (C#)](../../../../csharp/programming-guide/concepts/linq/working-with-xml-namespaces.md).  
   
-```cs  
+```csharp  
 XElement root = XElement.Parse(@"<Root xmlns='http://www.adatum.com'>  
   <Child1>  
     <Text>Child One Text</Text>  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-filter-on-element-names-linq-to-xml.md b/docs/csharp/programming-guide/concepts/linq/how-to-filter-on-element-names-linq-to-xml.md
index 38d636106989f..5ea5ca25d0f7b 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-filter-on-element-names-linq-to-xml.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-filter-on-element-names-linq-to-xml.md
@@ -25,7 +25,7 @@ When you call one of the methods that return <xref:System.Collections.Generic.IE
   
  This example uses the following XML document: [Sample XML File: Typical Purchase Order (LINQ to XML)](../../../../csharp/programming-guide/concepts/linq/sample-xml-file-typical-purchase-order-linq-to-xml-1.md).  
   
-```cs  
+```csharp  
 XElement po = XElement.Load("PurchaseOrder.xml");  
 IEnumerable<XElement> items =  
     from el in po.Descendants("ProductName")  
@@ -62,7 +62,7 @@ ProductName:Baby Monitor
   
  This example uses the following XML document: [Sample XML File: Typical Purchase Order in a Namespace](../../../../csharp/programming-guide/concepts/linq/sample-xml-file-typical-purchase-order-in-a-namespace.md).  
   
-```cs  
+```csharp  
 XNamespace aw = "http://www.adventure-works.com";  
 XElement po = XElement.Load("PurchaseOrderInNamespace.xml");  
 IEnumerable<XElement> items =  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-find-a-child-element-xpath-linq-to-xml.md b/docs/csharp/programming-guide/concepts/linq/how-to-find-a-child-element-xpath-linq-to-xml.md
index 82ae849a2f234..95bbddf112726 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-find-a-child-element-xpath-linq-to-xml.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-find-a-child-element-xpath-linq-to-xml.md
@@ -27,7 +27,7 @@ This topic compares the XPath child element axis to the [!INCLUDE[sqltecxlinq](.
   
  This example uses the following XML document: [Sample XML File: Multiple Purchase Orders (LINQ to XML)](../../../../csharp/programming-guide/concepts/linq/sample-xml-file-multiple-purchase-orders-linq-to-xml.md).  
   
-```cs  
+```csharp  
 XDocument cpo = XDocument.Load("PurchaseOrders.xml");  
 XElement po = cpo.Root.Element("PurchaseOrder");  
   
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-find-a-list-of-child-elements-xpath-linq-to-xml.md b/docs/csharp/programming-guide/concepts/linq/how-to-find-a-list-of-child-elements-xpath-linq-to-xml.md
index 451dc3a193520..c94500fea3de8 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-find-a-list-of-child-elements-xpath-linq-to-xml.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-find-a-list-of-child-elements-xpath-linq-to-xml.md
@@ -27,7 +27,7 @@ This topic compares the XPath child elements axis to the [!INCLUDE[sqltecxlinq](
   
  This example uses the following XML document: [Sample XML File: Multiple Purchase Orders (LINQ to XML)](../../../../csharp/programming-guide/concepts/linq/sample-xml-file-multiple-purchase-orders-linq-to-xml.md).  
   
-```cs  
+```csharp  
 XDocument cpo = XDocument.Load("PurchaseOrders.xml");  
 XElement po = cpo.Root.Element("PurchaseOrder").Element("Address");  
   
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-find-a-single-descendant-using-the-descendants-method.md b/docs/csharp/programming-guide/concepts/linq/how-to-find-a-single-descendant-using-the-descendants-method.md
index d5f692bad5e76..1fa74015ce7c5 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-find-a-single-descendant-using-the-descendants-method.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-find-a-single-descendant-using-the-descendants-method.md
@@ -23,7 +23,7 @@ You can use the <xref:System.Xml.Linq.XContainer.Descendants%2A> axis method to
 ## Example  
  This example uses the <xref:System.Linq.Enumerable.First%2A> standard query operator.  
   
-```cs  
+```csharp  
 XElement root = XElement.Parse(@"<Root>  
   <Child1>  
     <GrandChild1>GC1 Value</GrandChild1>  
@@ -53,7 +53,7 @@ GC3 Value
 ## Example  
  The following example shows the same query for XML that is in a namespace. For more information, see [Working with XML Namespaces (C#)](../../../../csharp/programming-guide/concepts/linq/working-with-xml-namespaces.md).  
   
-```cs  
+```csharp  
 XElement root = XElement.Parse(@"<aw:Root xmlns:aw='http://www.adventure-works.com'>  
   <aw:Child1>  
     <aw:GrandChild1>GC1 Value</aw:GrandChild1>  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-find-a-union-of-two-location-paths-xpath-linq-to-xml.md b/docs/csharp/programming-guide/concepts/linq/how-to-find-a-union-of-two-location-paths-xpath-linq-to-xml.md
index 251cc95139fbf..a2b76adeb2900 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-find-a-union-of-two-location-paths-xpath-linq-to-xml.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-find-a-union-of-two-location-paths-xpath-linq-to-xml.md
@@ -31,7 +31,7 @@ XPath allows you to find the union of the results of two XPath location paths.
   
  This example uses the following XML document: [Sample XML File: Numerical Data (LINQ to XML)](../../../../csharp/programming-guide/concepts/linq/sample-xml-file-numerical-data-linq-to-xml.md).  
   
-```cs  
+```csharp  
 XDocument data = XDocument.Load("Data.xml");  
   
 // LINQ to XML query  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-find-all-nodes-in-a-namespace.md b/docs/csharp/programming-guide/concepts/linq/how-to-find-all-nodes-in-a-namespace.md
index 4a410a7720be0..c6847e69b2d3e 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-find-all-nodes-in-a-namespace.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-find-all-nodes-in-a-namespace.md
@@ -23,7 +23,7 @@ You can filter on the namespace of each element or attribute to find all nodes i
 ## Example  
  The following example creates an XML tree with two namespaces. It then iterates through the tree and prints the names of all the elements and attributes in one of those namespaces.  
   
-```cs  
+```csharp  
 string markup = @"<aw:Root xmlns:aw='http://www.adventure-works.com' xmlns:fc='www.fourthcoffee.com'>  
   <fc:Child1>abc</fc:Child1>  
   <fc:Child2>def</fc:Child2>  
@@ -56,7 +56,7 @@ Nodes in the http://www.adventure-works.com namespace
   
  This example uses the following XML document: [Sample XML File: Consolidated Purchase Orders](../../../../csharp/programming-guide/concepts/linq/sample-xml-file-consolidated-purchase-orders.md).  
   
-```cs  
+```csharp  
 XDocument cpo = XDocument.Load("ConsolidatedPurchaseOrders.xml");  
 XNamespace aw = "http://www.adventure-works.com";  
 XElement newTree = new XElement("Root",  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-find-an-attribute-of-the-parent-xpath-linq-to-xml.md b/docs/csharp/programming-guide/concepts/linq/how-to-find-an-attribute-of-the-parent-xpath-linq-to-xml.md
index 7931c23da4244..bdb87cf2976b5 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-find-an-attribute-of-the-parent-xpath-linq-to-xml.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-find-an-attribute-of-the-parent-xpath-linq-to-xml.md
@@ -29,7 +29,7 @@ This topic shows how to navigate to the parent element and find an attribute of
   
  This example uses the following XML document: [Sample XML File: Books (LINQ to XML)](../../../../csharp/programming-guide/concepts/linq/sample-xml-file-books-linq-to-xml.md).  
   
-```cs  
+```csharp  
 XDocument books = XDocument.Load("Books.xml");  
   
 XElement author =   
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-find-an-element-with-a-specific-attribute.md b/docs/csharp/programming-guide/concepts/linq/how-to-find-an-element-with-a-specific-attribute.md
index b192bd070778f..11719116100b1 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-find-an-element-with-a-specific-attribute.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-find-an-element-with-a-specific-attribute.md
@@ -25,7 +25,7 @@ This topic shows how to find an element that has an attribute that has a specifi
   
  This example uses the following XML document: [Sample XML File: Typical Purchase Order (LINQ to XML)](../../../../csharp/programming-guide/concepts/linq/sample-xml-file-typical-purchase-order-linq-to-xml-1.md).  
   
-```cs  
+```csharp  
 XElement root = XElement.Load("PurchaseOrder.xml");  
 IEnumerable<XElement> address =  
     from el in root.Elements("Address")  
@@ -53,7 +53,7 @@ foreach (XElement el in address)
   
  This example uses the following XML document: [Sample XML File: Typical Purchase Order in a Namespace](../../../../csharp/programming-guide/concepts/linq/sample-xml-file-typical-purchase-order-in-a-namespace.md).  
   
-```cs  
+```csharp  
 XElement root = XElement.Load("PurchaseOrderInNamespace.xml");  
 XNamespace aw = "http://www.adventure-works.com";  
 IEnumerable<XElement> address =  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-find-an-element-with-a-specific-child-element.md b/docs/csharp/programming-guide/concepts/linq/how-to-find-an-element-with-a-specific-child-element.md
index 6ae43039e2243..02ca52a44c037 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-find-an-element-with-a-specific-child-element.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-find-an-element-with-a-specific-child-element.md
@@ -25,7 +25,7 @@ This topic shows how to find a particular element that has a child element with
   
  This example uses the following XML document: [Sample XML File: Test Configuration (LINQ to XML)](../../../../csharp/programming-guide/concepts/linq/sample-xml-file-test-configuration-linq-to-xml.md).  
   
-```cs  
+```csharp  
 XElement root = XElement.Load("TestConfig.xml");  
 IEnumerable<XElement> tests =  
     from el in root.Elements("Test")  
@@ -47,7 +47,7 @@ foreach (XElement el in tests)
   
  This example uses the following XML document: [Sample XML File: Test Configuration in a Namespace](../../../../csharp/programming-guide/concepts/linq/sample-xml-file-test-configuration-in-a-namespace1.md).  
   
-```cs  
+```csharp  
 XElement root = XElement.Load("TestConfigInNamespace.xml");  
 XNamespace ad = "http://www.adatum.com";  
 IEnumerable<XElement> tests =  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-find-attributes-of-siblings-with-a-specific-name-xpath-linq-to-xml.md b/docs/csharp/programming-guide/concepts/linq/how-to-find-attributes-of-siblings-with-a-specific-name-xpath-linq-to-xml.md
index e47f5980681eb..898fcf66c6204 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-find-attributes-of-siblings-with-a-specific-name-xpath-linq-to-xml.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-find-attributes-of-siblings-with-a-specific-name-xpath-linq-to-xml.md
@@ -29,7 +29,7 @@ This topic shows how to find all attributes of the siblings of the context node.
   
  This example uses the following XML document: [Sample XML File: Books (LINQ to XML)](../../../../csharp/programming-guide/concepts/linq/sample-xml-file-books-linq-to-xml.md).  
   
-```cs  
+```csharp  
 XDocument books = XDocument.Load("Books.xml");  
   
 XElement book =   
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-find-child-elements-based-on-position-xpath-linq-to-xml.md b/docs/csharp/programming-guide/concepts/linq/how-to-find-child-elements-based-on-position-xpath-linq-to-xml.md
index 34534f4a7e632..6fdbb92f21bc7 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-find-child-elements-based-on-position-xpath-linq-to-xml.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-find-child-elements-based-on-position-xpath-linq-to-xml.md
@@ -31,7 +31,7 @@ Sometimes you want to find elements based on their position. You might want to f
   
  This example uses the following XML document: [Sample XML File: Test Configuration (LINQ to XML)](../../../../csharp/programming-guide/concepts/linq/sample-xml-file-test-configuration-linq-to-xml.md).  
   
-```cs  
+```csharp  
 XElement testCfg = XElement.Load("TestConfig.xml");  
   
 // LINQ to XML query  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-find-descendant-elements-xpath-linq-to-xml.md b/docs/csharp/programming-guide/concepts/linq/how-to-find-descendant-elements-xpath-linq-to-xml.md
index e159b088ba750..0a3e13960b3b7 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-find-descendant-elements-xpath-linq-to-xml.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-find-descendant-elements-xpath-linq-to-xml.md
@@ -27,7 +27,7 @@ This topic shows how to get the descendant elements with a particular name.
   
  This example uses the following XML document: [Sample XML File: Multiple Purchase Orders (LINQ to XML)](../../../../csharp/programming-guide/concepts/linq/sample-xml-file-multiple-purchase-orders-linq-to-xml.md).  
   
-```cs  
+```csharp  
 XDocument po = XDocument.Load("PurchaseOrders.xml");  
   
 // LINQ to XML query  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-find-descendants-of-a-child-element-xpath-linq-to-xml.md b/docs/csharp/programming-guide/concepts/linq/how-to-find-descendants-of-a-child-element-xpath-linq-to-xml.md
index 469d276da1f1d..df51edeffad61 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-find-descendants-of-a-child-element-xpath-linq-to-xml.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-find-descendants-of-a-child-element-xpath-linq-to-xml.md
@@ -27,7 +27,7 @@ This topic shows how to get the descendant elements of a child element with a pa
 ## Example  
  This example simulates the problems of extracting text from an XML representation of a word processing document. It first selects all `Paragraph` elements, and then it selects all `Text` descendant elements of each `Paragraph` element. This doesn't select the descendant `Text` elements of the `Comment` element.  
   
-```cs  
+```csharp  
 XElement root = XElement.Parse(  
 @"<Root>  
   <Paragraph>  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-find-descendants-with-a-specific-element-name.md b/docs/csharp/programming-guide/concepts/linq/how-to-find-descendants-with-a-specific-element-name.md
index 30d422a8469fe..c3ac65dc9e16e 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-find-descendants-with-a-specific-element-name.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-find-descendants-with-a-specific-element-name.md
@@ -23,7 +23,7 @@ Sometimes you want to find all descendants with a particular name. You could wri
 ## Example  
  The following example shows how to find descendants based on the element name.  
   
-```cs  
+```csharp  
 XElement root = XElement.Parse(@"<root>  
   <para>  
     <r>  
@@ -62,7 +62,7 @@ Some text that is broken up into multiple segments.
 ## Example  
  The following example shows the same query for XML that is in a namespace. For more information, see [Working with XML Namespaces (C#)](../../../../csharp/programming-guide/concepts/linq/working-with-xml-namespaces.md).  
   
-```cs  
+```csharp  
 XElement root = XElement.Parse(@"<root xmlns='http://www.adatum.com'>  
   <para>  
     <r>  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-find-elements-in-a-namespace-xpath-linq-to-xml.md b/docs/csharp/programming-guide/concepts/linq/how-to-find-elements-in-a-namespace-xpath-linq-to-xml.md
index afb2dd71f60e0..adb45b69e808a 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-find-elements-in-a-namespace-xpath-linq-to-xml.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-find-elements-in-a-namespace-xpath-linq-to-xml.md
@@ -27,7 +27,7 @@ XPath expressions can find nodes in a particular namespace. XPath expressions us
 ## Example  
  The following example reads an XML tree that contains two namespaces. It uses an <xref:System.Xml.XmlReader> to read the XML document. It then gets an <xref:System.Xml.XmlNameTable> from the <xref:System.Xml.XmlReader>, and an <xref:System.Xml.XmlNamespaceManager> from the <xref:System.Xml.XmlNameTable>. It uses the <xref:System.Xml.XmlNamespaceManager> when selecting elements.  
   
-```cs  
+```csharp  
 XmlReader reader = XmlReader.Create("ConsolidatedPurchaseOrders.xml");  
 XElement root = XElement.Load(reader);  
 XmlNameTable nameTable = reader.NameTable;  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-find-elements-with-a-specific-attribute-xpath-linq-to-xml.md b/docs/csharp/programming-guide/concepts/linq/how-to-find-elements-with-a-specific-attribute-xpath-linq-to-xml.md
index 72df8bc5a7e23..0b6c319633161 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-find-elements-with-a-specific-attribute-xpath-linq-to-xml.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-find-elements-with-a-specific-attribute-xpath-linq-to-xml.md
@@ -27,7 +27,7 @@ Sometimes you want to find all elements that have a specific attribute. You are
 ## Example  
  The following code selects just the elements that have the `Select` attribute.  
   
-```cs  
+```csharp  
 XElement doc = XElement.Parse(  
 @"<Root>  
     <Child1>1</Child1>  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-find-preceding-siblings-xpath-linq-to-xml.md b/docs/csharp/programming-guide/concepts/linq/how-to-find-preceding-siblings-xpath-linq-to-xml.md
index 49956b9bdccf6..583b47a101cdd 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-find-preceding-siblings-xpath-linq-to-xml.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-find-preceding-siblings-xpath-linq-to-xml.md
@@ -31,7 +31,7 @@ This topic compares the XPath `preceding-sibling` axis to the [!INCLUDE[sqltecxl
   
  This example uses the following XML document: [Sample XML File: Customers and Orders (LINQ to XML)](../../../../csharp/programming-guide/concepts/linq/sample-xml-file-customers-and-orders-linq-to-xml-2.md).  
   
-```cs  
+```csharp  
 XElement co = XElement.Load("CustomersOrders.xml");  
   
 XElement add = co.Element("Customers").Element("Customer").Element("FullAddress");  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-find-related-elements-xpath-linq-to-xml.md b/docs/csharp/programming-guide/concepts/linq/how-to-find-related-elements-xpath-linq-to-xml.md
index 31f13c9b57948..ed70493bcd466 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-find-related-elements-xpath-linq-to-xml.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-find-related-elements-xpath-linq-to-xml.md
@@ -31,7 +31,7 @@ This topic shows how to get an element selecting on an attribute that is referre
   
  This example uses the following XML document: [Sample XML File: Customers and Orders (LINQ to XML)](../../../../csharp/programming-guide/concepts/linq/sample-xml-file-customers-and-orders-linq-to-xml-2.md).  
   
-```cs  
+```csharp  
 XDocument co = XDocument.Load("CustomersOrders.xml");  
   
 // LINQ to XML query  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-find-sibling-nodes-xpath-linq-to-xml.md b/docs/csharp/programming-guide/concepts/linq/how-to-find-sibling-nodes-xpath-linq-to-xml.md
index 1963e80bc7296..421c47ce5292e 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-find-sibling-nodes-xpath-linq-to-xml.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-find-sibling-nodes-xpath-linq-to-xml.md
@@ -29,7 +29,7 @@ You might want to find all siblings of a node that have a specific name. The res
   
  This example uses the following XML document: [Sample XML File: Books (LINQ to XML)](../../../../csharp/programming-guide/concepts/linq/sample-xml-file-books-linq-to-xml.md).  
   
-```cs  
+```csharp  
 XDocument books = XDocument.Load("Books.xml");  
   
 XElement book =   
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-find-the-immediate-preceding-sibling-xpath-linq-to-xml.md b/docs/csharp/programming-guide/concepts/linq/how-to-find-the-immediate-preceding-sibling-xpath-linq-to-xml.md
index ce4e6cb356b4e..e39f796dd1b67 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-find-the-immediate-preceding-sibling-xpath-linq-to-xml.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-find-the-immediate-preceding-sibling-xpath-linq-to-xml.md
@@ -23,7 +23,7 @@ Sometimes you want to find the immediate preceding sibling to a node. Due to the
 ## Example  
  In this example, the [!INCLUDE[sqltecxlinq](../../../../csharp/programming-guide/concepts/linq/includes/sqltecxlinq_md.md)] query uses the <xref:System.Linq.Enumerable.Last%2A> operator to find the last node in the collection returned by <xref:System.Xml.Linq.XNode.ElementsBeforeSelf%2A>. By contrast, the XPath expression uses a predicate with a value of 1 to find the immediately preceding element.  
   
-```cs  
+```csharp  
 XElement root = XElement.Parse(  
     @"<Root>  
     <Child1/>  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-find-the-root-element-xpath-linq-to-xml.md b/docs/csharp/programming-guide/concepts/linq/how-to-find-the-root-element-xpath-linq-to-xml.md
index 98723547c6616..70cd472714500 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-find-the-root-element-xpath-linq-to-xml.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-find-the-root-element-xpath-linq-to-xml.md
@@ -29,7 +29,7 @@ This topic shows how to get the root element with XPath and [!INCLUDE[sqltecxlin
   
  This example uses the following XML document: [Sample XML File: Multiple Purchase Orders (LINQ to XML)](../../../../csharp/programming-guide/concepts/linq/sample-xml-file-multiple-purchase-orders-linq-to-xml.md).  
   
-```cs  
+```csharp  
 XDocument po = XDocument.Load("PurchaseOrders.xml");  
   
 // LINQ to XML query  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-find-the-set-difference-between-two-lists-linq.md b/docs/csharp/programming-guide/concepts/linq/how-to-find-the-set-difference-between-two-lists-linq.md
index 033ba38ddc4df..72f5a6594d80d 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-find-the-set-difference-between-two-lists-linq.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-find-the-set-difference-between-two-lists-linq.md
@@ -31,7 +31,7 @@ This example shows how to use LINQ to compare two lists of strings and output th
   
 ## Example  
   
-```cs  
+```csharp  
 class CompareLists  
 {          
     static void Main()  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-generate-text-files-from-xml.md b/docs/csharp/programming-guide/concepts/linq/how-to-generate-text-files-from-xml.md
index b3471f4259eda..d19f9feca19dd 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-generate-text-files-from-xml.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-generate-text-files-from-xml.md
@@ -25,7 +25,7 @@ This example shows how to generate a comma-separated values (CSV) file from an X
   
  This example uses the following XML document: [Sample XML File: Customers and Orders (LINQ to XML)](../../../../csharp/programming-guide/concepts/linq/sample-xml-file-customers-and-orders-linq-to-xml-2.md).  
   
-```cs  
+```csharp  
 XElement custOrd = XElement.Load("CustomersOrders.xml");  
 string csv =  
     (from el in custOrd.Element("Customers").Elements("Customer")  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-generate-xml-from-csv-files.md b/docs/csharp/programming-guide/concepts/linq/how-to-generate-xml-from-csv-files.md
index 135af7575b504..dafd9c2f24cbd 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-generate-xml-from-csv-files.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-generate-xml-from-csv-files.md
@@ -25,7 +25,7 @@ This example shows how to use [!INCLUDE[vbteclinqext](../../../../csharp/getting
   
  The query uses the `let` clause to split each string into an array of fields.  
   
-```cs  
+```csharp  
 // Create the text file.  
 string csvString = @"GREAL,Great Lakes Food Market,Howard Snyder,Marketing Manager,(503) 555-7555,2732 Baker Blvd.,Eugene,OR,97403,USA  
 HUNGC,Hungry Coyote Import Store,Yoshi Latimer,Sales Representative,(503) 555-6874,City Center Plaza 516 Main St.,Elgin,OR,97827,USA  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-group-files-by-extension-linq.md b/docs/csharp/programming-guide/concepts/linq/how-to-group-files-by-extension-linq.md
index 4f88ad61cd26b..bd52356f0bd5e 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-group-files-by-extension-linq.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-group-files-by-extension-linq.md
@@ -28,7 +28,7 @@ This example shows how LINQ can be used to perform advanced grouping and sorting
 ## Example  
  The following query shows how to group the contents of a specified directory tree by the file name extension.  
   
-```cs  
+```csharp  
 class GroupByExtension  
 {  
     // This query will sort all the files under the specified folder  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-join-content-from-dissimilar-files-linq.md b/docs/csharp/programming-guide/concepts/linq/how-to-join-content-from-dissimilar-files-linq.md
index 24e1a85ae9b8e..01f1df531ffe4 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-join-content-from-dissimilar-files-linq.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-join-content-from-dissimilar-files-linq.md
@@ -63,7 +63,7 @@ This example shows how to join data from two comma-delimited files that share a
   
 ## Example  
   
-```cs  
+```csharp  
 class JoinStrings  
 {  
     static void Main()  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-join-two-collections-linq-to-xml.md b/docs/csharp/programming-guide/concepts/linq/how-to-join-two-collections-linq-to-xml.md
index c723381435ad4..f4c272f7b0f88 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-join-two-collections-linq-to-xml.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-join-two-collections-linq-to-xml.md
@@ -41,7 +41,7 @@ An element or attribute in an XML document can sometimes refer to another elemen
   
  Note that joining in this fashion will not perform very well. Joins are performed via a linear search. There are no hash tables or indexes to help with performance.  
   
-```cs  
+```csharp  
 XmlSchemaSet schemas = new XmlSchemaSet();  
 schemas.Add("", "CustomersOrders.xsd");  
   
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-list-all-nodes-in-a-tree.md b/docs/csharp/programming-guide/concepts/linq/how-to-list-all-nodes-in-a-tree.md
index 1a6d092ae152b..c0d55c2fc2a96 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-list-all-nodes-in-a-tree.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-list-all-nodes-in-a-tree.md
@@ -66,7 +66,7 @@ Sometimes it is helpful to list all nodes in a tree. This can be useful when lea
 /Root/aw:ElementInNamespace/aw:ChildInNamespace  
 ```  
   
-```cs  
+```csharp  
 public static class MyExtensions  
 {  
     private static string GetQName(XElement xe)  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-load-xml-from-a-file.md b/docs/csharp/programming-guide/concepts/linq/how-to-load-xml-from-a-file.md
index bbc170f0e2f44..8ad302d861adb 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-load-xml-from-a-file.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-load-xml-from-a-file.md
@@ -30,7 +30,7 @@ This topic shows how to load XML from a URI by using the <xref:System.Xml.Linq.X
   
  This example uses the following XML document: [Sample XML File: Books (LINQ to XML)](../../../../csharp/programming-guide/concepts/linq/sample-xml-file-books-linq-to-xml.md).  
   
-```cs  
+```csharp  
 XElement booksFromFile = XElement.Load(@"books.xml");  
 Console.WriteLine(booksFromFile);  
 ```  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-modify-an-office-open-xml-document.md b/docs/csharp/programming-guide/concepts/linq/how-to-modify-an-office-open-xml-document.md
index aaf098ae2762f..77bb81a517f79 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-modify-an-office-open-xml-document.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-modify-an-office-open-xml-document.md
@@ -27,7 +27,7 @@ This topic presents an example that opens an Office Open XML document, modifies
   
  This example uses classes found in the WindowsBase assembly. It uses types in the <xref:System.IO.Packaging?displayProperty=fullName> namespace.  
   
-```cs  
+```csharp  
 public static class LocalExtensions  
 {  
     public static string StringConcatenate(this IEnumerable<string> source)  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-parse-a-string.md b/docs/csharp/programming-guide/concepts/linq/how-to-parse-a-string.md
index 7127d60166608..62d48c21312c8 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-parse-a-string.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-parse-a-string.md
@@ -28,7 +28,7 @@ This topic shows how to parse a string to create an XML tree in C#.
 ## Example  
  The following C# code shows how to parse a string.  
   
-```cs  
+```csharp  
 XElement contacts = XElement.Parse(  
     @"<Contacts>  
         <Contact>  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-perform-streaming-transform-of-large-xml-documents.md b/docs/csharp/programming-guide/concepts/linq/how-to-perform-streaming-transform-of-large-xml-documents.md
index 8ff26ee5a0d29..e6f331d614cd3 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-perform-streaming-transform-of-large-xml-documents.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-perform-streaming-transform-of-large-xml-documents.md
@@ -85,7 +85,7 @@ Sometimes you have to transform large XML files, and write your application so t
 </Root>  
 ```  
   
-```cs  
+```csharp  
 static IEnumerable<XElement> StreamCustomerItem(string uri)  
 {  
     using (XmlReader reader = XmlReader.Create(uri))  
@@ -212,7 +212,7 @@ static void Main(string[] args)
   
  Using <xref:System.Xml.Linq.XStreamingElement> for streaming the output XML is preferred over writing to an <xref:System.Xml.XmlWriter>.  
   
-```cs  
+```csharp  
 static IEnumerable<XElement> StreamCustomerItem(string uri)  
 {  
     using (XmlReader reader = XmlReader.Create(uri))  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-perform-streaming-transformations-of-text-to-xml.md b/docs/csharp/programming-guide/concepts/linq/how-to-perform-streaming-transformations-of-text-to-xml.md
index b14d3d5ba7ee8..4132399431a31 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-perform-streaming-transformations-of-text-to-xml.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-perform-streaming-transformations-of-text-to-xml.md
@@ -34,7 +34,7 @@ One approach to processing a text file is to write an extension method that stre
   
  The following code contains an extension method that streams the lines of the text file in a deferred fashion.  
   
-```cs  
+```csharp  
 public static class StreamReaderSequence  
 {  
     public static IEnumerable<string> Lines(this StreamReader source)  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-populate-an-xml-tree-from-the-file-system.md b/docs/csharp/programming-guide/concepts/linq/how-to-populate-an-xml-tree-from-the-file-system.md
index 87ee4f9634c17..d41fc4cd628e0 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-populate-an-xml-tree-from-the-file-system.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-populate-an-xml-tree-from-the-file-system.md
@@ -23,7 +23,7 @@ A common and useful application of XML trees is as a hierarchical name/value dat
 ## Example  
  The following example populates an XML tree from the local file system using recursion. It then queries the tree, calculating the total of the sizes of all files in the tree.  
   
-```cs  
+```csharp  
 class Program  
 {  
     static XElement CreateFileSystemXmlTree(string source)  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-populate-an-xml-tree-with-an-xmlwriter-linq-to-xml.md b/docs/csharp/programming-guide/concepts/linq/how-to-populate-an-xml-tree-with-an-xmlwriter-linq-to-xml.md
index 11d93ab1fafa9..2f6d7a879dd9f 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-populate-an-xml-tree-with-an-xmlwriter-linq-to-xml.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-populate-an-xml-tree-with-an-xmlwriter-linq-to-xml.md
@@ -30,7 +30,7 @@ One way to populate an XML tree is to use <xref:System.Xml.Linq.XContainer.Creat
 ## Example  
  One possible use for <xref:System.Xml.Linq.XContainer.CreateWriter%2A> is when invoking an XSLT transformation. This example creates an XML tree, creates an <xref:System.Xml.XmlReader> from the XML tree, creates a new document, and then creates an <xref:System.Xml.XmlWriter> to write into the new document. It then invokes the XSLT transformation, passing in <xref:System.Xml.XmlReader> and <xref:System.Xml.XmlWriter>. After the transformation successfully completes, the new XML tree is populated with the results of the transformation.  
   
-```cs  
+```csharp  
 string xslMarkup = @"<?xml version='1.0'?>  
 <xsl:stylesheet xmlns:xsl='http://www.w3.org/1999/XSL/Transform' version='1.0'>  
     <xsl:template match='/Parent'>  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-populate-object-collections-from-multiple-sources-linq.md b/docs/csharp/programming-guide/concepts/linq/how-to-populate-object-collections-from-multiple-sources-linq.md
index 35f4e29a7b6f6..247b2be7d34b7 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-populate-object-collections-from-multiple-sources-linq.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-populate-object-collections-from-multiple-sources-linq.md
@@ -35,7 +35,7 @@ This example shows how to merge data from different sources into a sequence of n
 ## Example  
  The following example shows how to use a named type `Student` to store merged data from two in-memory collections of strings that simulate spreadsheet data in .csv format. The first collection of strings represents the student names and IDs, and the second collection represents the student ID (in the first column) and four exam scores. The ID is used as the foreign key.  
   
-```cs  
+```csharp  
 class Student  
 {  
     public string FirstName { get; set; }  
@@ -118,7 +118,7 @@ class PopulateCollection
   
  If you do not have to store the results of a query, anonymous types can be more convenient than named types. Named types are required if you pass the query results outside the method in which the query is executed. The following example performs the same task as the previous example, but uses anonymous types instead of named types:  
   
-```cs  
+```csharp  
 // Merge the data sources by using an anonymous type.  
 // Note the dynamic creation of a list of ints for the  
 // ExamScores member. We skip 1 because the first string  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-project-a-new-type-linq-to-xml.md b/docs/csharp/programming-guide/concepts/linq/how-to-project-a-new-type-linq-to-xml.md
index e7be4635d6c72..fe38eae3e5711 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-project-a-new-type-linq-to-xml.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-project-a-new-type-linq-to-xml.md
@@ -25,7 +25,7 @@ Other examples in this section have shown queries that return results as <xref:S
   
  This example uses the following XML document: [Sample XML File: Typical Purchase Order (LINQ to XML)](../../../../csharp/programming-guide/concepts/linq/sample-xml-file-typical-purchase-order-linq-to-xml-1.md).  
   
-```cs  
+```csharp  
 class NameQty {  
     public string name;  
     public int qty;  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-project-an-anonymous-type.md b/docs/csharp/programming-guide/concepts/linq/how-to-project-an-anonymous-type.md
index 184e187e038c0..cf8e57dbe1a9b 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-project-an-anonymous-type.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-project-an-anonymous-type.md
@@ -38,7 +38,7 @@ Country: USA
   
  This example uses the following XML document: [Sample XML File: Customers and Orders (LINQ to XML)](../../../../csharp/programming-guide/concepts/linq/sample-xml-file-customers-and-orders-linq-to-xml-2.md).  
   
-```cs  
+```csharp  
 XElement custOrd = XElement.Load("CustomersOrders.xml");  
 var custList =  
     from el in custOrd.Element("Customers").Elements("Customer")  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-project-an-object-graph.md b/docs/csharp/programming-guide/concepts/linq/how-to-project-an-object-graph.md
index f6d3a976b6880..ead083f858730 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-project-an-object-graph.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-project-an-object-graph.md
@@ -23,7 +23,7 @@ This topic illustrates how to project, or populate, an object graph from XML.
 ## Example  
  The following code populates an object graph with the `Address`, `PurchaseOrder`, and `PurchaseOrderItem` classes from the [Sample XML File: Typical Purchase Order (LINQ to XML)](../../../../csharp/programming-guide/concepts/linq/sample-xml-file-typical-purchase-order-linq-to-xml-1.md) XML document.  
   
-```cs  
+```csharp  
 class Address  
 {  
     public enum AddressUse  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-query-an-arraylist-with-linq.md b/docs/csharp/programming-guide/concepts/linq/how-to-query-an-arraylist-with-linq.md
index 475f90c9b205b..b4013982e994e 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-query-an-arraylist-with-linq.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-query-an-arraylist-with-linq.md
@@ -39,7 +39,7 @@ var query = from Student s in arrList
 ## Example  
  The following example shows a simple query over an <xref:System.Collections.ArrayList>. Note that this example uses object initializers when the code calls the <xref:System.Collections.ArrayList.Add%2A> method, but this is not a requirement.  
   
-```cs  
+```csharp  
 using System;  
 using System.Collections;  
 using System.Linq;  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-query-an-assembly-s-metadata-with-reflection-linq.md b/docs/csharp/programming-guide/concepts/linq/how-to-query-an-assembly-s-metadata-with-reflection-linq.md
index a201c564c839a..810f34f3d45d2 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-query-an-assembly-s-metadata-with-reflection-linq.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-query-an-assembly-s-metadata-with-reflection-linq.md
@@ -22,7 +22,7 @@ The following example shows how LINQ can be used with reflection to retrieve spe
   
 ## Example  
   
-```cs  
+```csharp  
 using System.Reflection;  
 using System.IO;  
 namespace LINQReflection  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-query-for-characters-in-a-string-linq.md b/docs/csharp/programming-guide/concepts/linq/how-to-query-for-characters-in-a-string-linq.md
index 5cb557e86bf72..9a7226b55d57b 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-query-for-characters-in-a-string-linq.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-query-for-characters-in-a-string-linq.md
@@ -28,7 +28,7 @@ Because the <xref:System.String> class implements the generic <xref:System.Colle
 ## Example  
  The following example queries a string to determine the number of numeric digits it contains. Note that the query is "reused" after it is executed the first time. This is possible because the query itself does not store any actual results.  
   
-```cs  
+```csharp  
 class QueryAString  
 {  
     static void Main()  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-query-for-duplicate-files-in-a-directory-tree-linq.md b/docs/csharp/programming-guide/concepts/linq/how-to-query-for-duplicate-files-in-a-directory-tree-linq.md
index b2a91e16b837c..9e70d88ad277c 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-query-for-duplicate-files-in-a-directory-tree-linq.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-query-for-duplicate-files-in-a-directory-tree-linq.md
@@ -27,7 +27,7 @@ Sometimes files that have the same name may be located in more than one folder.
   
 ## Example  
   
-```cs  
+```csharp  
 class QueryDuplicateFileNames  
 {  
     static void Main(string[] args)  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-query-for-files-with-a-specified-attribute-or-name.md b/docs/csharp/programming-guide/concepts/linq/how-to-query-for-files-with-a-specified-attribute-or-name.md
index 6b433bce58ac5..a00565531b518 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-query-for-files-with-a-specified-attribute-or-name.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-query-for-files-with-a-specified-attribute-or-name.md
@@ -27,7 +27,7 @@ This example shows how to find all files that have a specified file name extensi
   
 ## Example  
   
-```cs  
+```csharp  
 class FindFileByExtension  
 {  
     // This query will produce the full path for all .txt files  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-query-for-sentences-that-contain-a-specified-set-of-words-linq.md b/docs/csharp/programming-guide/concepts/linq/how-to-query-for-sentences-that-contain-a-specified-set-of-words-linq.md
index 07c94cc0ecd78..22c606101da4c 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-query-for-sentences-that-contain-a-specified-set-of-words-linq.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-query-for-sentences-that-contain-a-specified-set-of-words-linq.md
@@ -27,7 +27,7 @@ This example shows how to find sentences in a text file that contain matches for
   
 ## Example  
   
-```cs  
+```csharp  
 class FindSentences  
 {  
     static void Main()  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-query-for-the-largest-file-or-files-in-a-directory-tree-linq.md b/docs/csharp/programming-guide/concepts/linq/how-to-query-for-the-largest-file-or-files-in-a-directory-tree-linq.md
index 874b1ce0abe39..eecf18449a17d 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-query-for-the-largest-file-or-files-in-a-directory-tree-linq.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-query-for-the-largest-file-or-files-in-a-directory-tree-linq.md
@@ -38,7 +38,7 @@ This example shows five queries related to file size in bytes:
 ## Example  
  The following example contains five separate queries that show how to query and group files, depending on their file size in bytes. You can easily modify these examples to base the query on some other property of the <xref:System.IO.FileInfo> object.  
   
-```cs  
+```csharp  
 class QueryBySize  
 {  
     static void Main(string[] args)  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-query-for-the-total-number-of-bytes-in-a-set-of-folders-linq.md b/docs/csharp/programming-guide/concepts/linq/how-to-query-for-the-total-number-of-bytes-in-a-set-of-folders-linq.md
index 4807374c3c4ae..c9c12b65c2603 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-query-for-the-total-number-of-bytes-in-a-set-of-folders-linq.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-query-for-the-total-number-of-bytes-in-a-set-of-folders-linq.md
@@ -28,7 +28,7 @@ This example shows how to retrieve the total number of bytes used by all the fil
 ## Example  
  The <xref:System.Linq.Enumerable.Sum%2A> method adds the values of all the items selected in the `select` clause. You can easily modify this query to retrieve the biggest or smallest file in the specified directory tree by calling the <xref:System.Linq.Enumerable.Min%2A> or <xref:System.Linq.Enumerable.Max%2A> method instead of <xref:System.Linq.Enumerable.Sum%2A>.  
   
-```cs  
+```csharp  
 class QuerySize  
 {  
     public static void Main()  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-query-linq-to-xml-using-xpath.md b/docs/csharp/programming-guide/concepts/linq/how-to-query-linq-to-xml-using-xpath.md
index 9ee80b9ce5e45..631bae06d107e 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-query-linq-to-xml-using-xpath.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-query-linq-to-xml-using-xpath.md
@@ -25,7 +25,7 @@ This topic introduces the extension methods that enable you to query an XML tree
 ## Example  
  The following example creates a small XML tree and uses <xref:System.Xml.XPath.Extensions.XPathSelectElements%2A> to select a set of elements.  
   
-```cs  
+```csharp  
 XElement root = new XElement("Root",  
     new XElement("Child1", 1),  
     new XElement("Child1", 2),  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-query-the-contents-of-files-in-a-folder-lin.md b/docs/csharp/programming-guide/concepts/linq/how-to-query-the-contents-of-files-in-a-folder-lin.md
index 5ad20d3fb6da7..857f8455ae0b0 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-query-the-contents-of-files-in-a-folder-lin.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-query-the-contents-of-files-in-a-folder-lin.md
@@ -27,7 +27,7 @@ This example shows how to query over all the files in a specified directory tree
   
 ## Example  
   
-```cs  
+```csharp  
 class QueryContents  
 {  
     public static void Main()  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-read-and-write-an-encoded-document.md b/docs/csharp/programming-guide/concepts/linq/how-to-read-and-write-an-encoded-document.md
index 2c424a10ac5f8..ceee3e3426e23 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-read-and-write-an-encoded-document.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-read-and-write-an-encoded-document.md
@@ -34,7 +34,7 @@ To create an encoded XML document, you add an <xref:System.Xml.Linq.XDeclaration
 ## Example  
  The following example creates two documents, one with utf-8 encoding, and one with utf-16 encoding. It then loads the documents and prints the encoding to the console.  
   
-```cs  
+```csharp  
 Console.WriteLine("Creating a document with utf-8 encoding");  
 XDocument encodedDoc8 = new XDocument(  
     new XDeclaration("1.0", "utf-8", "yes"),  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-reorder-the-fields-of-a-delimited-file-linq.md b/docs/csharp/programming-guide/concepts/linq/how-to-reorder-the-fields-of-a-delimited-file-linq.md
index a8875b8b63134..c6a2980182d26 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-reorder-the-fields-of-a-delimited-file-linq.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-reorder-the-fields-of-a-delimited-file-linq.md
@@ -48,7 +48,7 @@ A comma-separated value (CSV) file is a text file that is often used to store sp
   
 ## Example  
   
-```cs  
+```csharp  
 class CSVFiles  
 {  
     static void Main(string[] args)  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-retrieve-a-collection-of-attributes-linq-to-xml.md b/docs/csharp/programming-guide/concepts/linq/how-to-retrieve-a-collection-of-attributes-linq-to-xml.md
index 2827b5921b0fc..f3009ac109161 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-retrieve-a-collection-of-attributes-linq-to-xml.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-retrieve-a-collection-of-attributes-linq-to-xml.md
@@ -23,7 +23,7 @@ This topic introduces the <xref:System.Xml.Linq.XElement.Attributes%2A> method.
 ## Example  
  The following example shows how to iterate through the collection of attributes of an element.  
   
-```cs  
+```csharp  
 XElement val = new XElement("Value",  
     new XAttribute("ID", "1243"),  
     new XAttribute("Type", "int"),  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-retrieve-a-collection-of-elements-linq-to-xml.md b/docs/csharp/programming-guide/concepts/linq/how-to-retrieve-a-collection-of-elements-linq-to-xml.md
index d24af1558dbbc..1e70b3c5df093 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-retrieve-a-collection-of-elements-linq-to-xml.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-retrieve-a-collection-of-elements-linq-to-xml.md
@@ -25,7 +25,7 @@ This topic demonstrates the <xref:System.Xml.Linq.XContainer.Elements%2A> method
   
  This example uses the following XML document: [Sample XML File: Typical Purchase Order (LINQ to XML)](../../../../csharp/programming-guide/concepts/linq/sample-xml-file-typical-purchase-order-linq-to-xml-1.md).  
   
-```cs  
+```csharp  
 XElement po = XElement.Load("PurchaseOrder.xml");  
 IEnumerable<XElement> childElements =  
     from el in po.Elements()  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-retrieve-a-single-attribute-linq-to-xml.md b/docs/csharp/programming-guide/concepts/linq/how-to-retrieve-a-single-attribute-linq-to-xml.md
index 3d7ae0ef863f3..4613e548f8790 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-retrieve-a-single-attribute-linq-to-xml.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-retrieve-a-single-attribute-linq-to-xml.md
@@ -25,7 +25,7 @@ This topic explains how to retrieve a single attribute of an element, given the
 ## Example  
  The following example uses the <xref:System.Xml.Linq.XElement.Attribute%2A> method.  
   
-```cs  
+```csharp  
 XElement cust = new XElement("PhoneNumbers",  
     new XElement("Phone",  
         new XAttribute("type", "home"),  
@@ -53,7 +53,7 @@ work
 ## Example  
  If you want to retrieve the value of the attribute, you can cast it, just as you do for with <xref:System.Xml.Linq.XElement> objects. The following example demonstrates this.  
   
-```cs  
+```csharp  
 XElement cust = new XElement("PhoneNumbers",  
     new XElement("Phone",  
         new XAttribute("type", "home"),  
@@ -81,7 +81,7 @@ work
 ## Example  
  The following example shows the same code for an attribute that is in a namespace. For more information, see [Working with XML Namespaces (C#)](../../../../csharp/programming-guide/concepts/linq/working-with-xml-namespaces.md).  
   
-```cs  
+```csharp  
 XNamespace aw = "http://www.adventure-works.com";  
 XElement cust = new XElement(aw + "PhoneNumbers",  
     new XElement(aw + "Phone",  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-retrieve-a-single-child-element-linq-to-xml.md b/docs/csharp/programming-guide/concepts/linq/how-to-retrieve-a-single-child-element-linq-to-xml.md
index 07f65a88a248c..cff0a0d1a50b5 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-retrieve-a-single-child-element-linq-to-xml.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-retrieve-a-single-child-element-linq-to-xml.md
@@ -31,7 +31,7 @@ This topic explains how to retrieve a single child element, given the name of th
   
  This example uses the following XML document: [Sample XML File: Typical Purchase Order (LINQ to XML)](../../../../csharp/programming-guide/concepts/linq/sample-xml-file-typical-purchase-order-linq-to-xml-1.md).  
   
-```cs  
+```csharp  
 XElement po = XElement.Load("PurchaseOrder.xml");  
 XElement e = po.Element("DeliveryNotes");  
 Console.WriteLine(e);  
@@ -49,7 +49,7 @@ Console.WriteLine(e);
   
  This example uses the following XML document: [Sample XML File: Typical Purchase Order in a Namespace](../../../../csharp/programming-guide/concepts/linq/sample-xml-file-typical-purchase-order-in-a-namespace.md).  
   
-```cs  
+```csharp  
 XElement po = XElement.Load("PurchaseOrderInNamespace.xml");  
 XNamespace aw = "http://www.adventure-works.com";  
 XElement e = po.Element(aw + "DeliveryNotes");  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-retrieve-paragraphs-from-an-office-open-xml-document.md b/docs/csharp/programming-guide/concepts/linq/how-to-retrieve-paragraphs-from-an-office-open-xml-document.md
index e3aaea80d75ab..5026505709080 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-retrieve-paragraphs-from-an-office-open-xml-document.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-retrieve-paragraphs-from-an-office-open-xml-document.md
@@ -31,7 +31,7 @@ This topic presents an example that opens an Office Open XML document, and retri
   
  This example uses classes found in the WindowsBase assembly. It uses types in the <xref:System.IO.Packaging?displayProperty=fullName> namespace.  
   
-```cs  
+```csharp  
 public static class LocalExtensions  
 {  
     public static string StringConcatenate(this IEnumerable<string> source)  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-retrieve-the-shallow-value-of-an-element.md b/docs/csharp/programming-guide/concepts/linq/how-to-retrieve-the-shallow-value-of-an-element.md
index 1695488689211..095b1968bf745 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-retrieve-the-shallow-value-of-an-element.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-retrieve-the-shallow-value-of-an-element.md
@@ -43,7 +43,7 @@ This topic shows how to get the shallow value of an element. The shallow value i
 </Report>  
 ```  
   
-```cs  
+```csharp  
 public static class MyExtensions  
 {  
     public static string ShallowValue(this XElement xe)  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-retrieve-the-value-of-an-attribute-linq-to-xml.md b/docs/csharp/programming-guide/concepts/linq/how-to-retrieve-the-value-of-an-attribute-linq-to-xml.md
index c709632cf660c..ee60a81ec3647 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-retrieve-the-value-of-an-attribute-linq-to-xml.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-retrieve-the-value-of-an-attribute-linq-to-xml.md
@@ -23,7 +23,7 @@ This topic shows how to obtain the value of attributes. There are two main ways:
 ## Example  
  To retrieve the value of an attribute, you just cast the <xref:System.Xml.Linq.XAttribute> object to your desired type.  
   
-```cs  
+```csharp  
 XElement root = new XElement("Root",  
                     new XAttribute("Attr", "abcde")  
                 );  
@@ -42,7 +42,7 @@ abcde
 ## Example  
  The following example shows how to retrieve the value of an attribute where the attribute is in a namespace. For more information, see [Working with XML Namespaces (C#)](../../../../csharp/programming-guide/concepts/linq/working-with-xml-namespaces.md).  
   
-```cs  
+```csharp  
 XNamespace aw = "http://www.adventure-works.com";  
 XElement root = new XElement(aw + "Root",  
                     new XAttribute(aw + "Attr", "abcde")  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-retrieve-the-value-of-an-element-linq-to-xml.md b/docs/csharp/programming-guide/concepts/linq/how-to-retrieve-the-value-of-an-element-linq-to-xml.md
index 85ac52d8c12ab..b3ecc5823af20 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-retrieve-the-value-of-an-element-linq-to-xml.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-retrieve-the-value-of-an-element-linq-to-xml.md
@@ -25,7 +25,7 @@ This topic shows how to get the value of elements. There are two main ways to do
 ## Example  
  To retrieve the value of an element, you just cast the <xref:System.Xml.Linq.XElement> object to your desired type. You can always cast an element to a string, as follows:  
   
-```cs  
+```csharp  
 XElement e = new XElement("StringElement", "abcde");  
 Console.WriteLine(e);  
 Console.WriteLine("Value of e:" + (string)e);  
@@ -41,7 +41,7 @@ Value of e:abcde
 ## Example  
  You can also cast elements to types other than string. For example, if you have an element that contains an integer, you can cast it to `int`, as shown in the following code:  
   
-```cs  
+```csharp  
 XElement e = new XElement("Age", "44");  
 Console.WriteLine(e);  
 Console.WriteLine("Value of e:" + (int)e);  
@@ -61,7 +61,7 @@ Value of e:44
 ## Example  
  You can use the <xref:System.Xml.Linq.XElement.Value%2A> property to retrieve the contents of an element:  
   
-```cs  
+```csharp  
 XElement e = new XElement("StringElement", "abcde");   
 Console.WriteLine(e);  
 Console.WriteLine("Value of e:" + e.Value);  
@@ -77,7 +77,7 @@ Value of e:abcde
 ## Example  
  Sometimes you try to retrieve the value of an element even though you are not sure it exists. In this case, when you assign the casted element to a nullable type (either `string` or one of the nullable types in the [!INCLUDE[dnprdnshort](../../../../csharp/getting-started/includes/dnprdnshort_md.md)]), if the element does not exist the assigned variable is just set to `null`. The following code shows that when the element might or might not exist, it is easier to use casting than to use the <xref:System.Xml.Linq.XElement.Value%2A> property.  
   
-```cs  
+```csharp  
 XElement root = new XElement("Root",  
     new XElement("Child1", "child 1 content"),  
     new XElement("Child2", "2")  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-serialize-using-datacontractserializer.md b/docs/csharp/programming-guide/concepts/linq/how-to-serialize-using-datacontractserializer.md
index 612700d15f7a3..036796544e0d4 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-serialize-using-datacontractserializer.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-serialize-using-datacontractserializer.md
@@ -28,7 +28,7 @@ This topic shows an example that serializes and deserializes using <xref:System.
 ## Example  
  The following example creates a number of objects that contain <xref:System.Xml.Linq.XElement> objects. It then serializes them to text files, and then deserializes them from the text files.  
   
-```cs  
+```csharp  
 using System;  
 using System.Xml;  
 using System.Xml.Linq;  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-serialize-using-xmlserializer.md b/docs/csharp/programming-guide/concepts/linq/how-to-serialize-using-xmlserializer.md
index 55432f3830372..ea664fa1309b6 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-serialize-using-xmlserializer.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-serialize-using-xmlserializer.md
@@ -28,7 +28,7 @@ This topic shows an example that serializes and deserializes using <xref:System.
 ## Example  
  The following example creates a number of objects that contain <xref:System.Xml.Linq.XElement> objects. It then serializes them to a memory stream, and then deserializes them from the memory stream.  
   
-```cs  
+```csharp  
 using System;  
 using System.IO;  
 using System.Linq;  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-sort-elements-on-multiple-keys.md b/docs/csharp/programming-guide/concepts/linq/how-to-sort-elements-on-multiple-keys.md
index 29b240dd65ea6..b65c682d16353 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-sort-elements-on-multiple-keys.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-sort-elements-on-multiple-keys.md
@@ -25,7 +25,7 @@ This topic shows how to sort on multiple keys.
   
  This example uses the following XML document: [Sample XML File: Customers and Orders (LINQ to XML)](../../../../csharp/programming-guide/concepts/linq/sample-xml-file-customers-and-orders-linq-to-xml-2.md).  
   
-```cs  
+```csharp  
 XElement co = XElement.Load("CustomersOrders.xml");  
 var sortedElements =  
     from c in co.Element("Orders").Elements("Order")  
@@ -74,7 +74,7 @@ CustomerID:LAZYK EmployeeID:8 ShipPostalCode:99362 OrderDate:5/22/1997
   
  This example uses the following XML document: [Sample XML File: Customers and Orders in a Namespace](../../../../csharp/programming-guide/concepts/linq/sample-xml-file-customers-and-orders-in-a-namespace.md).  
   
-```cs  
+```csharp  
 XElement co = XElement.Load("CustomersOrdersInNamespace.xml");  
 XNamespace aw = "http://www.adventure-works.com";  
 var sortedElements =  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-sort-elements.md b/docs/csharp/programming-guide/concepts/linq/how-to-sort-elements.md
index 6da88c775cea5..c12e512a8351f 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-sort-elements.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-sort-elements.md
@@ -23,7 +23,7 @@ This example shows how to write a query that sorts its results.
 ## Example  
  This example uses the following XML document: [Sample XML File: Numerical Data (LINQ to XML)](../../../../csharp/programming-guide/concepts/linq/sample-xml-file-numerical-data-linq-to-xml.md).  
   
-```cs  
+```csharp  
 XElement root = XElement.Load("Data.xml");  
 IEnumerable<decimal> prices =  
     from el in root.Elements("Data")  
@@ -51,7 +51,7 @@ foreach (decimal el in prices)
   
  This example uses the following XML document: [Sample XML File: Numerical Data in a Namespace](../../../../csharp/programming-guide/concepts/linq/sample-xml-file-numerical-data-in-a-namespace.md).  
   
-```cs  
+```csharp  
 XElement root = XElement.Load("DataInNamespace.xml");  
 XNamespace aw = "http://www.adatum.com";  
 IEnumerable<decimal> prices =  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-sort-or-filter-text-data-by-any-word-or-field-linq.md b/docs/csharp/programming-guide/concepts/linq/how-to-sort-or-filter-text-data-by-any-word-or-field-linq.md
index 9b3a7d6699b0c..181b46cfa8909 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-sort-or-filter-text-data-by-any-word-or-field-linq.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-sort-or-filter-text-data-by-any-word-or-field-linq.md
@@ -31,7 +31,7 @@ The following example shows how to sort lines of structured text, such as comma-
   
 ## Example  
   
-```cs  
+```csharp  
 public class SortLines  
 {  
     static void Main()  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-split-a-file-into-many-files-by-using-groups-linq.md b/docs/csharp/programming-guide/concepts/linq/how-to-split-a-file-into-many-files-by-using-groups-linq.md
index cd5fbc57c2ffd..737abb66699cf 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-split-a-file-into-many-files-by-using-groups-linq.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-split-a-file-into-many-files-by-using-groups-linq.md
@@ -59,7 +59,7 @@ This example shows one way to merge the contents of two files and then create a
   
 ## Example  
   
-```cs  
+```csharp  
 class SplitWithGroups  
 {  
     static void Main()  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-stream-xml-fragments-from-an-xmlreader.md b/docs/csharp/programming-guide/concepts/linq/how-to-stream-xml-fragments-from-an-xmlreader.md
index 03a96ff07677a..67f2d55e5c47d 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-stream-xml-fragments-from-an-xmlreader.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-stream-xml-fragments-from-an-xmlreader.md
@@ -38,7 +38,7 @@ When you have to process large XML files, it might not be feasible to load the w
 ## Example  
  This example creates a custom axis method. You can query it by using a [!INCLUDE[vbteclinq](../../../../csharp/includes/vbteclinq_md.md)] query. The custom axis method, `StreamRootChildDoc`, is a method that is designed specifically to read a document that has a repeating `Child` element.  
   
-```cs  
+```csharp  
 static IEnumerable<XElement> StreamRootChildDoc(StringReader stringReader)  
 {  
     using (XmlReader reader = XmlReader.Create(stringReader))  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-stream-xml-fragments-with-access-to-header-information.md b/docs/csharp/programming-guide/concepts/linq/how-to-stream-xml-fragments-with-access-to-header-information.md
index ef0f24646b0c3..af0567ad5e3a7 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-stream-xml-fragments-with-access-to-header-information.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-stream-xml-fragments-with-access-to-header-information.md
@@ -85,7 +85,7 @@ Sometimes you have to read arbitrarily large XML files, and write your applicati
   
  The following example shows how to implement and use a custom axis method that streams XML fragments from the file specified by the URI. This custom axis is specifically written such that it expects a document that has `Customer`, `Name`, and `Item` elements, and that those elements will be arranged as in the above `Source.xml` document. It is a simplistic implementation. A more robust implementation would be prepared to parse an invalid document.  
   
-```cs  
+```csharp  
 static IEnumerable<XElement> StreamCustomerItem(string uri)  
 {  
     using (XmlReader reader = XmlReader.Create(uri))  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-transform-the-shape-of-an-xml-tree.md b/docs/csharp/programming-guide/concepts/linq/how-to-transform-the-shape-of-an-xml-tree.md
index 0cab5bf1be198..47a4ea8cb426b 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-transform-the-shape-of-an-xml-tree.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-transform-the-shape-of-an-xml-tree.md
@@ -33,7 +33,7 @@ The *shape* of an XML document refers to its element names, attribute names, and
   
  This example uses the following XML document: [Sample XML File: Customers and Orders (LINQ to XML)](../../../../csharp/programming-guide/concepts/linq/sample-xml-file-customers-and-orders-linq-to-xml-2.md).  
   
-```cs  
+```csharp  
 XElement co = XElement.Load("CustomersOrders.xml");  
 XElement newCustOrd =  
     new XElement("Root",  
@@ -100,7 +100,7 @@ Console.WriteLine(newCustOrd);
   
  This example uses the following XML document: [Sample XML File: Typical Purchase Order (LINQ to XML)](../../../../csharp/programming-guide/concepts/linq/sample-xml-file-typical-purchase-order-linq-to-xml-1.md).  
   
-```cs  
+```csharp  
 static IEnumerable<XElement> ConvertAddress(XElement add)  
 {  
     List<XElement> fragment = new List<XElement>() {  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-use-annotations-to-transform-linq-to-xml-trees-in-an-xslt-style.md b/docs/csharp/programming-guide/concepts/linq/how-to-use-annotations-to-transform-linq-to-xml-trees-in-an-xslt-style.md
index 72ab5e45c1350..d8faff883985a 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-use-annotations-to-transform-linq-to-xml-trees-in-an-xslt-style.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-use-annotations-to-transform-linq-to-xml-trees-in-an-xslt-style.md
@@ -56,7 +56,7 @@ Annotations can be used to facilitate transforms of an XML tree.
 ## Transforming a Tree  
  This first example renames all `Paragraph` nodes to `para`.  
   
-```cs  
+```csharp  
 XNamespace xf = "http://www.microsoft.com/LinqToXmlTransform/2007";  
 XName at = xf + "ApplyTransforms";  
   
@@ -93,7 +93,7 @@ Console.WriteLine(newRoot);
 ## A More Complicated Transform  
  The following example queries the tree and calculates the average and sum of the `Data` elements, and adds them as new elements to the tree.  
   
-```cs  
+```csharp  
 XNamespace xf = "http://www.microsoft.com/LinqToXmlTransform/2007";  
 XName at = xf + "ApplyTransforms";  
   
@@ -192,7 +192,7 @@ If an element is not annotated
   
  Following is the implementation of this function:  
   
-```cs  
+```csharp  
 // Build a transformed XML tree per the annotations  
 static XElement XForm(XElement source)  
 {  
@@ -258,7 +258,7 @@ static XElement XForm(XElement source)
 ## Complete Example  
  The following code is a complete example that includes the `XForm` function. It includes a few of the typical uses of this type of transform:  
   
-```cs  
+```csharp  
 using System;  
 using System.Collections.Generic;  
 using System.Linq;  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-validate-using-xsd-linq-to-xml.md b/docs/csharp/programming-guide/concepts/linq/how-to-validate-using-xsd-linq-to-xml.md
index 316137f6ed287..4f62dc15ec880 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-validate-using-xsd-linq-to-xml.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-validate-using-xsd-linq-to-xml.md
@@ -28,7 +28,7 @@ The <xref:System.Xml.Schema> namespace contains extension methods that make it e
 ## Example  
  The following example creates an <xref:System.Xml.Schema.XmlSchemaSet>, then validates two <xref:System.Xml.Linq.XDocument> objects against the schema set. One of the documents is valid, the other is not.  
   
-```cs  
+```csharp  
 string xsdMarkup =  
     @"<xsd:schema xmlns:xsd='http://www.w3.org/2001/XMLSchema'>  
        <xsd:element name='Root'>  
@@ -95,7 +95,7 @@ doc2 did not validate
   
  This example uses the following XSD schema: [Sample XSD File: Customers and Orders](../../../../csharp/programming-guide/concepts/linq/sample-xsd-file-customers-and-orders1.md).  
   
-```cs  
+```csharp  
 XmlSchemaSet schemas = new XmlSchemaSet();  
 schemas.Add("", "CustomersOrders.xsd");  
   
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-work-with-dictionaries-using-linq-to-xml.md b/docs/csharp/programming-guide/concepts/linq/how-to-work-with-dictionaries-using-linq-to-xml.md
index d79651f042de4..cb8d0040aba91 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-work-with-dictionaries-using-linq-to-xml.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-work-with-dictionaries-using-linq-to-xml.md
@@ -23,7 +23,7 @@ It is often convenient to convert varieties of data structures to XML, and XML b
 ## Example  
  This example uses a form of functional construction in which a query projects new <xref:System.Xml.Linq.XElement> objects, and the resulting collection is passed as an argument to the constructor of the Root <xref:System.Xml.Linq.XElement> object.  
   
-```cs  
+```csharp  
 Dictionary<string, string> dict = new Dictionary<string, string>();  
 dict.Add("Child1", "Value1");  
 dict.Add("Child2", "Value2");  
@@ -50,7 +50,7 @@ Console.WriteLine(root);
 ## Example  
  The following code creates a dictionary from XML.  
   
-```cs  
+```csharp  
 XElement root = new XElement("Root",  
     new XElement("Child1", "Value1"),  
     new XElement("Child2", "Value2"),  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-write-a-linq-to-xml-axis-method.md b/docs/csharp/programming-guide/concepts/linq/how-to-write-a-linq-to-xml-axis-method.md
index f0cdaf25c3918..6f0223d177e35 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-write-a-linq-to-xml-axis-method.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-write-a-linq-to-xml-axis-method.md
@@ -25,7 +25,7 @@ You can write your own axis methods to retrieve collections from an XML tree. On
   
  This example uses the following XML document: [Sample XML File: Multiple Purchase Orders (LINQ to XML)](../../../../csharp/programming-guide/concepts/linq/sample-xml-file-multiple-purchase-orders-linq-to-xml.md).  
   
-```cs  
+```csharp  
 public static class MyExtensions  
 {  
     private static string GetQName(XElement xe)  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-write-a-query-that-finds-elements-based-on-context.md b/docs/csharp/programming-guide/concepts/linq/how-to-write-a-query-that-finds-elements-based-on-context.md
index db1ecfe7e52dd..3e05877aa56c0 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-write-a-query-that-finds-elements-based-on-context.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-write-a-query-that-finds-elements-based-on-context.md
@@ -25,7 +25,7 @@ Sometimes you might have to write a query that selects elements based on their c
 ## Example  
  The following example selects all `p` elements that are immediately followed by a `ul` element.  
   
-```cs  
+```csharp  
 XElement doc = XElement.Parse(@"<Root>  
     <p id=""1""/>  
     <ul>abc</ul>  
@@ -66,7 +66,7 @@ id = 6
 ## Example  
  The following example shows the same query for XML that is in a namespace. For more information, see [Working with XML Namespaces (C#)](../../../../csharp/programming-guide/concepts/linq/working-with-xml-namespaces.md).  
   
-```cs  
+```csharp  
 XElement doc = XElement.Parse(@"<Root xmlns='http://www.adatum.com'>  
     <p id=""1""/>  
     <ul>abc</ul>  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-write-queries-on-xml-in-namespaces.md b/docs/csharp/programming-guide/concepts/linq/how-to-write-queries-on-xml-in-namespaces.md
index c4c1d29a64714..6decba1355b3f 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-write-queries-on-xml-in-namespaces.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-write-queries-on-xml-in-namespaces.md
@@ -32,7 +32,7 @@ To write a query on XML that is in a namespace, you must use <xref:System.Xml.Li
 ## Example  
  The following example creates an XML tree that is in a default namespace. It then retrieves a collection of elements.  
   
-```cs  
+```csharp  
 XNamespace aw = "http://www.adventure-works.com";  
 XElement root = XElement.Parse(  
 @"<Root xmlns='http://www.adventure-works.com'>  
@@ -63,7 +63,7 @@ foreach (XElement el in c1)
   
  The following example creates an XML tree that is in a namespace with a prefix. It then retrieves a collection of elements.  
   
-```cs  
+```csharp  
 XNamespace aw = "http://www.adventure-works.com";  
 XElement root = XElement.Parse(  
 @"<aw:Root xmlns:aw='http://www.adventure-works.com'>  
diff --git a/docs/csharp/programming-guide/concepts/linq/how-to-write-queries-with-complex-filtering.md b/docs/csharp/programming-guide/concepts/linq/how-to-write-queries-with-complex-filtering.md
index c02d86e014f48..9c9cf7d5b5824 100644
--- a/docs/csharp/programming-guide/concepts/linq/how-to-write-queries-with-complex-filtering.md
+++ b/docs/csharp/programming-guide/concepts/linq/how-to-write-queries-with-complex-filtering.md
@@ -27,7 +27,7 @@ Sometimes you want to write LINQ to XML queries with complex filters. For exampl
   
  For more information about the `Any` operator, see [Quantifier Operations (C#)](../../../../csharp/programming-guide/concepts/linq/quantifier-operations.md).  
   
-```cs  
+```csharp  
 XElement root = XElement.Load("PurchaseOrders.xml");  
 IEnumerable<XElement> purchaseOrders =  
     from el in root.Elements("PurchaseOrder")  
@@ -54,7 +54,7 @@ foreach (XElement el in purchaseOrders)
   
  This example uses the following XML document: [Sample XML File: Multiple Purchase Orders in a Namespace](../../../../csharp/programming-guide/concepts/linq/sample-xml-file-multiple-purchase-orders-in-a-namespace.md).  
   
-```cs  
+```csharp  
 XElement root = XElement.Load("PurchaseOrdersInNamespace.xml");  
 XNamespace aw = "http://www.adventure-works.com";  
 IEnumerable<XElement> purchaseOrders =  
diff --git a/docs/csharp/programming-guide/concepts/linq/in-memory-xml-tree-modification-vs-functional-construction-linq-to-xml.md b/docs/csharp/programming-guide/concepts/linq/in-memory-xml-tree-modification-vs-functional-construction-linq-to-xml.md
index 789b6243e3337..1bc5a8fa048ce 100644
--- a/docs/csharp/programming-guide/concepts/linq/in-memory-xml-tree-modification-vs-functional-construction-linq-to-xml.md
+++ b/docs/csharp/programming-guide/concepts/linq/in-memory-xml-tree-modification-vs-functional-construction-linq-to-xml.md
@@ -41,7 +41,7 @@ Modifying an XML tree in place is a traditional approach to changing the shape o
 ### Modifying the XML Tree  
  You can write some procedural code to create elements from the attributes, and then delete the attributes, as follows:  
   
-```cs  
+```csharp  
 XElement root = XElement.Load("Data.xml");  
 foreach (XAttribute att in root.Attributes()) {  
     root.Add(new XElement(att.Name, (string)att));  
@@ -63,7 +63,7 @@ Console.WriteLine(root);
 ### Functional Construction Approach  
  By contrast, a functional approach consists of code to form a new tree, picking and choosing elements and attributes from the source tree, and transforming them as appropriate as they are added to the new tree. The functional approach looks like the following:  
   
-```cs  
+```csharp  
 XElement root = XElement.Load("Data.xml");  
 XElement newTree = new XElement("Root",  
     root.Element("Child1"),  
diff --git a/docs/csharp/programming-guide/concepts/linq/intermediate-materialization.md b/docs/csharp/programming-guide/concepts/linq/intermediate-materialization.md
index c3792178dace1..55397fd911c31 100644
--- a/docs/csharp/programming-guide/concepts/linq/intermediate-materialization.md
+++ b/docs/csharp/programming-guide/concepts/linq/intermediate-materialization.md
@@ -23,7 +23,7 @@ If you are not careful, in some situations you can drastically alter the memory
 ## Example  
  This example alters the previous example. The `AppendString` method calls <xref:System.Linq.Enumerable.ToList%2A> before iterating through the source. This causes materialization.  
   
-```cs  
+```csharp  
 public static class LocalExtensions  
 {  
     public static IEnumerable<string>  
diff --git a/docs/csharp/programming-guide/concepts/linq/introduction-to-linq-queries.md b/docs/csharp/programming-guide/concepts/linq/introduction-to-linq-queries.md
index 3d5cbd7418b3c..9333ee788efd7 100644
--- a/docs/csharp/programming-guide/concepts/linq/introduction-to-linq-queries.md
+++ b/docs/csharp/programming-guide/concepts/linq/introduction-to-linq-queries.md
@@ -66,7 +66,7 @@ A *query* is an expression that retrieves data from a data source. Queries are u
   
  With [!INCLUDE[vbtecdlinq](../../../../csharp/includes/vbtecdlinq_md.md)], you first create an object-relational mapping at design time either manually or by using the [LINQ to SQL Tools in Visual Studio](https://docs.microsoft.com/visualstudio/data-tools/linq-to-sql-tools-in-visual-studio2) in Visual Studio. You write your queries against the objects, and at run-time [!INCLUDE[vbtecdlinq](../../../../csharp/includes/vbtecdlinq_md.md)] handles the communication with the database. In the following example, `Customers` represents a specific table in the database, and the type of the query result, <xref:System.Linq.IQueryable%601>, derives from <xref:System.Collections.Generic.IEnumerable%601>.  
   
-```cs  
+```csharp  
 Northwnd db = new Northwnd(@"c:\northwnd.mdf");  
   
 // Query for customers in London.  
diff --git a/docs/csharp/programming-guide/concepts/linq/linq-to-xml-events.md b/docs/csharp/programming-guide/concepts/linq/linq-to-xml-events.md
index 881cbc4ca794d..726c755558f54 100644
--- a/docs/csharp/programming-guide/concepts/linq/linq-to-xml-events.md
+++ b/docs/csharp/programming-guide/concepts/linq/linq-to-xml-events.md
@@ -51,7 +51,7 @@ translation.priority.mt:
   
 ### Code  
   
-```cs  
+```csharp  
 XElement root = new XElement("Root",  
     new XElement("Total", "0"),  
     new XElement("Items")  
diff --git a/docs/csharp/programming-guide/concepts/linq/linq-to-xml-overview.md b/docs/csharp/programming-guide/concepts/linq/linq-to-xml-overview.md
index e04a6cb6ac172..fb81c8d553b19 100644
--- a/docs/csharp/programming-guide/concepts/linq/linq-to-xml-overview.md
+++ b/docs/csharp/programming-guide/concepts/linq/linq-to-xml-overview.md
@@ -43,7 +43,7 @@ XML has been widely adopted as a way to format data in many contexts. For exampl
   
  For example, you might have a typical XML purchase order as described in [Sample XML File: Typical Purchase Order (LINQ to XML)](http://msdn.microsoft.com/library/0606c09f-6e43-4f8d-95c8-e8e2e08d2348). By using [!INCLUDE[sqltecxlinq](../../../../csharp/programming-guide/concepts/linq/includes/sqltecxlinq_md.md)], you could run the following query to obtain the part number attribute value for every item element in the purchase order:  
   
-```cs  
+```csharp  
 IEnumerable<string> partNos =  
 from item in purchaseOrder.Descendants("Item")  
 select (string) item.Attribute("PartNumber");  
@@ -51,7 +51,7 @@ select (string) item.Attribute("PartNumber");
   
  As another example, you might want a list, sorted by part number, of the items with a value greater than $100. To obtain this information, you could run the following query:  
   
-```cs  
+```csharp  
 IEnumerable<XElement> partNos =  
 from item in purchaseOrder.Descendants("Item")  
 where (int) item.Element("Quantity") *  
@@ -79,7 +79,7 @@ select item;
 ## Creating XML Trees  
  IOne of the most significant advantages of programming with [!INCLUDE[sqltecxlinq](../../../../csharp/programming-guide/concepts/linq/includes/sqltecxlinq_md.md)] is that it is easy to create XML trees. For example, to create a small XML tree, you can write code as follows:  
   
-```cs  
+```csharp  
 XElement contacts =  
 new XElement("Contacts",  
     new XElement("Contact",  
diff --git a/docs/csharp/programming-guide/concepts/linq/linq-to-xml-vs-dom.md b/docs/csharp/programming-guide/concepts/linq/linq-to-xml-vs-dom.md
index ebea9c910ed7a..ae55776f0f1d4 100644
--- a/docs/csharp/programming-guide/concepts/linq/linq-to-xml-vs-dom.md
+++ b/docs/csharp/programming-guide/concepts/linq/linq-to-xml-vs-dom.md
@@ -30,7 +30,7 @@ This section describes some key differences between [!INCLUDE[sqltecxlinq](../..
   
  For example, the following would be a typical way to create an XML tree using the Microsoft implementation of DOM, <xref:System.Xml.XmlDocument>:  
   
-```cs  
+```csharp  
 XmlDocument doc = new XmlDocument();  
 XmlElement name = doc.CreateElement("Name");  
 name.InnerText = "Patrick Hines";  
@@ -67,7 +67,7 @@ doc.AppendChild(contacts);
   
  Here is how you would construct the same XML tree by using [!INCLUDE[sqltecxlinq](../../../../csharp/programming-guide/concepts/linq/includes/sqltecxlinq_md.md)] functional construction:  
   
-```cs  
+```csharp  
 XElement contacts =  
     new XElement("Contacts",  
         new XElement("Contact",  
@@ -101,7 +101,7 @@ XElement contacts =
   
  Compare this to the W3C DOM, in which the XML document is used as a logical container for the XML tree. In DOM, XML nodes, including elements and attributes, must be created in the context of an XML document. Here is a fragment of the code to create a name element in DOM:  
   
-```cs  
+```csharp  
 XmlDocument doc = new XmlDocument();  
 XmlElement name = doc.CreateElement("Name");  
 name.InnerText = "Patrick Hines";  
diff --git a/docs/csharp/programming-guide/concepts/linq/maintaining-name-value-pairs.md b/docs/csharp/programming-guide/concepts/linq/maintaining-name-value-pairs.md
index 507c09c4072b2..65aabdb95e2e8 100644
--- a/docs/csharp/programming-guide/concepts/linq/maintaining-name-value-pairs.md
+++ b/docs/csharp/programming-guide/concepts/linq/maintaining-name-value-pairs.md
@@ -44,7 +44,7 @@ Many applications have to maintain information that is best kept as name/value p
 ## Example  
  The following example creates an element with no attributes. It then uses the <xref:System.Xml.Linq.XElement.SetAttributeValue%2A> method to create and maintain a list of name/value pairs.  
   
-```cs  
+```csharp  
 // Create an element with no content.  
 XElement root = new XElement("Root");  
   
@@ -76,7 +76,7 @@ Console.WriteLine(root);
 ## Example  
  The following example creates an element with no child elements. It then uses the <xref:System.Xml.Linq.XElement.SetElementValue%2A> method to create and maintain a list of name/value pairs.  
   
-```cs  
+```csharp  
 // Create an element with no content.  
 XElement root = new XElement("Root");  
   
diff --git a/docs/csharp/programming-guide/concepts/linq/mixed-declarative-code-imperative-code-bugs-linq-to-xml.md b/docs/csharp/programming-guide/concepts/linq/mixed-declarative-code-imperative-code-bugs-linq-to-xml.md
index 0a5ec8a2fad3a..e7ad9ade20493 100644
--- a/docs/csharp/programming-guide/concepts/linq/mixed-declarative-code-imperative-code-bugs-linq-to-xml.md
+++ b/docs/csharp/programming-guide/concepts/linq/mixed-declarative-code-imperative-code-bugs-linq-to-xml.md
@@ -47,7 +47,7 @@ translation.priority.mt:
 ## Adding While Iterating  
  For example, suppose you want to write some code that for every element in a tree, you want to create a duplicate element:  
   
-```cs  
+```csharp  
 XElement root = new XElement("Root",  
     new XElement("A", "1"),  
     new XElement("B", "2"),  
@@ -61,7 +61,7 @@ foreach (XElement e in root.Elements())
   
  You can fix this problem by pulling the collection into memory using the <xref:System.Linq.Enumerable.ToList%2A> standard query operator, as follows:  
   
-```cs  
+```csharp  
 XElement root = new XElement("Root",  
     new XElement("A", "1"),  
     new XElement("B", "2"),  
@@ -88,7 +88,7 @@ Console.WriteLine(root);
 ## Deleting While Iterating  
  If you want to delete all nodes at a certain level, you might be tempted to write code like the following:  
   
-```cs  
+```csharp  
 XElement root = new XElement("Root",  
     new XElement("A", "1"),  
     new XElement("B", "2"),  
@@ -112,7 +112,7 @@ Console.WriteLine(root);
   
  The solution again is to call <xref:System.Linq.Enumerable.ToList%2A> to materialize the collection, as follows:  
   
-```cs  
+```csharp  
 XElement root = new XElement("Root",  
     new XElement("A", "1"),  
     new XElement("B", "2"),  
@@ -131,7 +131,7 @@ Console.WriteLine(root);
   
  Alternatively, you can eliminate the iteration altogether by calling <xref:System.Xml.Linq.XElement.RemoveAll%2A> on the parent element:  
   
-```cs  
+```csharp  
 XElement root = new XElement("Root",  
     new XElement("A", "1"),  
     new XElement("B", "2"),  
@@ -146,7 +146,7 @@ Console.WriteLine(root);
   
  Another possible approach would be to put in some sort of transaction syntax into LINQ, and have the compiler attempt to analyze the code and determine if any particular collection needed to be materialized. However, attempting to determine all code that has side-effects is incredibly complex. Consider the following code:  
   
-```cs  
+```csharp  
 var z =  
     from e in root.Elements()  
     where TestSomeCondition(e)  
@@ -168,7 +168,7 @@ var z =
   
  Second, if performance and other considerations allow, use only declarative code. Don't modify your existing XML tree. Generate a new one.  
   
-```cs  
+```csharp  
 XElement root = new XElement("Root",  
     new XElement("A", "1"),  
     new XElement("B", "2"),  
diff --git a/docs/csharp/programming-guide/concepts/linq/performance-of-chained-queries-linq-to-xml.md b/docs/csharp/programming-guide/concepts/linq/performance-of-chained-queries-linq-to-xml.md
index ad1bb8750b888..a184890d4d0f1 100644
--- a/docs/csharp/programming-guide/concepts/linq/performance-of-chained-queries-linq-to-xml.md
+++ b/docs/csharp/programming-guide/concepts/linq/performance-of-chained-queries-linq-to-xml.md
@@ -22,7 +22,7 @@ One of the most important benefits of LINQ (and LINQ to XML) is that chained que
   
  A chained query is a query that uses another query as its source. For example, in the following simple code, `query2` has `query1` as its source:  
   
-```cs  
+```csharp  
 XElement root = new XElement("Root",  
     new XElement("Child", 1),  
     new XElement("Child", 2),  
diff --git a/docs/csharp/programming-guide/concepts/linq/pre-atomization-of-xname-objects-linq-to-xml.md b/docs/csharp/programming-guide/concepts/linq/pre-atomization-of-xname-objects-linq-to-xml.md
index 08f70926ea3cc..c23ab53609267 100644
--- a/docs/csharp/programming-guide/concepts/linq/pre-atomization-of-xname-objects-linq-to-xml.md
+++ b/docs/csharp/programming-guide/concepts/linq/pre-atomization-of-xname-objects-linq-to-xml.md
@@ -27,7 +27,7 @@ One way to improve performance in LINQ to XML is to pre-atomize <xref:System.Xml
 ## Example  
  The following example demonstrates this.  
   
-```cs  
+```csharp  
 XName Root = "Root";  
 XName Data = "Data";  
 XName ID = "ID";  
@@ -59,7 +59,7 @@ Console.WriteLine(root);
   
  The following example shows the same technique where the XML document is in a namespace:  
   
-```cs  
+```csharp  
 XNamespace aw = "http://www.adventure-works.com";  
 XName Root = aw + "Root";  
 XName Data = aw + "Data";  
@@ -93,7 +93,7 @@ Console.WriteLine(root);
   
  The following example is more similar to what you will likely encounter in the real world. In this example, the content of the element is supplied by a query:  
   
-```cs  
+```csharp  
 XName Root = "Root";  
 XName Data = "Data";  
 XName ID = "ID";  
@@ -112,7 +112,7 @@ Console.WriteLine("Time to construct:{0}", t2 - t1);
   
  The previous example performs better than the following example, in which names are not pre-atomized:  
   
-```cs  
+```csharp  
 DateTime t1 = DateTime.Now;  
 XElement root = new XElement("Root",  
     from i in System.Linq.Enumerable.Range(1, 100000)  
diff --git a/docs/csharp/programming-guide/concepts/linq/programming-with-nodes.md b/docs/csharp/programming-guide/concepts/linq/programming-with-nodes.md
index 79ebdc4919612..f4af6d36b5dfb 100644
--- a/docs/csharp/programming-guide/concepts/linq/programming-with-nodes.md
+++ b/docs/csharp/programming-guide/concepts/linq/programming-with-nodes.md
@@ -33,7 +33,7 @@ translation.priority.mt:
   
  The following example demonstrates this:  
   
-```cs  
+```csharp  
 XDocument doc = XDocument.Parse(@"<!-- a comment --><Root/>");  
 Console.WriteLine(doc.Nodes().OfType<XComment>().First().Parent == null);  
 Console.WriteLine(doc.Root.Parent == null);  
@@ -51,7 +51,7 @@ True
   
  The following example demonstrates this:  
   
-```cs  
+```csharp  
 XElement xmlTree = new XElement("Root", "Content");  
   
 Console.WriteLine(xmlTree.Nodes().OfType<XText>().Count());  
@@ -76,7 +76,7 @@ Console.WriteLine(xmlTree.Nodes().OfType<XText>().Count());
 ### Empty Text Nodes are Possible  
  In some XML programming models, text nodes are guaranteed to not contain the empty string. The reasoning is that such a text node has no impact on serialization of the XML. However, for the same reason that adjacent text nodes are possible, if you remove the text from a text node by setting its value to the empty string, the text node itself will not be deleted.  
   
-```cs  
+```csharp  
 XElement xmlTree = new XElement("Root", "Content");  
 XText textNode = xmlTree.Nodes().OfType<XText>().First();  
   
@@ -96,7 +96,7 @@ Console.WriteLine(">>{0}<<", textNode2);
 ### An Empty Text Node Impacts Serialization  
  If an element contains only a child text node that is empty, it is serialized with the long tag syntax: `<Child></Child>`. If an element contains no child nodes whatsoever, it is serialized with the short tag syntax: `<Child />`.  
   
-```cs  
+```csharp  
 XElement child1 = new XElement("Child1",  
     new XText("")  
 );  
@@ -117,7 +117,7 @@ Console.WriteLine(child2);
   
  The <xref:System.Xml.Linq.XAttribute.IsNamespaceDeclaration%2A> property indicates whether an attribute is a namespace declaration.  
   
-```cs  
+```csharp  
 XElement root = XElement.Parse(  
 @"<Root  
     xmlns='http://www.adventure-works.com'  
@@ -138,7 +138,7 @@ AnAttribute="abc"  IsNamespaceDeclaration:False
 ### XPath Axis Methods Do Not Return Child White Space of XDocument  
  [!INCLUDE[sqltecxlinq](../../../../csharp/programming-guide/concepts/linq/includes/sqltecxlinq_md.md)] allows for child text nodes of an <xref:System.Xml.Linq.XDocument>, as long as the text nodes contain only white space. However, the XPath object model does not include white space as child nodes of a document, so when you iterate through the children of an <xref:System.Xml.Linq.XDocument> using the <xref:System.Xml.Linq.XContainer.Nodes%2A> axis, white space text nodes will be returned. However, when you iterate through the children of an <xref:System.Xml.Linq.XDocument> using the XPath axis methods, white space text nodes will not be returned.  
   
-```cs  
+```csharp  
 // Create a document with some white space child nodes of the document.  
 XDocument root = XDocument.Parse(  
 @"<?xml version='1.0' encoding='utf-8' standalone='yes'?>  
@@ -165,7 +165,7 @@ Console.WriteLine(((IEnumerable)root.XPathEvaluate("text()")).OfType<XText>().Co
 ### XDeclaration Objects are not Nodes  
  When you iterate through the children nodes of an <xref:System.Xml.Linq.XDocument>, you will not see the XML declaration object. It is a property of the document, not a child node of it.  
   
-```cs  
+```csharp  
 XDocument doc = new XDocument(  
     new XDeclaration("1.0", "utf-8", "yes"),  
     new XElement("Root")  
diff --git a/docs/csharp/programming-guide/concepts/linq/projecting-xml-in-a-different-shape.md b/docs/csharp/programming-guide/concepts/linq/projecting-xml-in-a-different-shape.md
index d9d34db107ee0..be11e7dfe09b6 100644
--- a/docs/csharp/programming-guide/concepts/linq/projecting-xml-in-a-different-shape.md
+++ b/docs/csharp/programming-guide/concepts/linq/projecting-xml-in-a-different-shape.md
@@ -29,7 +29,7 @@ This topic shows an example of projecting XML that is in a different shape than
   
  This example uses classes from the WindowsBase assembly. It uses types in the <xref:System.IO.Packaging?displayProperty=fullName> namespace.  
   
-```cs  
+```csharp  
 public static class LocalExtensions  
 {  
     public static string StringConcatenate(this IEnumerable<string> source)  
diff --git a/docs/csharp/programming-guide/concepts/linq/projection-operations.md b/docs/csharp/programming-guide/concepts/linq/projection-operations.md
index 2197b359c4472..f4c2b3e8d914a 100644
--- a/docs/csharp/programming-guide/concepts/linq/projection-operations.md
+++ b/docs/csharp/programming-guide/concepts/linq/projection-operations.md
@@ -39,7 +39,7 @@ Projection refers to the operation of transforming an object into a new form tha
 ### Select  
  The following example uses the `select` clause to project the first letter from each string in a list of strings.  
   
-```cs  
+```csharp  
 List<string> words = new List<string>() { "an", "apple", "a", "day" };  
   
 var query = from word in words  
@@ -60,7 +60,7 @@ foreach (string s in query)
 ### SelectMany  
  The following example uses multiple `from` clauses  to project each word from each string in a list of strings.  
   
-```cs  
+```csharp  
 List<string> phrases = new List<string>() { "an apple a day", "the quick brown fox" };  
   
 var query = from phrase in phrases  
@@ -99,7 +99,7 @@ foreach (string s in query)
 ### Code Example  
  The following example compares the behavior of `Select()` and `SelectMany()`. The code creates a "bouquet" of flowers by taking the first two items from each list of flower names in the source collection. In this example, the "single value" that the transform function <xref:System.Linq.Enumerable.Select%60%602%28System.Collections.Generic.IEnumerable%7B%60%600%7D%2CSystem.Func%7B%60%600%2C%60%601%7D%29> uses is itself a collection of values. This requires the extra `foreach` loop in order to enumerate each string in each sub-sequence.  
   
-```cs  
+```csharp  
 class Bouquet  
 {  
     public List<string> Flowers { get; set; }  
diff --git a/docs/csharp/programming-guide/concepts/linq/querying-an-xdocument-vs-querying-an-xelement.md b/docs/csharp/programming-guide/concepts/linq/querying-an-xdocument-vs-querying-an-xelement.md
index 8b615a2bd7d35..6965eac2b574b 100644
--- a/docs/csharp/programming-guide/concepts/linq/querying-an-xdocument-vs-querying-an-xelement.md
+++ b/docs/csharp/programming-guide/concepts/linq/querying-an-xdocument-vs-querying-an-xelement.md
@@ -25,7 +25,7 @@ When you load a document via <xref:System.Xml.Linq.XDocument.Load%2A?displayProp
   
  This first example loads an XML tree using <xref:System.Xml.Linq.XElement.Load%2A>. It then queries for the child elements of the root of the tree.  
   
-```cs  
+```csharp  
 // Create a simple document and write it to a file  
 File.WriteAllText("Test.xml", @"<Root>  
     <Child1>1</Child1>  
@@ -55,7 +55,7 @@ Querying tree loaded with XElement.Load
   
  The following example is the same as the one above, with the exception that the XML tree is loaded into an <xref:System.Xml.Linq.XDocument> instead of an <xref:System.Xml.Linq.XElement>.  
   
-```cs  
+```csharp  
 // Create a simple document and write it to a file  
 File.WriteAllText("Test.xml", @"<Root>  
     <Child1>1</Child1>  
@@ -89,7 +89,7 @@ Querying tree loaded with XDocument.Load
   
  One approach to dealing with this is to use the <xref:System.Xml.Linq.XDocument.Root%2A> property before accessing the axes methods, as follows:  
   
-```cs  
+```csharp  
 // Create a simple document and write it to a file  
 File.WriteAllText("Test.xml", @"<Root>  
     <Child1>1</Child1>  
diff --git a/docs/csharp/programming-guide/concepts/linq/refactoring-into-pure-functions.md b/docs/csharp/programming-guide/concepts/linq/refactoring-into-pure-functions.md
index 2118408775760..318ad9036ed09 100644
--- a/docs/csharp/programming-guide/concepts/linq/refactoring-into-pure-functions.md
+++ b/docs/csharp/programming-guide/concepts/linq/refactoring-into-pure-functions.md
@@ -39,7 +39,7 @@ An important aspect of pure functional transformations is learning how to refact
 ### Non-Pure Function that Changes a Class Member  
  In the following code, the `HypenatedConcat` function is not a pure function, because it modifies the `aMember` data member in the class:  
   
-```cs  
+```csharp  
 public class Program  
 {  
     private static string aMember = "StringOne";  
@@ -68,7 +68,7 @@ StringOne-StringTwo
 ### Non-Pure Function that Changes an Argument  
  Furthermore, the following version of this same function is not pure because it modifies the contents of its parameter, `sb`.  
   
-```cs  
+```csharp  
 public class Program  
 {  
     public static void HypenatedConcat(StringBuilder sb, String appendStr)  
@@ -93,7 +93,7 @@ public class Program
 ### Pure Function  
  This next version of the program hows how to implement the `HypenatedConcat` function as a pure function.  
   
-```cs  
+```csharp  
 class Program  
 {  
     public static string HyphenatedConcat(string s, string appendStr)  
diff --git a/docs/csharp/programming-guide/concepts/linq/refactoring-using-a-pure-function.md b/docs/csharp/programming-guide/concepts/linq/refactoring-using-a-pure-function.md
index cdbbd069e444d..764d68d9b7c52 100644
--- a/docs/csharp/programming-guide/concepts/linq/refactoring-using-a-pure-function.md
+++ b/docs/csharp/programming-guide/concepts/linq/refactoring-using-a-pure-function.md
@@ -27,7 +27,7 @@ The following example refactors the previous example, [Refactoring Using an Exte
   
  This example uses classes from the WindowsBase assembly. It uses types in the <xref:System.IO.Packaging?displayProperty=fullName> namespace.  
   
-```cs  
+```csharp  
 public static class LocalExtensions  
 {  
     public static string StringConcatenate(this IEnumerable<string> source)  
diff --git a/docs/csharp/programming-guide/concepts/linq/refactoring-using-an-extension-method.md b/docs/csharp/programming-guide/concepts/linq/refactoring-using-an-extension-method.md
index dea85d3095ae3..a5a008ab88113 100644
--- a/docs/csharp/programming-guide/concepts/linq/refactoring-using-an-extension-method.md
+++ b/docs/csharp/programming-guide/concepts/linq/refactoring-using-an-extension-method.md
@@ -31,7 +31,7 @@ This example builds on the previous example, [Retrieving the Text of the Paragra
   
  This example uses classes from the WindowsBase assembly. It uses types in the <xref:System.IO.Packaging?displayProperty=fullName> namespace.  
   
-```cs  
+```csharp  
 public static class LocalExtensions  
 {  
     public static string StringConcatenate(this IEnumerable<string> source)  
@@ -75,7 +75,7 @@ public static class LocalExtensions
   
  The following code uses all four overloads.  
   
-```cs  
+```csharp  
 string[] numbers = { "one", "two", "three" };  
   
 Console.WriteLine("{0}", numbers.StringConcatenate());  
@@ -98,7 +98,7 @@ one:two:three:
 ## Example  
  Now, the example can be modified to take advantage of the new extension method:  
   
-```cs  
+```csharp  
 public static class LocalExtensions  
 {  
     public static string StringConcatenate(this IEnumerable<string> source)  
diff --git a/docs/csharp/programming-guide/concepts/linq/removing-elements-attributes-and-nodes-from-an-xml-tree.md b/docs/csharp/programming-guide/concepts/linq/removing-elements-attributes-and-nodes-from-an-xml-tree.md
index 41209f50e422a..82231e831f433 100644
--- a/docs/csharp/programming-guide/concepts/linq/removing-elements-attributes-and-nodes-from-an-xml-tree.md
+++ b/docs/csharp/programming-guide/concepts/linq/removing-elements-attributes-and-nodes-from-an-xml-tree.md
@@ -46,7 +46,7 @@ You can modify an XML tree, removing elements, attributes, and other types of no
   
 ### Code  
   
-```cs  
+```csharp  
 XElement root = XElement.Parse(@"<Root>  
     <Child1>  
         <GrandChild1/>  
diff --git a/docs/csharp/programming-guide/concepts/linq/retrieving-the-paragraphs-and-their-styles.md b/docs/csharp/programming-guide/concepts/linq/retrieving-the-paragraphs-and-their-styles.md
index c468437839788..04cebbb28d429 100644
--- a/docs/csharp/programming-guide/concepts/linq/retrieving-the-paragraphs-and-their-styles.md
+++ b/docs/csharp/programming-guide/concepts/linq/retrieving-the-paragraphs-and-their-styles.md
@@ -27,7 +27,7 @@ In this example, we write a query that retrieves the paragraph nodes from a Word
 ## Example  
  The source of the query to retrieve all the paragraphs in a document and their styles is as follows:  
   
-```cs  
+```csharp  
 xDoc.Root.Element(w + "body").Descendants(w + "p")  
 ```  
   
@@ -36,7 +36,7 @@ xDoc.Root.Element(w + "body").Descendants(w + "p")
 ## Example  
  The query uses a `let` clause to determine the element that contains the style node. If there is no element, then `styleNode` is set to `null`:  
   
-```cs  
+```csharp  
 let styleNode = para.Elements(w + "pPr").Elements(w + "pStyle").FirstOrDefault()  
 ```  
   
@@ -51,7 +51,7 @@ let styleNode = para.Elements(w + "pPr").Elements(w + "pStyle").FirstOrDefault()
   
  This example uses classes found in the WindowsBase assembly. It uses types in the <xref:System.IO.Packaging?displayProperty=fullName> namespace.  
   
-```cs  
+```csharp  
 const string fileName = "SampleDoc.docx";  
   
 const string documentRelationshipType = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument";  
diff --git a/docs/csharp/programming-guide/concepts/linq/retrieving-the-text-of-the-paragraphs.md b/docs/csharp/programming-guide/concepts/linq/retrieving-the-text-of-the-paragraphs.md
index fc0dde47828ad..95c30fc429a30 100644
--- a/docs/csharp/programming-guide/concepts/linq/retrieving-the-text-of-the-paragraphs.md
+++ b/docs/csharp/programming-guide/concepts/linq/retrieving-the-text-of-the-paragraphs.md
@@ -35,7 +35,7 @@ This example builds on the previous example, [Retrieving the Paragraphs and Thei
   
  This example uses classes from the WindowsBase assembly. It uses types in the <xref:System.IO.Packaging?displayProperty=fullName> namespace.  
   
-```cs  
+```csharp  
 const string fileName = "SampleDoc.docx";  
   
 const string documentRelationshipType =  
diff --git a/docs/csharp/programming-guide/concepts/linq/scope-of-default-namespaces.md b/docs/csharp/programming-guide/concepts/linq/scope-of-default-namespaces.md
index a8dadf15c16e8..94d365488625f 100644
--- a/docs/csharp/programming-guide/concepts/linq/scope-of-default-namespaces.md
+++ b/docs/csharp/programming-guide/concepts/linq/scope-of-default-namespaces.md
@@ -36,7 +36,7 @@ Default namespaces as represented in the XML tree are not in scope for queries.
   
 ### Code  
   
-```cs  
+```csharp  
 XElement root = XElement.Parse(  
 @"<Root xmlns='http://www.adventure-works.com'>  
     <Child>1</Child>  
@@ -70,7 +70,7 @@ End of result set
   
 ### Code  
   
-```cs  
+```csharp  
 XElement root = XElement.Parse(  
 @"<Root xmlns='http://www.adventure-works.com'>  
     <Child>1</Child>  
diff --git a/docs/csharp/programming-guide/concepts/linq/serializing-to-an-xmlreader-invoking-xslt.md b/docs/csharp/programming-guide/concepts/linq/serializing-to-an-xmlreader-invoking-xslt.md
index bf2f95dc7e7af..4f71413b0e444 100644
--- a/docs/csharp/programming-guide/concepts/linq/serializing-to-an-xmlreader-invoking-xslt.md
+++ b/docs/csharp/programming-guide/concepts/linq/serializing-to-an-xmlreader-invoking-xslt.md
@@ -28,7 +28,7 @@ When you use the <xref:System.Xml?displayProperty=fullName> interoperability cap
 ## Invoking an XSLT Transformation  
  One possible use for this method is when invoking an XSLT transformation. You can create an XML tree, create an <xref:System.Xml.XmlReader> from the XML tree, create a new document, and then create an <xref:System.Xml.XmlWriter> to write into the new document. Then, you can invoke the XSLT transformation, passing in <xref:System.Xml.XmlReader> and <xref:System.Xml.XmlWriter>. After the transformation successfully completes, the new XML tree is populated with the results of the transformation.  
   
-```cs  
+```csharp  
 string xslMarkup = @"<?xml version='1.0'?>  
 <xsl:stylesheet xmlns:xsl='http://www.w3.org/1999/XSL/Transform' version='1.0'>  
     <xsl:template match='/Parent'>  
diff --git a/docs/csharp/programming-guide/concepts/linq/serializing-with-an-xml-declaration.md b/docs/csharp/programming-guide/concepts/linq/serializing-with-an-xml-declaration.md
index 2d6b2bd26a997..9f90f35b2fd44 100644
--- a/docs/csharp/programming-guide/concepts/linq/serializing-with-an-xml-declaration.md
+++ b/docs/csharp/programming-guide/concepts/linq/serializing-with-an-xml-declaration.md
@@ -33,7 +33,7 @@ This topic describes how to control whether serialization generates an XML decla
 ### Serializing with an XML Declaration  
  The following example creates an <xref:System.Xml.Linq.XElement>, saves the document to a file, and then prints the file to the console:  
   
-```cs  
+```csharp  
 XElement root = new XElement("Root",  
     new XElement("Child", "child content")  
 );  
@@ -54,7 +54,7 @@ Console.WriteLine(str);
 ### Serializing without an XML Declaration  
  The following example shows how to save an <xref:System.Xml.Linq.XElement> to an <xref:System.Xml.XmlWriter>.  
   
-```cs  
+```csharp  
 StringBuilder sb = new StringBuilder();  
 XmlWriterSettings xws = new XmlWriterSettings();  
 xws.OmitXmlDeclaration = true;  
diff --git a/docs/csharp/programming-guide/concepts/linq/shape-of-wordprocessingml-documents.md b/docs/csharp/programming-guide/concepts/linq/shape-of-wordprocessingml-documents.md
index 8b3551746a31d..491a9a6df11dc 100644
--- a/docs/csharp/programming-guide/concepts/linq/shape-of-wordprocessingml-documents.md
+++ b/docs/csharp/programming-guide/concepts/linq/shape-of-wordprocessingml-documents.md
@@ -65,7 +65,7 @@ xmlns:wne="http://schemas.microsoft.com/office/word/2006/wordml">
   
  This example uses classes found in the WindowsBase assembly. It uses types in the <xref:System.IO.Packaging?displayProperty=fullName> namespace.  
   
-```cs  
+```csharp  
 const string documentRelationshipType =  
   "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument";  
 const string wordmlNamespace =  
diff --git a/docs/csharp/programming-guide/concepts/linq/sorting-data.md b/docs/csharp/programming-guide/concepts/linq/sorting-data.md
index 987c89eb463ed..e3c6628cfd29c 100644
--- a/docs/csharp/programming-guide/concepts/linq/sorting-data.md
+++ b/docs/csharp/programming-guide/concepts/linq/sorting-data.md
@@ -48,7 +48,7 @@ A sorting operation orders the elements of a sequence based on one or more attri
 #### Primary Ascending Sort  
  The following example demonstrates how to use the `orderby` clause in a LINQ query to sort the strings in an array by string length, in ascending order.  
   
-```cs  
+```csharp  
 string[] words = { "the", "quick", "brown", "fox", "jumps" };  
   
 IEnumerable<string> query = from word in words  
@@ -71,7 +71,7 @@ foreach (string str in query)
 #### Primary Descending Sort  
  The next example demonstrates how to use the `orderby``descending` clause in a LINQ query to sort the strings by their first letter, in descending order.  
   
-```cs  
+```csharp  
 string[] words = { "the", "quick", "brown", "fox", "jumps" };  
   
 IEnumerable<string> query = from word in words  
@@ -96,7 +96,7 @@ foreach (string str in query)
 #### Secondary Ascending Sort  
  The following example demonstrates how to use the `orderby` clause in a LINQ query to perform a primary and secondary sort of the strings in an array. The strings are sorted primarily by length and secondarily by the first letter of the string, both in ascending order.  
   
-```cs  
+```csharp  
 string[] words = { "the", "quick", "brown", "fox", "jumps" };  
   
 IEnumerable<string> query = from word in words  
@@ -119,7 +119,7 @@ foreach (string str in query)
 #### Secondary Descending Sort  
  The next example demonstrates how to use the `orderby``descending` clause in a LINQ query to perform a primary sort, in ascending order, and a secondary sort, in descending order. The strings are sorted primarily by length and secondarily by the first letter of the string.  
   
-```cs  
+```csharp  
 string[] words = { "the", "quick", "brown", "fox", "jumps" };  
   
 IEnumerable<string> query = from word in words  
diff --git a/docs/csharp/programming-guide/concepts/linq/standard-query-operators-overview.md b/docs/csharp/programming-guide/concepts/linq/standard-query-operators-overview.md
index 65629353abfe9..5d15964eeeb4d 100644
--- a/docs/csharp/programming-guide/concepts/linq/standard-query-operators-overview.md
+++ b/docs/csharp/programming-guide/concepts/linq/standard-query-operators-overview.md
@@ -39,7 +39,7 @@ The *standard query operators* are the methods that form the LINQ pattern. Most
   
  The following code example demonstrates how the standard query operators can be used to obtain information about a sequence.  
   
-```cs  
+```csharp  
 string sentence = "the quick brown fox jumps over the lazy dog";  
 // Split the string into individual words to create a collection.  
 string[] words = sentence.Split(' ');  
diff --git a/docs/csharp/programming-guide/concepts/linq/statically-compiled-queries-linq-to-xml.md b/docs/csharp/programming-guide/concepts/linq/statically-compiled-queries-linq-to-xml.md
index ee7976488651c..4b641b2ab9eb4 100644
--- a/docs/csharp/programming-guide/concepts/linq/statically-compiled-queries-linq-to-xml.md
+++ b/docs/csharp/programming-guide/concepts/linq/statically-compiled-queries-linq-to-xml.md
@@ -29,7 +29,7 @@ One of the most important performance benefits LINQ to XML, as opposed to <xref:
 //Address[@Type='Shipping']  
 ```  
   
-```cs  
+```csharp  
 XDocument po = XDocument.Load("PurchaseOrders.xml");  
   
 IEnumerable<XElement> list1 =  
@@ -43,7 +43,7 @@ foreach (XElement el in list1)
   
  The query expression in this example is re-written by the compiler to method-based query syntax. The following example, which is written in method-based query syntax, produces the same results as the previous one:  
   
-```cs  
+```csharp  
 XDocument po = XDocument.Load("PurchaseOrders.xml");  
   
 IEnumerable<XElement> list1 =  
@@ -57,7 +57,7 @@ foreach (XElement el in list1)
   
  The <xref:System.Linq.Enumerable.Where%2A> method is an extension method. For more information, see [Extension Methods](../../../../csharp/programming-guide/classes-and-structs/extension-methods.md). Because <xref:System.Linq.Enumerable.Where%2A> is an extension method, the query above is compiled as though it were written as follows:  
   
-```cs  
+```csharp  
 XDocument po = XDocument.Load("PurchaseOrders.xml");  
   
 IEnumerable<XElement> list1 =  
@@ -77,7 +77,7 @@ foreach (XElement el in list1)
 ## Executing XPath Expressions with XmlDocument  
  The following example uses <xref:System.Xml.XmlDocument> to accomplish the same results as the previous examples:  
   
-```cs  
+```csharp  
 XmlReader reader = XmlReader.Create("PurchaseOrders.xml");  
 XmlDocument doc = new XmlDocument();  
 doc.Load(reader);  
diff --git a/docs/csharp/programming-guide/concepts/linq/using-xslt-to-transform-an-xml-tree.md b/docs/csharp/programming-guide/concepts/linq/using-xslt-to-transform-an-xml-tree.md
index 3eeb260114583..c36ea4284a48b 100644
--- a/docs/csharp/programming-guide/concepts/linq/using-xslt-to-transform-an-xml-tree.md
+++ b/docs/csharp/programming-guide/concepts/linq/using-xslt-to-transform-an-xml-tree.md
@@ -27,7 +27,7 @@ You can create an XML tree, create an <xref:System.Xml.XmlReader> from the XML t
   
 ## Example  
   
-```cs  
+```csharp  
 string xslMarkup = @"<?xml version='1.0'?>  
 <xsl:stylesheet xmlns:xsl='http://www.w3.org/1999/XSL/Transform' version='1.0'>  
     <xsl:template match='/Parent'>  
diff --git a/docs/csharp/programming-guide/concepts/linq/xattribute-class-overview.md b/docs/csharp/programming-guide/concepts/linq/xattribute-class-overview.md
index 9f976253473ae..fb02f0684b527 100644
--- a/docs/csharp/programming-guide/concepts/linq/xattribute-class-overview.md
+++ b/docs/csharp/programming-guide/concepts/linq/xattribute-class-overview.md
@@ -40,7 +40,7 @@ Attributes are name/value pairs that are associated with an element. The <xref:S
 ### Creating an Element with an Attribute  
  The following code shows the common task of creating an element that contains an attribute:  
   
-```cs  
+```csharp  
 XElement phone = new XElement("Phone",  
     new XAttribute("Type", "Home"),  
     "555-555-5555");  
@@ -56,7 +56,7 @@ Console.WriteLine(phone);
 ### Functional Construction of Attributes  
  You can construct <xref:System.Xml.Linq.XAttribute> objects in-line with the construction of <xref:System.Xml.Linq.XElement> objects, as follows:  
   
-```cs  
+```csharp  
 XElement c = new XElement("Customers",  
     new XElement("Customer",  
         new XElement("Name", "John Doe"),  
diff --git a/docs/csharp/programming-guide/concepts/linq/xdocument-class-overview.md b/docs/csharp/programming-guide/concepts/linq/xdocument-class-overview.md
index 328841a49a89e..356f83656ba06 100644
--- a/docs/csharp/programming-guide/concepts/linq/xdocument-class-overview.md
+++ b/docs/csharp/programming-guide/concepts/linq/xdocument-class-overview.md
@@ -57,7 +57,7 @@ This topic introduces the <xref:System.Xml.Linq.XDocument> class.
   
  The following code creates an <xref:System.Xml.Linq.XDocument> object and its associated contained objects.  
   
-```cs  
+```csharp  
 XDocument d = new XDocument(  
     new XComment("This is a comment."),  
     new XProcessingInstruction("xml-stylesheet",  
diff --git a/docs/csharp/programming-guide/concepts/linq/xelement-class-overview.md b/docs/csharp/programming-guide/concepts/linq/xelement-class-overview.md
index 05ef78be66e91..63aaeca5bebde 100644
--- a/docs/csharp/programming-guide/concepts/linq/xelement-class-overview.md
+++ b/docs/csharp/programming-guide/concepts/linq/xelement-class-overview.md
@@ -41,7 +41,7 @@ The <xref:System.Xml.Linq.XElement> class is one of the fundamental classes in [
   
  However, the most common way to create an XML tree is as follows:  
   
-```cs  
+```csharp  
 XElement contacts =  
     new XElement("Contacts",  
         new XElement("Contact",  
@@ -59,7 +59,7 @@ XElement contacts =
   
  Another very common technique for creating an XML tree involves using the results of a [!INCLUDE[vbteclinq](../../../../csharp/includes/vbteclinq_md.md)] query to populate an XML tree, as shown in the following example:  
   
-```cs  
+```csharp  
 XElement srcTree = new XElement("Root",  
     new XElement("Element", 1),  
     new XElement("Element", 2),  
diff --git a/docs/csharp/programming-guide/concepts/object-oriented-programming.md b/docs/csharp/programming-guide/concepts/object-oriented-programming.md
index f8346d549cebe..e2349122c4417 100644
--- a/docs/csharp/programming-guide/concepts/object-oriented-programming.md
+++ b/docs/csharp/programming-guide/concepts/object-oriented-programming.md
@@ -72,7 +72,7 @@ C# provides full support for object-oriented programming including encapsulation
   
  To define a class:  
   
-```cs  
+```csharp  
 class SampleClass  
 {  
 }  
@@ -82,7 +82,7 @@ class SampleClass
   
  To define a structure:  
   
-```cs  
+```csharp  
 struct SampleStruct  
 {  
 }  
@@ -102,7 +102,7 @@ struct SampleStruct
   
  To define a field:  
   
-```cs  
+```csharp  
 Class SampleClass  
 {  
     public string sampleField;  
@@ -115,7 +115,7 @@ Class SampleClass
   
  To define an auto-implemented property:  
   
-```cs  
+```csharp  
 class SampleClass  
 {  
     public int SampleProperty { get; set; }  
@@ -124,7 +124,7 @@ class SampleClass
   
  If you need to perform some additional operations for reading and writing the property value, define a field for storing the property value and provide the basic logic for storing and retrieving it:  
   
-```cs  
+```csharp  
 class SampleClass  
 {  
     private int _sample;  
@@ -151,7 +151,7 @@ class SampleClass
   
  To define a method of a class:  
   
-```cs  
+```csharp  
 class SampleClass  
 {  
     public int sampleMethod(string sampleParam)  
@@ -165,7 +165,7 @@ class SampleClass
   
  To overload a method:  
   
-```cs  
+```csharp  
 public int sampleMethod(string sampleParam) {};  
 public int sampleMethod(int sampleParam) {}  
 ```  
@@ -183,7 +183,7 @@ public int sampleMethod(int sampleParam) {}
   
  To define a constructor for a class:  
   
-```cs  
+```csharp  
 public class SampleClass  
 {  
     public SampleClass()  
@@ -214,7 +214,7 @@ public class SampleClass
 ####  <a name="NestedClasses"></a> Nested Classes  
  A class defined within another class is called *nested*. By default, the nested class is private.  
   
-```cs  
+```csharp  
 class Container  
 {  
     class Nested  
@@ -226,7 +226,7 @@ class Container
   
  To create an instance of the nested class, use the name of the container class followed by the dot and then followed by the name of the nested class:  
   
-```cs  
+```csharp  
 Container.Nested nestedInstance = new Container.Nested()  
 ```  
   
@@ -248,13 +248,13 @@ Container.Nested nestedInstance = new Container.Nested()
 ###  <a name="InstantiatingClasses"></a> Instantiating Classes  
  To create an object, you need to instantiate a class, or create a class instance.  
   
-```cs  
+```csharp  
 SampleClass sampleObject = new SampleClass();  
 ```  
   
  After instantiating a class, you can assign values to the instance's properties and fields and invoke class methods.  
   
-```cs  
+```csharp  
 // Set a property value.  
 sampleObject.sampleProperty = "Sample String";  
 // Call a method.  
@@ -263,7 +263,7 @@ sampleObject.sampleMethod();
   
  To assign values to properties during the class instantiation process, use object initializers:  
   
-```cs  
+```csharp  
 // Set a property value.  
 SampleClass sampleObject = new SampleClass   
     { FirstProperty = "A", SecondProperty = "B" };  
@@ -280,7 +280,7 @@ SampleClass sampleObject = new SampleClass
   
  To define a static member:  
   
-```cs  
+```csharp  
 static class SampleClass  
 {  
     public static string SampleString = "Sample String";  
@@ -289,7 +289,7 @@ static class SampleClass
   
  To access the static member, use the name of the class without creating an object of this class:  
   
-```cs  
+```csharp  
 Console.WriteLine(SampleClass.SampleString);  
 ```  
   
@@ -302,7 +302,7 @@ Console.WriteLine(SampleClass.SampleString);
   
  To create an instance of an anonymous type:  
   
-```cs  
+```csharp  
 // sampleObject is an instance of a simple anonymous type.  
 var sampleObject =   
     new { FirstProperty = "A", SecondProperty = "B" };  
@@ -318,7 +318,7 @@ var sampleObject =
   
  To inherit from a base class:  
   
-```cs  
+```csharp  
 class DerivedClass:BaseClass{}  
 ```  
   
@@ -326,13 +326,13 @@ class DerivedClass:BaseClass{}
   
  To specify that a class cannot be used as a base class:  
   
-```cs  
+```csharp  
 public sealed class A { }  
 ```  
   
  To specify that a class can be used as a base class only and cannot be instantiated:  
   
-```cs  
+```csharp  
 public abstract class B { }  
 ```  
   
@@ -359,7 +359,7 @@ public abstract class B { }
   
  To define an interface:  
   
-```cs  
+```csharp  
 interface ISampleInterface  
 {  
     void doSomething();  
@@ -368,7 +368,7 @@ interface ISampleInterface
   
  To implement an interface in a class:  
   
-```cs  
+```csharp  
 class SampleClass : ISampleInterface  
 {  
     void ISampleInterface.doSomething()  
@@ -389,7 +389,7 @@ class SampleClass : ISampleInterface
   
  To define a generic class:  
   
-```cs  
+```csharp  
 Public class SampleGeneric<T>   
 {  
     public T Field;  
@@ -398,7 +398,7 @@ Public class SampleGeneric<T>
   
  To create an instance of a generic class:  
   
-```cs  
+```csharp  
 SampleGeneric<string> sampleObject = new SampleGeneric<string>();  
 sampleObject.Field = "Sample string";  
 ```  
@@ -417,13 +417,13 @@ sampleObject.Field = "Sample string";
   
  To create a delegate:  
   
-```cs  
+```csharp  
 public delegate void SampleDelegate(string str);  
 ```  
   
  To create a reference to a method that matches the signature specified by the delegate:  
   
-```cs  
+```csharp  
 class SampleClass  
 {  
     // Method that matches the SampleDelegate signature.  
diff --git a/docs/csharp/programming-guide/concepts/reflection.md b/docs/csharp/programming-guide/concepts/reflection.md
index 92bb2add5fba3..39ae5c7a6debe 100644
--- a/docs/csharp/programming-guide/concepts/reflection.md
+++ b/docs/csharp/programming-guide/concepts/reflection.md
@@ -27,7 +27,7 @@ Reflection provides objects (of type <xref:System.Type>) that describe assemblie
   
  Here's a simple example of reflection using the static method `GetType` - inherited by all types from the `Object` base class - to obtain the type of a variable:  
   
-```cs  
+```csharp  
 // Using GetType to obtain type information:  
 int i = 42;  
 System.Type type = i.GetType();  
@@ -40,7 +40,7 @@ System.Console.WriteLine(type);
   
  The following example uses reflection to obtain the full name of the loaded assembly.  
   
-```cs  
+```csharp  
 // Using Reflection to get information from an Assembly:  
 System.Reflection.Assembly info = typeof(System.Int32).Assembly;  
 System.Console.WriteLine(info);  
diff --git a/docs/csharp/programming-guide/concepts/serialization/how-to-read-object-data-from-an-xml-file.md b/docs/csharp/programming-guide/concepts/serialization/how-to-read-object-data-from-an-xml-file.md
index a4289ff8d4d15..a42588daa856f 100644
--- a/docs/csharp/programming-guide/concepts/serialization/how-to-read-object-data-from-an-xml-file.md
+++ b/docs/csharp/programming-guide/concepts/serialization/how-to-read-object-data-from-an-xml-file.md
@@ -27,7 +27,7 @@ This example reads object data that was previously written to an XML file using
   
 ## Example  
   
-```cs  
+```csharp  
 public class Book  
 {  
     public String title;  
diff --git a/docs/csharp/programming-guide/concepts/serialization/how-to-write-object-data-to-an-xml-file.md b/docs/csharp/programming-guide/concepts/serialization/how-to-write-object-data-to-an-xml-file.md
index 8d0d83000f7ff..e36b560635305 100644
--- a/docs/csharp/programming-guide/concepts/serialization/how-to-write-object-data-to-an-xml-file.md
+++ b/docs/csharp/programming-guide/concepts/serialization/how-to-write-object-data-to-an-xml-file.md
@@ -27,7 +27,7 @@ TThis example writes the object from a class to an XML file using the <xref:Syst
   
 ## Example  
   
-```cs  
+```csharp  
 public class XMLWrite  
 {  
   
diff --git a/docs/csharp/programming-guide/concepts/serialization/walkthrough-persisting-an-object-in-visual-studio.md b/docs/csharp/programming-guide/concepts/serialization/walkthrough-persisting-an-object-in-visual-studio.md
index 36aec8c1cffa8..4e42085976623 100644
--- a/docs/csharp/programming-guide/concepts/serialization/walkthrough-persisting-an-object-in-visual-studio.md
+++ b/docs/csharp/programming-guide/concepts/serialization/walkthrough-persisting-an-object-in-visual-studio.md
@@ -47,7 +47,7 @@ Although you can set an object's properties to default values at design time, an
   
 3.  Add the following public members to the class:  
   
-    ```cs  
+    ```csharp  
     public class Loan : System.ComponentModel.INotifyPropertyChanged  
     {  
         public double LoanAmount {get; set;}  
@@ -103,7 +103,7 @@ Although you can set an object's properties to default values at design time, an
   
 9. In the Code Editor, add the following code:  
   
-    ```cs  
+    ```csharp  
     private LoanClass.Loan TestLoan = new LoanClass.Loan(10000.0, 0.075, 36, "Neil Black");  
   
     private void Form1_Load(object sender, EventArgs e)  
@@ -117,7 +117,7 @@ Although you can set an object's properties to default values at design time, an
   
 10. Add an event handler for the `PropertyChanged` event to the form by using the following code:  
   
-    ```cs  
+    ```csharp  
     private void CustomerPropertyChanged(object sender,   
         System.ComponentModel.PropertyChangedEventArgs e)  
     {  
@@ -136,7 +136,7 @@ Although you can set an object's properties to default values at design time, an
   
 -   Change the class declaration for the Loan class as follows:  
   
-    ```cs  
+    ```csharp  
     [Serializable()]  
     public class Loan : System.ComponentModel.INotifyPropertyChanged  
     {  
@@ -148,7 +148,7 @@ Although you can set an object's properties to default values at design time, an
   
 -   Change the declaration for the `PropertyChanged` event as follows:  
   
-    ```cs  
+    ```csharp  
     [field: NonSerialized()]  
     public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;  
     ```  
@@ -159,7 +159,7 @@ Although you can set an object's properties to default values at design time, an
   
 -   Add the following statements to the top of the `Form1` class:  
   
-    ```cs  
+    ```csharp  
     using System.IO;  
     using System.Runtime.Serialization.Formatters.Binary;  
     ```  
@@ -172,13 +172,13 @@ Although you can set an object's properties to default values at design time, an
   
 1.  Add a constant to the class for the serialized data's file name.  
   
-    ```cs  
+    ```csharp  
     const string FileName = @"..\..\SavedLoan.bin";  
     ```  
   
 2.  Modify the code in the `Form1_Load` event procedure as follows:  
   
-    ```cs  
+    ```csharp  
     private LoanClass.Loan TestLoan = new LoanClass.Loan(10000.0, 0.075, 36, "Neil Black");  
   
     private void Form1_Load(object sender, EventArgs e)  
@@ -208,7 +208,7 @@ Although you can set an object's properties to default values at design time, an
   
 -   Add the following code to the `Form1_FormClosing` event procedure:  
   
-    ```cs  
+    ```csharp  
     private void Form1_FormClosing(object sender, FormClosingEventArgs e)  
     {  
         TestLoan.LoanAmount = Convert.ToDouble(textBox1.Text);  
diff --git a/docs/csharp/programming-guide/concepts/threading/how-to-use-a-thread-pool.md b/docs/csharp/programming-guide/concepts/threading/how-to-use-a-thread-pool.md
index 068953d710108..3df67775aa44a 100644
--- a/docs/csharp/programming-guide/concepts/threading/how-to-use-a-thread-pool.md
+++ b/docs/csharp/programming-guide/concepts/threading/how-to-use-a-thread-pool.md
@@ -31,7 +31,7 @@ translation.priority.mt:
   
 ## Example  
   
-```cs  
+```csharp  
 using System;  
 using System.Threading;  
   
diff --git a/docs/csharp/programming-guide/concepts/threading/multithreaded-applications.md b/docs/csharp/programming-guide/concepts/threading/multithreaded-applications.md
index 990e59deef3a1..2d45615249548 100644
--- a/docs/csharp/programming-guide/concepts/threading/multithreaded-applications.md
+++ b/docs/csharp/programming-guide/concepts/threading/multithreaded-applications.md
@@ -32,7 +32,7 @@ With C#, you can write applications that perform multiple tasks at the same time
   
  You create a new thread by declaring a variable of type <xref:System.Threading.Thread> and calling the constructor, providing the name of the procedure or method that you want to execute on the new thread. The following code provides an example.  
   
-```cs  
+```csharp  
 System.Threading.Thread newThread =  
     new System.Threading.Thread(AMethod);  
 ```  
@@ -40,13 +40,13 @@ System.Threading.Thread newThread =
 ### Starting and Stopping Threads  
  To start the execution of a new thread, use the <xref:System.Threading.Thread.Start%2A> method, as shown in the following code.  
   
-```cs  
+```csharp  
 newThread.Start();  
 ```  
   
  To stop the execution of a thread, use the <xref:System.Threading.Thread.Abort%2A> method, as shown in the following code.  
   
-```cs  
+```csharp  
 newThread.Abort();  
 ```  
   
diff --git a/docs/csharp/programming-guide/concepts/threading/parameters-and-return-values-for-multithreaded-procedures.md b/docs/csharp/programming-guide/concepts/threading/parameters-and-return-values-for-multithreaded-procedures.md
index e45a51daf2eac..6ae112de94df9 100644
--- a/docs/csharp/programming-guide/concepts/threading/parameters-and-return-values-for-multithreaded-procedures.md
+++ b/docs/csharp/programming-guide/concepts/threading/parameters-and-return-values-for-multithreaded-procedures.md
@@ -28,7 +28,7 @@ Supplying and returning values in a multithreaded application is complicated bec
 ## Supplying Parameters for Multithreaded Procedures  
  The best way to supply parameters for a multithreaded method call is to wrap the target method in a class and define fields for that class that will serve as parameters for the new thread. The advantage of this approach is that you can create a new instance of the class, with its own parameters, every time you want to start a new thread. For example, suppose you have a function that calculates the area of a triangle, as in the following code:  
   
-```cs  
+```csharp  
 double CalcArea(double Base, double Height)  
 {  
     return 0.5 * Base * Height;  
@@ -37,7 +37,7 @@ double CalcArea(double Base, double Height)
   
  You can write a class that wraps the `CalcArea` function and creates fields to store input parameters, as follows:  
   
-```cs  
+```csharp  
 class AreaClass  
 {  
     public double Base;  
@@ -53,7 +53,7 @@ class AreaClass
   
  To use the `AreaClass`, you can create an `AreaClass` object, and set the `Base` and `Height` properties as shown in the following code:  
   
-```cs  
+```csharp  
 protected void TestArea()  
 {  
     AreaClass AreaObject = new AreaClass();  
@@ -73,7 +73,7 @@ protected void TestArea()
   
  The following example returns a value by raising an event from a procedure running on a separate thread:  
   
-```cs  
+```csharp  
 class AreaClass2  
 {  
     public double Base;  
diff --git a/docs/csharp/programming-guide/concepts/threading/thread-pooling.md b/docs/csharp/programming-guide/concepts/threading/thread-pooling.md
index 0efb57cbc6211..a37b9ee3dcd5d 100644
--- a/docs/csharp/programming-guide/concepts/threading/thread-pooling.md
+++ b/docs/csharp/programming-guide/concepts/threading/thread-pooling.md
@@ -38,7 +38,7 @@ A *thread pool* is a collection of threads that can be used to perform several t
 ## Thread Pooling Example  
  The following example shows how you can use thread pooling to start several tasks.  
   
-```cs  
+```csharp  
 public void DoWork()  
 {  
     // Queue a task.  
diff --git a/docs/csharp/programming-guide/concepts/threading/thread-synchronization.md b/docs/csharp/programming-guide/concepts/threading/thread-synchronization.md
index 70147235cd6d1..4823238abecf3 100644
--- a/docs/csharp/programming-guide/concepts/threading/thread-synchronization.md
+++ b/docs/csharp/programming-guide/concepts/threading/thread-synchronization.md
@@ -44,7 +44,7 @@ The following sections describe features and classes that can be used to synchro
   
  A `lock` statement is given an object as an argument, and is followed by a code block that is to be executed by only one thread at a time. For example:  
   
-```cs  
+```csharp  
 public class TestThreading  
 {  
     private System.Object lockThis = new System.Object();  
@@ -74,7 +74,7 @@ public class TestThreading
 ## Monitors  
  Like the `lock` keyword, monitors prevent blocks of code from simultaneous execution by multiple threads. The <xref:System.Threading.Monitor.Enter%2A> method allows one and only one thread to proceed into the following statements; all other threads are blocked until the executing thread calls <xref:System.Threading.Monitor.Exit%2A>. This is just like using the `lock` keyword. For example:  
   
-```cs  
+```csharp  
 lock (x)  
 {  
     DoSomething();  
@@ -83,7 +83,7 @@ lock (x)
   
  This is equivalent to:  
   
-```cs  
+```csharp  
 System.Object obj = (System.Object)x;  
 System.Threading.Monitor.Enter(obj);  
 try  
@@ -107,7 +107,7 @@ finally
   
  In the following example, a thread is created and started by the `Main` function. The new thread waits on an event using the <xref:System.Threading.WaitHandle.WaitOne%2A> method. The thread is suspended until the event becomes signaled by the primary thread that is executing the `Main` function. Once the event becomes signaled, the auxiliary thread returns. In this case, because the event is only used for one thread activation, either the <xref:System.Threading.AutoResetEvent> or <xref:System.Threading.ManualResetEvent> classes could be used.  
   
-```cs  
+```csharp  
 using System;  
 using System.Threading;  
   
diff --git a/docs/csharp/programming-guide/concepts/threading/thread-timers.md b/docs/csharp/programming-guide/concepts/threading/thread-timers.md
index 81fb7aae813f4..06a9f603f4326 100644
--- a/docs/csharp/programming-guide/concepts/threading/thread-timers.md
+++ b/docs/csharp/programming-guide/concepts/threading/thread-timers.md
@@ -28,7 +28,7 @@ The <xref:System.Threading.Timer?displayProperty=fullName> class is useful for p
 ## Thread Timer Example  
  The following example starts a task every two seconds and uses a flag to initiate the <xref:System.IDisposable.Dispose%2A> method that stops the timer. This example posts status to the output window.  
   
-```cs  
+```csharp  
 private class StateObjClass  
 {  
     // Used to hold parameters for calls to TimerTask.  
diff --git a/docs/csharp/programming-guide/concepts/threading/walkthrough-multithreading-with-the-backgroundworker-component.md b/docs/csharp/programming-guide/concepts/threading/walkthrough-multithreading-with-the-backgroundworker-component.md
index 5e4293711f629..5f1e4a91869b1 100644
--- a/docs/csharp/programming-guide/concepts/threading/walkthrough-multithreading-with-the-backgroundworker-component.md
+++ b/docs/csharp/programming-guide/concepts/threading/walkthrough-multithreading-with-the-backgroundworker-component.md
@@ -82,7 +82,7 @@ This walkthrough demonstrates how to create a multithreaded Windows Forms applic
   
 4.  Add the following code to the `Words` class:  
   
-    ```cs  
+    ```csharp  
     public class Words  
     {  
         // Object to store the current state, for passing to the caller.  
@@ -185,7 +185,7 @@ This walkthrough demonstrates how to create a multithreaded Windows Forms applic
   
 -   Add the following event handlers to your main form:  
   
-    ```cs  
+    ```csharp  
     private void backgroundWorker1_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)  
     {  
     // This event handler is called when the background thread finishes.  
@@ -212,7 +212,7 @@ This walkthrough demonstrates how to create a multithreaded Windows Forms applic
   
 1.  Add the following procedures to your program:  
   
-    ```cs  
+    ```csharp  
     private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)  
     {  
         // This event handler is where the actual work is done.  
@@ -244,7 +244,7 @@ This walkthrough demonstrates how to create a multithreaded Windows Forms applic
   
 2.  Call the `StartThread` method from the `Start` button on your form:  
   
-    ```cs  
+    ```csharp  
     private void Start_Click(object sender, EventArgs e)  
     {  
         StartThread();  
@@ -255,7 +255,7 @@ This walkthrough demonstrates how to create a multithreaded Windows Forms applic
   
     -   Call the `StopThread` procedure from the `Click` event handler for the `Cancel` button.  
   
-        ```cs  
+        ```csharp  
         private void Cancel_Click(object sender, EventArgs e)  
         {  
             // Cancel the asynchronous operation.  
diff --git a/docs/csharp/programming-guide/enumeration-types.md b/docs/csharp/programming-guide/enumeration-types.md
index 9c965f7a1e532..17f67080e20fc 100644
--- a/docs/csharp/programming-guide/enumeration-types.md
+++ b/docs/csharp/programming-guide/enumeration-types.md
@@ -45,7 +45,7 @@ An enumeration type (also named an enumeration or an enum) provides an efficient
   
  You can verify the underlying numeric values by casting  to the underlying type, as the following example shows.  
   
-```cs  
+```csharp  
 Days today = Days.Monday;  
 int dayNumber =(int)today;  
 Console.WriteLine("{0} is day number #{1}.", today, dayNumber);  
diff --git a/docs/csharp/programming-guide/events/how-to-publish-events-that-conform-to-net-framework-guidelines.md b/docs/csharp/programming-guide/events/how-to-publish-events-that-conform-to-net-framework-guidelines.md
index 4fb924ce927ff..56f66bdfa20bf 100644
--- a/docs/csharp/programming-guide/events/how-to-publish-events-that-conform-to-net-framework-guidelines.md
+++ b/docs/csharp/programming-guide/events/how-to-publish-events-that-conform-to-net-framework-guidelines.md
@@ -36,7 +36,7 @@ translation.priority.ht:
 # How to: Publish Events that Conform to .NET Framework Guidelines (C# Programming Guide)
 The following procedure demonstrates how to add events that follow the standard [!INCLUDE[dnprdnshort](../../../csharp/getting-started/includes/dnprdnshort_md.md)] pattern to your classes and structs. All events in the [!INCLUDE[dnprdnshort](../../../csharp/getting-started/includes/dnprdnshort_md.md)] class library are based on the <xref:System.EventHandler> delegate, which is defined as follows:  
   
-```cs  
+```csharp  
 public delegate void EventHandler(object sender, EventArgs e);  
 ```  
   
@@ -49,7 +49,7 @@ public delegate void EventHandler(object sender, EventArgs e);
   
 1.  (Skip this step and go to Step 3a if you do not have to send custom data with your event.) Declare the class for your custom data at a scope that is visible to both your publisher and subscriber classes. Then add the required members to hold your custom event data. In this example, a simple string is returned.  
   
-    ```cs  
+    ```csharp  
     public class CustomEventArgs : EventArgs  
     {  
         public CustomEventArgs(string s)  
@@ -66,7 +66,7 @@ public delegate void EventHandler(object sender, EventArgs e);
   
 2.  (Skip this step if you are using the generic version of <xref:System.EventHandler%601> .) Declare a delegate in your publishing class. Give it a name that ends with *EventHandler*. The second parameter specifies your custom EventArgs type.  
   
-    ```cs  
+    ```csharp  
     public delegate void CustomEventHandler(object sender, CustomEventArgs a);  
     ```  
   
@@ -74,19 +74,19 @@ public delegate void EventHandler(object sender, EventArgs e);
   
     1.  If you have no custom EventArgs class, your Event type will be the non-generic EventHandler delegate. You do not have to declare the delegate because it is already declared in the <xref:System> namespace that is included when you create your C# project. Add the following code to your publisher class.  
   
-        ```cs  
+        ```csharp  
         public event EventHandler RaiseCustomEvent;  
         ```  
   
     2.  If you are using the non-generic version of <xref:System.EventHandler> and you have a custom class derived from <xref:System.EventArgs>, declare your event inside your publishing class and use your delegate from step 2 as the type.  
   
-        ```cs  
+        ```csharp  
         public event CustomEventHandler RaiseCustomEvent;  
         ```  
   
     3.  If you are using the generic version, you do not need a custom delegate. Instead, in your publishing class, you specify your event type as `EventHandler<CustomEventArgs>`, substituting the name of your own class between the angle brackets.  
   
-        ```cs  
+        ```csharp  
         public event EventHandler<CustomEventArgs> RaiseCustomEvent;  
         ```  
   
diff --git a/docs/csharp/programming-guide/file-system/how-to-create-a-file-or-folder.md b/docs/csharp/programming-guide/file-system/how-to-create-a-file-or-folder.md
index b33e4f7ffe8f6..3ab12b5f8f4f5 100644
--- a/docs/csharp/programming-guide/file-system/how-to-create-a-file-or-folder.md
+++ b/docs/csharp/programming-guide/file-system/how-to-create-a-file-or-folder.md
@@ -48,7 +48,7 @@ You can programmatically create a folder on your computer, create a subfolder, c
   
 -   Specify a non-random file name.  
   
-    ```cs  
+    ```csharp  
     // Comment out the following line.  
     //string fileName = System.IO.Path.GetRandomFileName();  
   
@@ -59,7 +59,7 @@ You can programmatically create a folder on your computer, create a subfolder, c
   
 -   Replace the `if`-`else` statement with the `using` statement in the following code.  
   
-    ```cs  
+    ```csharp  
     using (System.IO.FileStream fs = new System.IO.FileStream(pathString, FileMode.Append))   
     {  
         for (byte i = 0; i < 100; i++)  
diff --git a/docs/csharp/programming-guide/file-system/how-to-get-information-about-files-folders-and-drives.md b/docs/csharp/programming-guide/file-system/how-to-get-information-about-files-folders-and-drives.md
index 7870111030122..6e4d57d2ab3b7 100644
--- a/docs/csharp/programming-guide/file-system/how-to-get-information-about-files-folders-and-drives.md
+++ b/docs/csharp/programming-guide/file-system/how-to-get-information-about-files-folders-and-drives.md
@@ -48,7 +48,7 @@ In the .NET Framework, you can access file system information by using the follo
   
  The <xref:System.IO.FileInfo> and <xref:System.IO.DirectoryInfo> classes represent a file or directory and contain properties that expose many of the file attributes that are supported by the NTFS file system. They also contain methods for opening, closing, moving, and deleting files and folders. You can create instances of these classes by passing a string that represents the name of the file, folder, or drive in to the constructor:  
   
-```cs  
+```csharp  
 System.IO.DriveInfo di = new System.IO.DriveInfo(@"C:\");  
 ```  
   
diff --git a/docs/csharp/programming-guide/file-system/how-to-iterate-through-a-directory-tree.md b/docs/csharp/programming-guide/file-system/how-to-iterate-through-a-directory-tree.md
index aa1c5b06f408e..80814bae088e3 100644
--- a/docs/csharp/programming-guide/file-system/how-to-iterate-through-a-directory-tree.md
+++ b/docs/csharp/programming-guide/file-system/how-to-iterate-through-a-directory-tree.md
@@ -42,7 +42,7 @@ The phrase "iterate a directory tree" means to access each file in each nested s
   
  In the simplest case, in which you know for certain that you have access permissions for all directories under a specified root, you can use the `System.IO.SearchOption.AllDirectories` flag. This flag returns all the nested subdirectories that match the specified pattern. The following example shows how to use this flag.  
   
-```cs  
+```csharp  
 root.GetDirectories("*.*", System.IO.SearchOption.AllDirectories);  
 ```  
   
diff --git a/docs/csharp/programming-guide/nullable-types/boxing-nullable-types.md b/docs/csharp/programming-guide/nullable-types/boxing-nullable-types.md
index 222e9126223fa..1602b5274b5fd 100644
--- a/docs/csharp/programming-guide/nullable-types/boxing-nullable-types.md
+++ b/docs/csharp/programming-guide/nullable-types/boxing-nullable-types.md
@@ -38,7 +38,7 @@ translation.priority.ht:
 # Boxing Nullable Types (C# Programming Guide)
 Objects based on nullable types are only boxed if the object is non-null. If <xref:System.Nullable%601.HasValue%2A> is `false`, the object reference is assigned to `null` instead of boxing. For example:  
   
-```cs  
+```csharp  
 bool? b = null;  
 object o = b;  
 // Now o is null.  
@@ -46,7 +46,7 @@ object o = b;
   
  If the object is non-null -- if <xref:System.Nullable%601.HasValue%2A> is `true` -- then boxing occurs, but only the underlying type that the nullable object is based on is boxed. Boxing a non-null nullable value type boxes the value type itself, not the <xref:System.Nullable%601?displayProperty=fullName> that wraps the value type. For example:  
   
-```cs  
+```csharp  
 bool? b = false;  
 int? i = 44;  
 object bBoxed = b; // bBoxed contains a boxed bool.  
@@ -55,7 +55,7 @@ object iBoxed = i; // iBoxed contains a boxed int.
   
  The two boxed objects are identical to those created by boxing non-nullable types. And, just like non-nullable boxed types, they can be unboxed into nullable types, as in the following example:  
   
-```cs  
+```csharp  
 bool? b2 = (bool?)bBoxed;  
 int? i2 = (int?)iBoxed;  
 ```  
@@ -65,7 +65,7 @@ int? i2 = (int?)iBoxed;
   
 1.  Nullable objects and their boxed counterpart can be tested for null:  
   
-    ```cs  
+    ```csharp  
     bool? b = null;  
     object boxedB = b;  
     if (b == null)  
@@ -80,7 +80,7 @@ int? i2 = (int?)iBoxed;
   
 2.  Boxed nullable types fully support the functionality of the underlying type:  
   
-    ```cs  
+    ```csharp  
     double? d = 44.4;  
     object iBoxed = d;  
     // Access IConvertible interface implemented by double.  
diff --git a/docs/csharp/programming-guide/nullable-types/how-to-safely-cast-from-bool-to-bool.md b/docs/csharp/programming-guide/nullable-types/how-to-safely-cast-from-bool-to-bool.md
index 2dd0f5bd94ab9..ec68876961dda 100644
--- a/docs/csharp/programming-guide/nullable-types/how-to-safely-cast-from-bool-to-bool.md
+++ b/docs/csharp/programming-guide/nullable-types/how-to-safely-cast-from-bool-to-bool.md
@@ -48,7 +48,7 @@ if (b) // Error CS0266.
   
 ## Example  
   
-```cs  
+```csharp  
 bool? test = null;  
 // Other code that may or may not  
 // give a value to test.  
diff --git a/docs/csharp/programming-guide/statements-expressions-operators/equality-comparisons.md b/docs/csharp/programming-guide/statements-expressions-operators/equality-comparisons.md
index 4960de658ccf7..936c56651a139 100644
--- a/docs/csharp/programming-guide/statements-expressions-operators/equality-comparisons.md
+++ b/docs/csharp/programming-guide/statements-expressions-operators/equality-comparisons.md
@@ -49,7 +49,7 @@ It is sometimes necessary to compare two values for equality. In some cases, you
 ## Value Equality  
  Value equality means that two objects contain the same value or values. For primitive value types such as [int](../../../csharp/language-reference/keywords/int.md) or [bool](../../../csharp/language-reference/keywords/bool.md), tests for value equality are straightforward. You can use the [==](../../../csharp/language-reference/operators/equality-comparison-operator.md) operator, as shown in the following example.  
   
-```cs  
+```csharp  
 int a = GetOriginalValue();  
 int b = GetCurrentValue();  
   
diff --git a/docs/csharp/programming-guide/statements-expressions-operators/lambda-expressions.md b/docs/csharp/programming-guide/statements-expressions-operators/lambda-expressions.md
index f9a083c2b8bbc..e0026cd26620c 100644
--- a/docs/csharp/programming-guide/statements-expressions-operators/lambda-expressions.md
+++ b/docs/csharp/programming-guide/statements-expressions-operators/lambda-expressions.md
@@ -43,7 +43,7 @@ A lambda expression is an [anonymous function](../../../csharp/programming-guide
   
  To create a lambda expression, you specify input parameters (if any) on the left side of the lambda operator [=>](../../../csharp/language-reference/operators/lambda-operator.md), and you put the expression or statement block on the other side. For example, the lambda expression `x => x * x` specifies a parameter that’s named `x` and returns the value of `x` squared. You can assign this expression to a delegate type, as the following example shows:  
   
-```cs  
+```csharp  
 delegate int del(int i);  
 static void Main(string[] args)  
 {  
@@ -54,7 +54,7 @@ static void Main(string[] args)
   
  To create an expression tree type:  
   
-```cs  
+```csharp  
 using System.Linq.Expressions;  
   
 namespace ConsoleApplication1  
@@ -84,25 +84,25 @@ namespace ConsoleApplication1
 ## Expression Lambdas  
  A lambda expression with an expression on the right side of the => operator is called an *expression lambda*. Expression lambdas are used extensively in the construction of [Expression Trees](http://msdn.microsoft.com/library/fb1d3ed8-d5b0-4211-a71f-dd271529294b). An expression lambda returns the result of the expression and takes the following basic form:  
   
-```cs
+```csharp
 (input-parameters) => expression
 ```
 
  The parentheses are optional only if the lambda has one input parameter; otherwise they are required. Two or more input parameters are separated by commas enclosed in parentheses:  
   
-```cs
+```csharp
 (x, y) => x == y
 ```
 
  Sometimes it is difficult or impossible for the compiler to infer the input types. When this occurs, you can specify the types explicitly as shown in the following example:  
   
-```cs
+```csharp
 (int x, string s) => s.Length > x
 ```
 
  Specify zero input parameters with empty parentheses:  
   
-```cs
+```csharp
 () => SomeMethod()
 ```
 
@@ -124,7 +124,7 @@ namespace ConsoleApplication1
 ## Async Lambdas  
  You can easily create lambda expressions and statements that incorporate asynchronous processing by using the [async](../../../csharp/language-reference/keywords/async.md) and [await](../../../csharp/language-reference/keywords/await.md) keywords. For example, the following Windows Forms example contains an event handler that calls and awaits an async method, `ExampleMethodAsync`.  
   
-```cs
+```csharp
 public partial class Form1 : Form  
 {  
     public Form1()  
@@ -149,7 +149,7 @@ public partial class Form1 : Form
 
  You can add the same event handler by using an async lambda. To add this handler, add an `async` modifier before the lambda parameter list, as the following example shows.  
   
-```cs  
+```csharp  
 public partial class Form1 : Form  
 {  
     public Form1()  
@@ -176,13 +176,13 @@ public partial class Form1 : Form
 ## Lambdas with the Standard Query Operators  
  Many Standard query operators have an input parameter whose type is one of the <xref:System.Func%602> family of generic delegates. These delegates use type parameters to define the number and types of input parameters, and the return type of the delegate. `Func` delegates are very useful for encapsulating user-defined expressions that are applied to each element in a set of source data. For example, consider the following delegate type:  
   
-```cs  
+```csharp  
 public delegate TResult Func<TArg0, TResult>(TArg0 arg0)  
 ```  
   
  The delegate can be instantiated as `Func<int,bool> myFunc` where `int` is an input parameter and `bool` is the return value. The return value is always specified in the last type parameter. `Func<int, string, bool>` defines a delegate with two input parameters, `int` and `string`, and a return type of `bool`. The following `Func` delegate, when it is invoked, will return true or false to indicate whether the input parameter is equal to 5:  
   
-```cs  
+```csharp  
 Func<int, bool> myFunc = x => x == 5;  
 bool result = myFunc(4); // returns false of course  
 ```  
@@ -191,7 +191,7 @@ bool result = myFunc(4); // returns false of course
   
  A standard query operator, the <xref:System.Linq.Enumerable.Count%2A> method, is shown here:  
   
-```cs  
+```csharp  
 int[] numbers = { 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 };  
 int oddNumbers = numbers.Count(n => n % 2 == 1);  
 ```  
@@ -200,20 +200,20 @@ int oddNumbers = numbers.Count(n => n % 2 == 1);
   
  The following line of code produces a sequence that contains all elements in the `numbers` array that are to the left side of the 9 because that's the first number in the sequence that doesn't meet the condition:  
   
-```cs  
+```csharp  
 var firstNumbersLessThan6 = numbers.TakeWhile(n => n < 6);  
 ```  
   
  This example shows how to specify multiple input parameters by enclosing them in parentheses. The method returns all the elements in the numbers array until a number is encountered whose value is less than its position. Do not confuse the lambda operator (`=>`) with the greater than or equal operator (`>=`).  
   
-```cs  
+```csharp  
 var firstSmallNumbers = numbers.TakeWhile((n, index) => n >= index);  
 ```  
   
 ## Type Inference in Lambdas  
  When writing lambdas, you often do not have to specify a type for the input parameters because the compiler can infer the type based on the lambda body, the parameter’s delegate type, and other factors as described in the C# Language Specification. For most of the standard query operators, the first input is the type of the elements in the source sequence. So if you are querying an `IEnumerable<Customer>`, then the input variable is inferred to be a `Customer` object, which means you have access to its methods and properties:  
   
-```cs  
+```csharp  
 customers.Where(c => c.City == "London");  
 ```  
   
@@ -230,7 +230,7 @@ customers.Where(c => c.City == "London");
 ## Variable Scope in Lambda Expressions  
  Lambdas can refer to *outer variables* (see [Anonymous Methods](../../../csharp/programming-guide/statements-expressions-operators/anonymous-methods.md)) that are in scope in the method that defines the lambda function, or in scope in the type that contains the lambda expression. Variables that are captured in this manner are stored for use in the lambda expression even if the variables would otherwise go out of scope and be garbage collected. An outer variable must be definitely assigned before it can be consumed in a lambda expression. The following example demonstrates these rules:  
   
-```cs  
+```csharp  
 delegate bool D();  
 delegate bool D2(int i);  
   
diff --git a/docs/csharp/programming-guide/statements-expressions-operators/operators.md b/docs/csharp/programming-guide/statements-expressions-operators/operators.md
index 7fd4495365c82..91c71176a3cd4 100644
--- a/docs/csharp/programming-guide/statements-expressions-operators/operators.md
+++ b/docs/csharp/programming-guide/statements-expressions-operators/operators.md
@@ -152,7 +152,7 @@ In C#, an *operator* is a program element that is applied to one or more *operan
 ## Associativity  
  When two or more operators that have the same precedence are present in an expression, they are evaluated based on associativity. Left-associative operators are evaluated in order from left to right. For example, `x * y / z` is evaluated as `(x * y) / z`. Right-associative operators are evaluated in order from right to left. For example, the assignment operator is right associative. If it were not, the following code would result in an error.  
   
-```cs  
+```csharp  
 int a, b, c;  
 c = 1;  
 // The following two lines are equivalent.  
diff --git a/docs/csharp/programming-guide/statements-expressions-operators/overloadable-operators.md b/docs/csharp/programming-guide/statements-expressions-operators/overloadable-operators.md
index b0fa428f0fc44..3002dd715edec 100644
--- a/docs/csharp/programming-guide/statements-expressions-operators/overloadable-operators.md
+++ b/docs/csharp/programming-guide/statements-expressions-operators/overloadable-operators.md
@@ -53,7 +53,7 @@ C# allows user-defined types to overload operators by defining static member fun
   
  To overload an operator on a custom class requires creating a method on the class with the correct signature. The method must be named "operator X" where X is the name or symbol of the operator being overloaded. Unary operators have one parameter, and binary operators have two parameters. In each case, one parameter must be the same type as the class or struct that declares the operator.  
   
-```cs  
+```csharp  
 public static Complex operator +(Complex c1, Complex c2)  
     {  
         Return new Complex(c1.real + c2.real, c1.imaginary + c2.imaginary);  
@@ -63,7 +63,7 @@ public static Complex operator +(Complex c1, Complex c2)
   
  It is common to have definitions that simply return immediately with the result of an expression.  There is a syntax shortcut using `=>` for these situations.  
   
-```cs  
+```csharp  
 public static Complex operator +(Complex c1, Complex c2) =>  
         new Complex(c1.real + c2.real, c1.imaginary + c2.imaginary);  
   
diff --git a/docs/csharp/programming-guide/strings/how-to-convert-a-string-to-a-datetime.md b/docs/csharp/programming-guide/strings/how-to-convert-a-string-to-a-datetime.md
index de5ea996156c8..a58951e5bb09e 100644
--- a/docs/csharp/programming-guide/strings/how-to-convert-a-string-to-a-datetime.md
+++ b/docs/csharp/programming-guide/strings/how-to-convert-a-string-to-a-datetime.md
@@ -47,7 +47,7 @@ It is common for programs to enable users to enter dates as string values. To co
   
  For more examples of date strings, see <xref:System.Convert.ToDateTime%28System.String%29?displayProperty=fullName>.  
   
-```cs  
+```csharp  
 string dateTime = "01/08/2008 14:50:50.42";  
             DateTime dt = Convert.ToDateTime(dateTime);  
             Console.WriteLine("Year: {0}, Month: {1}, Day: {2}, Hour: {3}, Minute: {4}, Second: {5}, Millisecond: {6}",  
diff --git a/docs/csharp/programming-guide/strings/how-to-parse-strings-using-string-split.md b/docs/csharp/programming-guide/strings/how-to-parse-strings-using-string-split.md
index be1c1e7ef6451..3868d2d249287 100644
--- a/docs/csharp/programming-guide/strings/how-to-parse-strings-using-string-split.md
+++ b/docs/csharp/programming-guide/strings/how-to-parse-strings-using-string-split.md
@@ -50,7 +50,7 @@ The following code example demonstrates how a string can be parsed using the <xr
   
  String.Split can take an array of strings (character sequences that act as separators for parsing the target string, instead of single characters).  
   
-```cs  
+```csharp  
 class TestStringSplit  
 {  
     static void Main()  
diff --git a/docs/csharp/programming-guide/types/casting-and-type-conversions.md b/docs/csharp/programming-guide/types/casting-and-type-conversions.md
index f4c436d9281bb..ce99c5b8f4d08 100644
--- a/docs/csharp/programming-guide/types/casting-and-type-conversions.md
+++ b/docs/csharp/programming-guide/types/casting-and-type-conversions.md
@@ -41,7 +41,7 @@ translation.priority.ht:
 # Casting and Type Conversions (C# Programming Guide)
 Because C# is statically-typed at compile time, after a variable is declared, it cannot be declared again or used to store values of another type unless that type is convertible to the variable's type. For example, there is no conversion from an integer to any arbitrary string. Therefore, after you declare `i` as an integer, you cannot assign the string "Hello" to it, as is shown in the following code.  
   
-```cs  
+```csharp  
 int i;  
 i = "Hello"; // Error: "Cannot implicitly convert type 'string' to 'int'"  
 ```  
@@ -79,7 +79,7 @@ Base b = d; // Always OK.
   
  For reference types, an explicit cast is required if you need to convert from a base type to a derived type:  
   
-```cs  
+```csharp  
 // Create a new derived type.  
 Giraffe g = new Giraffe();  
   
diff --git a/docs/csharp/programming-guide/types/index.md b/docs/csharp/programming-guide/types/index.md
index a9227fed06f12..94bbaef4f81a1 100644
--- a/docs/csharp/programming-guide/types/index.md
+++ b/docs/csharp/programming-guide/types/index.md
@@ -109,14 +109,14 @@ Value types and reference types in the CTS
   
  The built-in numeric types are structs, and they have properties and methods that you can access:  
   
-```cs  
+```csharp  
 // Static method on type Byte.  
 byte b = Byte.MaxValue;  
 ```  
   
  But you declare and assign values to them as if they were simple non-aggregate types:  
   
-```cs  
+```csharp  
 byte num = 0xA;  
 int i = 5;  
 char c = 'Z';  
@@ -141,13 +141,13 @@ char c = 'Z';
 ### Reference Types  
  A type that is defined as a [class](../../../csharp/language-reference/keywords/class.md), [delegate](../../../csharp/language-reference/keywords/delegate.md), array, or [interface](../../../csharp/language-reference/keywords/interface.md) is a *reference type*. At run time, when you declare a variable of a reference type, the variable contains the value [null](../../../csharp/language-reference/keywords/null.md) until you explicitly create an instance of the object by using the [new](../../../csharp/language-reference/keywords/new.md) operator, or assign it an object that has been created elsewhere by using `new, as shown in the following example:`  
   
-```cs  
+```csharp  
 MyClass mc = new MyClass();  
 MyClass mc2 = mc;  
 ```  
    An interface must be initialized together with a class object that implements it. If `MyClass` implements `IMyInterface`, you create an instance of `IMyInterface` as shown in the following example:  
   
-```cs  
+```csharp  
 IMyInterface iface = new MyClass();  
 ```  
   
@@ -169,7 +169,7 @@ IMyInterface iface = new MyClass();
 ## Generic Types  
  A type can be declared with one or more *type parameters* that serve as a placeholder for the actual type (the *concrete type*) that client code will provide when it creates an instance of the type. Such types are called *generic types*. For example, the .NET Framework type <xref:System.Collections.Generic.List%601?displayProperty=fullName> has one type parameter that by convention is given the name *T*. When you create an instance of the type, you specify the type of the objects that the list will contain, for example, string:  
  
-```cs
+```csharp
 List<string> stringList = new List<string>();
 stringList.Add("String example");
 // compile time error adding a type other than a string:
diff --git a/docs/csharp/properties.md b/docs/csharp/properties.md
index 1bd471d7c4948..73283820c1e2c 100644
--- a/docs/csharp/properties.md
+++ b/docs/csharp/properties.md
@@ -27,7 +27,7 @@ when a property is accessed or assigned.
 The syntax for properties is a natural extension to
 fields. A field defines a storage location:
 
-```cs
+```csharp
 public class Person
 {
 	public string FirstName;
@@ -39,7 +39,7 @@ A property definition contains declarations for a `get` and
 `set` accessor that retrieves and assigns the value of that
 property:
 
-```cs
+```csharp
 public class Person
 {
 	public string FirstName
@@ -56,7 +56,7 @@ generates the storage location for the field that backs up the
 property. The compiler also implements the body of the `get` and `set` accessors.
 You can also define the storage yourself, as shown below:
 
-```cs
+```csharp
 public class Person
 {
 	public string FirstName
@@ -91,7 +91,7 @@ by a property are always valid. For example, suppose one rule for the `Person`
 class is that the name cannot be blank, or whitespace. You would write that as
 follows:
 
-```cs
+```csharp
 public class Person
 {
     public string FirstName
@@ -111,7 +111,7 @@ public class Person
 
 The example above enforces the rule that the first name must not be blank,
 or whitespace. If a developer writes
-```cs
+```csharp
 hero.FirstName = "";
 ```
 That assignment throws an `ArgumentException`. Because a property set accessor
@@ -130,7 +130,7 @@ accessors. Suppose that your `Person` class should only enable changing the valu
 `FirstName` property from other methods in that class. You could give the set accessor
 `private` accessibility instead of `public`:
 
-```cs
+```csharp
 public class Person
 {
 	public string FirstName
@@ -160,7 +160,7 @@ A property does not need to simply return the value of a member field. You can c
 that return a computed value. Let's expand the `Person` object to return the full name, computed
 by concatenating the first and last names:
 
-```cs
+```csharp
 public class Person
 {
     public string FirstName
@@ -191,7 +191,7 @@ the formatted string for the full name.
 You can also use *Expression-bodied Members*, which provides a more
 succinct way to create the computed `FullName` property:
 
-```cs
+```csharp
 public class Person
 {
     public string FirstName
@@ -221,7 +221,7 @@ a *lazy evaluated property*.  For example, you could update the `FullName`
 property so that the string formatting only happened the first time it
 was accessed:
 
-```cs
+```csharp
 public class Person
 {
     public string FirstName
@@ -255,7 +255,7 @@ either the `FirstName` or `LastName` property, the previously evaluated
 `FirstName` and `LastName` property so that the `fullName` field is calculated
 again:
 
-```cs
+```csharp
 public class Person
 {
     private string firstName;
@@ -311,7 +311,7 @@ to indicate the change. The data binding libraries, in turn, update display elem
 based on that change. The code below shows how you would implement `INotifyPropertyChanged`
 for the `FirstName` property of this person class.
 
-```cs
+```csharp
 public class Person : INotifyPropertyChanged
 {
     public string FirstName
diff --git a/docs/csharp/tutorials/console-teleprompter.md b/docs/csharp/tutorials/console-teleprompter.md
index bfbe31ccd8a67..e09c88c8718d7 100644
--- a/docs/csharp/tutorials/console-teleprompter.md
+++ b/docs/csharp/tutorials/console-teleprompter.md
@@ -62,7 +62,7 @@ The simple Hello World application code is all in Program.cs. Open that
 file with your favorite text editor. We’re about to make our first changes.
 At the top of the file, see a using statement:
 
-```cs
+```csharp
 using System;
 ```
 
@@ -73,7 +73,7 @@ different. You can see that the program is enclosed in the
 `ConsoleApplication` namespace. That’s not a very descriptive name, so
 change it to `TeleprompterConsole`:
 
-```cs
+```csharp
 namespace TeleprompterConsole
 ```
 
@@ -88,7 +88,7 @@ application.
 Next, add the following method in your Program class (right below the `Main` 
 method):
 
-```cs
+```csharp
 static IEnumerable<string> ReadFrom(string file)
 {
     string line;
@@ -105,7 +105,7 @@ static IEnumerable<string> ReadFrom(string file)
 This method uses types from two new namespaces. For this to compile you’ll 
 need to add the following two lines to the top of the file:
 
-```cs
+```csharp
 using System.Collections.Generic;
 using System.IO;
 ```
@@ -145,7 +145,7 @@ a @System.IO.StreamReader object.
  
 Now, let’s fill in the code to read the file in the `Main` method: 
 
-```cs
+```csharp
 var lines = ReadFrom("sampleQuotes.txt");
 foreach (var line in lines)
 {
@@ -169,7 +169,7 @@ method to return single words instead of entire lines. That’s done with
 these modifications. Replace the `yield return line;` statement with the
 following code:
 
-```cs
+```csharp
 var words = line.Split(' ');
 foreach (var word in words)
 {
@@ -182,7 +182,7 @@ Next, you need to modify how you consume the lines of the file, and add a
 delay after writing each word. Replace the `Console.WriteLine(line)` statement
 in the `Main` method with the following block:
 
-```cs
+```csharp
 Console.Write(line);
 if (!string.IsNullOrWhiteSpace(line))
 {
@@ -197,7 +197,7 @@ if (!string.IsNullOrWhiteSpace(line))
 The `Task` class is in the `System.Threading.Tasks` namespace, so you need
 to add that `using` statement at the top of file:
 
-```cs
+```csharp
 using System.Threading.Tasks;
 ```
 
@@ -210,14 +210,14 @@ each line, and generate a new line whenever the line length reaches a
 certain threshold. Declare a local variable after the declaration of
 `words` that holds the line length:
 
-```cs
+```csharp
 var lineLength = 0;
 ```
  
 Then, add the following code after the `yield return word + " ";` statement
 (before the closing brace):
 
-```cs
+```csharp
 lineLength += word.Length + 1;
 if (lineLength > 70)
 {
@@ -240,7 +240,7 @@ represents the code you’ve created so far to read and display the file.
 Add this method to your `Program` class (it’s taken from the body of your
 `Main` method):
 
-```cs
+```csharp
 private static async Task ShowTeleprompter()
 {
     var words = ReadFrom("sampleQuotes.txt");
@@ -270,7 +270,7 @@ monitor that returned `Task` to determine when it has completed.
 
 You can call this new method in your `Main` method:
 
-```cs
+```csharp
 ShowTeleprompter().Wait();
 ```
 
@@ -284,7 +284,7 @@ Next, you need to write the second asynchronous method to read from the
 Console and watch for the ‘<’ and ‘>’ keys. Here’s the method you add for
 that task:
 
-```cs
+```csharp
 private static async Task GetInput()
 {
     var delay = 200;
@@ -320,7 +320,7 @@ It’s time to create a class that can handle the shared data between these
 two tasks. This class contains two public properties: the delay, and a
 flag to indicate that the file has been completely read:
 
-```cs
+```csharp
 namespace TeleprompterConsole
 {
     internal class TelePrompterConfig
@@ -348,7 +348,7 @@ enclosing class or namespace names. A `using static` statement imports the
 methods from one class. This is in contrast with the `using` statements used
 up to this point that have imported all classes from a namespace.
 
-```cs
+```csharp
 using static System.Math;
 ```
 
@@ -363,7 +363,7 @@ Next, you need to update the `ShowTeleprompter` and `GetInput` methods to
 use the new `config` object. Write one final `Task` returning `async` method to
 start both tasks and exit when the first task finishes:
 
-```cs
+```csharp
 private static async Task RunTeleprompter()
 {
     var config = new TelePrompterConfig();
@@ -380,7 +380,7 @@ that finishes as soon as any of the tasks in its argument list completes.
 Next, you need to update both the `ShowTeleprompter` and `GetInput` methods to
 use the `config` object for the delay:
 
-```cs
+```csharp
 private static async Task ShowTeleprompter(TelePrompterConfig config)
 {
     var words = ReadFrom("sampleQuotes.txt");
@@ -416,14 +416,14 @@ This new version of `ShowTeleprompter` calls a new method in the
 `TeleprompterConfig` class. Now, you need to update `Main` to call 
 `RunTeleprompter` instead of `ShowTeleprompter`:
 
-```cs
+```csharp
 RunTeleprompter().Wait();
 ```
 
 To finish, you'll need to add the
 `SetDone` method, and the `Done` property to the `TelePrompterConfig` class:
 
-```cs
+```csharp
 public bool Done => done;
 
 private bool done;
diff --git a/docs/csharp/tutorials/console-webapiclient.md b/docs/csharp/tutorials/console-webapiclient.md
index 1ec91147cfb8d..1273d801e4765 100644
--- a/docs/csharp/tutorials/console-webapiclient.md
+++ b/docs/csharp/tutorials/console-webapiclient.md
@@ -105,7 +105,7 @@ APIs, @System.Net.Http.HttpClient supports only async methods for its long-runni
 Start by making an async method. You'll fill in the implementation as you
 build the functionality of the application. Start by opening the `program.cs` file in your project directory and adding the following method to the `Program` class:
 
-```cs
+```csharp
 private static async Task ProcessRepositories()
 {
     
@@ -115,7 +115,7 @@ private static async Task ProcessRepositories()
 You'll need to add a `using` statement at the top of your `Main` method so
 that the C# compiler recognizes the @System.Threading.Tasks.Task type:
 
-```cs
+```csharp
 using System.Threading.Tasks;
 ```
 
@@ -131,7 +131,7 @@ Next, update the `Main` method to call this method. The
 program before that task finishes. Therefore, you must use the `Wait`
 method to block and wait for the task to finish:
 
-```cs
+```csharp
 public static void Main(string[] args)
 {
     ProcessRepositories().Wait();
@@ -141,7 +141,7 @@ public static void Main(string[] args)
 Now, you have a program that does nothing, but does it asynchronously. Let's go back to the
 `ProcessRepositories` method and fill in a first version of it:
 
-```cs
+```csharp
 private static async Task ProcessRepositories()
 {
     var client = new HttpClient();
@@ -159,7 +159,7 @@ private static async Task ProcessRepositories()
 
 You'll need to also add two new using statements at the top of the file for this to compile:
 
-```cs
+```csharp
 using System.Net.Http;
 using System.Net.Http.Headers;
 ```
@@ -192,7 +192,7 @@ The JSON Serializer converts JSON data into C# Objects. Your first task is to de
 type to contain the information you use from this response. Let's build this slowly, so start with
 a simple C# type that contains the name of the repository:
 
-```cs
+```csharp
 using System;
 
 namespace WebAPIClient
@@ -218,13 +218,13 @@ Now that you've created the type, let's deserialize it. You'll need to create a
 JSON packet it retrieves. The packet from GitHub contains a sequence of repositories, so a
 `List<repo>` is the correct type. Add the following line to your `ProcessRepositories` method:
 
-```cs
+```csharp
 var serializer = new DataContractJsonSerializer(typeof(List<repo>));
 ```
 
 You're using two new namespaces, so you'll need to add those as well:
 
-```cs
+```csharp
 using System.Collections.Generic;
 using System.Runtime.Serialization.Json;
 ```
@@ -232,7 +232,7 @@ using System.Runtime.Serialization.Json;
 Next, you'll use the serializer to convert JSON into C# objects. Replace the call to
 @System.Net.Http.HttpClient.GetStringAsync(System.String) in your `ProcessRepositories` method with the following two lines:
 
-```cs
+```csharp
 var streamTask = client.GetStreamAsync("https://api.github.com/orgs/dotnet/repos");
 var repositories = serializer.ReadObject(await streamTask) as List<repo>;
 ```
@@ -251,14 +251,14 @@ instead of throwing an exception.
 You're almost done with this section. Now that you've converted the JSON to C# objects, let's display
 the name of each repository. Replace the lines that read:
 
-```cs
+```csharp
 var msg = await stringTask;   //**Deleted this
 Console.Write(msg);
 ```
 
 with the following:
 
-```cs
+```csharp
 foreach (var repo in repositories)
     Console.WriteLine(repo.name);
 ```
@@ -289,7 +289,7 @@ Next, open the `repo.cs` file. Let's change the name to use Pascal Case, and ful
 `DataContract` attribute to the class declaration. You'll set the `Name` property of the attribute
 to the name of the JSON nodes that map to this type:
 
-```cs
+```csharp
 [DataContract(Name="repo")]
 public class Repository
 ```
@@ -297,14 +297,14 @@ public class Repository
 The @System.Runtime.Serialization.DataContractAttribute is a member of the @System.Runtime.Serialization namespace, so you'll
 need to add the appropriate `using` statement at the top of the file:
 
-```cs
+```csharp
 using System.Runtime.Serialization;
 ```
 
 You changed the name of the `repo` class to `Repository`, so you'll need to make the same name change
 in Program.cs (some editors may support a rename refactoring that will make this change automatically:)
 
-```cs
+```csharp
 var serializer = new DataContractJsonSerializer(typeof(List<Repository>));
 
 // ...
@@ -315,14 +315,14 @@ var repositories = serializer.ReadObject(await streamTask) as List<Repository>;
 Next, let's make the same change with the `name` field by using the @System.Runtime.Serialization.DataMemberAttribute class. Make
 the following changes to the declaration of the `name` field in repo.cs:
 
-```cs
+```csharp
 [DataMember(Name="name")]
 public string Name;
 ```
 
 This change means you need to change the code that writes the name of each repository in program.cs:
 
-```cs
+```csharp
 Console.WriteLine(repo.Name);
 ```
 
@@ -335,14 +335,14 @@ easier to add those changes later without breaking any code that uses the `Repos
 
 Remove the field definition, and replace it with an [auto-implemented property](../programming-guide/classes-and-structs/auto-implemented-properties.md):
 
-```cs
+```csharp
 public string Name { get; set; }
 ```
 
 The compiler generates the body of the `get` and `set` accessors, as well as a private field to
 store the name. It would be similar to the following code that you could type by hand:
 
-```cs
+```csharp
 public string Name 
 { 
     get { return this._name; }
@@ -358,13 +358,13 @@ and move the code that writes the information into the `Main` method.
 Change the signature of `ProcessRepositories` to return a task whose result is a list of `Repository`
 objects:
 
-```cs
+```csharp
 private static async Task<List<Repository>> ProcessRepositories()
 ```
 
 Then, just return the repositories after processing the JSON response:
 
-```cs
+```csharp
 var repositories = serializer.ReadObject(await streamTask) as List<Repository>;
 return repositories;
 ```
@@ -373,7 +373,7 @@ The compiler generates the `Task<T>` object for the return because you've marked
 Then, let's modify the `Main` method so that it captures those results and writes each repository name
 to the console. Your `Main` method now looks like this:
 
-```cs
+```csharp
 public static void Main(string[] args)
 {
     var repositories = ProcessRepositories().Result;
@@ -396,7 +396,7 @@ features of the C# language.
 Let's start by adding a few more simple types to the `Repository` class definition. Add these properties
 to that class:
 
-```cs
+```csharp
 [DataMember(Name="description")]
 public string Description { get; set; }
 
@@ -417,7 +417,7 @@ the serialization action will throw an exception.
 
 Once you've added these, update the `Main` method to display those elements:
 
-```cs
+```csharp
 foreach (var repo in repositories)
 {
     Console.WriteLine(repo.Name);
@@ -440,7 +440,7 @@ a custom conversion method. You also probably don't want the raw string exposed
 class. Attributes can help control that as well. First, define a `private` property that will hold the
 string representation of the date time in your `Repository` class:
 
-```cs
+```csharp
 [DataMember(Name="pushed_at")]
 private string JsonDate { get; set; }
 ```
@@ -449,7 +449,7 @@ The `DataMember` attribute informs the serializer that this should be processed,
 a public member. Next, you need to write a public read-only property that converts the string to a
 valid @System.DateTime object, and returns that @System.DateTime:
 
-```cs
+```csharp
 [IgnoreDataMember]
 public DateTime LastPush
 {
@@ -471,14 +471,14 @@ property accessor throws an exception.
 To use @System.Globalization.CultureInfo.InvariantCulture, you will need to add the @System.Globalization namespace to the `using` statements 
 in `repo.cs`:
 
-```cs
+```csharp
 using System.Globalization;
 ```
 
 Finally, add one more output statement in the console, and you're ready to build and run this app
 again:
 
-```cs
+```csharp
 Console.WriteLine(repo.LastPush);
 ```
 
diff --git a/docs/csharp/tutorials/inheritance.md b/docs/csharp/tutorials/inheritance.md
index 89850245a1cf5..825af8af09d6a 100644
--- a/docs/csharp/tutorials/inheritance.md
+++ b/docs/csharp/tutorials/inheritance.md
@@ -66,7 +66,7 @@ While all other members of a base class are inherited by derived classes, whethe
 
 Derived classes can also *override* inherited members by providing an alternate implementation. In order to be able to override a member, the member in the base class must be marked with the [virtual](../language-reference/keywords/virtual.md) keyword. By default, base class members are not marked as `virtual` and cannot be overridden. Attempting to override a non-virtual member, as the following example does, generates compiler error CS0506: "<member> cannot override inherited member <member> because it is not marked virtual, abstract, or override.
 
-   ```cs
+   ```csharp
    public class A
    {
       public void Method1()
@@ -86,7 +86,7 @@ Derived classes can also *override* inherited members by providing an alternate
 
 In some cases, a derived class *must* override the base class implementation. Base class members marked with the [abstract](../language-reference/keywords/abstract.md) keyword require that derived classes override them. Attempting to compile the following example generates compiler error CS0534, "<class> does not implement inherited abstract member <member>', because class `B` provides no implementation for `A.Method1`.
 
-   ```cs
+   ```csharp
    public abstract class A
    {
       public abstract void Method1();
@@ -103,7 +103,7 @@ In some cases, a derived class *must* override the base class implementation. Ba
 
 Inheritance applies only to classes and interfaces. Other type categories (structs, delegates, and enums) do not support inheritance. Because of this, attempting to compile code like the following produces compiler error CS0527: "Type 'ValueType' in interface list is not an interface." The error message indicates that, although you can define the interfaces that a struct implements, inheritance is not supported.
 
-   ```cs
+   ```csharp
    using System;
 
    public struct ValueStructure : ValueType       // Generates CS0527.
@@ -206,7 +206,7 @@ The following example shows the source code for the `Publication` class, as well
 
   Because the `Publication` class is `abstract`, it cannot be instantiated directly from code like the following:
 
-  ```cs
+  ```csharp
   var publication = new Publication("Tiddlywinks for Experts", "Fun and Games",
                                     PublicationType.Book);
   ```
diff --git a/docs/csharp/tutorials/microservices.md b/docs/csharp/tutorials/microservices.md
index ba2915ff9edba..ef6cdf8d92261 100644
--- a/docs/csharp/tutorials/microservices.md
+++ b/docs/csharp/tutorials/microservices.md
@@ -198,7 +198,7 @@ in the code above.
 Next, you need to convert the strings to doubles. The method you'll use
 to convert the string to a double is `double.TryParse()`:
 
-```cs
+```csharp
 bool TryParse(string s, out double result);
 ```
 
@@ -243,7 +243,7 @@ the updated results.
 Your next task is to build a random weather forecast. Let's start with a data
 container that holds the values you'd want for a weather forecast:
 
-```cs
+```csharp
 public class WeatherReport
 {
     private static readonly string[] PossibleConditions = new string[]
diff --git a/docs/csharp/tutorials/string-interpolation.md b/docs/csharp/tutorials/string-interpolation.md
index 8324126e02c3e..45fcf281c5622 100644
--- a/docs/csharp/tutorials/string-interpolation.md
+++ b/docs/csharp/tutorials/string-interpolation.md
@@ -18,7 +18,7 @@ String Interpolation is the way that placeholders in a string are replaced by th
 
 Other programming languages have had string interpolation built into the language for a while. For instance, in PHP:
 
-```PHP
+```php
 $name = "Jonas";
 echo "My name is $name.";
 // This will output "My name is Jonas."
@@ -99,7 +99,7 @@ If a variable name is not found, then a compile time error will be generated.
 
 For instance:
 
-```cs
+```csharp
 var animal = "fox";
 var localizeMe = $"The {adj} brown {animal} jumped over the lazy {otheranimal}";
 var adj = "quick";
diff --git a/docs/csharp/tutorials/working-with-linq.md b/docs/csharp/tutorials/working-with-linq.md
index 8c1a9f587b529..842d400a9730b 100644
--- a/docs/csharp/tutorials/working-with-linq.md
+++ b/docs/csharp/tutorials/working-with-linq.md
@@ -70,7 +70,7 @@ thirteen values). You'll combine those source into a 52 card deck.
 
 Here's the query:
 
-```cs
+```csharp
 var startingDeck = from s in Suits()
                    from r in Ranks()
                    select new { Suit = s, Rank = r };
@@ -89,7 +89,7 @@ Next, you'll need to build the Suits() and Ranks() methods. Let's start
 with a really simple set of *iterator methods* that generate the sequence
 as an enumerable of strings:
 
-```cs
+```csharp
 static IEnumerable<string> Suits()
 {
     yield return "clubs";
@@ -132,7 +132,7 @@ Next, let's build a utility method that can perform the shuffle. The first step
 is to split the deck in two. The `Take()` and `Skip()` methods that are
 part of the LINQ APIs provide that feature for us:
 
-```cs
+```csharp
 var top = startingDeck.Take(26);
 var bottom = startingDeck.Skip(26);
 ```
@@ -144,7 +144,7 @@ steps.
 
 The signature for the method creates an *extension method*:
 
-```cs
+```csharp
 public static IEnumerable<T> InterleaveSequenceWith<T>
     (this IEnumerable<T> first, IEnumerable<T> second)
 ```
@@ -163,7 +163,7 @@ This method declaration also follows a standard idiom where the input and
 output types are `IEnumerable<T>`. That practice enables LINQ methods to
 be chained together to perform more complex queries.
 
-```cs
+```csharp
 using System.Collections.Generic;
 
 namespace LinqFaroShuffle
@@ -193,7 +193,7 @@ of building a collection and returning the collection, you'll use the
 
 Here's the implementation of that method:
 
-```cs
+```csharp
 public static IEnumerable<T> InterleaveSequenceWith<T>
     (this IEnumerable<T> first, IEnumerable<T> second)
 {
@@ -210,7 +210,7 @@ public static IEnumerable<T> InterleaveSequenceWith<T>
 Now that you've written this method, go back to the `Main` method
 and shuffle the deck once:
 
-```cs
+```csharp
 public static void Main(string[] args)
 {
     var startingDeck = from s in Suits()
@@ -243,7 +243,7 @@ element, you'll compare the matching elements of each sequence. When
 the entire sequence has been enumerated, if every element matches,
 the sequences are the same:
 
-```cs
+```csharp
 public static bool SequenceEquals<T>(this IEnumerable<T> first, IEnumerable<T> second)
 {
     var firstIter = first.GetEnumerator();
@@ -267,7 +267,7 @@ the sequence is back in its original order by applying the `SequenceEquals()`
 method. You can see it would always be the final method in any query, because it
 returns a single value instead of a sequence:
 
-```cs
+```csharp
 var times = 0;
 var shuffle = startingDeck;
 do
@@ -296,7 +296,7 @@ first card in the deck. That means the last card in the top half becomes the bot
 card. That's just a one line change. Update the call to shuffle to change the order
 of the top and bottom halves of the deck:
 
-```cs
+```csharp
 shuffle = shuffle.Skip(26).InterleaveSequenceWith(shuffle.Take(26));
 ```
 
@@ -318,7 +318,7 @@ the original deck many, many times. Let's write a log to demonstrate this behavi
 
 Here's a log method that can be appended to any query to mark that the query executed.
 
-```cs
+```csharp
 public static IEnumerable<T> LogQuery<T>(this IEnumerable<T> sequence, string tag)
 {
     using (var writer = File.AppendText("debug.log"))
@@ -331,7 +331,7 @@ public static IEnumerable<T> LogQuery<T>(this IEnumerable<T> sequence, string ta
 
 Next, instrument the definition of each query with a log message:
 
-```cs
+```csharp
 public static void Main(string[] args)
 {
 var startingDeck = (from s in Suits().LogQuery("Suit Generation")
@@ -372,7 +372,7 @@ in an array or a list, respectively. You use these methods to cache the data res
 rather than execute the source query again.  Append the queries that generate the card decks
 with a call to `ToArray()` and run the query again:
 
-```cs
+```csharp
 public static void Main(string[] args)
 {
 var startingDeck = (from s in Suits().LogQuery("Suit Generation")
@@ -447,7 +447,7 @@ values.
 
 Start with the suits. This is a perfect time to use an `enum`:
 
-```cs
+```csharp
 public enum Suit
 {
     Clubs,
@@ -459,7 +459,7 @@ public enum Suit
 
 The `Suits()` method also changes type and implementation:
 
-```cs
+```csharp
 static IEnumerable<Suit> Suits()
 {
     yield return Suit.Clubs;
@@ -471,7 +471,7 @@ static IEnumerable<Suit> Suits()
 
 Next, do the same change with the Rank of the cards:
 
-```cs
+```csharp
 public enum Rank
 {
     Two,
@@ -492,7 +492,7 @@ public enum Rank
 
 And the method that generates them:
 
-```cs
+```csharp
 static IEnumerable<Rank> Values()
 {
     yield return Rank.Two;
@@ -516,7 +516,7 @@ relying on an anonymous type. Anonymous types are great for lightweight,
 local types, but in this example, the playing card is one of the main
 concepts. It should be a concrete type.
 
-```cs
+```csharp
 public class PlayingCard
 {
     public Suit CardSuit { get; }
@@ -542,7 +542,7 @@ string output.
 
 Update the query that generates the starting deck to use the new type:
 
-```cs
+```csharp
 var startingDeck = (from s in Suits().LogQuery("Suit Generation")
                     from r in Ranks().LogQuery("Value Generation")
                     select new PlayingCard(s, r))
diff --git a/docs/fsharp/tutorials/asynchronous-and-concurrent-programming/async.md b/docs/fsharp/tutorials/asynchronous-and-concurrent-programming/async.md
index ca61406233619..68210695411e1 100644
--- a/docs/fsharp/tutorials/asynchronous-and-concurrent-programming/async.md
+++ b/docs/fsharp/tutorials/asynchronous-and-concurrent-programming/async.md
@@ -25,7 +25,7 @@ The key concept to understand is that an async expression’s type is `Async<'T>
 
 For example, say you wanted to download the HTML from dotnetfoundation.org without blocking the main thread. You can accomplish it like this:
 
-```fs
+```fsharpharp
 let fetchHtmlAsync url = async {
     let uri = new System.Uri(url)
     let webClient = new System.Net.WebClient()
@@ -59,7 +59,7 @@ As mentioned earlier, async code is a specification of work to be done in anothe
 
 1.  `Async.RunSynchronously` will start an async workflow on another thread and await its result.
 
- ```fs
+ ```fsharp
  let fetchHtmlAsync url = async {
      let uri = new System.Uri(url)
      let webClient = new System.Net.WebClient()
@@ -77,7 +77,7 @@ As mentioned earlier, async code is a specification of work to be done in anothe
 
 2.  `Async.Start` will start an async workflow on another thread, and will **not** await its result.
 
- ```fs
+ ```fsharp
  let uploadDataAsync url data = async {
      let uri = new System.Uri(url)
      let webClient = new System.Net.WebClient()
@@ -105,7 +105,7 @@ Sometimes you may need to perform multiple asynchronous jobs in parallel, collec
 
 The following example will use `Async.Parallel` to download the HTML from four popular sites in parallel, wait for those tasks to complete, and then print the HTML which was downloaded.
 
-```fs
+```fsharp
 let urlList = [
     "http://www.microsoft.com"
     "http://www.google.com"
@@ -180,7 +180,7 @@ In contrast, F# async workflows are more naturally cancellable. Cancellation is
 
 Example:
 
-```fs
+```fsharp
 let uploadDataAsync url data = async {
     let uri = new System.Uri(url)
     let webClient = new System.Net.WebClient()
diff --git a/docs/standard/delegates-lambdas.md b/docs/standard/delegates-lambdas.md
index 5621be2bcf489..afe593ef915ed 100644
--- a/docs/standard/delegates-lambdas.md
+++ b/docs/standard/delegates-lambdas.md
@@ -16,7 +16,7 @@ ms.assetid: fe2e4b4c-6483-4106-a4b4-a33e2e306591
 
 Delegates define a type, which specify a particular method signature. A method (static or instance) that satisfies this signature can be assigned to a variable of that type, then called directly (with the appropriate arguments) or passed as an argument itself to another method and then called. The following example demonstrates delegate use.
 
-```cs
+```csharp
 public class Program
 {
 
@@ -50,7 +50,7 @@ In order to streamline the development process, .NET includes a set of delegate
 
 We can now take our example above and rewrite it using the `Func<>` delegate instead of a custom type. The program will continue running exactly the same.
 
-```cs
+```csharp
 public class Program
 {
 
@@ -73,7 +73,7 @@ For this simple example, having a method defined outside of the Main() method se
 
 For an example, we are going to switch it up and use our anonymous delegate to filter out a list of only even numbers and then print them to the console.
 
-```cs
+```csharp
 public class Program
 {
 
@@ -110,7 +110,7 @@ Lambda expressions, or just “lambdas” for short, were introduced first in C#
 
 Since a lambda expression is just another way of specifying a delegate, we should be able to rewrite the above sample to use a lambda expression instead of an anonymous delegate.
 
-```cs
+```csharp
 public class Program
 {
 
@@ -138,7 +138,7 @@ If you take a look at the highlighted lines, you can see how a lambda expression
 
 Again, lambdas are just delegates, which means that they can be used as an event handler without any problems, as the following code snippet illustrates.
 
-```cs
+```csharp
 public MainWindow()
 {
     InitializeComponent();
diff --git a/docs/standard/garbagecollection/implementing-dispose.md b/docs/standard/garbagecollection/implementing-dispose.md
index 253af03a57e27..7c2c674104d65 100644
--- a/docs/standard/garbagecollection/implementing-dispose.md
+++ b/docs/standard/garbagecollection/implementing-dispose.md
@@ -39,7 +39,7 @@ The [IDisposable](xref:System.IDisposable) interface requires the implementation
 
 * A protected virtual (`Overridable` in Visual Basic) `Dispose` method whose signature is:
 
-  ```cs
+  ```csharp
   protected virtual void Dispose(bool disposing)
   ```
 
@@ -51,7 +51,7 @@ The [IDisposable](xref:System.IDisposable) interface requires the implementation
 
 Because the public, non-virtual (`NonInheritable` in Visual Basic), parameterless `Dispose` method is called by a consumer of the type, its purpose is to free unmanaged resources and to indicate that the finalizer, if one is present, doesn't have to run. Because of this, it has a standard implementation:
 
-```cs
+```csharp
 public void Dispose()
 {
    // Dispose of unmanaged resources.
@@ -105,7 +105,7 @@ If you implement the dispose pattern for a base class, you must provide the foll
 
 Here's the general pattern for implementing the dispose pattern for a base class that uses a safe handle. 
 
-```cs
+```csharp
 using Microsoft.Win32.SafeHandles;
 using System;
 using System.Runtime.InteropServices;
@@ -182,7 +182,7 @@ End Class
  
 Here's the general pattern for implementing the dispose pattern for a base class that overrides [Object.Finalize](xref:System.Object.Finalize). 
 
-```cs
+```csharp
 using System;
 
 class BaseClass : IDisposable
@@ -266,7 +266,7 @@ A class derived from a class that implements the [IDisposable](xref:System.IDisp
 
 Here's the general pattern for implementing the dispose pattern for a derived class that uses a safe handle: 
 
-```cs
+```csharp
 using Microsoft.Win32.SafeHandles;
 using System;
 using System.Runtime.InteropServices;
@@ -335,7 +335,7 @@ End Class
 
 Here's the general pattern for implementing the dispose pattern for a derived class that overrides [Object.Finalize](xref:System.Object.Finalize):
 
-```cs
+```csharp
 using System;
 
 class DerivedClass : BaseClass
@@ -420,7 +420,7 @@ Classes derived from the [System.Runtime.InteropServices.SafeHandle](xref:System
 
 The following example illustrates the dispose pattern for a base class, `DisposableStreamResource`, that uses a safe handle to encapsulate unmanaged resources. It defines a `DisposableResource` class that uses a [SafeFileHandle](xref:Microsoft.Win32.SafeHandles.SafeFileHandle) to wrap a [Stream](xref:System.IO.Stream) object that represents an open file. The `DisposableResource` method also includes a single property, `Size`, that returns the total number of bytes in the file stream. 
 
-```cs
+```csharp
 using Microsoft.Win32.SafeHandles;
 using System;
 using System.IO;
@@ -584,7 +584,7 @@ End Class
 
 The following example illustrates the dispose pattern for a derived class, `DisposableStreamResource2`, that inherits from the `DisposableStreamResource` class presented in the previous example. The class adds an additional method, `WriteFileInfo`, and uses a [SafeFileHandle](xref:Microsoft.Win32.SafeHandles.SafeFileHandle) object to wrap the handle of the writable file. 
 
-```cs
+```csharp
 using Microsoft.Win32.SafeHandles;
 using System;
 using System.IO;
diff --git a/docs/standard/garbagecollection/using-objects.md b/docs/standard/garbagecollection/using-objects.md
index bac194cc2bb46..b5e8c26e9296d 100644
--- a/docs/standard/garbagecollection/using-objects.md
+++ b/docs/standard/garbagecollection/using-objects.md
@@ -26,7 +26,7 @@ The `using` statement in C# and the `Using` statement in Visual Basic simplify t
 
 The following example uses the `using` statement to create and release a [System.IO.StreamReader](xref:System.IO.StreamReader) object.
 
-```cs
+```csharp
 using System;
 using System.IO;
 
@@ -72,7 +72,7 @@ End Module
 
 Note that although the [StreamReader](xref:System.IO.StreamReader) class implements the [IDisposable](xref:System.IDisposable) interface, which indicates that it uses an unmanaged resource, the example doesn't explicitly call the [StreamReader.Dispose](xref:System.IO.StreamReader.Dispose(System.Boolean)) method. When the C# or Visual Basic compiler encounters the `using` statement, it emits intermediate language (IL) that is equivalent to the following code that explicitly contains a `try/finally` block. 
 
-```cs
+```csharp
 using System;
 using System.IO;
 
@@ -129,7 +129,7 @@ End Module
 
 The C# `using` statement also allows you to acquire multiple resources in a single statement, which is internally equivalent to nested using statements. The following example instantiates two [StreamReader](xref:System.IO.StreamReader) objects to read the contents of two different files. 
 
-```cs
+```csharp
 using System;
 using System.IO;
 
@@ -166,7 +166,7 @@ Instead of wrapping a `try/finally` block in a `using` statement, you may choose
 
 The following example is similar to the previous example, except that it uses a `try/catch/finally` block to instantiate, use, and dispose of a [StreamReader](xref:System.IO.StreamReader) object, and to handle any exceptions thrown by the [StreamReader](xref:System.IO.StreamReader) constructor and its [ReadToEnd](xref:System.IO.StreamReader.ReadToEnd) method. Note that the code in the `finally` block checks that the object that implements [IDisposable](xref:System.IDisposable) isn't `null` before it calls the [Dispose](xref:System.IDisposable.Dispose) method. Failure to do this can result in a [NullReferenceException](xref:System.NullReferenceException) exception at run time. 
 
-```cs
+```csharp
 using System;
 using System.Globalization;
 using System.IO;
diff --git a/docs/standard/generics.md b/docs/standard/generics.md
index 57b783fcc686b..9d576ac96dc73 100644
--- a/docs/standard/generics.md
+++ b/docs/standard/generics.md
@@ -24,7 +24,7 @@ Generics are also available at runtime, or **reified**. This means the runtime k
 
 Here is a small program that illustrates the efficiency of knowing the data structure type at runtime:
 
-```cs
+```csharp
   using System;
   using System.Collections;
   using System.Collections.Generic;
diff --git a/docs/standard/native-interop.md b/docs/standard/native-interop.md
index 60c73283c13f1..b99204ac9aa37 100644
--- a/docs/standard/native-interop.md
+++ b/docs/standard/native-interop.md
@@ -33,7 +33,7 @@ P/Invoke is a technology that allows you to access structs, callbacks and functi
 
 Let’s start from the most common example, and that is calling unmanaged functions in your managed code. Let’s show a message box from a command-line application:
 
-```cs
+```csharp
 using System.Runtime.InteropServices;
 
 public class Program {
@@ -61,7 +61,7 @@ The rest of the example is just invoking the method as you would any other manag
 
 The sample is similar for macOS. One thing that needs to change is, of course, the name of the library in the `DllImport` attribute, as macOS has a different scheme of naming dynamic libraries. The sample below uses the `getpid(2)` function to get the process ID of the application and print it out to the console.
 
-```cs
+```csharp
 using System;
 using System.Runtime.InteropServices;
 
@@ -84,7 +84,7 @@ namespace PInvokeSamples {
 
 It is similar on Linux, of course. The function name is same, since `getpid(2)` is [POSIX](https://en.wikipedia.org/wiki/POSIX) system call.
 
-```cs
+```csharp
 using System;
 using System.Runtime.InteropServices;
 
@@ -111,7 +111,7 @@ Of course, the runtime allows communication to flow both ways which enables you
 
 The way to use this feature is similar to managed to native process described above. For a given callback, you define a delegate that matches the signature, and pass that into the external method. The runtime will take care of everything else.
 
-```cs
+```csharp
 using System;
 using System.Runtime.InteropServices;
 
@@ -155,7 +155,7 @@ With this in mind, let’s walk through the example:
 
 The Linux and macOS examples are shown below. For them, we use the `ftw` function that can be found in `libc`, the C library. This function is used to traverse directory hierarchies and it takes a pointer to a function as one of its parameters. The said function has the following signature: `int (*fn) (const char *fpath, const struct stat *sb, int typeflag)`.
 
-```cs
+```csharp
 using System;
 using System.Runtime.InteropServices;
 
@@ -208,7 +208,7 @@ namespace PInvokeSamples {
 
 macOS example uses the same function, and the only difference is the argument to the `DllImport` attribute, as macOS keeps `libc` in a different place.
 
-```cs
+```csharp
 using System;
 using System.Runtime.InteropServices;
 
@@ -267,7 +267,7 @@ Both of the above examples depend on parameters, and in both cases, the paramete
 
 The reason marshalling is needed is because the types in the managed and unmanaged code are different. In managed code, for instance, you have a `String`, while in the unmanaged world strings can be Unicode (“wide”), non-Unicode, null-terminated, ASCII, etc. By default, the P/Invoke subsystem will try to do the Right Thing based on the default behavior which you can see on [MSDN](https://msdn.microsoft.com/library/zah6xy75.aspx). However, for those situations where you need extra control, you can employ the `MarshalAs` attribute to specify what is the expected type on the unmanaged side. For instance, if we want the string to be sent as a null-terminated ANSI string, we could do it like this:
 
-```cs
+```csharp
 [DllImport("somenativelibrary.dll"]
 static extern int MethodA([MarshalAs(UnmanagedType.LPStr)] string parameter);
 
@@ -277,7 +277,7 @@ static extern int MethodA([MarshalAs(UnmanagedType.LPStr)] string parameter);
 
 Another aspect of type marshalling is how to pass in a struct to an unmanaged method. For instance, some of the unmanaged methods require a struct as a parameter. In these cases, we need to create a corresponding struct or a class in managed part of the world to use it as a parameter. However, just defining the class is not enough, we also need to instruct the marshaler how to map fields in the class to the unmanaged struct. This is where the `StructLayout` attribute comes into play.
 
-```cs
+```csharp
 [DllImport("kernel32.dll")]
 static extern void GetSystemTime(SystemTime systemTime);
 
@@ -319,7 +319,7 @@ typedef struct _SYSTEMTIME {
 
 We already saw the Linux and macOS example for this in the previous example. It is shown again below.
 
-```cs
+```csharp
 [StructLayout(LayoutKind.Sequential)]
 public class StatClass {
         public uint DeviceID;
diff --git a/docs/standard/using-linq.md b/docs/standard/using-linq.md
index 5e511b8d2c5fc..05408659dcc96 100644
--- a/docs/standard/using-linq.md
+++ b/docs/standard/using-linq.md
@@ -20,7 +20,7 @@ LINQ provides language-level querying capabilities and a [higher-order function]
 
 Language-level query syntax:
 
-```cs
+```csharp
 var linqExperts = from p in programmers
                   where p.IsNewToLINQ
                   select new LINQExpert(p);
@@ -29,7 +29,7 @@ var linqExperts = from p in programmers
 
 Same example using the `IEnumerable<T>` API:
 
-```cs
+```csharp
 var linqExperts = programmers.Where(p => IsNewToLINQ)
                              .Select(p => new LINQExpert(p));
 
@@ -41,7 +41,7 @@ Imagine you have a list of pets, but want to convert it into a dictionary where
 
 Traditional imperative code:
 
-```cs
+```csharp
 var petLookup = new Dictionary<int, Pet>();
 
 foreach (var pet in pets)
@@ -55,7 +55,7 @@ The intention behind the code is not to create a new `Dictionary<int, Pet>` and
 
 Equivalent LINQ expression:
 
-```cs
+```csharp
 var petLookup = pets.ToDictionary(pet => pet.RFID);
 
 ```
@@ -68,7 +68,7 @@ For a significant chunk of software out in the wild, everything revolves around
 
 Consider the following: finding all XML elements with a specific attribute value.
 
-```cs
+```csharp
 public static IEnumerable<XElement> FindAllElementsWithAttribute(XElement documentRoot, string elementName,
                                            string attributeName, string value)
 {
@@ -87,14 +87,14 @@ Interacting with XML isn’t the only thing you can do with LINQ Providers. [Lin
 
 This is a question which often comes up. After all, this,
 
-```cs
+```csharp
 var filteredItems = myItems.Where(item => item.Foo);
 
 ```
 
 is a lot more concise than this:
 
-```cs
+```csharp
 var filteredItems = from item in myItems
                     where item.Foo
                     select item;
@@ -127,7 +127,7 @@ The following is a quick demonstration of some of the essential pieces of LINQ.
 
 *   The bread and butter - `Where`, `Select`, and `Aggregate`:
 
-```cs
+```csharp
 // Filtering a list
 var germanShepards = dogs.Where(dog => dog.Breed == DogBreed.GermanShepard);
 
@@ -151,7 +151,7 @@ int sumOfStrings = strings.Aggregate(seed, (s1, s2) => s1.Length + s2.Length);
 
 *   Flattening a list of lists:
 
-```cs
+```csharp
 // Transforms the list of kennels into a list of all their dogs.
 var allDogsFromKennels = kennels.SelectMany(kennel => kennel.Dogs);
 
@@ -159,7 +159,7 @@ var allDogsFromKennels = kennels.SelectMany(kennel => kennel.Dogs);
 
 *   Union between two sets (with custom comparator):
 
-```cs
+```csharp
 public class DogHairLengthComparer : IEqualityComparer<Dog>
 {
     public bool Equals(Dog a, Dog b)
@@ -195,7 +195,7 @@ var allShortHairedDogs = kennel1.Dogs.Union(kennel2.Dogs, new DogHairLengthCompa
 
 *   Intersection between two sets:
 
-```cs
+```csharp
 // Gets the volunteers who spend share time with two humane societies.
 var volunteers = humaneSociety1.Volunteers.Intersect(humaneSociety2.Volunteers,
                                                      new VolunteerTimeComparer());
@@ -204,7 +204,7 @@ var volunteers = humaneSociety1.Volunteers.Intersect(humaneSociety2.Volunteers,
 
 *   Ordering:
 
-```cs
+```csharp
 // Get driving directions, ordering by if it's toll-free before estimated driving time.
 var results = DirectionsProcessor.GetDirections(start, end)
               .OrderBy(direction => direction.HasNoTolls)
@@ -214,7 +214,7 @@ var results = DirectionsProcessor.GetDirections(start, end)
 
 *   Finally, a more advanced sample: determining if the values of the properties of two instances of the same type are equal (Borrowed and modified from [this StackOverflow post](http://stackoverflow.com/a/844855)):
 
-```cs
+```csharp
 public static bool PublicInstancePropertiesEqual<T>(this T self, T to, params string[] ignore) where T : class
 {
     if (self != null && to != null)
@@ -243,7 +243,7 @@ PLINQ, or Parallel LINQ, is a parallel execution engine for LINQ expressions. In
 
 Consider the following:
 
-```cs
+```csharp
 public static string GetAllFacebookUserLikesMessage(IEnumerable<FacebookUser> facebookUsers)
 {
     var seed = default(UInt64);
diff --git a/docs/visual-basic/developing-apps/windows-forms/how-to-draw-lines-with-the-lineshape-control-visual-studio.md b/docs/visual-basic/developing-apps/windows-forms/how-to-draw-lines-with-the-lineshape-control-visual-studio.md
index 64befe702647d..18df3f5d84602 100644
--- a/docs/visual-basic/developing-apps/windows-forms/how-to-draw-lines-with-the-lineshape-control-visual-studio.md
+++ b/docs/visual-basic/developing-apps/windows-forms/how-to-draw-lines-with-the-lineshape-control-visual-studio.md
@@ -61,7 +61,7 @@ You can use the <xref:Microsoft.VisualBasic.PowerPacks.LineShape> control to dra
 Imports Microsoft.VisualBasic.PowerPacks  
 ```  
   
-```cs  
+```csharp  
 using Microsoft.VisualBasic.PowerPacks;  
 ```  
   
diff --git a/docs/visual-basic/developing-apps/windows-forms/how-to-draw-shapes-with-the-ovalshape-and-rectangleshape-controls.md b/docs/visual-basic/developing-apps/windows-forms/how-to-draw-shapes-with-the-ovalshape-and-rectangleshape-controls.md
index aae07c12f473b..ea8778d6eba0b 100644
--- a/docs/visual-basic/developing-apps/windows-forms/how-to-draw-shapes-with-the-ovalshape-and-rectangleshape-controls.md
+++ b/docs/visual-basic/developing-apps/windows-forms/how-to-draw-shapes-with-the-ovalshape-and-rectangleshape-controls.md
@@ -64,7 +64,7 @@ You can use the <xref:Microsoft.VisualBasic.PowerPacks.OvalShape> control to dra
 Imports Microsoft.VisualBasic.PowerPacks  
 ```  
   
-```cs  
+```csharp  
 using Microsoft.VisualBasic.PowerPacks;  
 ```  
   
diff --git a/docs/visual-basic/developing-apps/windows-forms/how-to-enable-tabbing-between-shapes-visual-studio.md b/docs/visual-basic/developing-apps/windows-forms/how-to-enable-tabbing-between-shapes-visual-studio.md
index 5c6b5010e9057..b0be8e7b9388b 100644
--- a/docs/visual-basic/developing-apps/windows-forms/how-to-enable-tabbing-between-shapes-visual-studio.md
+++ b/docs/visual-basic/developing-apps/windows-forms/how-to-enable-tabbing-between-shapes-visual-studio.md
@@ -50,7 +50,7 @@ Line and shape controls do not have `TabStop` or `TabIndex` properties, but you
 Imports Microsoft.VisualBasic.PowerPacks  
 ```  
   
-```cs  
+```csharp  
 using Microsoft.VisualBasic.PowerPacks;  
 ```  
 
diff --git a/docs/visual-basic/developing-apps/windows-forms/troubleshooting-the-datarepeater-control-visual-studio.md b/docs/visual-basic/developing-apps/windows-forms/troubleshooting-the-datarepeater-control-visual-studio.md
index 484235c95140d..effbad076c149 100644
--- a/docs/visual-basic/developing-apps/windows-forms/troubleshooting-the-datarepeater-control-visual-studio.md
+++ b/docs/visual-basic/developing-apps/windows-forms/troubleshooting-the-datarepeater-control-visual-studio.md
@@ -52,7 +52,7 @@ This topic lists common issues that may occur when you are working with the <xre
 DataRepeater1.Top = ProductsBindingNavigator.Height  
 ```  
   
-```cs  
+```csharp  
 dataRepeater1.Top = productsBindingNavigator.Height;  
 ```  
   
diff --git a/samples/README.md b/samples/README.md
index 2fd908b0bca03..924eba98126e9 100644
--- a/samples/README.md
+++ b/samples/README.md
@@ -57,7 +57,7 @@ To create a sample:
 2. Write the topic that explains the concepts demonstrated in your sample (example: `docs/standard/linq/where-clause.md`) 
 3. Write your sample (example: `WhereClause-Sample1.cs`)
 4. Create a Program.cs with a Main entry point that calls your samples. If there is already one there, add the call to your sample:
-  ```cs
+  ```csharp
     public class Program
     {
         public void Main(string[] args)
diff --git a/styleguide/template.md b/styleguide/template.md
index ae81f0a5d586d..ae831a007f909 100644
--- a/styleguide/template.md
+++ b/styleguide/template.md
@@ -254,11 +254,37 @@ runtime errors, you can use inline code blocks.
 
 ### Inline code blocks with language identifier
 
-Use three backticks (\`\`\`) + a language ID to apply language-specific color coding to a code block. Here is the entire list of [GFM language IDs](https://github.com/jmm/gfm-lang-ids/wiki/GitHub-Flavored-Markdown-(GFM)-language-IDs).
+Use three backticks (\`\`\`) + a language ID to apply language-specific color coding to a code block. Here is the list of supported languages showing the markdown label for each language ID. 
+
+#### Supported Languages
+|Name|Markdown Label|
+|-----|-------|
+|Azure CLI|azurecli|
+|AzCopy|azcopy|
+|C++|cpp|
+|C#|csharp|
+|F#|fsharp|
+|JavaScript|javascript|
+|JSON|json|
+|NodeJS|nodejs|
+|Objective-C|objc|
+|PHP|php|
+|PowerShell|powershell|
+|Python|python|
+|Ruby|ruby|
+|SQL / T-SQL|sql|
+|Swift|swift|
+|VB|vb|
+|XAML|xaml|
+|XML|xml| 
+ 
+ 
+
+The following are examples of code blocks using the language IDs for C# (\`\`\`csharp), Python (\`\`\`python), and PowerShell (\`\`\`powershell).
 
 ##### C&#9839;
 
-```cs
+```csharp
 using System;
 namespace HelloWorld
 {

From b1cc722f51131f667b34fb7f8d35a285d6ecf1f4 Mon Sep 17 00:00:00 2001
From: "Tom Pratt (Aquent LLC)" <v-thprat@microsoft.com>
Date: Fri, 24 Mar 2017 13:11:03 -0700
Subject: [PATCH 2/2] Fixes to address review comments.

---
 .../static-classes-and-static-class-members.md                 | 3 +--
 .../tutorials/asynchronous-and-concurrent-programming/async.md | 2 +-
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/docs/csharp/programming-guide/classes-and-structs/static-classes-and-static-class-members.md b/docs/csharp/programming-guide/classes-and-structs/static-classes-and-static-class-members.md
index 6fe489dbe9f91..135d74b022a5d 100644
--- a/docs/csharp/programming-guide/classes-and-structs/static-classes-and-static-class-members.md
+++ b/docs/csharp/programming-guide/classes-and-structs/static-classes-and-static-class-members.md
@@ -46,7 +46,7 @@ UtilityClass.MethodA();
   
  A static class can be used as a convenient container for sets of methods that just operate on input parameters and do not have to get or set any internal instance fields. For example, in the .NET Framework Class Library, the static <xref:System.Math?displayProperty=fullName> class contains methods that perform mathematical operations, without any requirement to store or retrieve data that is unique to a particular instance of the <xref:System.Math> class. That is, you apply the members of the class by specifying the class name and the method name, as shown in the following example.  
   
-```  
+```csharp  
 double dub = -3.14;  
 Console.WriteLine(Math.Abs(dub));  
 Console.WriteLine(Math.Floor(dub));  
@@ -56,7 +56,6 @@ Console.WriteLine(Math.Round(Math.Abs(dub)));
 // 3.14  
 // -4  
 // 3  
-  
 ```  
   
  As is the case with all class types, the type information for a static class is loaded by the [!INCLUDE[dnprdnshort](../../../csharp/getting-started/includes/dnprdnshort_md.md)] common language runtime (CLR) when the program that references the class is loaded. The program cannot specify exactly when the class is loaded. However, it is guaranteed to be loaded and to have its fields initialized and its static constructor called before the class is referenced for the first time in your program. A static constructor is only called one time, and a static class remains in memory for the lifetime of the application domain in which your program resides.  
diff --git a/docs/fsharp/tutorials/asynchronous-and-concurrent-programming/async.md b/docs/fsharp/tutorials/asynchronous-and-concurrent-programming/async.md
index 68210695411e1..06a0b89b4b148 100644
--- a/docs/fsharp/tutorials/asynchronous-and-concurrent-programming/async.md
+++ b/docs/fsharp/tutorials/asynchronous-and-concurrent-programming/async.md
@@ -25,7 +25,7 @@ The key concept to understand is that an async expression’s type is `Async<'T>
 
 For example, say you wanted to download the HTML from dotnetfoundation.org without blocking the main thread. You can accomplish it like this:
 
-```fsharpharp
+```fsharp
 let fetchHtmlAsync url = async {
     let uri = new System.Uri(url)
     let webClient = new System.Net.WebClient()