Man Linux: Main Page and Category List


       csharp, gsharp - Interactive C# Shell


       csharp [--attach PID] [file1 [file2]] [options]

       gsharp [file1 [file2]]


       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

       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
       target process.

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


              This is an advanced option and should only be used if you have a
              deep   understanding  of  multi-threading.      This  option  is
              availble 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.


       Once  you  launch  the  csharp  command,  you  will be greeted with the
       interactive prompt:

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

       Enter statements below.

       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 ();

       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.

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

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

       The  C#  shell  uses  the  ToString()  method on the returned object to
       display 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;
       csharp> csharp> a.Name;

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

       csharp> var pages = new Hashtable () {
             >  { "Mono",    "" },
             >  { "Linux",   "" } };
       csharp> pages;
       {{ "Mono", "" }, { "Linux", "" }}

       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;

       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;

       LINQ  and  its  functional  foundation  produce  on-demand   code   for
       IEnumerable return values.  For instance, the return value from a using
       `from' is an IEnumerable that is evaluated on demand.    The  automatic
       rendering  of  IEnumerables  on  the  command  line  will  trigger  the
       IEnumerable pipeline to execute at that point  instead  of  having  its
       execution delayed 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
       declaration is entered, for example:

       csharp> var a = 1;
       csharp> a.GetType ();
       csharp> var a = "Hello";
       csharp> a.GetType ();
       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

       csharp> var done = false;
       csharp> while (!done) { }
       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]


       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
       history 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
              complete, or waits for further input.

              Cancel  the  current  line  being  edited.   This  will kill any
              currently 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.

              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.

              Pastes the content of the kill  buffer  at  the  current  cursor

              This  is  the  quote  character.    It  allows the user to enter
              control-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.

              Terminates  the  program.    This  terminates  the input for the


       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

       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
              expression 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
              statements 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

       csharp> Time (() => { for (int i = 0; i < 5; i++) Console.WriteLine (i);});

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


       In addition to the methods and  properties  available  in  the  console
       version  there  are  a handful of extra properties available on the GUI
       version.   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.


       The C# shell will load all the Mono  assemblies  and  C#  script  files
       located  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
       definitions  should be compiled into dlls and stored in that directory.


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


       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.


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


       To report bugs in the compiler, you must file them on our bug  tracking
       system, at:


       The    Mono    Mailing    lists    are   listed   at   http://www.mono-


       The   Mono   C#    compiler    was    developed    by    Novell,    Inc
       (,  http)  and  is  based  on the ECMA C# language
       standard available here:

       The  home  page  for  the  Mono  C#  compiler  is  at  http://www.mono-  information about the interactive mode for
       C# is available in

                               4 September 2008                      csharp(1)