Esempio n. 1
0
        public async override Task <bool> RenameFileAsync(string oldPath, string newPath)
        {
            await AwaitHelper.EnsureNotMainThread();

            File.Move(oldPath, newPath);
            return(true);
        }
Esempio n. 2
0
        public override async Task <string> GetTemporaryFilePathAsync(bool createFile = false, string useExtension = null)
        {
            await AwaitHelper.EnsureNotMainThread();

            if (!createFile)
            {
                return(Path.GetTempPath());
            }
            if (useExtension == null || useExtension.Length < 2)
            {
                return(Path.GetTempFileName());
            }

            if (!useExtension.StartsWith(".", StringComparison.Ordinal))
            {
                useExtension = "." + useExtension;
            }
            var path = Path.Combine(Path.GetTempPath(), Path.GetFileName(Path.GetRandomFileName()) + useExtension);

            if (createFile)
            {
                File.WriteAllText(path, string.Empty);
            }
            return(path);
        }
Esempio n. 3
0
        public override async Task <FileDetail> GetFileDetailAsync(string path)
        {
            if (path == null)
            {
                throw new ArgumentNullException(nameof(path));
            }

            await AwaitHelper.EnsureNotMainThread();

            return(new FileDetailShared(path));
        }
Esempio n. 4
0
        public override async Task <bool> CreateDirectoryAsync(string path, bool allowExisting = true)
        {
            if (path == null)
            {
                throw new ArgumentNullException(nameof(path));
            }

            await AwaitHelper.EnsureNotMainThread();

            if (Directory.Exists(path))
            {
                return(allowExisting);
            }

            Directory.CreateDirectory(path);
            return(true);
        }
Esempio n. 5
0
        public override async Task <bool> DeleteDirectoryAsync(string path, bool recursive)
        {
            if (path == null)
            {
                throw new ArgumentNullException(nameof(path));
            }

            await AwaitHelper.EnsureNotMainThread();

            try
            {
                Directory.Delete(path, recursive);
            }
            catch (Exception)
            {
                return(false);
            }

            return(true);
        }
Esempio n. 6
0
        public override async Task <IEnumerable <string> > GetDirectoryListAsync(string path, bool recursive = false)
        {
            if (path == null)
            {
                throw new ArgumentNullException(nameof(path));
            }

            await AwaitHelper.EnsureNotMainThread();

            var root = new DirectoryInfo(path);

            if (root.Exists)
            {
                var list = new List <string>();
                foreach (var di in root.EnumerateDirectories("*", recursive ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly))
                {
                    list.Add(di.FullName);
                }
                return(list);
            }

            return(null);
        }
Esempio n. 7
0
        public override async Task <IEnumerable <FileDetail> > GetFileListAsync(string path, bool recursive = false)
        {
            if (path == null)
            {
                throw new ArgumentNullException(nameof(path));
            }

            await AwaitHelper.EnsureNotMainThread();

            var di = new DirectoryInfo(path);

            if (di.Exists)
            {
                var details = new List <FileDetail>();
                foreach (var fi in di.EnumerateFiles("*", recursive ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly))
                {
                    details.Add(new FileDetailShared(fi.FullName));
                }
                return(details);
            }
            // return null if no folder exists at the path
            return(null);
        }
Esempio n. 8
0
        public override async Task <bool> DeleteFileAsync(string path)
        {
            if (path == null)
            {
                throw new ArgumentNullException(nameof(path));
            }

            await AwaitHelper.EnsureNotMainThread();

            if (File.Exists(path))
            {
                try
                {
                    File.Delete(path);
                }
                catch (Exception)
                {
                    return(false);
                }
            }

            // return success if doesn't exist in the first place
            return(true);
        }
Esempio n. 9
0
        public override async Task <bool> CheckExistsAsync(string path)
        {
            await AwaitHelper.EnsureNotMainThread();

            return(File.Exists(path) || Directory.Exists(path));
        }
Esempio n. 10
0
        public override async Task <Stream> OpenFileAsync(string path, AccessMode accessMode = AccessMode.ReadOnly, CollisionMethod collisionMethod = CollisionMethod.NormalOpen)
        {
            if (path == null)
            {
                throw new ArgumentNullException(nameof(path));
            }

            await AwaitHelper.EnsureNotMainThread();

            var fi = new FileInfo(path);

            // set some default enums
            FileMode    mode    = FileMode.Open;
            FileAccess  access  = FileAccess.Read;
            FileShare   sharing = FileShare.Read;
            FileOptions opts    = FileOptions.RandomAccess | FileOptions.Asynchronous;

            // parse the supplied options
            switch (accessMode)
            {
            case AccessMode.ReadWrite:
                mode   = FileMode.OpenOrCreate;
                access = FileAccess.ReadWrite;
                break;

            case AccessMode.ReadWriteTemporary:
                mode   = FileMode.OpenOrCreate;
                access = FileAccess.ReadWrite;
                opts  |= FileOptions.DeleteOnClose;
                break;

            case AccessMode.ReadWriteExclusive:
                mode    = FileMode.OpenOrCreate;
                access  = FileAccess.ReadWrite;
                sharing = FileShare.None;
                break;
            }

            // check collision options
            if (fi.Exists)
            {
                if (collisionMethod == CollisionMethod.FailIfExists)
                {
                    return(null);
                }
                else if (collisionMethod == CollisionMethod.RenameIfExists)
                {
                    // append numbers until we find a unique one
                    var fPath = fi.DirectoryName;
                    var fName = Path.GetFileNameWithoutExtension(fi.Name);
                    for (int num = 2; ; num++)
                    {
                        var name = Path.Combine(fPath, string.Format("{0}-{1}.{2}", fName, num, fi.Extension));
                        if (!File.Exists(name))
                        {
                            path = name; // use this new name
                            break;
                        }
                    }
                }
                else if (collisionMethod == CollisionMethod.OverwriteIfExists && accessMode != AccessMode.ReadOnly)
                {
                    mode = FileMode.Create;
                }
            }

            // try creating the file stream
            try
            {
                return(new FileStream(path, mode, access, sharing, 16 * 1024, opts));
            }
            catch (ArgumentException)
            {
                // bad file name
            }
            catch (NotSupportedException)
            {
                // something weird, like lpt1:
            }
            catch (FileNotFoundException)
            {
                // file doesn't exist for read
            }
            catch (IOException)
            {
                // stream broke
            }
            catch (UnauthorizedAccessException)
            {
                // not permitted
            }
            return(null);
        }