Changeset 903


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

Location:
branches/eraser6/Eraser
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • branches/eraser6/Eraser/AboutForm.Designer.cs

    r856 r903  
    3939                components.Dispose(); 
    4040            } 
     41 
     42            ParentBitmap.Dispose(); 
     43            AboutBitmap.Dispose(); 
     44            AboutTextBitmap.Dispose(); 
     45            DoubleBufferBitmap.Dispose(); 
    4146            base.Dispose(disposing); 
    4247        } 
  • branches/eraser6/Eraser/AboutForm.cs

    r856 r903  
    129129                string disclaimerText = S._("Eraser is free open-source software!"); 
    130130                PointF disclaimerPos = new PointF(websitePos.X, websitePos.Y + websiteSize.Height * 1.5f); 
    131                 SizeF disclaimerSize = g.MeasureString(disclaimerText, Font); 
    132131                g.DrawString(disclaimerText, Font, textBrush, disclaimerPos); 
    133132 
     
    175174            } 
    176175 
    177             ParentOpacity = 0; 
    178176            AboutTextScrollTop = AboutTextRect.Height / 2; 
    179177            animationTimer_Tick(null, null); 
     
    215213                ParentOpacity += 8; 
    216214            if (AboutTextBitmap.Height < -AboutTextScrollTop) 
    217             { 
    218215                AboutTextScrollTop = AboutTextRect.Height; 
    219                 GC.Collect(); 
    220             } 
    221216            else 
    222217                AboutTextScrollTop -= 1; 
  • branches/eraser6/Eraser/LogForm.cs

    r900 r903  
    109109        { 
    110110            StringBuilder text = new StringBuilder(); 
    111             Dictionary<DateTime, List<LogEntry>> log = task.Log.Entries; 
    112             Dictionary<DateTime, List<LogEntry>>.Enumerator iter = log.GetEnumerator(); 
    113             foreach (DateTime sessionTime in log.Keys) 
     111            Dictionary<DateTime, List<LogEntry>> logEntries = task.Log.Entries; 
     112            foreach (DateTime sessionTime in logEntries.Keys) 
    114113            { 
    115114                text.AppendLine(S._("Session: {0}", sessionTime.ToString(DATEPATTERN))); 
    116                 foreach (LogEntry entry in log[sessionTime]) 
     115                foreach (LogEntry entry in logEntries[sessionTime]) 
    117116                { 
    118117                    text.AppendFormat("{0}  {1} {2}\n", 
  • branches/eraser6/Eraser/Program.cs

    r858 r903  
    3737using Eraser.Util; 
    3838using Microsoft.Win32; 
     39using System.Runtime.Serialization; 
    3940 
    4041namespace Eraser 
     
    127128        { 
    128129            //Create the program instance 
    129             GUIProgram program = new GUIProgram(commandLine, "Eraser-BAD0DAC6-C9EE-4acc-" + 
     130            using (GUIProgram program = new GUIProgram(commandLine, "Eraser-BAD0DAC6-C9EE-4acc-" + 
    130131                "8701-C9B3C64BC65E-GUI-" + 
    131                 System.Security.Principal.WindowsIdentity.GetCurrent().User.ToString()); 
     132                System.Security.Principal.WindowsIdentity.GetCurrent().User.ToString())) 
    132133 
    133134            //Then run the program instance. 
     
    155156            System.Threading.Thread.CurrentThread.CurrentUICulture = 
    156157                new CultureInfo(settings.Language); 
    157             program.SafeTopLevelCaptionFormat = S._("Eraser"); 
     158            GUIProgram.SafeTopLevelCaptionFormat = S._("Eraser"); 
    158159 
    159160            //Load the task list 
     
    164165                        eraserClient.LoadTaskList(stream); 
    165166                    } 
    166                     catch (Exception) 
     167                    catch (SerializationException e) 
    167168                    { 
    168169                        settings.TaskList = null; 
    169170                        MessageBox.Show(S._("Could not load task list. All task entries have " + 
    170                             "been lost."), S._("Eraser"), MessageBoxButtons.OK, 
    171                             MessageBoxIcon.Error); 
     171                            "been lost. The error returned was: {0}", e.Message), S._("Eraser"), 
     172                            MessageBoxButtons.OK, MessageBoxIcon.Error); 
    172173                    } 
    173174 
     
    242243    } 
    243244 
    244     class GUIProgram 
     245    class GUIProgram : IDisposable 
    245246    { 
    246247        /// <summary> 
     
    260261            //Check if there already is another instance of the program. 
    261262            globalMutex = new Mutex(true, instanceID, out isFirstInstance); 
     263        } 
     264 
     265        public void Dispose() 
     266        { 
     267            globalMutex.Close(); 
     268            GC.SuppressFinalize(this); 
    262269        } 
    263270 
     
    278285            //If no other instances are running, set up our pipe server so clients 
    279286            //can connect and give us subsequent command lines. 
    280             if (isFirstInstance) 
     287            if (IsAlreadyRunning) 
    281288            { 
    282289                try 
     
    324331                    int count = Encoding.UTF8.GetBytes(commandLineStr.ToString(), 0, 
    325332                        commandLineStr.Length, buffer, 0); 
    326                     client.Write(buffer, 0, buffer.Length); 
     333                    client.Write(buffer, 0, count); 
    327334                } 
    328335                catch (UnauthorizedAccessException) 
     
    422429        /// they are displayed with a warning banner. 
    423430        /// </summary> 
    424         public string SafeTopLevelCaptionFormat 
     431        public static string SafeTopLevelCaptionFormat 
    425432        { 
    426433            get 
     
    657664                        if (parameter[1] == '-') 
    658665                            return parameter.Substring(2) == expectedParameter; 
    659                         else if (shortParameter == null || shortParameter == string.Empty) 
     666                        else if (string.IsNullOrEmpty(shortParameter)) 
    660667                            return parameter.Substring(1) == expectedParameter; 
    661668                        else 
     
    666673                        parameter = parameter.Substring(1); 
    667674                        return parameter == expectedParameter || ( 
    668                             shortParameter != null && shortParameter != string.Empty && 
    669                             parameter == shortParameter 
     675                            !string.IsNullOrEmpty(shortParameter) && parameter == shortParameter 
    670676                        ); 
    671677 
     
    767773                    List<KeyValuePair<string, string>> subParams = 
    768774                        GetSubParameters(param.Substring(equalPos + 1)); 
    769                     ErasureMethod = new Guid(subParams[0].Key); 
     775                    erasureMethod = new Guid(subParams[0].Key); 
    770776                } 
    771777                else if (IsParam(param, "schedule", "s")) 
     
    780786                    { 
    781787                        case "now": 
    782                             Schedule = Schedule.RunNow; 
     788                            schedule = Schedule.RunNow; 
    783789                            break; 
    784790                        case "restart": 
     
    872878                    return erasureMethod; 
    873879                } 
    874                 private set 
    875                 { 
    876                     erasureMethod = value; 
    877                 } 
    878880            } 
    879881 
     
    887889                    return schedule; 
    888890                } 
    889                 set 
    890                 { 
    891                     schedule = value; 
    892                 } 
    893891            } 
    894892 
     
    901899                { 
    902900                    return new List<Task.ErasureTarget>(targets.ToArray()); 
    903                 } 
    904                 set 
    905                 { 
    906                     targets = value; 
    907901                } 
    908902            } 
     
    967961        /// defaults. 
    968962        /// </summary> 
    969         private void CreateConsole() 
     963        private static void CreateConsole() 
    970964        { 
    971965            if (KernelAPI.AllocConsole()) 
     
    10881082        private void AddTask() 
    10891083        { 
    1090             AddTaskCommandLine arguments = (AddTaskCommandLine)Arguments; 
     1084            AddTaskCommandLine taskArgs = (AddTaskCommandLine)Arguments; 
    10911085             
    10921086            //Create the task, and set the method to use. 
    10931087            Task task = new Task(); 
    1094             ErasureMethod method = arguments.ErasureMethod == Guid.Empty ?  
     1088            ErasureMethod method = taskArgs.ErasureMethod == Guid.Empty ?  
    10951089                ErasureMethodManager.Default : 
    1096                 ErasureMethodManager.GetInstance(arguments.ErasureMethod); 
    1097             foreach (Task.ErasureTarget target in arguments.Targets) 
     1090                ErasureMethodManager.GetInstance(taskArgs.ErasureMethod); 
     1091            foreach (Task.ErasureTarget target in taskArgs.Targets) 
    10981092            { 
    10991093                target.Method = method; 
     
    11061100 
    11071101            //Set the schedule for the task. 
    1108             task.Schedule = arguments.Schedule; 
     1102            task.Schedule = taskArgs.Schedule; 
    11091103 
    11101104            //Send the task out. 
     
    11221116 
    11231117                        if (!((RemoteExecutorClient)Program.eraserClient).Connect()) 
    1124                             throw new Exception("Eraser cannot connect to the running " + 
     1118                            throw new IOException("Eraser cannot connect to the running " + 
    11251119                                "instance for erasures."); 
    11261120                    } 
     
    11711165            /// </summary> 
    11721166            /// <param name="key">The registry key to look for the settings in.</param> 
    1173             public RegistrySettings(Guid pluginID, RegistryKey key) 
     1167            public RegistrySettings(Guid guid, RegistryKey key) 
    11741168            { 
    11751169                this.key = key; 
     
    11871181                                return new BinaryFormatter().Deserialize(stream); 
    11881182                            } 
    1189                             catch (Exception) 
     1183                            catch (SerializationException) 
    11901184                            { 
    11911185                                key.DeleteValue(setting); 
  • branches/eraser6/Eraser/TaskDataSelectionForm.cs

    r865 r903  
    176176                } 
    177177                else 
    178                     throw new Exception("Unknown erasure target."); 
     178                    throw new ArgumentException("Unknown erasure target."); 
    179179            } 
    180180        } 
  • branches/eraser6/Eraser/TaskPropertiesForm.cs

    r493 r903  
    119119                } 
    120120                else 
    121                     throw new Exception("No such scheduling method."); 
     121                    throw new ArgumentException("No such scheduling method."); 
    122122            } 
    123123        } 
     
    187187                        break; 
    188188                    default: 
    189                         throw new Exception("Unknown schedule type."); 
     189                        throw new ArgumentException("Unknown schedule type."); 
    190190                } 
    191191            } 
  • branches/eraser6/Eraser/ToolBar.cs

    r492 r903  
    2828using System.Windows.Forms; 
    2929using System.Runtime.InteropServices; 
     30using System.Collections.ObjectModel; 
    3031 
    3132namespace Eraser 
     
    8182        /// </summary> 
    8283        /// <param name="dc">Graphics object to draw on.</param> 
    83         public void Draw(Graphics sdc) 
     84        public void Draw(Graphics rawDC) 
    8485        { 
    8586            //Create a backing bitmap buffer to prevent flicker 
     
    145146            } 
    146147 
    147             sdc.DrawImage(back_bmp, new Point(0, 0)); 
     148            rawDC.DrawImage(back_bmp, new Point(0, 0)); 
    148149        } 
    149150 
     
    160161        /// </summary> 
    161162        /// <param name="pe">Paint event object.</param> 
    162         protected override void OnPaint(PaintEventArgs pe) 
    163         { 
    164             Draw(pe.Graphics); 
     163        protected override void OnPaint(PaintEventArgs e) 
     164        { 
     165            Draw(e.Graphics); 
    165166 
    166167            // Calling the base class OnPaint 
    167             base.OnPaint(pe); 
     168            base.OnPaint(e); 
    168169        } 
    169170 
     
    176177        /// Accesses or modifies the items in the tool bar. 
    177178        /// </summary> 
    178         /// <param name="i">Index of item.</param> 
     179        /// <param name="index">Index of item.</param> 
    179180        /// <returns>ToolBarItem describing the item at index i.</returns> 
    180         public ToolBarItem this[int i] 
     181        public ToolBarItem this[int index] 
    181182        { 
    182183            get 
    183184            { 
    184                 return items[i]; 
     185                return items[index]; 
    185186            } 
    186187 
    187188            set 
    188189            { 
    189                 items[i] = value; 
     190                items[index] = value; 
    190191                Redraw(); 
    191192            } 
    192193        } 
    193194 
    194         public List<ToolBarItem> Items 
     195        public ICollection<ToolBarItem> Items 
    195196        { 
    196197            get { return items; } 
    197             set { items = value; } 
    198198        } 
    199199    } 
     
    233233        /// Item click event handler 
    234234        /// </summary> 
    235         public event ToolbarItemClickedEventFunction ToolbarItemClicked; 
    236         public delegate void ToolbarItemClickedEventFunction(object sender, EventArgs e); 
     235        public EventHandler<EventArgs> ToolbarItemClicked 
     236        { 
     237            get; 
     238            set; 
     239        } 
     240 
    237241        internal void OnToolbarItemClicked(object sender) 
    238242        { 
  • 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.