C#

// SingleInstance.cs

using System;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Threading;
using System.Windows.Forms;

namespace YourNamespace
{
    internal static class SingleInstance
    {
        #region Fields

        private static Form applicationForm = null;
        private static string assemblyGuid = null;
        private static int message = 0;
        private static Mutex mutex = null;

        #endregion

        #region Properties

        /// <summary>
        /// Gets this assembly's GUID.
        /// </summary>
        private static string AssemblyGuid
        {
            get
            {
                if (assemblyGuid == null)
                {
                    object[] attributes = Assembly.GetEntryAssembly().GetCustomAttributes(typeof(GuidAttribute), false);
                    if (attributes.Length != 0)
                        assemblyGuid = ((GuidAttribute)attributes[0]).Value;
                    else
                        assemblyGuid = string.Empty;
                }
                return assemblyGuid;
            }
        }
        /// <summary>
        /// Gets the unique message that will be broadcast when another instance is rejected.
        /// </summary>
        public static int Message
        {
            get
            {
                if (message == 0)
                    message = NativeMethods.RegisterWindowMessage(String.Format("WM_SHOWFIRSTINSTANCE|{0}", AssemblyGuid));
                return message;
            }
        }

        #endregion

        #region Methods

        /// <summary>
        /// If this is the only instance of this application then it will be run.
        /// If not, a message will be broadcast that the first instance can respond to.
        /// </summary>
        /// <param name="mainForm">A System.Windows.Forms.Form that represents the form to make visible.</param>
        /// <remarks>Call this from Main in Program.cs to run your app as a single instance.</remarks>
        public static void Run(Form mainForm)
        {
            Run(mainForm, false);
        }
        /// <summary>
        /// If this is the only instance of this application then it will be run.
        /// If not, a message will be broadcast that the first instance can respond to.
        /// </summary>
        /// <param name="mainForm">A System.Windows.Forms.Form that represents the form to make visible.</param>
        /// <param name="globalMutex">true to make this single instance system wide; otherwise, false.</param>
        /// <remarks>Call this from Main in Program.cs to run your app as a single instance.</remarks>
        public static void Run(Form mainForm, bool globalMutex)
        {
            if (mainForm != null)
            {
                if (Start(globalMutex))
                {
                    try
                    {
                        applicationForm = mainForm;
                        Application.Run(applicationForm);
                    }
                    catch (Exception e)
                    {
                        MessageBox.Show(e.Message);
                    }
                    Stop();
                }
            }
        }
        /// <summary>
        /// Brings the main form to the front and gives it focus.
        /// If the form is minimized or maximized it will be restored.
        /// </summary>
        public static void ShowToFront()
        {
            if (applicationForm != null)
            {
                NativeMethods.SetWindowPos(applicationForm.Handle, new IntPtr(-1), 0, 0, 0, 0, NativeMethods.SWP_NOMOVE | NativeMethods.SWP_NOSIZE);
                NativeMethods.SetWindowPos(applicationForm.Handle, new IntPtr(-2), 0, 0, 0, 0, NativeMethods.SWP_NOMOVE | NativeMethods.SWP_NOSIZE);
                NativeMethods.ShowWindow(applicationForm.Handle, NativeMethods.SW_SHOWNORMAL);
                NativeMethods.SetForegroundWindow(applicationForm.Handle);
            }
        }
        private static bool Start()
        {
            return Start(false);
        }
        private static bool Start(bool globalMutex)
        {
            bool createdNew = false;
            string name = null;
            if (globalMutex)
                name = String.Format("Global\\{0}", AssemblyGuid);
            else
                name = string.Format("Local\\{0}", AssemblyGuid);
            Mutex thisMutex = new Mutex(true, name, out createdNew);
            if (createdNew)
                mutex = thisMutex;
            else
                NativeMethods.PostMessage(
                    (IntPtr)NativeMethods.HWND_BROADCAST,
                    Message,
                    IntPtr.Zero,
                    IntPtr.Zero);
            return createdNew;
        }
        private static void Stop()
        {
            mutex.ReleaseMutex();
        }

        #endregion

        /// <summary>
        /// Win32 API functions.
        /// </summary>
        private static class NativeMethods
        {
            #region Constants

            /// <summary>
            /// The message is posted to all top-level windows in the system, including disabled or invisible unowned windows, overlapped windows, and pop-up windows.
            /// The message is not posted to child windows.
            /// </summary>
            public const int HWND_BROADCAST = 0xffff;
            /// <summary>
            /// Activates and displays a window.
            /// If the window is minimized or maximized, the system restores it to its original size and position.
            /// </summary>
            public const int SW_SHOWNORMAL = 1;
            /// <summary>
            /// Retains the current size (ignores the cx and cy parameters).
            /// </summary>
            public const int SWP_NOSIZE = 0x0001;
            /// <summary>
            /// Retains the current position (ignores X and Y parameters).
            /// </summary>
            public const int SWP_NOMOVE = 0x0002;

