Ignore:
Timestamp:
04/28/09 10:34:04 (6 years ago)
Author:
lowjoel
Message:

Ran Static code analysis on the Eraser project and implemented a few recommendations.

-Use more specific exceptions to allow code to determine the type of exception.
-Made GUIProgram implement IDisposable since the global mutex must be freed.
-Mde AboutForm? implement IDisposable, clearing the caching bitmaps on dispose.
-Made a few CommandLineProgram? functions static since they don't reference this.
-Name parameters/local with more unique, descriptive names for clarity.
-Use EventHandler?<EventArg?> instead of declaring our own delegate and event types as the type of the evenr handler

File:
1 edited

Legend:

Unmodified
Added
Removed
  • branches/eraser6/Eraser/UpdateForm.cs

    r864 r903  
    8787            { 
    8888                updates.OnProgressEvent += updateListDownloader_ProgressChanged; 
    89                 updates.GetUpdates(); 
     89                updates.DownloadUpdateList(); 
    9090            } 
    9191            finally 
     
    107107                    throw new OperationCanceledException(); 
    108108 
    109                 Invoke(new UpdateManager.ProgressEventFunction(updateListDownloader_ProgressChanged), 
    110                     sender, e); 
     109                Invoke(new EventHandler<UpdateManager.ProgressEventArgs>( 
     110                    updateListDownloader_ProgressChanged), sender, e); 
    111111                return; 
    112112            } 
     
    306306                    throw new OperationCanceledException(); 
    307307 
    308                 Invoke(new UpdateManager.ProgressEventFunction(downloader_ProgressChanged), 
     308                Invoke(new EventHandler<UpdateManager.ProgressEventArgs>(downloader_ProgressChanged), 
    309309                    sender, e); 
    310310                return; 
     
    312312 
    313313            UpdateData update = uiUpdates[(UpdateManager.Update)e.UserState]; 
    314             long amountLeft = (long)((1 - e.ProgressPercentage) * update.Update.FileSize); 
    315314 
    316315            if (e is UpdateManager.ProgressErrorEventArgs) 
     
    415414                    throw new OperationCanceledException(); 
    416415 
    417                 Invoke(new UpdateManager.ProgressEventFunction(installer_ProgressChanged), 
     416                Invoke(new EventHandler<UpdateManager.ProgressEventArgs>(installer_ProgressChanged), 
    418417                    sender, e); 
    419418                return; 
     
    480479                Update = update; 
    481480                LVItem = item; 
    482                 amountDownloaded = 0; 
    483                 Error = null; 
    484481            } 
    485482 
     
    527524        { 
    528525            public Mirror(string location, string link) 
     526                : this() 
    529527            { 
    530528                Location = location; 
     
    535533            /// The location where the mirror is at. 
    536534            /// </summary> 
    537             public string Location; 
     535            public string Location 
     536            { 
     537                get; 
     538                set; 
     539            } 
    538540 
    539541            /// <summary> 
    540542            /// The URL prefix to utilise the mirror. 
    541543            /// </summary> 
    542             public string Link; 
     544            public string Link 
     545            { 
     546                get; 
     547                set; 
     548            } 
    543549 
    544550            public override string ToString() 
     
    648654        /// Retrieves the update list from the server. 
    649655        /// </summary> 
    650         public void GetUpdates() 
     656        public void DownloadUpdateList() 
    651657        { 
    652658            WebRequest.DefaultCachePolicy = new HttpRequestCachePolicy( 
    653659                HttpRequestCacheLevel.Refresh); 
    654660            HttpWebRequest req = (HttpWebRequest) 
    655                 WebRequest.Create("http://eraser.heidi.ie/updates?action=listupdates&" + 
    656                     "version=" + Assembly.GetExecutingAssembly().GetName().Version.ToString()); 
     661                WebRequest.Create(new Uri("http://eraser.heidi.ie/updates?action=listupdates&" + 
     662                    "version=" + Assembly.GetExecutingAssembly().GetName().Version.ToString())); 
    657663             
    658664            using (WebResponse resp = req.GetResponse()) 
     
    781787        /// <param name="updates">The updates to retrieve and install.</param> 
    782788        /// <returns>An opaque object for use with InstallUpdates.</returns> 
    783         public object DownloadUpdates(List<Update> updates) 
     789        public object DownloadUpdates(ICollection<Update> downloadQueue) 
    784790        { 
    785791            //Create a folder to hold all our updates. 
     
    789795            int currUpdate = 0; 
    790796            Dictionary<string, Update> tempFilesMap = new Dictionary<string, Update>(); 
    791             foreach (Update update in updates) 
     797            foreach (Update update in downloadQueue) 
    792798            { 
    793799                try 
     
    800806                        reqUri = new Uri(update.Link); 
    801807                    else 
    802                         reqUri = new Uri(new Uri(SelectedMirror.Link), update.Link); 
     808                        reqUri = new Uri(new Uri(SelectedMirror.Link), new Uri(update.Link)); 
    803809                     
    804810                    //Then grab the download. 
     
    823829                                //Compute progress 
    824830                                float itemProgress = tempStrm.Position / (float)resp.ContentLength; 
    825                                 float overallProgress = (currUpdate - 1 + itemProgress) / updates.Count; 
     831                                float overallProgress = (currUpdate - 1 + itemProgress) / downloadQueue.Count; 
    826832                                OnProgress(new ProgressEventArgs(itemProgress, overallProgress, 
    827833                                    update, S._("Downloading: {0}", update.Name))); 
     
    833839 
    834840                        //Let the event handler know the download is complete. 
    835                         OnProgress(new ProgressEventArgs(1.0f, (float)currUpdate / updates.Count, 
     841                        OnProgress(new ProgressEventArgs(1.0f, (float)currUpdate / downloadQueue.Count, 
    836842                            update, S._("Downloaded: {0}", update.Name))); 
    837843                    } 
     
    840846                { 
    841847                    OnProgress(new ProgressErrorEventArgs(new ProgressEventArgs(1.0f, 
    842                         (float)currUpdate / updates.Count, update, 
     848                        (float)currUpdate / downloadQueue.Count, update, 
    843849                            S._("Error downloading {0}: {1}", update.Name, e.Message)), 
    844850                        e)); 
     
    849855        } 
    850856 
    851         public void InstallUpdates(object downloadObject) 
    852         { 
    853             Dictionary<string, Update> tempFiles = (Dictionary<string, Update>)downloadObject; 
     857        public void InstallUpdates(object value) 
     858        { 
     859            Dictionary<string, Update> tempFiles = (Dictionary<string, Update>)value; 
    854860            Dictionary<string, Update>.KeyCollection files = tempFiles.Keys; 
    855861            int currItem = 0; 
     
    876882                        OnProgress(new ProgressErrorEventArgs(new ProgressEventArgs(1.0f, 
    877883                            progress, item, S._("Error installing {0}", item.Name)), 
    878                             new Exception(S._("The installer exited with an error code {0}", 
     884                            new ApplicationException(S._("The installer exited with an error code {0}", 
    879885                                process.ExitCode)))); 
    880886                } 
     
    898904 
    899905        /// <summary> 
    900         /// Prototype of the callback functions from this object. 
    901         /// </summary> 
    902         /// <param name="sender">The source of the event.</param> 
    903         /// <param name="arg">The ProgressEventArgs object holding information 
    904         /// about the progress of the current operation.</param> 
    905         public delegate void ProgressEventFunction(object sender, ProgressEventArgs arg); 
    906  
    907         /// <summary> 
    908906        /// Called when the progress of the operation changes. 
    909907        /// </summary> 
    910         public ProgressEventFunction OnProgressEvent; 
     908        public EventHandler<ProgressEventArgs> OnProgressEvent 
     909        { 
     910            get { return onProgressEvent; } 
     911            set { onProgressEvent = value; } 
     912        } 
     913        private EventHandler<ProgressEventArgs> onProgressEvent; 
    911914 
    912915        /// <summary> 
     
    956959                    } 
    957960 
    958                 throw new IndexOutOfRangeException(); 
     961                throw new ArgumentException(S._("Unknown mirror selected.")); 
    959962            } 
    960963        } 
     
    987990        /// <param name="key">The category to retrieve.</param> 
    988991        /// <returns>All updates in the given category.</returns> 
    989         public List<Update> this[string key] 
     992        public ICollection<Update> this[string key] 
    990993        { 
    991994            get 
Note: See TracChangeset for help on using the changeset viewer.