CShell 1.0.8

CShell

CShell creates a runtime environment to make it easy to create C# based shell style scripts. CShell is built on top of MedallionShell and runs great as a CSX on .NET Core giving you a great cross platform C# alternative to powershell and bash scripts.

There are 2 functionalities which CShell provides:

• The concept of a current folder with relative commands for navigating and manipulating files and folders
• The ability to smoothly invoke processes and pipe
• Helpers to make it easy to work with the output of processes

By maintaining the concept of a current folder then all file and folder commands can be expressed using relative paths just like a normal shell.

You can just create a CShell directly and start working with it You can just create a CShell directly and start working with it

var shell = new CShell();

shell.CreateFolder("test");
shell.ChangeFolder("test");
foreach(var folder in shell.CurrentFolder.EnumerateDirectories()) 
{
	Console.WriteLine(folder.FullName);
}

Or you can derive a class and not need the shell. prefix at all

class MyScript: CShell()
{
	async Task Go()
	{
		CreateFolder("test");
		ChangeFolder("test");
		foreach(var folder in shell.CurrentFolder.EnumerateDirectories()) 
		{
			Console.WriteLine(folder.FullName);
		}
	}
}

CShell Process Commands

CShell is built using MedallionShell, which provides a great set of functionality for easily invoking processes and piping data between them. CShell adds on location awareness and helper methods to make it even easier to work with the output of processes.

To invoke a process you simply call .Run(). You can chain processes together using .RedirectTo(), pipe '|' or greater than '>'.

class MyScript: CShell()
{
	async Task Go()
	{
		// Invoke multiple commands using fluent style
		CommandResult result3 = await Run("cmd1", "args1")
			.RedirectTo("cmd2", "args2", "args3")
			.RedirectTo("cmd3", "args4")
			.AsResult();

		// we can even chain commands together with the pipe operator
		CommandResult result = await Run("cmd1", "args1") 
			| Run("cmd2", "args2", "args3") 
			| Run("cmd3", "args4")
			.AsResult();

		// we can even chain commands together with the > operator
		CommandResult result2 = await Run("cmd1", "args1") 
 			> Run("cmd2", "args2", "args3")
			> Run("cmd3", "args4")
			.AsResult();
	}
}

The CommandResult object has StandardOutput, StandardError information for further processing.

Working with typed results

Medallion makes it wasy to work with processes, but CShell adds on helper methods to make it even easier to work with the result of a command chain.

You can easily change the previous example directly into a typed object in one command:

class MyScript: CShell()
{
	async Task Go()
	{
		// get the result as dynamic object
		dynamic jsonResult  = await Run("cmd1", "args1")
			.RedirectTo("cmd2", "args2", "args3")
			.RedirectTo("cmd3", "args4")
			.ToJson();

		// get the json result as a typed object
		MyObject myObject  = await Run("cmd1", "args1")
			.RedirectTo("cmd2", "args2", "args3")
			.RedirectTo("cmd3", "args4")
			.ToJson<MyObject>();
	}
}

Working with files

CShell has ReadFile() and AsFile() extension methods which allow you to "start" the process chain from a file, or to end with it in a file.

class MyScript: CShell()
{
	async Task Go()
	{
		// start with text file and pass into cmd2, then write the final stdout and stderr and return a CommandResult
		var result  = await ReadFile("myfile.txt")
			.RedirectTo("cmd2", "args2", "args3")
			.RedirectTo("cmd3", "args4")
			.AsFile("stdout.txt", "stderr.txt");
	}
}