/// <summary>
/// Gets a list of subfolders in this folder
/// </summary>
/// <returns>A list of subfolders in the folder</returns>
public async Task <IList <IFolder> > GetFoldersAsync(CancellationToken cancellationToken)
{
await AwaitExtensions.SwitchOffMainThreadAsync(cancellationToken);
EnsureExists();
IList <IFolder> ret = Directory.GetDirectories(Path).Select(d => new FileSystemFolder(d, true)).ToList <IFolder>().AsReadOnly();
return(ret);
}
/// <summary>
/// Gets a list of the files in this folder
/// </summary>
/// <returns>A list of the files in the folder</returns>
public async Task <IList <IFile> > GetFilesAsync(CancellationToken cancellationToken)
{
await AwaitExtensions.SwitchOffMainThreadAsync(cancellationToken);
EnsureExists();
IList <IFile> ret = Directory.GetFiles(Path).Select(f => new FileSystemFile(f)).ToList <IFile>().AsReadOnly();
return(ret);
}
/// <summary>
/// Deletes the file
/// </summary>
/// <returns>A task which will complete after the file is deleted.</returns>
public async Task DeleteAsync(CancellationToken cancellationToken)
{
await AwaitExtensions.SwitchOffMainThreadAsync(cancellationToken);
if (!File.Exists(Path))
{
throw new StorageEverywhere.Exceptions.FileNotFoundException("File does not exist: " + Path);
}
File.Delete(Path);
}
/// <summary>
/// Deletes this folder and all of its contents
/// </summary>
/// <returns>A task which will complete after the folder is deleted</returns>
public async Task DeleteAsync(CancellationToken cancellationToken)
{
if (!_canDelete)
{
throw new IOException("Cannot delete root storage folder.");
}
await AwaitExtensions.SwitchOffMainThreadAsync(cancellationToken);
EnsureExists();
Directory.Delete(Path, true);
}
/// <summary>
/// Creates a file in this folder
/// </summary>
/// <param name="desiredName">The name of the file to create</param>
/// <param name="option">Specifies how to behave if the specified file already exists</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>The newly created file</returns>
public async Task <IFile> CreateFileAsync(string desiredName, CreationCollisionOption option, CancellationToken cancellationToken)
{
Requires.NotNullOrEmpty(desiredName, "desiredName");
await AwaitExtensions.SwitchOffMainThreadAsync(cancellationToken);
EnsureExists();
string nameToUse = desiredName;
string newPath = System.IO.Path.Combine(Path, nameToUse);
if (File.Exists(newPath))
{
if (option == CreationCollisionOption.GenerateUniqueName)
{
string desiredRoot = System.IO.Path.GetFileNameWithoutExtension(desiredName);
string desiredExtension = System.IO.Path.GetExtension(desiredName);
for (int num = 2; File.Exists(newPath); num++)
{
cancellationToken.ThrowIfCancellationRequested();
nameToUse = desiredRoot + " (" + num + ")" + desiredExtension;
newPath = System.IO.Path.Combine(Path, nameToUse);
}
InternalCreateFile(newPath);
}
else if (option == CreationCollisionOption.ReplaceExisting)
{
File.Delete(newPath);
InternalCreateFile(newPath);
}
else if (option == CreationCollisionOption.FailIfExists)
{
throw new IOException("File already exists: " + newPath);
}
else if (option == CreationCollisionOption.OpenIfExists)
{
// No operation
}
else
{
throw new ArgumentException("Unrecognized CreationCollisionOption: " + option);
}
}
else
{
// Create file
InternalCreateFile(newPath);
}
var ret = new FileSystemFile(newPath);
return(ret);
}
/// <summary>
/// Gets a folder, given its path. Returns null if the folder does not exist.
/// </summary>
/// <param name="path">The path to a folder, as returned from the <see cref="IFolder.Path"/> property.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>A folder for the specified path, or null if it does not exist.</returns>
public async Task <IFolder> GetFolderFromPathAsync(string path, CancellationToken cancellationToken)
{
Requires.NotNullOrEmpty(path, "path");
await AwaitExtensions.SwitchOffMainThreadAsync(cancellationToken);
if (Directory.Exists(path))
{
return(new FileSystemFolder(path, true));
}
return(null);
}
/// <summary>
/// Gets a file in this folder
/// </summary>
/// <param name="name">The name of the file to get</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>The requested file, or null if it does not exist</returns>
public async Task <IFile> GetFileAsync(string name, CancellationToken cancellationToken)
{
await AwaitExtensions.SwitchOffMainThreadAsync(cancellationToken);
string path = System.IO.Path.Combine(Path, name);
if (!File.Exists(path))
{
throw new StorageEverywhere.Exceptions.FileNotFoundException("File does not exist: " + path);
}
var ret = new FileSystemFile(path);
return(ret);
}
/// <summary>
/// Creates a subfolder in this folder
/// </summary>
/// <param name="desiredName">The name of the folder to create</param>
/// <param name="option">Specifies how to behave if the specified folder already exists</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>The newly created folder</returns>
public async Task <IFolder> CreateFolderAsync(string desiredName, CreationCollisionOption option, CancellationToken cancellationToken)
{
Requires.NotNullOrEmpty(desiredName, "desiredName");
await AwaitExtensions.SwitchOffMainThreadAsync(cancellationToken);
EnsureExists();
string nameToUse = desiredName;
string newPath = System.IO.Path.Combine(Path, nameToUse);
if (Directory.Exists(newPath))
{
if (option == CreationCollisionOption.GenerateUniqueName)
{
for (int num = 2; Directory.Exists(newPath); num++)
{
cancellationToken.ThrowIfCancellationRequested();
nameToUse = desiredName + " (" + num + ")";
newPath = System.IO.Path.Combine(Path, nameToUse);
}
Directory.CreateDirectory(newPath);
}
else if (option == CreationCollisionOption.ReplaceExisting)
{
Directory.Delete(newPath, true);
Directory.CreateDirectory(newPath);
}
else if (option == CreationCollisionOption.FailIfExists)
{
throw new IOException("Directory already exists: " + newPath);
}
else if (option == CreationCollisionOption.OpenIfExists)
{
// No operation
}
else
{
throw new ArgumentException("Unrecognized CreationCollisionOption: " + option);
}
}
else
{
Directory.CreateDirectory(newPath);
}
var ret = new FileSystemFolder(newPath, true);
return(ret);
}
/// <summary>
/// Gets a subfolder in this folder
/// </summary>
/// <param name="name">The name of the folder to get</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>The requested folder, or null if it does not exist</returns>
public async Task <IFolder> GetFolderAsync(string name, CancellationToken cancellationToken)
{
Requires.NotNullOrEmpty(name, "name");
await AwaitExtensions.SwitchOffMainThreadAsync(cancellationToken);
string path = System.IO.Path.Combine(Path, name);
if (!Directory.Exists(path))
{
throw new StorageEverywhere.Exceptions.DirectoryNotFoundException("Directory does not exist: " + path);
}
var ret = new FileSystemFolder(path, true);
return(ret);
}
/// <summary>
/// Moves a file.
/// </summary>
/// <param name="newPath">The new full path of the file.</param>
/// <param name="collisionOption">How to deal with collisions with existing files.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>
/// A task which will complete after the file is moved.
/// </returns>
public async Task MoveAsync(string newPath, NameCollisionOption collisionOption, CancellationToken cancellationToken)
{
Requires.NotNullOrEmpty(newPath, "newPath");
await AwaitExtensions.SwitchOffMainThreadAsync(cancellationToken);
string newDirectory = System.IO.Path.GetDirectoryName(newPath);
string newName = System.IO.Path.GetFileName(newPath);
for (int counter = 1; ; counter++)
{
cancellationToken.ThrowIfCancellationRequested();
string candidateName = newName;
if (counter > 1)
{
candidateName = String.Format(
CultureInfo.InvariantCulture,
"{0} ({1}){2}",
System.IO.Path.GetFileNameWithoutExtension(newName),
counter,
System.IO.Path.GetExtension(newName));
}
string candidatePath = PortablePath.Combine(newDirectory, candidateName);
if (File.Exists(candidatePath))
{
switch (collisionOption)
{
case NameCollisionOption.FailIfExists:
throw new IOException("File already exists.");
case NameCollisionOption.GenerateUniqueName:
continue; // try again with a new name.
case NameCollisionOption.ReplaceExisting:
File.Delete(candidatePath);
break;
}
}
File.Move(_path, candidatePath);
_path = candidatePath;
_name = candidateName;
return;
}
}
/// <summary>
/// Opens the file
/// </summary>
/// <param name="fileAccess">Specifies whether the file should be opened in read-only or read/write mode</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>A <see cref="Stream"/> which can be used to read from or write to the file</returns>
public async Task <Stream> OpenAsync(FileAccess fileAccess, CancellationToken cancellationToken)
{
await AwaitExtensions.SwitchOffMainThreadAsync(cancellationToken);
if (fileAccess == FileAccess.Read)
{
return(File.OpenRead(Path));
}
else if (fileAccess == FileAccess.ReadAndWrite)
{
return(File.Open(Path, FileMode.Open, System.IO.FileAccess.ReadWrite));
}
else
{
throw new ArgumentException("Unrecognized FileAccess value: " + fileAccess);
}
}
/// <summary>
/// Checks whether a folder or file exists at the given location.
/// </summary>
/// <param name="name">The name of the file or folder to check for.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>
/// A task whose result is the result of the existence check.
/// </returns>
public async Task <ExistenceCheckResult> CheckExistsAsync(string name, CancellationToken cancellationToken)
{
Requires.NotNullOrEmpty(name, "name");
await AwaitExtensions.SwitchOffMainThreadAsync(cancellationToken);
string checkPath = PortablePath.Combine(this.Path, name);
if (File.Exists(checkPath))
{
return(ExistenceCheckResult.FileExists);
}
else if (Directory.Exists(checkPath))
{
return(ExistenceCheckResult.FolderExists);
}
else
{
return(ExistenceCheckResult.NotFound);
}
}