As of late 2018, Windows 10 and Windows 2019 come up with OpenSSH installed. I had to use OpenSSH in some of the scripts at work, but managing the connections became difficult. So, I created a small .NET program that manages SSH connections. It’s a very simple SSH GUI front-end for OpenSSH. It’s not meant to be a replacement for putty or any other SSH terminal programs.
In case you get an error that your PEM certificate is wide open, change the permissions on that file. Do this from a command prompt, not from a Power Shell prompt.

set key="c:\folder\mykey.pem"
cmd /c icacls %key% /c /t /inheritance:d
cmd /c icacls %key% /c /t /grant %username%:F
cmd /c icacls %key%  /c /t /remove Administrator BUILTIN\Administrators BUILTIN Everyone System Users "Authenticated Users"
cmd /c icacls %key%

Here is the link to the GitHub repo.
Here is a screenshot.

Here is the C# source. Click + to expand.

using System;
using System.IO;
using System.Windows.Forms;
using System.Diagnostics;

namespace pusshy
{
    public partial class frmpusshy : Form
    {
        //It holds the name of the header column when a cell is right-clicked
        //Used for hiding columns
        string strColumnHeader; 
        //When a user hits enter, the next selected cell is on the right, not the bottom one
        //It allows horizontal scrolling when typing, not vertical
        protected override bool ProcessCmdKey(ref System.Windows.Forms.Message msg, System.Windows.Forms.Keys keyData)
        {
            int intColumn = gridHosts.CurrentCell.ColumnIndex;
            int intRow = gridHosts.CurrentCell.RowIndex;
            if (keyData == Keys.Enter)
            {
                if (intColumn == gridHosts.Columns.Count - 1)
                {
                    gridHosts.Rows.Add();
                    gridHosts.CurrentCell = gridHosts[0, intRow + 1];
                }
                else
                {
                    gridHosts.CurrentCell = gridHosts[intColumn + 1, intRow];
                }
                return true;
            }
            else
                return base.ProcessCmdKey(ref msg, keyData);
        }

        public frmpusshy()
        {
            InitializeComponent();
        }

        private void frmpusshy_FormClosed(object sender, FormClosedEventArgs e)
        {
            //Save the current size and position of the window
            //Used to remember these settings when the program is started next time
            Properties.Settings.Default["Location"] = this.Location;
            Properties.Settings.Default["Size"] = this.Size;
            Properties.Settings.Default.Save();
            //The local app data folder where settings and the data will be saved
            var strLocalAppData = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
            //The data is in pusshy.csv file under C:\Users\<username>\AppData\Local\pusshy
            var strFileName = strLocalAppData + "/pusshy/" + "pusshy.csv";
            string strCellValue;
            //Open the file for saving
            StreamWriter csvFileWriter = new StreamWriter(strFileName, false);
            int intColumnCount = gridHosts.ColumnCount - 1;
            int intColCount = gridHosts.Columns.Count;
            //Iterate through the grid and save
            foreach (DataGridViewRow dataRowObject in gridHosts.Rows)
            {
                if (!dataRowObject.IsNewRow)
                {
                    string strDataFromGrid = "";                    
                    for (int i = 0; i <= intColumnCount; i++)
                    {
                        try
                        {
                            strCellValue = dataRowObject.Cells[i].Value.ToString();
                        }
                        //If the cell has no value, replace it with blank string instead of null
                        catch (System.NullReferenceException exception)
                        {
                            strCellValue = "";
                        }
                        //Create a comma separated line
                        if (i != 0)
                        {
                            strDataFromGrid = strDataFromGrid + ',' + strCellValue;
                        }
                        else
                        {
                            strDataFromGrid = strCellValue;
                        }
                    }
                    csvFileWriter.WriteLine(strDataFromGrid);
                }
            }
            csvFileWriter.Flush();
            csvFileWriter.Close();
        }
        //Tag the whole row if there is a password in the password column (column=2). Used to hide password cells
        private void gridHosts_EditingControlShowing(object sender, DataGridViewEditingControlShowingEventArgs e)
        {            
            if (gridHosts.CurrentRow.Tag != null && gridHosts.CurrentCell.ColumnIndex == 2)
            {
                e.Control.Text = gridHosts.CurrentRow.Tag.ToString();
            }
        }
        //Replace the text in the password cell (column=2) with dots
        private void gridHosts_CellFormatting(object sender, DataGridViewCellFormattingEventArgs e)
        {
            if (e.ColumnIndex == 2 && e.Value != null)
            {                
                gridHosts.Rows[e.RowIndex].Tag = e.Value;
                e.Value = new String('\u25CF', e.Value.ToString().Length);
            }
        }
        //Right-click on row header or column header
        private void gridHosts_MouseDown(object sender, MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Right)
            {
                var hit = gridHosts.HitTest(e.X, e.Y);
                var intCurrentColumnIndex = hit.ColumnIndex;
                //If the user right-clicks the column header display this menu
                if ((hit.Type == DataGridViewHitTestType.ColumnHeader))
                {
                    strColumnHeader = gridHosts.Columns[intCurrentColumnIndex].HeaderText;
                    menuRightColumnClick.Show(MousePosition);
                }
                //If the user right-clicks the column header display this menu
                if ((hit.Type == DataGridViewHitTestType.RowHeader))
                {
                    menuRightRowClick.Show(MousePosition);
                }
            }
        }
        //Hide the column that was selected
        private void hideToolStripMenuItem_Click(object sender, EventArgs e)
        {
            gridHosts.Columns[strColumnHeader].Visible = false;
        }       
        //Delete a row
        private void deleteToolStripMenuItem_Click(object sender, EventArgs e)
        {
            foreach (DataGridViewRow row in gridHosts.SelectedRows)
            {
                try
                {
                    gridHosts.Rows.Remove(row);
                }
                //Can't delete the bottom row. Catch the exception
                catch (InvalidOperationException exception)
                {
                    return;
                }
            }
        }

