C# Settings.Save方法代码示例

        internal WindowManipulationService(
            Window window,
            Func<double> getWindowTopSetting,
            Action<double> setWindowTopSetting,
            Func<double> getWindowLeftSetting,
            Action<double> setWindowLeftSetting,
            Func<double> getWindowHeightSetting,
            Action<double> setWindowHeightSetting,
            Func<double> getWindowWidthSetting,
            Action<double> setWindowWidthSetting,
            Func<WindowState> getWindowStateSetting,
            Action<WindowState> setWindowStateSetting,
            Settings settings,
            bool loadSavedState = false,
            bool saveStateOnClose = false)
        {
            this.window = window;
            this.getWindowTopSetting = getWindowTopSetting;
            this.getWindowLeftSetting = getWindowLeftSetting;
            this.getWindowHeightSetting = getWindowHeightSetting;
            this.getWindowWidthSetting = getWindowWidthSetting;
            this.getWindowStateSetting = getWindowStateSetting;

            if(loadSavedState)
            {
                LoadState();
            }

            window.Closing += (sender, args) =>
            {
                if (saveStateOnClose)
                {
                    //Check window is not in minimised state (either as a ssmall icon on the screen, or the window is actually minimised)
                    if (!windowIsMinimised
                        && window.WindowState != WindowState.Minimized
                        && window.WindowState != WindowState.Maximized)
                    {
                        setWindowTopSetting(window.Top);
                        setWindowLeftSetting(window.Left);
                        setWindowHeightSetting(window.Height);
                        setWindowWidthSetting(window.Width);
                        setWindowStateSetting(window.WindowState);

                        settings.Save();
                    }
                }

                if (otherWindowsShouldBeMaximisedOnExit)
                {
                    //Maximise all windows if they were arranged at some point
                    var thisHwnd = new WindowInteropHelper(window).Handle;
                    var otherWindows = Windows.GetVisibleOverlappedWindows(thisHwnd);
                    foreach (var otherWindow in otherWindows)
                    {
                        Log.DebugFormat("Maximising window '{0}' before we exit", otherWindow.Item1);
                        PInvoke.ShowWindow(otherWindow.Item2, (int)WindowShowStyle.Maximize);
                    }
                }
            };
        }

		public Settings LoadSettings(string path = "")
		{
			if (Settings == null || Path != path)
			{
				if (path == "")
				{
					Path = Settings1.Default.FileLocation;
				}
				else Path = path;
				if (File.Exists(Path))
				{
					using (var fileStream = File.Open(Path, FileMode.Open))
					{
						Settings = Settings.Load(fileStream, SerializationMode.Xml);
						Debug.WriteLine("Settings loaded");
						if (Settings.CurrentSkin == null)
							Settings.CurrentSkin = Skin.Null;
						else
							Settings.CurrentSkin = Skin.GetSkin(Settings.CurrentSkin.Name);
						return Settings;
					}
				}
				else
				{
					Settings = new Settings();
					Settings.Save(Path, SerializationMode.Xml);
					return Settings;

				}
			}
			else return Settings;
		}

        public MainForm( SteamContext context )
        {
            try
            {
                sets = Settings.Load( "settings.xml" );

                if ( sets == null )
                {
                    sets = new Settings();
                    sets.Save( "settings.xml" );
                }
            }
            catch ( Exception ex )
            {
                MessageBox.Show( "Unable to load settings!\n\n" + ex.ToString() );
				sets = new Settings();
            }

            InitializeComponent();

            foreach ( string str in sets.NameChanger )
            {
                txtNameChanger.Text += str + "\r\n";
            }

            chkNoEscape.Checked = sets.NoEscape;
            awayMessageBox.Text = sets.NoEscapeString;

            nameEntries = new List<NameEntry>();

            this.context = context;

            friendsList.SteamContext = context;

            txtPersonaName.Text = context.SteamFriends.GetPersonaName();

            for ( int x = -2 ; x < ( int )( EPersonaState.k_EPersonaStateMax + 2 ) ; x++ )
                cmbState.Items.Add( ( EPersonaState )x );

            cmbState.SelectedIndex = ( int )( context.SteamFriends.GetPersonaState() + 2 );

            for ( int i = 0 ; i < context.SteamFriends.GetFriendCount( ( int )EFriendFlags.k_EFriendFlagImmediate ) ; ++i )
            {
                Friend friend = new Friend();

                CSteamID steamId = context.SteamFriends.GetFriendByIndex( i, ( int )EFriendFlags.k_EFriendFlagImmediate );
                string friendName = context.SteamFriends.GetFriendPersonaName( steamId );

                friend.SteamID = steamId;
                friend.PersonaName = friendName;

                friendsList.Items.Add( friend );
            }

            friendsList.Sorted = true;
        }

        private static void Main()
        {
            Settings = Settings.Load<Settings>(SettingsFilename);

            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.Run(new MainForm());

            Settings.Save(SettingsFilename);
        }

        public void TestClosureCompilerAdvancedOnlineJsEngine()
        {
            Settings settings = new Settings();
            settings.GoogleClosureOffline = false;
            settings.Save();

            string code = "function hello(name) {alert('Hello, ' + name);}hello('New user');";
            //create file for googleClosureCompilerOffline
            string TempFilePath = System.Environment.CurrentDirectory + "\\test.js";
            System.IO.File.WriteAllText(TempFilePath, code);

            code = Zippy.Chirp.Engines.ClosureCompilerEngine.Minify(TempFilePath, code, GetProjectItem(TempFilePath), ClosureCompilerCompressMode.ADVANCED_OPTIMIZATIONS, string.Empty);
            Assert.IsTrue(code == "alert(\"Hello, New user\");\r\n" || code == "alert(\"Hello, New user\");");
        }

        public void TestClosureCompilerAdvancedOnlineDetectFileName()
        {
            Settings settings = new Settings();
            settings.GoogleClosureOffline = false;
            settings.ChirpJsFile = ".chirp.js";
            settings.Save();

            string code = "function hello(name) {alert('Hello, ' + name);}hello('New user');";
            //create file for googleClosureCompilerOffline
            string TempFilePath = System.Environment.CurrentDirectory + "\\test.chirp.js";
            System.IO.File.WriteAllText(TempFilePath, code);

            ClosureCompilerEngine closureCompilerEngine = new ClosureCompilerEngine();
            code = closureCompilerEngine.Transform(TempFilePath, code, GetProjectItem(TempFilePath));
            Assert.IsTrue(code == "alert(\"Hello, New user\");\r\n" || code == "alert(\"Hello, New user\");");
        }

 protected void btnUpdate_Click(object sender, EventArgs e)
 {
     lbError.Visible = false;
     Settings s = new Settings();
     s.Where.SettingID.Value = 1;
     if (s.Query.Load())
     {
         if (s.s_Password != Encrypt.EncryptRijndael(tbOldPassword.Text))
         {
             lbError.Visible = true;
             return;
         }
         s.Password = Encrypt.EncryptRijndael(text_Password.Text);
         s.Save();
     }
     btnCancel_Click(sender, e);
 }

        public void TestJsHintEngine()
        {
            Settings settings = new Settings();
            settings.JsHintOptions.bitwise = true;
            settings.JsHintOptions.boss = true;
            settings.JsHintOptions.curly = true;
            settings.JsHintOptions.debug = true;
            settings.JsHintOptions.devel = true;
            settings.JsHintOptions.eqeqeq = true;
            settings.JsHintOptions.evil = true;
            settings.JsHintOptions.forin = true;
            settings.JsHintOptions.immed = true;
            settings.JsHintOptions.laxbreak = true;
            settings.JsHintOptions.maxerr = 25;
            settings.JsHintOptions.newcap = true;
            settings.JsHintOptions.noarg = true;
            settings.JsHintOptions.noempty = true;
            settings.JsHintOptions.nomen = true;
            settings.JsHintOptions.nonew = true;
            settings.JsHintOptions.onevar = true;
            settings.JsHintOptions.passfail = true;
            settings.JsHintOptions.plusplus = true;
            settings.JsHintOptions.regexp = true;
            settings.JsHintOptions.strict = true;
            settings.JsHintOptions.sub = true;
            settings.JsHintOptions.undef = true;
            settings.JsHintOptions.white = true;
            settings.Save();

            string code = "if(test) {\r\n\t eval('test'); }";
            var filename = System.IO.Path.GetTempFileName();
            try
            {
                System.IO.File.WriteAllText(filename, code);
                using (var jshint = new Zippy.Chirp.Engines.JSHintEngine())
                {
                    jshint.Run(filename, GetProjectItem(filename));
                    Assert.AreNotEqual(0, TaskList.Instance.Errors.Count());
                }
            }
            finally
            {
                System.IO.File.Delete(filename);
            }
        }

        public ActionResult OnEdit(int txtFirstTimeLimit, int txtSecondTimeLimit, int txtThirdTimeLimit)
        {
            Settings settings = new Settings();
            settings.FirstTimeLimit = txtFirstTimeLimit;
            settings.SecondTimeLimit = txtSecondTimeLimit;
            settings.ThirdTimeLimit = txtThirdTimeLimit;

            try
            {
                settings.Save(CurrentUserId, null);
            }
            catch (Exception ex)
            {
                string message = ex.Message;
            }

            //return View();
            return Redirect(Url.Action("Index"));
        }

		public void TestConnectDisconnect()
		{
			var settings = new Settings {Uri = new Uri("http://localhost"), Login = "admin", DecryptedPassword = "admin",};
			settings.Save();
			var env = new DummyControllerEnvironment();
			Controller ctl;
			using (ctl = new Controller(new DummyTimeTrackingRepository(), new DummyWebServicesFactory(), env))
			{
				Assert.IsFalse(ctl.Connected);
				env.DialogResult = DialogResult.OK;
				ctl.Connect(true);
				Assert.IsTrue(ctl.Connected);
				ctl.Disconnect();
				Assert.IsFalse(ctl.Connected);
				env.DialogResult = DialogResult.Cancel;
				ctl.Connect(true);
				Assert.IsFalse(ctl.Connected);
				env.DialogResult = DialogResult.OK;
				ctl.Connect(true);
				Assert.IsTrue(ctl.Connected);
			}
			Assert.IsFalse(ctl.Connected);
		}

            public void SetsProperties()
            {
                var settings = new Settings();

                // Get From File Test
                Assert.Equal(true, settings.GetSetting<bool>("TrueSetting", false));

                // Default Setting Test
                Assert.Equal("default", settings.GetSetting("asdf", "default", true));

                // Check Create method
                Assert.Equal("default", settings.GetSetting("asdf", String.Empty));

                // Set Setting Test
                settings.SetSetting("mySetting", "False");
                Assert.Equal("False", settings.GetSetting("mySetting", String.Empty));

                // Remove Setting
                string fileValue = settings.GetSetting("ToBeRemovedSetting", "xmlvalue");
                settings.RemoveSetting("ToBeRemovedSetting");
                Assert.NotEqual(fileValue, settings.GetSetting("ToBeRemovedSetting", "notthexml"));
                settings.Save();
            }

        public static void UpdateDatHash()
        {
            Settings settings = new Settings();
            settings.Load();

            // Hash 01.dat and update settings file
            string datHash = Tools.GetMd5Hash(ModManager.ZeroPath);
            settings.GameData.DatHash = datHash;

            settings.Save();
        }

 public static void SetGameData(GameData NewGameData)
 {
     Settings settings = new Settings();
     settings.Load();
     settings.GameData = NewGameData;
     settings.Save();
 }

 public static void RemoveMod(ModEntry Mod)
 {
     Settings settings = new Settings();
     settings.Load();
     ModEntry remMod = settings.ModEntries.Find(entry => entry.Name == Mod.Name);
     settings.ModEntries.Remove(remMod);
     settings.Save();
 }

 public static void ClearAllMods()
 {
     Settings settings = new Settings();
     settings.Load();
     settings.ModEntries = new List<ModEntry>();
     settings.Save();
 }