fixed absolute and msdn links (dotnet#1001)

* fixed absolute and msdn links

* added missing space

Author: mairaw

docs/core/docker/building-net-docker-images.md

@@ -37,7 +37,7 @@ To achieve the goals above, we provide image variants under [microsoft/dotnet](h
 
 - `microsoft/dotnet:<version>-sdk` : that is **microsoft/dotnet-preview2-sdk**, this image contains the .NET Core SDK which includes the .NET Core and Command Line Tools (CLI). This image maps to the **development scenario**. You would use this image for local development, debugging and unit testing. For example, all the development you do, before you check in your code. This image can also be used for your **build** scenarios.
 
-- `microsoft/dotnet:<version>-core` : that is **microsoft/dotnet:1.0.0-core**, image which runs [portable .NET Core applications](https://docs.microsoft.com/en-us/dotnet/articles/core/app-types) and it is optimized for running your application in **production**. It does not contain the SDK, and is meant to take the optimized output of `dotnet publish`. The portable runtime is well suited for Docker container scenarios as running multiple containers benefit from shared image layers.  
+- `microsoft/dotnet:<version>-core` : that is **microsoft/dotnet:1.0.0-core**, image which runs [portable .NET Core applications](../app-types.md) and it is optimized for running your application in **production**. It does not contain the SDK, and is meant to take the optimized output of `dotnet publish`. The portable runtime is well suited for Docker container scenarios as running multiple containers benefit from shared image layers.  
 
 ## Alternative images
 

docs/core/porting/libraries.md

@@ -332,7 +332,7 @@ The best way to make sure everything works when you've ported your code is to te
 * [NUnit](http://www.nunit.org/)
   - [Getting Started](https://github.com/nunit/docs/wiki/Installation)
   - [Blog post about migrating from MSTest to NUnit](http://www.florian-rappl.de/News/Page/275/convert-mstest-to-nunit)
-* [MSTest](https://msdn.microsoft.com/en-us/library/ms243147(v=vs.90).aspx)
+* [MSTest](https://msdn.microsoft.com/library/ms243147.aspx)
 
 ## Recommended Approach to Porting
 

docs/core/windows-prerequisites.md

@@ -50,10 +50,10 @@ Verify that you're running [Visual Studio 2015 Update 3.3](https://www.visualstu
 
 * On the **Help** menu, choose **About Microsoft Visual Studio**.
 * In the About Microsoft Visual Studio dialog, the version number should be 14.0.25424.00 or higher, and include "Update 3".
-* If you don't have Update 3, you can download and install [Visual Studio 2015 Update 3](https://www.visualstudio.com/en-us/news/releasenotes/vs2015-update3-vs).
-* If you have Update 3, you download and install [Visual Studio 2015 Update 3.3](https://msdn.microsoft.com/en-us/library/mt752379.aspx).
+* If you don't have Update 3, you can download and install [Visual Studio 2015 Update 3](https://www.visualstudio.com/news/releasenotes/vs2015-update3-vs).
+* If you have Update 3, you download and install [Visual Studio 2015 Update 3.3](https://msdn.microsoft.com/library/mt752379.aspx).
 
-You can read more about the changes in Update 3.3 in the [release notes](https://www.visualstudio.com/en-us/news/releasenotes/vs2015-update3-vs).
+You can read more about the changes in Update 3.3 in the [release notes](https://www.visualstudio.com/news/releasenotes/vs2015-update3-vs).
 
 ## NuGet Manager extension for Visual Studio
 

docs/csharp/async.md

@@ -16,7 +16,7 @@ ms.assetid: b878c34c-a78f-419e-a594-a2b44fa521a4
 
 If you have any I/O-bound needs (such as requesting data from a network or accessing a database), you'll want to utilize asynchronous programming.  You could also have CPU-bound code, such as performing an expensive calculation, which is also a good scenario for writing async code.
 
-C# has a language-level asynchronous programming model which allows for easily writing asynchronous code without having to juggle callbacks or conform to a library which supports asynchrony. It follows what is known as the [Task-based Asynchronous Pattern (TAP)](https://msdn.microsoft.com/en-us/library/hh873175%28v=vs.110%29.aspx).
+C# has a language-level asynchronous programming model which allows for easily writing asynchronous code without having to juggle callbacks or conform to a library which supports asynchrony. It follows what is known as the [Task-based Asynchronous Pattern (TAP)](https://msdn.microsoft.com/library/hh873175.aspx).
 
 ## Basic Overview of the Asynchronous Model
 

docs/csharp/codedoc.md

@@ -20,7 +20,7 @@ The compiler generated XML file can be distributed alongside your .NET assembly
 Additionally the XML file can be run through tools like [DocFX](https://dotnet.github.io/docfx/) and [Sandcastle](https://github.com/EWSoftware/SHFB) to generate full on API reference websites.
 
 XML documentation comments like all other comments are ignored by the compiler, to enable generation of the XML file add `"xmlDoc":true` under `buildOptions` in your `project.json` when using .NET Core or use the `/doc` compiler option for the .NET framework.
-Go [here](https://msdn.microsoft.com/en-us/library/3260k4x7.aspx) to learn how to enable XML documentation generation in Visual Studio.
+See the [/doc](https://msdn.microsoft.com/library/3260k4x7.aspx) article on MSDN to learn how to enable XML documentation generation in Visual Studio.
 
 XML documentation comments are characterized by triple forward slashes (`///`) and an XML formatted comment body.
 
@@ -1239,11 +1239,11 @@ An there you have it, our code is back to being readable and no documentation in
 
 The `filename` attribute represents the name of the XML file containing the documentation.
 
-The `path` attribute represents an [XPath](https://msdn.microsoft.com/en-us/library/ms256115(v=vs.110).aspx) query to the `tag name` present in the specified `filename`
+The `path` attribute represents an [XPath](https://msdn.microsoft.com/library/ms256115.aspx) query to the `tag name` present in the specified `filename`.
 
-The `name` attribute represents the name specifier in the tag that precedes the comments
+The `name` attribute represents the name specifier in the tag that precedes the comments.
 
-The `id` attribute which can be used in place of `name` represents the ID for the tag that precedes the comments
+The `id` attribute which can be used in place of `name` represents the ID for the tag that precedes the comments.
 
 ### User Defined Tags
 

docs/fsharp/index.md

@@ -32,7 +32,7 @@ The [Tutorials](tutorials/index.md) also have step-by-step guides for various sk
 
 ## If You're Experienced with F# #
 
-If you know your way around F#, you'll find a lot of use in the [Language Reference](language-reference/index.md), which documents each aspect of the language thoroughly, supplemented by numerous code samples.  You'll also find a lot of use in the [F# Core Library Reference](https://msdn.microsoft.com/en-us/visualfsharpdocs/conceptual/fsharp-core-library-reference).
+If you know your way around F#, you'll find a lot of use in the [Language Reference](language-reference/index.md), which documents each aspect of the language thoroughly, supplemented by numerous code samples.  You'll also find a lot of use in the [F# Core Library Reference](https://msdn.microsoft.com/visualfsharpdocs/conceptual/fsharp-core-library-reference).
 
 ## The F# Software Foundation
 
@@ -48,7 +48,7 @@ To learn more and get involved, check out [fsharp.org](http://fsharp.org).
 * [Introduction to Functional Programming](introduction-to-functional-programming/index.md)
 * [Tutorials](tutorials/index.md)
 * [Language Reference](language-reference/index.md)
-* [F# Core Library Reference](https://msdn.microsoft.com/en-us/visualfsharpdocs/conceptual/fsharp-core-library-reference)
+* [F# Core Library Reference](https://msdn.microsoft.com/visualfsharpdocs/conceptual/fsharp-core-library-reference)
 
 ## Further Resources
 

docs/fsharp/language-reference/arrays.md

@@ -48,7 +48,7 @@ You can access array elements by using a dot operator (`.`) and brackets (`[` an
 
 [!code-fsharp[Main](../../../samples/snippets/fsharp/arrays/snippet5.fs)]
 
-Array indices start at 0.
+Array indexes start at 0.
 
 You can also access array elements by using slice notation, which enables you to specify a subrange of the array. Examples of slice notation follow.
 
@@ -192,13 +192,13 @@ You can also use the function [`Array2D.init`](https://msdn.microsoft.com/librar
 
 [!code-fsharp[Main](../../../samples/snippets/fsharp/arrays/snippet21.fs)]
 
-Array indexing and slicing syntax is supported for arrays up to rank 4. When you specify an index in multiple dimensions, you use commas to separate the indices, as illustrated in the following code example.
+Array indexing and slicing syntax is supported for arrays up to rank 4. When you specify an index in multiple dimensions, you use commas to separate the indexes, as illustrated in the following code example.
 
 [!code-fsharp[Main](../../../samples/snippets/fsharp/arrays/snippet22.fs)]
 
 The type of a two-dimensional array is written out as `<type>[,]` (for example, `int[,]`, `double[,]`), and the type of a three-dimensional array is written as `<type>[,,]`, and so on for arrays of higher dimensions.
 
-Only a subset of the functions available for one-dimensional arrays is also available for multidimensional arrays. For more information, see [`Collections.Array Module`](https://msdn.microsoft.com/en-us/visualfsharpdocs/conceptual/collections.array-module-%5bfsharp%5d), [`Collections.Array2D Module`](https://msdn.microsoft.com/en-us/visualfsharpdocs/conceptual/collections.array2d-module-%5bfsharp%5d), [`Collections.Array3D Module`](https://msdn.microsoft.com/en-us/visualfsharpdocs/conceptual/collections.array3d-module-%5bfsharp%5d), and [`Collections.Array4D Module`]https://msdn.microsoft.com/en-us/visualfsharpdocs/conceptual/collections.array4d-module-%5bfsharp%5d).
+Only a subset of the functions available for one-dimensional arrays is also available for multidimensional arrays. For more information, see [`Collections.Array Module`](https://msdn.microsoft.com/visualfsharpdocs/conceptual/collections.array-module-%5bfsharp%5d), [`Collections.Array2D Module`](https://msdn.microsoft.com/visualfsharpdocs/conceptual/collections.array2d-module-%5bfsharp%5d), [`Collections.Array3D Module`](https://msdn.microsoft.com/visualfsharpdocs/conceptual/collections.array3d-module-%5bfsharp%5d), and [`Collections.Array4D Module`](https://msdn.microsoft.com/visualfsharpdocs/conceptual/collections.array4d-module-%5bfsharp%5d).
 
 ### Array Slicing and Multidimensional Arrays
 

docs/fsharp/language-reference/asynchronous-workflows.md

@@ -59,7 +59,7 @@ One example of using asynchronous workflows is included here; there are many oth
 
 This example shows how to use asynchronous workflows to perform computations in parallel.
 
-In the following code example, a function fetchAsync gets the HTML text returned from a Web request. The fetchAsync function contains an asynchronous block of code. When a binding is made to the result of an asynchronous primitive, in this case [`AsyncDownloadString`](https://msdn.microsoft.com/library/8a85a9b7-f712-4cac-a0ce-0a797f8ea32a), let! is used instead of let.
+In the following code example, a function `fetchAsync` gets the HTML text returned from a Web request. The `fetchAsync` function contains an asynchronous block of code. When a binding is made to the result of an asynchronous primitive, in this case [`AsyncDownloadString`](https://msdn.microsoft.com/library/8a85a9b7-f712-4cac-a0ce-0a797f8ea32a), let! is used instead of let.
 
 You use the function [`Async.RunSynchronously`](https://msdn.microsoft.com/library/0a6663a9-50f2-4d38-8bf3-cefd1a51fd6b) to execute an asynchronous operation and wait for its result. As an example, you can execute multiple asynchronous operations in parallel by using the [`Async.Parallel`](https://msdn.microsoft.com/library/aa9b0355-2d55-4858-b943-cbe428de9dc4) function together with the `Async.RunSynchronously` function. The `Async.Parallel` function takes a list of the `Async` objects, sets up the code for each `Async` task object to run in parallel, and returns an `Async` object that represents the parallel computation. Just as for a single operation, you call `Async.RunSynchronously` to start the execution.
 
@@ -73,4 +73,4 @@ The `runAll` function launches three asynchronous workflows in parallel and wait
 
 [Computation Expressions](computation-expressions.md)
 
-[Control.Async Class](https://msdn.microsoft.com/en-us/visualfsharpdocs/conceptual/control.async-class-%5bfsharp%5d)
+[Control.Async Class](https://msdn.microsoft.com/visualfsharpdocs/conceptual/control.async-class-%5bfsharp%5d)

docs/fsharp/language-reference/code-quotations.md

@@ -47,7 +47,7 @@ The F# PowerPack provides support for evaluating and executing F# expression obj
 
 
 ## Expr Type
-An instance of the `Expr` type represents an F# expression. Both the generic and the non-generic `Expr` types are documented in the F# library documentation. For more information, see [Microsoft.FSharp.Quotations Namespace](https://msdn.microsoft.com/en-us/visualfsharpdocs/conceptual/microsoft.fsharp.quotations-namespace-%5bfsharp%5d) and [Quotations.Expr Class](https://msdn.microsoft.com/en-us/visualfsharpdocs/conceptual/quotations.expr-class-%5bfsharp%5d).
+An instance of the `Expr` type represents an F# expression. Both the generic and the non-generic `Expr` types are documented in the F# library documentation. For more information, see [Microsoft.FSharp.Quotations Namespace](https://msdn.microsoft.com/visualfsharpdocs/conceptual/microsoft.fsharp.quotations-namespace-%5bfsharp%5d) and [Quotations.Expr Class](https://msdn.microsoft.com/visualfsharpdocs/conceptual/quotations.expr-class-%5bfsharp%5d).
 
 
 ## Splicing Operators
@@ -83,7 +83,7 @@ let f = fun (x:System.Int32) -> x + 10 in f 10
 ## Example
 
 ### Description
-You can also use the three active patterns in the [ExprShape module](https://msdn.microsoft.com/library/7685150e-2432-4d39-9338-57292eff18de) to traverse expression trees with fewer active patterns. These active patterns can be useful when you want to traverse a tree but you do not need all the information in most of the nodes. When you use these patterns, any F# expression matches one of the following three patterns: `ShapeVar` if the expression is a variable, `ShapeLambda` if the expression is a lambda expression, or `ShapeCombination` if the expression is anything else. If you traverse an expression tree by using the active patterns as in the previous code example, you have to use many more patterns to handle all possible F# expression types, and your code will be more complex. For more information, see [ExprShape.ShapeVar|ShapeLambda|ShapeCombination Active Pattern](https://msdn.microsoft.com/en-us/visualfsharpdocs/conceptual/exprshape.shapevarhshapelambdahshapecombination-active-pattern-%5bfsharp%5d).
+You can also use the three active patterns in the [ExprShape module](https://msdn.microsoft.com/library/7685150e-2432-4d39-9338-57292eff18de) to traverse expression trees with fewer active patterns. These active patterns can be useful when you want to traverse a tree but you do not need all the information in most of the nodes. When you use these patterns, any F# expression matches one of the following three patterns: `ShapeVar` if the expression is a variable, `ShapeLambda` if the expression is a lambda expression, or `ShapeCombination` if the expression is anything else. If you traverse an expression tree by using the active patterns as in the previous code example, you have to use many more patterns to handle all possible F# expression types, and your code will be more complex. For more information, see [ExprShape.ShapeVar|ShapeLambda|ShapeCombination Active Pattern](https://msdn.microsoft.com/visualfsharpdocs/conceptual/exprshape.shapevarhshapelambdahshapecombination-active-pattern-%5bfsharp%5d).
 
 The following code example can be used as a basis for more complex traversals. In this code, an expression tree is created for an expression that involves a function call, `add`. The [SpecificCall](https://msdn.microsoft.com/library/05a77b21-20fe-4b9a-8e07-aa999538198d) active pattern is used to detect any call to `add` in the expression tree. This active pattern assigns the arguments of the call to the `exprList` value. In this case, there are only two, so these are pulled out and the function is called recursively on the arguments. The results are inserted into a code quotation that represents a call to `mul` by using the splice operator (`%%`). The `println` function from the previous example is used to display the results.
 

docs/fsharp/language-reference/import-declarations-the-open-keyword.md

@@ -61,11 +61,11 @@ Some namespaces are so frequently used in F# code that they are opened implicitl
 |`Microsoft.FSharp.Text`|Contains functions for formatted IO, such as the `printf` function.|
 
 ## AutoOpen Attribute
-You can apply the `AutoOpen` attribute to an assembly if you want to automatically open a namespace or module when the assembly is referenced. You can also apply the `AutoOpen` attribute to a module to automatically open that module when the parent module or namespace is opened. For more information, see [Core.AutoOpenAttribute Class](https://stage.docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/core.autoopenattribute-class).
+You can apply the `AutoOpen` attribute to an assembly if you want to automatically open a namespace or module when the assembly is referenced. You can also apply the `AutoOpen` attribute to a module to automatically open that module when the parent module or namespace is opened. For more information, see [Core.AutoOpenAttribute Class](https://msdn.microsoft.com/visualfsharpdocs/conceptual/core.autoopenattribute-class-%5bfsharp%5d).
 
 
 ## RequireQualifiedAccess Attribute
-Some modules, records, or union types may specify the `RequireQualifiedAccess` attribute. When you reference elements of those modules, records, or unions, you must use a qualified name regardless of whether you include an import declaration. If you use this attribute strategically on types that define commonly used names, you help avoid name collisions and thereby make code more resilient to changes in libraries. For more information, see [Core.RequireQualifiedAccessAttribute Class](https://stage.docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/core.requirequalifiedaccessattribute-class).
+Some modules, records, or union types may specify the `RequireQualifiedAccess` attribute. When you reference elements of those modules, records, or unions, you must use a qualified name regardless of whether you include an import declaration. If you use this attribute strategically on types that define commonly used names, you help avoid name collisions and thereby make code more resilient to changes in libraries. For more information, see [Core.RequireQualifiedAccessAttribute Class](https://msdn.microsoft.com/visualfsharpdocs/conceptual/core.requirequalifiedaccessattribute-class-%5Bfsharp%5D).
 
 
 ## See Also

docs/fsharp/language-reference/lists.md

@@ -437,7 +437,7 @@ The `List` module provides functions for converting to and from both sequences a
 
 
 ### Additional Operations
-For information about additional operations on lists, see the library reference topic [Collections.List Module](https://msdn.microsoft.com/en-us/visualfsharpdocs/conceptual/collections.list-module-%5bfsharp%5d).
+For information about additional operations on lists, see the library reference topic [Collections.List Module](https://msdn.microsoft.com/visualfsharpdocs/conceptual/collections.list-module-%5bfsharp%5d).
 
 
 ## See Also

docs/fsharp/language-reference/literals.md

@@ -77,4 +77,4 @@ In pattern matching expressions, identifiers that begin with lowercase character
 
 ## See Also
 
-[Core.LiteralAttribute Class](https://msdn.microsoft.com/en-us/visualfsharpdocs/conceptual/core.literalattribute-class-%5bfsharp%5d)
+[Core.LiteralAttribute Class](https://msdn.microsoft.com/visualfsharpdocs/conceptual/core.literalattribute-class-%5bfsharp%5d)