        private void frmpusshy_Load(object sender, EventArgs e)
        {
            //The local app data folder where settings and the data will be saved
            var strLocalAppData = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
            //The data is in pusshy.csv file under C:\Users\<username>\AppData\Local\pusshy
            var strFileName = strLocalAppData + "/pusshy/" + "pusshy.csv";
            if (!File.Exists(strFileName))
            {
                return;
            }   
            //Clear the grid and load the pusshy.csv file
            gridHosts.Rows.Clear();
            StreamReader fileReader = new StreamReader(strFileName, false);
            int i = 0;
            while (fileReader.Peek() != -1)
            {
                var fileRow = fileReader.ReadLine();
                var fileDataField = fileRow.Split(',');
                gridHosts.Rows.Add(fileDataField);
                //var rd = fileDataField[2];                
                i++;
            }
            fileReader.Dispose();
            fileReader.Close();
            //Change the size and the position of the application on load
            //With the settings that were saved last time the app was used
            this.Location = Properties.Settings.Default.Location;
            this.Size = Properties.Settings.Default.Size;
        }
        //When the user chooses Show All, all hidden columns will become visible
        private void showAllToolStripMenuItem_Click(object sender, EventArgs e)
        {            
            foreach (DataGridViewColumn column in gridHosts.Columns)
            {
                string strHeaderCaptionText = column.HeaderText;
                gridHosts.Columns[strHeaderCaptionText].Visible = true;
            }                    
        }
        //When the user double-clicks a cell, launch the terminal
        private void gridHosts_CellDoubleClick(object sender, DataGridViewCellEventArgs e)
        {
            string strCommand = "";
            int intRowIndex = gridHosts.CurrentCell.RowIndex;  
            //Get all values from the row
            string strHost = gridHosts.Rows[intRowIndex].Cells[0].Value.ToString();
            string strLogin = gridHosts.Rows[intRowIndex].Cells[1].Value.ToString();
            string strPwd = gridHosts.Rows[intRowIndex].Cells[2].Value.ToString();
            string strCert = gridHosts.Rows[intRowIndex].Cells[3].Value.ToString();
            //If the password cell is empty, start the terminal with certificate
            if (strPwd == "")
            {
                strCommand = "\"C:/windows/sysnative/OpenSSH/ssh.exe\" -l " + strLogin + " " + "-i " + strCert + " " + strHost;
            } else
            //Or without password
            {
                strCommand = "\"C:/windows/sysnative/OpenSSH/ssh.exe\" -l " + strLogin + " " + strHost;
            }
            Process.Start("powershell.exe", strCommand);            
        }
    }
}

While I was playing with docker, I needed some 10-15 commands executed repeatedly. At first, I was using the cursor up to search through the history, but at point there were so menu of them that I got lost. In bash, you can also use the command history and then execute the command from it if you know the line number by putting ! as a prefix, e.g. !20, but that didn’t work too. So, I’ve opened a notepad on a side and pasted my most used commands in a separate line. This worked better, but then while I was selecting and copying the lines, I would make mistakes and copy the line with a part of the next line or with the line feed character, so it executed immediately when pasted. I needed a small text edit where each line can be copied to the clipboard with a click of a button and can stay on top of the other windows. In addition, I needed many of these, so I needed something to spawn a new instance from the program itself. So, I made this utility that looks like this.

The program’s caption bar has been minimized so the program doesn’t take much real estate on the screen. The green bar on top is used to move the window. The buttons have captions to quickly display the function. Form left to right, button C copies from the text box to the clipboard, button P paste the text from clipboard into the text box, N means a new window – the program will start another instance of itself, the T button is a toggle – to stay on top of the other windows or not (if you have one monitor, this is very useful), and the last two buttons are minimize and exit. On the right bottom size there is a grip to resize the instance. This is how I use my program.

Anytime I need something, I just click on the C button and then right-click-Paste in my shell. No need to search through the history of your bash.
The source and the exe are at github.

git clone https://www.github.com/klimenta/cmddepot.git

The EXE is under cmddepot\CmdDepot\bin\Release folder.
The main source. Click to expand.

using System;
using System.Drawing;
using System.Windows.Forms;

namespace CmdDepot
{
    public partial class CmdDepot : Form
    {
        public CmdDepot()
        {
            InitializeComponent();
            this.FormBorderStyle = FormBorderStyle.None;
            this.DoubleBuffered = true;
            this.SetStyle(ControlStyles.ResizeRedraw, true);
        }
        private const int cGrip = 16;      // Grip size
        private const int cCaption = 5;   // Caption bar height;

