Wes' Puzzling Blog

using System.Drawing;
using System.Security.Cryptography;


...


public static Color GetRandomColor()
{
  KnownColor[] colors = (KnownColor[])Enum.GetValues(typeof(KnownColor));
  
  return Color.FromKnownColor(colors[GetRandomNumber(colors.Length)]);  
}


public static int GetRandomNumber(int maxValue)
{
  RandomNumberGenerator rng = RNGCryptoServiceProvider.Create();


  byte[] bytes = new byte[4];


  rng.GetBytes(bytes);


  int ranNum = BitConverter.ToInt32(bytes, 0);


  return Math.Abs(ranNum % maxValue);
}

using System;
using Microsoft.Win32;


...


/// 

/// This method will retrieve the directory of the framework that this
/// program is executing under.  It accomplishes this by getting the
/// install root directory from the registry and then getting the framework
/// version by using Environment.Version.
/// 
/// path of the framework executing this program
public static string GetFrameworkDirectory()
{
  // This is the location of the .Net Framework Registry Key
  string framworkRegPath = @"Software\Microsoft\.NetFramework";


  // Get a non-writable key from the registry
  RegistryKey netFramework = Registry.LocalMachine.OpenSubKey(framworkRegPath, false);


  // Retrieve the install root path for the framework
  string installRoot = netFramework.GetValue("InstallRoot").ToString();


  // Retrieve the version of the framework executing this program
  string version = string.Format(@"v{0}.{1}.{2}\",
    Environment.Version.Major, 
    Environment.Version.Minor,
    Environment.Version.Build); 


  // Return the path of the framework
  return System.IO.Path.Combine(installRoot, version);     
}

public static void Main(string[] args)
{
  // bool used to determine if we created a new mutex
  bool createdNew;
 
  // give a unique name for the mutex,
  // prefix it with Local\ to ensure that it's created in the per-session namespace, not the global namespace.
  string mutexName = @"Local\" + System.Reflection.Assembly.GetExecutingAssembly().GetName().Name;
 
  // Create a new mutex object with given name
  Mutex m = new Mutex(false, mutexName, out createdNew);
 
  // If the mutex already exists then don't start program becase
  // another instance is already running.
  if(!createdNew)
    return;
 
  //
  // Do work like Application.Run(new MainForm());
  //
 
  // Release the mutex resources
  m.ReleaseMutex();
}

string[] args = {
  "C:\WINDOWS\Microsoft.NET\Framework\v1.0.3705\IEExec", 
  "http://localhost/WebCommandLine/WebCommandLine.exe?param1&param2", 
  "3", "1",  "86474707A3C6F63616C686F6374710000000"};

AppDomain.CurrentDomain.SetData("APP_CONFIG_FILE", "");

using System;
using System.IO;
using System.Reflection;
public class MainClass
{
  public const string APP_CONFIG_FILE = "APP_CONFIG_FILE";
  /// <summary>
  /// The main entry point for the application.
  /// </summary>
  [STAThread]
  public static void Main(string[] args)
  {
    // Get Command Line Args
    args = CommandLineArgs(args);
    // Print out the command line parameters
    int parmNumber = 1;        
    foreach(string arg in args)
      Console.WriteLine("Parameter {0}: {1}", parmNumber++, arg);
    Console.ReadLine();
  }
  /// <summary>
  /// This will determine if this exe was executed locally or through a web browser. 
  /// </summary>
  public static bool IsSmartClient
  {
    get
    {
      try
      {         
        new DirectoryInfo(AppDomain.CurrentDomain.SetupInformation.ApplicationBase);
        return false;
      }
      catch 
      {
        return true;
      }
    }
  }
  /// <summary>
  /// This method will parse the command line arguments for a .Net exe's start through
  /// a web browser(Smart Clients).  It will simple split the string after the '?' by the '&'.
  /// </summary>
  /// <remarks>EnvironmentPermission: You must have Read permission to access the "Path" environment 
  /// variable for the Environment.GetCommandLineArgs() 
  /// Command line args passed into main </remarks>
  /// <returns>list of command line args from main or from web command line</returns>
  public static string[] CommandLineArgs(string[] args)
  {
    // If this is not a smart client then return the passed in args
    if(!IsSmartClient)
      return args;
    // If you don't set the config file correctly then you will receive exception like:
    // ConfigurationException: can't file xml file app.exe?param1&param2.config     
    // Correct the location of the config file, I'm setting it to the empty string because
    // I'm not using a config file for this app, but you can set the file to what you want,
    // but remember that by default IIS will not serve a .config file.
    AppDomain.CurrentDomain.SetData(APP_CONFIG_FILE, "");
    // Get the command line args from the environment 
    args = Environment.GetCommandLineArgs();
    // args should look something like: 
    // C:\WINDOWS\Microsoft.NET\Framework\v1.0.3705\IEExec
    //  http://localhost/WebCommandLine/WebCommandLine.exe?param1&param2
    //  3 1 86474707A3C6F63616C686F6374710000000
    
    // Second parameter should be the url
    string url = args[1];
    int startParams = url.IndexOf("?") + 1;
    // If there is no '?' then return  
    if(startParams <= 0)
      return new string[] {};
    // Return the list of parameters split by '&'
    return url.Substring(startParams).Split('&');
  }
}