c#保存窗口位置大小 *** 作类（序列化和文件读写功能）

概述记录窗口上次关闭的位置和大小复制代码代码如下:namespacePDSafe.Base{   publicclassSetting   {       ///<summary>   &

记录窗口上次关闭的位置和大小
复制代码 代码如下:
namespace PDSafe.Base
{
    public class Setting
    {
        ///<summary>
        /// 把对象序列化为字节数组
        ///</summary>
        public static byte[] SerializeObject(object obj)
        {
            if (obj == null)
                return null;
            MemoryStream ms = new MemoryStream();
            BinaryFormatter formatter = new BinaryFormatter();
            formatter.Serialize(ms,obj);
            ms.position = 0;
            byte[] bytes = new byte[ms.Length];
            ms.Read(bytes,bytes.Length);
            ms.Close();
            return bytes;
        }

        ///<summary>
        /// 把字节数组反序列化成对象
        ///</summary>
        public static object DeserializeObject(byte[] bytes)
        {
            object obj = null;
            if (bytes == null)
                return obj;
            MemoryStream ms = new MemoryStream(bytes);
            ms.position = 0;
            BinaryFormatter formatter = new BinaryFormatter();
            try
            {
                obj = formatter.Deserialize(ms);
            }
            catch { obj = null; }
            ms.Close();
            return obj;
        }

        public static bool Save(string path,object value,bool isCeranew)
        {
            //如果不存在创建文件
            fileStream fs;
            if ((!file.Exists(path)) && isCeranew)
            {
                try
                {
                    fs = file.Create(path);
                }
                catch
                {
                    return false;
                }
            }
            //如果存在则打开
            else
            {
                try
                {
                    fs = file.Open(path,fileMode.Open,fileAccess.Write);
                }
                catch
                {
                    return false;
                }

            }
            //写文件
            byte[] buffer = SerializeObject(value);

            try
            {
                for (long i = 0; i < buffer.LongLength; i++)
                    fs.WriteByte(buffer[i]);
            }
            catch
            {
                return false;
            }
            fs.Close();
            return true;
        }

        public static object Read(string path)
        {
            fileStream fs;
            try
            {
                fs = file.OpenRead(path);
            }
            catch
            {
                return null;
            }

            //读入缓存
            StreamReader sreader = new StreamReader(fs);
            string str = sreader.ReadToEnd();
            fs.Close();
            sreader.Close();
            //分析内容
            byte[] buffer = EnCoding.Default.GetBytes(str);
            return DeserializeObject(buffer);
        }
        [Serializable]
        public struct FormSizeandLocation
        {
            public int SizeW;
            public int SizeH;
            public int LocationX;
            public int LocationY;
            public int Style;
        }
      private static  Setting.FormSizeandLocation fsp = new Setting.FormSizeandLocation();
        public static voID AddRenewFormSizeControl(Form form)
        {
            form.FormClosing += new FormClosingEventHandler(FormcloseEvent);
            form.Load += new EventHandler(FormloadEvent);
         }
        private static voID FormcloseEvent(object sender,EventArgs e)
        {
            Form form = (Form)sender;
            switch (form.windowstate)
            {
                case Formwindowstate.Maximized:
                    fsp.Style = 2;

                    fsp.SizeW = form.WIDth;
                    fsp.SizeH = form.Height;
                    fsp.LocationX = form.Location.X;
                    fsp.LocationY = form.Location.Y;
                    break;
                case Formwindowstate.Minimized:
                    fsp.Style = 1;
                    break;
                case Formwindowstate.normal:
                    fsp.Style = 0;

                    fsp.SizeW = form.WIDth;
                    fsp.SizeH = form.Height;
                    fsp.LocationX = form.Location.X;
                    fsp.LocationY = form.Location.Y;
                    break;
            }
            Setting.Save(Directory.GetCurrentDirectory() + @"\" + "Location.set",fsp,true);
        }
        private static voID FormloadEvent(object sender,EventArgs e)
        {
            Form form = (Form)sender;
            object result = Setting.Read(Directory.GetCurrentDirectory() + @"\" + "Location.set");
            if (result != null)
            {
                fsp = (Setting.FormSizeandLocation)result;
                switch (fsp.Style)
                {
                    case 2:
                        form.windowstate = Formwindowstate.Maximized;
                        break;
                    default:
                        form.windowstate = Formwindowstate.normal;
                        break;
                }
                form.left = fsp.LocationX;
                form.top = fsp.LocationY;
                form.Size = new Size(fsp.SizeW,fsp.SizeH);

            }
        }
    }
}

基本功能就是保存一个结构体类型的数据
bool Save（filePath,value,true）;
还有读取被保存数据的文件，从中读取，这个结构体被装箱，要做的只是拆箱
object result = Save（filePath，将要保存的数据实例，true）
if（result ！= null）//确认文件存在且读取成功

将这两个功能结合，能不能把窗口的位置和大小记录下来呢，当然可以，首先要做的事声明一个结构体，用来保存大小和位置还有状态
复制代码 代码如下:
 [Serializable]
        public struct FormSizeandLocation
        {
            public int SizeW;
            public int SizeH;
            public int LocationX;
            public int LocationY;
            public int Style;
        }

然后进行保存和设置，代码108-172行都是对于它的处理，How does it work?
让用户给出一个窗口实例
订阅实例的 Load和Closing事件
在load事件中把保存的文件读取，并更改实例的位置和大小
在closing事件中把大小和位置保存
AddRenewFormSizeControl（this）；
 //只需一句代码，一定要写在InitializeComponent函数后。不能写在load事件里

注意，保存的文件是 工作路径+Location.set 你也可以自己改写此类。

总结

以上是内存溢出为你收集整理的c#保存窗口位置大小 *** 作类（序列化和文件读写功能）全部内容，希望文章能够帮你解决c#保存窗口位置大小 *** 作类（序列化和文件读写功能）所遇到的程序开发问题。

如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。