        protected override void OnPaint(PaintEventArgs e)
        {
            Rectangle rc = new Rectangle(this.ClientSize.Width - cGrip, this.ClientSize.Height - cGrip, cGrip, cGrip);
            ControlPaint.DrawSizeGrip(e.Graphics, this.BackColor, rc);
            rc = new Rectangle(0, 0, this.ClientSize.Width, cCaption);
            e.Graphics.FillRectangle(Brushes.Chartreuse, rc);
        }

        protected override void WndProc(ref Message m)
        {
            if (m.Msg == 0x84)
            {  // Trap WM_NCHITTEST
                Point pos = new Point(m.LParam.ToInt32());
                pos = this.PointToClient(pos);
                if (pos.Y < cCaption)
                {
                    m.Result = (IntPtr)2;  // HTCAPTION
                    return;
                }
                if (pos.X >= this.ClientSize.Width - cGrip && pos.Y >= this.ClientSize.Height - cGrip)
                {
                    m.Result = (IntPtr)17; // HTBOTTOMRIGHT
                    return;
                }
            }
            base.WndProc(ref m);
        }
    
        private void btnClose_Click(object sender, EventArgs e)
        {
            System.Windows.Forms.Application.Exit();
        }

        private void btnMinimize_Click(object sender, EventArgs e)
        {
            this.WindowState = FormWindowState.Minimized;
        }

        private void btnPaste_Click(object sender, EventArgs e)
        {
            tbCmd.Paste();
        }

        private void btnCopy_Click(object sender, EventArgs e)
        {
            Clipboard.SetText(tbCmd.Text);
        }

        private void btnNew_Click(object sender, EventArgs e)
        {
            System.Diagnostics.Process.Start(System.Diagnostics.Process.GetCurrentProcess().MainModule.FileName);
        }

        private void btnStayOnTop_Click(object sender, EventArgs e)
        {
            this.TopMost = !this.TopMost;
            if (this.TopMost) {
                btnStayOnTop.BackColor = Color.Tomato;
            } else
            {
                btnStayOnTop.BackColor = btnCopy.BackColor;
            }            
        }
    }
}

I needed a tool that takes screenshots at a regular interval. No bells and whistles, just simple tool where you can specify at what interval you can take the screesnhots, the destination folder and the monitor (if you have more than one). It looks like this.

Click Start when you are ready and the tool will minimize itself. When you are done, double-click the icon in the tray or right-click on it and choose Open where you can Stop the screesnhot grabbing.

Here is the source for your review but you’ll need the whole C# solution in order to work. Get it (git clone) from github. You’ll need .NET 3.5. Here is the EXE.

using System;
using System.Drawing;
using System.Windows.Forms;
using System.Drawing.Imaging;
using System.IO;

namespace SSG
{
    public partial class Form1 : Form
    {

        //Get all available monitors
        Screen[] scrScreens = Screen.AllScreens;

        public Form1()
        {
            InitializeComponent();
        }

        private void btnFolderBrowser_Click(object sender, EventArgs e)
        {
            //Shows up the browse dialog for the destination files
            DialogResult drResult = fbdBrowserDialog.ShowDialog();
            if (drResult == DialogResult.OK)
            {
                tbFolder.Text = fbdBrowserDialog.SelectedPath;
            }

        }

        private void btnRecord_Click(object sender, EventArgs e)
        {
            //Check if valid interval
            int intInterval = 1000;
            if (!(Int32.TryParse(tbInterval.Text, out intInterval)))
            {
                MessageBox.Show("Not a valid interval.", "SSG", MessageBoxButtons.OK, MessageBoxIcon.Error);
                return;
            }
            if (intInterval < 1)
            {
                MessageBox.Show("Not a valid interval.", "SSG", MessageBoxButtons.OK, MessageBoxIcon.Error);
                return;
            }
            timTimer.Interval = intInterval * 1000;
            //Check if folder exists
            if (!(Directory.Exists(tbFolder.Text)))
            {
                MessageBox.Show("The folder does not exist.", "SSG", MessageBoxButtons.OK, MessageBoxIcon.Error);
                return;
            }
            if (timTimer.Enabled)
            {
                timTimer.Enabled = false;
                btnRecord.Image = Properties.Resources.StartWithoutDebug_16x;
                return;
            }
            timTimer.Enabled = true;
            this.WindowState = FormWindowState.Minimized;
            btnRecord.Image = Properties.Resources.Stop_16x;            
        }

        private void timTimer_Tick(object sender, EventArgs e)
        {
            //Get the screenshots as JPG files
            Rectangle bounds = scrScreens[cbMonitor.SelectedIndex].Bounds;
            using (Bitmap bitmap = new Bitmap(bounds.Width, bounds.Height))
            {
                using (Graphics g = Graphics.FromImage(bitmap))
                {
                    g.CopyFromScreen(bounds.Left, bounds.Top, 0, 0, bounds.Size);
                }
                string strDateTime = DateTime.Now.ToString("yyyyMMddHHmmss");
                bitmap.Save(tbFolder.Text + "\\" + strDateTime + ".jpg", ImageFormat.Jpeg);
            }

        }

        private void Form1_Resize(object sender, EventArgs e)
        {
            //Minimize to tray
            if (this.WindowState == FormWindowState.Minimized)
            {
                Hide();
                niTrayIcon.Visible = true;
                if (timTimer.Enabled)
                {
                    niTrayIcon.Text = "SSG - Recording";
                }
                else
                {
                    niTrayIcon.Text = "SSG - Idle";
                }
            }
        }

