External tools add-in with ProcessStartInfo and Process classes

Download Source Code

Introduction

In this article we show how to develop a very common utility with ProcessStartInfo and Process classes included in System.Diagnostics namespace for PragmaSQL editor.

PragmaSQL T-SQL editor has very extensive add-in support. External Tools add-in presented in this article has two goals

1- Serve as PragmaSQL add-in development example.
2- Provide a very common feature included in all development IDEs and editors.

IC#Code Add-In Architecture Overview

PragmaSQL makes use of IC#Code's Add-In architecture. This architecture provides
fantastic fatures that enables us to develop plugins for our applications easily thus
making our applications extendable. IC#Code Add-In architecture provides

1- Simple and neat XML add-in definition via .addin files
2- Loading of add-in assemblies
3- Expose add-in functionality through menus and toolbars of the host application
4- And many utility services like MenuService and MessageService

For details about the architecture please refer to SODA - SharpDevelop Open Development Architecture by Mike Krueger

PragmaSQL Services Overview

PragmaSQL exposes many of the built-in host features to the add-in developers with a core librarary.
Exposed features include

1- Host Options
2- Editor Services: Access to T-SQL script editor and text editor
3- Object Explorer Service: Access to database object explorer
4- Project Explorer Service
5- Shared Scripts and Code Snippets
6- Internal web browser
7- Text Diff Service
8- Code completion lists
9- Application messages service

Entry point to all these services is HostServicesSingleton, as its name mimics this class is a singleton.

HostServicesSingleton Usage Example From PragmaSQL.ExternalTools

Example code provided below shows

1) How we can use Application Message Service to print messages into Host Application Messages window.
2) Evaluate macros with HostServices EvalMacro function and prepare tool arguments

private void process_Exited(object sender, EventArgs e)
{
    Process p = sender as Process;
    if (p == null)
        return;

    long handle = p.Handle.ToInt64();
    if (!_runningToolDefs.ContainsKey(handle))
        return;

    try
    {
        ExternalToolDef def = _runningToolDefs[handle];
        
        //Here we clear application messages window



        if (chkClearOutput.Checked)
            HostServicesSingleton.HostServices.MsgService.ClearMessages();

        bool shallShow = false;

        while (p.StandardOutput.Peek() > -1)
        {
            string info = p.StandardOutput.ReadLine();
            if (!String.IsNullOrEmpty(info))
            {
                // Print info message to Applicatin Messages Window



                HostServicesSingleton.HostServices.MsgService.InfoMsg(info, "Tool : " + def.Title, String.Empty, String.Empty);
                shallShow = true;
            }
        }

        while (p.StandardError.Peek() > -1)
        {
            string error = p.StandardError.ReadLine();
            if (!String.IsNullOrEmpty(error))
            {
                // Print error message to Applicatin Messages Window



                HostServicesSingleton.HostServices.MsgService.ErrorMsg(error, "Tool : " + def.Title, String.Empty, String.Empty);
                shallShow = true;
            }
        }

        if (shallShow == true)
            HostServicesSingleton.HostServices.MsgService.ShowMessages();
    }
    finally
    {
        _runningToolDefs.Remove(handle);
    }
}




private void RenderExternalToolDef(ExternalToolDef exDef)
{
    tbCmd.Text = String.Empty;
    tbArgs.Text = String.Empty;
    tbWorkingDir.Text = String.Empty;
    
    if (exDef == null)
        return;
        
    tbCmd.Text = exDef.Command;
    // Here we prepare arguments by evaluating macros



    tbArgs.Text = HostServicesSingleton.HostServices.EvalMacro(exDef.Args);
    tbWorkingDir.Text = exDef.WorkingDir; 
}

        

NOTE: In order to develop PragmaSQL Add-Ins you need to get PragmaSQL.Core.dll. All host functionality
and many utility classes are hosted in this assembly.Download from here

PragmaSQL.ExternalTools

Add-In Definition

<AddIn name        = "External Tools AddIn for PragmaSQL"
       author      = "Ali �zg�r"
       description = "Enables you to define external tools for PragmaSQL">
    <Manifest>
        <Identity name = "PragmaSQL.ExternalTools"/>
    </Manifest>

    <Runtime>
        <Import assembly="PragmaSQL.ExternalTools.dll"/>
    </Runtime>

    <Path name = "/Workspace/ToolsMenu">
        <MenuItem id = "ExtTools.Configure"
                         label = "External Tools..."
                         class ="PragmaSQL.ExternalTools.ConfigureTools"/>
        <MenuItem id = "ExtTools.Run"
                         label = "Run External Tool"
                         shortcut     = "Control|Shift|E"
                         class ="PragmaSQL.ExternalTools.RunExternalTool"/>
    </Path>
</AddIn>

In the add-in definition file above we provide the description of our add-in and how our add-in integrates to PragmaSQL.
Most important part of this add-in definition is the Path tag. We provide the predefined host path along with the MenuItems
we want to be created for our add-in.

Another very important tag is Class. IC#Code Add-In architecture makes use of Command Pattern.
We define commands associated to the specified menu/toolbar items with Command classes through this tag.
In the above example for External Tools... menu item you can see that we want PragmaSQL.ExternalTools.ConfigureTools command
to be invoked. ConfigureTools command class inherits from AbstractMenuCommand and has Run() method.

NOTE: Predefined host paths can be found in Base.addin file that comes with PragmaSQL installation.

ExternalTools Add-In Specific Classes

private void RunTool()
{
    if (CurrentDef == null)
        return;

    ProcessStartInfo psi = new System.Diagnostics.ProcessStartInfo();
    tbArgs.Text = HostServicesSingleton.HostServices.EvalMacro(CurrentDef.Args);
    psi.FileName = CurrentDef.Command;
    psi.Arguments = tbArgs.Text;
    psi.WorkingDirectory = CurrentDef.WorkingDir;
    psi.RedirectStandardOutput = CurrentDef.UseOuput;
    psi.RedirectStandardError = CurrentDef.UseOuput;
    psi.CreateNoWindow = CurrentDef.UseOuput;
    psi.UseShellExecute = !CurrentDef.UseOuput;
    
    Process p = new Process();
    p.EnableRaisingEvents = CurrentDef.UseOuput;
    if (CurrentDef.UseOuput)
        p.Exited += new EventHandler(p_Exited);
    
    p.StartInfo = psi;
    p.Start();

    if (CurrentDef.UseOuput)
        _runningToolDefs.Add(p.Handle.ToInt64(), CurrentDef);
}