Wrapper for FileInfo
Inheritance: FileSystemInfoWrapper, IFileInfo
Exemple #1
0
        /// <summary>
        /// Replaces the contents of a specified destinationFile with the file described by the current IFileInfo
        /// object, deleting the original file, and creating a backup of the replaced file.
        /// Also specifies whether to ignore merge errors.
        /// </summary>
        /// <param name="destinationFile">Destination file.</param>
        /// <param name="destinationBackupFileName">Destination backup file name.</param>
        /// <param name="ignoreMetadataErrors"><c>true</c> to ignore merge errors (such as attributes and ACLs) from the replaced file to the replacement file; otherwise <c>false</c>.</param>
        /// <returns>A IFileInfo object that encapsulates information about the file described by the destFileName parameter.</returns>
        public IFileInfo Replace(IFileInfo destinationFile, IFileInfo destinationBackupFileName, bool ignoreMetadataErrors)
        {
#if __MonoCS__
            var reader       = new ExtendedAttributeReaderUnix();
            var oldSourceEAs = new Dictionary <string, string>();
            var oldTargetEAs = new Dictionary <string, string>();
            if (reader.IsFeatureAvailable(this.FullName))
            {
                foreach (var key in reader.ListAttributeKeys(this.FullName))
                {
                    oldSourceEAs.Add(key, this.GetExtendedAttribute(key));
                }

                foreach (var key in reader.ListAttributeKeys(destinationFile.FullName))
                {
                    oldTargetEAs.Add(key, destinationFile.GetExtendedAttribute(key));
                }
            }
#endif
            var result = new FileInfoWrapper(this.original.Replace(destinationFile.FullName, destinationBackupFileName.FullName, ignoreMetadataErrors));

#if __MonoCS__
            foreach (var entry in oldSourceEAs)
            {
                result.SetExtendedAttribute(entry.Key, entry.Value, true);
            }

            foreach (var entry in oldTargetEAs)
            {
                destinationBackupFileName.SetExtendedAttribute(entry.Key, entry.Value, true);
            }
#endif
            return(result);
        }
        /// <summary>
        /// Gets the files of the original instance wrapped by new FileInfoWrapper instances.
        /// </summary>
        /// <returns>The files.</returns>
        public IFileInfo[] GetFiles()
        {
            FileInfo[]  originalFiles = this.original.GetFiles();
            IFileInfo[] wrappedFiles  = new IFileInfo[originalFiles.Length];
            for (int i = 0; i < originalFiles.Length; i++)
            {
                wrappedFiles[i] = new FileInfoWrapper(originalFiles[i]);
            }

            return(wrappedFiles);
        }
        /// <summary>
        /// Replaces the contents of a specified destinationFile with the file described by the current IFileInfo
        /// object, deleting the original file, and creating a backup of the replaced file.
        /// Also specifies whether to ignore merge errors.
        /// </summary>
        /// <param name="destinationFile">Destination file.</param>
        /// <param name="destinationBackupFileName">Destination backup file name.</param>
        /// <param name="ignoreMetadataErrors"><c>true</c> to ignore merge errors (such as attributes and ACLs) from the replaced file to the replacement file; otherwise <c>false</c>.</param>
        /// <returns>A IFileInfo object that encapsulates information about the file described by the destFileName parameter.</returns>
        public IFileInfo Replace(IFileInfo destinationFile, IFileInfo destinationBackupFileName, bool ignoreMetadataErrors) {
#if __MonoCS__
            var reader = new ExtendedAttributeReaderUnix();
            var oldSourceEAs = new Dictionary<string, string>();
            var oldTargetEAs = new Dictionary<string, string>();
            if (reader.IsFeatureAvailable(this.FullName)) {
                foreach (var key in reader.ListAttributeKeys(this.FullName)) {
                    oldSourceEAs.Add(key, this.GetExtendedAttribute(key));
                }

                foreach (var key in reader.ListAttributeKeys(destinationFile.FullName)) {
                    oldTargetEAs.Add(key, destinationFile.GetExtendedAttribute(key));
                }
            }
#else
            try {
#endif
                var result = new FileInfoWrapper(this.original.Replace(destinationFile.FullName, destinationBackupFileName.FullName, ignoreMetadataErrors));
#if __MonoCS__
            foreach (var entry in oldSourceEAs) {
                result.SetExtendedAttribute(entry.Key, entry.Value, true);
            }

            foreach (var entry in oldTargetEAs) {
                destinationBackupFileName.SetExtendedAttribute(entry.Key, entry.Value, true);
            }

            return result;
#else
                return result;
            } catch (IOException ex) {
                int error = Marshal.GetHRForException(ex) & 0xffff;
                if (error == 1176) {
                    string newName = destinationFile.FullName + Guid.NewGuid().ToString() + ".sync";
                    IFileInfo newResult = null;
                    try {
                        var copy = this.original.CopyTo(newName, true);
                        newResult = new FileInfoWrapper(copy.Replace(destinationFile.FullName, destinationBackupFileName.FullName, ignoreMetadataErrors));
                        this.Delete();
                        return newResult;
                    } catch (Exception) {
                    } finally {
                        if (File.Exists(newName)) {
                            File.Delete(newName);
                        }
                    }

                    throw;
                } else {
                    throw;
                }
            }
#endif
        }
        /// <summary>
        /// Gets the files of the original instance wrapped by new FileInfoWrapper instances.
        /// </summary>
        /// <returns>The files.</returns>
        public IFileInfo[] GetFiles() {
            FileInfo[] originalFiles = this.original.GetFiles();
            IFileInfo[] wrappedFiles = new IFileInfo[originalFiles.Length];
            for (int i = 0; i < originalFiles.Length; i++) {
                wrappedFiles[i] = new FileInfoWrapper(originalFiles[i]);
            }

            return wrappedFiles;
        }
        /// <summary>
        /// Replaces the contents of a specified destinationFile with the file described by the current IFileInfo
        /// object, deleting the original file, and creating a backup of the replaced file.
        /// Also specifies whether to ignore merge errors.
        /// </summary>
        /// <param name="destinationFile">Destination file.</param>
        /// <param name="destinationBackupFileName">Destination backup file name.</param>
        /// <param name="ignoreMetadataErrors"><c>true</c> to ignore merge errors (such as attributes and ACLs) from the replaced file to the replacement file; otherwise <c>false</c>.</param>
        /// <returns>A IFileInfo object that encapsulates information about the file described by the destFileName parameter.</returns>
        public IFileInfo Replace(IFileInfo destinationFile, IFileInfo destinationBackupFileName, bool ignoreMetadataErrors)
        {
#if __MonoCS__
            var reader       = new ExtendedAttributeReaderUnix();
            var oldSourceEAs = new Dictionary <string, string>();
            var oldTargetEAs = new Dictionary <string, string>();
            if (reader.IsFeatureAvailable(this.FullName))
            {
                foreach (var key in reader.ListAttributeKeys(this.FullName))
                {
                    oldSourceEAs.Add(key, this.GetExtendedAttribute(key));
                }

                foreach (var key in reader.ListAttributeKeys(destinationFile.FullName))
                {
                    oldTargetEAs.Add(key, destinationFile.GetExtendedAttribute(key));
                }
            }
#else
            try {
#endif
            var result = new FileInfoWrapper(this.original.Replace(destinationFile.FullName, destinationBackupFileName.FullName, ignoreMetadataErrors));
#if __MonoCS__
            foreach (var entry in oldSourceEAs)
            {
                result.SetExtendedAttribute(entry.Key, entry.Value, true);
            }

            foreach (var entry in oldTargetEAs)
            {
                destinationBackupFileName.SetExtendedAttribute(entry.Key, entry.Value, true);
            }

            return(result);
#else
            return(result);
        }

        catch (IOException ex) {
            int error = Marshal.GetHRForException(ex) & 0xffff;
            if (error == 1176)
            {
                string    newName   = destinationFile.FullName + Guid.NewGuid().ToString() + ".sync";
                IFileInfo newResult = null;
                try {
                    var copy = this.original.CopyTo(newName, true);
                    newResult = new FileInfoWrapper(copy.Replace(destinationFile.FullName, destinationBackupFileName.FullName, ignoreMetadataErrors));
                    this.Delete();
                    return(newResult);
                } catch (Exception) {
                } finally {
                    if (File.Exists(newName))
                    {
                        File.Delete(newName);
                    }
                }

                throw;
            }
            else
            {
                throw;
            }
        }
#endif
        }