C#

<br />
Configuration config = ConfigurationManager.OpenExeConfiguration("");        <br />
ConfigurationSection section = config.Sections["connectionStrings"];<br />
<br />
// you can use the section information here such as<br />
//   section.SectionInformation.UnprotectSection();<br />
<br />
// then make sure to save the changes to the file<br />
config.Save();<br />

Syed Shahid Hussain wrote:

I want to khnow the Key codes

private void Form1_KeyDown(object sender, KeyEventArgs e)
{
   Keys key = e.KeyCode;
   Debug.WriteLine(String.Format("KEY: {0}", key));
}

dan neely wrote:

The two enter keys have the same value in that enumeration.

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

namespace GlobalKeyHook
{
  /// 
  /// KeyboardHook, as the name implies, hooks into the windows messaging system to
  /// catch global keystrokes.
  /// 
  /// 
  /// 	/// The hook is automatically released when the class is disposed.
  /// You can force the release by calling 
  /// 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
  /// e.Handled=true; will prevent other hooks from executing. For system keys
  /// as the Windows key, this means that the key gets 'blocked'
  /// 
  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;
    /// Gets/Sets the DisableHooking property.
    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");
    }

    /// 
    /// See the property  for info
    /// 
    public KeyboardHook(bool AddModifierData)
      : this()
    {
      this.AddModifierData = AddModifierData;
    }

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

    private bool disposed;
    /// 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
    public void Dispose()
    {
      if (!disposed)
      {
        UnhookWindowsHookEx(keybhook);
        GC.SuppressFinalize(this);
        disposed = true;
      }
    }

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

    /// This structure is filled when calling the KeyBoardCatcherDelegate.
    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;

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

    private const int
      wpKeyDown = 256,
      wpKeyUp = 257;

    /// If this value is true
    /// 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 false
    /// and check  instead
    /// 
    public bool AddModifierData = true;

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

    /// The method that's used to catch the keyboard input
    /// 
    /// 
    /// 
    /// 
    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);
    }
  }
}

Regards