        private void niTrayIcon_MouseDoubleClick(object sender, MouseEventArgs e)
        {
            Show();
            this.WindowState = FormWindowState.Normal;
            niTrayIcon.Visible = false;
        }

        private void tsmiExit_Click(object sender, EventArgs e)
        {
            Application.Exit();
        }

        private void tsmiOpen_Click(object sender, EventArgs e)
        {
            Show();
            this.WindowState = FormWindowState.Normal;
            niTrayIcon.Visible = false;
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            //Adds the number of monitors in a combox box
            int intMonitors = scrScreens.Length;
            int intCounter = 0;
            while (intCounter < intMonitors)
            {
                cbMonitor.Items.Add((intCounter + 1).ToString());
                intCounter++;
            }
            cbMonitor.SelectedIndex = 0;
        }
    }
}

I needed an utility that acts as a TCP server on a random port and if a client telnets to that port, the server will have to return something to that client. There are probably a tons of utilities like this, ranging from PowerShell scripts to nc (netcat), but I’ve decided to make one in Visual C# 2015 using .NET 3.5.
My utility is based on this MSDN article with slight modifications.
So, launch the utility with the port in mind, e.g. listen -p 25000 and the program will wait for someone to connect to that port. Once you do telnet 25000, you’ll be greeted with a banned from the utility. Type any key and you’ll get a response with the upper version of that key. Type q and it will terminate the session. The utility is useful to check TCP ports across networks. If you try to run the utility on a port that’s already in use, e.g. port 80 on a web server, the utility will throw an exception. Also, if you try to listen on port 443 and then go to https://server_ip, the utility will also throw an exception. Nevertheless, this means you have a connection.
So, here is the source and link to github repo.
An image of listen in action.

using System;
using System.Net;
using System.Net.Sockets;

namespace listen
{
    class Program
    {
        static void usage()
        {
            Console.WriteLine(new string('=', 42));
            Console.WriteLine("listen v1.0, Kliment Andreev 2016");
            Console.WriteLine("Usage: listen -p <port>");
            Console.WriteLine("Opens a TCP socket on a given port");
            Console.WriteLine("CTRL + C to exit or type q from the client");
            Console.WriteLine(new string('=', 42));
        }

        static void Main(string[] args)
        {
            if ((args.Length == 0) || (args.Length != 2))
            {
                usage();
                return;
            }

            if (args[0]!="-p")
            {
                Console.WriteLine("Unknown switch {0}", args[0]);
                usage();
                return;
            }

            int intTemp;
            bool bisNumeric = int.TryParse(args[1], out intTemp);
            if (!bisNumeric)
            {
                usage();
                return;
            }
           
            TcpListener server = null;
            try
            {
                // Set the TcpListener on port intTemp.
                Int32 intPort = intTemp;
                IPAddress localAddr = IPAddress.Parse("0.0.0.0");
                // TcpListener server = new TcpListener(port);
                server = new TcpListener(localAddr, intPort);
                // Start listening for client requests.
                server.Start();
                // Buffer for reading data
                Byte[] bytes = new Byte[4096];
                
                String data = null;
                // Enter the listening loop.
                while (true)
                {
                    usage();
                    Console.WriteLine("I am listening on {0}... ", intPort);
                    // Perform a blocking call to accept requests.
                    // You could also user server.AcceptSocket() here.
                    TcpClient client = server.AcceptTcpClient();
                    Console.WriteLine("=====> Connected to {0}", client.Client.RemoteEndPoint);
                    data = null;
                    // Get a stream object for reading and writing
                    NetworkStream stream = client.GetStream();
                    byte[] banner = System.Text.Encoding.ASCII.GetBytes(
                        "listen v1.0, Kliment Andreev 2016\r\nType q to exit\r\n" 
                        + "Connected to " + client.Client.LocalEndPoint + "\r\n");
                    stream.Write(banner, 0, banner.Length);
                    int intLoop;
                    // Loop to receive all the data sent by the client.
                    while ((intLoop = stream.Read(bytes, 0, bytes.Length)) != 0)
                    {
                        // Translate data bytes to a ASCII string.
                        data = System.Text.Encoding.ASCII.GetString(bytes, 0, intLoop);
                        Console.WriteLine("Received: {0} from {1}", data, client.Client.RemoteEndPoint);
                        // Process the data sent by the client.
                        data = data.ToUpper();
                        if (data == "Q") return;
                        byte[] msg = System.Text.Encoding.ASCII.GetBytes(data);
                        // Send back a response.                        
                        stream.Write(msg, 0, msg.Length);                        
                        Console.WriteLine("Sent: {0} to {1}", data, client.Client.RemoteEndPoint);
                    }

                    // Shutdown and end connection
                    client.Close();
                }
            }
            catch (Exception e)
            {
                Console.WriteLine("SocketException: {0}", e);
            }
            finally
            {
                // Stop listening for new clients.
                //server.Stop();
            }
        }
    }
}

I made a small RSS feed tracker that monitors up to 5 RSS feeds and displays the changes in combo boxes. The program looks like this.

If you want to read the full article, select it from the drop down box and click on it. If you just want to see all of the available articles, click on the down arrow. Anytime you click on the article, it will open your default browser. For any other articles, a new tab will be opened.

The program can be minimized in the tray (double-click to bring it back). Every minute the program will check for any changes and if there are any, they will be displayed as a balloon tip.

Under Windows 10, it looks like this.

