Sauvegarder et de Restaurer la Forme de la Position et de la Taille

private void Form1_Load( object sender, EventArgs e )
{
    //restore location and size of the form on the desktop
    this.DesktopBounds =
        new Rectangle(Properties.Settings.Default.Location,
    Properties.Settings.Default.Size);
    //restore form's window state
    this.WindowState = ( FormWindowState )Enum.Parse(
        typeof(FormWindowState),
        Properties.Settings.Default.WindowState);
}

private void Form1_FormClosing( object sender, FormClosingEventArgs e )
{
    System.Drawing.Rectangle bounds = this.WindowState != FormWindowState.Normal ? this.RestoreBounds : this.DesktopBounds;
    Properties.Settings.Default.Location = bounds.Location;
    Properties.Settings.Default.Size = bounds.Size;
    Properties.Settings.Default.WindowState =
        Enum.GetName(typeof(FormWindowState), this.WindowState);
    //persist location ,size and window state of the form on the desktop
    Properties.Settings.Default.Save();
}

Il y a effectivement un manque réel d'un seul, "fonctionne" solution à ce n'importe où sur l'internet, alors voici ma création:

using System;
using System.Collections.Generic;
using System.Text;
using System.Drawing;
using System.Windows.Forms;
using Microsoft.Win32;
using System.ComponentModel;
using System.Security.Cryptography;
namespace nedprod
{
abstract public class WindowSettings
{
private Form form;
public FormWindowState state;
public Point location;
public Size size;
public WindowSettings(Form _form)
{
this.form = _form;
}
internal class MD5Sum
{
static MD5CryptoServiceProvider engine = new MD5CryptoServiceProvider();
private byte[] sum = engine.ComputeHash(BitConverter.GetBytes(0));
public MD5Sum() { }
public MD5Sum(string s)
{
for (var i = 0; i < sum.Length; i++)
sum[i] = byte.Parse(s.Substring(i * 2, 2), System.Globalization.NumberStyles.HexNumber);
}
public void Add(byte[] data)
{
byte[] temp = new byte[sum.Length + data.Length];
var i=0;
for (; i < sum.Length; i++)
temp[i] = sum[i];
for (; i < temp.Length; i++)
temp[i] = data[i - sum.Length];
sum=engine.ComputeHash(temp);
}
public void Add(int data)
{
Add(BitConverter.GetBytes(data));
}
public void Add(string data)
{
Add(Encoding.UTF8.GetBytes(data));
}
public static bool operator ==(MD5Sum a, MD5Sum b)
{
if (a.sum == b.sum) return true;
if (a.sum.Length != b.sum.Length) return false;
for (var i = 0; i < a.sum.Length; i++)
if (a.sum[i] != b.sum[i]) return false;
return true;
}
public static bool operator !=(MD5Sum a, MD5Sum b)
{
return !(a == b);
}
public override bool Equals(object obj)
{
try
{
return (bool)(this == (MD5Sum)obj);
}
catch
{
return false;
}
}
public override int GetHashCode()
{
return ToString().GetHashCode();
}
public override string ToString()
{
StringBuilder sb = new StringBuilder();
for (var i = 0; i < sum.Length; i++)
sb.Append(sum[i].ToString("x2"));
return sb.ToString();
}
}
private MD5Sum screenconfig()
{
MD5Sum md5=new MD5Sum();
md5.Add(Screen.AllScreens.Length); //Hash the number of screens
for(var i=0; i<Screen.AllScreens.Length; i++)
{
md5.Add(Screen.AllScreens[i].Bounds.ToString()); //Hash the dimensions of this screen
}
return md5;
}
public void load()
{
using (RegistryKey r = Registry.CurrentUser.OpenSubKey(@"Software\" + CompanyId() + @"\" + AppId() + @"\Window State\" + form.Name))
{
if (r != null)
{
try
{
string _location = (string)r.GetValue("location"), _size = (string)r.GetValue("size");
state = (FormWindowState)r.GetValue("state");
location = (Point)TypeDescriptor.GetConverter(typeof(Point)).ConvertFromInvariantString(_location);
size = (Size)TypeDescriptor.GetConverter(typeof(Size)).ConvertFromInvariantString(_size);
//Don't do anything if the screen config has since changed (otherwise windows vanish off the side)
if (screenconfig() == new MD5Sum((string) r.GetValue("screenconfig")))
{
form.Location = location;
form.Size = size;
//Don't restore if miminised (it's unhelpful as the user misses the fact it's opened)
if (state != FormWindowState.Minimized)
form.WindowState = state;
}
}
catch (Exception)
{
}
}
}
}
public void save()
{
state = form.WindowState;
if (form.WindowState == FormWindowState.Normal)
{
size = form.Size;
location = form.Location;
}
else
{
size = form.RestoreBounds.Size;
location = form.RestoreBounds.Location;
}
using (RegistryKey r = Registry.CurrentUser.CreateSubKey(@"Software\" + CompanyId()+@"\"+AppId() + @"\Window State\" + form.Name, RegistryKeyPermissionCheck.ReadWriteSubTree))
{
r.SetValue("state", (int) state, RegistryValueKind.DWord);
r.SetValue("location", location.X.ToString() + "," + location.Y.ToString(), RegistryValueKind.String);
r.SetValue("size", size.Width.ToString()+","+size.Height.ToString(), RegistryValueKind.String);
r.SetValue("screenconfig", screenconfig().ToString(), RegistryValueKind.String);
}
}
abstract protected string CompanyId();
abstract protected string AppId();
}
}

Cette application stocke la position et la taille d'un formulaire dans HKCU/Software/<CompanyId()>/<AppId()>/État de la Fenêtre de/<form name>. Il ne sera pas restaurer les paramètres si le moniteur changements de configuration, comme pour empêcher les fenêtres d'être restauré hors de l'écran.

Évidemment, cela ne peut pas gérer plusieurs instances de la même forme. J'ai aussi spécifiquement désactivé la restauration minimisé, mais c'est une solution facile de la source.

Ci-dessus est conçu pour être tombé dans son propre .cs fichier et n'a jamais touché à nouveau. Vous devez instancier un espace de noms local de la copie comme ceci (dans le Programme.cs ou votre plugin principal .cs fichier ou où):

namespace <your app/plugin namespace name>
{
public class WindowSettings : nedprod.WindowSettings
{
public WindowSettings(Form form) : base(form) { }
protected override string CompanyId() { return "<your company name>"; }
protected override string AppId() { return "<your app name>"; }
}
....

Vous avez maintenant un non-résumé de l'instanciation de l'espace principal. Donc, pour l'utiliser, ajoutez à cela les formes que vous souhaitez sauvé et restauré:

    private void IssuesForm_FormClosing(object sender, FormClosingEventArgs e)
{
new WindowSettings(this).save();
}
private void IssuesForm_Load(object sender, EventArgs e)
{
new WindowSettings(this).load();
}

Évidemment hésitez pas à personnaliser à vos propres fins. Aucune garantie n'est exprimée ou implicite. Utilisez à vos risques et périls - je déclinons toute le droit d'auteur.

Niall

Je suis dans le même bateau que vous, en qui j'ai un certain nombre de formes (MDI enfants, dans mon cas) que je tiens à préserver la position et la taille de chaque utilisateur. D'après mes recherches, la création de paramètres de l'application lors de l'exécution n'est pas pris en charge. (voir cette entrée de blog)
Cependant, vous n'avez pas à coller le tout dans le principal fichier de paramètres. Vous pouvez ajouter un fichier de Settings de votre projet (expliqué ici dans le MSDN) et l'utiliser via les Propriétés.Les paramètres de l'objet. Ce ne sera pas soulager la douleur d'avoir à se souvenir de créer de nouveaux paramètres globaux pour chaque forme, mais au moins cela permettra de les garder, et ne pas encombrer vos principaux paramètres de l'application.

Aussi loin que l'utilisation de la classe de base pour récupérer les paramètres... je ne sais pas si vous pouvez le faire là. Ce que je voudrais (et probablement) n'est le nom de chaque attribut , puis utilisez Moi.GetType().ToString() (je travaille en VB) pour composer les noms des attributs, je veux récupérer dans le Load() de chaque forme.

Voici le code que j'ai utilisé.

private void SaveWindowPosition()
{
Rectangle rect = (WindowState == FormWindowState.Normal) ?
new Rectangle(DesktopBounds.Left, DesktopBounds.Top, DesktopBounds.Width, DesktopBounds.Height) :
new Rectangle(RestoreBounds.Left, RestoreBounds.Top, RestoreBounds.Width, RestoreBounds.Height);
RegistrySettings.SetSetting("WindowPosition", String.Format("{0},{1},{2},{3},{4}",
(int)this.WindowState,
rect.Left, rect.Top, rect.Width, rect.Height));
}
private void RestoreWindowPosition()
{
try
{
string s = RegistrySettings.GetSetting("WindowPosition", String.Empty) as string;
if (s != null)
{
List<int> settings = s.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries)
.Select(v => int.Parse(v)).ToList();
if (settings.Count == 5)
{
this.SetBounds(
settings[1],
settings[2],
settings[3],
settings[4]);
this.WindowState = (FormWindowState)settings[0];
}
}
}
catch { /* Just leave current position if error */ }
}

J'ai aussi présenté ce code dans mon article La sauvegarde et la Restauration d'un Formulaire Position de la Fenêtre.