mirrors/dotnet-installer
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge pull request #706 from blackdwarf/fixmans

Browse source 
Fix README.md files to be like man pages
This commit is contained in:
Piotr Puszkiewicz 2016-01-11 15:23:32 -08:00
commit f90a171457
14 changed files with 764 additions and 349 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

125
Documentation/manpages/dotnet-compile-native.1 Normal file
View file

@ -0,0 +1,125 @@
.\" Automatically generated by Pandoc 1.15.1
.\"
.hy
.TH "dotnet-native" "1" "January 2016" "" ""
.SH NAME
.PP
dotnet\-compile\-native \-\- Compiles IL binaries to native binaries.
.SH SYNOPSIS
.PP
dotnet compile [\-\-appdepsdk] [\-\-configuration] [\-\-ilcargs]
[\-\-linklib] [\-\-logpath] [\-\-mode] [\-\-out] [\-\-reference]
[\-\-temp\-out] [\-\-verbose]
.SH DESCRIPTION
.PP
The \f[C]compile\-native\f[] command compiles IL assemblies to native
machine code.
It is used by \f[C]dotnet\-compile\ \-\-native\f[].
.PP
The output is a native exe that conforms to the architecture of the
underlying operating system (i.e.
running on 64\-bit OS will produce a native 64\-bit exe).
This can be overriden via the \-\-arch switch and specifying the wanted
architecture.
The executable has a default extension of "" on Linux and OS X and
".exe" on Windows.
The source must include a `static void Main(string[] args) entry point
and specify compilerOptions.emitEntryPoint in the project.json.
.PP
Output files are written to the child \f[C]bin\f[] folder, which will be
created if it doesn\[aq]t exist.
Files will be overwritten as needed.
.SH OPTIONS
.PP
\f[C]\-\-appdepsdk\ <SDK_PATH>\f[]
.IP
.nf
\f[C]
Path\ to\ custom\ AppDepSDK
\f[]
.fi
.PP
\f[C]\-c,\ \-\-configuration\ [debug|release]\f[]
.IP
.nf
\f[C]
Build\ configuration.\ Defaults\ to\ `debug`.
\f[]
.fi
.PP
\f[C]\-\-ilcargs\ <args>\f[]
.IP
.nf
\f[C]
Custom\ arguments\ for\ the\ IL\ Compiler.
\f[]
.fi
.PP
\f[C]\-\-ilcpath\ <ILC_PATH>\f[]
.IP
.nf
\f[C]
Path\ to\ a\ custom\ ilc.exe
\f[]
.fi
.PP
\f[C]\-\-linklib\ <LIB_PATH>\f[]
.IP
.nf
\f[C]
Path\ to\ static\ lib\ to\ link
\f[]
.fi
.PP
\f[C]\-\-logpath\ <LOG_PATH>\f[]
.IP
.nf
\f[C]
Enables\ logging\ and\ writes\ native\ compilation\ logs\ to\ the\ given\ path.
\f[]
.fi
.PP
\f[C]\-m,\ \-\-mode\ [cpp|ryujit|custom]\f[]
.IP
.nf
\f[C]
Code\ generation\ mode.\ Defaults\ to\ ryujit.
\f[]
.fi
.PP
\f[C]\-o,\ \-\-out\ directoryname\f[]
.IP
.nf
\f[C]
Output\ directory\ for\ the\ native\ executable.
\f[]
.fi
.PP
\f[C]\-r,\ \-\-reference\f[]
.IP
.nf
\f[C]
Path\ to\ a\ managed\ dll\ reference\ for\ the\ app.
\f[]
.fi
.PP
\f[C]\-t,\ \-\-temp\-out\f[]
.IP
.nf
\f[C]
Specifies\ temporary\ directory\ for\ intermediate\ files.
\f[]
.fi
.PP
\f[C]\-v,\ \-\-verbose\f[]
.IP
.nf
\f[C]
Prints\ verbose\ logging\ information,\ to\ follow\ the\ flow\ of\ execution\ of\ the\ command.
\f[]
.fi
.SH SEE ALSO
.PP
dotnet\-compile(1), dotnet(1), dotnet\-restore(1)
.SH AUTHORS
Zlatko Knezevic zlakne\@microsoft.com.

186
Documentation/manpages/dotnet-compile.1
View file

@ -1,41 +1,35 @@
.\" Automatically generated by Pandoc 1.15.1
.\"
.hy
.TH "dotnet-compiler" "1" "" "" ""
.SH dotnet\-compile
.TH "dotnet-compiler" "1" "January 2016" "" ""
.SH NAME
.PP
dotnet\-compile \-\- Compiles source files for a single project to a
binary format and saves to a target file.
.SH SYNOPSIS
.PP
dotnet compile options (#options)
dotnet compile [\-\-native] [\-\-output] [\-\-temp\-output]
[\-\-framework] [\-\-configuration] [\-\-output] [\-\-arch] [\-\-cpp]
[\-ilc\-args] [\-\-verbose]
.SH DESCRIPTION
.PP
The compile command compiles source files from a single project to a
binary file, either IL byte code or native machine code, depending on
the options provided.
binary file, either intermmediate language (IL) byte code or native
machine code, depending on the options provided.
The default option is compilation to IL byte code, but may change in the
future.
.PP
Users who want to benefit from incremental builds and who want to
compile both the project and its dependencies should use the Build
command.
compile both the project and its dependencies should use the
dotnet\-build(1) command.
.PP
The default IL [\-\-il] output is a PE32 exe [exe], with the default
extension of ".exe" on all OSes.
The exe must include a public static void or public static int main
entry point, or it is an error.
The dll [dll] output option has the default extension of ".dll".
The result of compilation is by default an executable file that can be
ran.
Output files, are written to the child \f[C]bin\f[] folder, which will
be created if it doesn\[aq]t exist.
Files will be overwritten as needed.
The temporary files that are created during compilation are placed in
the child \f[C]obj\f[] folder.
.PP
The IL exe output type needs a runtime host to execute.
The IL exe output type also copies a host to the output directory.
The host is renamed to the name of the exe.
For example, if the file is intended to be "foo" (\f[C]\-o\ foo\f[]),
then the host will be called foo, with the appropriate default native
file extension fo the OS (see the native file extensions, below).
The PE32 exe will be called "[filename]"\-app.exe".
In this case, it would be called "foo\-app.exe".
The executables also require a special configuration section in
project.json:
.IP
@ -64,65 +58,109 @@ The static library [staticlib] option has the default extension of ".a"
on Linux, UNIX and OS X and ".lib" on Windows.
.PP
This command relies on the following artifacts: source files,
project.json project file, project.lock.json temporary file and restored
NuGet dependencies.
project.json project file and the "lock" file (project.lock.json).
Prior to invoking dotnet\-compile, dotnet\-restore(1) should be run to
restore any dependencies that are needed for the application.
.SH OPTIONS
.PP
The project.json file represents and describes the project.
It can contain several setting, which are described in the
Build (https://docs.asp.net/en/latest/dnx/projects.html#building).
The most important information in the project.json file are the root
(not transitive) NuGet dependencies and the files to be compiled.
By default, this is a wildcard \-\- "*.cs".
It supports both inclusion and exclusion semantics.
\f[C]\-n,\ \-\-native\f[]
.IP
.nf
\f[C]
Compiles\ source\ to\ native\ machine\ code,\ for\ the\ local\ machine.\ The\ default\ is\ a\ native\ executable.\ The\ default\ executable\ extension\ is\ no\ extension\ and\ ".exe"\ on\ Windows.
\f[]
.fi
.PP
The project.lock.json file is expanded form of the project.json file.
It includes the transitive closure of the project, per framework.
It is produced by a NuGet client, typically by using the
\f[C]dotnet\ restore\f[] command.
The project.lock.json file can be used by tools to safely determine the
closure of dependencies, without having to manually calculate them.
This file is only intended for tools, is temporary and should not be
checked into source control.
It should be present in .gitignore files.
\f[C]\-t,\ \-\-temp\-output\ <PATH>\f[]
.IP
.nf
\f[C]
Path\ where\ to\ drop\ the\ temporary\ binaries\ that\ are\ produced\ during\ compile.\ By\ default,\ the\ temporary\ binaries\ are\ dropped\ in\ the\ `obj`\ directory\ in\ the\ directory\ where\ `project.json`\ files\ lives,\ that\ is,\ where\ the\ application\ lives.\ \
\f[]
.fi
.PP
It is important to know that a project.lock.json is invalid given that a
project.json has been changed.
The project.lock.json has enough information to determine this state
given a project.json.
The compile command validates this state and will error if the
project.lock.json is invalid.
\f[C]\-f,\ \-\-framework\ <FID>\f[]
.IP
.nf
\f[C]
Compile\ the\ application\ for\ the\ specified\ framework.\ If\ the\ framework\ is\ not\ specified,\ one\ specified\ in\ `project.json`\ will\ be\ used.\
\f[]
.fi
.PP
The compile command relies on NuGet dependencies for compilation, as
references.
These are expected to be found in the user\-local NuGet cache (typically
location here).
It is an error state if a given NuGet package is not found.
\f[C]\-c,\ \-\-configuration\ <CONFIGURATION>\f[]
.IP
.nf
\f[C]
Compile\ the\ application\ under\ the\ specified\ configuration.\ If\ not\ specified,\ the\ configuration\ will\ default\ to\ "Debug".\ \
\f[]
.fi
.PP
Output files, are written to the child \f[C]bin\f[] folder, which will
be created if it doesn\[aq]t exist.
Files will be overwritten as needed.
The temporary files that are created during compilation are placed in
the child \f[C]obj\f[] folder.
.SH Options
\f[C]\-o,\ \-\-output\ filename\f[]
.IP
.nf
\f[C]
Specifies\ the\ filename\ to\ be\ used.\ By\ default,\ the\ resulting\ filename\ will\ be\ the\ same\ as\ the\ project\ name\ specified\ in\ `project.json`,\ if\ one\ exists,\ or\ the\ directory\ in\ which\ the\ source\ files\ reside.\
\f[]
.fi
.PP
\-n, \-\-native [exe | dynlib | lib] Compiles source to native machine
code, for the local machine.
The default is a native executable.
The default exe extension is no extension and ".exe" on Windows.
The default dynlib extension is ".a", ".dynlib" on OS X and ".dll" on
Windows.
\f[C]\-\-no\-project\-dependencies\f[]
.IP
.nf
\f[C]
Skips\ building\ cross\-project\ references.\ The\ effect\ of\ this\ is\ that\ only\ the\ current\ project\ will\ be\ built.\
\f[]
.fi
.PP
\-\-il [exe | dll] Compiles source to IL byte code, which is (typically)
portable across machine types.
The default output is a PE32 exe, with the default extension of ".exe"
on all OSes.
The exe must include a static main entry point, or it is an error.
The DLL output option has the default extension of ".dll".
\f[C]\-a,\ \-\-arch\f[]
.IP
.nf
\f[C]
The\ architecture\ for\ which\ to\ compile.\ x64\ only\ currently\ supported.
\f[]
.fi
.PP
\-o, \-\-output filename Specifies the filename to be used.
It is an error not to specify an output filename.
If no extension is provided, the default one is provided for the output
type.
\f[C]\-\-ilc\-args\ <ARGS>\f[]
.IP
.nf
\f[C]
Specified\ parameters\ are\ passed\ through\ to\ ILC\ and\ are\ used\ by\ the\ engine\ when\ doing\ native\ compilation.\
\f[]
.fi
.PP
\-v, \-\-verbose Prints verbose logging information, to follow the flow
of execution of the command.
\f[C]\-\-cpp\f[]
.IP
.nf
\f[C]
Specify\ the\ C++\ code\ generator\ to\ do\ native\ compilation\ of\ code\ instead\ of\ the\ default\ RyuJIT.\ \ \ \ \ \ \
\f[]
.fi
.PP
\f[C]\-v,\ \-\-verbose\f[]
.IP
.nf
\f[C]
Prints\ verbose\ logging\ information,\ to\ follow\ the\ flow\ of\ execution\ of\ the\ command.
\f[]
.fi
.PP
\f[C]\-h,\ \-\-help\f[]
.IP
.nf
\f[C]
Show\ short\ help.\
\f[]
.fi
.SH ENVIRONMENT
.PP
\f[C]DOTNET_HOME\f[]
.IP
.nf
\f[C]
Points\ to\ the\ base\ directory\ that\ contains\ the\ runtime\ and\ the\ binaries\ directories.\ The\ runtime\ will\ be\ used\ to\ run\ the\ executable\ file\ that\ is\ dropped\ after\ compiling.\ Not\ needed\ for\ native\ compilation.\ \
\f[]
.fi
.SH SEE ALSO
.PP
dotnet\-restore(1), dotnet\-publish(1), dotnet(1)
.SH AUTHORS
Zlatko Knezevic zlakne\@microsoft.com.

57
Documentation/manpages/dotnet-native.1
View file

@ -1,57 +0,0 @@
.\" Automatically generated by Pandoc 1.15.1
.\"
.hy
.TH "dotnet-native" "1" "" "" ""
.SH dotnet\-compile
.SH NAME
.PP
dotnet\-compile\-native \-\- Compiles IL binaries to native binaries.
.SH SYNOPSIS
.PP
dotnet compile options (#options)
.SH DESCRIPTION
.PP
The \f[C]compile\-native\f[] command compiles IL assemblies to native
machine code.
It is used by \f[C]dotnet\-compile\ \-\-native\f[].
.PP
The output is a native exe that conforms to the architecture of the
underlying operating system (i.e.
running on 64\-bit OS will produce a native 64\-bit exe).
This can be overriden via the \-\-arch switch and specifying the wanted
architecture.
The executable has a default extension of "" on Linux and OS X and
".exe" on Windows.
The source must include a `static void Main(string[] args) entry point
and specify compilerOptions.emitEntryPoint in the project.json.
.PP
Output files are written to the child \f[C]bin\f[] folder, which will be
created if it doesn\[aq]t exist.
Files will be overwritten as needed.
.SH Options
.PP
\-\-appdepsdk Path to custom AppDepSDK
.PP
\-c, \-\-configuration [debug|release] Build configuration.
Defaults to \f[C]debug\f[].
.PP
\-\-ilcargs Custom arguments for the IL Compiler.
.PP
\-\-ilcpath Path to a custom ilc.exe
.PP
\-\-linklib Path to static lib to link
.PP
\-\-logpath Enables logging and writes native compilation logs to the
given path.
.PP
\-m, \-\-mode [cpp|ryujit|custom] Code generation mode.
Defaults to ryujit.
.PP
\-o, \-\-out directoryname Output directory for the native executable.
.PP
\-r, \-\-reference Path to a managed dll reference for the app.
.PP
\-t, \-\-temp\-out Specifies temporary directory for intermediate files.
.PP
\-v, \-\-verbose Prints verbose logging information, to follow the flow
of execution of the command.