By default, the following 5 RSS sites are monitored.

https://blog.andreev.it/?feed=rss2
http://feeds.bbci.co.uk/news/world/rss.xml
http://feeds.feedburner.com/neowin-main
http://feeds.gawker.com/lifehacker/full.xml
http://feeds.mashable.com/Mashable

If you want to check other feeds, click on the button in the lower right corner and when the settings window pops up, enter your RSS URLs and click OK.

If there are any issues with the feeds, you can delete the whole KRSS folder that’s under:

C:\Users\%username%\AppData\Local

The C# code can be found at https://github.com/klimenta/KRSS and you can download the EXE from there as well (https://github.com/klimenta/KRSS/tree/master/KRSS/bin/Release/KRSS.exe)

I miss the onscreen weather gadget that was included in Windows 7, but not in Windows 10, so I made a similar application. It gets the current weather and the forecast from the Weather Underground web site. Initially I tried to use OpenWeatherMap and its API but the temperatures were off for an hour or two, meaning the current temperature that I got from the API call was the actual temperature 1-2 hours ago.
Both Weather Underground and OpenWeatherMap offer free API calls and you need to register in order to get an API key. Using that key, you can retrieve the weather. No key – no weather forecast.

So, first go to WU web site, register and get a key.
If you want to get the source, make sure that you have JSON from Netwtonsoft in your project reference. See their web page for install.

git clone https://www.github.com/klimenta/WUnderK

If you want the EXE, you’ll have to install it because the EXE comes with the Json.dll.
Download it from here.

NOTE: The WU API returns JSON which can be parsed and validated on this web site for accuracy. The output was deserialized directly to C# classes and the conversion was possible because of this site.

This is how the gadget (app) looks like expanded with the details and forecast panes. You can hide them if you want, so only the temperature and the city is shown.

This is the options screen.

And this is how it looks like on the screen.

This is an old game that I made about 15 years ago. The original game can be found on my old web site. Look for Kling! 2.001 and Kling!

Lately, when I played with C#, I decided to remake it. The original games were written in Delphi (Pascal).
You can get the source from GitHub.

git clone https://www.github.com/klimenta/5ball

The goal is to match 5 or more balls in any direction. Once you do that, they’ll disappear. But, every move you make, three more random balls are dropped on the grid.

You can get the EXE from here.

Windows 7 came with gadgets, small tools that sit on your desktop and do something. I used CPU/Memory gadget and the Weather gadget. Windows 8 and Windows 10, discontinued the gadgets, but there are some ways of how to install them back under Win 10.

I made a small tool in Visual C# (Community edition 2015) that does pretty much the same. It monitors the CPU usage and draws a graph. You can choose the background, transparency, threshold colors, etc… See the options screenshot below.

You can get the source here.

git clone https://www.github.com/klimenta/CPU-Gadget

If you get an exception while trying to compile or execute the program, it means your counters in registry are messed up.
This is the error that you might get.

InvalidOperationException: Cannot load Counter Name data because an invalid index '' was read from the registry.

Open the command prompt (Run as Administrator) and execute these commands depending on your OS (32/64) bit.

C:\windows\system32> lodctr /r

or

C:\windows\SysWOW64> lodctr /r

You should get this back if everything is OK.

Info: Successfully rebuilt performance counter setting from system backup store

If you get this, you are doing it for 32 bit OS instead of 64 bit OS and vice versa.

Error: Unable to rebuild performance counter setting from system backup store, error code is 2

This is how the gadget looks like on the desktop (click for larger image).

UPDATE 4/12/2016
================

Based on this source, I made slight modifications for another gadget that monitors the available RAM usage.
You can get the code here.

git clone https://www.github.com/klimenta/CPU-Gadget

Or get both executables from here (CPU Gadget) and here (RAM Gadget).

I used Visual C# and MS Office Development Tools to create a VSTO plugin for Outlook. Anytime you receive an email that have the words “please advise”, “please assist” or “kindly”, you’ll see a red banner in the email.

As Urban Dictionary says, please advise is “an extremely stuffy phrase used by business executives to close emails when they don’t understand how to ask a real question. It basically means Please use your imagination to figure out what the f* I need to know to make a decision on this item without making me look like an idiot in front of all the people I CCed”

Dear Luke,

I recently got a call from Alex in LA telling me that we're out of blinkity blank in California so the blippity blue isn't working. 
What-the-f* we're losing 15k a day what-the-f* save me please.

Please Advise, 
John

So…. Go to Visual Studio, choose a new Project and select Outlook. I did mine for Outlook 2010, but it should be very similar for 2013 and 2016.

Once you have the template, update the methods, so it looks like the source below. Change the list of words if you like (line 29), then compile and run and the add-in will be automatically added to Outlook. If you want to distribute it, it’s a bit more complicated, but check this page or this page.

If everything is OK, next time you receive an e-mail it will look like this.

using System.Collections.Generic;
using System.Linq;
using Outlook = Microsoft.Office.Interop.Outlook;

namespace PleaseAdvise
{
    public partial class ThisAddIn
    {

        Outlook.NameSpace outlookNameSpace;
        Outlook.MAPIFolder inbox;
        Outlook.Items items;

