Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
csharp(1)		    General Commands Manual		     csharp(1)

NAME
       csharp, gsharp -	Interactive C# Shell

SYNOPSIS
       csharp [--attach	PID] [-e EXPRESSION] [file1 [file2]] [options]

       gsharp [file1 [file2]]

DESCRIPTION
       The csharp is an	interactive C# shell that allows the user to enter and
       evaluate	C# statements and expressions from  the	 command  line.	   The
       regular	mcs  command  line  options can	be used	in this	version	of the
       compiler.

       The gsharp command is a GUI version of the  C#  interpreter  that  uses
       Gtk#  and provides an area to attach widgets as well.	  This version
       can be attached to other	Gtk# applications in a safe way	as it  injects
       itself  into the	main loop of a Gtk# application, avoiding any problems
       arising from the	multi-threaded nature of injecting itself into a  tar-
       get process.

       Files  specified	 in  the  command  line	will be	loaded and executed as
       scripts.

       Starting	with Mono 2.10,	the csharp command can be used	as  an	inter-
       preter executed by executables flagged with the Unix execute attribute.
       To do this, make	the first line of your C# source code look like	this:
       "#!/usr/bin/csharp"
       Console.WriteLine ("Hello, World");

OPTIONS
       The commands accept all of the commands that are	available to  the  mcs
       command,	so you can reference assemblies, specify paths,	language level
       and so on from the command line.	  In addition, the  following  command
       line options are	supported:

       --attach
	      This is an advanced option and should only be used if you	have a
	      deep understanding of multi-threading.	 This option is	avail-
	      ble on the csharp	command	and allows the compiler	to be injected
	      into other processes.  This is done by injecting the C# shell in
	      a	 separate thread that runs concurrently	with your application.
	      This means that you must take special measures to	avoid crashing
	      the  target  application while using it.	For example, you might
	      have to take the proper locks before issuing any	commands  that
	      might  affect  the  target  process  state,  or sending commands
	      through a	method dispatcher.

       -e EXPRESSION
	      This will	evaluate the specified C# EXPRESSION and exit