15
Documentation/manpages/dotnet-new.1
View file

@ -1,11 +1,10 @@
.\" Automatically generated by Pandoc 1.15.1
.\"
.hy
.TH "dotnet-new" "1" "" "" ""
.SH dotnet\-new
.TH "dotnet-new" "1" "January 2016" "" ""
.SH NAME
.PP
dotnet\-new \-\- Create a new sample project
dotnet\-new \-\- Create a new sample .NET Core project
.SH SYNOPSIS
.PP
dotnet new
@ -25,7 +24,15 @@ A valid \f[C]project.json\f[] file
After this, the project is ready to be compiled and/or edited further.
.SH EXAMPLES
.PP
\f[C]dotnet\ new\f[] Drops a sample in the current directory.
\f[C]dotnet\ new\f[]
.IP
.nf
\f[C]
Drops\ a\ sample\ in\ the\ current\ directory.
\f[]
.fi
.SH SEE ALSO
.PP
dotnet\-run(1)
.SH AUTHORS
Zlatko Knezevic zlakne\@microsoft.com.

137
Documentation/manpages/dotnet-publish.1
View file

@ -1,89 +1,114 @@
.\" Automatically generated by Pandoc 1.15.1
.\"
.hy
.TH "dotnet-publish" "1" "" "" ""
.SH dotnet\-publish
.TH "dotnet-publish" "1" "January 2016" "" ""
.SH NAME
.PP
\f[C]dotnet\-publish\f[] > packs the application and all of its
\f[C]dotnet\-publish\f[] \- packs the application and all of its
dependencies into a folder getting it ready for publishing
.SH SYNOPSIS
.PP
\f[C]dotnet\-publish\ [options]\ [project]\f[]
dotnet\-publish [\-\-framework] [\-\-runtime] [\-\-output]
[\-\-configuration]
.PD 0
.P
.PD
[< project >]
.SH DESCRIPTION
.PP
\f[C]dotnet\-publish\f[] will compile the application, read through its
dependencies specified in \f[I]project.json\f[] and publish the
dependencies specified in \f[C]project.json\f[] and publish the
resulting set of files to a directory.
This directory contains the assemblies, the runtime as well as the
runnable version of the application.
This directory will contain the assemblies, the runtime as well as the
executable version of the application.
This directory can then be moved to a different machine and the
application will be able to be ran regardless of existence of any other
application will be able to run regardless of existence of any other
runtime.
.PP
\f[C]dotnet\-publish\f[] needs access to \f[I]project.json\f[] to work.
If it is not specified on invocation via [project],
\f[I]project.json\f[] in the current directory will be the default.
If no \f[I]project.json\f[] can be found, \f[C]dotnet\-publish\f[] will
error out.
The native dependencies of the runtime are not packaged with the
application.
This means that the target machine needs to have the native dependencies
installed in order for the application to run.
.SH OPTIONS
.PP
The command also requires information on the targeted framework and
runtime, both of which can be specified on the command line.
If the runtime is not specified, the command will default to the runtime
for the current operating system.
If the framework is not specified, the command will read the information
from the \f[I]project.json\f[] file.
In case of no valid framework found, the command will error out.
In case of multiple valid frameworks found, the command will publish for
all valid frameworks.
.SH Options
.PP
\f[C]\-f\f[], \f[C]\-\-framework\f[] [FID]
.PP
Publish the application for a given framework identifier (FID).
If not specified, FID is read from \f[I]project.json\f[].
.PP
\f[C]\-r\f[], \f[C]\-\-runtime\f[] [RID]
.PP
Publish the application for a given runtime.
Supported values for runtimes at this time are:
\f[C][project]\f[]
.IP
.nf
\f[C]
*\ ubuntu.14.04\-x64
*\ win7\-x64
*\ osx.10.10\-x64
`dotnet\-publish`\ needs\ access\ to\ `project.json`\ to\ work.\ If\ it\ is\ not\ specified\ on\ invocation\ via\ [project],\ `project.json`\ in\ the\ current\ directory\ will\ be\ the\ default.\ \ \ \ \ If\ no\ `project.json`\ can\ be\ found,\ `dotnet\-publish`\ will\ error\ out.\ `dotnet\-publish`\ command\ also\ requires\ certain\ dependencies\ in\ the\ `project.json`\ to\ work.\ Namely\ the\ `Microsoft.NETCore.Runtime`\ package\ must\ be\ referenced\ as\ a\ dependency\ in\ order\ for\ the\ command\ to\ copy\ the\ runtime\ files\ as\ well\ as\ the\ application\[aq]s\ files\ to\ the\ published\ location.\ \
\f[]
.fi
.PP
\f[C]\-f\f[], \f[C]\-\-framework\f[] [FID]
.IP
.nf
\f[C]
Publish\ the\ application\ for\ a\ given\ framework\ identifier\ (FID).\ If\ not\ specified,\ FID\ is\ read\ from\ `project.json`.\ In\ case\ of\ no\ valid\ framework\ found,\ the\ command\ will\ error\ out.\ In\ case\ of\ multiple\ valid\ frameworks\ found,\ the\ command\ will\ publish\ for\ all\ valid\ frameworks.\
\f[]
.fi
.PP
\f[C]\-r\f[], \f[C]\-\-runtime\f[] [RID]
.IP
.nf
\f[C]
Publish\ the\ application\ for\ a\ given\ runtime.\ If\ the\ option\ is\ not\ specified,\ the\ command\ will\ default\ to\ the\ runtime\ for\ the\ current\ operationg\ system.\ Supported\ values\ for\ the\ option\ at\ this\ time\ are:
\ \ \ \ *\ ubuntu.14.04\-x64
\ \ \ \ *\ win7\-x64
\ \ \ \ *\ osx.10.10\-x64
\f[]
.fi
.PP
\f[C]\-o\f[], \f[C]\-\-output\f[]
.PP
Specify the path where to place the directory.
If not specified, will default to
\f[I]\&./bin/[configuration]/[framework]/[runtime]/\f[]
.IP
.nf
\f[C]
Specify\ the\ path\ where\ to\ place\ the\ directory.\ If\ not\ specified,\ will\ default\ to\ _./bin/[configuration]/[framework]/[runtime]/_
\f[]
.fi
.PP
\f[C]\-c\f[], \f[C]\-\-configuration\ [Debug|Release]\f[]
.PP
Configuration to use when publishing.
If not specified, will default to "Debug".
.IP
.nf
\f[C]
Configuration\ to\ use\ when\ publishing.\ If\ not\ specified,\ will\ default\ to\ "Debug".
\f[]
.fi
.SH EXAMPLES
.PP
\f[C]dotnet\-publish\f[] >Publish the current application using the
\f[I]project.json\f[] framework and runtime for the current operating
system.
\f[C]dotnet\-publish\f[]
.IP
.nf
\f[C]
Publish\ the\ current\ application\ using\ the\ `project.json`\ framework\ and\ runtime\ for\ the\ current\ operating\ system.\
\f[]
.fi
.PP
\f[C]dotnet\-publish\ ~/projects/app1/project.json\f[] >Publish the
application using the specified \f[I]project.json\f[]; also use
framework specified withing and runtime for the current operating
system.
\f[C]dotnet\-publish\ ~/projects/app1/project.json\f[]
.IP
.nf
\f[C]
Publish\ the\ application\ using\ the\ specified\ `project.json`;\ also\ use\ framework\ specified\ withing\ and\ runtime\ for\ the\ current\ operating\ system.\
\f[]
.fi
.PP
\f[C]dotnet\-publish\ \-\-framework\ dnxcore50\f[] >Publish the current
application using the \f[C]dnxcore50\f[] framework and runtime for the
current operating system.
\f[C]dotnet\-publish\ \-\-framework\ dnxcore50\f[]
.IP
.nf
\f[C]
Publish\ the\ current\ application\ using\ the\ `dnxcore50`\ framework\ and\ runtime\ for\ the\ current\ operating\ system.\
\f[]
.fi
.PP
\f[C]dotnet\-publish\ \-\-framework\ dnxcore50\ \-\-runtime\ osx.10.10\-x64\f[]
>Publish the current application using the \f[C]dnxcore50\f[] framework
and runtime for \f[C]OS\ X\ 10.10\f[]
.IP
.nf
\f[C]
Publish\ the\ current\ application\ using\ the\ `dnxcore50`\ framework\ and\ runtime\ for\ `OS\ X\ 10.10`
\f[]
.fi
.SH SEE ALSO
.PP
\f[C]dotnet\-restore\f[]
dotnet\-restore(1), dotnet\-compile(1)
.SH AUTHORS
Zlatko Knezevic zlakne\@microsoft.com.