        private void ThisAddIn_Startup(object sender, System.EventArgs e)
        {
            outlookNameSpace = this.Application.GetNamespace("MAPI");
            inbox = outlookNameSpace.GetDefaultFolder(
                    Microsoft.Office.Interop.Outlook.
                    OlDefaultFolders.olFolderInbox);

            items = inbox.Items;
            items.ItemAdd +=
                new Outlook.ItemsEvents_ItemAddEventHandler(items_ItemAdd);
  
        }

        void items_ItemAdd(object Item)
        {            
            List<string> lstKeyWords = new List<string>(new string[] { "PLEASE ADVISE", "PLEASE ASSIST", "KINDLY" });
            Outlook.MailItem mail = (Outlook.MailItem)Item;
            if (Item != null)
            {
                bool bSubject = lstKeyWords.Any(mail.Subject.ToUpper().Contains);
                bool bBody = lstKeyWords.Any(mail.Body.ToUpper().Contains);
              
                if ((mail.MessageClass == "IPM.Note") && (bSubject || bBody))
                {
                    mail.FlagIcon = Outlook.OlFlagIcon.olRedFlagIcon;
                }
            }
        }
    
        private void ThisAddIn_Shutdown(object sender, System.EventArgs e)
        {
            // Note: Outlook no longer raises this event. If you have code that 
            //    must run when Outlook shuts down, see http://go.microsoft.com/fwlink/?LinkId=506785
        }

        #region VSTO generated code

        /// <summary>
        /// Required method for Designer support - do not modify
        /// the contents of this method with the code editor.
        /// </summary>
        private void InternalStartup()
        {
            this.Startup += new System.EventHandler(ThisAddIn_Startup);
            this.Shutdown += new System.EventHandler(ThisAddIn_Shutdown);
        }
        
        #endregion
    }
}

I needed some small program that will work in the background and do basic PING checks. Then I’ve decided to expand the scope and include TCP port checks, so I made this small program in Visual C#. You can get the program from GitHub.

git clone https://www.github.com/klimenta/kmon

As you can see from the screenshot, the top left buttons are used to add/remove a server. Each server can have maximum of 6 ports that can be monitored plus ping (ICMP). When you click on the red/green button, it enables or disables the monitoring. The time interval of 5 seconds (default) means that the program will do its checks for 5 seconds and then stop for 5 seconds. The more servers you have, the more your time interval should be. Do about 1-2 seconds per server for internal servers and 3-4 seconds for external (internet facing) servers. The timeout value of 100 ms means that when checking TCP ports, the program will wait for 100 ms before giving up. If your services are slow in response, increase this value.

There are also three buttons (SA, CLR and CPY). When clicked, they Select All the text from the text box, Clear the text and/or Copy it to the clipboard.

using System;
using System.Collections.Generic;
using System.Windows.Forms;
using System.Net.NetworkInformation;
using System.Net.Sockets;
using System.ComponentModel;
using System.Drawing;
using System.Text;

namespace kmon
{

    public partial class frmMain : Form
    {
        //All checks are running as background processes, otherwise the GUI would be very unresponsive
        private BackgroundWorker bw = new BackgroundWorker();
        //Ping average in ms
        double dPingTimeAverage;
        //Holds the status of each TCP port (open/closed)
        bool bCheckOpenTCPPort;
        //kmon can monitor up to 6 ports. You can probably go with more
        const int iNumberOfPorts = 6;
        //A list of Text Boxes for the ports
        List<TextBox> tbPort = new List<TextBox>();
        //Temp variable/counter
        public int intCounter = 0;
        //Default timeout for ping or port checks before kmon gives up
        int intTimeout = 100; //Default = 100 ms
        //Time interval for all checks. kmon will do it's job for 5 secs then pause for 5 secs
        int intTimeInterval = 5000; //Default 5 sec

        //Checks if the TCP port is open or closed
        public static bool CheckOpenTCPPort(string host, int port, int intTimeout)
        {
            bool bOpenPort = false;
            try
            {            
                TcpClient tcpClient = new TcpClient();
                tcpClient.ReceiveTimeout = intTimeout;
                tcpClient.SendTimeout = intTimeout;
                var AsyncResult = tcpClient.BeginConnect(host, port, null, null);
                var waitHandle = AsyncResult.AsyncWaitHandle;
                try
                {
                    if (!AsyncResult.AsyncWaitHandle.WaitOne(TimeSpan.FromMilliseconds(intTimeout), false))
                {
                        // wait handle didn't came back in time
                        tcpClient.Close();
                    }
                    else
                    {
                        // The result was positiv
                        bOpenPort = tcpClient.Connected;
                    }
                    // ensure the ending-call
                    tcpClient.EndConnect(AsyncResult);
                }
                finally
                {
                    // Ensure to close the wait handle.
                    waitHandle.Close();
                }
            }
            catch
            {
            }
            return bOpenPort;
        }

        //Returns the ping time average. If the return value is negative 1 (-1), it means the host is not reachable.
        //It doesn't necessarily means it's down. It means, ICMP protocolo can not be established between kmon and the end host.
        public static double PingTimeAverage(string host, int timeout)
        {
            Ping pingSender = new Ping();
            PingOptions options = new PingOptions();
            options.DontFragment = true;
            string data = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
            byte[] buffer = Encoding.ASCII.GetBytes(data);
            //int timeout = 
            PingReply reply = pingSender.Send(host, timeout, buffer, options);
            if (reply.Status == IPStatus.Success)
            {
                return reply.RoundtripTime;
            }
            else
            { return -1.0; }
        }