OPERATION
       Once you	launch the csharp command, you will be greeted with the	inter-
       active prompt:

       $ csharp
       Mono C# Shell, type "help;" for help

       Enter statements	below.
       csharp>

       A  number  of  namespaces are pre-defined with C# these include System,
       System.Linq, System.Collections and System.Collections.Generic.	Unlike
       the  compiled  mode,  it	is possible to add new using statements	as you
       type code, for example:

       csharp> new XmlDocument ();
       <interactive>(1,6): error CS0246: The type or namespace name `XmlDocument' could	not be found. Are you missing a	using directive	or an assembly reference?
       csharp> using System.Xml;
       csharp> new XmlDocument ();
       System.Xml.XmlDocument

       Every time a command is typed, the scope	of that	command	is  one	 of  a
       class  that  derives from the class Mono.CSharp.InteractiveBase.	  This
       class defines a number of static	properties and methods.	  To display a
       list of available commands access the `help' property:
       csharp> help;
       "Static methods:
	 LoadPackage (pkg); - Loads the	given Package (like -pkg:FILE)
	 [...]
	 ShowVars ();	    - Shows defined local variables.
	 ShowUsing ();	    - Show active using	decltions.
	 help;
       "
       csharp>

       When  expressions  are entered, the C# shell will display the result of
       executing the expression:

       csharp> Math.Sin	(Math.PI/4);
       0.707106781186547
       csharp> 1+1;
       2
       csharp> "Hello, world".IndexOf (',');
       5

       The C# shell uses the ToString()	method on the returned object to  dis-
       play  the  object, this sometimes can be	limiting since objects that do
       not override the	ToString() method will get the default	behavior  from
       System.Object which is merely to	display	their type name:

       csharp> var a = new XmlDocument ();
       csharp> a;
       System.Xml.Document
       csharp> csharp> a.Name;
       "#document"
       csharp>

       A  few datatypes	are handled specially by the C#	interactive shell like
       arrays,	System.Collections.Hashtable,  objects	that  implement	  Sys-
       tem.Collections.IEnumerable  and	IDictionary and	are rendered specially
       instead of just using ToString ():

       csharp> var pages = new Hashtable () {
	     >	{ "Mono",    "http://www.mono-project.com/" },
	     >	{ "Linux",   "http://kernel.org" } };
       csharp> pages;
       {{ "Mono", "http://www.mono-project.com/" }, { "Linux", "http://kernel.org" }}

       It is possible to use LINQ directly in the C# interactive  shell	 since
       the System.Linq namespace has been imported at startup.	 The following
       sample gets a list of all the files that	have not been  accessed	 in  a
       week from /tmp:

       csharp> using System.IO;
       csharp> var last_week = DateTime.Now - TimeSpan.FromDays	(7);
       csharp> var old_files = from f in Directory.GetFiles ("/tmp")
	     >	 let fi	= new FileInfo (f)
	     >	 where fi.LastAccessTime < LastWeek select f;
       csharp>

       You can of course print the results in a	single statement as well:

       csharp> using System.IO;
       csharp> var last_week = DateTime.Now - TimeSpan.FromDays	(7);
       csharp> from f in Directory.GetFiles ("/tmp")
	     >	 let fi	= new FileInfo (f)
	     >	 where fi.LastAccessTime < last_week select f;
       [...]
       csharp>

       LINQ  and its functional	foundation produce on-demand code for IEnumer-
       able return values.  For	instance, the return value from	a using	`from'
       is  an IEnumerable that is evaluated on demand.	 The automatic render-
       ing of IEnumerables on the command line will  trigger  the  IEnumerable
       pipeline	 to  execute at	that point instead of having its execution de-
       layed until a later point.

       If you want to avoid having the IEnumerable  rendered  at  this	point,
       simply assign the value to a variable.

       Unlike compiled C#, the type of a variable can be changed if a new dec-
       laration	is entered, for	example:

       csharp> var a = 1;
       csharp> a.GetType ();
       System.Int32
       csharp> var a = "Hello";
       csharp> a.GetType ();
       System.String
       csharp> ShowVars	();
       string a	= "Hello"

       In the case that	an expression or a statement is	 not  completed	 in  a
       single line, a continuation prompt is displayed,	for example:

       csharp> var protocols = new string [] {
	     >	  "ftp",
	     >	  "http",
	     >	  "gopher"
	     > };
       csharp> protocols;
       { "ftp",	"http",	"gopher" }

       Long running computations can be	interrupted by using the Control-C se-
       quence:

       csharp> var done	= false;
       csharp> while (!done) { }
       Interrupted!
       System.Threading.ThreadAbortException: Thread was being aborted
	 at Class1.Host	(System.Object&	$retval) [0x00000]
	 at Mono.CSharp.InteractiveShell.ExecuteBlock (Mono.CSharp.Class host, Mono.CSharp.Undo	undo) [0x00000]
       csharp>

INTERACTIVE EDITING
       The C# interactive shell	contains a line-editor that  provides  a  more
       advanced	 command  line editing functionality than the operating	system
       provides.   These are available in the command line  version,  the  GUI
       versions	uses the standard Gtk# key bindings.

       The command set is similar to many other	applications (cursor keys) and
       incorporates some of the	Emacs commands for editing as well as  a  his-
       tory mechanism to

       The following keyboard input is supported:

       Home Key, Control-a
	      Goes to the beginning of the line.

       End Key,	Control-e
	      Goes to the end of the line.

       Left Arrow Key, Control-b
	      Moves the	cursor back one	character.

       Right Arrow Key,	Control-f
	      Moves the	cursor forward one character.

       Up Arrow	Key, Control-p
	      Goes  back  in  the  history, replaces the current line with the
	      previous line in the history.

       Down Arrow Key, Control-n
	      Moves forward in the history, replaces the current line with the
	      next lien	in the history.

       Return Executes the current line	if the statement or expression is com-
	      plete, or	waits for further input.

       Control-C
	      Cancel the current line being edited.  This will kill  any  cur-
	      rently  in-progress  edits  or  partial editing and go back to a
	      toplevel definition.

       Backspace Key
	      Deletes the character before the cursor

       Delete Key, Control-d
	      Deletes the character at the current cursor position.

       Control-k
	      Erases the contents of the line until the	end of	the  line  and
	      places the result	in the cut and paste buffer.

       Alt-D  Deletes  the  word  starting  at the cursor position and appends
	      into the cut and paste buffer.	By pressing Alt-d  repeatedly,
	      multiple words can be appended into the paste buffer.

       Control-Y
	      Pastes  the content of the kill buffer at	the current cursor po-
	      sition.

       Control-Q
	      This is the quote	character.   It	allows the user	to enter  con-
	      trol-characters  that are	otherwise taken	by the command editing
	      facility.	  Press	Control-Q followed by the character  you  want
	      to  insert,  and	it  will be inserted verbatim into the command
	      line.

       Control-D
	      Terminates the program.	This terminates	the input for the pro-
	      gram.

STATIC PROPERTIES AND METHODS
       Since  the  methods  and	 properties  of	 the base class	from where the
       statements and expressions are executed are static, they	can be invoked
       directly	from the shell.	  These	are the	available properties and meth-
       ods:

       void LoadAssembly(string	assembly)
	      Loads the	given assembly.	  This is equivalent  to  passing  the
	      compiler the -r: flag with the specified string.

       void LoadPackage(string package)
	      Imports  the package specified.	This is	equivalent to invoking
	      the compiler with	the -pkg: flag with the	specified string.

       string Prompt { get; set	}
	      The prompt used by the shell.  It	defaults to the	value "csharp>
	      ".   string  ContinuationPrompt {	get; set; } The	prompt used by
	      the shell	when further input is required to complete the expres-
	      sion or statement.

       void ShowVars()
	      Displays	all  the  variables  that have been defined so far and
	      their types.    In the csharp shell declaring new	variables will
	      shadow previous variable declarations, this is different than C#
	      when compiled.  void ShowUsing() Displays	all the	 using	state-
	      ments in effect.	TimeSpan Time (Action a) Handy routine to time
	      the time that some code takes to execute.	  The parameter	is  an
	      Action  delegate,	and the	return value is	a TimeSpan.  For exam-
	      ple:

       csharp> Time (()	=> { for (int i	= 0; i < 5; i++) Console.WriteLine (i);});
       0
       1
       2
       3
       4
       00:00:00.0043230
       csharp>

       The return value	is a TimeSpan, that you	can store in  a	 variable  for
       benchmarking purposes.

GUI METHODS AND	PROPERTIES
       In addition to the methods and properties available in the console ver-
       sion there are a	handful	of extra properties available on the GUI  ver-
       sion.   For example a "PaneContainer" Gtk.Container is exposed that you
       can use to host Gtk# widgets  while  prototyping	 or  the  "MainWindow"
       property	that gives you access to the current toplevel window.

STARTUP	FILES
       The  C# shell will load all the Mono assemblies and C# script files lo-
       cated in	the ~/.config/csharp directory on Unix.	  The  assemblies  are
       loaded before the source	files are loaded.

       C#  script  files are files that	have the extension .cs and they	should
       only contain statements and expressions,	 they  can  not	 contain  full
       class  definitions  (at	least not as of	Mono 2.0).  Full class defini-
       tions should be compiled	into dlls and stored in	that directory.

AUTHORS
       The Mono	C# Compiler was	written	by Miguel de Icaza, Ravi Pratap,  Mar-
       tin  Baulig, Marek Safar	and Raja Harinath.  The	development was	funded
       by Ximian, Novell and Marek Safar.

LICENSE
       The Mono	Compiler Suite is released under the terms of the GNU  GPL  or
       the  MIT	X11.  Please read the accompanying `COPYING' file for details.
       Alternative licensing for the compiler is available from	Novell.