35
Documentation/manpages/dotnet-run.1
View file

@ -1,15 +1,14 @@
.\" Automatically generated by Pandoc 1.15.1
.\"
.hy
.TH "dotnet-run" "1" "" "" ""
.SH dotnet\-run
.TH "dotnet-run" "1" "January 2016" "" ""
.SH NAME
.PP
dotnet\-run \-\- Runs source code \[aq]in\-place\[aq] without any
explicit compile or launch commands.
.SH SYNOPSIS
.PP
dotnet run options (#options)
\f[C]dotnet\ run\ [\-\-verbose]\f[]
.SH DESCRIPTION
.PP
The run command provides a convenient option to run source code with one
@ -20,11 +19,10 @@ This command is useful for fast iterative development and can also be
used to run a source\-distributed program (e.g.
website).
.PP
This command relies on the compile
command (https://github.com/dotnet/cli/issues/48) to compile source
This command relies on \f[C]dotnet\-compile(1)\f[] to compile source
inputs to a .NET assembly, before launching the program.
The requirements for and handling of source inputs for this command are
all inhereted from the compile command.
all inherited from the compile command.
The documentation for the compile command provides more information on
those requirements.
.PP
@ -32,7 +30,26 @@ Output files, are written to the child \f[C]bin\f[] folder, which will
be created if it doesn\[aq]t exist.
Files will be overwritten as needed.
Temporary files are written to the child \f[C]obj\f[] folder.
.SH Options
.SH OPTIONS
.PP
\-v, \-\-verbose Prints verbose logging information, to follow the flow
of execution of the command.
\-v, \-\-verbose
.IP
.nf
\f[C]
Prints\ verbose\ logging\ information,\ to\ follow\ the\ flow\ of\ execution\ of\ the\ command.
\f[]
.fi
.SH ENVIRONMENT
.PP
\f[C]DOTNET_HOME\f[]
.IP
.nf
\f[C]
Points\ to\ the\ base\ directory\ that\ contains\ the\ runtime\ and\ the\ binaries\ directories.\ The\ runtime\ will\ be\ used\ to\ run\ the\ executable\ file\ that\ is\ dropped\ after\ compiling.\ Not\ needed\ for\ native\ compilation.\ \ \
\f[]
.fi
.SH SEE ALSO
.PP
dotnet\-compile(1), dotnet\-publish(1)
.SH AUTHORS
Zlatko Knezevic zlakne\@microsoft.com.

152
Documentation/manpages/dotnet.1
View file

@ -1,34 +1,160 @@
.\" Automatically generated by Pandoc 1.15.1
.\"
.hy
.TH "dotnet-cli" "1" "" "" ""
.SH dotnet
.TH "dotnet-cli" "1" "January 2016" "" ""
.SH NAME
.PP
dotnet \-\- general driver for running the command\-line commands
.SH SYNOPSIS
.PP
dotnet [common\-options] [command] arguments (#arguments)
dotnet [\-\-version] [\-\-help] [\-\-verbose] < command > [< args >]
.SH DESCRIPTION
.PP
dotnet is a generic driver for the CLI toolchain.
Invoked on its own, it will give out brief usage instructions.
.PP
Each specific feature is implemented as a command.
In order to use the feautre, it is specified after dotnet, i.e.
dotnet compile.
In order to use the feature, it is specified after dotnet, i.e.
\f[C]dotnet\ compile\f[].
All of the arguments following the command are command\[aq]s own
arguments.
.SH Arguments
.SH OPTIONS
.PP
\-v, \-\-verbose Enable verbose output
\f[C]\-v,\ \-\-verbose\f[]
.IP
.nf
\f[C]
Enable\ verbose\ output.
\f[]
.fi
.PP
\-\-version Print out the version of the CLI tooling
.SH Commands
\f[C]\-\-version\f[]
.IP
.nf
\f[C]
Print\ out\ the\ version\ of\ the\ CLI\ tooling
\f[]
.fi
.PP
There are many possible commands that you can use.
The few main ones are: * run \- run your code from source * compile \-
compile your source code * publish \- publish
\f[C]\-h,\ \-\-help\f[]
.IP
.nf
\f[C]
Print\ out\ a\ short\ help\ and\ a\ list\ of\ current\ commands.\
\f[]
.fi
.SH DOTNET COMMANDS
.PP
The following commands exist for dotnet.
.PP
\f[C]dotnet\-compile(1)\f[]
.IP
.nf
\f[C]
Compile\ the\ application\ to\ either\ an\ intermidiate\ language\ (IL)\ or\ to\ a\ native\ binary.\
\f[]
.fi
.PP
\f[C]dotnet\-restore(1)\f[]
.IP
.nf
\f[C]
Restores\ the\ dependencies\ for\ a\ given\ application.\
\f[]
.fi
.PP
\f[C]dotnet\-run(1)\f[]
.IP
.nf
\f[C]
Runs\ the\ application\ from\ source.
\f[]
.fi
.PP
\f[C]dotnet\-publish(1)\f[]
.IP
.nf
\f[C]
Publishes\ a\ flat\ directory\ that\ contains\ the\ application\ and\ its\ dependencies,\ including\ the\ runtime\ binaries.\
\f[]
.fi
.PP
\f[C]dotnet\-test(1)\f[]
.IP
.nf
\f[C]
Runs\ tests\ using\ a\ test\ runner\ specified\ in\ project.json.
\f[]
.fi
.PP
\f[C]dotnet\-new(1)\f[]
.IP
.nf
\f[C]
Initializes\ a\ sample\ .NET\ Core\ console\ application.\
\f[]
.fi
.SH EXAMPLES
.PP
\f[C]dotnew\ new\f[]
.IP
.nf
\f[C]
Initializes\ a\ sample\ .NET\ Core\ console\ application\ that\ can\ be\ compiled\ and\ ran.
\f[]
.fi
.PP
\f[C]dotnet\ restore\f[]
.IP
.nf
\f[C]
Restores\ dependencies\ for\ a\ given\ application.\
\f[]
.fi
.PP
\f[C]dotnet\ compile\f[]
.IP
.nf
\f[C]
Compiles\ the\ application\ in\ a\ given\ directory.\
\f[]
.fi
.SH ENVIRONMENT
.PP
\f[C]DOTNET_HOME\f[]
.IP
.nf
\f[C]
Points\ to\ the\ base\ directory\ that\ contains\ the\ runtime\ and\ the\ binaries\ directories.\ The\ runtime\ will\ be\ used\ to\ run\ the\ executable\ file\ that\ is\ dropped\ after\ compiling.\ Not\ needed\ for\ native\ compilation.\ \
\f[]
.fi
.PP
\f[C]DOTNET_PACKAGES\f[]
.IP
.nf
\f[C]
The\ primary\ package\ cache.\ If\ not\ set,\ defaults\ to\ $HOME/.nuget/packages\ on\ Unix\ or\ %LOCALAPPDATA%\\NuGet\\Packages\ (TBD)\ on\ Windows.
\f[]
.fi
.PP
\f[C]DOTNET_PACKAGES_CACHE\f[]
.IP
.nf
\f[C]
The\ secondary\ cache.\ This\ is\ used\ by\ shared\ hosters\ (such\ as\ Azure)\ to\ provide\ a\ cache\ of\ pre\-downloaded\ common\ packages\ on\ a\ faster\ disk.\ If\ not\ set\ it\ is\ not\ used.
\f[]
.fi
.PP
\f[C]DOTNET_SERVICING\f[]
.IP
.nf
\f[C]
Specifies\ the\ location\ of\ the\ servicing\ index\ to\ use\ by\ the\ shared\ host\ when\ loading\ the\ runtime.\
\f[]
.fi
.SH SEE ALSO
.PP
dotnet\-compile dotnet\-run dotnet\-publish
dotnet\-compile(1), dotnet\-run(1), dotnet\-publish(1),
dotnet\-restore(1)
.SH AUTHORS
Zlatko Knezevic zlakne\@microsoft.com.

93
src/Microsoft.DotNet.Cli/README.md
View file

@ -1,5 +1,6 @@
dotnet
======
% DOTNET(1)
% Zlatko Knezevic zlakne@microsoft.com
% January 2016
# NAME
@ -7,30 +8,86 @@ dotnet -- general driver for running the command-line commands
# SYNOPSIS
dotnet [common-options] [command] [arguments]
dotnet [--version] [--help] [--verbose] < command > [< args >]
# DESCRIPTION
dotnet is a generic driver for the CLI toolchain. Invoked on its own, it will give out brief usage instructions.
Each specific feature is implemented as a command. In order to use the feautre, it is specified after dotnet, i.e. dotnet compile. All of the arguments following the command are command's own arguments.
Each specific feature is implemented as a command. In order to use the feature, it is specified after dotnet, i.e. `dotnet compile`. All of the arguments following the command are command's own arguments.
# Arguments
-v, --verbose
Enable verbose output
# OPTIONS
`-v, --verbose`
--version
Print out the version of the CLI tooling
Enable verbose output.
# Commands
`--version`
There are many possible commands that you can use. The few main ones are:
* run - run your code from source
* compile - compile your source code
* publish - publish
Print out the version of the CLI tooling
`-h, --help`
Print out a short help and a list of current commands.
# DOTNET COMMANDS
The following commands exist for dotnet.
`dotnet-compile(1)`
Compile the application to either an intermidiate language (IL) or to a native binary.
`dotnet-restore(1)`
Restores the dependencies for a given application.
`dotnet-run(1)`
Runs the application from source.
`dotnet-publish(1)`
Publishes a flat directory that contains the application and its dependencies, including the runtime binaries.
`dotnet-test(1)`
Runs tests using a test runner specified in project.json.
`dotnet-new(1)`
Initializes a sample .NET Core console application.
# EXAMPLES
`dotnew new`
Initializes a sample .NET Core console application that can be compiled and ran.
`dotnet restore`
Restores dependencies for a given application.
`dotnet compile`
Compiles the application in a given directory.
# ENVIRONMENT
`DOTNET_HOME`
Points to the base directory that contains the runtime and the binaries directories. The runtime will be used to run the executable file that is dropped after compiling. Not needed for native compilation.
`DOTNET_PACKAGES`
The primary package cache. If not set, defaults to $HOME/.nuget/packages on Unix or %LOCALAPPDATA%\NuGet\Packages (TBD) on Windows.
`DOTNET_PACKAGES_CACHE`
The secondary cache. This is used by shared hosters (such as Azure) to provide a cache of pre-downloaded common packages on a faster disk. If not set it is not used.
`DOTNET_SERVICING`
Specifies the location of the servicing index to use by the shared host when loading the runtime.
# SEE ALSO
dotnet-compile
dotnet-run
dotnet-publish
dotnet-compile(1), dotnet-run(1), dotnet-publish(1), dotnet-restore(1)

59
src/Microsoft.DotNet.Tools.Compiler.Csc/README.md
View file

@ -2,17 +2,17 @@ dotnet-compile
===========
# NAME
dotnet-compile -- Compiles source files to a binary format and saves to a target file.
dotnet-compile -- Compiles source files for a single project to a binary format and saves to a target file.
# SYNOPSIS
dotnet compile [options]
dotnet compile [--output] [--temp-output] [--framework] [--configuration] [--output] [--arch] [--verbose]
# DESCRIPTION
The compile command compiles source files to a binary file, either IL byte code or native machine code, depending on the options provided. The default option is compilation to IL byte code, but may change in the future.
The compile command compiles source files from a single project to a binary file, either intermmediate language (IL) byte code or native machine code, depending on the options provided. The default option is compilation to IL byte code, but may change in the future. Users who want to benefit from incremental builds and who want to compile both the project and its dependencies should use the dotnet-build(1) command.
The default IL [--il] output is a PE32 exe [exe], with the default extension of ".exe" on all OSes. The exe must include a public static void or public static int main entry point, or it is an error. The dll [dll] output option has the default extension of ".dll".
The IL exe output type needs a runtime host to execute. The IL exe output type also copies a host to the output directory. The host is renamed to the name of the exe. For example, if the file is intended to be "foo" (`-o foo`), then the host will be called foo, with the appropriate default native file extension fo the OS (see the native file extensions, below). The PE32 exe will be called "[filename]"-app.exe". In this case, it would be called "foo-app.exe". The executables also require a special configuration section in project.json:
The result of compilation is by default an executable file that can be ran. Output files, are written to the child `bin` folder, which will be created if it doesn't exist. Files will be overwritten as needed. The temporary files that are created during compilation are placed in the child `obj` folder.
The executables also require a special configuration section in project.json:
```json
{
@ -24,28 +24,47 @@ The IL exe output type needs a runtime host to execute. The IL exe output type a
The default native [--native] output is a native exe that conforms to the architecture of the underlying operating system (i.e. running on 64-bit OS will produce a native 64-bit exe). This can be overriden via the --arch switch and specifying the wanted architecture. The executable has a default extension of "" on Linux and OS X and ".exe" on Windows. The source must include a static void main entry point, or it is an error, unless otherwise specified in the project.json. The dynamic library [dylib] output option has the default extension of ".so" on Linux/UNIX, ".dynlib" on OS X and ".dll" on Windows. The static library [staticlib] option has the default extension of ".a" on Linux, UNIX and OS X and ".lib" on Windows.
This command relies on the following artifacts: source files, project.json project file, project.lock.json temporary file and restored NuGet dependencies.
This command relies on the following artifacts: source files, project.json project file and the "lock" file (project.lock.json). Prior to invoking dotnet-compile, dotnet-restore(1) should be run to restore any dependencies that are needed for the application.
The project.json file represents and describes the project. It can contain several setting, which are described in the [Build](https://docs.asp.net/en/latest/dnx/projects.html#building). The most important information in the project.json file are the root (not transitive) NuGet dependencies and the files to be compiled. By default, this is a wildcard -- "*.cs". It supports both inclusion and exclusion semantics.
# OPTIONS
The project.lock.json file is expanded form of the project.json file. It includes the transitive closure of the project, per framework. It is produced by a NuGet client, typically by using the `dotnet restore` command. The project.lock.json file can be used by tools to safely determine the closure of dependencies, without having to manually calculate them. This file is only intended for tools, is temporary and should not be checked into source control. It should be present in .gitignore files.
`-n, --native`
Compiles source to native machine code, for the local machine. The default is a native executable. The default executable extension is no extension and ".exe" on Windows.
It is important to know that a project.lock.json is invalid given that a project.json has been changed. The project.lock.json has enough information to determine this state given a project.json. The compile command validates this state and will error if the project.lock.json is invalid.
`-t, --temp-output <PATH>`
Path where to drop the temporary binaries that are produced during compile. By default, the temporary binaries are dropped in the `obj` directory in the directory where `project.json` files lives, that is, where the application lives.
The compile command relies on NuGet dependencies for compilation, as references. These are expected to be found in the user-local NuGet cache (typically location here). It is an error state if a given NuGet package is not found.
`-f, --framework <FID>`
Compile the application for the specified framework. If the framework is not specified, one specified in `project.json` will be used.
Output files, are written to the child `bin` folder, which will be created if it doesn't exist. Files will be overwritten as needed. The temporary files that are created during compilation are placed in the child `obj` folder.
`-c, --configuration <CONFIGURATION>`
Compile the application under the specified configuration. If not specified, the configuration will default to "Debug".
# Options
`-o, --output filename`
Specifies the filename to be used. By default, the resulting filename will be the same as the project name specified in `project.json`, if one exists, or the directory in which the source files reside.
-n, --native [exe | dynlib | lib]
Compiles source to native machine code, for the local machine. The default is a native executable. The default exe extension is no extension and ".exe" on Windows. The default dynlib extension is ".a", ".dynlib" on OS X and ".dll" on Windows.
`--no-project-dependencies`
Skips building cross-project references. The effect of this is that only the current project will be built.
--il [exe | dll]
Compiles source to IL byte code, which is (typically) portable across machine types. The default output is a PE32 exe, with the default extension of ".exe" on all OSes. The exe must include a static main entry point, or it is an error. The DLL output option has the default extension of ".dll".
`-a, --arch`
The architecture for which to compile. x64 only currently supported.
-o, --output filename
Specifies the filename to be used. It is an error not to specify an output filename. If no extension is provided, the default one is provided for the output type.
`--ilc-args <ARGS>`
Specified parameters are passed through to ILC and are used by the engine when doing native compilation.
-v, --verbose
`--cpp`
Specify the C++ code generator to do native compilation of code instead of the default RyuJIT.
`-v, --verbose`
Prints verbose logging information, to follow the flow of execution of the command.
`-h, --help`
Show short help.
# ENVIRONMENT
`DOTNET_HOME`
Points to the runtime that will be used to run the executable file that is dropped after compiling. Not needed for native compilation.
# SEE ALSO
dotnet-restore(1), dotnet-publish(1), dotnet(1)

70
src/Microsoft.DotNet.Tools.Compiler.Native/README.md
View file

@ -1,11 +1,15 @@
dotnet-compile
===========
% DOTNET-COMPILE-NATIVE(1)
% Zlatko Knezevic zlakne@microsoft.com
% January 2016
# NAME
dotnet-compile-native -- Compiles IL binaries to native binaries.
# SYNOPSIS
dotnet compile [options]
dotnet compile [--appdepsdk] [--configuration]
[--ilcargs] [--linklib] [--logpath]
[--mode] [--out] [--reference]
[--temp-out] [--verbose]
# DESCRIPTION
The `compile-native` command compiles IL assemblies to native machine code. It is used by `dotnet-compile --native`.
@ -14,37 +18,51 @@ The output is a native exe that conforms to the architecture of the underlying o
Output files are written to the child `bin` folder, which will be created if it doesn't exist. Files will be overwritten as needed.
# Options
# OPTIONS
--appdepsdk <SDK_PATH>
Path to custom AppDepSDK
`--appdepsdk <SDK_PATH>`
Path to custom AppDepSDK
-c, --configuration [debug|release]
Build configuration. Defaults to `debug`.
`-c, --configuration [debug|release]`
Build configuration. Defaults to `debug`.
--ilcargs <args>
Custom arguments for the IL Compiler.
`--ilcargs <args>`
Custom arguments for the IL Compiler.
--ilcpath <ILC_PATH>
Path to a custom ilc.exe
`--ilcpath <ILC_PATH>`
Path to a custom ilc.exe
--linklib <LIB_PATH>
Path to static lib to link
`--linklib <LIB_PATH>`
Path to static lib to link
--logpath <LOG_PATH>
Enables logging and writes native compilation logs to the given path.
`--logpath <LOG_PATH>`
Enables logging and writes native compilation logs to the given path.
-m, --mode [cpp|ryujit|custom]
Code generation mode. Defaults to ryujit.
`-m, --mode [cpp|ryujit|custom]`
Code generation mode. Defaults to ryujit.
-o, --out directoryname
Output directory for the native executable.
`-o, --out directoryname`
Output directory for the native executable.
-r, --reference
Path to a managed dll reference for the app.
`-r, --reference`
Path to a managed dll reference for the app.
-t, --temp-out
Specifies temporary directory for intermediate files.
`-t, --temp-out`
Specifies temporary directory for intermediate files.
-v, --verbose
Prints verbose logging information, to follow the flow of execution of the command.
`-v, --verbose`
Prints verbose logging information, to follow the flow of execution of the command.
# SEE ALSO
dotnet-compile(1), dotnet(1), dotnet-restore(1)

80
src/Microsoft.DotNet.Tools.Compiler/README.md
View file

@ -1,20 +1,21 @@
dotnet-compile
===========
% DOTNET-COMPILE(1)
% Zlatko Knezevic zlakne@microsoft.com
% January 2016
# NAME
dotnet-compile -- Compiles source files for a single project to a binary format and saves to a target file.
# SYNOPSIS
dotnet compile [options]
dotnet compile [--native] [--output]
[--temp-output] [--framework] [--configuration]
[--output] [--arch] [--cpp] [-ilc-args] [--verbose]
# DESCRIPTION
The compile command compiles source files from a single project to a binary file, either IL byte code or native machine code, depending on the options provided. The default option is compilation to IL byte code, but may change in the future.
The compile command compiles source files from a single project to a binary file, either intermmediate language (IL) byte code or native machine code, depending on the options provided. The default option is compilation to IL byte code, but may change in the future. Users who want to benefit from incremental builds and who want to compile both the project and its dependencies should use the dotnet-build(1) command.
Users who want to benefit from incremental builds and who want to compile both the project and its dependencies should use the Build command.
The default IL [--il] output is a PE32 exe [exe], with the default extension of ".exe" on all OSes. The exe must include a public static void or public static int main entry point, or it is an error. The dll [dll] output option has the default extension of ".dll".
The IL exe output type needs a runtime host to execute. The IL exe output type also copies a host to the output directory. The host is renamed to the name of the exe. For example, if the file is intended to be "foo" (`-o foo`), then the host will be called foo, with the appropriate default native file extension fo the OS (see the native file extensions, below). The PE32 exe will be called "[filename]"-app.exe". In this case, it would be called "foo-app.exe". The executables also require a special configuration section in project.json:
The result of compilation is by default an executable file that can be ran. Output files, are written to the child `bin` folder, which will be created if it doesn't exist. Files will be overwritten as needed. The temporary files that are created during compilation are placed in the child `obj` folder.
The executables also require a special configuration section in project.json:
```json
{
@ -26,28 +27,59 @@ The IL exe output type needs a runtime host to execute. The IL exe output type a
The default native [--native] output is a native exe that conforms to the architecture of the underlying operating system (i.e. running on 64-bit OS will produce a native 64-bit exe). This can be overriden via the --arch switch and specifying the wanted architecture. The executable has a default extension of "" on Linux and OS X and ".exe" on Windows. The source must include a static void main entry point, or it is an error, unless otherwise specified in the project.json. The dynamic library [dylib] output option has the default extension of ".so" on Linux/UNIX, ".dynlib" on OS X and ".dll" on Windows. The static library [staticlib] option has the default extension of ".a" on Linux, UNIX and OS X and ".lib" on Windows.
This command relies on the following artifacts: source files, project.json project file, project.lock.json temporary file and restored NuGet dependencies.
This command relies on the following artifacts: source files, project.json project file and the "lock" file (project.lock.json). Prior to invoking dotnet-compile, dotnet-restore(1) should be run to restore any dependencies that are needed for the application.
The project.json file represents and describes the project. It can contain several setting, which are described in the [Build](https://docs.asp.net/en/latest/dnx/projects.html#building). The most important information in the project.json file are the root (not transitive) NuGet dependencies and the files to be compiled. By default, this is a wildcard -- "*.cs". It supports both inclusion and exclusion semantics.
# OPTIONS
The project.lock.json file is expanded form of the project.json file. It includes the transitive closure of the project, per framework. It is produced by a NuGet client, typically by using the `dotnet restore` command. The project.lock.json file can be used by tools to safely determine the closure of dependencies, without having to manually calculate them. This file is only intended for tools, is temporary and should not be checked into source control. It should be present in .gitignore files.
`-n, --native`
Compiles source to native machine code, for the local machine. The default is a native executable. The default executable extension is no extension and ".exe" on Windows.
It is important to know that a project.lock.json is invalid given that a project.json has been changed. The project.lock.json has enough information to determine this state given a project.json. The compile command validates this state and will error if the project.lock.json is invalid.
`-t, --temp-output <PATH>`
Path where to drop the temporary binaries that are produced during compile. By default, the temporary binaries are dropped in the `obj` directory in the directory where `project.json` files lives, that is, where the application lives.
The compile command relies on NuGet dependencies for compilation, as references. These are expected to be found in the user-local NuGet cache (typically location here). It is an error state if a given NuGet package is not found.
`-f, --framework <FID>`
Compile the application for the specified framework. If the framework is not specified, one specified in `project.json` will be used.
Output files, are written to the child `bin` folder, which will be created if it doesn't exist. Files will be overwritten as needed. The temporary files that are created during compilation are placed in the child `obj` folder.
`-c, --configuration <CONFIGURATION>`
Compile the application under the specified configuration. If not specified, the configuration will default to "Debug".
# Options
`-o, --output filename`
Specifies the filename to be used. By default, the resulting filename will be the same as the project name specified in `project.json`, if one exists, or the directory in which the source files reside.
-n, --native [exe | dynlib | lib]
Compiles source to native machine code, for the local machine. The default is a native executable. The default exe extension is no extension and ".exe" on Windows. The default dynlib extension is ".a", ".dynlib" on OS X and ".dll" on Windows.
`--no-project-dependencies`
Skips building cross-project references. The effect of this is that only the current project will be built.
--il [exe | dll]
Compiles source to IL byte code, which is (typically) portable across machine types. The default output is a PE32 exe, with the default extension of ".exe" on all OSes. The exe must include a static main entry point, or it is an error. The DLL output option has the default extension of ".dll".
`-a, --arch`
The architecture for which to compile. x64 only currently supported.
-o, --output filename
Specifies the filename to be used. It is an error not to specify an output filename. If no extension is provided, the default one is provided for the output type.
`--ilc-args <ARGS>`
Specified parameters are passed through to ILC and are used by the engine when doing native compilation.
-v, --verbose
Prints verbose logging information, to follow the flow of execution of the command.
`--cpp`
Specify the C++ code generator to do native compilation of code instead of the default RyuJIT.
`-v, --verbose`
Prints verbose logging information, to follow the flow of execution of the command.
`-h, --help`
Show short help.
# ENVIRONMENT
`DOTNET_HOME`
Points to the base directory that contains the runtime and the binaries directories. The runtime will be used to run the executable file that is dropped after compiling. Not needed for native compilation.
# SEE ALSO
dotnet-restore(1), dotnet-publish(1), dotnet(1)

8
src/Microsoft.DotNet.Tools.New/README.md
View file

@ -1,8 +1,9 @@
dotnet-new
===========
% DOTNET-NEW(1)
% Zlatko Knezevic zlakne@microsoft.com
% January 2016
# NAME
dotnet-new -- Create a new sample project
dotnet-new -- Create a new sample .NET Core project
# SYNOPSIS
dotnet new
@ -20,6 +21,7 @@ After this, the project is ready to be compiled and/or edited further.
# EXAMPLES
`dotnet new`
Drops a sample in the current directory.
# SEE ALSO

72
src/Microsoft.DotNet.Tools.Publish/README.md
View file

@ -1,76 +1,70 @@
dotnet-publish
==============
% DOTNET-PUBLISH(1)
% Zlatko Knezevic zlakne@microsoft.com
% January 2016
# NAME
`dotnet-publish`
> packs the application and all of its dependencies into a folder getting it ready for publishing
`dotnet-publish` - packs the application and all of its dependencies into a folder getting it ready for publishing
# SYNOPSIS
`dotnet-publish [options] [project]`
dotnet-publish [--framework]
[--runtime] [--output]
[--configuration]
[< project >]
# DESCRIPTION
`dotnet-publish` will compile the application, read through its dependencies specified in _project.json_ and publish the resulting set of files to a directory.
This directory contains the assemblies, the runtime as well as the runnable version of the application.
This directory can then be moved to a different machine and the application will be able to be ran regardless of existence of any other runtime.
`dotnet-publish` will compile the application, read through its dependencies specified in `project.json` and publish the resulting set of files to a directory.
This directory will contain the assemblies, the runtime as well as the executable version of the application. This directory can then be moved to a different machine and the application will be able to run regardless of existence of any other runtime.
`dotnet-publish` needs access to _project.json_ to work.
If it is not specified on invocation via [project], _project.json_ in the current directory will be the default.
If no _project.json_ can be found, `dotnet-publish` will error out.
The native dependencies of the runtime are not packaged with the application. This means that the target machine needs to have the native dependencies installed in order for the application to run.
`dotnet-publish` command also requires certain dependencies in the _project.json_ to work. Namely the `Microsoft.NETCore.Runtime` package must be referenced as a dependency in order for the command to copy the runtime files as well as the application's files to the published location.
# OPTIONS
The command also requires information on the targeted framework and runtime, both of which can be specified on the command line.
If the runtime is not specified, the command will default to the runtime for the current operating system.
If the framework is not specified, the command will read the information from the _project.json_ file.
In case of no valid framework found, the command will error out.
In case of multiple valid frameworks found, the command will publish for all valid frameworks.
# Options
`[project]`
`dotnet-publish` needs access to `project.json` to work. If it is not specified on invocation via [project], `project.json` in the current directory will be the default. If no `project.json` can be found, `dotnet-publish` will error out. `dotnet-publish` command also requires certain dependencies in the `project.json` to work. Namely the `Microsoft.NETCore.Runtime` package must be referenced as a dependency in order for the command to copy the runtime files as well as the application's files to the published location.
`-f`, `--framework` [FID]
Publish the application for a given framework identifier (FID).
If not specified, FID is read from _project.json_.
Publish the application for a given framework identifier (FID). If not specified, FID is read from `project.json`. In case of no valid framework found, the command will error out. In case of multiple valid frameworks found, the command will publish for all valid frameworks.
`-r`, `--runtime` [RID]
Publish the application for a given runtime.
Supported values for runtimes at this time are:
Publish the application for a given runtime. If the option is not specified, the command will default to the runtime for the current operationg system. Supported values for the option at this time are:
* ubuntu.14.04-x64
* win7-x64
* osx.10.10-x64
* ubuntu.14.04-x64
* win7-x64
* osx.10.10-x64
`-o`, `--output`
Specify the path where to place the directory.
If not specified, will default to _./bin/[configuration]/[framework]/[runtime]/_
Specify the path where to place the directory. If not specified, will default to _./bin/[configuration]/[framework]/[runtime]/_
`-c`, `--configuration [Debug|Release]`
Configuration to use when publishing.
If not specified, will default to "Debug".
Configuration to use when publishing. If not specified, will default to "Debug".
# EXAMPLES
`dotnet-publish`
>Publish the current application using the _project.json_ framework and runtime for the current operating system.
Publish the current application using the `project.json` framework and runtime for the current operating system.
`dotnet-publish ~/projects/app1/project.json`
>Publish the application using the specified _project.json_; also use framework specified withing and runtime for the current operating system.
Publish the application using the specified `project.json`; also use framework specified withing and runtime for the current operating system.
`dotnet-publish --framework dnxcore50`
>Publish the current application using the `dnxcore50` framework and runtime for the current operating system.
Publish the current application using the `dnxcore50` framework and runtime for the current operating system.
`dotnet-publish --framework dnxcore50 --runtime osx.10.10-x64`
>Publish the current application using the `dnxcore50` framework and runtime for `OS X 10.10`
Publish the current application using the `dnxcore50` framework and runtime for `OS X 10.10`
# SEE ALSO
`dotnet-restore`
dotnet-restore(1), dotnet-compile(1)

24
src/Microsoft.DotNet.Tools.Run/README.md
View file

@ -1,20 +1,32 @@
dotnet-run
===========
% DOTNET-RUN(1)
% Zlatko Knezevic zlakne@microsoft.com
% January 2016
# NAME
dotnet-run -- Runs source code 'in-place' without any explicit compile or launch commands.
# SYNOPSIS
dotnet run [options]
`dotnet run [--verbose]`
# DESCRIPTION
The run command provides a convenient option to run source code with one command. It compiles source code, generates an output program and then runs that program. This command is useful for fast iterative development and can also be used to run a source-distributed program (e.g. website).
This command relies on the [compile command](https://github.com/dotnet/cli/issues/48) to compile source inputs to a .NET assembly, before launching the program. The requirements for and handling of source inputs for this command are all inhereted from the compile command. The documentation for the compile command provides more information on those requirements.
This command relies on `dotnet-compile(1)` to compile source inputs to a .NET assembly, before launching the program. The requirements for and handling of source inputs for this command are all inherited from the compile command. The documentation for the compile command provides more information on those requirements.
Output files, are written to the child `bin` folder, which will be created if it doesn't exist. Files will be overwritten as needed. Temporary files are written to the child `obj` folder.
# Options
# OPTIONS
-v, --verbose
Prints verbose logging information, to follow the flow of execution of the command.
Prints verbose logging information, to follow the flow of execution of the command.
# ENVIRONMENT
`DOTNET_HOME`
Points to the base directory that contains the runtime and the binaries directories. The runtime will be used to run the executable file that is dropped after compiling. Not needed for native compilation.
# SEE ALSO
dotnet-compile(1), dotnet-publish(1)