Posted
about 11 years
ago
by
jeevanjj
|
Posted
about 11 years
ago
by
jeevanjj
|
Posted
about 11 years
ago
by
jeevanjj
ConsoleFx assemblies and deployment scenarios
ConsoleFx ships with 2 assemblies:
ConsoleFx.dll: Contains the core classes, the parser and the classes needed to create simple and complex command-line applications using the fluent API.
... [More]
ConsoleFx.Interactive.dll: Contains the classes needed to create an interactive shell application.
The ConsoleFx.Interactive assembly has a dependency on the ConsoleFx assembly.
Deployment scenarios
Normally, when using ConsoleFx in your CLI application, you will have to ship your application with the necessary ConsoleFX assemblies. However, most CLI applications tend to be self-contained and are normally only a single executable file. If you wish to deploy your application as a single executable file, or you simply do not want to ship your application with the ConsoleFx assemblies, you can use any of these options:
Option 1 (recommended) : Embed ConsoleFx source code in your application project
The recommended deployment option is to include the required ConsoleFx source code directly into your CLI application's code and compile the whole thing into a single executable.This is made easy with the availability of ConsoleFx's code packages on NuGet, which embed the source code into your project, instead of adding references to the assemblies.And the best part is - whenever ConsoleFx gets updated, you get the option to update your project to the latest version, so you're always up-to-date.Currently, the following code packages are available on NuGet:
ConsoleFx.Code - the core framework with the fluent API
Option 2 : Embed the ConsoleFx DLLs in your application and load them on demand
From Jeffrey Richter's blog post at http://blogs.msdn.com/b/microsoft_press/archive/2010/02/03/jeffrey-richter-excerpt-2-from-clr-via-c-third-edition.aspx, you can embed the ConsoleFx DLLs as resources in your console application and load them dynamically when the application starts.
Option 3 : Merge your assemblies using the ILMerge tool
ILMerge is a free utility that can be used to merge multiple .NET assemblies into a single assembly.It is available http://research.microsoft.com/en-us/people/mbarnett/ILMerge.aspx. The download link to the latest version is at http://www.microsoft.com/en-us/download/details.aspx?id=17630.Using ILMerge, you can merge one or more ConsoleFx assemblies into your CLI executable file to produce a single executable. ILMerge /target:exe /out:MyConsoleApp.exe MyApp.exe ConsoleFx.dll ConsoleFx.Interactive.dll Typically, you would perform this step as a post-build action, or as part of your continuous integration process.
[Less]
|
Posted
about 11 years
ago
by
jeevanjj
ConsoleFx assemblies and deployment scenarios
ConsoleFx ships with 2 assemblies:
ConsoleFx.dll: Contains the core classes, the parser and the classes needed to create simple and complex command-line applications using the fluent API.
... [More]
ConsoleFx.Interactive.dll: Contains the classes needed to create an interactive shell application.
The ConsoleFx.Interactive assembly has a dependency on the ConsoleFx assembly.
Deployment scenarios
Normally, when using ConsoleFx in your CLI application, you will have to ship your application with the necessary ConsoleFX assemblies. However, most CLI applications tend to be self-contained and are normally only a single executable file. If you wish to deploy your application as a single executable file, or you simply do not want to ship your application with the ConsoleFx assemblies, you can use any of these options:
Option 1 (recommended) : Embed ConsoleFx source code in your application project
The recommended deployment option is to include the required ConsoleFx source code directly into your CLI application's code and compile the whole thing into a single executable.This is made easy with the availability of ConsoleFx's code packages on NuGet, which embed the source code into your project, instead of adding references to the assemblies.And the best part is - whenever ConsoleFx gets updated, you get the option to update your project to the latest version, so you're always up-to-date.Currently, the following code packages are available on NuGet:
ConsoleFx.Code - the core framework with the fluent API
Option 2 : Embed the ConsoleFx DLLs in your application and load them on demand
From Jeffrey Richter's blog post at http://blogs.msdn.com/b/microsoft_press/archive/2010/02/03/jeffrey-richter-excerpt-2-from-clr-via-c-third-edition.aspx, you can embed the ConsoleFx DLLs as resources in your console application and load them dynamically when the application starts.
Option 3 : Merge your assemblies using the ILMerge tool
ILMerge is a free utility that can be used to merge multiple .NET assemblies into a single assembly.It is available http://research.microsoft.com/en-us/people/mbarnett/ILMerge.aspx. The download link to the latest version is at http://www.microsoft.com/en-us/download/details.aspx?id=17630.Using ILMerge, you can merge one or more ConsoleFx assemblies into your CLI executable file to produce a single executable. ILMerge /target:exe /out:MyConsoleApp.exe MyApp.exe ConsoleFx.dll ConsoleFx.Interactive.dll Typically, you would perform this step as a post-build action, or as part of your continuous integration process. [Less]
|
Posted
about 11 years
ago
by
jeevanjj
ConsoleFx assemblies and deployment scenarios
ConsoleFx ships with 2 assemblies:
ConsoleFx.dll: Contains the core classes, the parser and the classes needed to create simple and complex command-line applications using the fluent API.
... [More]
ConsoleFx.Interactive.dll: Contains the classes needed to create an interactive shell application.
The ConsoleFx.Interactive assembly has a dependency on the ConsoleFx assembly.
Deployment scenarios
Normally, when using ConsoleFx in your CLI application, you will have to ship your application with the necessary ConsoleFX assemblies. However, most CLI applications tend to be self-contained and are normally only a single executable file. If you wish to deploy your application as a single executable file, or you simply do not want to ship your application with the ConsoleFx assemblies, you can use any of these options:
Option 1 (recommended) : Embed ConsoleFx source code in your application project
The recommended deployment option is to include the required ConsoleFx source code directly into your CLI application's code and compile the whole thing into a single executable.This is made easy with the availability of ConsoleFx's code packages on NuGet, which embed the source code into your project, instead of adding references to the assemblies.And the best part is - whenever ConsoleFx gets updated, you get the option to update your project to the latest version, so you're always up-to-date.Currently, the following code packages are available on NuGet:
ConsoleFx.Code - the core framework with the fluent API
Option 2 : Embed the ConsoleFx DLLs in your application and load them on demand
From Jeffrey Richter's blog post at http://blogs.msdn.com/b/microsoft_press/archive/2010/02/03/jeffrey-richter-excerpt-2-from-clr-via-c-third-edition.aspx, you can embed the ConsoleFx DLLs as resources in your console application and load them dynamically when the application starts.
Option 3 : Merge your assemblies using the ILMerge tool
ILMerge is a free utility that can be used to merge multiple .NET assemblies into a single assembly.It is available http://research.microsoft.com/en-us/people/mbarnett/ILMerge.aspx. The download link to the latest version is at http://www.microsoft.com/en-us/download/details.aspx?id=17630.Using ILMerge, you can merge one or more ConsoleFx assemblies into your CLI executable file to produce a single executable. ILMerge /target:exe /out:MyConsoleApp.exe MyApp.exe ConsoleFx.dll ConsoleFx.Interactive.dll Typically, you would perform this step as a post-build action, or as part of your continuous integration process. [Less]
|
Posted
about 11 years
ago
by
jeevanjj
ConsoleFx assemblies and deployment scenarios
ConsoleFx ships with 2 assemblies:
ConsoleFx.dll: Contains the core classes, the parser and the classes needed to create simple and complex command-line applications using the fluent API.
... [More]
ConsoleFx.Interactive.dll: Contains the classes needed to create an interactive shell application.
The ConsoleFx.Interactive assembly has a dependency on the ConsoleFx assembly.
Deployment scenarios
Normally, when using ConsoleFx in your CLI application, you will have to ship your application with the necessary ConsoleFX assemblies. However, most CLI applications tend to be self-contained and are normally only a single executable file. If you wish to deploy your application as a single executable file, or you simply do not want to ship your application with the ConsoleFx assemblies, you can use any of these options:
Option 1 (recommended) : Embed ConsoleFx source code in your application project
The recommended deployment option is to include the required ConsoleFx source code directly into your CLI application's code and compile the whole thing into a single executable.This is made easy with the availability of ConsoleFx's code packages on NuGet, which embed the source code into your project, instead of adding references to the assemblies.And the best part is - whenever ConsoleFx gets updated, you get the option to update your project to the latest version, so you're always up-to-date.Currently, the following code packages are available on NuGet:
ConsoleFx.Code - the core framework with the fluent API
Option 2 : Embed the ConsoleFx DLLs in your application and load them on demand
From Jeffrey Richter's blog post at http://blogs.msdn.com/b/microsoft_press/archive/2010/02/03/jeffrey-richter-excerpt-2-from-clr-via-c-third-edition.aspx, you can embed the ConsoleFx DLLs as resources in your console application and load them dynamically when the application starts.
Option 3 : Merge your assemblies using the ILMerge tool
ILMerge is a free utility that can be used to merge multiple .NET assemblies into a single assembly.It is available http://research.microsoft.com/en-us/people/mbarnett/ILMerge.aspx. The download link to the latest version is at http://www.microsoft.com/en-us/download/details.aspx?id=17630.Using ILMerge, you can merge one or more ConsoleFx assemblies into your CLI executable file to produce a single executable. ILMerge /target:exe /out:MyConsoleApp.exe MyApp.exe ConsoleFx.dll ConsoleFx.Interactive.dll Typically, you would perform this step as a post-build action, or as part of your continuous integration process.
[Less]
|
Posted
about 11 years
ago
by
jeevanjj
Documentation | Project Roadmap | NuGet
Project Description
ConsoleFx is a .NET library to build command-line applications with support for command-line argument parsing/handling, including error handling and validationsUsing the ConsoleFx
... [More]
command-line parser, you can specify a whole host of conditions for specifying command-line arguments. These can include the ability to:
Enforce the order of the command-line arguments
Specify switch options and limit the number of times they can occur as command-line arguments
Allow parameters to be specified for switch options, and limit the number of parameters that can be specified
Specify non-switch arguments and how they are to be used
Run custom validations on switch parameters and non-switch arguments, including tests for regular expressions, file masks, integers, booleans, enums, etc.
Automatically map non-switch arguments to strong-typed properties for easier readability
In addition, ConsoleFx also provides the following extras:
A separate command-line parsing engine that can be used in non-CLI applications like Windows Forms and WPF applications.
Ability to create an interactive command-line shell application that utilizes ConsoleFx's build-in parser to handle input.
Utility classes for console output capturing and extensions to the Console class. We plan to add other utility classes in the future, making it the all-in-one solution for creating your command-line applications.
We have a large documentation section with Getting Started guides, advanced topics and references for ConsoleFx. In particular, check out our Getting Started guide to writing a simple console application to get a quick start on using ConsoleFx.
Overview
ConsoleFx provides a fluent API for specifying the rules for processing command-line arguments.For example, the following code creates a command-line application that supports these signatures:
BACKUP [/type:Full|Incremental] [/verbose] <directory to backup>
BACKUP /?
var backupApp = new ConsoleProgram(includeHelpSupport: true);
backupApp.AddOption("type", "t", expectedParameters: 1)
.ValidateWith(new EnumValidator(typeof(BackupTypes))))
.AssignTo(() => BackupType);
backupApp.AddOption("verbose", "v")
.Flag(() => VerboseOutput);
backupApp.AddArgument()
.ValidateWith(new PathValidator { PathType = PathType.Directory, CheckIfExists = true })
.AssignTo(() => DirectoryToBackup);
backupApp.Run();
NuGet Support
The ConsoleFx binaries and code are now available through NuGet.
ConsoleFx binaries package
ConsoleFx code package
ConsoleFx Interactive Shell binaries package
ConsoleFx Interactive Shell code package
See the ConsoleFx assemblies and deployment scenarios section for scenarios on using the code packages. [Less]
|
Posted
about 11 years
ago
by
jeevanjj
Documentation | Project Roadmap | NuGet
Project Description
ConsoleFx is a .NET library to build command-line applications with support for command-line argument parsing/handling, including error handling and validationsUsing the ConsoleFx
... [More]
command-line parser, you can specify a whole host of conditions for specifying command-line arguments. These can include the ability to:
Enforce the order of the command-line arguments
Specify switch options and limit the number of times they can occur as command-line arguments
Allow parameters to be specified for switch options, and limit the number of parameters that can be specified
Specify non-switch arguments and how they are to be used
Run custom validations on switch parameters and non-switch arguments, including tests for regular expressions, file masks, integers, booleans, enums, etc.
Automatically map non-switch arguments to strong-typed properties for easier readability
In addition, ConsoleFx also provides the following extras:
A separate command-line parsing engine that can be used in non-CLI applications like Windows Forms and WPF applications.
Ability to create an interactive command-line shell application that utilizes ConsoleFx's build-in parser to handle input.
Utility classes for console output capturing and extensions to the Console class. We plan to add other utility classes in the future, making it the all-in-one solution for creating your command-line applications.
We have a large documentation section with Getting Started guides, advanced topics and references for ConsoleFx. In particular, check out our Getting Started guide to writing a simple console application to get a quick start on using ConsoleFx.
Overview
ConsoleFx provides a fluent API for specifying the rules for processing command-line arguments.For example, the following code creates a command-line application that supports these signatures:
BACKUP [/type:Full|Incremental] [/verbose]
BACKUP /?
var backupApp = new ConsoleProgram(includeHelpSupport: true);
backupApp.AddOption("type", "t", expectedParameters: 1)
.ValidateWith(new EnumValidator(typeof(BackupTypes))))
.AssignTo(() => BackupType);
backupApp.AddOption("verbose", "v")
.Flag(() => VerboseOutput);
backupApp.AddArgument()
.ValidateWith(new PathValidator { PathType = PathType.Directory, CheckIfExists = true })
.AssignTo(() => DirectoryToBackup);
backupApp.Run();
NuGet Support
The ConsoleFx binaries and code are now available through NuGet.
ConsoleFx binaries package
ConsoleFx code package
ConsoleFx Interactive Shell binaries package
ConsoleFx Interactive Shell code package
See the ConsoleFx assemblies and deployment scenarios section for scenarios on using the code packages.
[Less]
|
Posted
about 11 years
ago
by
jeevanjj
Documentation | Project Roadmap | NuGet
Project Description
ConsoleFx is a .NET library to build command-line applications with support for command-line argument parsing/handling, including error handling and validationsUsing the ConsoleFx
... [More]
command-line parser, you can specify a whole host of conditions for specifying command-line arguments. These can include the ability to:
Enforce the order of the command-line arguments
Specify switch options and limit the number of times they can occur as command-line arguments
Allow parameters to be specified for switch options, and limit the number of parameters that can be specified
Specify non-switch arguments and how they are to be used
Run custom validations on switch parameters and non-switch arguments, including tests for regular expressions, file masks, integers, booleans, enums, etc.
Automatically map non-switch arguments to strong-typed properties for easier readability
In addition, ConsoleFx also provides the following extras:
A separate command-line parsing engine that can be used in non-CLI applications like Windows Forms and WPF applications.
Ability to create an interactive command-line shell application that utilizes ConsoleFx's build-in parser to handle input.
Utility classes for console output capturing and extensions to the Console class. We plan to add other utility classes in the future, making it the all-in-one solution for creating your command-line applications.
We have a large documentation section with Getting Started guides, advanced topics and references for ConsoleFx. In particular, check out our Getting Started guide to writing a simple console application to get a quick start on using ConsoleFx.
Overview
ConsoleFx provides a fluent API for specifying the rules for processing command-line arguments.For example, the following code creates a command-line application that supports these signatures:
BACKUP [/type:Full|Incremental] [/verbose] <directory to backup>
BACKUP /?
var backupApp = new ConsoleProgram(includeHelpSupport: true);
backupApp.AddOption("type", "t", expectedParameters: 1)
.ValidateWith(new EnumValidator(typeof(BackupTypes))))
.AssignTo(() => BackupType);
backupApp.AddOption("verbose", "v")
.Flag(() => VerboseOutput);
backupApp.AddArgument()
.ValidateWith(new PathValidator { PathType = PathType.Directory, CheckIfExists = true })
.AssignTo(() => DirectoryToBackup);
backupApp.Run();
NuGet Support
The ConsoleFx binaries and code are now available through NuGet.
ConsoleFx binaries package
ConsoleFx code package
ConsoleFx Interactive Shell binaries package
ConsoleFx Interactive Shell code package
See the ConsoleFx assemblies and deployment scenarios section for scenarios on using the code packages. [Less]
|
Posted
about 11 years
ago
by
jeevanjj
Documentation | Project Roadmap | NuGet
Project Description
ConsoleFx is a .NET library to build command-line applications with support for command-line argument parsing/handling, including error handling and validationsUsing the ConsoleFx
... [More]
command-line parser, you can specify a whole host of conditions for specifying command-line arguments. These can include the ability to:
Enforce the order of the command-line arguments
Specify switch options and limit the number of times they can occur as command-line arguments
Allow parameters to be specified for switch options, and limit the number of parameters that can be specified
Specify non-switch arguments and how they are to be used
Run custom validations on switch parameters and non-switch arguments, including tests for regular expressions, file masks, integers, booleans, enums, etc.
Automatically map non-switch arguments to strong-typed properties for easier readability
In addition, ConsoleFx also provides the following extras:
A separate command-line parsing engine that can be used in non-CLI applications like Windows Forms and WPF applications.
Ability to create an interactive command-line shell application that utilizes ConsoleFx's build-in parser to handle input.
Utility classes for console output capturing and extensions to the Console class. We plan to add other utility classes in the future, making it the all-in-one solution for creating your command-line applications.
We have a large documentation section with Getting Started guides, advanced topics and references for ConsoleFx. In particular, check out our Getting Started guide to writing a simple console application to get a quick start on using ConsoleFx.
Overview
ConsoleFx provides a fluent API for specifying the rules for processing command-line arguments.For example, the following code creates a command-line application that supports these signatures:
BACKUP [/type:Full|Incremental] [/verbose]
BACKUP /?
var backupApp = new ConsoleProgram(includeHelpSupport: true);
backupApp.AddOption("type", "t", expectedParameters: 1)
.ValidateWith(new EnumValidator(typeof(BackupTypes))))
.AssignTo(() => BackupType);
backupApp.AddOption("verbose", "v")
.Flag(() => VerboseOutput);
backupApp.AddArgument()
.ValidateWith(new PathValidator { PathType = PathType.Directory, CheckIfExists = true })
.AssignTo(() => DirectoryToBackup);
backupApp.Run();
NuGet Support
The ConsoleFx binaries and code are now available through NuGet.
ConsoleFx binaries package
ConsoleFx code package
ConsoleFx Interactive Shell binaries package
ConsoleFx Interactive Shell code package
See the ConsoleFx assemblies and deployment scenarios section for scenarios on using the code packages.
[Less]
|