C#

Greeeg wrote:

As far as I know first a quicksort is used to "divide and conquer", but for sublists with <=7 elements the insertion sort is used. That's at least the case in the C++ STL.

<br />
System.Net.Sockets.TcpClient myclient = new System.Net.Sockets.TcpClient();<br />
for (int i = 0; i < 65535; i++)<br />
{<br />
   try<br />
   {<br />
     myclient.Connect("localhost", i);<br />
     // Client was able to connect, hence the specified port 'i' is open...<br />
   }<br />
   catch<br />
   {<br />
     // An Exception was thrown, hence there was a problem while connecting.. port 'i' closed?<br />
   }<br />
}<br />

Robert Rohde wrote:

2. Can the server send messages to the clients?
In the examples I have investigated so far (mostly chat apps) the clients regulary poll for new data from the server. Is there a possibility that the server directly calls functions in all connected clients?

Robert Rohde wrote:

3. When a client makes a call in the server does this call create server side a new thread in which this call is processed? Is this the same for every call coming from the same client?

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

namespace GlobalKeyHook
{
  /// <summary>
  /// <c>KeyboardHook</c>, as the name implies, hooks into the windows messaging system to
  /// catch global keystrokes.
  /// </summary>
  /// <remarks>
  /// <para>	/// The hook is automatically released when the class is disposed.
  /// You can force the release by calling <see cref="Dispose"/></para>
  /// <para>The class exposes a KeyDown and KeyUp event, which can be used as any
  /// other keydown/up event in the .net framework. The sender object will always be
  /// this class, but all global keystrokes are processed.
  /// As in other keydown/up events, setting handled of the keyeventargs object to true
  /// <code>e.Handled=true;</code> will prevent other hooks from executing. For system keys
  /// as the Windows key, this means that the key gets 'blocked'</para>
  /// </remarks>
  public class KeyboardHook : IDisposable
  {
    #region Hook-dlls

    [DllImport("user32", EntryPoint = "SetWindowsHookExA")]
    private static extern int SetWindowsHookEx(int idHook, KeyBoardCatcherDelegate lpfn, int hmod, int dwThreadId);

    [DllImport("user32.dll", CharSet = CharSet.Auto,
     ExactSpelling = true, CallingConvention = CallingConvention.Winapi)]
    private static extern short GetKeyState(int keyCode);

    [DllImport("user32", EntryPoint = "MapVirtualKey")]
    private static extern int MapVirtualKey(int wCode, int wMapType);

    [DllImport("user32", EntryPoint = "CallNextHookEx")]
    private static extern int CallNextHook(int hHook, int ncode, int wParam, KeybHookStruct lParam);

    private const int
      WH_KEYBOARD = 2,
      WH_KEYBOARD_LL = 13; //Global keyboard hook. 

    [DllImport("user32", EntryPoint = "UnhookWindowsHookEx")]
    private static extern int UnhookWindowsHookEx(int hHook);

    #endregion


    private bool m_DisableHooking = false;
    /// <summary>Gets/Sets the DisableHooking property.</summary>
    public bool DisableHooking
    {
      get { return m_DisableHooking; }
      set { m_DisableHooking = value; }
    }
	      

    public KeyboardHook()
    {
      kbcatcher = new KeyBoardCatcherDelegate(KeyBoardCatcher);

      keybhook = SetWindowsHookEx(WH_KEYBOARD_LL, kbcatcher,
        Marshal.GetHINSTANCE(typeof(KeyboardHook).Module).ToInt32(), 0);

      if (keybhook == 0)
        throw new ExternalException("Error: " + Marshal.GetLastWin32Error().ToString() + "\r\nCould not hook keyboard");
    }

    /// <summary></summary>
    /// <param name="AddModifierData" type="bool">See the property <see cref="AddModifierData"/> for info</param>
    /// <returns></returns>
    public KeyboardHook(bool AddModifierData)
      : this()
    {
      this.AddModifierData = AddModifierData;
    }

    #region Dispose
    /// <summary>The keyboard hook id, to be used with unhookwindowsex</summary>
    /// <remarks></remarks>
    private readonly int keybhook;

    private bool disposed;
    /// <summary>call Dispose when finished to release the hook.
    /// If this is not done manually, the destructor releases the hook,
    /// but manually disposing is more effective</summary>
    public void Dispose()
    {
      if (!disposed)
      {
        UnhookWindowsHookEx(keybhook);
        GC.SuppressFinalize(this);
        disposed = true;
      }
    }

    /// <summary>Destructor</summary>
    ~KeyboardHook()
    {
      Dispose();
    }
    #endregion

    /// <summary>This structure is filled when calling the KeyBoardCatcherDelegate.</summary>
    private struct KeybHookStruct
    {
      public int vkCode, scanCode, flags, time, dwExtraInfo;
    }

    private delegate int KeyBoardCatcherDelegate(int code, int wparam, ref KeybHookStruct lparam);


    public static bool CheckKeyPressed(params Keys[] keys)
    {
      for (int i = 0; i < keys.Length; i++)
        if (!CheckKeyPressed(ref keys[i])) return false;
      return true;
    }

    public static bool CheckKeyPressed(ref Keys key)
    {
      return CheckKeyPressed((int)key);
    }

    public static bool CheckKeyPressed(int vkey)
    {
      short ks = GetKeyState(vkey);
      Console.WriteLine(ks);
      return ks == 1;
    }

    public bool IsKeyPressed(Keys key)
    {
      return CheckKeyPressed(ref key);
    }

