2016-10-29 01:40:15 -04:00
using System ;
using System.Collections.Generic ;
using System.IO ;
using System.Linq ;
using System.Text ;
using MediaBrowser.Model.IO ;
using MediaBrowser.Model.Logging ;
2017-03-10 14:51:29 -05:00
using MediaBrowser.Model.System ;
2016-10-29 01:40:15 -04:00
namespace Emby.Common.Implementations.IO
{
/// <summary>
/// Class ManagedFileSystem
/// </summary>
public class ManagedFileSystem : IFileSystem
{
protected ILogger Logger ;
private readonly bool _supportsAsyncFileStreams ;
private char [ ] _invalidFileNameChars ;
private readonly List < IShortcutHandler > _shortcutHandlers = new List < IShortcutHandler > ( ) ;
2017-03-10 14:51:29 -05:00
private bool EnableFileSystemRequestConcat ;
2016-10-29 01:40:15 -04:00
2017-01-23 16:51:23 -05:00
private string _tempPath ;
2017-03-10 14:51:29 -05:00
public ManagedFileSystem ( ILogger logger , IEnvironmentInfo environmentInfo , string tempPath )
2016-10-29 01:40:15 -04:00
{
Logger = logger ;
2017-03-10 14:51:29 -05:00
_supportsAsyncFileStreams = true ;
2017-01-23 16:51:23 -05:00
_tempPath = tempPath ;
2017-03-18 19:37:29 -04:00
// On Linux, this needs to be true or symbolic links are ignored
EnableFileSystemRequestConcat = environmentInfo . OperatingSystem ! = MediaBrowser . Model . System . OperatingSystem . Windows & &
environmentInfo . OperatingSystem ! = MediaBrowser . Model . System . OperatingSystem . OSX ;
2017-03-10 14:51:29 -05:00
SetInvalidFileNameChars ( environmentInfo . OperatingSystem = = MediaBrowser . Model . System . OperatingSystem . Windows ) ;
2016-10-29 01:40:15 -04:00
}
public void AddShortcutHandler ( IShortcutHandler handler )
{
_shortcutHandlers . Add ( handler ) ;
}
protected void SetInvalidFileNameChars ( bool enableManagedInvalidFileNameChars )
{
if ( enableManagedInvalidFileNameChars )
{
_invalidFileNameChars = Path . GetInvalidFileNameChars ( ) ;
}
else
{
// GetInvalidFileNameChars is less restrictive in Linux/Mac than Windows, this mimic Windows behavior for mono under Linux/Mac.
_invalidFileNameChars = new char [ 41 ] { ' \ x00 ' , ' \ x01 ' , ' \ x02 ' , ' \ x03 ' , ' \ x04 ' , ' \ x05 ' , ' \ x06 ' , ' \ x07 ' ,
' \ x08 ' , ' \ x09 ' , ' \ x0A ' , ' \ x0B ' , ' \ x0C ' , ' \ x0D ' , ' \ x0E ' , ' \ x0F ' , ' \ x10 ' , ' \ x11 ' , ' \ x12 ' ,
' \ x13 ' , ' \ x14 ' , ' \ x15 ' , ' \ x16 ' , ' \ x17 ' , ' \ x18 ' , ' \ x19 ' , ' \ x1A ' , ' \ x1B ' , ' \ x1C ' , ' \ x1D ' ,
' \ x1E ' , ' \ x1F ' , ' \ x22 ' , ' \ x3C ' , ' \ x3E ' , ' \ x7C ' , ':' , '*' , '?' , '\\' , '/' } ;
}
}
public char DirectorySeparatorChar
{
get
{
return Path . DirectorySeparatorChar ;
}
}
2016-11-13 16:04:21 -05:00
public char PathSeparator
{
get
{
2016-11-14 14:27:37 -05:00
return Path . PathSeparator ;
2016-11-13 16:04:21 -05:00
}
}
2016-10-29 01:40:15 -04:00
public string GetFullPath ( string path )
{
return Path . GetFullPath ( path ) ;
}
/// <summary>
/// Determines whether the specified filename is shortcut.
/// </summary>
/// <param name="filename">The filename.</param>
/// <returns><c>true</c> if the specified filename is shortcut; otherwise, <c>false</c>.</returns>
/// <exception cref="System.ArgumentNullException">filename</exception>
public virtual bool IsShortcut ( string filename )
{
if ( string . IsNullOrEmpty ( filename ) )
{
throw new ArgumentNullException ( "filename" ) ;
}
var extension = Path . GetExtension ( filename ) ;
return _shortcutHandlers . Any ( i = > string . Equals ( extension , i . Extension , StringComparison . OrdinalIgnoreCase ) ) ;
}
/// <summary>
/// Resolves the shortcut.
/// </summary>
/// <param name="filename">The filename.</param>
/// <returns>System.String.</returns>
/// <exception cref="System.ArgumentNullException">filename</exception>
public virtual string ResolveShortcut ( string filename )
{
if ( string . IsNullOrEmpty ( filename ) )
{
throw new ArgumentNullException ( "filename" ) ;
}
var extension = Path . GetExtension ( filename ) ;
var handler = _shortcutHandlers . FirstOrDefault ( i = > string . Equals ( extension , i . Extension , StringComparison . OrdinalIgnoreCase ) ) ;
if ( handler ! = null )
{
return handler . Resolve ( filename ) ;
}
return null ;
}
/// <summary>
/// Creates the shortcut.
/// </summary>
/// <param name="shortcutPath">The shortcut path.</param>
/// <param name="target">The target.</param>
/// <exception cref="System.ArgumentNullException">
/// shortcutPath
/// or
/// target
/// </exception>
public void CreateShortcut ( string shortcutPath , string target )
{
if ( string . IsNullOrEmpty ( shortcutPath ) )
{
throw new ArgumentNullException ( "shortcutPath" ) ;
}
if ( string . IsNullOrEmpty ( target ) )
{
throw new ArgumentNullException ( "target" ) ;
}
var extension = Path . GetExtension ( shortcutPath ) ;
var handler = _shortcutHandlers . FirstOrDefault ( i = > string . Equals ( extension , i . Extension , StringComparison . OrdinalIgnoreCase ) ) ;
if ( handler ! = null )
{
handler . Create ( shortcutPath , target ) ;
}
else
{
throw new NotImplementedException ( ) ;
}
}
/// <summary>
/// Returns a <see cref="FileSystemMetadata"/> object for the specified file or directory path.
/// </summary>
/// <param name="path">A path to a file or directory.</param>
/// <returns>A <see cref="FileSystemMetadata"/> object.</returns>
/// <remarks>If the specified path points to a directory, the returned <see cref="FileSystemMetadata"/> object's
/// <see cref="FileSystemMetadata.IsDirectory"/> property will be set to true and all other properties will reflect the properties of the directory.</remarks>
public FileSystemMetadata GetFileSystemInfo ( string path )
{
if ( string . IsNullOrEmpty ( path ) )
{
throw new ArgumentNullException ( "path" ) ;
}
// Take a guess to try and avoid two file system hits, but we'll double-check by calling Exists
if ( Path . HasExtension ( path ) )
{
var fileInfo = new FileInfo ( path ) ;
if ( fileInfo . Exists )
{
return GetFileSystemMetadata ( fileInfo ) ;
}
return GetFileSystemMetadata ( new DirectoryInfo ( path ) ) ;
}
else
{
var fileInfo = new DirectoryInfo ( path ) ;
if ( fileInfo . Exists )
{
return GetFileSystemMetadata ( fileInfo ) ;
}
return GetFileSystemMetadata ( new FileInfo ( path ) ) ;
}
}
/// <summary>
/// Returns a <see cref="FileSystemMetadata"/> object for the specified file path.
/// </summary>
/// <param name="path">A path to a file.</param>
/// <returns>A <see cref="FileSystemMetadata"/> object.</returns>
/// <remarks><para>If the specified path points to a directory, the returned <see cref="FileSystemMetadata"/> object's
/// <see cref="FileSystemMetadata.IsDirectory"/> property and the <see cref="FileSystemMetadata.Exists"/> property will both be set to false.</para>
/// <para>For automatic handling of files <b>and</b> directories, use <see cref="GetFileSystemInfo"/>.</para></remarks>
public FileSystemMetadata GetFileInfo ( string path )
{
if ( string . IsNullOrEmpty ( path ) )
{
throw new ArgumentNullException ( "path" ) ;
}
var fileInfo = new FileInfo ( path ) ;
return GetFileSystemMetadata ( fileInfo ) ;
}
/// <summary>
/// Returns a <see cref="FileSystemMetadata"/> object for the specified directory path.
/// </summary>
/// <param name="path">A path to a directory.</param>
/// <returns>A <see cref="FileSystemMetadata"/> object.</returns>
/// <remarks><para>If the specified path points to a file, the returned <see cref="FileSystemMetadata"/> object's
/// <see cref="FileSystemMetadata.IsDirectory"/> property will be set to true and the <see cref="FileSystemMetadata.Exists"/> property will be set to false.</para>
/// <para>For automatic handling of files <b>and</b> directories, use <see cref="GetFileSystemInfo"/>.</para></remarks>
public FileSystemMetadata GetDirectoryInfo ( string path )
{
if ( string . IsNullOrEmpty ( path ) )
{
throw new ArgumentNullException ( "path" ) ;
}
var fileInfo = new DirectoryInfo ( path ) ;
return GetFileSystemMetadata ( fileInfo ) ;
}
private FileSystemMetadata GetFileSystemMetadata ( FileSystemInfo info )
{
var result = new FileSystemMetadata ( ) ;
result . Exists = info . Exists ;
result . FullName = info . FullName ;
result . Extension = info . Extension ;
result . Name = info . Name ;
if ( result . Exists )
{
var attributes = info . Attributes ;
result . IsDirectory = info is DirectoryInfo | | ( attributes & FileAttributes . Directory ) = = FileAttributes . Directory ;
result . IsHidden = ( attributes & FileAttributes . Hidden ) = = FileAttributes . Hidden ;
result . IsReadOnly = ( attributes & FileAttributes . ReadOnly ) = = FileAttributes . ReadOnly ;
var fileInfo = info as FileInfo ;
if ( fileInfo ! = null )
{
result . Length = fileInfo . Length ;
result . DirectoryName = fileInfo . DirectoryName ;
}
result . CreationTimeUtc = GetCreationTimeUtc ( info ) ;
result . LastWriteTimeUtc = GetLastWriteTimeUtc ( info ) ;
}
else
{
result . IsDirectory = info is DirectoryInfo ;
}
return result ;
}
/// <summary>
/// The space char
/// </summary>
private const char SpaceChar = ' ' ;
/// <summary>
/// Takes a filename and removes invalid characters
/// </summary>
/// <param name="filename">The filename.</param>
/// <returns>System.String.</returns>
/// <exception cref="System.ArgumentNullException">filename</exception>
public string GetValidFilename ( string filename )
{
if ( string . IsNullOrEmpty ( filename ) )
{
throw new ArgumentNullException ( "filename" ) ;
}
var builder = new StringBuilder ( filename ) ;
foreach ( var c in _invalidFileNameChars )
{
builder = builder . Replace ( c , SpaceChar ) ;
}
return builder . ToString ( ) ;
}
/// <summary>
/// Gets the creation time UTC.
/// </summary>
/// <param name="info">The info.</param>
/// <returns>DateTime.</returns>
public DateTime GetCreationTimeUtc ( FileSystemInfo info )
{
// This could throw an error on some file systems that have dates out of range
try
{
return info . CreationTimeUtc ;
}
catch ( Exception ex )
{
Logger . ErrorException ( "Error determining CreationTimeUtc for {0}" , ex , info . FullName ) ;
return DateTime . MinValue ;
}
}
/// <summary>
/// Gets the creation time UTC.
/// </summary>
/// <param name="path">The path.</param>
/// <returns>DateTime.</returns>
public DateTime GetCreationTimeUtc ( string path )
{
return GetCreationTimeUtc ( GetFileSystemInfo ( path ) ) ;
}
public DateTime GetCreationTimeUtc ( FileSystemMetadata info )
{
return info . CreationTimeUtc ;
}
public DateTime GetLastWriteTimeUtc ( FileSystemMetadata info )
{
return info . LastWriteTimeUtc ;
}
/// <summary>
/// Gets the creation time UTC.
/// </summary>
/// <param name="info">The info.</param>
/// <returns>DateTime.</returns>
public DateTime GetLastWriteTimeUtc ( FileSystemInfo info )
{
// This could throw an error on some file systems that have dates out of range
try
{
return info . LastWriteTimeUtc ;
}
catch ( Exception ex )
{
Logger . ErrorException ( "Error determining LastAccessTimeUtc for {0}" , ex , info . FullName ) ;
return DateTime . MinValue ;
}
}
/// <summary>
/// Gets the last write time UTC.
/// </summary>
/// <param name="path">The path.</param>
/// <returns>DateTime.</returns>
public DateTime GetLastWriteTimeUtc ( string path )
{
return GetLastWriteTimeUtc ( GetFileSystemInfo ( path ) ) ;
}
/// <summary>
/// Gets the file stream.
/// </summary>
/// <param name="path">The path.</param>
/// <param name="mode">The mode.</param>
/// <param name="access">The access.</param>
/// <param name="share">The share.</param>
/// <param name="isAsync">if set to <c>true</c> [is asynchronous].</param>
/// <returns>FileStream.</returns>
public Stream GetFileStream ( string path , FileOpenMode mode , FileAccessMode access , FileShareMode share , bool isAsync = false )
{
if ( _supportsAsyncFileStreams & & isAsync )
{
return new FileStream ( path , GetFileMode ( mode ) , GetFileAccess ( access ) , GetFileShare ( share ) , 262144 , true ) ;
}
return new FileStream ( path , GetFileMode ( mode ) , GetFileAccess ( access ) , GetFileShare ( share ) , 262144 ) ;
}
private FileMode GetFileMode ( FileOpenMode mode )
{
switch ( mode )
{
case FileOpenMode . Append :
return FileMode . Append ;
case FileOpenMode . Create :
return FileMode . Create ;
case FileOpenMode . CreateNew :
return FileMode . CreateNew ;
case FileOpenMode . Open :
return FileMode . Open ;
case FileOpenMode . OpenOrCreate :
return FileMode . OpenOrCreate ;
case FileOpenMode . Truncate :
return FileMode . Truncate ;
default :
throw new Exception ( "Unrecognized FileOpenMode" ) ;
}
}
private FileAccess GetFileAccess ( FileAccessMode mode )
{
2016-11-27 14:36:56 -05:00
switch ( mode )
{
case FileAccessMode . ReadWrite :
return FileAccess . ReadWrite ;
case FileAccessMode . Write :
return FileAccess . Write ;
case FileAccessMode . Read :
return FileAccess . Read ;
default :
throw new Exception ( "Unrecognized FileAccessMode" ) ;
}
2016-10-29 01:40:15 -04:00
}
private FileShare GetFileShare ( FileShareMode mode )
{
2016-11-27 14:36:56 -05:00
switch ( mode )
{
case FileShareMode . ReadWrite :
return FileShare . ReadWrite ;
case FileShareMode . Write :
return FileShare . Write ;
case FileShareMode . Read :
return FileShare . Read ;
case FileShareMode . None :
return FileShare . None ;
default :
throw new Exception ( "Unrecognized FileShareMode" ) ;
}
2016-10-29 01:40:15 -04:00
}
public void SetHidden ( string path , bool isHidden )
{
var info = GetFileInfo ( path ) ;
if ( info . Exists & & info . IsHidden ! = isHidden )
{
if ( isHidden )
{
2016-10-31 00:28:23 -04:00
File . SetAttributes ( path , File . GetAttributes ( path ) | FileAttributes . Hidden ) ;
2016-10-29 01:40:15 -04:00
}
else
{
2016-10-31 00:28:23 -04:00
FileAttributes attributes = File . GetAttributes ( path ) ;
attributes = RemoveAttribute ( attributes , FileAttributes . Hidden ) ;
File . SetAttributes ( path , attributes ) ;
2016-10-29 01:40:15 -04:00
}
}
}
2016-11-09 12:24:57 -05:00
public void SetReadOnly ( string path , bool isReadOnly )
{
var info = GetFileInfo ( path ) ;
if ( info . Exists & & info . IsReadOnly ! = isReadOnly )
{
if ( isReadOnly )
{
File . SetAttributes ( path , File . GetAttributes ( path ) | FileAttributes . ReadOnly ) ;
}
else
{
FileAttributes attributes = File . GetAttributes ( path ) ;
attributes = RemoveAttribute ( attributes , FileAttributes . ReadOnly ) ;
File . SetAttributes ( path , attributes ) ;
}
}
}
2016-10-29 01:40:15 -04:00
private static FileAttributes RemoveAttribute ( FileAttributes attributes , FileAttributes attributesToRemove )
{
return attributes & ~ attributesToRemove ;
}
/// <summary>
/// Swaps the files.
/// </summary>
/// <param name="file1">The file1.</param>
/// <param name="file2">The file2.</param>
public void SwapFiles ( string file1 , string file2 )
{
if ( string . IsNullOrEmpty ( file1 ) )
{
throw new ArgumentNullException ( "file1" ) ;
}
if ( string . IsNullOrEmpty ( file2 ) )
{
throw new ArgumentNullException ( "file2" ) ;
}
2017-01-23 16:51:23 -05:00
var temp1 = Path . Combine ( _tempPath , Guid . NewGuid ( ) . ToString ( "N" ) ) ;
2016-10-29 01:40:15 -04:00
// Copying over will fail against hidden files
2016-12-27 02:25:51 -05:00
SetHidden ( file1 , false ) ;
SetHidden ( file2 , false ) ;
2016-10-29 01:40:15 -04:00
2017-01-23 16:51:23 -05:00
Directory . CreateDirectory ( _tempPath ) ;
2016-10-29 01:40:15 -04:00
CopyFile ( file1 , temp1 , true ) ;
2016-12-17 15:52:05 -05:00
CopyFile ( file2 , file1 , true ) ;
2016-10-29 01:40:15 -04:00
CopyFile ( temp1 , file2 , true ) ;
}
2017-01-11 12:56:26 -05:00
public bool AreEqual ( string path1 , string path2 )
{
if ( path1 = = null & & path2 = = null )
{
return true ;
}
if ( path1 = = null | | path2 = = null )
{
return false ;
}
path1 = path1 . TrimEnd ( DirectorySeparatorChar ) ;
path2 = path2 . TrimEnd ( DirectorySeparatorChar ) ;
return string . Equals ( path1 , path2 , StringComparison . OrdinalIgnoreCase ) ;
}
2016-10-29 01:40:15 -04:00
public bool ContainsSubPath ( string parentPath , string path )
{
if ( string . IsNullOrEmpty ( parentPath ) )
{
throw new ArgumentNullException ( "parentPath" ) ;
}
if ( string . IsNullOrEmpty ( path ) )
{
throw new ArgumentNullException ( "path" ) ;
}
return path . IndexOf ( parentPath . TrimEnd ( Path . DirectorySeparatorChar ) + Path . DirectorySeparatorChar , StringComparison . OrdinalIgnoreCase ) ! = - 1 ;
}
public bool IsRootPath ( string path )
{
if ( string . IsNullOrEmpty ( path ) )
{
throw new ArgumentNullException ( "path" ) ;
}
var parent = Path . GetDirectoryName ( path ) ;
if ( ! string . IsNullOrEmpty ( parent ) )
{
return false ;
}
return true ;
}
public string NormalizePath ( string path )
{
if ( string . IsNullOrEmpty ( path ) )
{
throw new ArgumentNullException ( "path" ) ;
}
if ( path . EndsWith ( ":\\" , StringComparison . OrdinalIgnoreCase ) )
{
return path ;
}
return path . TrimEnd ( Path . DirectorySeparatorChar ) ;
}
public string GetFileNameWithoutExtension ( FileSystemMetadata info )
{
if ( info . IsDirectory )
{
return info . Name ;
}
return Path . GetFileNameWithoutExtension ( info . FullName ) ;
}
public string GetFileNameWithoutExtension ( string path )
{
return Path . GetFileNameWithoutExtension ( path ) ;
}
public bool IsPathFile ( string path )
{
if ( string . IsNullOrWhiteSpace ( path ) )
{
throw new ArgumentNullException ( "path" ) ;
}
// Cannot use Path.IsPathRooted because it returns false under mono when using windows-based paths, e.g. C:\\
if ( path . IndexOf ( "://" , StringComparison . OrdinalIgnoreCase ) ! = - 1 & &
! path . StartsWith ( "file://" , StringComparison . OrdinalIgnoreCase ) )
{
return false ;
}
return true ;
//return Path.IsPathRooted(path);
}
public void DeleteFile ( string path )
{
2016-11-09 12:24:57 -05:00
var fileInfo = GetFileInfo ( path ) ;
if ( fileInfo . Exists )
{
if ( fileInfo . IsHidden )
{
SetHidden ( path , false ) ;
}
if ( fileInfo . IsReadOnly )
{
SetReadOnly ( path , false ) ;
}
}
2016-10-29 01:40:15 -04:00
File . Delete ( path ) ;
}
public void DeleteDirectory ( string path , bool recursive )
{
Directory . Delete ( path , recursive ) ;
}
public void CreateDirectory ( string path )
{
Directory . CreateDirectory ( path ) ;
}
2016-10-31 23:07:45 -04:00
public List < FileSystemMetadata > GetDrives ( )
{
// Only include drives in the ready state or this method could end up being very slow, waiting for drives to timeout
return DriveInfo . GetDrives ( ) . Where ( d = > d . IsReady ) . Select ( d = > new FileSystemMetadata
{
Name = GetName ( d ) ,
FullName = d . RootDirectory . FullName ,
IsDirectory = true
} ) . ToList ( ) ;
}
private string GetName ( DriveInfo drive )
{
return drive . Name ;
}
2016-10-29 01:40:15 -04:00
public IEnumerable < FileSystemMetadata > GetDirectories ( string path , bool recursive = false )
{
var searchOption = recursive ? SearchOption . AllDirectories : SearchOption . TopDirectoryOnly ;
2017-03-29 02:26:48 -04:00
return ToMetadata ( new DirectoryInfo ( path ) . EnumerateDirectories ( "*" , searchOption ) ) ;
2016-10-29 01:40:15 -04:00
}
public IEnumerable < FileSystemMetadata > GetFiles ( string path , bool recursive = false )
2017-03-29 02:26:48 -04:00
{
return GetFiles ( path , null , true , recursive ) ;
}
public IEnumerable < FileSystemMetadata > GetFiles ( string path , string [ ] extensions , bool enableCaseSensitiveExtensions , bool recursive = false )
2016-10-29 01:40:15 -04:00
{
var searchOption = recursive ? SearchOption . AllDirectories : SearchOption . TopDirectoryOnly ;
2017-03-29 02:26:48 -04:00
// On linux and osx the search pattern is case sensitive
// If we're OK with case-sensitivity, and we're only filtering for one extension, then use the native method
if ( enableCaseSensitiveExtensions & & extensions ! = null & & extensions . Length = = 1 )
{
return ToMetadata ( new DirectoryInfo ( path ) . EnumerateFiles ( "*" + extensions [ 0 ] , searchOption ) ) ;
}
var files = new DirectoryInfo ( path ) . EnumerateFiles ( "*" , searchOption ) ;
if ( extensions ! = null & & extensions . Length > 0 )
{
files = files . Where ( i = >
{
var ext = i . Extension ;
if ( ext = = null )
{
return false ;
}
return extensions . Contains ( ext , StringComparer . OrdinalIgnoreCase ) ;
} ) ;
}
return ToMetadata ( files ) ;
2016-10-29 01:40:15 -04:00
}
public IEnumerable < FileSystemMetadata > GetFileSystemEntries ( string path , bool recursive = false )
{
var directoryInfo = new DirectoryInfo ( path ) ;
var searchOption = recursive ? SearchOption . AllDirectories : SearchOption . TopDirectoryOnly ;
if ( EnableFileSystemRequestConcat )
{
2017-03-29 02:26:48 -04:00
return ToMetadata ( directoryInfo . EnumerateDirectories ( "*" , searchOption ) )
. Concat ( ToMetadata ( directoryInfo . EnumerateFiles ( "*" , searchOption ) ) ) ;
2016-10-29 01:40:15 -04:00
}
2017-03-29 02:26:48 -04:00
return ToMetadata ( directoryInfo . EnumerateFileSystemInfos ( "*" , searchOption ) ) ;
2016-10-29 01:40:15 -04:00
}
2017-03-29 02:26:48 -04:00
private IEnumerable < FileSystemMetadata > ToMetadata ( IEnumerable < FileSystemInfo > infos )
2016-10-29 01:40:15 -04:00
{
2017-01-23 16:51:23 -05:00
return infos . Select ( GetFileSystemMetadata ) ;
2016-10-29 01:40:15 -04:00
}
2016-11-04 04:43:59 -04:00
public string [ ] ReadAllLines ( string path )
{
return File . ReadAllLines ( path ) ;
}
public void WriteAllLines ( string path , IEnumerable < string > lines )
{
File . WriteAllLines ( path , lines ) ;
}
2016-10-29 01:40:15 -04:00
public Stream OpenRead ( string path )
{
return File . OpenRead ( path ) ;
}
public void CopyFile ( string source , string target , bool overwrite )
{
File . Copy ( source , target , overwrite ) ;
}
public void MoveFile ( string source , string target )
{
File . Move ( source , target ) ;
}
public void MoveDirectory ( string source , string target )
{
Directory . Move ( source , target ) ;
}
public bool DirectoryExists ( string path )
{
return Directory . Exists ( path ) ;
}
public bool FileExists ( string path )
{
return File . Exists ( path ) ;
}
public string ReadAllText ( string path )
{
return File . ReadAllText ( path ) ;
}
public byte [ ] ReadAllBytes ( string path )
{
return File . ReadAllBytes ( path ) ;
}
public void WriteAllText ( string path , string text , Encoding encoding )
{
File . WriteAllText ( path , text , encoding ) ;
}
public void WriteAllText ( string path , string text )
{
File . WriteAllText ( path , text ) ;
}
public void WriteAllBytes ( string path , byte [ ] bytes )
{
File . WriteAllBytes ( path , bytes ) ;
}
public string ReadAllText ( string path , Encoding encoding )
{
return File . ReadAllText ( path , encoding ) ;
}
public IEnumerable < string > GetDirectoryPaths ( string path , bool recursive = false )
{
var searchOption = recursive ? SearchOption . AllDirectories : SearchOption . TopDirectoryOnly ;
return Directory . EnumerateDirectories ( path , "*" , searchOption ) ;
}
public IEnumerable < string > GetFilePaths ( string path , bool recursive = false )
{
var searchOption = recursive ? SearchOption . AllDirectories : SearchOption . TopDirectoryOnly ;
return Directory . EnumerateFiles ( path , "*" , searchOption ) ;
}
public IEnumerable < string > GetFileSystemEntryPaths ( string path , bool recursive = false )
{
var searchOption = recursive ? SearchOption . AllDirectories : SearchOption . TopDirectoryOnly ;
return Directory . EnumerateFileSystemEntries ( path , "*" , searchOption ) ;
}
2016-11-11 02:24:36 -05:00
public virtual void SetExecutable ( string path )
{
2017-03-29 02:26:48 -04:00
2016-11-11 02:24:36 -05:00
}
2016-10-29 01:40:15 -04:00
}
}