        //A class for each monitored server
        public class Server
        {
            //Server name
            public string strServerName { get; set; }
            //Ping monitoring (y/n)
            public bool bPing { get; set; }
            //TCP Ports
            public List<int> lstPorts = new List<int>();
        }

        //Initialize a list of server objects
        List<Server> srvServer = new List<Server>();
        //Toggle for monitoring/not monitoring button
        private bool bMonitor = false;
        
        public frmMain()
        {
            InitializeComponent();
            btnMonitor.BackColor = System.Drawing.Color.Red;
            btnMonitor.Text = "Not Monitoring";
            
            for (int i = 0; i < iNumberOfPorts; i++)
            {
                TextBox newTextBox = new TextBox();
                tbPort.Add(newTextBox);
                tbPort[i].Width = 45;
                tbPort[i].Height = 20;
                                
                tbPort[i].TabIndex = i + 10;
                tbPort[i].Text = "0";
                tbPort[i].Name = "tbPort" + i.ToString();
                tbPort[i].Tag= i;
                tbPort[i].TextChanged += new EventHandler(tbPort_TextChanged);
                this.Controls.Add(newTextBox);
            }
            tbPort[0].Top = 45; tbPort[1].Top = 45; tbPort[2].Top = 45;
            tbPort[3].Top = 75; tbPort[4].Top = 75; tbPort[5].Top = 75;
            tbPort[0].Left = 221; tbPort[3].Left = 221;
            tbPort[1].Left = 335; tbPort[4].Left = 335;
            tbPort[2].Left = 449; tbPort[5].Left = 449;


            bw.WorkerReportsProgress = true;
            bw.WorkerSupportsCancellation = true;
            bw.DoWork += new DoWorkEventHandler(bw_DoWork);
            bw.ProgressChanged += new ProgressChangedEventHandler(bw_ProgressChanged);
            bw.RunWorkerCompleted += new RunWorkerCompletedEventHandler(bw_RunWorkerCompleted);            
        }

        //Event when you change the port to be monitored
        protected void tbPort_TextChanged(object sender, EventArgs e)
        {
            int intPort;
            int intCheck = lbServers.SelectedIndices.Count;
            
            if (lbServers.SelectedIndex == -1)
            {
                MessageBox.Show("You have to select a server on the left side", "Error");
                return;
            }
            try
            {                
                intPort = Convert.ToInt32((sender as TextBox).Text.Trim());
                if (intPort > 65535) intPort = 65535;           
            }
            catch (Exception)
            {
                (sender as TextBox).Text = "0";
                return;
            }
            srvServer[lbServers.SelectedIndex].lstPorts[Convert.ToInt32((sender as TextBox).Tag)] = intPort;            
        }

        //Add server to be monitored
        private void btnAdd_Click(object sender, EventArgs e)
        {
            frmAddServer frm2 = new frmAddServer();
            frm2.ShowDialog();
            //Prevent duplicates
            if (frmAddServer.strServerName == null || frmAddServer.strServerName == "") return;
            if (!lbServers.Items.Contains(frmAddServer.strServerName))
            {
                lbServers.Items.Add(frmAddServer.strServerName);
                srvServer.Add(new Server { strServerName = frmAddServer.strServerName, bPing = false, lstPorts = new List<int>(iNumberOfPorts) { 0, 0, 0, 0, 0, 0 } });                
            }
            else
            {
                MessageBox.Show("Duplicate entry. Please re-enter.", "kmon");
            }            
        }

        //Remove server from being monitored
        private void btnRemove_Click(object sender, EventArgs e)
        {
            for (int intCounter = lbServers.SelectedIndices.Count - 1; intCounter >= 0; intCounter--)
            {
                int intIndex = lbServers.SelectedIndices[intCounter];
                lbServers.Items.RemoveAt(intIndex);
                srvServer.RemoveAt(intIndex);
            }
        }

        //Toggle button monitor/not monitor
        private void btnMonitor_Click(object sender, EventArgs e)
        {            
            if (bMonitor)
            {
                bMonitor = false;
                btnMonitor.BackColor = Color.Red;
                btnMonitor.Text = "Not Monitoring";               
                if (bw.WorkerSupportsCancellation == true)
                {
                    bw.CancelAsync();
                }
            }
            else
            {
                bMonitor = true;
                btnMonitor.BackColor = Color.Green;
                btnMonitor.Text = "Monitoring";               
                if (bw.IsBusy != true)
                {
                    bw.RunWorkerAsync();
                }
            }
        }

        //Event when you change the time interval
        private void tbInterval_TextChanged(object sender, EventArgs e)
        {
            try
            {
                intTimeInterval = Convert.ToInt32(tbInterval.Text.Trim()) * 1000;                
            }
            catch (Exception)
            {
                tbInterval.Text = "5";
            }
        }

        //Event when you select the server from the list of servers
        private void lbServers_SelectedIndexChanged(object sender, EventArgs e)
        {            
            try
            {               
                for (int i = 0; i < iNumberOfPorts; i++)
                {
                    tbPort[i].Text = srvServer[lbServers.SelectedIndex].lstPorts[i].ToString();
                }                    
                cbPing.Checked = srvServer[lbServers.SelectedIndex].bPing;
            }
            catch (Exception)
            { }            
        }