    public bool AreKeysPressed(params Keys[] keys)
    {
      return CheckKeyPressed(keys);
    }

    private const int HC_ACTION = 0;

    [MarshalAs(UnmanagedType.FunctionPtr)]
    private KeyBoardCatcherDelegate kbcatcher;

    /// <summary>Catch the keys if you like. These are the global keys. Set e.Handled=true to block the key (such as alt-tab)</summary>
    public event KeyEventHandler
      KeyDown = null,
      KeyUp = null;

    private const int
      wpKeyDown = 256,
      wpKeyUp = 257;

    /// <summary>If this value is <c>true</c>
    /// modifier data (such as shift,control,alt) is added to the KeyEventArgs, otherwise
    /// only the keydata is send.
    /// Adding the modifier data can produce some overhead since
    /// it is checked on every keypress.
    /// If you want to check manually, set this property to <c>false</c>
    /// and check <see cref="IsKeyPressed"/> instead
    /// </summary>
    public bool AddModifierData = true;

    public readonly Keys[] Modifiers = { Keys.Alt, Keys.Control, Keys.Shift };

    /// <summary>The method that's used to catch the keyboard input</summary>
    /// <param name="idHook" type="int"></param>
    /// <param name="wparam" type="int"></param>
    /// <param name="lparam" type="ref ShortCutter.Form1.keybHookStruct"></param>
    /// <returns></returns>
    private int KeyBoardCatcher(int hookcode, int wparam, ref KeybHookStruct lparam)
    {
      if (HC_ACTION == hookcode)
      {
        if ((wparam == wpKeyDown && KeyDown != null)
          || (wparam == wpKeyUp && KeyUp != null))
        {
          try
          {
            Keys k = (Keys)lparam.vkCode;
            if (AddModifierData)
              k |= Control.ModifierKeys;

            KeyEventArgs e = new KeyEventArgs(k);

            if (wparam == wpKeyDown)
              KeyDown(this, e);
            else
              KeyUp(this, e);
            //If handled, do not process any other hooks after this one. (key is blocked)
            if (e.Handled) return 1;
          }
          /*
          //for debugging only
          catch(Exception ex)
          {
            MessageBox.Show(ex.Message);
          }
          */
          catch { }
        }
      }
      //Call the next hook for the input
      return CallNextHook(keybhook, hookcode, wparam, lparam);
    }
  }
}

// install global system hooks
KeyHooker keyhooker = KeyHooker.Instance;

// disable global keyboard hooks
KeyHooker.Instance.DisableHooking = true;

// re-enable hotkey hooks
KeyHooker.Instance.DisableHooking = false;

using System;
using System.Drawing;
using System.Runtime.InteropServices;

namespace ScreenShot.interop
{
  /// <summary>
  /// This class encapsulates the API functions necessary to get the
  /// desktop image and form a bitmap from it.
  /// </summary>	
  public sealed class Desktop
  {
    [DllImport("user32.dll")]
    internal extern static IntPtr GetDesktopWindow();

    [DllImport("user32.dll")]
    internal extern static IntPtr GetDC(IntPtr windowHandle);

    [DllImport("gdi32.dll")]
    internal extern static IntPtr GetCurrentObject(IntPtr hdc, ushort objectType);

    [DllImport("user32.dll")]
    internal extern static void ReleaseDC(IntPtr hdc);

    [DllImport("user32.dll")]
    internal extern static void UpdateWindow(IntPtr hwnd);

    [DllImport("user32")]
    internal static extern IntPtr GetWindowDC(IntPtr hwnd);

    [DllImport("user32")]
    public static extern IntPtr GetForegroundWindow();

    /// <summary>
    /// Captures the windows desktop and returns it as a Bitmap
    /// </summary>
    /// <returns></returns>
    internal static Bitmap Capture()
    {
      try
      {
        //Get a pointer to the desktop window
        IntPtr desktopWindow = GetDesktopWindow();

        //Get a device context from the desktop window
        IntPtr desktopDC = GetDC(desktopWindow);

        Bitmap desktopImage = GetBitmap(desktopDC);

        ReleaseDC(desktopDC);

        return desktopImage;
      }
      catch (Exception e)
      {
        ScreenShotConfig.persistance.Logger.Log(typeof(Desktop), "Capture(): " + e.Message);
        return null;
      }
    }

    internal static Bitmap GetBitmap(IntPtr imagePtr)
    {
      //Get a GDI handle to the image
      IntPtr hwnd = GetCurrentObject(imagePtr, 7);

      //This call takes as an argument the handle to a GDI image
      Bitmap desktopImage = Image.FromHbitmap(hwnd);

      return desktopImage;
    }


    internal static Bitmap GetForegroundWindowBitmap()
    {
      IntPtr handle = GetForegroundWindow();

      //Get a device context from the desktop window
      IntPtr windowDC = GetWindowDC(handle);

      //Get a GDI handle to the image
      IntPtr hwnd = GetCurrentObject(windowDC, 0);

      //This call takes as an argument the handle to a GDI image
      Bitmap desktopImage = Image.FromHbitmap(hwnd);

      ReleaseDC(windowDC);

      return desktopImage;
    }

  }
}

Bitmap b = Desktop.Capture();

Rectangle rec = Screen.PrimaryScreen.Bounds;
Bitmap screenCap = new Bitmap(rec.Width, rec.Height, PixelFormat.Format32bppArgb);
Graphics getScreen = Graphics.FromImage(screenCap);
getScreen.CopyFromScreen(rec.X, rec.Y, 0, 0, rec.Size, CopyPixelOperation.SourceCopy);
return screenCap;