            #endregion

            #region Methods

            // http://msdn.microsoft.com/en-us/library/ms644944(VS.85).aspx
            /// <summary>
            /// Places (posts) a message in the message queue associated with the thread that created the specified window and returns without waiting for the thread to process the message.
            /// </summary>
            /// <param name="hWnd">Handle to the window whose window procedure is to receive the message.</param>
            /// <param name="Msg">Specifies the message to be posted.</param>
            /// <param name="wParam">Additional message-specific information.</param>
            /// <param name="lParam">Additional message-specific information.</param>
            /// <returns>Nonzero if the function succeeds; otherwise, zero.</returns>
            [DllImport("user32")]
            public static extern bool PostMessage(
                IntPtr hWnd,
                int Msg,
                IntPtr wParam,
                IntPtr lParam);

            // http://msdn.microsoft.com/en-us/library/ms644947(VS.85).aspx
            /// <summary>
            /// Defines a new window message that is guaranteed to be unique throughout the system.
            /// </summary>
            /// <param name="lpString">String that specifies the message to be registered.</param>
            /// <returns>A message identifier in the range 0xC000 through 0xFFFF ff the message is successfully registered; otherwise, zero</returns>
            [DllImport("user32")]
            public static extern int RegisterWindowMessage(
                string lpString);

            // http://msdn.microsoft.com/en-us/library/ms633539(VS.85).aspx
            /// <summary>
            /// Puts the thread that created the specified window into the foreground and activates the window.
            /// </summary>
            /// <param name="hWnd">Handle to the window that should be activated and brought to the foreground.</param>
            /// <returns>Nonzero if the window was brought to the foreground; otherwise, zero.</returns>
            [DllImport("user32.dll")]
            public static extern bool SetForegroundWindow(
                IntPtr hWnd);

            // http://msdn.microsoft.com/en-us/library/ms633545(VS.85).aspx
            /// <summary>
            /// Changes the size, position, and Z order of a child, pop-up, or top-level window.
            /// </summary>
            /// <param name="hWnd">A handle to the window.</param>
            /// <param name="hWndInsertAfter">A handle to the window to precede the positioned window in the Z order.</param>
            /// <param name="X">Specifies the new position of the left side of the window, in client coordinates.</param>
            /// <param name="Y">Specifies the new position of the top of the window, in client coordinates.</param>
            /// <param name="cx">Specifies the new width of the window, in pixels.</param>
            /// <param name="cy">Specifies the new height of the window, in pixels. </param>
            /// <param name="uFlags">Specifies the window sizing and positioning flags.</param>
            /// <returns>Nonzero if the function succeeds; otherwise, zero.</returns>
            [DllImport("user32.dll")]
            public static extern bool SetWindowPos(
                IntPtr hWnd,
                IntPtr hWndInsertAfter,
                int X,
                int Y,
                int cx,
                int cy,
                int uFlags);

            // http://msdn.microsoft.com/en-us/library/ms633548(VS.85).aspx
            /// <summary>
            /// Sets the specified window's show state.
            /// </summary>
            /// <param name="hWnd">Handle to the window.</param>
            /// <param name="nCmdShow">Specifies how the window is to be shown.</param>
            /// <returns>Nonzero if the window was previously visible; otherwise, zero.</returns>
            [DllImport("user32.dll")]
            public static extern bool ShowWindow(
                IntPtr hWnd,
                int nCmdShow);

            #endregion
        }
    }
}

// Modified Program.cs
using System;
using System.Windows.Forms;

namespace YourNamespace
{
    internal static class Program
    {
        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        [STAThread]
        static void Main()
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            // Use SingleInstance class instead of Application
            SingleInstance.Run(new FormMain());
        }
    }
}

//  Added to FormMain.cs

protected override void WndProc(ref Message message)
{
    if (message.Msg == SingleInstance.Message)
        SingleInstance.ShowToFront();
    base.WndProc(ref message);
}

Wheels012 wrote:

numbers[i].ToString() == ""

Wheels012 wrote:

int[] numbers = new int[1000];

Wheels012 wrote:

numbers[i].ToString() == ""

Wheels012 wrote:

Originally I had the array declaration in the method ... that would clear the array everytime

Wheels012 wrote:

I will look it up

Luc Pattyn wrote:

HashSet

Alex Manolescu wrote:

you can create an array of dimension = elements x 2 (for the duplicates).

Alex Manolescu wrote:

If you don't know the number of elements then you need to use another data structure, for example: a linked list!

John Simmons / outlaw programmer wrote:

Jeeze!

Wheels012 wrote:

Array.BinarySearch(numbers, 0, numbers.Length, intRnd);

List<int> numbers = new List<int>();

private bool RndDuplicate(int intRnd)
{
    if (numbers.Contains(intRnd))
        return true;
    else
    {
        numbers.Add(intRnd);
        return false;
    }
}

HashSet set=new HashSet();

private bool RndDuplicate(int intRnd) {return !set.Add(intRnd);}