        //Check mark event ping/not ping
        private void cbPing_CheckedChanged(object sender, EventArgs e)
        {
            int intCheck = lbServers.SelectedIndices.Count;
            if (lbServers.SelectedIndex == -1)
            {
                MessageBox.Show("You have to select a server on the left side", "Error");
                return;
            }
            srvServer[lbServers.SelectedIndex].bPing = cbPing.Checked;       
        }

        //Background process init/cancel
        private void bw_DoWork(object sender, DoWorkEventArgs e)
        {
            BackgroundWorker worker = sender as BackgroundWorker;

            while ( true )
            {
                if ((worker.CancellationPending == true))
                {
                    e.Cancel = true;
                    break;
                }
                else
                {                    
                    System.Threading.Thread.Sleep(intTimeInterval); //Time interval between each thread
                    worker.ReportProgress(0);
                }
            }
        }

        //Append log
        private void bw_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            if ((e.Cancelled == true))
            {                
                rtbLog.AppendText(DateTime.Now + " ", Color.Blue);                
                rtbLog.AppendText("NOT MONITORING!" + Environment.NewLine, Color.Red);
            }

            else if (!(e.Error == null))
            {
                rtbLog.AppendText(DateTime.Now + " ", Color.Blue);
                rtbLog.AppendText("Error: " + e.Error.Message, Color.Red);
            }

            else
            {
                rtbLog.AppendText(DateTime.Now + " ", Color.Blue);
                rtbLog.AppendText("Done!", Color.Green);
            }
        }

        //Main process for ping/check TCP ports
        private void bw_ProgressChanged(object sender, ProgressChangedEventArgs e)
        {
            Color cColor;
            for (int j = 0; j < srvServer.Count; j++)
            {
                if (srvServer[j].bPing) {
                    dPingTimeAverage = PingTimeAverage(srvServer[j].strServerName, intTimeout);
                    rtbLog.AppendText(DateTime.Now + " ", Color.Blue);
                    if (dPingTimeAverage == -1)
                    {
                        cColor = Color.Red;
                    }
                    else
                    {
                        cColor = Color.Green;
                    }
                    string strPingTimeAverage = dPingTimeAverage.ToString();
                    if (strPingTimeAverage == "-1")
                    {
                        strPingTimeAverage = "NOT REACHABLE ";
                    }
                    rtbLog.AppendText(srvServer[j].strServerName + " " + strPingTimeAverage + "ms reply time " + Environment.NewLine, cColor);
                }
                int i = 0;
                while (srvServer[j].lstPorts[i] != 0) {
                    bCheckOpenTCPPort = CheckOpenTCPPort(srvServer[j].strServerName, srvServer[j].lstPorts[i], intTimeout);
                    rtbLog.AppendText(DateTime.Now + " ", Color.Blue);
                    if (bCheckOpenTCPPort)
                    {
                        cColor = Color.Green;
                    }
                    else
                    {
                        cColor = Color.Red;
                    }
                    string strPort;
                    if (bCheckOpenTCPPort)
                    {
                        strPort = " opened";
                    }
                    else {
                        strPort = " CLOSED";
                    }
                    rtbLog.AppendText(srvServer[j].strServerName + " has port " + srvServer[j].lstPorts[i].ToString() + strPort + Environment.NewLine, cColor);
                    i++;
                }
            }
        }

        //Select all in the log
        private void btnSelectAll_Click(object sender, EventArgs e)
        {
            rtbLog.SelectAll();
        }

        //Clear the log
        private void btnClearLog_Click(object sender, EventArgs e)
        {
            rtbLog.Clear();
        }

        //Copy the log to clipboard
        private void btnCopy_Click(object sender, EventArgs e)
        {
            Clipboard.SetText(rtbLog.SelectedRtf, TextDataFormat.Rtf);
        }

        //Event when you change the timeout setting
        private void tbTimeout_TextChanged(object sender, EventArgs e)
        {
            try
            {
                intTimeout = Convert.ToInt32(tbTimeout.Text.Trim());
            }
            catch (Exception)
            {
                tbTimeout.Text = "100";
            }            
        }

        //Hide the window when minimized
        private void frmMain_Resize(object sender, EventArgs e)
        {
            if (FormWindowState.Minimized == WindowState)
                Hide();
        }

        //Retore the view when the icon is clicked in the tray
        private void notifyIcon1_MouseDoubleClick(object sender, MouseEventArgs e)
        {
            Show();
            WindowState = FormWindowState.Normal;
        }

        //Restore the icon when "restore" option is chosen from the menu
        private void restoreToolStripMenuItem_Click(object sender, EventArgs e)
        {
            Show();
            WindowState = FormWindowState.Normal;
        }

        //Try to close the program when "exit" option is chosen from the menu
        private void exitToolStripMenuItem_Click(object sender, EventArgs e)
        {
            Application.Exit();
        }

        //Ask for confirmation before the program closes
        private void frmMain_FormClosing(object sender, FormClosingEventArgs e)
        {
            if (MessageBox.Show("Are you sure you want to close?", "kmon", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.No)
            {
                e.Cancel = true;
            }
        }
    }
}

//Class to Extend AppendText for RichTextBox control to include the color value
public static class RichTextBoxExtensions
{
    public static void AppendText(this RichTextBox box, string text, Color color)
    {
        box.SelectionStart = box.TextLength;
        box.SelectionLength = 0;
        box.SelectionColor = color;
        box.AppendText(text);
        box.SelectionColor = box.ForeColor;
    }
}