SEE ALSO
       gmcs(1),	mcs(1),	mdb(1),	mono(1), pkg-config(1)

BUGS
       To report bugs in the compiler, you must	file them on our bug  tracking
       system, at: http://www.mono-project.com/community/bugs/

MAILING	LIST
       The Mono	Mailing	lists are listed at http://www.mono-project.com/commu-
       nity/help/mailing-lists/

MORE INFORMATION
       The Mono	C# compiler was	 developed  by	Novell,	 Inc  (http://www.nov-
       ell.com,	 http) and is based on the ECMA	C# language standard available
       here: http://www.ecma.ch/ecma1/STAND/ecma-334.htm

       The  home  page	for  the  Mono	C#  compiler  is  at  http://www.mono-
       project.com/docs/about-mono/languages/csharp/ information about the in-
       teractive    mode    for	   C#	 is    available    in	  http://mono-
       project.com/docs/tools+libraries/tools/repl/

			       4 September 2008			     csharp(1)

NAME | SYNOPSIS | DESCRIPTION | OPTIONS | OPERATION | INTERACTIVE EDITING | STATIC PROPERTIES AND METHODS | GUI METHODS AND PROPERTIES | STARTUP FILES | AUTHORS | LICENSE | SEE ALSO | BUGS | MAILING LIST | MORE INFORMATION

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=csharp&manpath=FreeBSD+12.1-RELEASE+and+Ports>

home | help