Changeset 2045 for trunk/eraser


Ignore:
Timestamp:
5/4/2010 3:04:18 AM (4 years ago)
Author:
lowjoel
Message:

Fixed the null Progress property upon the completion of the FileSystemObjectErasureTarget?.Execute function. The Progress property is now managed by the derived class itself.

Location:
trunk/eraser/Eraser.DefaultPlugins/ErasureTargets
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/eraser/Eraser.DefaultPlugins/ErasureTargets/FileErasureTarget.cs

    r2044 r2045  
    3030 
    3131using Eraser.Manager; 
     32using Eraser.Util; 
    3233 
    3334namespace Eraser.DefaultPlugins 
     
    7980            return result; 
    8081        } 
     82 
     83        public override void Execute() 
     84        { 
     85            Progress = new SteppedProgressManager(); 
     86            try 
     87            { 
     88                base.Execute(); 
     89            } 
     90            finally 
     91            { 
     92                Progress = null; 
     93            } 
     94        } 
    8195    } 
    8296} 
  • trunk/eraser/Eraser.DefaultPlugins/ErasureTargets/FileSystemObjectErasureTarget.cs

    r2039 r2045  
    179179        } 
    180180 
    181         public override void Execute() 
     181        /// <remarks>The <see cref="Progress"/> property must be defined prior 
     182        /// to the execution of this function.</remarks> 
     183        public virtual void Execute() 
    182184        { 
    183185            //Retrieve the list of files to erase. 
     
    190192 
    191193            //Set the event's current target status. 
    192             SteppedProgressManager progress = new SteppedProgressManager(); 
    193             Progress = progress; 
    194             Task.Progress.Steps.Add(new SteppedProgressManagerStep(progress, 1.0f / Task.Targets.Count)); 
     194            if (Progress == null) 
     195                throw new InvalidOperationException("The Progress property must not be null."); 
     196            Task.Progress.Steps.Add(new SteppedProgressManagerStep(Progress, 1.0f / Task.Targets.Count)); 
    195197 
    196198            //Iterate over every path, and erase the path. 
  • trunk/eraser/Eraser.DefaultPlugins/ErasureTargets/FolderErasureTarget.cs

    r2044 r2045  
    182182        public override void Execute() 
    183183        { 
    184             base.Execute(); 
    185  
    186             //If the user requested a folder removal, do it. 
    187             if (Directory.Exists(Path)) 
    188             { 
    189                 ProgressManager step = new ProgressManager(); 
    190                 Progress.Steps.Add(new SteppedProgressManagerStep(step, 
    191                     0.0f, S._("Removing folders..."))); 
    192  
    193                 //Remove all subfolders which are empty. 
    194                 FileSystem fsManager = ManagerLibrary.Instance.FileSystemRegistrar[ 
    195                     VolumeInfo.FromMountPoint(Path)]; 
    196                 Action<DirectoryInfo> eraseEmptySubFolders = null; 
    197                 eraseEmptySubFolders = delegate(DirectoryInfo info) 
    198                 { 
    199                     foreach (DirectoryInfo subDir in info.GetDirectories()) 
     184            Progress = new SteppedProgressManager(); 
     185            try 
     186            { 
     187                base.Execute(); 
     188 
     189                //If the user requested a folder removal, do it. 
     190                if (Directory.Exists(Path)) 
     191                { 
     192                    ProgressManager step = new ProgressManager(); 
     193                    Progress.Steps.Add(new SteppedProgressManagerStep(step, 
     194                        0.0f, S._("Removing folders..."))); 
     195 
     196                    //Remove all subfolders which are empty. 
     197                    FileSystem fsManager = ManagerLibrary.Instance.FileSystemRegistrar[ 
     198                        VolumeInfo.FromMountPoint(Path)]; 
     199                    Action<DirectoryInfo> eraseEmptySubFolders = null; 
     200                    eraseEmptySubFolders = delegate(DirectoryInfo info) 
     201                    { 
     202                        foreach (DirectoryInfo subDir in info.GetDirectories()) 
     203                            eraseEmptySubFolders(subDir); 
     204                        OnProgressChanged(this, new ProgressChangedEventArgs(step, 
     205                            new TaskProgressChangedEventArgs(info.FullName, 0, 0))); 
     206 
     207                        FileSystemInfo[] files = info.GetFileSystemInfos(); 
     208                        if (files.Length == 0) 
     209                            fsManager.DeleteFolder(info); 
     210                    }; 
     211 
     212                    DirectoryInfo directory = new DirectoryInfo(Path); 
     213                    foreach (DirectoryInfo subDir in directory.GetDirectories()) 
    200214                        eraseEmptySubFolders(subDir); 
    201                     OnProgressChanged(this, new ProgressChangedEventArgs(step, 
    202                        new TaskProgressChangedEventArgs(info.FullName, 0, 0))); 
    203  
    204                     FileSystemInfo[] files = info.GetFileSystemInfos(); 
    205                     if (files.Length == 0) 
    206                         fsManager.DeleteFolder(info); 
    207                 }; 
    208  
    209                 DirectoryInfo directory = new DirectoryInfo(Path); 
    210                 foreach (DirectoryInfo subDir in directory.GetDirectories()) 
    211                     eraseEmptySubFolders(subDir); 
    212  
    213                 if (DeleteIfEmpty) 
    214                 { 
    215                     //See if this is the root of a volume. 
    216                     bool isVolumeRoot = directory.Parent == null; 
    217                     foreach (VolumeInfo volume in VolumeInfo.Volumes) 
    218                         foreach (string mountPoint in volume.MountPoints) 
    219                             if (directory.FullName == mountPoint) 
    220                                 isVolumeRoot = true; 
    221  
    222                     //If the folder is a mount point, then don't delete it. If it isn't, 
    223                     //search for files under the folder to see if it is empty. 
    224                     if (!isVolumeRoot && directory.Exists && 
    225                         directory.GetFiles("*", SearchOption.AllDirectories).Length == 0) 
     215 
     216                    if (DeleteIfEmpty) 
    226217                    { 
    227                         fsManager.DeleteFolder(directory); 
     218                        //See if this is the root of a volume. 
     219                        bool isVolumeRoot = directory.Parent == null; 
     220                        foreach (VolumeInfo volume in VolumeInfo.Volumes) 
     221                            foreach (string mountPoint in volume.MountPoints) 
     222                                if (directory.FullName == mountPoint) 
     223                                    isVolumeRoot = true; 
     224 
     225                        //If the folder is a mount point, then don't delete it. If it isn't, 
     226                        //search for files under the folder to see if it is empty. 
     227                        if (!isVolumeRoot && directory.Exists && 
     228                            directory.GetFiles("*", SearchOption.AllDirectories).Length == 0) 
     229                        { 
     230                            fsManager.DeleteFolder(directory); 
     231                        } 
    228232                    } 
    229233                } 
     234            } 
     235            finally 
     236            { 
     237                Progress = null; 
    230238            } 
    231239        } 
  • trunk/eraser/Eraser.DefaultPlugins/ErasureTargets/RecycleBinErasureTarget.cs

    r2039 r2045  
    133133        public override void Execute() 
    134134        { 
    135             base.Execute(); 
     135            Progress = new SteppedProgressManager(); 
     136            try 
     137            { 
     138                base.Execute(); 
    136139 
    137             ProgressManager step = new ProgressManager(); 
    138             Progress.Steps.Add(new SteppedProgressManagerStep(step, 
    139                 0.0f, S._("Emptying recycle bin..."))); 
    140             OnProgressChanged(this, new ProgressChangedEventArgs(step, 
    141                 new TaskProgressChangedEventArgs(string.Empty, 0, 0))); 
     140                ProgressManager step = new ProgressManager(); 
     141                Progress.Steps.Add(new SteppedProgressManagerStep(step, 
     142                    0.0f, )); 
     143                OnProgressChanged(this, new ProgressChangedEventArgs(step, 
     144                    new TaskProgressChangedEventArgs(string.Empty, 0, 0))); 
    142145 
    143             RecycleBin.Empty(EmptyRecycleBinOptions.NoConfirmation | 
    144                 EmptyRecycleBinOptions.NoProgressUI | EmptyRecycleBinOptions.NoSound); 
     146                RecycleBin.Empty(EmptyRecycleBinOptions.NoConfirmation | 
     147                    EmptyRecycleBinOptions.NoProgressUI | EmptyRecycleBinOptions.NoSound); 
     148            } 
     149            finally 
     150            { 
     151                Progress = null; 
     152            } 
    145153        } 
    146154    } 
Note: See TracChangeset for help on using the changeset viewer.