[](https://dnceng.visualstudio.com/public/_build/latest?definitionId=686&branchName=master)
[](https://gitter.im/dotnet/runtime)
-This repo contains the code to build the .NET Core runtime, libraries and shared host (`dotnet`) installers for
-all supported platforms, as well as the sources to .NET Core runtime and libraries.
+This repo contains the code to build the .NET runtime, libraries and shared host (`dotnet`) installers for
+all supported platforms, as well as the sources to .NET runtime and libraries.
-## What is .NET Core?
+## What is .NET?
Official Starting Page: https://dotnet.microsoft.com/
## Filing issues
-This repo should contain issues that are tied to the runtime, the class libraries and frameworks, the installation of the `dotnet` binary (sometimes known as the `muxer`) and installation of the .NET Core runtime and libraries.
+This repo should contain issues that are tied to the runtime, the class libraries and frameworks, the installation of the `dotnet` binary (sometimes known as the `muxer`) and installation of the .NET runtime and libraries.
For other issues, please use the following repos:
-- For overall .NET Core SDK issues, file in the [dotnet/sdk](https://github.com/dotnet/sdk) repo
+- For overall .NET SDK issues, file in the [dotnet/sdk](https://github.com/dotnet/sdk) repo
- For ASP.NET issues, file in the [dotnet/aspnetcore](https://github.com/dotnet/aspnetcore) repo.
## Useful Links
## .NET Foundation
-.NET Core is a [.NET Foundation](https://www.dotnetfoundation.org/projects) project.
+.NET Runtime is a [.NET Foundation](https://www.dotnetfoundation.org/projects) project.
There are many .NET related projects on GitHub.
-.NET Core uses third-party libraries or other resources that may be
-distributed under licenses different than the .NET Core software.
+.NET Runtime uses third-party libraries or other resources that may be
+distributed under licenses different than the .NET Runtime software.
In the event that we accidentally failed to list a required notice, please
bring it to our attention. Post an issue or email us:
# Nullability annotations
-C# 8 provides an opt-in feature that allows for the compiler to track reference type nullability in order to catch potential null dereferences. We are adopting that feature across .NET Core's libraries, working up from the bottom of the stack. We're doing this for three primary reasons, in order of importance:
+C# 8 provides an opt-in feature that allows for the compiler to track reference type nullability in order to catch potential null dereferences. We are adopting that feature across .NET's libraries, working up from the bottom of the stack. We're doing this for three primary reasons, in order of importance:
-- **To annotate the .NET Core surface area with appropriate nullability annotations.** While this could be done solely in the reference assemblies, we're doing it first in the implementation to help validate the selected annotations.
+- **To annotate the .NET surface area with appropriate nullability annotations.** While this could be done solely in the reference assemblies, we're doing it first in the implementation to help validate the selected annotations.
- **To help validate the nullability feature itself.** With millions of lines of C# code, we have a very large and robust codebase with which to try out the feature and find areas in which it shines and areas in which we can improve it. The work to annotate System.Private.CoreLib in .NET Core 3.0 helped to improve the feature as shipped in C# 8, and annotating the rest of the libraries will continue to be helpful in this regard.
-- **To find null-related bugs in .NET Core itself.** We expect to find relatively few meaningful bugs, due to how relatively well-tested the codebases are and how long they've been around.
+- **To find null-related bugs in .NET Runtime itself.** We expect to find relatively few meaningful bugs, due to how relatively well-tested the codebases are and how long they've been around.
## Breaking Change Guidance
We’ll use the following scenarios when defining priorities:
-- P1: Performance analysis in support of bring-up of the .NET Core runtime and framework on Linux and OS X.
+- P1: Performance analysis in support of bring-up of the .NET runtime and framework on Linux and OS X.
- P2: Performance analysis of ASP.NET running on .NET Core on Linux and OS X.
To support these scenarios, we need the following capabilities:
## Types of LoadContext
### Default LoadContext
-Every .NET Core app has a **LoadContext** instance created during .NET Core Runtime startup that we will refer to as the *Default LoadContext*. All application assemblies (including their transitive closure) are loaded within this **LoadContext** instance.
+Every .NET app has a **LoadContext** instance created during .NET Runtime startup that we will refer to as the *Default LoadContext*. All application assemblies (including their transitive closure) are loaded within this **LoadContext** instance.
### Custom LoadContext
For scenarios that wish to have isolation between loaded assemblies, applications can create their own **LoadContext** instance by deriving from **System.Runtime.Loader.AssemblyLoadContext** type and loading the assemblies within that instance.
## Constraints
-* **System.Private.CoreLib.dll** is only loaded once, and into the **Default LoadContext**, during the .NET Core Runtime startup as it is a logical extension of the same. It cannot be loaded into **Custom LoadContext**.
+* **System.Private.CoreLib.dll** is only loaded once, and into the **Default LoadContext**, during the .NET Runtime startup as it is a logical extension of the same. It cannot be loaded into **Custom LoadContext**.
* Currently, custom **LoadContext** cannot be unloaded once created. This is a feature we are looking into for a future release.
* If an attempt is made to load a [Ready-To-Run (R2R)](https://github.com/dotnet/runtime/blob/master/docs/design/coreclr/botr/readytorun-overview.md) image from the same location in multiple load context's, then precompiled code can only be used from the first image that got loaded. The subsequent images will have their code JITted. This happens because subsequent loading binaries from the same location results in OS mapping them to the same memory as the previous one was mapped to and thus, could corrupt internal state information required for use precompiled code.
## Host Policy
The host policy library implements all the policies to actually load the runtime, apply configuration, resolve all app's dependencies and calls the runtime to run the app or load the required component.
-The host policy library lives in the runtime folder and is versioned alongside it. Which version is used is specified by the app as it specifies which version of the .NET Core runtime to use (done directly or indirectly by referencing the `Microsoft.NETCore.App` framework, or carrying everything app-local).
+The host policy library lives in the runtime folder and is versioned alongside it. Which version is used is specified by the app as it specifies which version of the .NET runtime to use (done directly or indirectly by referencing the `Microsoft.NETCore.App` framework, or carrying everything app-local).
Host policy library reads the `.deps.json` file of the app (and the `.deps.json` of all the referenced frameworks). It resolves all the assemblies specified in the `.deps.json` for the app and frameworks and creates a list of assembly paths (also called TPA). It does a similar thing for native dependencies as well.
This URL is part of the output of `dotnet --info`:
```console
-To install additional .NET Core runtimes or SDKs:
+To install additional .NET runtimes or SDKs:
https://aka.ms/dotnet-download
```
It's also part of the error when an SDK command is executed and there's no SDK installed:
```
- It was not possible to find any installed .NET Core SDKs
- Did you mean to run .NET Core SDK commands? Install a .NET Core SDK from:
+ It was not possible to find any installed .NET SDKs
+ Did you mean to run .NET SDK commands? Install a .NET SDK from:
https://aka.ms/dotnet-download
```
* `LibHostInitFailure` (`0x8000808e`) - Initialization of the `hostpolicy` library failed. The `corehost_load` method takes a structure with lot of initialization parameters. If the version of this structure doesn't match the expected value, this error code is returned. This would in general mean incompatibility between the `hostfxr` and `hostpolicy`, which should really only happen if somehow a newer `hostpolicy` is used by older `hostfxr`. This typically means corrupted installation.
-* `LibHostSdkFindFailure` (`0x80008091`) - Failure to find the requested SDK. This happens in the `hostfxr` when an SDK (also called CLI) command is used with `dotnet`. In this case the hosting layer tries to find an installed .NET Core SDK to run the command on. The search is based on deduced install location and on the requested version from potential `global.json` file. If either no matching SDK version can be found, or that version exists, but it's missing the `dotnet.dll` file, this error code is returned.
+* `LibHostSdkFindFailure` (`0x80008091`) - Failure to find the requested SDK. This happens in the `hostfxr` when an SDK (also called CLI) command is used with `dotnet`. In this case the hosting layer tries to find an installed .NET SDK to run the command on. The search is based on deduced install location and on the requested version from potential `global.json` file. If either no matching SDK version can be found, or that version exists, but it's missing the `dotnet.dll` file, this error code is returned.
* `LibHostInvalidArgs` (`0x80008092`) - Arguments to `hostpolicy` are invalid. This is used in three unrelated places in the `hostpolicy`, but in all cases it means the component calling `hostpolicy` did something wrong:
* Command line arguments for the app - the failure would typically mean that wrong argument was passed or such. For example if the application main assembly is not specified on the command line. On its own this should not happen as `hostfxr` should have parsed and validated all command line arguments.
The .NET Core host and runtime contain messages that can be displayed to both end-users and developers. Currently, all such messages are displayed in English.
-Other managed components built on top of .NET Core (e.g. SDK, WinForms, WPF) have already been localized, so a process already exists for handling translation and localizing assets, while the .NET Core runtime handles satellite assembly loading. The host and runtime are different in that they have messages that originate from native components and must continue to do so. While the runtime does contain some managed resources, this document focusses on localization of native resources.
+Other managed components built on top of .NET Runtime (e.g. SDK, WinForms, WPF) have already been localized, so a process already exists for handling translation and localizing assets, while the runtime handles satellite assembly loading. The host and runtime are different in that they have messages that originate from native components and must continue to do so. While the runtime does contain some managed resources, this document focusses on localization of native resources.
The goal is to support:
Each host component will include English resource strings by default. If the resource for the appropriate locale could not be found, the host components can always fall back to English.
-`dotnet`, `hostfxr`, and `hostpolicy` will each have separate resources that will be installed by the .NET Core runtime. These components can be different versions, so their resources must be separate.
+`dotnet`, `hostfxr`, and `hostpolicy` will each have separate resources that will be installed by the .NET runtime. These components can be different versions, so their resources must be separate.
`apphost` will have a single localized message. All languages will be included in the executable itself. The message will direct the user to a URL that will contain localized content.
- If the hosts are newer than installed runtime, new messages would not be localized
- Issues:
- Compatibility concerns for resource IDs / format values
- - Awkward split deployment since `*host` components are not normally part of the .NET Core runtime install
+ - Awkward split deployment since `*host` components are not normally part of the .NET runtime install
- Options:
1. Separate resource for each host
`comhost`, `ijwhost`, `winrthost`, and `nethost` are designed to be consumed by a component that .NET Core does not own and intentionally do not show messages to the user. As such, they sit at a low priority for localization support.
-`apphost` is the end-user-facing host. The amount of logic and messaging in `apphost` is intentionally limited. The most important message it contains for an end-user is for the missing .NET Core runtime scenario, so it should not rely on resources installed via the .NET Core runtime.
+`apphost` is the end-user-facing host. The amount of logic and messaging in `apphost` is intentionally limited. The most important message it contains for an end-user is for the missing .NET runtime scenario, so it should not rely on resources installed via the .NET runtime.
Embedding resources in the `apphost` would make for the most stream-lined user experience (particularly around deployment). Since the `apphost` is sensitive to size, the number of messages will be pared down to one generic localized message which directs the user to a URL.
Each platform has its own standard way and file formats for handling localization. There are two main approaches that can be taken here:
1. Convert a base format to platform-specific localization formats and use platform-specific localization support
- Requires a tool/script to convert file formats at build time
- - Uses platform support and standard localization methods that the .NET Core team will not need to maintain
+ - Uses platform support and standard localization methods that the .NET team will not need to maintain
- Different method for handling localized resources on each platform
2. Create a custom solution: storage format for string resources, tools for generation from the [translated assets (.xlf)](#translated-assets), and implementation for reading
- - Requires design of completely custom support that will need to be maintained by the .NET Core team on all platforms
+ - Requires design of completely custom support that will need to be maintained by the .NET team on all platforms
- Allows support for both string resources from file or memory
- All platforms could use the same method for handling localized resources
# Native hosting
-Native hosting is the ability to host the .NET Core runtime in an arbitrary process, one which didn't start from .NET Core produced binaries.
+Native hosting is the ability to host the .NET runtime in an arbitrary process, one which didn't start from .NET Core produced binaries.
#### Terminology
* "native host" - the code which uses the proposed APIs. Can be any non .NET Core application (.NET Core applications have easier ways to perform these scenarios).
## Existing support
* **C-style ABI in `coreclr`**
-`coreclr` exposes ABI to host the .NET Core runtime and run managed code already using C-style APIs. See this [header file](https://github.com/dotnet/runtime/blob/master/src/coreclr/src/hosts/inc/coreclrhost.h) for the exposed functions.
-This API requires the native host to locate the runtime and to fully specify all startup parameters for the runtime. There's no inherent interoperability between these APIs and the .NET Core SDK.
+`coreclr` exposes ABI to host the .NET runtime and run managed code already using C-style APIs. See this [header file](https://github.com/dotnet/runtime/blob/master/src/coreclr/src/hosts/inc/coreclrhost.h) for the exposed functions.
+This API requires the native host to locate the runtime and to fully specify all startup parameters for the runtime. There's no inherent interoperability between these APIs and the .NET SDK.
* **COM-style ABI in `coreclr`**
-`coreclr` exposes COM-style ABI to host the .NET Core runtime and perform a wide range of operations on it. See this [header file](https://github.com/dotnet/runtime/blob/master/src/coreclr/src/pal/prebuilt/inc/mscoree.h) for more details.
+`coreclr` exposes COM-style ABI to host the .NET runtime and perform a wide range of operations on it. See this [header file](https://github.com/dotnet/runtime/blob/master/src/coreclr/src/pal/prebuilt/inc/mscoree.h) for more details.
Similarly to the C-style ABI the COM-style ABI also requires the native host to locate the runtime and to fully specify all startup parameters.
-There's no inherent interoperability between these APIs and the .NET Core SDK.
+There's no inherent interoperability between these APIs and the .NET SDK.
The COM-style ABI is deprecated and should not be used going forward.
* **`hostfxr` and `hostpolicy` APIs**
The hosting layer of .NET Core already exposes some functionality as C-style ABI on either the `hostfxr` or `hostpolicy` libraries. These can execute application, determine available SDKs, determine native dependency locations, resolve component dependencies and so on.
-Unlike the above `coreclr` based APIs these don't require the caller to fully specify all startup parameters, instead these APIs understand artifacts produced by .NET Core SDK making it much easier to consume SDK produced apps/libraries.
+Unlike the above `coreclr` based APIs these don't require the caller to fully specify all startup parameters, instead these APIs understand artifacts produced by .NET SDK making it much easier to consume SDK produced apps/libraries.
The native host is still required to locate the `hostfxr` or `hostpolicy` libraries. These APIs are also designed for specific narrow scenarios, any usage outside of these bounds is typically not possible.
## Scope
-This document focuses on hosting which cooperates with the .NET Core SDK and consumes the artifacts produced by building the managed app/libraries directly. It completely ignores the COM-style ABI as it's hard to use from some programming languages.
+This document focuses on hosting which cooperates with the .NET SDK and consumes the artifacts produced by building the managed app/libraries directly. It completely ignores the COM-style ABI as it's hard to use from some programming languages.
As such the document explicitly excludes any hosting based on directly loading `coreclr`. Instead it focuses on using the existing .NET Core hosting layer in new ways. For details on the .NET Core hosting components see [this document](https://github.com/dotnet/runtime/tree/master/docs/design/features/host-components.md).
## New host binary for finding `hostfxr`
New library `nethost` which provides a way to locate the right `hostfxr`.
This is a dynamically loaded library (`.dll`, `.so`, `.dylib`). For ease of use there is a header file for C/C++ apps as well as `.lib` for easy linking on Windows.
-Native hosts ship this library as part of the app. Unlike the `apphost`, `comhost` and `ijwhost`, the `nethost` will not be directly supported by the .NET Core SDK since it's target usage is not from .NET Core apps.
+Native hosts ship this library as part of the app. Unlike the `apphost`, `comhost` and `ijwhost`, the `nethost` will not be directly supported by the .NET SDK since it's target usage is not from .NET Core apps.
The `nethost` is part of the `Microsoft.NETCore.DotNetAppHost` package. Users are expected to either download the package directly or rely on .NET SDK to pull it down.
+++ /dev/null
-# .NET Core Applications
-
-NETCoreApp is the [target framework](https://docs.nuget.org/Create/TargetFrameworks) that represents .NET Core applications
-
-Property | Value
----------|---------
-Target framework identifier | `.NETCoreApp`
-Target framework version | `3.0`
-Target framework moniker | `.NETCoreApp,Version=v3.0`
-Friendly name | .NET Core Application
-NuGet folder name | `netcoreapp3.0`
-NETStandard version supported | `netstandard2.1`
-
-## FAQ
-**Q: What is a .NET Core application?**
-**A:** A .NET Core application is an application that can run on any .NET Core runtime: CoreCLR (current), Mono (future). It can run on one of many .NET core platforms (Windows, OSX, Linux). It relies on the host provided by the given runtime. It's a composable framework built from the packages on which the application depends. Its assembly loading policy permits newer versions of dependencies without any application configuration (e.g.: BindingRedirects are not required).
-
-**Q: Can I share source between a .NET Core application, and other target frameworks?**
-**A:** Yes. Most of the API supported by .NET Core application is also part of .NET Standard. That source could be compiled as a .NET Standard library and shared with a .NET Core application and a .NET Framework application as a binary. Alternatively, the source could be shared and cross-compiled between a .NET Core application and a .NET Framework application.
-
-**Q: Can a .NET Core application depend on more packages than just those in the `Microsoft.NETCore.App` package?**
-**A:** Yes. The contents of `Microsoft.NETCore.App` at a particular version are guaranteed to run on every platform where that version .NET Core is released. Packages outside this set can be used but don't come with that guarantee. For instance, if a package is not part of `Microsoft.NETCore.App` and needs to be cross-compiled specifically for a new OS, there is no guarantee that it will be re-released when .NET Core supports that new OS.
-
-**Q: Can a .NET Core application depend on platform specific packages like `Microsoft.Win32.Registry`?**
-**A:** Yes, but it will only run on the platforms that support those packages.
-
-**Q: How is this different than `.NETCore`?**
-**A:** The `.NETCore` target framework represents Windows 8, Windows 8.1, and Universal Windows Platform applications. For compatibility purposes this moniker cannot be reused for “.NET Core applications”. The branding overlap is unfortunate.
-
-**Q: How is this different than `.NETStandard`?**
-**A:** The `NETStandard` target framework is an abstract target framework that represents API surface of many frameworks and platforms. As such `NETStandard` assemblies can run on any platform that supports the `NETStandard` targeted by that assembly, for example: .NET Desktop, Windows Phone, Universal Windows Platform applications, .NET Core applications, etc. `NETCoreApplication` is a concrete target framework that represents a single platform with both API surface and implementation. .NET Core applications are runnable on their own. .NETStandard libraries must be published-for or consumed-by a specific concrete target framework to be used in that type of application.
-
-**Q: How is this different than `.NETFramework`, AKA: Full .NET, Desktop .NET, Big .NET, old .NET?**
-**A:** `.NETFramework` is another concrete framework like `.NETCoreApp` but has a different implementation and runtime and supports a different set of API. Both `.NETFramework` and `.NETCoreApp` support a common version of `.NETStandard` and the API it exposes. As such a `.NETStandard` assembly can be used by both `.NETFramework` and `.NETCoreApp`, but a `.NETCoreApp` assembly is not meant to run on `.NETFramework`, nor is a `.NETFramework` assembly meant to run on `.NETCoreApp`.
Tiered compilation is enabled by default from .NET Core 2.2 preview 2 and in 3.0 daily builds.
-- Download the .NET Core SDK from the [download archives](https://www.microsoft.com/net/download/archives)
+- Download the .NET SDK from the [download archives](https://www.microsoft.com/net/download/archives)
- For the latest pre-release installers, download a [daily build](https://github.com/dotnet/core/blob/master/daily-builds.md)
- For .NET Core 2.1 and 2.2 preview 1, tiered compilation may be enabled in any of the following ways ([instructions](https://github.com/aspnet/JitBench/blob/tiered_compilation_demo/README.md#16-run-the-app-with-tiered-compilation-enabled)):
- In `<app>.csproj` before the build
- With an environment variable before running the app (in a console, or at user or system level)
- Ensure that the `<app>.csproj` is targeting the correct `TargetFramework` and `RuntimeFrameworkVersion`
- `TargetFramework` should be `netcoreapp3.0` or `netcoreapp2.2`, etc.
- - `RuntimeFrameworkVersion` should be a .NET Core runtime version corresponding to the above
+ - `RuntimeFrameworkVersion` should be a .NET runtime version corresponding to the above
- `dotnet --info` lists the available runtimes versions, use the version for Microsoft.NETCore.App
- For .NET Core 2.2 preview 2, it is `2.2.0-preview2-26905-02`
- Run the app, and see [the demo](https://github.com/aspnet/JitBench/blob/tiered_compilation_demo/README.md#part-2---exploring-the-application-behavior) about how to see tiered compilation in action
Copyright
=========
-The .NET Core copyright is held by ".NET Foundation and Contributors".
+The .NET project copyright is held by ".NET Foundation and Contributors".
The [.NET Foundation](http://www.dotnetfoundation.org/) is an independent organization that encourages open development and collaboration around the .NET ecosystem.
Source License
--------------
-The .NET Core project uses multiple licenses for the various project repositories.
+The .NET project uses multiple licenses for the various project repositories.
-- The [MIT License](https://opensource.org/licenses/MIT) is used by most repositories for [code](https://github.com/dotnet/runtime/).
-- The [Apache 2 License](https://opensource.org/licenses/Apache-2.0) is also used by some projects for [code](https://github.com/dotnet/roslyn/).
+- The [MIT License](https://opensource.org/licenses/MIT) is used for [code](https://github.com/dotnet/runtime/).
- The [Creative Commons Attribution 4.0 International Public License (CC-BY)](https://creativecommons.org/licenses/by/4.0/) is used for [documentation](https://github.com/dotnet/docs/) and [swag](https://github.com/dotnet/swag).
Binary License
--------------
-.NET Core distributions are licensed with a variety of licenses, dependent on the content. By default, the MIT license is used, the exact same as the [source license](https://github.com/dotnet/core/blob/master/LICENSE.TXT), with the same copyright holder. There are some cases where that isn't possible because a given component includes a proprietary Microsoft binary. This is typically only the case for Windows distributions.
+.NET distributions are licensed with a variety of licenses, dependent on the content. By default, the MIT license is used, the exact same as the [source license](https://github.com/dotnet/core/blob/master/LICENSE.TXT), with the same copyright holder. There are some cases where that isn't possible because a given component includes a proprietary Microsoft binary. This is typically only the case for Windows distributions.
The following rules are used for determining the binary license:
-- .NET Core binary distributions (zips, nuget packages, …) are licensed as MIT (identical to the [.NET Core source license](https://github.com/dotnet/core/blob/master/LICENSE.TXT)).
-- The license link (if there is one) should point to the repository where the file came from, for example: [dotnet/corefx](https://github.com/dotnet/runtime/blob/master/LICENSE.TXT).
-- If the contained binaries are built from multiple .NET Core repositories, the license should point to [dotnet/core](https://github.com/dotnet/core/blob/master/LICENSE.TXT).
+- .NET binary distributions (zips, nuget packages, …) are licensed as MIT (identical to the [.NET source license](https://github.com/dotnet/core/blob/master/LICENSE.TXT)).
+- The license link (if there is one) should point to the repository where the file came from, for example: [dotnet/runtime](https://github.com/dotnet/runtime/blob/master/LICENSE.TXT).
+- If the contained binaries are built from multiple .NET repositories, the license should point to [dotnet/core](https://github.com/dotnet/core/blob/master/LICENSE.TXT).
- If the contents are not 100% open source, the distribution should be licensed with the [.NET Library license](https://www.microsoft.com/net/dotnet_library_license.htm).
-- It is OK for licensing to be asymmetric for a single distribution type. For example, it’s possible that the .NET Core SDK distribution might be fully open source for Linux but include a closed-source component on Windows. In this case, the SDK would be licensed as MIT on Linux and use the .NET Library License on Windows. It is better to have more open licenses than less.
+- It is OK for licensing to be asymmetric for a single distribution type. For example, it’s possible that the .NET SDK distribution might be fully open source for Linux but include a closed-source component on Windows. In this case, the SDK would be licensed as MIT on Linux and use the .NET Library License on Windows. It is better to have more open licenses than less.
- It is OK for the source and binary licenses not to match. For example, the source might be Apache 2 but ships as an MIT binary. The third party notices file should capture the Apache 2 license. This only works for a permissive licenses, however, we have limited the project to that class of licenses already. The value of this approach is that binary licenses are uniform.
Patents
# How to get up and running on .NET Core
This document provides the steps necessary to consume a nightly build of
-.NET Core runtime and SDK.
+.NET runtime and SDK.
Please note that these steps are likely to change as we're simplifying
this experience. Make sure to consult this document often.
## Install prerequisites
-1. Acquire the latest nightly .NET Core SDK by downloading the zip or tarball listed in https://github.com/dotnet/core-sdk#installers-and-binaries (for example, https://dotnetcli.blob.core.windows.net/dotnet/Sdk/master/dotnet-sdk-latest-win-x64.zip ) into a new folder, for instance `C:\dotnet`.
+1. Acquire the latest nightly .NET SDK by downloading the zip or tarball listed in https://github.com/dotnet/core-sdk#installers-and-binaries (for example, https://dotnetcli.blob.core.windows.net/dotnet/Sdk/master/dotnet-sdk-latest-win-x64.zip ) into a new folder, for instance `C:\dotnet`.
2. By default, the dotnet CLI will use the globally installed SDK if it matches the major/minor version you request and has a higher revision. To force it to use the locally installed SDK, you must set an environment variable `DOTNET_MULTILEVEL_LOOKUP=0` in your shell. You can use `dotnet --info` to verify what version of the Shared Framework it is using.
-3. Reminder: if you are using a local copy of the dotnet CLI, take care that when you type `dotnet` you do not inadvertently pick up a different copy that you may have in your path. On Windows, for example, if you use a Command Prompt, a global copy may be in the path, so use the fully qualified path to your local `dotnet` (e.g. `C:\dotnet\dotnet.exe`). If you receive an error "error NETSDK1045: The current .NET SDK does not support targeting .NET Core 3.0." then you may be executing an older `dotnet`.
+3. Reminder: if you are using a local copy of the dotnet CLI, take care that when you type `dotnet` you do not inadvertently pick up a different copy that you may have in your path. On Windows, for example, if you use a Command Prompt, a global copy may be in the path, so use the fully qualified path to your local `dotnet` (e.g. `C:\dotnet\dotnet.exe`). If you receive an error "error NETSDK1045: The current .NET SDK does not support targeting .NET Core 5.0." then you may be executing an older `dotnet`.
After setting up dotnet you can verify you are using the dogfooding version by executing `dotnet --info`. Here is an example output at the time of writing:
```
>dotnet --info
.NET Core SDK (reflecting any global.json):
- Version: 3.0.100-preview-009844
- Commit: fa073dacc4
+ Version: 5.0.100-preview.1.20167.6
+ Commit: 00255dd10b
Runtime Environment:
OS Name: Windows
- OS Version: 10.0.17134
+ OS Version: 10.0.18363
OS Platform: Windows
RID: win10-x64
- Base Path: C:\dotnet\sdk\3.0.100-preview-009844\
+ Base Path: c:\dotnet\sdk\5.0.100-preview.1.20167.6\
Host (useful for support):
- Version: 3.0.0-preview-27218-01
- Commit: d40b87f29d
+ Version: 5.0.0-preview.1.20120.5
+ Commit: 3c523a6a7a
.NET Core SDKs installed:
- 3.0.100-preview-009844 [C:\dotnet\sdk]
+ 5.0.100-preview.1.20167.6 [c:\dotnet\sdk]
.NET Core runtimes installed:
- Microsoft.AspNetCore.App 3.0.0-preview-18579-0056 [C:\dotnet\shared\Microsoft.AspNetCore.App]
- Microsoft.NETCore.App 3.0.0-preview-27218-01 [C:\dotnet\shared\Microsoft.NETCore.App]
- Microsoft.WindowsDesktop.App 3.0.0-alpha-27218-3 [C:\dotnet\shared\Microsoft.WindowsDesktop.App]
+ Microsoft.AspNetCore.App 5.0.0-preview.1.20124.5 [c:\dotnet\shared\Microsoft.AspNetCore.App]
+ Microsoft.NETCore.App 5.0.0-preview.1.20120.5 [c:\dotnet\shared\Microsoft.NETCore.App]
+ Microsoft.WindowsDesktop.App 5.0.0-preview.1.20127.5 [c:\dotnet\shared\Microsoft.WindowsDesktop.App]
To install additional .NET Core runtimes or SDKs:
https://aka.ms/dotnet-download
## Advanced Scenario - Using a nightly build of Microsoft.NETCore.App
When using the above instructions, your application will run against the same
-.NET Core runtime that comes with the SDK. That works fine to get up and
+.NET runtime that comes with the SDK. That works fine to get up and
running quickly. However, there are times when you need to use a nightly build
of Microsoft.NETCore.App which hasn't made its way into the SDK yet. To enable
this, there are two options you can take.
### Option 1: Framework-dependent
-This is the default case for applications - running against an installed .NET Core
-runtime.
+This is the default case for applications - running against an installed .NET runtime.
-1. You still need to install the prerequisite .NET Core SDK from above.
-2. Optionally, install the specific .NET Core runtime you require:
+1. You still need to install the prerequisite .NET SDK from above.
+2. Optionally, install the specific .NET runtime you require:
- https://github.com/dotnet/core-sdk#installers-and-binaries
3. Modify your .csproj to reference the nightly build of Microsoft.NETCore.App
<PropertyGroup>
<OutputType>Exe</OutputType>
<!-- Ensure that the target framework is correct e.g. 'netcoreapp5.0' -->
- <TargetFramework>netcoreapp3.0</TargetFramework>
- <!-- modify version in this line with one reported by `dotnet --info` under ".NET Core runtimes installed" -> Microsoft.NETCore.App -->
- <RuntimeFrameworkVersion>3.0.0-preview-27225-1</RuntimeFrameworkVersion>
+ <TargetFramework>netcoreapp5.0</TargetFramework>
+ <!-- modify version in this line with one reported by `dotnet --info` under ".NET runtimes installed" -> Microsoft.NETCore.App -->
+ <RuntimeFrameworkVersion>5.0.0-preview.1.20120.5</RuntimeFrameworkVersion>
</PropertyGroup>
```
### Option 2: Self-contained
-In this case, the .NET Core runtime will be published along with your application.
+In this case, the .NET runtime will be published along with your application.
-1. You still need to install the prerequisite .NET Core SDK from above.
+1. You still need to install the prerequisite .NET SDK from above.
2. Modify your .csproj to reference the nightly build of Microsoft.NETCore.App *and*
make it self-contained by adding a RuntimeIdentifier (RID).
<PropertyGroup>
<OutputType>Exe</OutputType>
<!-- Ensure that the target framework is correct e.g. 'netcoreapp5.0' -->
- <TargetFramework>netcoreapp3.0</TargetFramework>
- <!-- modify build in this line with version reported by `dotnet --info` as above under ".NET Core runtimes installed" -> Microsoft.NETCore.App -->
+ <TargetFramework>netcoreapp5.0</TargetFramework>
+ <!-- modify build in this line with version reported by `dotnet --info` as above under ".NET runtimes installed" -> Microsoft.NETCore.App -->
<!-- moreover, this can be any valid Microsoft.NETCore.App package version from https://dotnetfeed.blob.core.windows.net/dotnet-core/index.json -->
- <RuntimeFrameworkVersion>3.0.0-preview-27218-01</RuntimeFrameworkVersion>
+ <RuntimeFrameworkVersion>5.0.0-preview.1.20120.5</RuntimeFrameworkVersion>
<RuntimeIdentifier>win-x64</RuntimeIdentifier> <!-- RID to make it self-contained -->
</PropertyGroup>
```
```
$ dotnet restore
$ dotnet publish
-$ bin\Debug\netcoreapp3.0\win-x64\publish\App.exe
+$ bin\Debug\netcoreapp5.0\win-x64\publish\App.exe
```
## More Advanced Scenario - Using your local CoreFx build
-# EventPipe and dotnet-trace (.NET Core 3.0 Preview 5 or later)
+# EventPipe and dotnet-trace (.NET Core 3.0 or later)
## Intro ##
EventPipe is a new cross-platform tracing mechanism we built into the runtime from .NET Core 3.0. It works the same across all platforms we support (Windows, macOS, and Linux), and we have built various diagnostics tools on top of it. dotnet-trace is a dotnet CLI tool that allows you to trace your .NET application using EventPipe.
## Installing dotnet-trace ##
dotnet-trace can be installed by using the dotnet CLI:
```
-dotnet tool install --global dotnet-trace --version 1.0.4-preview6.19311.1
+dotnet tool install --global dotnet-trace
```
## Collecting a trace ##
+++ /dev/null
-# Porting to .NET Core
-
-The purpose of this document is to share the plans on how we're going to port more APIs to .NET Core.
-
-## Summary
-
-Compared to other .NET stacks, specifically the .NET Framework, Mono, Unity, and Xamarin the .NET Core platform doesn't expose enough APIs. This makes porting assets to .NET Core quite challenging, especially for areas which don't have replacements.
-
-So we want to bring more APIs to .NET Core. In order to keep our promise of being open and transparent, we want to:
-
-* Clearly communicate what we plan on porting, how we prioritize, what we don't want to port, and how we're thinking of cross-platform and compatibility.
-* Avoid being the bottleneck by allowing community members to help with porting.
-
-## Prioritization
-
-As of today, .NET Core supports three app models:
-
-* **ASP.NET apps and services**
-* **Console apps**
-* **Universal Windows Platform (UWP) apps**
-
-We'll prioritize APIs that affect the ability to write those kind of apps over app models that .NET Core currently doesn't support (such as building desktop applications). Please note that this doesn't mean that we'll never port the other APIs -- it just means those rank lower.
-
-The same is true for platforms: the implementation of .NET Framework only runs on Windows. Our goal for .NET Core is to support the following platforms:
-
-* Windows
-* OS X
-* Linux
-
-(Please note that the specific version numbers, editions, and distros aren't fully finalized yet.)
-
-While we try to be mindful of other ports actively happening (such a BSD Unix), we prioritize those three platforms. It's also worth pointing out that we generally don't prioritize within these platforms; in other words we consider them all as equals. Of course, we start from a Windows implementation so the support is currently more complete there. Also, we're mindful of the ways developers are most likely to use the platforms as well. For instance, many web developers debug and test on OS X but deploy to Linux. This guides us when prioritizing work to address point-in-time issues.
-
-We determine which APIs are critical by leveraging various data sources:
-
-* **Community feedback** (such as GitHub, UserVoice)
-* **Partner feedback** (1st party and 3rd party applications)
-* **API usage of existing applications** (such as submissions from API Port, ASP.NET applications, and Silverlight based phone apps)
-
-We obviously aren't going to use a fixed formula to determine the stack rank of an API. We'll also leverage the experience from long term members on the team and combine it with the data and feedback to make intelligent decisions. For the sake of transparency we'll share all the data we have and the factors that lead to a specific decision. So if a decision we make is problematic for a part of the .NET ecosystem, such as not including the interfaces of ADO.NET for ORM providers, we can adjust as we go.
-
-## Mechanics
-
-For the most part, the source code for .NET Framework and .NET Core is disjoint. In other words, porting code to .NET Core isn't an exercise of checking a box -- it requires active work.
-
-Here is the summary of the activities involved:
-
-* Decide which APIs should go into .NET Core
-* Assess implications on componentization (see guidelines for more details)
-* Assess cross-platform impact. If necessary, find out how, and even if, the current design can be supported on all supported platforms
-* Get the code onto GitHub (this includes some minor clean up, such as running the code formatting tool)
-* Produce packages
-* Port corresponding tests
-
-## Porting Guidelines
-
-Here are the high level guidelines:
-
-* **Do not** port APIs of technologies we don't want to support moving forward (see list below).
-* **Do not** port APIs marked as obsolete.
-* **Consider** porting APIs even if considered legacy, problematic, or otherwise inadequate.
-* **Do** factor assemblies appropriately in order to preserve the componentization, specifically:
- - **Do not** add dependencies from non-legacy to legacy components.
- - **Do not** expose Windows-only technologies in otherwise fully portable assemblies.
- - **Do** factor large chunks of functionality that cannot be supported everywhere into their own assemblies.
- - **Do** consider using tester-doer patterns if only a very small number of APIs cannot be supported in all environments.
-* **Consider** using extension methods and partial facades to accelerate bringing revised APIs to the .NET Framework.
-* **Avoid** making changes that result in loss of binary and/or source compatibility between the .NET Framework and .NET Core.
-* **Avoid** "franken-designs" with extension methods and partial facades purely for the sake of .NET Framework compatibility.
-
-## Unsupported Technologies
-
-Feature owners reserve the right to call out what they don't want to support on .NET Core. Since .NET Core is a new platform, we don't want to penalize our ability to build a componentized and cross-platform stack by signing up for technologies that are expensive to bring into this world and we don't think are sensible for today's needs.
-
-This list, while not complete, is meant as a reference point. We'll add to it as we refine our porting plan. Also, just because something is currently not implemented, doesn't imply it's intentionally unsupported. Feel free to [file an issue](https://github.com/dotnet/runtime/issues/new) to ask for specific APIs and technologies. Porting requests are generally marked as [port-to-core](https://github.com/dotnet/runtime/issues?q=is%3Aopen+is%3Aissue+label%3Aport-to-core).
-
-Binary Serialization is supported post 1.1, however we do not support cross-platform binary serialization. For new code you may want to consider other serialization approaches such as data contract serialization, XML serialization, JSON.NET, and protobuf-net.
-
-Technology | More information
----------------------------|-----------------------------------
-AppDomains | [Details](#app-domains)
-Remoting | [Details](#remoting)
-Code Access Security (CAS) | [Details](#code-access-security-cas)
-Security Transparency | [Details](#security-transparency)
-
-### App Domains
-
-**Justification**. AppDomains require runtime support and are generally quite expensive. They are not implemented in .NET Core. We do not plan on adding this capability in future.
-
-**Replacement**. AppDomains were used for different features; for isolation we recommend processes and/or containers. For dynamic loading, we provide `AssemblyLoadContext`. Information (such as the name and base directory) is provided by APIs on other types, for instance `AppContext.BaseDirectory`. Some scenarios, such as getting the list of loaded assemblies are unsupported as they are inherently fragile.
-
-To make code migration from .NET Framework easier, we have exposed some of the `AppDomain` API surface in .NET Core. Some of the APIs work fine (e.g. `UnhandledException`), some of them do nothing (e.g. `SetCachePath`) and some of them throw `PlatformNotSupportedException` (e.g. `CreateDomain`). See more details about particular API differences in [TODO](https://github.com/dotnet/corefx/issues/18405).
-
-### Remoting
-
-**Justification**. The idea of .NET remoting -- which is transparent remote procedure calls -- has been identified as a problematic architecture. Outside of that realm, it's also used for cross AppDomain communication which is no longer supported. On top of that, remoting requires runtime support and is quite heavyweight.
-
-**Replacement**. For communication across processes, inter-process communication (IPC) should be used, such as pipes or memory mapped files. Across machines, you should use a network based solution, preferably `System.Net.Sockets` (see sample - [TODO](https://github.com/dotnet/corefx/issues/18394)).
-
-### Code Access Security (CAS)
-
-**Justification**. Sandboxing, i.e. relying on the runtime or the framework to constrain which resources a managed application or library can run is [not supported on .NET Framework](https://msdn.microsoft.com/en-us/library/c5tk9z76(v=vs.110).aspx) and therefore is also not supported on .NET Core. We believe that there are simply too many pieces in the .NET Framework and runtime that can result in elevation of privileges. Thus we don't treat [CAS as security boundary](https://msdn.microsoft.com/en-us/library/c5tk9z76(v=vs.110).aspx) anymore. On top of that, it makes the implementation more complicated and often has correctness performance implications for applications that don’t intend to use it.
-
-**Replacement**. Use operating system provided security boundaries, such as virtualization, containers, or user accounts for running processes with the least set of privileges.
-
-### Security Transparency
-
-**Justification**. Similar to CAS, this feature allows separating sandboxed code from security critical code in a declarative fashion, but is [no longer supported as a security boundary](https://msdn.microsoft.com/en-us/library/ee191569(v=vs.110).aspx). This feature was heavily used by Silverlight.
-
-**Replacement**. Use operating system provided security boundaries, such as virtualization, containers, or user accounts for running processes with the least set of privileges.
# Status of CoreCLR Profiler APIs
-The .NET Core project started with the codebase from the desktop CoreCLR/Silverlight so all the profiler APIs present there are also present in the code here. This is the status of our testing and porting efforts for these APIs.
+The CoreCLR project started with the codebase from the .NET Framework so all the profiler APIs present there are also present in the code here. This is the status of our testing and porting efforts for these APIs.
## Platform test coverage
When you create a .NET assembly using C# compiler, your assembly contains only MSIL code.
When the app runs, the JIT compiler translates the MSIL code into native code, before the CPU can execute them.
-This execution model has some advantages. For example, your assembly code can be portable across all platforms and architectures that support .NET Core.
+This execution model has some advantages. For example, your assembly code can be portable across all platforms and architectures that support .NET.
However, this portability comes with a performance cost. Your app starts up more slowly because the JIT compiler has to spend time to translate the code.
To help make your app start up faster, CoreCLR includes a tool called CrossGen, which can pre-compile the MSIL code into native code.
**Examples**
-- Build project for Linux for .NET Core
+- Build project for Linux
```
dotnet build System.Net.NetworkInformation.csproj /p:TargetOS=Linux
```
## Debugging core dumps with lldb
-It is also possible to debug .NET Core crash dumps using lldb and SOS. In order to do this, you need all of the following:
+It is also possible to debug .NET crash dumps using lldb and SOS. In order to do this, you need all of the following:
- The crash dump file.
- On Linux, there is an utility called `createdump` (see [doc](../../../design/coreclr/botr/xplat-minidump-generation.md "doc")) that can be setup to generate core dumps when a managed app throws an unhandled exception or faults.'
Debugging CoreFX on Windows
==========================
-You can Debug .NET Core via Visual Studio or WinDBG.
+You can Debug .NET via Visual Studio or WinDBG.
For Visual Studio debugging, follow the instructions at [Debugging tests in Visual Studio](../../testing/libraries/testing-vs.md) to run and debug tests.
For bugs that cannot be reproduced within Visual Studio (certain low-probability race conditions, SafeHandle life-time problems, etc) you will need to use WinDBG.
associated with the repository, including
* `coreclr` - This is the main runtime DLL (the GC, class loader, interop are all here)
* `corjit` - This is the Just In Time (JIT) compiler that compiles .NET Intermediate language to native code.
- * `corerun` - This is the simple host program that can load the CLR and run a .NET Core application
+ * `corerun` - This is the simple host program that can run a .NET application
* `crossgen` - This is the host program that runs the JIT compiler and produces .NET Native images (`*.ni.dll`)
for C# code.
# See Also
-Before you make modifications, you probably want to learn more about the general architecture of .NET Core.
+Before you make modifications, you probably want to learn more about the general architecture of .NET Runtime.
See the following docs for more.
- * [Documentation on the .NET Core Runtime](../README.md)
+ * [Documentation on the .NET Runtime](../README.md)
- Ensure that `powershell.exe` is accessible via the PATH environment variable. Typically this is `%SYSTEMROOT%\System32\WindowsPowerShell\v1.0\` and its automatically set upon Windows installation.
- Powershell version must be 3.0 or higher. Use `$PSVersionTable.PSVersion` to determine the engine version.
-## DotNet Core SDK
+## .NET SDK
-While not strictly needed to build or test the .NET Core repository, having the .NET Core SDK installed lets you use the dotnet.exe command to run .NET Core applications in the 'normal' way.
+While not strictly needed to build or test this repository, having the .NET SDK installed lets you use the dotnet.exe command to run .NET applications in the 'normal' way.
We use this in the [Using Your Build](../testing/using-your-build.md) instructions.
-Visual Studio should have installed the .NET Core SDK, but in case it did not you can get it from the [Installing the .NET Core SDK](https://dotnet.microsoft.com/download) page.
+Visual Studio should have installed the .NET SDK, but in case it did not you can get it from the [Installing the .NET SDK](https://dotnet.microsoft.com/download) page.
## Adding to the default PATH variable
-# Running .NET Core Tests
+# Running Tests
Details on test metadata can be found in [test-configuration.md](test-configuration.md).
libraries -buildtests
```
-- The following builds and runs all tests for .NET Core in release configuration:
+- The following builds and runs all tests in release configuration:
```
libraries -test -c Release
```
-# Using corerun To Run .NET Core Application
+# Using corerun To Run .NET Application
-In page [Using your .NET Core Runtime Build with dotnet cli](../using-dotnet-cli.md) gives detailed instructions on using the standard
-command line host and SDK, dotnet.exe to run a .NET application with the modified build of the
-.NET Core runtime built here. This is the preferred mechanism for you to officially deploy
+In page [Using your .NET Runtime Build with dotnet cli](../using-dotnet-cli.md) gives detailed instructions on using the standard
+command line host and SDK, dotnet.exe to run an application with the modified build of the
+.NET Runtime built here. This is the preferred mechanism for you to officially deploy
your changes to other people since dotnet.exe and Nuget insure that you end up with a consistent
set of DLLs that can work together.
For this situation there is an alternative host to dotnet.exe called corerun.exe that is well suited
for this. It does not know about Nuget at all, and has very simple rules. It needs to find the
-.NET Core runtime (that is coreclr.dll) and additionally any class library DLLs (e.g. System.Runtime.dll System.IO.dll ...).
+.NET runtime (that is coreclr.dll) and additionally any class library DLLs (e.g. System.Runtime.dll System.IO.dll ...).
It does this by looking at two environment variables.
-# Using your .NET Core Runtime Build
+# Using your .NET Runtime Build
We assume that you have successfully built CoreCLR repository and thus have files of the form
```
~/runtime/artifacts/bin/coreclr/<OS>.<arch>.<flavor>/
```
-To run your newly built .NET Core Runtime in addition to the application itself, you will need
-a 'host' program that will load the Runtime as well as all the other .NET Core Framework
+To run your newly built .NET Runtime in addition to the application itself, you will need
+a 'host' program that will load the Runtime as well as all the other .NET libraries
code that your application needs. The easiest way to get all this other stuff is to simply use the
-standard 'dotnet' host that installs with .NET Core SDK.
+standard 'dotnet' host that installs with .NET SDK.
The released version of 'dotnet' tool may not be compatible with the live CoreCLR repository. The following steps
assume use of a dogfood build of the .NET SDK.
-## Acquire the latest nightly .NET Core SDK
+## Acquire the latest nightly .NET SDK
- [Win 64-bit Latest](https://dotnetcli.blob.core.windows.net/dotnet/Sdk/master/dotnet-sdk-latest-win-x64.zip)
- [macOS 64-bit Latest](https://dotnetcli.blob.core.windows.net/dotnet/Sdk/master/dotnet-sdk-latest-osx-x64.tar.gz)
`dotnet --info` -- the version should be greater than 3.0.0-*
-For another small walkthrough see [Dogfooding .NET Core SDK](https://github.com/dotnet/runtime/blob/master/docs/project/dogfooding.md).
+For another small walkthrough see [Dogfooding .NET SDK](https://github.com/dotnet/runtime/blob/master/docs/project/dogfooding.md).
## Create sample self-contained application
dotnet publish
```
-**Note:** If publish fails to restore runtime packages you need to configure custom NuGet feeds. This is because you are using a dogfood .NET Core SDK: its dependencies are not yet on the regular NuGet feed. To do so you have to:
+**Note:** If publish fails to restore runtime packages you need to configure custom NuGet feeds. This is because you are using a dogfood .NET SDK: its dependencies are not yet on the regular NuGet feed. To do so you have to:
1. run `dotnet new nugetconfig`
2. go to the `NuGet.Config` file and replace the content with:
## Update CoreCLR from raw binary output
Updating CoreCLR from raw binary output is easier for quick one-off testing which is what this set of instructions
-outline but for consuming in a real .NET Core application you should use the nuget package instructions below.
+outline but for consuming in a real .NET application you should use the nuget package instructions below.
The 'dotnet publish' step above creates a directory that has all the files necessary to run your app
including the CoreCLR and the parts of CoreFX that were needed. You can use this fact to skip some steps if
Assert failure(PID 13452 [0x0000348c], Thread: 10784 [0x2a20]): Consistency check failed: AV in clr at this callstack:
```
-## Using DotNetCli to run your .NET Core Application
+## Using .NET SDK to run your .NET Application
If you don't like the idea of copying files manually you can follow [these instructions](../using-dotnet-cli.md) to use dotnet cli to do this for you.
However the steps described here are the simplest and most commonly used by CoreCLR developers for ad-hoc testing.
-## Using CoreRun to run your .NET Core Application
+## Using CoreRun to run your .NET Application
-Generally using dotnet.exe tool to run your .NET Core application is the preferred mechanism to run .NET Core Apps.
-However there is a simpler 'host' for .NET Core applications called 'CoreRun' that can also be used. The value
+Generally using dotnet.exe tool to run your .NET application is the preferred mechanism to run .NET Apps.
+However there is a simpler 'host' for .NET applications called 'CoreRun' that can also be used. The value
of this host is that it is simpler (in particular it knows nothing about NuGet), but precisely because of this
it can be harder to use (since you are responsible for insuring all the dependencies you need are gather together)
-See [Using CoreRun To Run .NET Core Application](using-corerun.md) for more.
+See [Using CoreRun To Run .NET Application](using-corerun.md) for more.
-# Using your .NET Core Runtime Build with dotnet cli
+# Using your .NET Runtime build with .NET SDK
-This walkthrough explains how to run against your local CoreCLR build using `dotnet cli` only.
+This walkthrough explains how to run against your local CoreCLR build using .NET SDK only.
For other walkthroughs see:
- [Using Your Build - Update CoreCLR from raw binary output](./testing/using-your-build.md)
-- [Using CoreRun To Run .NET Core Application](./testing/using-corerun.md)
-- [Dogfooding .NET Core SDK](https://github.com/dotnet/runtime/blob/master/docs/project/dogfooding.md).
+- [Using CoreRun To Run .NET Application](./testing/using-corerun.md)
+- [Dogfooding .NET SDK](https://github.com/dotnet/runtime/blob/master/docs/project/dogfooding.md).
## Prerequisites
artifacts\bin\coreclr\<OS>.<arch>.<flavor>\.nuget\pkg\runtime.<OS>-<arch>.Microsoft.NETCore.Runtime.CoreCLR.<version>.nupkg
```
-2. Acquired the latest nightly .NET Core SDK from [here](https://github.com/dotnet/cli/blob/master/README.md#installers-and-binaries) and added it's root folder to your [path](requirements/windows-requirements.md#adding-to-the-default-path-variable)
+2. Acquired the latest nightly .NET SDK from [here](https://github.com/dotnet/cli/blob/master/README.md#installers-and-binaries) and added it's root folder to your [path](requirements/windows-requirements.md#adding-to-the-default-path-variable)
## First Run
### 2. Create NuGet.Config file
-The build script creates NuGet packages and puts them to `artifacts\bin\coreclr\<OS>.<arch>.<flavor>\.nuget\pkg\`. dotnet cli has no idea about its existence and we need to tell it where to search for the packages.
+The build script creates NuGet packages and puts them to `artifacts\bin\coreclr\<OS>.<arch>.<flavor>\.nuget\pkg\`. .NET SDK has no idea about its existence and we need to tell it where to search for the packages.
Please run `dotnet new nugetconfig` in the app folder and update the created `NuGet.Config` file:
<Project>
<PropertyGroup>
- <!-- The .NET Core product branding version -->
+ <!-- The .NET product branding version -->
<ProductVersion>5.0.0</ProductVersion>
<!-- File version numbers -->
<MajorVersion>5</MajorVersion>
jobTemplate: /eng/pipelines/coreclr/templates/build-job.yml
buildConfig: checked
platforms:
- # TODO: add Windows_NT_arm64, when we have hardware available, and .NET Core supports it. Note: platform-matrix.yml needs to enable a Helix queue for this.
+ # TODO: add Windows_NT_arm64, when we have hardware available. Note: platform-matrix.yml needs to enable a Helix queue for this.
- Linux_arm
- Linux_arm64
- Linux_x64
jobTemplate: /eng/pipelines/coreclr/templates/run-test-job.yml
buildConfig: checked
platforms:
- # TODO: add Windows_NT_arm64, when we have hardware available, and .NET Core supports it. Note: platform-matrix.yml needs to enable a Helix queue for this.
+ # TODO: add Windows_NT_arm64, when we have hardware available. Note: platform-matrix.yml needs to enable a Helix queue for this.
- Linux_arm
- Linux_arm64
- Linux_x64
jobTemplate: /eng/pipelines/coreclr/templates/build-job.yml
buildConfig: checked
platforms:
- # TODO: add Windows_NT_arm64, when we have hardware available, and .NET Core supports it. Note: platform-matrix.yml needs to enable a Helix queue for this.
+ # TODO: add Windows_NT_arm64, when we have hardware available. Note: platform-matrix.yml needs to enable a Helix queue for this.
- Linux_arm
- Linux_arm64
- Linux_x64
jobTemplate: /eng/pipelines/coreclr/templates/run-test-job.yml
buildConfig: checked
platforms:
- # TODO: add Windows_NT_arm64, when we have hardware available, and .NET Core supports it. Note: platform-matrix.yml needs to enable a Helix queue for this.
+ # TODO: add Windows_NT_arm64, when we have hardware available. Note: platform-matrix.yml needs to enable a Helix queue for this.
- Linux_arm
- Linux_arm64
- Linux_x64
jobTemplate: /eng/pipelines/coreclr/templates/build-job.yml
buildConfig: checked
platforms:
- # TODO: add Windows_NT_arm64, when we have hardware available, and .NET Core supports it. Note: platform-matrix.yml needs to enable a Helix queue for this.
+ # TODO: add Windows_NT_arm64, when we have hardware available. Note: platform-matrix.yml needs to enable a Helix queue for this.
- Linux_arm
- Linux_arm64
- Linux_x64
jobTemplate: /eng/pipelines/coreclr/templates/run-test-job.yml
buildConfig: checked
platforms:
- # TODO: add Windows_NT_arm64, when we have hardware available, and .NET Core supports it. Note: platform-matrix.yml needs to enable a Helix queue for this.
+ # TODO: add Windows_NT_arm64, when we have hardware available. Note: platform-matrix.yml needs to enable a Helix queue for this.
- Linux_arm
- Linux_arm64
- Linux_x64
jobTemplate: /eng/pipelines/coreclr/templates/build-job.yml
buildConfig: checked
platforms:
- # TODO: add Windows_NT_arm64, when we have hardware available, and .NET Core supports it. Note: platform-matrix.yml needs to enable a Helix queue for this.
+ # TODO: add Windows_NT_arm64, when we have hardware available. Note: platform-matrix.yml needs to enable a Helix queue for this.
- Linux_arm
- Linux_arm64
- Linux_x64
jobTemplate: /eng/pipelines/coreclr/templates/run-test-job.yml
buildConfig: checked
platforms:
- # TODO: add Windows_NT_arm64, when we have hardware available, and .NET Core supports it. Note: platform-matrix.yml needs to enable a Helix queue for this.
+ # TODO: add Windows_NT_arm64, when we have hardware available. Note: platform-matrix.yml needs to enable a Helix queue for this.
- Linux_arm
- Linux_arm64
- Linux_x64
steps:
- task: UseDotNet@2
# This should match what jitutils YML uses to build.
- displayName: 'Install .NET Core SDK'
+ displayName: 'Install .NET SDK'
inputs:
packageType: 'sdk'
version: '3.x'
<Description Condition="'$(Description)' == ''">$(AssemblyName)</Description>
<!-- SDK sets product to assembly but we want it to be our product name -->
- <Product>Microsoft%AE .NET Core</Product>
+ <Product>Microsoft%AE .NET</Product>
- <!-- Use the .NET Core product branding version for informational version description -->
+ <!-- Use the .NET product branding version for informational version description -->
<InformationalVersion>$(ProductVersion)</InformationalVersion>
<InformationalVersion Condition="'$(VersionSuffix)' != ''">$(InformationalVersion)-$(VersionSuffix)</InformationalVersion>
</PropertyGroup>
<FileWrites Include="$(AssemblyInfoFile)" />
</ItemGroup>
</Target>
-</Project>
\ No newline at end of file
+</Project>
<PropertyGroup>
<!-- SDK sets product to assembly but we want it to be our product name -->
- <Product>Microsoft%AE .NET Core</Product>
+ <Product>Microsoft%AE .NET</Product>
- <!-- Use the .NET Core product branding version for informational version description -->
+ <!-- Use the .NET product branding version for informational version description -->
<InformationalVersion>$(ProductVersion)</InformationalVersion>
<InformationalVersion Condition="'$(VersionSuffix)' != ''">$(InformationalVersion)-$(VersionSuffix)</InformationalVersion>
</PropertyGroup>
<!-- Properties that should be defined for all managed product assemblies -->
<PropertyGroup>
<Company>Microsoft Corporation</Company>
- <Product>Microsoft%AE .NET Core</Product>
+ <Product>Microsoft%AE .NET</Product>
</PropertyGroup>
</Project>
-SOS and other diagnostic tools now ship out of band and work with any version of the .NET Core runtime.
+SOS and other diagnostic tools now ship out of band and work with any version of the .NET runtime.
SOS has moved to the diagnostics repo here: https://github.com/dotnet/diagnostics.git.
// See the LICENSE file in the project root for more information.
#ifndef VER_PRODUCTNAME_STR
- #define VER_PRODUCTNAME_STR L"Microsoft\256 .NET Core"
+ #define VER_PRODUCTNAME_STR L"Microsoft\256 .NET"
#endif
#ifndef VER_LEGALCOPYRIGHT_STR
}
}
- // Log the .NET Core Version if we can get it
+ // Log the .NET Version if we can get it
LPCWSTR fxProductVersion = Configuration::GetKnobStringValue(W("FX_PRODUCT_VERSION"));
if (fxProductVersion != nullptr)
{
- m_Description.Append(W(".NET Core Version: "));
+ m_Description.Append(W(".NET Version: "));
m_Description.Append(fxProductVersion);
m_Description.Append(W("\n"));
}
framework_parser.add_argument('--result_dir', dest='result_dirname', required=True)
framework_parser.set_defaults(func=crossgen_framework)
- dotnet_sdk_parser_description = "Unpack .NET Core SDK archive file and runs crossgen on each assembly."
+ dotnet_sdk_parser_description = "Unpack .NET SDK archive file and runs crossgen on each assembly."
dotnet_sdk_parser = subparsers.add_parser('crossgen_dotnet_sdk', description=dotnet_sdk_parser_description)
dotnet_sdk_parser.add_argument('--crossgen', dest='crossgen_executable_filename', required=True)
dotnet_sdk_parser.add_argument('--il_corelib', dest='il_corelib_filename', required=True)
Assert.IsTrue(DoCallBack_MarshalSbyteArray_AsParam_AsByRef(new DelSbyteArrByRefAsCdeclCaller(TestMethodForSbyteArray_AsReversePInvokeByRef_AsCdecl)));
Console.WriteLine("\t\tMarshalSbyteArray_AsReversePInvokeByRef_AsCdecl Passed!");
- // We don't support exception interop in .NET Core off-Windows.
+ // We don't support exception interop in .NET off-Windows.
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
Console.WriteLine("\tScenario 3 : short ==> SHORT, Array_Size = -1, Return_Array_Size = 20");
{
Component.Contracts.IStringTesting target = (Component.Contracts.IStringTesting)WinRTNativeComponent.GetObjectFromNativeComponent("Component.Contracts.StringTesting");
string left = "Hello C++/WinRT";
- string right = " from .NET Core";
+ string right = " from .NET";
Assert.AreEqual(string.Concat(left, right), target.ConcatStrings(left, right));
}
}
-.NET Core uses third-party libraries or other resources that may be
-distributed under licenses different than the .NET Core software.
+.NET uses third-party libraries or other resources that may be
+distributed under licenses different than the .NET software.
Attributions and license notices for test cases originally authored by
third parties can be found in the respective test directories.
<SharedFrameworkName>Microsoft.NETCore.App</SharedFrameworkName>
<NETCoreAppFrameworkIdentifier>.NETCoreApp</NETCoreAppFrameworkIdentifier>
<NETCoreAppFrameworkMoniker>$(NETCoreAppFrameworkIdentifier),Version=v$(NETCoreAppFrameworkVersion)</NETCoreAppFrameworkMoniker>
- <NETCoreAppFrameworkBrandName>.NET Core $(NETCoreAppFrameworkVersion)</NETCoreAppFrameworkBrandName>
+ <NETCoreAppFrameworkBrandName>.NET $(NETCoreAppFrameworkVersion)</NETCoreAppFrameworkBrandName>
</PropertyGroup>
<!-- Platform detection -->
<!-- Generate Version files -->
<ItemGroup>
<HostFiles Include="dotnet">
- <FileDescription>.NET Core Host</FileDescription>
+ <FileDescription>.NET Host</FileDescription>
</HostFiles>
<HostFiles Include="hostfxr">
- <FileDescription>.NET Core Host Resolver - $(HostResolverVersion)</FileDescription>
+ <FileDescription>.NET Host Resolver - $(HostResolverVersion)</FileDescription>
</HostFiles>
<HostFiles Include="hostpolicy">
- <FileDescription>.NET Core Host Policy - $(HostPolicyVersion)</FileDescription>
+ <FileDescription>.NET Host Policy - $(HostPolicyVersion)</FileDescription>
</HostFiles>
<HostFiles Include="comhost">
- <FileDescription>.NET Core COM Host</FileDescription>
+ <FileDescription>.NET COM Host</FileDescription>
</HostFiles>
<HostFiles Include="ijwhost">
- <FileDescription>.NET Core IJW Host</FileDescription>
+ <FileDescription>.NET IJW Host</FileDescription>
</HostFiles>
<HostFiles Include="winrthost">
- <FileDescription>.NET Core WinRT Host</FileDescription>
+ <FileDescription>.NET WinRT Host</FileDescription>
</HostFiles>
<HostFiles Include="nethost">
- <FileDescription>.NET Core Component Host</FileDescription>
+ <FileDescription>.NET Component Host</FileDescription>
</HostFiles>
</ItemGroup>
auto eventSource = ::RegisterEventSourceW(nullptr, _X(".NET Runtime"));
const DWORD traceErrorID = 1023; // Matches CoreCLR ERT_UnmanagedFailFast
pal::string_t message;
- message.append(_X("Description: A .NET Core application failed.\n"));
+ message.append(_X("Description: A .NET application failed.\n"));
message.append(_X("Application: ")).append(executable_name).append(_X("\n"));
message.append(_X("Path: ")).append(executable_path).append(_X("\n"));
message.append(_X("Message: ")).append(g_buffered_errors).append(_X("\n"));
if (pal::getenv(_X("DOTNET_DISABLE_GUI_ERRORS"), &gui_errors_disabled) && pal::xtoi(gui_errors_disabled.c_str()) == 1)
return;
- pal::string_t dialogMsg = _X("To run this application, you must install .NET Core.\n\n");
+ pal::string_t dialogMsg = _X("To run this application, you must install .NET.\n\n");
pal::string_t url;
const pal::string_t url_prefix = _X(" - ") DOTNET_CORE_APPLAUNCH_URL _X("?");
if (error_code == StatusCode::CoreHostLibMissingFailure)
trace::println(_X(" Commit: %s"), commit.substr(0, 10).c_str());
trace::println();
- trace::println(_X(".NET Core SDKs installed:"));
+ trace::println(_X(".NET SDKs installed:"));
if (!sdk_info::print_all_sdks(dotnet_root, _X(" ")))
{
trace::println(_X(" No SDKs were found."));
}
trace::println();
- trace::println(_X(".NET Core runtimes installed:"));
+ trace::println(_X(".NET runtimes installed:"));
if (!framework_info::print_all_frameworks(dotnet_root, _X(" ")))
{
trace::println(_X(" No runtimes were found."));
}
trace::println();
- trace::println(_X("To install additional .NET Core runtimes or SDKs:"));
+ trace::println(_X("To install additional .NET runtimes or SDKs:"));
trace::println(_X(" %s"), DOTNET_CORE_DOWNLOAD_URL);
}
trace::println();
trace::println(_X("Common Options:"));
trace::println(_X(" -h|--help Displays this help."));
- trace::println(_X(" --info Display .NET Core information."));
+ trace::println(_X(" --info Display .NET information."));
}
-}
\ No newline at end of file
+}
return StatusCode::Success;
}
- trace::error(_X("Could not execute because the application was not found or a compatible .NET Core SDK is not installed."));
+ trace::error(_X("Could not execute because the application was not found or a compatible .NET SDK is not installed."));
trace::error(_X("Possible reasons for this include:"));
- trace::error(_X(" * You intended to execute a .NET Core program:"));
+ trace::error(_X(" * You intended to execute a .NET program:"));
trace::error(_X(" The application '%s' does not exist."), app_candidate.c_str());
- trace::error(_X(" * You intended to execute a .NET Core SDK command:"));
+ trace::error(_X(" * You intended to execute a .NET SDK command:"));
resolver.print_resolution_error(host_info.dotnet_root, _X(" "));
return StatusCode::LibHostSdkFindFailure;
if (!pal::file_exists(sdk_dotnet))
{
- trace::error(_X("Found .NET Core SDK, but did not find dotnet.dll at [%s]"), sdk_dotnet.c_str());
+ trace::error(_X("Found .NET SDK, but did not find dotnet.dll at [%s]"), sdk_dotnet.c_str());
return StatusCode::LibHostSdkFindFailure;
}
new_argv.push_back(sdk_dotnet.c_str());
new_argv.insert(new_argv.end(), argv + 1, argv + argc);
- trace::verbose(_X("Using .NET Core SDK dll=[%s]"), sdk_dotnet.c_str());
+ trace::verbose(_X("Using .NET SDK dll=[%s]"), sdk_dotnet.c_str());
int new_argoff;
pal::string_t sdk_app_candidate;
void sdk_resolver::print_resolution_error(const pal::string_t& dotnet_root, const pal::char_t *prefix) const
{
bool sdk_exists = false;
- const pal::char_t *no_sdk_message = _X("It was not possible to find any installed .NET Core SDKs.");
+ const pal::char_t *no_sdk_message = _X("It was not possible to find any installed .NET SDKs.");
if (!version.is_empty())
{
pal::string_t requested = version.as_str();
if (!global_file.empty())
{
- trace::error(_X("%sA compatible installed .NET Core SDK for global.json version [%s] from [%s] was not found."), prefix, requested.c_str(), global_file.c_str());
- trace::error(_X("%sInstall the [%s] .NET Core SDK or update [%s] with an installed .NET Core SDK:"), prefix, requested.c_str(), global_file.c_str());
+ trace::error(_X("%sA compatible installed .NET SDK for global.json version [%s] from [%s] was not found."), prefix, requested.c_str(), global_file.c_str());
+ trace::error(_X("%sInstall the [%s] .NET SDK or update [%s] with an installed .NET SDK:"), prefix, requested.c_str(), global_file.c_str());
}
else
{
- trace::error(_X("%sA compatible installed .NET Core SDK version [%s] was not found."), prefix, requested.c_str());
- trace::error(_X("%sInstall the [%s] .NET Core SDK or create a global.json file with an installed .NET Core SDK:"), prefix, requested.c_str());
+ trace::error(_X("%sA compatible installed .NET SDK version [%s] was not found."), prefix, requested.c_str());
+ trace::error(_X("%sInstall the [%s] .NET SDK or create a global.json file with an installed .NET SDK:"), prefix, requested.c_str());
}
sdk_exists = sdk_info::print_all_sdks(dotnet_root, pal::string_t{prefix}.append(_X(" ")));
if (!sdk_exists)
{
- trace::error(_X("%sInstall a .NET Core SDK from:"), prefix);
+ trace::error(_X("%sInstall a .NET SDK from:"), prefix);
trace::error(_X("%s %s"), prefix, DOTNET_CORE_DOWNLOAD_URL);
}
}
}
else
{
- trace::verbose(_X("--- Resolving .NET Core SDK with working dir [%s]"), cwd.c_str());
+ trace::verbose(_X("--- Resolving .NET SDK with working dir [%s]"), cwd.c_str());
}
return from_nearest_global_file(cwd, allow_prerelease);
}
resolver = sdk_resolver{ allow_prerelease };
trace::warning(
- _X("Ignoring SDK settings in global.json: the latest installed .NET Core SDK (%s prereleases) will be used"),
+ _X("Ignoring SDK settings in global.json: the latest installed .NET SDK (%s prereleases) will be used"),
resolver.allow_prerelease ? _X("including") : _X("excluding"));
}
dotnet_root_env_var_name.c_str(),
self_registered_message.c_str());
trace::error(_X(""));
- trace::error(_X("The .NET Core runtime can be found at:"));
+ trace::error(_X("The .NET runtime can be found at:"));
trace::error(_X(" - %s&apphost_version=%s"), get_download_url().c_str(), _STRINGIFY(COMMON_HOST_PKG_VER));
return false;
}
if (!pal::load_library(&fxr_path, &fxr))
{
trace::error(_X("The library %s was found, but loading it from %s failed"), LIBFXR_NAME, fxr_path.c_str());
- trace::error(_X(" - Installing .NET Core prerequisites might help resolve this problem."));
+ trace::error(_X(" - Installing .NET prerequisites might help resolve this problem."));
trace::error(_X(" %s"), DOTNET_CORE_INSTALL_PREREQUISITES_URL);
return StatusCode::CoreHostLibLoadFailure;
}
if (status != StatusCode::Success)
{
// If we ignore the failure to patch bootstrap thunks we will come to this same
- // function again, causing an infinite loop of "Failed to start the .NET Core runtime" errors.
+ // function again, causing an infinite loop of "Failed to start the .NET runtime" errors.
// As we were taken here via an entry point with arbitrary signature,
// there's no way of returning the error code so we just throw it.
- trace::error(_X("Failed to start the .NET Core runtime. Error code %d"), status);
+ trace::error(_X("Failed to start the .NET runtime. Error code %d"), status);
#pragma warning (push)
#pragma warning (disable: 4297)
trace::println();
trace::println(_X("Options:"));
trace::println(_X(" -h|--help Display help."));
- trace::println(_X(" --info Display .NET Core information."));
+ trace::println(_X(" --info Display .NET information."));
trace::println(_X(" --list-sdks Display the installed SDKs."));
trace::println(_X(" --list-runtimes Display the installed runtimes."));
trace::println();
if (!pal::load_library(&fxr_path, &fxr))
{
trace::error(_X("The library %s was found, but loading it from %s failed"), LIBFXR_NAME, fxr_path.c_str());
- trace::error(_X(" - Installing .NET Core prerequisites might help resolve this problem."));
+ trace::error(_X(" - Installing .NET prerequisites might help resolve this problem."));
trace::error(_X(" %s"), DOTNET_CORE_INSTALL_PREREQUISITES_URL);
return StatusCode::CoreHostLibLoadFailure;
}
if (trace::get_error_writer() != nullptr && rc == static_cast<int>(StatusCode::FrameworkMissingFailure) && !set_error_writer_fn)
{
pal::string_t url = get_download_url();
- trace::error(_X(" _ To run this application, you need to install a newer version of .NET Core."));
+ trace::error(_X(" _ To run this application, you need to install a newer version of .NET."));
trace::error(_X(""));
trace::error(_X(" - %s"), url.c_str());
}
<PropertyGroup>
<TargetFramework>netstandard2.0</TargetFramework>
- <Description>Abstractions for modifying .net core host-binaries</Description>
+ <Description>Abstractions for modifying .NET host binaries</Description>
<IsShipping>false</IsShipping>
</PropertyGroup>
</PropertyGroup>
<PropertyGroup>
- <ProductBrandPrefix Condition="'$(ProductBrandPrefix)' == ''">Microsoft .NET Core</ProductBrandPrefix>
+ <ProductBrandPrefix Condition="'$(ProductBrandPrefix)' == ''">Microsoft .NET</ProductBrandPrefix>
<ProductBrandSuffix>$(ProductionVersion)</ProductBrandSuffix>
<ProductBrandSuffix Condition="'$(ReleaseBrandSuffix)'!=''">$(ProductionVersion) $(ReleaseBrandSuffix)</ProductBrandSuffix>
{
- "maintainer_name":".NET Core Team",
+ "maintainer_name":".NET Team",
"maintainer_email": "dotnetpackages@dotnetfoundation.org",
"package_name": "%HOSTFXR_DEBIAN_PACKAGE_NAME%",
"install_root": "/usr/share/dotnet",
"short_description": "%HOSTFXR_BRAND_NAME% %HOSTFXR_NUGET_VERSION%",
- "long_description": ".NET Core is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.",
+ "long_description": ".NET is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.",
"homepage": "https://dot.net/core",
"release":{
{
- "maintainer_name":".NET Core Team",
+ "maintainer_name":".NET Team",
"maintainer_email": "dotnetpackages@dotnetfoundation.org",
"package_name": "%RUNTIME_DEPS_DEBIAN_PACKAGE_NAME%",
"install_root": "/usr/share/dotnet",
"short_description": "%RUNTIME_DEPS_DEBIAN_PACKAGE_NAME% %RUNTIME_DEPS_VERSION%",
- "long_description": ".NET Core is a development platform that you can use to build command-line applications, microservices and modern websites. This package installs all the system dependencies for .NET Core Runtime.",
+ "long_description": ".NET is a development platform that you can use to build command-line applications, microservices and modern websites. This package installs all the system dependencies for .NET Runtime.",
"homepage": "https://dot.net/core",
"release":{
{
- "maintainer_name":".NET Core Team",
+ "maintainer_name":".NET Team",
"maintainer_email": "dotnetpackages@dotnetfoundation.org",
"package_name": "%SHARED_FRAMEWORK_DEBIAN_PACKAGE_NAME%",
"install_root": "/usr/share/dotnet",
"short_description": "%SHARED_FRAMEWORK_BRAND_NAME% %SHARED_FRAMEWORK_NUGET_NAME% %SHARED_FRAMEWORK_NUGET_VERSION%",
- "long_description": ".NET Core is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.",
+ "long_description": ".NET is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.",
"homepage": "https://dot.net/core",
"release":{
{
- "maintainer_name":".NET Core Team",
+ "maintainer_name":".NET Team",
"maintainer_email": "dotnetpackages@dotnetfoundation.org",
"package_name": "dotnet-host",
"install_root": "/usr/share/dotnet",
"short_description": "%SHARED_HOST_BRAND_NAME%",
- "long_description": ".NET Core is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.",
+ "long_description": ".NET is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.",
"homepage": "https://dot.net/core",
"release":{
</SharedFrameworkTokenValue>
<!--
- In every runtime deps Deb package, include alternatives known to work with .NET Core.
+ In every runtime deps Deb package, include alternatives known to work with .NET.
Specifying these as "or" dependencies lets us create one package that works on many distros.
-->
<SharedFrameworkTokenValue
<html lang="en">
<head>
<meta charset="utf-8" />
- <title styles="color:white">Congratulations! You've successfully installed .NET Core CLI!</title>
+ <title styles="color:white">Congratulations! You've successfully installed .NET CLI!</title>
</head>
<body>
<div align="center" style="font-family: Helvetica;">
<h1>The installation was successful.</h1>
- <p>.NET Core CLI was successfully installed.</p>
+ <p>.NET CLI was successfully installed.</p>
<h2>
Install dependencies
</h2>
<p>
- In order to be able to use .NET Core on OS X, you need to install <b>OpenSSL</b> version <b>1.0.1/1.0.2</b>.
+ In order to be able to use .NET on OS X, you need to install <b>OpenSSL</b> version <b>1.0.1/1.0.2</b>.
There are many ways to install/update your libssl. Using <a href="https://brew.sh">Homebrew</a> is the easiest.
You can view the instructions <a href="http://brewformulas.org/Openssl">here</a> or if you're updating, <a href="https://github.com/dotnet/runtime/blob/master/docs/workflow/building/coreclr/osx-instructions.md#openssl">on this page</a>.
</p>
<html lang="en">
<head>
<meta charset="utf-8" />
- <title styles="color:white">Welcome to the .NET Core CLI installer.</title>
+ <title styles="color:white">Welcome to the .NET CLI installer.</title>
</head>
<body>
<font face="Helvetica">
<h3>
- Microsoft .NET Core CLI
+ Microsoft .NET CLI
</h3>
<p>
- .NET Core is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.
+ .NET is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.
</p>
<p>
- This package contains all the tools you will need to start writing applications with .NET Core. It includes the several tools, including the C# compiler and the NuGet package manager, and a copy of .NET Core for both you and the tools to use.
+ This package contains all the tools you will need to start writing applications with .NET. It includes the several tools, including the C# compiler and the NuGet package manager, and a copy of .NET for both you and the tools to use.
</p>
</font>
</body>
<html lang="en">
<head>
<meta charset="utf-8" />
- <title styles="color:white">Congratulations! You've successfully installed .NET Core CLI!</title>
+ <title styles="color:white">Congratulations! You've successfully installed .NET CLI!</title>
</head>
<body>
<div align="center" style="font-family: Helvetica;">
<h1>The installation was successful.</h1>
- <p>.NET Core CLI was successfully installed.</p>
+ <p>.NET CLI was successfully installed.</p>
<h2>
Install dependencies
</h2>
<p>
- In order to be able to use .NET Core on OS X, you need to install <b>OpenSSL</b> version <b>1.0.1/1.0.2</b>.
+ In order to be able to use .NET on OS X, you need to install <b>OpenSSL</b> version <b>1.0.1/1.0.2</b>.
There are many ways to install/update your libssl. Using <a href="https://brew.sh">Homebrew</a> is the easiest.
You can view the instructions <a href="http://brewformulas.org/Openssl">here</a> or if you're updating, <a href="https://github.com/dotnet/runtime/blob/master/docs/workflow/building/coreclr/osx-instructions.md#openssl">on this page</a>.
</p>
<html lang="en">
<head>
<meta charset="utf-8" />
- <title styles="color:white">Welcome to the .NET Core CLI installer.</title>
+ <title styles="color:white">Welcome to the .NET CLI installer.</title>
</head>
<body>
<font face="Helvetica">
<h3>
- Microsoft .NET Core CLI
+ Microsoft .NET CLI
</h3>
<p>
- .NET Core is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.
+ .NET is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.
</p>
<p>
- This package contains all the tools you will need to start writing applications with .NET Core. It includes the several tools, including the C# compiler and the NuGet package manager, and a copy of .NET Core for both you and the tools to use.
+ This package contains all the tools you will need to start writing applications with .NET. It includes the several tools, including the C# compiler and the NuGet package manager, and a copy of .NET for both you and the tools to use.
</p>
</font>
</body>
<html lang="en">
<head>
<meta charset="utf-8" />
- <title styles="color:white">Congratulations! You've successfully installed .NET Core CLI!</title>
+ <title styles="color:white">Congratulations! You've successfully installed .NET CLI!</title>
</head>
<body>
<div align="center" style="font-family: Helvetica;">
<h1>The installation was successful.</h1>
- <p>.NET Core CLI was successfully installed.</p>
+ <p>.NET CLI was successfully installed.</p>
<h2>
Install dependencies
</h2>
<p>
- In order to be able to use .NET Core on OS X, you need to install <b>OpenSSL</b> version <b>1.0.1/1.0.2</b>.
+ In order to be able to use .NET on OS X, you need to install <b>OpenSSL</b> version <b>1.0.1/1.0.2</b>.
There are many ways to install/update your libssl. Using <a href="https://brew.sh">Homebrew</a> is the easiest.
You can view the instructions <a href="http://brewformulas.org/Openssl">here</a> or if you're updating, <a href="https://github.com/dotnet/runtime/blob/master/docs/workflow/building/coreclr/osx-instructions.md#openssl">on this page</a>.
</p>
<html lang="en">
<head>
<meta charset="utf-8" />
- <title styles="color:white">Welcome to the .NET Core CLI installer.</title>
+ <title styles="color:white">Welcome to the .NET CLI installer.</title>
</head>
<body>
<font face="Helvetica">
<h3>
- Microsoft .NET Core CLI
+ Microsoft .NET CLI
</h3>
<p>
- .NET Core is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.
+ .NET is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.
</p>
<p>
- This package contains all the tools you will need to start writing applications with .NET Core. It includes the several tools, including the C# compiler and the NuGet package manager, and a copy of .NET Core for both you and the tools to use.
+ This package contains all the tools you will need to start writing applications with .NET. It includes the several tools, including the C# compiler and the NuGet package manager, and a copy of .NET for both you and the tools to use.
</p>
</font>
</body>
<html lang="en">
<head>
<meta charset="utf-8" />
- <title styles="color:white">Congratulations! You've successfully installed .NET Core CLI!</title>
+ <title styles="color:white">Congratulations! You've successfully installed .NET CLI!</title>
</head>
<body>
<div align="center" style="font-family: Helvetica;">
<h1>The installation was successful.</h1>
- <p>.NET Core CLI was successfully installed.</p>
+ <p>.NET CLI was successfully installed.</p>
<h2>
Install dependencies
</h2>
<p>
- In order to be able to use .NET Core on OS X, you need to install <b>OpenSSL</b> version <b>1.0.1/1.0.2</b>.
+ In order to be able to use .NET on OS X, you need to install <b>OpenSSL</b> version <b>1.0.1/1.0.2</b>.
There are many ways to install/update your libssl. Using <a href="https://brew.sh">Homebrew</a> is the easiest.
You can view the instructions <a href="http://brewformulas.org/Openssl">here</a> or if you're updating, <a href="https://github.com/dotnet/runtime/blob/master/docs/workflow/building/coreclr/osx-instructions.md#openssl">on this page</a>.
</p>
<html lang="en">
<head>
<meta charset="utf-8" />
- <title styles="color:white">Welcome to the .NET Core CLI installer.</title>
+ <title styles="color:white">Welcome to the .NET CLI installer.</title>
</head>
<body>
<font face="Helvetica">
<h3>
- Microsoft .NET Core CLI
+ Microsoft .NET CLI
</h3>
<p>
- .NET Core is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.
+ .NET is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.
</p>
<p>
- This package contains all the tools you will need to start writing applications with .NET Core. It includes the several tools, including the C# compiler and the NuGet package manager, and a copy of .NET Core for both you and the tools to use.
+ This package contains all the tools you will need to start writing applications with .NET. It includes the several tools, including the C# compiler and the NuGet package manager, and a copy of .NET for both you and the tools to use.
</p>
</font>
</body>
<html lang="en">
<head>
<meta charset="utf-8" />
- <title styles="color:white">Congratulations! You've successfully installed .NET Core CLI!</title>
+ <title styles="color:white">Congratulations! You've successfully installed .NET CLI!</title>
</head>
<body>
<div align="center" style="font-family: Helvetica;">
<h1>The installation was successful.</h1>
- <p>.NET Core CLI was successfully installed.</p>
+ <p>.NET CLI was successfully installed.</p>
<h2>
Install dependencies
</h2>
<p>
- In order to be able to use .NET Core on OS X, you need to install <b>OpenSSL</b> version <b>1.0.1/1.0.2</b>.
+ In order to be able to use .NET on OS X, you need to install <b>OpenSSL</b> version <b>1.0.1/1.0.2</b>.
There are many ways to install/update your libssl. Using <a href="https://brew.sh">Homebrew</a> is the easiest.
You can view the instructions <a href="http://brewformulas.org/Openssl">here</a> or if you're updating, <a href="https://github.com/dotnet/runtime/blob/master/docs/workflow/building/coreclr/osx-instructions.md#openssl">on this page</a>.
</p>
<html lang="en">
<head>
<meta charset="utf-8" />
- <title styles="color:white">Welcome to the .NET Core CLI installer.</title>
+ <title styles="color:white">Welcome to the .NET CLI installer.</title>
</head>
<body>
<font face="Helvetica">
<h3>
- Microsoft .NET Core CLI
+ Microsoft .NET CLI
</h3>
<p>
- .NET Core is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.
+ .NET is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.
</p>
<p>
- This package contains all the tools you will need to start writing applications with .NET Core. It includes the several tools, including the C# compiler and the NuGet package manager, and a copy of .NET Core for both you and the tools to use.
+ This package contains all the tools you will need to start writing applications with .NET. It includes the several tools, including the C# compiler and the NuGet package manager, and a copy of .NET for both you and the tools to use.
</p>
</font>
</body>
<html lang="en">
<head>
<meta charset="utf-8" />
- <title styles="color:white">Congratulations! You've successfully installed .NET Core CLI!</title>
+ <title styles="color:white">Congratulations! You've successfully installed .NET CLI!</title>
</head>
<body>
<div align="center" style="font-family: Helvetica;">
<h1>The installation was successful.</h1>
- <p>.NET Core CLI was successfully installed.</p>
+ <p>.NET CLI was successfully installed.</p>
<h2>
Install dependencies
</h2>
<p>
- In order to be able to use .NET Core on OS X, you need to install <b>OpenSSL</b> version <b>1.0.1/1.0.2</b>.
+ In order to be able to use .NET on OS X, you need to install <b>OpenSSL</b> version <b>1.0.1/1.0.2</b>.
There are many ways to install/update your libssl. Using <a href="https://brew.sh">Homebrew</a> is the easiest.
You can view the instructions <a href="http://brewformulas.org/Openssl">here</a> or if you're updating, <a href="https://github.com/dotnet/runtime/blob/master/docs/workflow/building/coreclr/osx-instructions.md#openssl">on this page</a>.
</p>
<html lang="en">
<head>
<meta charset="utf-8" />
- <title styles="color:white">Welcome to the .NET Core CLI installer.</title>
+ <title styles="color:white">Welcome to the .NET CLI installer.</title>
</head>
<body>
<font face="Helvetica">
<h3>
- Microsoft .NET Core CLI
+ Microsoft .NET CLI
</h3>
<p>
- .NET Core is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.
+ .NET is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.
</p>
<p>
- This package contains all the tools you will need to start writing applications with .NET Core. It includes the several tools, including the C# compiler and the NuGet package manager, and a copy of .NET Core for both you and the tools to use.
+ This package contains all the tools you will need to start writing applications with .NET. It includes the several tools, including the C# compiler and the NuGet package manager, and a copy of .NET for both you and the tools to use.
</p>
</font>
</body>
<html lang="en">
<head>
<meta charset="utf-8" />
- <title styles="color:white">Congratulations! You've successfully installed .NET Core CLI!</title>
+ <title styles="color:white">Congratulations! You've successfully installed .NET CLI!</title>
</head>
<body>
<div align="center" style="font-family: Helvetica;">
<h1>The installation was successful.</h1>
- <p>.NET Core CLI was successfully installed.</p>
+ <p>.NET CLI was successfully installed.</p>
<h2>
Install dependencies
</h2>
<p>
- In order to be able to use .NET Core on OS X, you need to install <b>OpenSSL</b> version <b>1.0.1/1.0.2</b>.
+ In order to be able to use .NET on OS X, you need to install <b>OpenSSL</b> version <b>1.0.1/1.0.2</b>.
There are many ways to install/update your libssl. Using <a href="https://brew.sh">Homebrew</a> is the easiest.
You can view the instructions <a href="http://brewformulas.org/Openssl">here</a> or if you're updating, <a href="https://github.com/dotnet/runtime/blob/master/docs/workflow/building/coreclr/osx-instructions.md#openssl">on this page</a>.
</p>
<html lang="en">
<head>
<meta charset="utf-8" />
- <title styles="color:white">Welcome to the .NET Core CLI installer.</title>
+ <title styles="color:white">Welcome to the .NET CLI installer.</title>
</head>
<body>
<font face="Helvetica">
<h3>
- Microsoft .NET Core CLI
+ Microsoft .NET CLI
</h3>
<p>
- .NET Core is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.
+ .NET is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.
</p>
<p>
- This package contains all the tools you will need to start writing applications with .NET Core. It includes the several tools, including the C# compiler and the NuGet package manager, and a copy of .NET Core for both you and the tools to use.
+ This package contains all the tools you will need to start writing applications with .NET. It includes the several tools, including the C# compiler and the NuGet package manager, and a copy of .NET for both you and the tools to use.
</p>
</font>
</body>
<html lang="en">
<head>
<meta charset="utf-8" />
- <title styles="color:white">Congratulations! You've successfully installed .NET Core CLI!</title>
+ <title styles="color:white">Congratulations! You've successfully installed .NET CLI!</title>
</head>
<body>
<div align="center" style="font-family: Helvetica;">
<h1>The installation was successful.</h1>
- <p>.NET Core CLI was successfully installed.</p>
+ <p>.NET CLI was successfully installed.</p>
<h2>
Install dependencies
</h2>
<p>
- In order to be able to use .NET Core on OS X, you need to install <b>OpenSSL</b> version <b>1.0.1/1.0.2</b>.
+ In order to be able to use .NET on OS X, you need to install <b>OpenSSL</b> version <b>1.0.1/1.0.2</b>.
There are many ways to install/update your libssl. Using <a href="https://brew.sh">Homebrew</a> is the easiest.
You can view the instructions <a href="http://brewformulas.org/Openssl">here</a> or if you're updating, <a href="https://github.com/dotnet/runtime/blob/master/docs/workflow/building/coreclr/osx-instructions.md#openssl">on this page</a>.
</p>
<html lang="en">
<head>
<meta charset="utf-8" />
- <title styles="color:white">Welcome to the .NET Core CLI installer.</title>
+ <title styles="color:white">Welcome to the .NET CLI installer.</title>
</head>
<body>
<font face="Helvetica">
<h3>
- Microsoft .NET Core CLI
+ Microsoft .NET CLI
</h3>
<p>
- .NET Core is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.
+ .NET is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.
</p>
<p>
- This package contains all the tools you will need to start writing applications with .NET Core. It includes the several tools, including the C# compiler and the NuGet package manager, and a copy of .NET Core for both you and the tools to use.
+ This package contains all the tools you will need to start writing applications with .NET. It includes the several tools, including the C# compiler and the NuGet package manager, and a copy of .NET for both you and the tools to use.
</p>
</font>
</body>
<html lang="en">
<head>
<meta charset="utf-8" />
- <title styles="color:white">Congratulations! You've successfully installed .NET Core CLI!</title>
+ <title styles="color:white">Congratulations! You've successfully installed .NET CLI!</title>
</head>
<body>
<div align="center" style="font-family: Helvetica;">
<h1>The installation was successful.</h1>
- <p>.NET Core CLI was successfully installed.</p>
+ <p>.NET CLI was successfully installed.</p>
<h2>
Install dependencies
</h2>
<p>
- In order to be able to use .NET Core on OS X, you need to install <b>OpenSSL</b> version <b>1.0.1/1.0.2</b>.
+ In order to be able to use .NET on OS X, you need to install <b>OpenSSL</b> version <b>1.0.1/1.0.2</b>.
There are many ways to install/update your libssl. Using <a href="https://brew.sh">Homebrew</a> is the easiest.
You can view the instructions <a href="http://brewformulas.org/Openssl">here</a> or if you're updating, <a href="https://github.com/dotnet/runtime/blob/master/docs/workflow/building/coreclr/osx-instructions.md#openssl">on this page</a>.
</p>
<html lang="en">
<head>
<meta charset="utf-8" />
- <title styles="color:white">Welcome to the .NET Core CLI installer.</title>
+ <title styles="color:white">Welcome to the .NET CLI installer.</title>
</head>
<body>
<font face="Helvetica">
<h3>
- Microsoft .NET Core CLI
+ Microsoft .NET CLI
</h3>
<p>
- .NET Core is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.
+ .NET is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.
</p>
<p>
- This package contains all the tools you will need to start writing applications with .NET Core. It includes the several tools, including the C# compiler and the NuGet package manager, and a copy of .NET Core for both you and the tools to use.
+ This package contains all the tools you will need to start writing applications with .NET. It includes the several tools, including the C# compiler and the NuGet package manager, and a copy of .NET for both you and the tools to use.
</p>
</font>
</body>
<html lang="en">
<head>
<meta charset="utf-8" />
- <title styles="color:white">Congratulations! You've successfully installed .NET Core CLI!</title>
+ <title styles="color:white">Congratulations! You've successfully installed .NET CLI!</title>
</head>
<body>
<div align="center" style="font-family: Helvetica;">
<h1>The installation was successful.</h1>
- <p>.NET Core CLI was successfully installed.</p>
+ <p>.NET CLI was successfully installed.</p>
<h2>
Install dependencies
</h2>
<p>
- In order to be able to use .NET Core on OS X, you need to install <b>OpenSSL</b> version <b>1.0.1/1.0.2</b>.
+ In order to be able to use .NET on OS X, you need to install <b>OpenSSL</b> version <b>1.0.1/1.0.2</b>.
There are many ways to install/update your libssl. Using <a href="https://brew.sh">Homebrew</a> is the easiest.
You can view the instructions <a href="http://brewformulas.org/Openssl">here</a> or if you're updating, <a href="https://github.com/dotnet/runtime/blob/master/docs/workflow/building/coreclr/osx-instructions.md#openssl">on this page</a>.
</p>
<html lang="en">
<head>
<meta charset="utf-8" />
- <title styles="color:white">Welcome to the .NET Core CLI installer.</title>
+ <title styles="color:white">Welcome to the .NET CLI installer.</title>
</head>
<body>
<font face="Helvetica">
<h3>
- Microsoft .NET Core CLI
+ Microsoft .NET CLI
</h3>
<p>
- .NET Core is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.
+ .NET is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.
</p>
<p>
- This package contains all the tools you will need to start writing applications with .NET Core. It includes the several tools, including the C# compiler and the NuGet package manager, and a copy of .NET Core for both you and the tools to use.
+ This package contains all the tools you will need to start writing applications with .NET. It includes the several tools, including the C# compiler and the NuGet package manager, and a copy of .NET for both you and the tools to use.
</p>
</font>
</body>
<html lang="en">
<head>
<meta charset="utf-8" />
- <title styles="color:white">Congratulations! You've successfully installed .NET Core CLI!</title>
+ <title styles="color:white">Congratulations! You've successfully installed .NET CLI!</title>
</head>
<body>
<div align="center" style="font-family: Helvetica;">
<h1>The installation was successful.</h1>
- <p>.NET Core CLI was successfully installed.</p>
+ <p>.NET CLI was successfully installed.</p>
<h2>
Install dependencies
</h2>
<p>
- In order to be able to use .NET Core on OS X, you need to install <b>OpenSSL</b> version <b>1.0.1/1.0.2</b>.
+ In order to be able to use .NET on OS X, you need to install <b>OpenSSL</b> version <b>1.0.1/1.0.2</b>.
There are many ways to install/update your libssl. Using <a href="https://brew.sh">Homebrew</a> is the easiest.
You can view the instructions <a href="http://brewformulas.org/Openssl">here</a> or if you're updating, <a href="https://github.com/dotnet/runtime/blob/master/docs/workflow/building/coreclr/osx-instructions.md#openssl">on this page</a>.
</p>
<html lang="en">
<head>
<meta charset="utf-8" />
- <title styles="color:white">Welcome to the .NET Core CLI installer.</title>
+ <title styles="color:white">Welcome to the .NET CLI installer.</title>
</head>
<body>
<font face="Helvetica">
<h3>
- Microsoft .NET Core CLI
+ Microsoft .NET CLI
</h3>
<p>
- .NET Core is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.
+ .NET is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.
</p>
<p>
- This package contains all the tools you will need to start writing applications with .NET Core. It includes the several tools, including the C# compiler and the NuGet package manager, and a copy of .NET Core for both you and the tools to use.
+ This package contains all the tools you will need to start writing applications with .NET. It includes the several tools, including the C# compiler and the NuGet package manager, and a copy of .NET for both you and the tools to use.
</p>
</font>
</body>
<html lang="en">
<head>
<meta charset="utf-8" />
- <title styles="color:white">Congratulations! You've successfully installed .NET Core CLI!</title>
+ <title styles="color:white">Congratulations! You've successfully installed .NET CLI!</title>
</head>
<body>
<div align="center" style="font-family: Helvetica;">
<h1>The installation was successful.</h1>
- <p>.NET Core CLI was successfully installed.</p>
+ <p>.NET CLI was successfully installed.</p>
<h2>
Install dependencies
</h2>
<p>
- In order to be able to use .NET Core on OS X, you need to install <b>OpenSSL</b> version <b>1.0.1/1.0.2</b>.
+ In order to be able to use .NET on OS X, you need to install <b>OpenSSL</b> version <b>1.0.1/1.0.2</b>.
There are many ways to install/update your libssl. Using <a href="https://brew.sh">Homebrew</a> is the easiest.
You can view the instructions <a href="http://brewformulas.org/Openssl">here</a> or if you're updating, <a href="https://github.com/dotnet/runtime/blob/master/docs/workflow/building/coreclr/osx-instructions.md#openssl">on this page</a>.
</p>
<html lang="en">
<head>
<meta charset="utf-8" />
- <title styles="color:white">Welcome to the .NET Core CLI installer.</title>
+ <title styles="color:white">Welcome to the .NET CLI installer.</title>
</head>
<body>
<font face="Helvetica">
<h3>
- Microsoft .NET Core CLI
+ Microsoft .NET CLI
</h3>
<p>
- .NET Core is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.
+ .NET is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.
</p>
<p>
- This package contains all the tools you will need to start writing applications with .NET Core. It includes the several tools, including the C# compiler and the NuGet package manager, and a copy of .NET Core for both you and the tools to use.
+ This package contains all the tools you will need to start writing applications with .NET. It includes the several tools, including the C# compiler and the NuGet package manager, and a copy of .NET for both you and the tools to use.
</p>
</font>
</body>
<html lang="en">
<head>
<meta charset="utf-8" />
- <title styles="color:white">Congratulations! You've successfully installed .NET Core CLI!</title>
+ <title styles="color:white">Congratulations! You've successfully installed .NET CLI!</title>
</head>
<body>
<div align="center" style="font-family: Helvetica;">
<h1>The installation was successful.</h1>
- <p>.NET Core CLI was successfully installed.</p>
+ <p>.NET CLI was successfully installed.</p>
<h2>
Install dependencies
</h2>
<p>
- In order to be able to use .NET Core on OS X, you need to install <b>OpenSSL</b> version <b>1.0.1/1.0.2</b>.
+ In order to be able to use .NET on OS X, you need to install <b>OpenSSL</b> version <b>1.0.1/1.0.2</b>.
There are many ways to install/update your libssl. Using <a href="https://brew.sh">Homebrew</a> is the easiest.
You can view the instructions <a href="http://brewformulas.org/Openssl">here</a> or if you're updating, <a href="https://github.com/dotnet/runtime/blob/master/docs/workflow/building/coreclr/osx-instructions.md#openssl">on this page</a>.
</p>
<html lang="en">
<head>
<meta charset="utf-8" />
- <title styles="color:white">Welcome to the .NET Core CLI installer.</title>
+ <title styles="color:white">Welcome to the .NET CLI installer.</title>
</head>
<body>
<font face="Helvetica">
<h3>
- Microsoft .NET Core CLI
+ Microsoft .NET CLI
</h3>
<p>
- .NET Core is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.
+ .NET is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.
</p>
<p>
- This package contains all the tools you will need to start writing applications with .NET Core. It includes the several tools, including the C# compiler and the NuGet package manager, and a copy of .NET Core for both you and the tools to use.
+ This package contains all the tools you will need to start writing applications with .NET. It includes the several tools, including the C# compiler and the NuGet package manager, and a copy of .NET for both you and the tools to use.
</p>
</font>
</body>
<html lang="en">
<head>
<meta charset="utf-8" />
- <title styles="color:white">Congratulations! You've successfully installed .NET Core CLI!</title>
+ <title styles="color:white">Congratulations! You've successfully installed .NET CLI!</title>
</head>
<body>
<div align="center" style="font-family: Helvetica;">
<h1>The installation was successful.</h1>
- <p>.NET Core CLI was successfully installed.</p>
+ <p>.NET CLI was successfully installed.</p>
<h2>
Install dependencies
</h2>
<p>
- In order to be able to use .NET Core on OS X, you need to install <b>OpenSSL</b> version <b>1.0.1/1.0.2</b>.
+ In order to be able to use .NET on OS X, you need to install <b>OpenSSL</b> version <b>1.0.1/1.0.2</b>.
There are many ways to install/update your libssl. Using <a href="https://brew.sh">Homebrew</a> is the easiest.
You can view the instructions <a href="http://brewformulas.org/Openssl">here</a> or if you're updating, <a href="https://github.com/dotnet/runtime/blob/master/docs/workflow/building/coreclr/osx-instructions.md#openssl">on this page</a>.
</p>
<html lang="en">
<head>
<meta charset="utf-8" />
- <title styles="color:white">Welcome to the .NET Core CLI installer.</title>
+ <title styles="color:white">Welcome to the .NET CLI installer.</title>
</head>
<body>
<font face="Helvetica">
<h3>
- Microsoft .NET Core CLI
+ Microsoft .NET CLI
</h3>
<p>
- .NET Core is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.
+ .NET is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.
</p>
<p>
- This package contains all the tools you will need to start writing applications with .NET Core. It includes the several tools, including the C# compiler and the NuGet package manager, and a copy of .NET Core for both you and the tools to use.
+ This package contains all the tools you will need to start writing applications with .NET. It includes the several tools, including the C# compiler and the NuGet package manager, and a copy of .NET for both you and the tools to use.
</p>
</font>
</body>
<body>
<br>
<div align="left" style="font-family: Helvetica;padding-left:10px">
- <h2>.NET Core Runtime</h2>
- <p>.NET Core is a development platform that you can use to build command-line applications, microservices and modern websites.It is open source, cross-platform, and supported by Microsoft. We hope you enjoy it!</p>
+ <h2>.NET Runtime</h2>
+ <p>.NET is a development platform that you can use to build command-line applications, microservices and modern websites.It is open source, cross-platform, and supported by Microsoft. We hope you enjoy it!</p>
</div>
<div align="left" style="font-family: Helvetica">
- <h2 style="padding-left:10px">Learn more about .NET Core</h2>
+ <h2 style="padding-left:10px">Learn more about .NET</h2>
<ul>
<li><a href="https://aka.ms/dotnet-docs">Documentation</a></li>
<li><a href="https://aka.ms/dev-privacy">Privacy Statement</a></li>
<body>
<br>
<div align="left" style="font-family: Helvetica;padding-left:10px">
- <h2>.NET Core Runtime</h2>
- <p>.NET Core is a development platform that you can use to build command-line applications, microservices and modern websites.It is open source, cross-platform, and supported by Microsoft. We hope you enjoy it!</p>
+ <h2>.NET Runtime</h2>
+ <p>.NET is a development platform that you can use to build command-line applications, microservices and modern websites.It is open source, cross-platform, and supported by Microsoft. We hope you enjoy it!</p>
</div>
<div align="left" style="font-family: Helvetica">
- <h2 style="padding-left:10px">Learn more about .NET Core</h2>
+ <h2 style="padding-left:10px">Learn more about .NET</h2>
<ul>
<li><a href="https://aka.ms/dotnet-docs">Documentation</a></li>
<li><a href="https://aka.ms/dev-privacy">Privacy Statement</a></li>
<body>
<br>
<div align="left" style="font-family: Helvetica;padding-left:10px">
- <h2>.NET Core Runtime</h2>
- <p>.NET Core is a development platform that you can use to build command-line applications, microservices and modern websites.It is open source, cross-platform, and supported by Microsoft. We hope you enjoy it!</p>
+ <h2>.NET Runtime</h2>
+ <p>.NET is a development platform that you can use to build command-line applications, microservices and modern websites.It is open source, cross-platform, and supported by Microsoft. We hope you enjoy it!</p>
</div>
<div align="left" style="font-family: Helvetica">
- <h2 style="padding-left:10px">Learn more about .NET Core</h2>
+ <h2 style="padding-left:10px">Learn more about .NET</h2>
<ul>
<li><a href="https://aka.ms/dotnet-docs">Documentation</a></li>
<li><a href="https://aka.ms/dev-privacy">Privacy Statement</a></li>
<body>
<br>
<div align="left" style="font-family: Helvetica;padding-left:10px">
- <h2>.NET Core Runtime</h2>
- <p>.NET Core is a development platform that you can use to build command-line applications, microservices and modern websites.It is open source, cross-platform, and supported by Microsoft. We hope you enjoy it!</p>
+ <h2>.NET Runtime</h2>
+ <p>.NET is a development platform that you can use to build command-line applications, microservices and modern websites.It is open source, cross-platform, and supported by Microsoft. We hope you enjoy it!</p>
</div>
<div align="left" style="font-family: Helvetica">
- <h2 style="padding-left:10px">Learn more about .NET Core</h2>
+ <h2 style="padding-left:10px">Learn more about .NET</h2>
<ul>
<li><a href="https://aka.ms/dotnet-docs">Documentation</a></li>
<li><a href="https://aka.ms/dev-privacy">Privacy Statement</a></li>
<body>
<br>
<div align="left" style="font-family: Helvetica;padding-left:10px">
- <h2>.NET Core Runtime</h2>
- <p>.NET Core is a development platform that you can use to build command-line applications, microservices and modern websites.It is open source, cross-platform, and supported by Microsoft. We hope you enjoy it!</p>
+ <h2>.NET Runtime</h2>
+ <p>.NET is a development platform that you can use to build command-line applications, microservices and modern websites.It is open source, cross-platform, and supported by Microsoft. We hope you enjoy it!</p>
</div>
<div align="left" style="font-family: Helvetica">
- <h2 style="padding-left:10px">Learn more about .NET Core</h2>
+ <h2 style="padding-left:10px">Learn more about .NET</h2>
<ul>
<li><a href="https://aka.ms/dotnet-docs">Documentation</a></li>
<li><a href="https://aka.ms/dev-privacy">Privacy Statement</a></li>
<body>
<br>
<div align="left" style="font-family: Helvetica;padding-left:10px">
- <h2>.NET Core Runtime</h2>
- <p>.NET Core is a development platform that you can use to build command-line applications, microservices and modern websites.It is open source, cross-platform, and supported by Microsoft. We hope you enjoy it!</p>
+ <h2>.NET Runtime</h2>
+ <p>.NET is a development platform that you can use to build command-line applications, microservices and modern websites.It is open source, cross-platform, and supported by Microsoft. We hope you enjoy it!</p>
</div>
<div align="left" style="font-family: Helvetica">
- <h2 style="padding-left:10px">Learn more about .NET Core</h2>
+ <h2 style="padding-left:10px">Learn more about .NET</h2>
<ul>
<li><a href="https://aka.ms/dotnet-docs">Documentation</a></li>
<li><a href="https://aka.ms/dev-privacy">Privacy Statement</a></li>
<body>
<br>
<div align="left" style="font-family: Helvetica;padding-left:10px">
- <h2>.NET Core Runtime</h2>
- <p>.NET Core is a development platform that you can use to build command-line applications, microservices and modern websites.It is open source, cross-platform, and supported by Microsoft. We hope you enjoy it!</p>
+ <h2>.NET Runtime</h2>
+ <p>.NET is a development platform that you can use to build command-line applications, microservices and modern websites.It is open source, cross-platform, and supported by Microsoft. We hope you enjoy it!</p>
</div>
<div align="left" style="font-family: Helvetica">
- <h2 style="padding-left:10px">Learn more about .NET Core</h2>
+ <h2 style="padding-left:10px">Learn more about .NET</h2>
<ul>
<li><a href="https://aka.ms/dotnet-docs">Documentation</a></li>
<li><a href="https://aka.ms/dev-privacy">Privacy Statement</a></li>
<body>
<br>
<div align="left" style="font-family: Helvetica;padding-left:10px">
- <h2>.NET Core Runtime</h2>
- <p>.NET Core is a development platform that you can use to build command-line applications, microservices and modern websites.It is open source, cross-platform, and supported by Microsoft. We hope you enjoy it!</p>
+ <h2>.NET Runtime</h2>
+ <p>.NET is a development platform that you can use to build command-line applications, microservices and modern websites.It is open source, cross-platform, and supported by Microsoft. We hope you enjoy it!</p>
</div>
<div align="left" style="font-family: Helvetica">
- <h2 style="padding-left:10px">Learn more about .NET Core</h2>
+ <h2 style="padding-left:10px">Learn more about .NET</h2>
<ul>
<li><a href="https://aka.ms/dotnet-docs">Documentation</a></li>
<li><a href="https://aka.ms/dev-privacy">Privacy Statement</a></li>
<body>
<br>
<div align="left" style="font-family: Helvetica;padding-left:10px">
- <h2>.NET Core Runtime</h2>
- <p>.NET Core is a development platform that you can use to build command-line applications, microservices and modern websites.It is open source, cross-platform, and supported by Microsoft. We hope you enjoy it!</p>
+ <h2>.NET Runtime</h2>
+ <p>.NET is a development platform that you can use to build command-line applications, microservices and modern websites.It is open source, cross-platform, and supported by Microsoft. We hope you enjoy it!</p>
</div>
<div align="left" style="font-family: Helvetica">
- <h2 style="padding-left:10px">Learn more about .NET Core</h2>
+ <h2 style="padding-left:10px">Learn more about .NET</h2>
<ul>
<li><a href="https://aka.ms/dotnet-docs">Documentation</a></li>
<li><a href="https://aka.ms/dev-privacy">Privacy Statement</a></li>
<body>
<br>
<div align="left" style="font-family: Helvetica;padding-left:10px">
- <h2>.NET Core Runtime</h2>
- <p>.NET Core is a development platform that you can use to build command-line applications, microservices and modern websites.It is open source, cross-platform, and supported by Microsoft. We hope you enjoy it!</p>
+ <h2>.NET Runtime</h2>
+ <p>.NET is a development platform that you can use to build command-line applications, microservices and modern websites.It is open source, cross-platform, and supported by Microsoft. We hope you enjoy it!</p>
</div>
<div align="left" style="font-family: Helvetica">
- <h2 style="padding-left:10px">Learn more about .NET Core</h2>
+ <h2 style="padding-left:10px">Learn more about .NET</h2>
<ul>
<li><a href="https://aka.ms/dotnet-docs">Documentation</a></li>
<li><a href="https://aka.ms/dev-privacy">Privacy Statement</a></li>
<line choice="{SharedHostComponentId}.pkg" />
<line choice="{HostFxrComponentId}.pkg" />
</choices-outline>
- <choice id="{SharedFxComponentId}.pkg" visible="true" title="{SharedFxBrandName} (x64)" description="The .NET Core Shared Framework">
+ <choice id="{SharedFxComponentId}.pkg" visible="true" title="{SharedFxBrandName} (x64)" description="The .NET Shared Framework">
<pkg-ref id="{SharedFxComponentId}.pkg" />
</choice>
- <choice id="{HostFxrComponentId}.pkg" visible="true" title="{HostFxrBrandName} (x64)" description="The .NET Core HostFxr">
+ <choice id="{HostFxrComponentId}.pkg" visible="true" title="{HostFxrBrandName} (x64)" description="The .NET HostFxr">
<pkg-ref id="{HostFxrComponentId}.pkg" />
</choice>
- <choice id="{SharedHostComponentId}.pkg" visible="true" title="{SharedHostBrandName} (x64)" description="The .NET Core Shared Host." >
+ <choice id="{SharedHostComponentId}.pkg" visible="true" title="{SharedHostBrandName} (x64)" description="The .NET Shared Host." >
<pkg-ref id="{SharedHostComponentId}.pkg" />
</choice>
<pkg-ref id="{SharedFxComponentId}.pkg">{SharedFxComponentId}.pkg</pkg-ref>
{
- "maintainer_name": ".NET Core Team",
+ "maintainer_name": ".NET Team",
"maintainer_email": "dotnetpackages@dotnetfoundation.org",
"vendor": ".NET Foundation",
"install_doc": "/usr/share/doc/%HOSTFXR_RPM_PACKAGE_NAME%/",
"short_description": "%HOSTFXR_BRAND_NAME% %HOSTFXR_NUGET_VERSION%",
- "long_description": ".NET Core is a development platform that you can use to build command-line\napplications, microservices and modern websites. It is open source,\ncross-platform and is supported by Microsoft. We hope you enjoy using it!\nIf you do, please consider joining the active community of developers that are\ncontributing to the project on GitHub (https://github.com/dotnet/core).\nWe happily accept issues and PRs.",
+ "long_description": ".NET is a development platform that you can use to build command-line\napplications, microservices and modern websites. It is open source,\ncross-platform and is supported by Microsoft. We hope you enjoy using it!\nIf you do, please consider joining the active community of developers that are\ncontributing to the project on GitHub (https://github.com/dotnet/core).\nWe happily accept issues and PRs.",
"homepage": "https://github.com/dotnet/core",
"release":{
{
- "maintainer_name": ".NET Core Team",
+ "maintainer_name": ".NET Team",
"maintainer_email": "dotnetpackages@dotnetfoundation.org",
"vendor": ".NET Foundation",
"install_root": "/usr/share/dotnet",
"short_description": "%RUNTIME_DEPS_RPM_PACKAGE_NAME% %RUNTIME_DEPS_VERSION%",
- "long_description": ".NET Core is a development platform that you can use to build command-line applications, microservices and modern websites. This package installs all the system dependencies for .NET Core Runtime.",
+ "long_description": ".NET is a development platform that you can use to build command-line applications, microservices and modern websites. This package installs all the system dependencies for .NET Runtime.",
"homepage": "https://dot.net/core",
"release":{
{
- "maintainer_name": ".NET Core Team",
+ "maintainer_name": ".NET Team",
"maintainer_email": "dotnetpackages@dotnetfoundation.org",
"vendor": ".NET Foundation",
"install_root": "/usr/share/dotnet",
"short_description": "%RUNTIME_DEPS_RPM_PACKAGE_NAME% %RUNTIME_DEPS_VERSION%",
- "long_description": ".NET Core is a development platform that you can use to build command-line applications, microservices and modern websites. This package installs all the system dependencies for .NET Core Runtime.",
+ "long_description": ".NET is a development platform that you can use to build command-line applications, microservices and modern websites. This package installs all the system dependencies for .NET Runtime.",
"homepage": "https://dot.net/core",
"release":{
{
- "maintainer_name": ".NET Core Team",
+ "maintainer_name": ".NET Team",
"maintainer_email": "dotnetpackages@dotnetfoundation.org",
"vendor": ".NET Foundation",
"install_root": "/usr/share/dotnet",
"short_description": "%RUNTIME_DEPS_RPM_PACKAGE_NAME% %RUNTIME_DEPS_VERSION%",
- "long_description": ".NET Core is a development platform that you can use to build command-line applications, microservices and modern websites. This package installs all the system dependencies for .NET Core Runtime.",
+ "long_description": ".NET is a development platform that you can use to build command-line applications, microservices and modern websites. This package installs all the system dependencies for .NET Runtime.",
"homepage": "https://dot.net/core",
"release":{
{
- "maintainer_name": ".NET Core Team",
+ "maintainer_name": ".NET Team",
"maintainer_email": "dotnetpackages@dotnetfoundation.org",
"vendor": ".NET Foundation",
"install_root": "/usr/share/dotnet",
"short_description": "%RUNTIME_DEPS_RPM_PACKAGE_NAME% %RUNTIME_DEPS_VERSION%",
- "long_description": ".NET Core is a development platform that you can use to build command-line applications, microservices and modern websites. This package installs all the system dependencies for .NET Core Runtime.",
+ "long_description": ".NET is a development platform that you can use to build command-line applications, microservices and modern websites. This package installs all the system dependencies for .NET Runtime.",
"homepage": "https://dot.net/core",
"release":{
{
- "maintainer_name": ".NET Core Team",
+ "maintainer_name": ".NET Team",
"maintainer_email": "dotnetpackages@dotnetfoundation.org",
"vendor": ".NET Foundation",
"install_root": "/usr/share/dotnet",
"short_description": "%RUNTIME_DEPS_RPM_PACKAGE_NAME% %RUNTIME_DEPS_VERSION%",
- "long_description": ".NET Core is a development platform that you can use to build command-line applications, microservices and modern websites. This package installs all the system dependencies for .NET Core Runtime.",
+ "long_description": ".NET is a development platform that you can use to build command-line applications, microservices and modern websites. This package installs all the system dependencies for .NET Runtime.",
"homepage": "https://dot.net/core",
"release":{
{
- "maintainer_name": ".NET Core Team",
+ "maintainer_name": ".NET Team",
"maintainer_email": "dotnetpackages@dotnetfoundation.org",
"vendor": ".NET Foundation",
"install_root": "/usr/share/dotnet",
"short_description": "%RUNTIME_DEPS_RPM_PACKAGE_NAME% %RUNTIME_DEPS_VERSION%",
- "long_description": ".NET Core is a development platform that you can use to build command-line applications, microservices and modern websites. This package installs all the system dependencies for .NET Core Runtime.",
+ "long_description": ".NET is a development platform that you can use to build command-line applications, microservices and modern websites. This package installs all the system dependencies for .NET Runtime.",
"homepage": "https://dot.net/core",
"release":{
{
- "maintainer_name": ".NET Core Team",
+ "maintainer_name": ".NET Team",
"maintainer_email": "dotnetpackages@dotnetfoundation.org",
"vendor": ".NET Foundation",
"install_doc": "/usr/share/doc/%SHARED_FRAMEWORK_RPM_PACKAGE_NAME%/",
"short_description": "%SHARED_FRAMEWORK_BRAND_NAME% %SHARED_FRAMEWORK_NUGET_NAME%",
- "long_description": ".NET Core is a development platform that you can use to build command-line\napplications, microservices and modern websites. It is open source,\ncross-platform and is supported by Microsoft. We hope you enjoy using it!\nIf you do, please consider joining the active community of developers that are\ncontributing to the project on GitHub (https://github.com/dotnet/core).\nWe happily accept issues and PRs.",
+ "long_description": ".NET is a development platform that you can use to build command-line\napplications, microservices and modern websites. It is open source,\ncross-platform and is supported by Microsoft. We hope you enjoy using it!\nIf you do, please consider joining the active community of developers that are\ncontributing to the project on GitHub (https://github.com/dotnet/core).\nWe happily accept issues and PRs.",
"homepage": "https://github.com/dotnet/core",
"release":{
{
- "maintainer_name": ".NET Core Team",
+ "maintainer_name": ".NET Team",
"maintainer_email": "dotnetpackages@dotnetfoundation.org",
"vendor": ".NET Foundation",
"install_man": "/usr/share/man/man1",
"short_description": "%SHARED_HOST_BRAND_NAME%",
- "long_description": ".NET Core is a development platform that you can use to build command-line\napplications, microservices and modern websites. It is open source,\ncross-platform and is supported by Microsoft. We hope you enjoy using it!\nIf you do, please consider joining the active community of developers that are\ncontributing to the project on GitHub (https://github.com/dotnet/core).\nWe happily accept issues and PRs.",
+ "long_description": ".NET is a development platform that you can use to build command-line\napplications, microservices and modern websites. It is open source,\ncross-platform and is supported by Microsoft. We hope you enjoy using it!\nIf you do, please consider joining the active community of developers that are\ncontributing to the project on GitHub (https://github.com/dotnet/core).\nWe happily accept issues and PRs.",
"homepage": "https://github.com/dotnet/core",
"release":{
},
{
"Name": "Microsoft.NETCore.DotNetAppHost",
- "Description": "Provides the .NET Core app bootstrapper intended for use in the application directory",
+ "Description": "Provides the .NET app bootstrapper intended for use in the application directory",
"CommonTypes": [ ]
},
{
},
{
"Name": "Microsoft.NETCore.App",
- "Description": "A set of .NET APIs that are included in the default .NET Core application model.",
+ "Description": "A set of .NET APIs that are included in the default .NET application model.",
"CommonTypes": [ ]
},
{
"Name": "Microsoft.NETCore.App.Internal",
- "Description": "Transport package for .NET Core App runtime assets.",
+ "Description": "Transport package for .NET App runtime assets.",
"CommonTypes": [ ]
},
{
"Name": "Microsoft.NETCore.App.Ref",
- "Description": "A set of .NET APIs that are included in the default .NET Core application model. Contains reference assemblies, documentation, and other design-time assets.",
+ "Description": "A set of .NET APIs that are included in the default .NET application model. Contains reference assemblies, documentation, and other design-time assets.",
"CommonTypes": [ ]
},
{
<CandleVariables Include="BundleThmDir" Value="$(MSBuildProjectDirectory)" />
</ItemGroup>
- <!-- ***** When the product-band version: "3.0" advances, remove these sections to clean up ***** -->
- <ItemGroup Condition="'$(TargetArchitecture)' == 'x86'">
- <!-- ".NET Core 3.0.0 Preview 1" 3.0.0-preview-27122-01-win-x86 upgrade-code -->
- <UpgradeRelatedBundle Include="{138DC905-5BB8-5C92-2BB2-CEEC57FD4912}" />
- <!-- ".NET Core 3.0.0 Preview 2" 3.0.0-preview-27324-5-win-x86 upgrade-code -->
- <UpgradeRelatedBundle Include="{2210ACC2-5EA6-4707-01F8-B064B94BB1C8}" />
- <!-- ".NET Core 3.0.0 Preview 3" 3.0.0-preview3-27503-5-win-x86 upgrade-code -->
- <UpgradeRelatedBundle Include="{8F802AA7-56BF-69E8-8E15-BE8FF8347CF7}" />
- </ItemGroup>
-
- <ItemGroup Condition="'$(TargetArchitecture)' == 'x64'">
- <!-- ".NET Core 3.0.0 Preview 1" 3.0.0-preview-27122-01-win-x64 upgrade-code -->
- <UpgradeRelatedBundle Include="{C98F9B17-536C-711E-5B31-ADA492F8B956}" />
- <!-- ".NET Core 3.0.0 Preview 2" 3.0.0-preview-27324-5-win-x64 upgrade-code -->
- <UpgradeRelatedBundle Include="{E5F8505A-5282-7C15-4388-83FB730DCC13}" />
- <!-- ".NET Core 3.0.0 Preview 3" 3.0.0-preview3-27503-5-win-x64 upgrade-code -->
- <UpgradeRelatedBundle Include="{31F12178-5807-40A5-6799-2C9C47725A5E}" />
- </ItemGroup>
-
- <ItemGroup Condition="'$(NETCoreAppFrameworkVersion)' == '3.0'">
- <CandleVariables Include="RelatedDotNetBundleIds" Value="@(UpgradeRelatedBundle)" />
- </ItemGroup>
-
</Project>
<String Id="FilesInUseDontCloseRadioButton">&Do not close applications. A reboot will be required.</String>
<String Id="FilesInUseOkButton">&OK</String>
<String Id="FilesInUseCancelButton">&Cancel</String>
- <String Id="WelcomeHeaderMessage">.NET Core Runtime</String>
- <String Id="WelcomeDescription">.NET Core is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform, and supported by Microsoft. We hope you enjoy it!</String>
- <String Id="LearnMoreTitle">Learn more about .NET Core</String>
+ <String Id="WelcomeHeaderMessage">.NET Runtime</String>
+ <String Id="WelcomeDescription">.NET is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform, and supported by Microsoft. We hope you enjoy it!</String>
+ <String Id="LearnMoreTitle">Learn more about .NET</String>
<String Id="SuccessInstallLocation">The following was installed at [DOTNETHOME]</String>
<String Id="SuccessInstallProductName"> - [BUNDLEMONIKER] </String>
<String Id="ResourcesHeader">Resources</String>
<String Id="DocumentationLink"><A HREF="https://aka.ms/dotnet-docs">Documentation</A></String>
<String Id="RelaseNotesLink"><A HREF="https://aka.ms/20-p2-rel-notes">Release Notes</A></String>
<String Id="TutorialLink"><A HREF="https://aka.ms/dotnet-tutorials">Tutorials</A></String>
- <String Id="TelemetryLink"><A HREF="https://aka.ms/dotnet-cli-telemetry">.NET Core Telemetry</A></String>
+ <String Id="TelemetryLink"><A HREF="https://aka.ms/dotnet-cli-telemetry">.NET SDK Telemetry</A></String>
<String Id="PrivacyStatementLink"><A HREF="https://aka.ms/dev-privacy">Privacy Statement</A></String>
<String Id="EulaLink"><A HREF="https://go.microsoft.com/fwlink/?LinkId=329770">.NET Library EULA</A></String>
<String Id="FilesInUseDontCloseRadioButton">不關閉應用程式，需要重新啟動(&D)</String>
<String Id="FilesInUseOkButton">確定(&O)</String>
<String Id="FilesInUseCancelButton">取消(&C)</String>
- <String Id="WelcomeHeaderMessage">.NET Core 執行階段</String>
- <String Id="WelcomeDescription">.NET Core 是開發平台，可用來建置命令列應用程式、微服務和新式網站。其為開放原始碼、跨平台且由 Microsoft 支援。希望您喜歡!</String>
- <String Id="LearnMoreTitle">深入了解 .NET Core</String>
+ <String Id="WelcomeHeaderMessage">.NET 執行階段</String>
+ <String Id="WelcomeDescription">.NET 是開發平台，可用來建置命令列應用程式、微服務和新式網站。其為開放原始碼、跨平台且由 Microsoft 支援。希望您喜歡!</String>
+ <String Id="LearnMoreTitle">深入了解 .NET</String>
<String Id="SuccessInstallLocation">下列項目已安裝在 [DOTNETHOME]</String>
<String Id="SuccessInstallProductName"> - [BUNDLEMONIKER] </String>
<String Id="ResourcesHeader">資源</String>
<String Id="DocumentationLink"><A HREF="https://aka.ms/dotnet-docs">文件</A></String>
<String Id="RelaseNotesLink"><A HREF="https://aka.ms/20-p2-rel-notes">版本資訊</A></String>
<String Id="TutorialLink"><A HREF="https://aka.ms/dotnet-tutorials">教學課程</A></String>
- <String Id="TelemetryLink"><A HREF="https://aka.ms/dotnet-cli-telemetry">.NET Core 遙測</A></String>
+ <String Id="TelemetryLink"><A HREF="https://aka.ms/dotnet-cli-telemetry">.NET 遙測</A></String>
<String Id="PrivacyStatementLink"><A HREF="https://aka.ms/dev-privacy">隱私權聲明</A></String>
<String Id="EulaLink"><A HREF="https://go.microsoft.com/fwlink/?LinkId=329770">.NET 程式庫 EULA</A></String>
<String Id="FilesInUseDontCloseRadioButton">A&plikace nezavírejte. Bude potřeba provést restart.</String>
<String Id="FilesInUseOkButton">&OK</String>
<String Id="FilesInUseCancelButton">&Zrušit</String>
- <String Id="WelcomeHeaderMessage">Modul runtime .NET Core</String>
- <String Id="WelcomeDescription">.NET Core je vývojová platforma, pomocí které lze vytvářet aplikace příkazového řádku, mikroslužby a moderní weby. Je opensourcová, víceplatformová a podporována společností Microsoft. Věříme, že s ní budete spokojeni.</String>
- <String Id="LearnMoreTitle">Další informace o .NET Core</String>
+ <String Id="WelcomeHeaderMessage">Modul runtime .NET</String>
+ <String Id="WelcomeDescription">.NET je vývojová platforma, pomocí které lze vytvářet aplikace příkazového řádku, mikroslužby a moderní weby. Je opensourcová, víceplatformová a podporována společností Microsoft. Věříme, že s ní budete spokojeni.</String>
+ <String Id="LearnMoreTitle">Další informace o .NET</String>
<String Id="SuccessInstallLocation">Do [DOTNETHOME] se nainstalovaly následující položky.</String>
<String Id="SuccessInstallProductName"> - [BUNDLEMONIKER] </String>
<String Id="ResourcesHeader">Prostředky</String>
<String Id="DocumentationLink"><A HREF="https://aka.ms/dotnet-docs">Dokumentace</A></String>
<String Id="RelaseNotesLink"><A HREF="https://aka.ms/20-p2-rel-notes">Zpráva k vydání verze</A></String>
<String Id="TutorialLink"><A HREF="https://aka.ms/dotnet-tutorials">Kurzy</A></String>
- <String Id="TelemetryLink"><A HREF="https://aka.ms/dotnet-cli-telemetry">Telemetrie pro platformu .NET Core</A></String>
+ <String Id="TelemetryLink"><A HREF="https://aka.ms/dotnet-cli-telemetry">Telemetrie pro platformu .NET</A></String>
<String Id="PrivacyStatementLink"><A HREF="https://aka.ms/dev-privacy">Prohlášení o zásadách ochrany osobních údajů</A></String>
<String Id="EulaLink"><A HREF="https://go.microsoft.com/fwlink/?LinkId=329770">Smlouva EULA ke knihovně .NET</A></String>
<String Id="FilesInUseDontCloseRadioButton">&Anwendungen nicht schließen. Ein Neustart ist erforderlich.</String>
<String Id="FilesInUseOkButton">&OK</String>
<String Id="FilesInUseCancelButton">&Abbrechen</String>
- <String Id="WelcomeHeaderMessage">.NET Core-Runtime</String>
- <String Id="WelcomeDescription">.NET Core ist eine Entwicklungsplattform, die Sie zum Erstellen von Befehlszeilenanwendungen, Microservices und modernen Websites verwenden können. Sie ist Open Source und plattformübergreifend und wird von Microsoft unterstützt. Wir wünschen Ihnen viel Spaß!</String>
- <String Id="LearnMoreTitle">Weitere Informationen zu .NET Core</String>
+ <String Id="WelcomeHeaderMessage">.NET-Runtime</String>
+ <String Id="WelcomeDescription">.NET ist eine Entwicklungsplattform, die Sie zum Erstellen von Befehlszeilenanwendungen, Microservices und modernen Websites verwenden können. Sie ist Open Source und plattformübergreifend und wird von Microsoft unterstützt. Wir wünschen Ihnen viel Spaß!</String>
+ <String Id="LearnMoreTitle">Weitere Informationen zu .NET</String>
<String Id="SuccessInstallLocation">Folgendes wurde unter [DOTNETHOME] installiert.</String>
<String Id="SuccessInstallProductName"> - [BUNDLEMONIKER] </String>
<String Id="ResourcesHeader">Ressourcen</String>
<String Id="DocumentationLink"><A HREF="https://aka.ms/dotnet-docs">Dokumentation</A></String>
<String Id="RelaseNotesLink"><A HREF="https://aka.ms/20-p2-rel-notes">Versionshinweise</A></String>
<String Id="TutorialLink"><A HREF="https://aka.ms/dotnet-tutorials">Tutorials</A></String>
- <String Id="TelemetryLink"><A HREF="https://aka.ms/dotnet-cli-telemetry">.NET Core-Telemetrie</A></String>
+ <String Id="TelemetryLink"><A HREF="https://aka.ms/dotnet-cli-telemetry">.NET-Telemetrie</A></String>
<String Id="PrivacyStatementLink"><A HREF="https://aka.ms/dev-privacy">Datenschutzerklärung</A></String>
<String Id="EulaLink"><A HREF="https://go.microsoft.com/fwlink/?LinkId=329770">Lizenzbedingungen für die .NET-Bibliothek</A></String>
<String Id="FilesInUseDontCloseRadioButton">&Do not close applications. A reboot will be required.</String>
<String Id="FilesInUseOkButton">&OK</String>
<String Id="FilesInUseCancelButton">&Cancel</String>
- <String Id="WelcomeHeaderMessage">.NET Core Runtime</String>
- <String Id="WelcomeDescription">.NET Core is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform, and supported by Microsoft. We hope you enjoy it!</String>
- <String Id="LearnMoreTitle">Learn more about .NET Core</String>
+ <String Id="WelcomeHeaderMessage">.NET Runtime</String>
+ <String Id="WelcomeDescription">.NET is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform, and supported by Microsoft. We hope you enjoy it!</String>
+ <String Id="LearnMoreTitle">Learn more about .NET</String>
<String Id="SuccessInstallLocation">The following was installed at [DOTNETHOME]</String>
<String Id="SuccessInstallProductName"> - [BUNDLEMONIKER] </String>
<String Id="ResourcesHeader">Resources</String>
<String Id="DocumentationLink"><A HREF="https://aka.ms/dotnet-docs">Documentation</A></String>
<String Id="RelaseNotesLink"><A HREF="https://aka.ms/20-p2-rel-notes">Release Notes</A></String>
<String Id="TutorialLink"><A HREF="https://aka.ms/dotnet-tutorials">Tutorials</A></String>
- <String Id="TelemetryLink"><A HREF="https://aka.ms/dotnet-cli-telemetry">.NET Core Telemetry</A></String>
+ <String Id="TelemetryLink"><A HREF="https://aka.ms/dotnet-cli-telemetry">.NET Telemetry</A></String>
<String Id="PrivacyStatementLink"><A HREF="https://aka.ms/dev-privacy">Privacy Statement</A></String>
<String Id="EulaLink"><A HREF="https://go.microsoft.com/fwlink/?LinkId=329770">.NET Library EULA</A></String>
<String Id="FilesInUseDontCloseRadioButton">&Ne pas fermer les applications. Un redémarrage sera nécessaire.</String>
<String Id="FilesInUseOkButton">&OK</String>
<String Id="FilesInUseCancelButton">&Annuler</String>
- <String Id="WelcomeHeaderMessage">Runtime .NET Core</String>
- <String Id="WelcomeDescription">.NET Core est une plateforme de développement qui vous permet de générer des applications en ligne de commande, des microservices et des sites web modernes. Il s'agit d'un framework open source, multiplateforme et pris en charge par Microsoft. Nous espérons que vous l'apprécierez !</String>
- <String Id="LearnMoreTitle">En savoir plus sur .NET Core</String>
+ <String Id="WelcomeHeaderMessage">Runtime .NET</String>
+ <String Id="WelcomeDescription">.NET est une plateforme de développement qui vous permet de générer des applications en ligne de commande, des microservices et des sites web modernes. Il s'agit d'un framework open source, multiplateforme et pris en charge par Microsoft. Nous espérons que vous l'apprécierez !</String>
+ <String Id="LearnMoreTitle">En savoir plus sur .NET</String>
<String Id="SuccessInstallLocation">L'élément suivant a été installé sur [DOTNETHOME]</String>
<String Id="SuccessInstallProductName"> - [BUNDLEMONIKER] </String>
<String Id="ResourcesHeader">Ressources</String>
<String Id="DocumentationLink"><A HREF="https://aka.ms/dotnet-docs">Documentation</A></String>
<String Id="RelaseNotesLink"><A HREF="https://aka.ms/20-p2-rel-notes">Notes de publication</A></String>
<String Id="TutorialLink"><A HREF="https://aka.ms/dotnet-tutorials">Tutoriels</A></String>
- <String Id="TelemetryLink"><A HREF="https://aka.ms/dotnet-cli-telemetry">Télémétrie .NET Core</A></String>
+ <String Id="TelemetryLink"><A HREF="https://aka.ms/dotnet-cli-telemetry">Télémétrie .NET</A></String>
<String Id="PrivacyStatementLink"><A HREF="https://aka.ms/dev-privacy">Déclaration de confidentialité</A></String>
<String Id="EulaLink"><A HREF="https://go.microsoft.com/fwlink/?LinkId=329770">CLUF de la bibliothèque .NET</A></String>
<String Id="FilesInUseDontCloseRadioButton">&Non chiudere le applicazioni; sarà necessario riavviare il sistema</String>
<String Id="FilesInUseOkButton">&OK</String>
<String Id="FilesInUseCancelButton">&Annulla</String>
- <String Id="WelcomeHeaderMessage">Runtime di .NET Core</String>
+ <String Id="WelcomeHeaderMessage">Runtime di .NET</String>
<String Id="WelcomeDescription">NET Core è una piattaforma di sviluppo che è possibile usare per creare microservizi, siti Web moderni e applicazioni dalla riga di comando. È open source, multipiattaforma e supportata da Microsoft.</String>
- <String Id="LearnMoreTitle">Altre informazioni su .NET Core</String>
+ <String Id="LearnMoreTitle">Altre informazioni su .NET</String>
<String Id="SuccessInstallLocation">I componenti seguenti sono stati installati in [DOTNETHOME]</String>
<String Id="SuccessInstallProductName"> - [BUNDLEMONIKER] </String>
<String Id="ResourcesHeader">Risorse</String>
<String Id="DocumentationLink"><A HREF="https://aka.ms/dotnet-docs">Documentazione</A></String>
<String Id="RelaseNotesLink"><A HREF="https://aka.ms/20-p2-rel-notes">Note sulla versione</A></String>
<String Id="TutorialLink"><A HREF="https://aka.ms/dotnet-tutorials">Esercitazioni</A></String>
- <String Id="TelemetryLink"><A HREF="https://aka.ms/dotnet-cli-telemetry">Telemetria di .NET Core</A></String>
+ <String Id="TelemetryLink"><A HREF="https://aka.ms/dotnet-cli-telemetry">Telemetria di .NET</A></String>
<String Id="PrivacyStatementLink"><A HREF="https://aka.ms/dev-privacy">Informativa sulla privacy</A></String>
<String Id="EulaLink"><A HREF="https://go.microsoft.com/fwlink/?LinkId=329770">Condizioni di licenza della libreria .NET</A></String>
<String Id="FilesInUseDontCloseRadioButton">アプリケーションを終了させない (コンピューターの再起動が必要になります)(&D)</String>
<String Id="FilesInUseOkButton">OK(&O)</String>
<String Id="FilesInUseCancelButton">キャンセル(&C)</String>
- <String Id="WelcomeHeaderMessage">.NET Core Runtime</String>
- <String Id="WelcomeDescription">.Net Core は、コマンドライン アプリケーション、マイクロサービス、および最新の Web サイトをビルドするために使用できる開発プラットフォームです。オープンソースのクロス プラットフォームで、Microsoft によってサポートされています。お楽しみいただければ幸いです。</String>
- <String Id="LearnMoreTitle">.Net Core の詳細</String>
+ <String Id="WelcomeHeaderMessage">.NET Runtime</String>
+ <String Id="WelcomeDescription">.NET は、コマンドライン アプリケーション、マイクロサービス、および最新の Web サイトをビルドするために使用できる開発プラットフォームです。オープンソースのクロス プラットフォームで、Microsoft によってサポートされています。お楽しみいただければ幸いです。</String>
+ <String Id="LearnMoreTitle">.NET の詳細</String>
<String Id="SuccessInstallLocation">[DOTNETHOME] に以下がインストールされました</String>
<String Id="SuccessInstallProductName"> - [BUNDLEMONIKER] </String>
<String Id="ResourcesHeader">リソース</String>
<String Id="DocumentationLink"><A HREF="https://aka.ms/dotnet-docs">ドキュメント</A></String>
<String Id="RelaseNotesLink"><A HREF="https://aka.ms/20-p2-rel-notes">リリース ノート</A></String>
<String Id="TutorialLink"><A HREF="https://aka.ms/dotnet-tutorials">チュートリアル</A></String>
- <String Id="TelemetryLink"><A HREF="https://aka.ms/dotnet-cli-telemetry">.NET Core テレメトリ</A></String>
+ <String Id="TelemetryLink"><A HREF="https://aka.ms/dotnet-cli-telemetry">.NET テレメトリ</A></String>
<String Id="PrivacyStatementLink"><A HREF="https://aka.ms/dev-privacy">プライバシーに関する声明</A></String>
<String Id="EulaLink"><A HREF="https://go.microsoft.com/fwlink/?LinkId=329770">.NET ライブラリのライセンス条項</A></String>
<String Id="FilesInUseDontCloseRadioButton">애플리케이션을 닫지 않습니다(&D). 다시 부팅해야 합니다.</String>
<String Id="FilesInUseOkButton">확인(&O)</String>
<String Id="FilesInUseCancelButton">취소(&C)</String>
- <String Id="WelcomeHeaderMessage">.NET Core 런타임</String>
- <String Id="WelcomeDescription">.NET Core는 명령줄 애플리케이션, 마이크로 서비스 및 최신 웹 사이트를 빌드하는 데 사용할 수 있는 개발 플랫폼입니다. Microsoft가 지원하는 플랫폼 간 오픈 소스입니다. 즐기시기 바랍니다!</String>
- <String Id="LearnMoreTitle">.NET Core에 대한 자세한 정보</String>
+ <String Id="WelcomeHeaderMessage">.NET 런타임</String>
+ <String Id="WelcomeDescription">.NET는 명령줄 애플리케이션, 마이크로 서비스 및 최신 웹 사이트를 빌드하는 데 사용할 수 있는 개발 플랫폼입니다. Microsoft가 지원하는 플랫폼 간 오픈 소스입니다. 즐기시기 바랍니다!</String>
+ <String Id="LearnMoreTitle">.NET에 대한 자세한 정보</String>
<String Id="SuccessInstallLocation">다음이 [DOTNETHOME]에 설치되었습니다.</String>
<String Id="SuccessInstallProductName"> - [BUNDLEMONIKER] </String>
<String Id="ResourcesHeader">리소스</String>
<String Id="DocumentationLink"><A HREF="https://aka.ms/dotnet-docs">설명서</A></String>
<String Id="RelaseNotesLink"><A HREF="https://aka.ms/20-p2-rel-notes">릴리스 정보</A></String>
<String Id="TutorialLink"><A HREF="https://aka.ms/dotnet-tutorials">자습서</A></String>
- <String Id="TelemetryLink"><A HREF="https://aka.ms/dotnet-cli-telemetry">.NET Core 원격 분석</A></String>
+ <String Id="TelemetryLink"><A HREF="https://aka.ms/dotnet-cli-telemetry">.NET 원격 분석</A></String>
<String Id="PrivacyStatementLink"><A HREF="https://aka.ms/dev-privacy">개인정보처리방침</A></String>
<String Id="EulaLink"><A HREF="https://go.microsoft.com/fwlink/?LinkId=329770">.NET Library EULA</A></String>
<String Id="FilesInUseDontCloseRadioButton">&Nie zamykaj aplikacji. Będzie konieczne ponowne uruchomienie.</String>
<String Id="FilesInUseOkButton">&OK</String>
<String Id="FilesInUseCancelButton">&Anuluj</String>
- <String Id="WelcomeHeaderMessage">Środowisko uruchomieniowe platformy .NET Core</String>
- <String Id="WelcomeDescription">Platforma .NET Core to platforma programistyczna, za pomocą której można kompilować aplikacje poziomu wiersza polecenia, mikrousługi i nowoczesne witryny internetowe. Jest to rozwiązanie typu open source, międzyplatformowe i obsługiwane przez firmę Microsoft. Mamy nadzieję, że Ci się spodoba!</String>
- <String Id="LearnMoreTitle">Dowiedz się więcej o platformie .NET Core</String>
+ <String Id="WelcomeHeaderMessage">Środowisko uruchomieniowe platformy .NET</String>
+ <String Id="WelcomeDescription">Platforma .NET to platforma programistyczna, za pomocą której można kompilować aplikacje poziomu wiersza polecenia, mikrousługi i nowoczesne witryny internetowe. Jest to rozwiązanie typu open source, międzyplatformowe i obsługiwane przez firmę Microsoft. Mamy nadzieję, że Ci się spodoba!</String>
+ <String Id="LearnMoreTitle">Dowiedz się więcej o platformie .NET</String>
<String Id="SuccessInstallLocation">Następujące elementy zainstalowano w [DOTNETHOME]</String>
<String Id="SuccessInstallProductName"> - [BUNDLEMONIKER] </String>
<String Id="ResourcesHeader">Zasoby</String>
<String Id="DocumentationLink"><A HREF="https://aka.ms/dotnet-docs">Dokumentacja</A></String>
<String Id="RelaseNotesLink"><A HREF="https://aka.ms/20-p2-rel-notes">Informacje o wersji</A></String>
<String Id="TutorialLink"><A HREF="https://aka.ms/dotnet-tutorials">Samouczki</A></String>
- <String Id="TelemetryLink"><A HREF="https://aka.ms/dotnet-cli-telemetry">Telemetria programu .NET Core</A></String>
+ <String Id="TelemetryLink"><A HREF="https://aka.ms/dotnet-cli-telemetry">Telemetria programu .NET</A></String>
<String Id="PrivacyStatementLink"><A HREF="https://aka.ms/dev-privacy">Zasady zachowania poufności informacji</A></String>
<String Id="EulaLink"><A HREF="https://go.microsoft.com/fwlink/?LinkId=329770">Umowa licencyjna użytkownika oprogramowania biblioteki .NET</A></String>
<String Id="FilesInUseDontCloseRadioButton">&Não feche os aplicativos. Será necessária uma reinicialização.</String>
<String Id="FilesInUseOkButton">&OK</String>
<String Id="FilesInUseCancelButton">&Cancelar</String>
- <String Id="WelcomeHeaderMessage">Runtime do .NET Core</String>
- <String Id="WelcomeDescription">O .NET Core é uma plataforma de desenvolvimento que você pode usar para criar aplicativos de linha de comando, microsserviços e sites modernos. Trata-se de um software livre, multiplataforma que conta com o suporte da Microsoft. Esperamos que você goste dele!</String>
- <String Id="LearnMoreTitle">Saiba mais sobre o .NET Core</String>
+ <String Id="WelcomeHeaderMessage">Runtime do .NET</String>
+ <String Id="WelcomeDescription">O .NET é uma plataforma de desenvolvimento que você pode usar para criar aplicativos de linha de comando, microsserviços e sites modernos. Trata-se de um software livre, multiplataforma que conta com o suporte da Microsoft. Esperamos que você goste dele!</String>
+ <String Id="LearnMoreTitle">Saiba mais sobre o .NET</String>
<String Id="SuccessInstallLocation">O seguinte foi instalado em [DOTNETHOME]</String>
<String Id="SuccessInstallProductName"> - [BUNDLEMONIKER] </String>
<String Id="ResourcesHeader">Recursos</String>
<String Id="DocumentationLink"><A HREF="https://aka.ms/dotnet-docs">Documentação</A></String>
<String Id="RelaseNotesLink"><A HREF="https://aka.ms/20-p2-rel-notes">Notas sobre a Versão</A></String>
<String Id="TutorialLink"><A HREF="https://aka.ms/dotnet-tutorials">Tutoriais</A></String>
- <String Id="TelemetryLink"><A HREF="https://aka.ms/dotnet-cli-telemetry">Telemetria do .NET Core</A></String>
+ <String Id="TelemetryLink"><A HREF="https://aka.ms/dotnet-cli-telemetry">Telemetria do .NET</A></String>
<String Id="PrivacyStatementLink"><A HREF="https://aka.ms/dev-privacy">Política de Privacidade</A></String>
<String Id="EulaLink"><A HREF="https://go.microsoft.com/fwlink/?LinkId=329770">Termos de licença da Biblioteca do .NET</A></String>
<String Id="FilesInUseDontCloseRadioButton">&Не закрывать приложения. Потребуется перезагрузка.</String>
<String Id="FilesInUseOkButton">О&К</String>
<String Id="FilesInUseCancelButton">&Отмена</String>
- <String Id="WelcomeHeaderMessage">Среда выполнения .NET Core</String>
- <String Id="WelcomeDescription">.NET Core — это платформа разработки, которую можно использовать для создания приложений командной строки, микрослужб и современных веб-сайтов. Это кроссплатформенная система с открытым исходным кодом, которая поддерживается корпорацией Майкрософт. Надеемся, что она вам понравится!</String>
- <String Id="LearnMoreTitle">Дополнительные сведения о .NET Core</String>
+ <String Id="WelcomeHeaderMessage">Среда выполнения .NET</String>
+ <String Id="WelcomeDescription">.NET — это платформа разработки, которую можно использовать для создания приложений командной строки, микрослужб и современных веб-сайтов. Это кроссплатформенная система с открытым исходным кодом, которая поддерживается корпорацией Майкрософт. Надеемся, что она вам понравится!</String>
+ <String Id="LearnMoreTitle">Дополнительные сведения о .NET</String>
<String Id="SuccessInstallLocation">Следующее было установлено в [DOTNETHOME]</String>
<String Id="SuccessInstallProductName"> - [BUNDLEMONIKER] </String>
<String Id="ResourcesHeader">Ресурсы</String>
<String Id="DocumentationLink"><A HREF="https://aka.ms/dotnet-docs">Документация</A></String>
<String Id="RelaseNotesLink"><A HREF="https://aka.ms/20-p2-rel-notes">Заметки о выпуске</A></String>
<String Id="TutorialLink"><A HREF="https://aka.ms/dotnet-tutorials">Руководства</A></String>
- <String Id="TelemetryLink"><A HREF="https://aka.ms/dotnet-cli-telemetry">Телеметрия .NET Core</A></String>
+ <String Id="TelemetryLink"><A HREF="https://aka.ms/dotnet-cli-telemetry">Телеметрия .NET</A></String>
<String Id="PrivacyStatementLink"><A HREF="https://aka.ms/dev-privacy">Заявление о конфиденциальности</A></String>
<String Id="EulaLink"><A HREF="https://go.microsoft.com/fwlink/?LinkId=329770">Лицензионное соглашение для библиотеки .NET</A></String>
<String Id="FilesInUseDontCloseRadioButton">&Uygulamaları kapatmayın. Sistemi yeniden başlatmanız gerekir.</String>
<String Id="FilesInUseOkButton">&Tamam</String>
<String Id="FilesInUseCancelButton">&İptal</String>
- <String Id="WelcomeHeaderMessage">.NET Core Çalışma Zamanı</String>
- <String Id="WelcomeDescription">.NET Core, komut satırı uygulamaları, mikro hizmetler ve modern web siteleri oluşturmak için kullanabileceğiniz bir geliştirme platformudur. Açık kaynaktır, platformlar arası kullanılabilir ve Microsoft tarafından desteklenmektedir. Keyfini çıkarmanızı umuyoruz!</String>
- <String Id="LearnMoreTitle">.NET Core hakkında daha fazla bilgi edinin</String>
+ <String Id="WelcomeHeaderMessage">.NET Çalışma Zamanı</String>
+ <String Id="WelcomeDescription">.NET, komut satırı uygulamaları, mikro hizmetler ve modern web siteleri oluşturmak için kullanabileceğiniz bir geliştirme platformudur. Açık kaynaktır, platformlar arası kullanılabilir ve Microsoft tarafından desteklenmektedir. Keyfini çıkarmanızı umuyoruz!</String>
+ <String Id="LearnMoreTitle">.NET hakkında daha fazla bilgi edinin</String>
<String Id="SuccessInstallLocation">Aşağıdakiler [DOTNETHOME] konumunda yüklendi</String>
<String Id="SuccessInstallProductName"> - [BUNDLEMONIKER] </String>
<String Id="ResourcesHeader">Kaynaklar</String>
<String Id="DocumentationLink"><A HREF="https://aka.ms/dotnet-docs">Belgeler</A></String>
<String Id="RelaseNotesLink"><A HREF="https://aka.ms/20-p2-rel-notes">Sürüm Notları</A></String>
<String Id="TutorialLink"><A HREF="https://aka.ms/dotnet-tutorials">Öğreticiler</A></String>
- <String Id="TelemetryLink"><A HREF="https://aka.ms/dotnet-cli-telemetry">.NET Core Telemetrisi</A></String>
+ <String Id="TelemetryLink"><A HREF="https://aka.ms/dotnet-cli-telemetry">.NET Telemetrisi</A></String>
<String Id="PrivacyStatementLink"><A HREF="https://aka.ms/dev-privacy">Gizlilik Bildirimi</A></String>
<String Id="EulaLink"><A HREF="https://go.microsoft.com/fwlink/?LinkId=329770">.NET Kitaplığı EULA</A></String>
<String Id="FilesInUseDontCloseRadioButton">不关闭应用程序(&D)。需要重启。</String>
<String Id="FilesInUseOkButton">确定(&O)</String>
<String Id="FilesInUseCancelButton">取消(&C)</String>
- <String Id="WelcomeHeaderMessage">.NET Core Runtime</String>
- <String Id="WelcomeDescription">.NET Core 是一种开发平台，可用于生成命令行应用程序、微服务和新式网站。它是开源、跨平台的，且受 Microsoft 支持。希望你喜欢!</String>
- <String Id="LearnMoreTitle">了解有关 .NET Core 的详细信息</String>
+ <String Id="WelcomeHeaderMessage">.NET Runtime</String>
+ <String Id="WelcomeDescription">.NET 是一种开发平台，可用于生成命令行应用程序、微服务和新式网站。它是开源、跨平台的，且受 Microsoft 支持。希望你喜欢!</String>
+ <String Id="LearnMoreTitle">了解有关 .NET 的详细信息</String>
<String Id="SuccessInstallLocation">以下项已安装到 [DOTNETHOME]</String>
<String Id="SuccessInstallProductName"> - [BUNDLEMONIKER] </String>
<String Id="ResourcesHeader">资源</String>
<String Id="DocumentationLink"><A HREF="https://aka.ms/dotnet-docs">文档</A></String>
<String Id="RelaseNotesLink"><A HREF="https://aka.ms/20-p2-rel-notes">发行说明</A></String>
<String Id="TutorialLink"><A HREF="https://aka.ms/dotnet-tutorials">教程</A></String>
- <String Id="TelemetryLink"><A HREF="https://aka.ms/dotnet-cli-telemetry">.NET Core 遥测</A></String>
+ <String Id="TelemetryLink"><A HREF="https://aka.ms/dotnet-cli-telemetry">.NET 遥测</A></String>
<String Id="PrivacyStatementLink"><A HREF="https://aka.ms/dev-privacy">隐私声明</A></String>
<String Id="EulaLink"><A HREF="https://go.microsoft.com/fwlink/?LinkId=329770">.NET 库 EULA</A></String>
<String Id="FilesInUseDontCloseRadioButton">&No cerrar las aplicaciones. Será necesario un reinicio.</String>
<String Id="FilesInUseOkButton">&Aceptar</String>
<String Id="FilesInUseCancelButton">&Cancelar</String>
- <String Id="WelcomeHeaderMessage">.NET Core Runtime</String>
- <String Id="WelcomeDescription">.NET Core es una plataforma de desarrollo que se puede usar para compilar aplicaciones de la línea de comandos, microservicios y sitios web modernos. Es de código abierto, multiplataforma y se admite en Microsoft. Esperamos que la disfrute.</String>
- <String Id="LearnMoreTitle">Más información sobre .NET Core</String>
+ <String Id="WelcomeHeaderMessage">.NET Runtime</String>
+ <String Id="WelcomeDescription">.NET es una plataforma de desarrollo que se puede usar para compilar aplicaciones de la línea de comandos, microservicios y sitios web modernos. Es de código abierto, multiplataforma y se admite en Microsoft. Esperamos que la disfrute.</String>
+ <String Id="LearnMoreTitle">Más información sobre .NET</String>
<String Id="SuccessInstallLocation">Lo siguiente se instaló en [DOTNETHOME]</String>
<String Id="SuccessInstallProductName"> - [BUNDLEMONIKER] </String>
<String Id="ResourcesHeader">Recursos</String>
<String Id="DocumentationLink"><A HREF="https://aka.ms/dotnet-docs">Documentación</A></String>
<String Id="RelaseNotesLink"><A HREF="https://aka.ms/20-p2-rel-notes">Notas de la versión</A></String>
<String Id="TutorialLink"><A HREF="https://aka.ms/dotnet-tutorials">Tutoriales</A></String>
- <String Id="TelemetryLink"><A HREF="https://aka.ms/dotnet-cli-telemetry">Telemetría de .NET Core</A></String>
+ <String Id="TelemetryLink"><A HREF="https://aka.ms/dotnet-cli-telemetry">Telemetría de .NET</A></String>
<String Id="PrivacyStatementLink"><A HREF="https://aka.ms/dev-privacy">Declaración de privacidad</A></String>
<String Id="EulaLink"><A HREF="https://go.microsoft.com/fwlink/?LinkId=329770">CLUF de la biblioteca .NET</A></String>
.Execute(fExpectedToFail: true)
.Should().Fail()
.And.HaveStdErrContaining($"The application '{fileName}' does not exist")
- .And.HaveStdErrContaining($"It was not possible to find any installed .NET Core SDKs");
+ .And.HaveStdErrContaining($"It was not possible to find any installed .NET SDKs");
}
// Return a non-exisitent path that contains a mix of / and \
Directory.CreateDirectory(_regSdkBaseDir);
// Trace messages used to identify from which folder the SDK was picked
- _exeSelectedMessage = $"Using .NET Core SDK dll=[{_exeSdkBaseDir}";
- _regSelectedMessage = $"Using .NET Core SDK dll=[{_regSdkBaseDir}";
+ _exeSelectedMessage = $"Using .NET SDK dll=[{_exeSdkBaseDir}";
+ _regSelectedMessage = $"Using .NET SDK dll=[{_regSdkBaseDir}";
_testOnlyProductBehaviorMarker = TestOnlyProductBehavior.Enable(DotNet.GreatestVersionHostFxrFilePath);
}
.CaptureStdErr()
.Execute(fExpectedToFail: true)
.Should().Fail()
- .And.HaveStdErrContaining("A compatible installed .NET Core SDK for global.json version");
+ .And.HaveStdErrContaining("A compatible installed .NET SDK for global.json version");
// Add SDK versions
AddAvailableSdkVersions(_exeSdkBaseDir, "9999.4.1", "9999.3.4-dummy");
.CaptureStdErr()
.Execute(fExpectedToFail: true)
.Should().Fail()
- .And.HaveStdErrContaining("A compatible installed .NET Core SDK for global.json version");
+ .And.HaveStdErrContaining("A compatible installed .NET SDK for global.json version");
// Add SDK versions
AddAvailableSdkVersions(_regSdkBaseDir, "9999.3.3");
.CaptureStdErr()
.Execute(fExpectedToFail: true)
.Should().Fail()
- .And.HaveStdErrContaining("A compatible installed .NET Core SDK for global.json version");
+ .And.HaveStdErrContaining("A compatible installed .NET SDK for global.json version");
// Add SDK versions
AddAvailableSdkVersions(_exeSdkBaseDir, "9999.3.4");
.CaptureStdErr()
.Execute(fExpectedToFail: true)
.Should().Fail()
- .And.HaveStdErrContaining("A compatible installed .NET Core SDK for global.json version");
+ .And.HaveStdErrContaining("A compatible installed .NET SDK for global.json version");
// Add SDK versions
AddAvailableSdkVersions(_regSdkBaseDir, "9999.3.57", "9999.3.4-dummy");
.CaptureStdErr()
.Execute(fExpectedToFail: true)
.Should().Fail()
- .And.HaveStdErrContaining("A compatible installed .NET Core SDK for global.json version");
+ .And.HaveStdErrContaining("A compatible installed .NET SDK for global.json version");
// Add SDK versions
AddAvailableSdkVersions(_exeSdkBaseDir, "9999.3.300", "9999.7.304-global-dummy");
.CaptureStdErr()
.Execute(fExpectedToFail: true)
.Should().Fail()
- .And.HaveStdErrContaining("A compatible installed .NET Core SDK for global.json version");
+ .And.HaveStdErrContaining("A compatible installed .NET SDK for global.json version");
// Add SDK versions
AddAvailableSdkVersions(_regSdkBaseDir, "9999.3.304");
command.WaitForExit(true)
.Should().Fail()
.And.HaveStdErrContaining($"Showing error dialog for application: '{Path.GetFileName(appExe)}' - error code: 0x{expectedErrorCode}")
- .And.HaveStdErrContaining("To run this application, you need to install a newer version of .NET Core");
+ .And.HaveStdErrContaining("To run this application, you need to install a newer version of .NET");
}
}
Directory.CreateDirectory(_exeSdkBaseDir);
// Trace messages used to identify from which folder the SDK was picked
- _exeSelectedMessage = $"Using .NET Core SDK dll=[{_exeSdkBaseDir}";
+ _exeSelectedMessage = $"Using .NET SDK dll=[{_exeSdkBaseDir}";
}
public void Dispose()
.CaptureStdErr()
.Execute(fExpectedToFail: true)
.Should().Fail()
- .And.HaveStdErrContaining("A compatible installed .NET Core SDK for global.json version")
- .And.HaveStdErrContaining("It was not possible to find any installed .NET Core SDKs")
+ .And.HaveStdErrContaining("A compatible installed .NET SDK for global.json version")
+ .And.HaveStdErrContaining("It was not possible to find any installed .NET SDKs")
.And.HaveStdErrContaining("aka.ms/dotnet-download")
.And.NotHaveStdErrContaining("Checking if resolved SDK dir");
.CaptureStdErr()
.Execute(fExpectedToFail: true)
.Should().Fail()
- .And.HaveStdErrContaining("A compatible installed .NET Core SDK for global.json version")
- .And.NotHaveStdErrContaining("It was not possible to find any installed .NET Core SDKs");
+ .And.HaveStdErrContaining("A compatible installed .NET SDK for global.json version")
+ .And.NotHaveStdErrContaining("It was not possible to find any installed .NET SDKs");
// Add SDK versions
AddAvailableSdkVersions(_exeSdkBaseDir, "9999.3.3");
.CaptureStdErr()
.Execute(fExpectedToFail: true)
.Should().Fail()
- .And.HaveStdErrContaining("A compatible installed .NET Core SDK for global.json version")
- .And.NotHaveStdErrContaining("It was not possible to find any installed .NET Core SDKs");
+ .And.HaveStdErrContaining("A compatible installed .NET SDK for global.json version")
+ .And.NotHaveStdErrContaining("It was not possible to find any installed .NET SDKs");
// Add SDK versions
AddAvailableSdkVersions(_exeSdkBaseDir, "9999.3.4");
.CaptureStdErr()
.Execute(fExpectedToFail: true)
.Should().Fail()
- .And.HaveStdErrContaining("A compatible installed .NET Core SDK for global.json version")
- .And.HaveStdErrContaining("It was not possible to find any installed .NET Core SDKs");
+ .And.HaveStdErrContaining("A compatible installed .NET SDK for global.json version")
+ .And.HaveStdErrContaining("It was not possible to find any installed .NET SDKs");
// Add SDK versions
AddAvailableSdkVersions(_exeSdkBaseDir, "9999.3.57", "9999.3.4-dummy");
.CaptureStdErr()
.Execute(fExpectedToFail: true)
.Should().Fail()
- .And.HaveStdErrContaining("A compatible installed .NET Core SDK for global.json version")
- .And.NotHaveStdErrContaining("It was not possible to find any installed .NET Core SDKs");
+ .And.HaveStdErrContaining("A compatible installed .NET SDK for global.json version")
+ .And.NotHaveStdErrContaining("It was not possible to find any installed .NET SDKs");
// Add SDK versions
AddAvailableSdkVersions(_exeSdkBaseDir, "9999.3.300", "9999.7.304-global-dummy");
.CaptureStdErr()
.Execute(fExpectedToFail: true)
.Should().Fail()
- .And.HaveStdErrContaining("A compatible installed .NET Core SDK for global.json version")
- .And.NotHaveStdErrContaining("It was not possible to find any installed .NET Core SDKs");
+ .And.HaveStdErrContaining("A compatible installed .NET SDK for global.json version")
+ .And.NotHaveStdErrContaining("It was not possible to find any installed .NET SDKs");
// Add SDK versions
AddAvailableSdkVersions(_exeSdkBaseDir, "9999.3.304");
.CaptureStdErr()
.Execute(fExpectedToFail: true)
.Should().Fail()
- .And.HaveStdErrContaining("It was not possible to find any installed .NET Core SDKs")
- .And.HaveStdErrContaining("Install a .NET Core SDK from");
+ .And.HaveStdErrContaining("It was not possible to find any installed .NET SDKs")
+ .And.HaveStdErrContaining("Install a .NET SDK from");
// Add SDK versions
AddAvailableSdkVersions(_exeSdkBaseDir, "9999.0.4");
result
.Should()
.Fail()
- .And.HaveStdErrContaining($"A compatible installed .NET Core SDK for global.json version [{requested}] from [{globalJson}] was not found")
- .And.HaveStdErrContaining($"Install the [{requested}] .NET Core SDK or update [{globalJson}] with an installed .NET Core SDK:");
+ .And.HaveStdErrContaining($"A compatible installed .NET SDK for global.json version [{requested}] from [{globalJson}] was not found")
+ .And.HaveStdErrContaining($"Install the [{requested}] .NET SDK or update [{globalJson}] with an installed .NET SDK:");
}
else
{
{
get
{
- const string IgnoringSDKSettings = "Ignoring SDK settings in global.json: the latest installed .NET Core SDK (including prereleases) will be used";
+ const string IgnoringSDKSettings = "Ignoring SDK settings in global.json: the latest installed .NET SDK (including prereleases) will be used";
// Use invalid JSON
yield return new object[] {
-This project has the purpose to automate verification test for .NET Core Runtime and SDK linux packages.\r
+This project has the purpose to automate verification test for .NET Runtime and SDK linux packages.\r
\r
To have this test running in your local machine do the following steps:\r
1. Download VerificationTestOnDocker.sh, RuntimeInstallation.sh, SdkInstallation.sh, images.txt in the same folder\r
The options are:\r
\r
* \<package> \r
- * runtime - verification test for .NET Core Runtime Linux packages \r
- * sdk - verification test for .NET Core SDK Linux packages\r
+ * runtime - verification test for .NET Runtime Linux packages \r
+ * sdk - verification test for .NET SDK Linux packages\r
* \<version> \r
- * latest - install the latest available .NET Core package from our master repository \r
+ * latest - install the latest available .NET package from our master repository \r
* \<number> - install the package corresponding to this version number \r
* \<command> \r
* install - verification test for install\r
\r
The script VerificationTestOnDocker.sh is responsible for read a file (images.txt) containing docker images and run a docker container for each image specified in that file. Inside each container it will be executed the script to install .NET Runtime (RuntimeInstallation.sh) or .NET SDK (SdkInstallation.sh). \r
\r
-Both scripts RuntimeInstallation.sh and SdkInstallation.sh automatically identify what distro and version is running in the current machine and can install and uninstall the latest version of .NET Core Runtime/Sdk packages corresponding to that distro & version. The installation's stdout for all containers is redirected to a single file (logfile.txt). In the end of this file (logfile.txt) it's also displayed the results of the test, printing for each distro and version the result 'failed' or 'passed'.\r
+Both scripts RuntimeInstallation.sh and SdkInstallation.sh automatically identify what distro and version is running in the current machine and can install and uninstall the latest version of .NET Runtime/Sdk packages corresponding to that distro & version. The installation's stdout for all containers is redirected to a single file (logfile.txt). In the end of this file (logfile.txt) it's also displayed the results of the test, printing for each distro and version the result 'failed' or 'passed'.\r
\r
-.NET Core packages are downloaded from the blob https://dotnetcli.blob.core.windows.net/dotnet\r
+.NET packages are downloaded from the blob https://dotnetcli.blob.core.windows.net/dotnet\r
\r
This project takes in account: \r
-> dotnet-sdk depends on dotnet-runtime and aspnet-runtime \r
-> aspnet-runtime depends on dotnet-runtime (can be different to what dotnet-sdk depends on) \r
-> dotnet-runtime-deps depends on system packages \r
- -> .NET Core runtime carries: dotnet-runtime-deps, dotnet-host, dotnet-hostfxr and dotnet-runtime. \r
+ -> .NET runtime carries: dotnet-runtime-deps, dotnet-host, dotnet-hostfxr and dotnet-runtime. \r
\r
Changes on how dotnet runtime packages are structured or modification on the packages dependencies may affect the verification test result.\r
\r
if [ "$1" == "sdk" ] ; then
InstallationScript="SdkInstallation.sh"
- echo -e ".NET Core SDK varification test result\n" > $InstallationTestResult
+ echo -e ".NET SDK verification test result\n" > $InstallationTestResult
elif [ "$1" == "runtime" ] ; then
InstallationScript="RuntimeInstallation.sh"
- echo -e ".NET Core Runtime varification test result\n" > $InstallationTestResult
+ echo -e ".NET Runtime verification test result\n" > $InstallationTestResult
fi
while IFS='' read -r image || [[ -n "$image" ]]; do
// do it in a way that failures don't cascade.
//
- public static bool IsNetCore => RuntimeInformation.FrameworkDescription.StartsWith(".NET Core", StringComparison.OrdinalIgnoreCase);
+ public static bool IsNetCore => Environment.Version.Major >= 5 || RuntimeInformation.FrameworkDescription.StartsWith(".NET Core", StringComparison.OrdinalIgnoreCase);
public static bool IsMonoRuntime => Type.GetType("Mono.RuntimeStructs") != null;
public static bool IsMonoInterpreter => GetIsRunningOnMonoInterpreter();
public static bool IsFreeBSD => RuntimeInformation.IsOSPlatform(OSPlatform.Create("FREEBSD"));
private void WriteHeader()
{
// do not localize Copyright header
- Console.WriteLine(string.Format(CultureInfo.CurrentCulture, "[Microsoft (R) .NET Core Xml Serialization Generation Utility, Version {0}]", ThisAssembly.InformationalVersion));
- Console.WriteLine("Copyright (C) Microsoft Corporation. All rights reserved.");
+ Console.WriteLine(string.Format(CultureInfo.CurrentCulture, ".NET Xml Serialization Generation Utility, Version {0}]", ThisAssembly.InformationalVersion));
}
private void WriteHelp()
X509_NAME_ENTRY* nameEnt = X509_NAME_get_entry(subject, i);
ASN1_STRING* cn = X509_NAME_ENTRY_get_data(nameEnt);
- // For compatibility with previous .NET Core builds, allow any type of
+ // For compatibility with previous .NET builds, allow any type of
// string for CN, provided it ended up with a single-byte encoding (otherwise
// strncasecmp simply won't match).
if (CheckX509HostnameMatch(cn, name, (int)namelen, cn->type))
// See the LICENSE file in the project root for more information.
// Definitions of structures from OpenSSL 1.0.2, modified as relevant to
-// building .NET Core.
+// building .NET.
// The CRYPTO_EX_DATA struct is smaller in 1.1, which changes the packing of
// dsa_st
// ensure cleanup before doing the creation.
DeleteOU(de, ouName);
- CreateOU(de, ouName, ".Net Core Developers Unit");
+ CreateOU(de, ouName, ".Net Developers Unit");
try
{
SearchOUByName(de, ouName);
<value>Error {0} calling {1}, '{2}'.</value>
</data>
<data name="PlatformNotSupported_WinHttpHandler" xml:space="preserve">
- <value>WinHttpHandler is only supported on .NET Framework and .NET Core runtimes on Windows. It is not supported for Windows Store Applications (UWP) or Unix platforms.</value>
+ <value>WinHttpHandler is only supported on .NET Framework and .NET runtimes on Windows. It is not supported for Windows Store Applications (UWP) or Unix platforms.</value>
</data>
</root>
Interop.SspiCli.SCHANNEL_CRED.Flags.SCH_CRED_NO_DEFAULT_CREDS |
Interop.SspiCli.SCHANNEL_CRED.Flags.SCH_SEND_AUX_RECORD;
- // .NET Core: always opt-in SCH_USE_STRONG_CRYPTO for TLS.
+ // Always opt-in SCH_USE_STRONG_CRYPTO for TLS.
if (((protocolFlags == 0) ||
(protocolFlags & ~(Interop.SChannel.SP_PROT_SSL2 | Interop.SChannel.SP_PROT_SSL3)) != 0)
&& (policy != EncryptionPolicy.AllowNoEncryption) && (policy != EncryptionPolicy.NoEncryption))
[SkipOnTargetFramework(~TargetFrameworkMonikers.Netcoreapp)]
public void VerifyRuntimeNameOnNetCoreApp()
{
- Assert.True(RuntimeInformation.FrameworkDescription.StartsWith(".NET Core"), RuntimeInformation.FrameworkDescription);
+ Assert.True(RuntimeInformation.FrameworkDescription.StartsWith(".NET"), RuntimeInformation.FrameworkDescription);
Assert.Same(RuntimeInformation.FrameworkDescription, RuntimeInformation.FrameworkDescription);
}
try
{
// *** SETUP *** \\
- var sf = new SyndicationFeed("First feed on .net core ever!!", "This is the first feed on .net core ever!", new Uri("https://github.com/dotnet/wcf"));
+ var sf = new SyndicationFeed("First feed on .NET ever!!", "This is the first feed on .NET ever!", new Uri("https://github.com/dotnet/wcf"));
Assert.True(sf != null);
using (XmlWriter xmlw = XmlWriter.Create(filePath))
feed.Authors.Add(author);
//Create item
- SyndicationItem item1 = new SyndicationItem("SyndicationFeed released for .net Core", "A lot of text describing the release of .net core feature", new Uri("http://Contoso.com/news/path"));
+ SyndicationItem item1 = new SyndicationItem("SyndicationFeed released for .NET", "A lot of text describing the release of .NET feature", new Uri("http://Contoso.com/news/path"));
//Add item to feed
List<SyndicationItem> feedList = new List<SyndicationItem> { item1 };
string serializeFilePath = Path.GetTempFileName();
bool toDeletedFile = true;
- SyndicationItem item = new SyndicationItem("SyndicationFeed released for .net Core", "A lot of text describing the release of .net core feature", new Uri("http://contoso.com/news/path"));
+ SyndicationItem item = new SyndicationItem("SyndicationFeed released for .NET", "A lot of text describing the release of .NET feature", new Uri("http://contoso.com/news/path"));
item.Id = "uuid:43481a10-d881-40d1-adf2-99b438c57e21;id=1";
item.LastUpdatedTime = new DateTimeOffset(Convert.ToDateTime("2017-10-11T11:25:55Z")).UtcDateTime;
<entry xmlns="http://www.w3.org/2005/Atom">
<id>uuid:43481a10-d881-40d1-adf2-99b438c57e21;id=1</id>
- <title type="text">SyndicationFeed released for .net Core</title>
+ <title type="text">SyndicationFeed released for .NET</title>
<updated>2017-10-11T11:25:55Z</updated>
<link rel="alternate" href="http://contoso.com/news/path" />
- <content type="text">A lot of text describing the release of .net core feature</content>
+ <content type="text">A lot of text describing the release of .NET feature</content>
</entry>
<a10:id>123FeedID</a10:id>
<item>
<link>http://Contoso.com/news/path</link>
- <title>SyndicationFeed released for .net Core</title>
- <description>A lot of text describing the release of .net core feature</description>
+ <title>SyndicationFeed released for .NET</title>
+ <description>A lot of text describing the release of .NET feature</description>
<author>Contoso Item author</author>
<category>Item Category</category>
<pubdate>Mon, 19 Jun 2017 11:52:39 -0700</pubdate>
<CustomElement>asd</CustomElement>
<item>
<link>http://Contoso.com/news/path</link>
- <title>SyndicationFeed released for .net Core</title>
- <description>A lot of text describing the release of .net core feature</description>
+ <title>SyndicationFeed released for .NET</title>
+ <description>A lot of text describing the release of .NET feature</description>
<author>Contoso Item author</author>
<category>Item Category</category>
<pubdate>Mon, 19 Jun 2017 11:52:39 -0700</pubdate>
</item>
</channel>
-</rss>
\ No newline at end of file
+</rss>
<CustomElement>asd</CustomElement>
<item>
<link>http://Contoso.com/news/path</link>
- <title>SyndicationFeed released for .net Core</title>
- <description>A lot of text describing the release of .net core feature</description>
+ <title>SyndicationFeed released for .NET</title>
+ <description>A lot of text describing the release of .NET feature</description>
<author>Contoso Item author</author>
<category>Item Category</category>
<pubdate>Mon, 19 Jun 2017 11:52:39 -0700</pubdate>
</item>
</channel>
-</rss>
\ No newline at end of file
+</rss>
<CustomElement xmlns="">asd</CustomElement>
<entry>
<id>uuid:71d91f91-f5f9-4175-9065-4b7cb357fc4d;id=1</id>
- <title type="text">SyndicationFeed released for .net Core</title>
+ <title type="text">SyndicationFeed released for .NET</title>
<updated>2017-06-26T21:41:43Z</updated>
<link rel="alternate" href="http://contoso.com/news/path" />
- <content type="text">A lot of text describing the release of .net core feature</content>
+ <content type="text">A lot of text describing the release of .NET feature</content>
</entry>
-</feed>
\ No newline at end of file
+</feed>
<CustomElement xmlns="">asd</CustomElement>
<entry>
<id>EntryId</id>
- <title type="text">SyndicationFeed released for .net Core</title>
+ <title type="text">SyndicationFeed released for .NET</title>
<updated>2017-06-26T21:41:43Z</updated>
<link rel="alternate" href="EntryLinkHref" />
<content src="EntryContentSrc" />
</entry>
-</feed>
\ No newline at end of file
+</feed>
<CustomElement>asd</CustomElement>
<item>
<link>http://Contoso.com/news/path</link>
- <title>SyndicationFeed released for .net Core</title>
- <description>A lot of text describing the release of .net core feature</description>
+ <title>SyndicationFeed released for .NET</title>
+ <description>A lot of text describing the release of .NET feature</description>
<author>Contoso Item author</author>
<category>Item Category</category>
<pubdate>Mon, 19 Jun 2017 11:52:39 -0700</pubdate>
</item>
</channel>
-</rss>
\ No newline at end of file
+</rss>
## Overview
-* Our goal is to provide high-performance JSON APIs built into .NET Core.
+* Our goal is to provide high-performance JSON APIs built into .NET Runtime.
See the [announcement](https://github.com/dotnet/announcements/issues/90) for more details.
- For the first version of the library, our objective is to remove the
dependency on JSON.NET within the shared framework.
- The primary focus will be on core functionality with emphasis on performance
over capabilities and additional features.
- - These APIs will be targeting .NET Core specifically as part of v1.
- Providing a netstandard implementation can be considered in the future.
install-package : NU1605: Detected package downgrade: Microsoft.NETCore.Platforms from 3.0.0-preview6.19251.6 to 3.0.0-preview6.19223.2. Reference the package directly from the project to select a different version.
```
-This can occur if the NuGet client attempts to install a newer version of the package than allowed by the .NET Core version your application is targeting. For now you can work around this error by specifying the explicit package version in the install command. Match the version passed to the NuGet client (shown below) to the version specified in the error message (shown above).
+This can occur if the NuGet client attempts to install a newer version of the package than allowed by the .NET Runtime version your application is targeting. For now you can work around this error by specifying the explicit package version in the install command. Match the version passed to the NuGet client (shown below) to the version specified in the error message (shown above).
```ps
install-package System.Utf8String.Experimental -prerelease -source https://dotnetfeed.blob.core.windows.net/dotnet-core/index.json -version 3.0.0-preview6.19223.2
},
{
"Name": "Microsoft.Extensions.Hosting",
- "Description": ".NET Core hosting and startup infrastructures for applications.",
+ "Description": "Hosting and startup infrastructures for applications.",
"CommonTypes": []
},
{
"Name": "Microsoft.Extensions.Hosting.Abstractions",
- "Description": ".NET Core hosting and startup abstractions for applications.",
+ "Description": "Hosting and startup abstractions for applications.",
"CommonTypes": []
},
{
},
{
"Name": "Microsoft.NETCore.Runtime",
- "Description": "The .NET Core runtime.",
+ "Description": "The .NET runtime.",
"CommonTypes": []
},
{
},
{
"Name": "Microsoft.XmlSerializer.Generator",
- "Description": "Like the Xml Serializer Generator (sgen.exe) on desktop, Microsoft.XmlSerializer.Generator NuGet package is the solution for .NET Core and .NET Standard Libraries. It creates an Xml serialization assembly for types contained in an assembly in order to improve the startup performance of Xml serialization when serializing or de-serializing objects of those types using XmlSerializer.",
+ "Description": "Creates an Xml serialization assembly for types contained in an assembly in order to improve the startup performance of Xml serialization when serializing or de-serializing objects of those types using XmlSerializer.",
"CommonTypes": []
},
{
},
{
"Name": "System.Drawing.Primitives",
- "Description": "Provides basic drawing primitive structures, that exposes the corresponding System.Drawing.dll types in .NET Core.",
+ "Description": "Provides basic drawing primitive structures.",
"CommonTypes": [
"System.Drawing.Color",
"System.Drawing.Point",
<PropertyGroup>
<!-- SDK sets product to assembly but we want it to be our product name -->
- <Product>Microsoft%AE .NET Core</Product>
+ <Product>Microsoft%AE .NET</Product>
- <!-- Use the .NET Core product branding version for informational version description -->
+ <!-- Use the .NET product branding version for informational version description -->
<InformationalVersion>$(ProductVersion)</InformationalVersion>
<InformationalVersion Condition="'$(VersionSuffix)' != ''">$(InformationalVersion)-$(VersionSuffix)</InformationalVersion>
</PropertyGroup>
},
{
"Name": "Microsoft.NETCore.Runtime.Mono",
- "Description": "The Mono .NET Core runtime and the base library, called System.Private.CoreLib. It includes the garbage collector, JIT compiler, base .NET data types and many low-level classes.",
+ "Description": "The Mono .NET Runtime and the base library, called System.Private.CoreLib. It includes the garbage collector, JIT compiler, base .NET data types and many low-level classes.",
"CommonTypes": [ ]
},
{
"Name": "Microsoft.NETCore.Tool.MonoAOT",
- "Description": "The Mono .NET Core AOT compiler for compiling IL into native code targetting a specific platform and architecture.",
+ "Description": "The Mono .NET Runtime AOT compiler for compiling IL into native code targetting a specific platform and architecture.",
"CommonTypes": [ ]
}
]
projects / platform / upstream / dotnet / runtime.git / commitdiff