Winify – Diff between revs 20 and 21

Subversion Repositories:

?pathlinks?

Rev 20 – Details – Blame – Last modification – View Log

+{
     public partial class Form1 : Form
+    {
         #region Private Delegates, Events, Enums, Properties, Indexers and Fields
-        private readonly Announcements.Announcements _notifications;
+        private readonly Announcements.Announcements _announcements;
             Settings.Default.SettingsSaving += Default_SettingsSaving;
             Settings.Default.PropertyChanged += Default_PropertyChanged;
             _servers = new global::Servers.Servers();
+            _servers.Server.CollectionChanged += Server_CollectionChanged;
-            _servers.Server.CollectionChanged += Server_CollectionChanged;
+            _servers.Server.ListChanged += Server_ListChanged;
-            _notifications = new Announcements.Announcements();
+            _announcements = new Announcements.Announcements();
+            _announcements.Announcement.CollectionChanged += Announcements_CollectionChanged;
-            _notifications.Announcement.CollectionChanged += Announcements_CollectionChanged;
+            _announcements.Announcement.ListChanged += Announcement_ListChanged;
+            {
                 var restoreAnnouncements = await task;
                 foreach (var announcement in restoreAnnouncements.Announcement)
                 {
-                    _notifications.Announcement.Add(announcement);
+                    _announcements.Announcement.Add(announcement);
+                }
             });
         protected override void Dispose(bool disposing)
+        {
             if (disposing && components != null)
+            {
                 _servers.Server.CollectionChanged -= Server_CollectionChanged;
-                _notifications.Announcement.CollectionChanged -= Announcements_CollectionChanged;
+                _announcements.Announcement.CollectionChanged -= Announcements_CollectionChanged;
                 Settings.Default.SettingsLoaded -= Default_SettingsLoaded;
                 Settings.Default.SettingsSaving -= Default_SettingsSaving;
         #endregion
+        #region Event Handlers
+        private async void Announcement_ListChanged(object sender, ListChangedEventArgs e)
+        {
+            await SaveAnnouncements();
+        }
+        private async void Server_ListChanged(object sender, ListChangedEventArgs e)
+        {
             await SaveServers();
         #region Event Handlers
-        private async void Announcements_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
-        {
-            switch (await ServersSerialization.Serialize(_notifications, Constants.NotificationsFile, "Announcements",
-                "<!ATTLIST Announcements xmlns:xsi CDATA #IMPLIED xsi:noNamespaceSchemaLocation CDATA #IMPLIED>"))
-            {
-                case SerializationFailure serializationFailure:
-                    Log.Warning(serializationFailure.Exception, "Unable to serialize announcements.");
+        private async void Announcements_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
                     break;
             await SaveAnnouncements();
         }
         private void GotifyConnectionManager_GotifyNotification(object sender, GotifyNotificationEventArgs e)
+        {
-            _notificationManager.ShowNotification(e, _notifications);
-        }
-        private async void Server_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
-        {
-            // Encrypt password for all servers.
-            var deviceId = Miscellaneous.GetMachineGuid();
-            var @protected = new global::Servers.Servers
-            {
-                Server = new BindingListWithCollectionChanged<Server>()
-            };
-            foreach (var server in _servers.Server)
-            {
-                var encrypted = AES.Encrypt(Encoding.UTF8.GetBytes(server.Password), deviceId);
-                var armored = Convert.ToBase64String(encrypted);
-                @protected.Server.Add(new Server(server.Name, server.Url, server.Username, armored));
-            }
-            switch (await ServersSerialization.Serialize(@protected, Constants.ServersFile, "Servers",
+            _notificationManager.ShowNotification(e, _announcements);
-                "<!ATTLIST Servers xmlns:xsi CDATA #IMPLIED xsi:noNamespaceSchemaLocation CDATA #IMPLIED>"))
+        }
                 case SerializationFailure serializationFailure:
-                    Log.Warning(serializationFailure.Exception, "Unable to serialize servers.");
+        private async void Server_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
                     break;
             if (_settingsForm != null)
+            {
                 return;
+            }
-            _settingsForm = new SettingsForm(_servers, _notifications);
+            _settingsForm = new SettingsForm(_servers, _announcements);
             _settingsForm.Closing += SettingsForm_Closing;
             _settingsForm.Show();
+        }
         #endregion
+        #region Private Methods
+        private async Task SaveAnnouncements()
+        {
+            switch (await ServersSerialization.Serialize(_announcements, Constants.NotificationsFile, "Announcements",
+                "<!ATTLIST Announcements xmlns:xsi CDATA #IMPLIED xsi:noNamespaceSchemaLocation CDATA #IMPLIED>"))
+            {
+                case SerializationFailure serializationFailure:
+                    Log.Warning(serializationFailure.Exception, "Unable to serialize announcements.");
+                    break;
+            }
+        }
+        private async Task SaveServers()
+        {
+            // Encrypt password for all servers.
+            var deviceId = Miscellaneous.GetMachineGuid();
+            var @protected = new global::Servers.Servers
+            {
+                Server = new BindingListWithCollectionChanged<Server>()
+            };
+            foreach (var server in _servers.Server)
+            {
+                var encrypted = AES.Encrypt(Encoding.UTF8.GetBytes(server.Password), deviceId);
+                var armored = Convert.ToBase64String(encrypted);
+                @protected.Server.Add(new Server(server.Name, server.Url, server.Username, armored));
+            }
+            switch (await ServersSerialization.Serialize(@protected, Constants.ServersFile, "Servers",
+                "<!ATTLIST Servers xmlns:xsi CDATA #IMPLIED xsi:noNamespaceSchemaLocation CDATA #IMPLIED>"))
+            {
+                case SerializationFailure serializationFailure:
+                    Log.Warning(serializationFailure.Exception, "Unable to serialize servers.");
+                    break;
+            }
         #region Private Methods
         private static async Task<Announcements.Announcements> LoadAnnouncements()
+        {
             switch (deserializationResult)
+            {
                 case SerializationSuccess<Announcements.Announcements> serializationSuccess:
+                    return serializationSuccess.Result;
+                case SerializationFailure serializationFailure:
+                    Log.Warning(serializationFailure.Exception, "Unable to load announcements.");
-                    return serializationSuccess.Result;
+                    return new Announcements.Announcements();
                 default:
                     return new Announcements.Announcements();
+            }
                         @protected.Server.Add(new Server(server.Name, server.Url, server.Username, decrypted));
+                    }
+                    return @protected;
+                case SerializationFailure serializationFailure:
+                    Log.Warning(serializationFailure.Exception, "Unable to load servers.");
-                    return @protected;
+                    return new global::Servers.Servers();
                 default:
                     return new global::Servers.Servers();