public MatrixTestCase(FileShare PreviousShare, FileAccess RequestedAccess, FileShare RequestedShare, bool ExpectSuccess)
{
previousShare = PreviousShare;
requestedAccess = RequestedAccess;
requestedShare = RequestedShare;
expectSuccess = ExpectSuccess;
}
public virtual TextReader GetReader(out Encoding encoding, FileShare sharing)
{
string encodingName;
StreamReader reader;
var stream = this.GetInputStream(out encodingName, sharing);
if (encodingName == null)
{
reader = new StreamReader(stream);
}
else
{
var enc = Encoding.GetEncoding(encodingName);
if (enc != null)
{
reader = new StreamReader(stream, enc);
}
else
{
reader = new StreamReader(stream);
}
}
encoding = reader.CurrentEncoding;
return reader;
}
public FileStream(String path, FileMode mode,
FileAccess access, FileShare share,
int bufferSize)
: this(path, mode, access, share, bufferSize, false)
{
// Nothing to do here.
}
public override Stream OpenInputFileStream(string path, FileMode mode, FileAccess access, FileShare share)
{
if (mode != FileMode.Open || access != FileAccess.Read) {
throw new IOException("can only read files from the XAP");
}
return OpenInputFileStream(path);
}
public static void Lock(string path, int millisecondsTimeout, Action<FileStream> action,
FileMode mode, FileAccess access, FileShare share)
{
var log = Program.Log;
var autoResetEvent = new AutoResetEvent(false);
const string pattern = "Lock('{0}', {1}, {2}, {3}, {4})";
string msg = string.Format(pattern, path, millisecondsTimeout, mode, access, share);
log.Trace(msg);
while (true)
{
try
{
using (var stream = File.Open(path, mode, access, share))
{
const string pattern2 = "Access to file: {0}, {1}, {2}, {3}";
string msg2 = string.Format(pattern2, path, mode, access, share);
log.Trace(msg2);
action(stream);
break;
}
}
catch (IOException exc)
{
const string pattern3 = "Cannot access to file: {0}";
string msg3 = string.Format(pattern3, path);
log.TraceException(msg3, exc);
AutoResetFileSystemWatcher(path, millisecondsTimeout, autoResetEvent);
}
}
}
public SeqFileStreamReader(string fn, FileMode mode, FileAccess access, FileShare share, int bufferSize)
: base(fn, mode, access, share, bufferSize)
{
curfilename = fn;
bufsz = bufferSize;
_init();
}
public IsolatedStorageFileStream(String path, FileMode mode,
FileAccess access, FileShare share,
int bufferSize)
: this(path, mode, access, share, bufferSize, null)
{
// Nothing to do here.
}
public int CreateFile(string filename, FileAccess access, FileShare share, FileMode mode, FileOptions options, DokanFileInfo info)
{
Trace.WriteLine(string.Format("CreateFile FILENAME({0}) ACCESS({1}) SHARE({2}) MODE({3})", filename, access, share, mode));
if (mode == FileMode.Create || mode == FileMode.OpenOrCreate || mode == FileMode.CreateNew)
{
// we want to write a file
var fileRef = Extensions.GetFileReference(root, filename.ToFileString());
fileRef.Create(0);
return 0;
}
if (share == FileShare.Delete)
{
return DeleteFile(filename, info);
}
if (GetFileInformation(filename, new FileInformation(), new DokanFileInfo(0)) == 0)
{
return 0;
}
else
{
return -DokanNet.ERROR_FILE_NOT_FOUND;
}
}
public int CreateFile(String filename, FileAccess access, FileShare share,
FileMode mode, FileOptions options, DokanFileInfo info)
{
string path = GetPath(filename);
try
{
if (Directory.Exists(path))
{
info.IsDirectory = true;
}
else
{
FileStream fs = new FileStream(path, mode, access, share, 8, options);
fs.Close();
}
//Console.WriteLine("Create file: {0}\t access: {1}", filename, access);
return DokanNet.DOKAN_SUCCESS;
}
catch (Exception e)
{
return -DokanNet.DOKAN_ERROR;
}
}
private SafeFileHandle OpenHandle(FileMode mode, FileShare share, FileOptions options)
{
// FileStream performs most of the general argument validation. We can assume here that the arguments
// are all checked and consistent (e.g. non-null-or-empty path; valid enums in mode, access, share, and options; etc.)
// Store the arguments
_mode = mode;
_options = options;
if (_useAsyncIO)
_asyncState = new AsyncState();
// Translate the arguments into arguments for an open call.
Interop.Sys.OpenFlags openFlags = PreOpenConfigurationFromOptions(mode, _access, options); // FileShare currently ignored
// If the file gets created a new, we'll select the permissions for it. Most Unix utilities by default use 666 (read and
// write for all), so we do the same (even though this doesn't match Windows, where by default it's possible to write out
// a file and then execute it). No matter what we choose, it'll be subject to the umask applied by the system, such that the
// actual permissions will typically be less than what we select here.
const Interop.Sys.Permissions OpenPermissions =
Interop.Sys.Permissions.S_IRUSR | Interop.Sys.Permissions.S_IWUSR |
Interop.Sys.Permissions.S_IRGRP | Interop.Sys.Permissions.S_IWGRP |
Interop.Sys.Permissions.S_IROTH | Interop.Sys.Permissions.S_IWOTH;
// Open the file and store the safe handle.
return SafeFileHandle.Open(_path, openFlags, (int)OpenPermissions);
}
private static extern SafeFileHandle CreateFile(string filename,
FileAccess desiredAccess,
FileShare shareMode,
IntPtr attributes,
FileMode creationDisposition,
uint flagsAndAttributes = 0,
IntPtr templateFile = default(IntPtr));
public Stream FileOpen(string filePath, FileMode fileMode, FileAccess fileAccess, FileShare fileShare)
{
#if WINDOWS_STORE_APP
var folder = ApplicationData.Current.LocalFolder;
if (fileMode == FileMode.Create || fileMode == FileMode.CreateNew)
{
return folder.OpenStreamForWriteAsync(filePath, CreationCollisionOption.ReplaceExisting).GetAwaiter().GetResult();
}
else if (fileMode == FileMode.OpenOrCreate)
{
if (fileAccess == FileAccess.Read)
return folder.OpenStreamForReadAsync(filePath).GetAwaiter().GetResult();
else
{
// Not using OpenStreamForReadAsync because the stream position is placed at the end of the file, instead of the beginning
var f = folder.CreateFileAsync(filePath, CreationCollisionOption.OpenIfExists).AsTask().GetAwaiter().GetResult();
return f.OpenAsync(FileAccessMode.ReadWrite).AsTask().GetAwaiter().GetResult().AsStream();
}
}
else if (fileMode == FileMode.Truncate)
{
return folder.OpenStreamForWriteAsync(filePath, CreationCollisionOption.ReplaceExisting).GetAwaiter().GetResult();
}
else
{
//if (fileMode == FileMode.Append)
// Not using OpenStreamForReadAsync because the stream position is placed at the end of the file, instead of the beginning
folder.CreateFileAsync(filePath, CreationCollisionOption.OpenIfExists).AsTask().GetAwaiter().GetResult().OpenAsync(FileAccessMode.ReadWrite).AsTask().GetAwaiter().GetResult().AsStream();
var f = folder.CreateFileAsync(filePath, CreationCollisionOption.OpenIfExists).AsTask().GetAwaiter().GetResult();
return f.OpenAsync(FileAccessMode.ReadWrite).AsTask().GetAwaiter().GetResult().AsStream();
}
#else
return File.Open(filePath, fileMode, fileAccess, fileShare);
#endif
}
/// <summary>
/// File might be locked when attempting to open it. This will attempt to open the file the number of times specified by <paramref name="retry"/>
/// </summary>
/// <param name="filePath">The file to attempt to get a file stream for</param>
/// <param name="retry">The number of times a file open should be attempted</param>
/// <param name="fileMode">The file mode to use</param>
/// <param name="fileAccess">The file access to use</param>
/// <param name="fileShare">The file sharing to use</param>
/// <returns>A file stream of the file</returns>
/// <remarks>
/// It attempt to open the file in increasingly longer periods and throw an exception if it cannot open it within the
/// specified number of retries.
/// </remarks>
public Stream OpenFileStream(string filePath, int retry, FileMode fileMode, FileAccess fileAccess, FileShare fileShare)
{
var delay = 0;
for(var i = 0; i < retry; i++)
{
try
{
var stream = new FileStream(filePath, fileMode, fileAccess, fileShare);
return stream;
}
catch(DirectoryNotFoundException)
{
CreateDirectoryStructure(filePath);
}
catch(FileNotFoundException)
{
throw;
}
catch(IOException)
{
delay += 100;
if(i == retry) throw;
}
Thread.Sleep(delay);
}
//We will never get here
throw new IOException(string.Format("Unable to open file '{0}'", filePath));
}
public static Stream CreateFile(
string fileName, FileAccess fileAccess, FileShare fileShare, FileMode fileMode, FileAttributes flags)
{
// TODO: This is not quite right, but it's close.
//
var nativeAccess = fileAccess;
if ((nativeAccess & FileAccess.Read) != 0)
{
nativeAccess &= ~FileAccess.Read;
nativeAccess |= (FileAccess)GENERIC_READ;
}
if ((nativeAccess & FileAccess.Write) != 0)
{
nativeAccess &= ~FileAccess.Write;
nativeAccess |= (FileAccess)GENERIC_WRITE;
}
var handle = _CreateFile(fileName, nativeAccess, fileShare, IntPtr.Zero, fileMode, flags, IntPtr.Zero);
if (handle.IsInvalid)
{
Marshal.ThrowExceptionForHR(Marshal.GetHRForLastWin32Error());
}
return new SimpleFileStream(handle);
}
/// <summary>
/// Opens a <see cref="FileStream"/>
/// </summary>
/// <param name="pathInfo">The file to open. </param>
/// <param name="mode"><see cref="FileMode"/> </param>
/// <param name="access"><see cref="FileAccess"/></param>
/// <param name="share"><see cref="FileShare"/></param>
/// <returns><see cref="FileStream"/></returns>
/// <remarks>http://msdn.microsoft.com/en-us/library/y973b725(v=vs.110).aspx</remarks>
public static FileStream Open( QuickIOPathInfo pathInfo, FileMode mode, FileAccess access, FileShare share )
{
Contract.Requires( pathInfo != null );
Contract.Ensures( Contract.Result<FileStream>() != null );
return OpenFileStream( pathInfo.FullNameUnc, access, mode, share );
}
static internal string ToString(string path, FileMode mode, FileAccess access, FileShare share)
{
// http://ee.php.net/fopen
//'r' Open for reading only; place the file pointer at the beginning of the file.
//'r+' Open for reading and writing; place the file pointer at the beginning of the file.
//'w' Open for writing only; place the file pointer at the beginning of the file and truncate the file to zero length. If the file does not exist, attempt to create it.
//'w+' Open for reading and writing; place the file pointer at the beginning of the file and truncate the file to zero length. If the file does not exist, attempt to create it.
//'a' Open for writing only; place the file pointer at the end of the file. If the file does not exist, attempt to create it.
//'a+' Open for reading and writing; place the file pointer at the end of the file. If the file does not exist, attempt to create it.
//'x' Create and open for writing only; place the file pointer at the beginning of the file. If the file already exists, the fopen() call will fail by returning FALSE and generating an error of level E_WARNING. If the file does not exist, attempt to create it. This is equivalent to specifying O_EXCL|O_CREAT flags for the underlying open(2) system call.
//'x+' Create and open for reading and writing; place the file pointer at the beginning of the file. If the file already exists, the fopen() call will fail by returning FALSE and generating an error of level E_WARNING. If the file does not exist, attempt to create it. This is equivalent to specifying O_EXCL|O_CREAT flags for the underlying open(2) system call.
if (mode == FileMode.OpenOrCreate)
{
if (access == FileAccess.Write)
{
if (File.Exists(path))
return "r+b";
else
return "x+b";
}
if (access == FileAccess.Read)
{
if (File.Exists(path))
return "rb";
else
return "xb";
}
}
var e = new { mode, access, share };
throw new NotImplementedException(e.ToString());
}
/// <summary>
/// Opens a <see cref="FileStream"/>
/// </summary>
/// <param name="path">The file to open. </param>
/// <param name="mode"><see cref="FileMode"/></param>
/// <param name="access"><see cref="FileAccess"/></param>
/// <param name="share"><see cref="FileShare"/> </param>
/// <returns>A <see cref="FileStream"/></returns>
/// <remarks>http://msdn.microsoft.com/en-us/library/y973b725(v=vs.110).aspx</remarks>
public static FileStream Open( string path, FileMode mode, FileAccess access, FileShare share )
{
Contract.Requires( !String.IsNullOrWhiteSpace( path ) );
Contract.Ensures( Contract.Result<FileStream>() != null );
return OpenFileStream( path, access, mode, share );
}
internal LogStream(string path, int bufferSize, LogRetentionOption retention, long maxFileSize, int maxNumOfFiles)
{
string fullPath = Path.GetFullPath(path);
this._fileName = fullPath;
if (fullPath.StartsWith(@"\\.\", StringComparison.Ordinal))
{
throw new NotSupportedException(System.SR.GetString("NotSupported_IONonFileDevices"));
}
Microsoft.Win32.UnsafeNativeMethods.SECURITY_ATTRIBUTES secAttrs = GetSecAttrs(FileShare.Read);
int num = 0x100000;
this._canWrite = true;
this._pathSav = fullPath;
this._fAccessSav = 0x40000000;
this._shareSav = FileShare.Read;
this._secAttrsSav = secAttrs;
this._secAccessSav = FileIOPermissionAccess.Write;
this._modeSav = (retention != LogRetentionOption.SingleFileUnboundedSize) ? FileMode.Create : FileMode.OpenOrCreate;
this._flagsAndAttributesSav = num;
this._seekToEndSav = retention == LogRetentionOption.SingleFileUnboundedSize;
base.bufferSize = bufferSize;
this._retention = retention;
this._maxFileSize = maxFileSize;
this._maxNumberOfFiles = maxNumOfFiles;
this._Init(fullPath, this._fAccessSav, this._shareSav, this._secAttrsSav, this._secAccessSav, this._modeSav, this._flagsAndAttributesSav, this._seekToEndSav);
}
public override Stream OpenInputFileStream(string path, FileMode mode, FileAccess access, FileShare share)
{
//TODO: OpenInputFileStream with params
Stream st = null;
if (access == FileAccess.Read)
{
st = OpenInputFileStream(path);
if (st == null)
{
CRhoFile file = new CRhoFile();
file.open(path, CRhoFile.EOpenModes.OpenReadOnly);
st = file.getStream();
}
}
else
{
CRhoFile file = new CRhoFile();
file.open(path, CRhoFile.EOpenModes.OpenForReadWrite);
st = file.getStream();
}
return st;
}
/// <summary>
/// File might be locked when attempting to open it. This will attempt to open the file the number of times specified by <paramref name="retry"/>
/// </summary>
/// <param name="fileInfo">The file to attempt to get a file stream for</param>
/// <param name="retry">The number of times a file open should be attempted</param>
/// <param name="fileMode">The file mode to use</param>
/// <param name="fileAccess">The file access to use</param>
/// <param name="fileShare">The file sharing to use</param>
/// <returns>A file stream of the file</returns>
/// <remarks>
/// It attempt to open the file in increasingly longer periods and throw an exception if it cannot open it within the
/// specified number of retries.
/// </remarks>
public FileStream OpenFileStream(FileInfo fileInfo, int retry, FileMode fileMode, FileAccess fileAccess, FileShare fileShare)
{
var delay = 0;
for (var i = 0; i < retry; i++)
{
try
{
var stream = new FileStream(fileInfo.FullName, fileMode, fileAccess, fileShare);
return stream;
}
catch(FileNotFoundException)
{
throw;
}
catch (IOException)
{
delay += 100;
if (i == retry) throw;
}
Thread.Sleep(delay);
}
//We will never get here
throw new IOException("Unable to open file - " + fileInfo.FullName);
}
public IsolatedStorageFileStream(String path, FileMode mode,
FileAccess access, FileShare share,
IsolatedStorageFile sf)
: this(path, mode, access, share, BUFSIZ, sf)
{
// Nothing to do here.
}
private static extern IntPtr CreateFile(string fileName,
FILE_ACCESS_RIGHTS access,
FileShare share,
int securityAttributes,
FileMode creation,
FILE_FLAGS flags,
IntPtr templateFile);
/// <summary>
/// Check's if the file has the accessrights specified in the input parameters
/// </summary>
/// <param name="filename"></param>
/// <param name="fa">Read,Write,ReadWrite</param>
/// <param name="fs">Read,ReadWrite...</param>
/// <returns></returns>
public static void CheckFileAccessRights(string fileName, FileMode fm, FileAccess fa, FileShare fs)
{
FileStream fileStream = null;
StreamReader streamReader = null;
try
{
Encoding fileEncoding = Encoding.Default;
fileStream = File.Open(fileName, fm, fa, fs);
streamReader = new StreamReader(fileStream, fileEncoding, true);
}
finally
{
try
{
if (fileStream != null)
{
fileStream.Close();
fileStream.Dispose();
}
if (streamReader != null)
{
streamReader.Close();
streamReader.Dispose();
}
}
finally {}
}
}
public static extern SafeFileHandle CreateFile(String fileName,
FileAccess desiredAccess,
FileShare shareMode,
IntPtr securityAttrs,
FileMode creationDisposition,
int flagsAndAttributes,
IntPtr templateFile);
/// <summary>
/// Pass the file handle to the <see cref="System.IO.FileStream"/> constructor.
/// The <see cref="System.IO.FileStream"/> will close the handle.
/// </summary>
public static SafeFileHandle CreateFileHandle(
string filePath,
CreationDisposition creationDisposition,
FileAccess fileAccess,
FileShare fileShare)
{
filePath = CheckAddLongPathPrefix(filePath);
// Create a file with generic write access
var fileHandle =
PInvokeHelper.CreateFile(
filePath,
fileAccess,
fileShare,
IntPtr.Zero,
creationDisposition,
0,
IntPtr.Zero);
// Check for errors.
var lastWin32Error = Marshal.GetLastWin32Error();
if (fileHandle.IsInvalid)
{
throw new Win32Exception(
lastWin32Error,
string.Format(
"Error {0} creating file handle for file path '{1}': {2}",
lastWin32Error,
filePath,
CheckAddDotEnd(new Win32Exception(lastWin32Error).Message)));
}
// Pass the file handle to FileStream. FileStream will close the handle.
return fileHandle;
}
public static FileStream OpenSequentialStream(string path, FileMode mode, FileAccess access, FileShare share)
{
var options = FileOptions.SequentialScan;
if (concurrency > 0)
{
options |= FileOptions.Asynchronous;
}
#if MONO
return new FileStream( path, mode, access, share, bufferSize, options );
#else
if (unbuffered)
{
options |= NoBuffering;
}
else
{
return new FileStream(path, mode, access, share, bufferSize, options);
}
SafeFileHandle fileHandle = CreateFile(path, (int)access, share, IntPtr.Zero, mode, (int)options, IntPtr.Zero);
if (fileHandle.IsInvalid)
{
throw new IOException();
}
return new UnbufferedFileStream(fileHandle, access, bufferSize, (concurrency > 0));
#endif
}
private void Init(String path, FileMode mode, FileAccess access, FileShare share, int bufferSize, FileOptions options)
{
if (path == null)
throw new ArgumentNullException("path", SR.ArgumentNull_Path);
if (path.Length == 0)
throw new ArgumentException(SR.Argument_EmptyPath, "path");
// don't include inheritable in our bounds check for share
FileShare tempshare = share & ~FileShare.Inheritable;
String badArg = null;
if (mode < FileMode.CreateNew || mode > FileMode.Append)
badArg = "mode";
else if (access < FileAccess.Read || access > FileAccess.ReadWrite)
badArg = "access";
else if (tempshare < FileShare.None || tempshare > (FileShare.ReadWrite | FileShare.Delete))
badArg = "share";
if (badArg != null)
throw new ArgumentOutOfRangeException(badArg, SR.ArgumentOutOfRange_Enum);
// NOTE: any change to FileOptions enum needs to be matched here in the error validation
if (options != FileOptions.None && (options & ~(FileOptions.WriteThrough | FileOptions.Asynchronous | FileOptions.RandomAccess | FileOptions.DeleteOnClose | FileOptions.SequentialScan | FileOptions.Encrypted | (FileOptions)0x20000000 /* NoBuffering */)) != 0)
throw new ArgumentOutOfRangeException("options", SR.ArgumentOutOfRange_Enum);
if (bufferSize <= 0)
throw new ArgumentOutOfRangeException("bufferSize", SR.ArgumentOutOfRange_NeedPosNum);
// Write access validation
if ((access & FileAccess.Write) == 0)
{
if (mode == FileMode.Truncate || mode == FileMode.CreateNew || mode == FileMode.Create || mode == FileMode.Append)
{
// No write access
throw new ArgumentException(SR.Format(SR.Argument_InvalidFileModeAndAccessCombo, mode, access));
}
}
string fullPath = PathHelpers.GetFullPathInternal(path);
// Prevent access to your disk drives as raw block devices.
if (fullPath.StartsWith("\\\\.\\", StringComparison.Ordinal))
throw new ArgumentException(SR.Arg_DevicesNotSupported);
#if !PLATFORM_UNIX
// Check for additional invalid characters. Most invalid characters were checked above
// in our call to Path.GetFullPath(path);
if (HasAdditionalInvalidCharacters(fullPath))
throw new ArgumentException(SR.Argument_InvalidPathChars);
if (fullPath.IndexOf(':', 2) != -1)
throw new NotSupportedException(SR.Argument_PathFormatNotSupported);
#endif
if ((access & FileAccess.Read) != 0 && mode == FileMode.Append)
throw new ArgumentException(SR.Argument_InvalidAppendMode);
this._innerStream = FileSystem.Current.Open(fullPath, mode, access, share, bufferSize, options, this);
}
public DokanError CreateFile(string fileName, DokanNet.FileAccess access, FileShare share, FileMode mode, FileOptions options, FileAttributes attributes, DokanFileInfo info)
{
info.DeleteOnClose = (options & FileOptions.DeleteOnClose) != 0;
//Console.WriteLine("CreateFile: {0}, mode = {1}", fileName, mode);
if (fileName == "\\")
{
return DokanError.ErrorSuccess;
}
Directory dir = new Directory(Util.GetPathDirectory(fileName));
if (!dir.Exists())
{
return DokanError.ErrorPathNotFound;
}
String name = Util.GetPathFileName(fileName);
if (name.Length == 0)
{
return DokanError.ErrorInvalidName;
}
if (name.IndexOfAny(Path.GetInvalidFileNameChars()) > -1)
{
return DokanError.ErrorInvalidName;
}
// dokan API 要求在目标文件是目录时候，设置 info.IsDirectory = true
if (dir.Contains(name) && (dir.GetItemInfo(name).attribute & FileAttributes.Directory) != 0)
{
info.IsDirectory = true;
return DokanError.ErrorSuccess;
}
try
{
File f = new File(fileName, mode);
f.flagDeleteOnClose = info.DeleteOnClose;
info.Context = f;
}
catch (FileNotFoundException)
{
return DokanError.ErrorFileNotFound;
}
catch (IOException)
{
return DokanError.ErrorAlreadyExists;
}
catch (NotImplementedException)
{
return DokanError.ErrorAccessDenied;
}
catch (Exception)
{
return DokanError.ErrorError;
}
return DokanError.ErrorSuccess;
}
private static extern SafeFileHandle CreateFile( string lpFileName, int dwDesiredAccess, FileShare dwShareMode, IntPtr securityAttrs, FileMode dwCreationDisposition, int dwFlagsAndAttributes, IntPtr hTemplateFile);
// On NetFX FileStream has an internal no arg constructor that we utilize to provide the facade. We don't have access
// to internals in CoreFX so we'll do the next best thing and contort ourselves into the SafeFileHandle constructor.
// (A path constructor would try and create the requested file and give us two open handles.)
//
// We only expose our own nested FileStream so the base class having a handle doesn't matter. Passing a new SafeFileHandle
// with ownsHandle: false avoids the parent class closing without our knowledge.
private IsolatedStorageFileStream(string path, FileMode mode, FileAccess access, FileShare share, int bufferSize, InitialiationData initializationData)
: base(new SafeFileHandle(initializationData.NestedStream.SafeFileHandle.DangerousGetHandle(), ownsHandle: false), access, bufferSize)
{
_isf = initializationData.StorageFile;
_givenPath = path;
_fullPath = initializationData.FullPath;
_fs = initializationData.NestedStream;
}
public override Stream OpenInputFileStream(string path, FileMode mode, FileAccess access, FileShare share)
{
return(OpenInputFileStream(path));
}
public static RowKeysPairAnsi GetInstanceFromRowKeysAnsi(string rowKeysAnsiFileName, ParallelOptions parallelOptions, FileAccess fileAccess = FileAccess.Read, FileShare fileShare = FileShare.Read)
{
RowKeysPairAnsi rowKeysPairAnsi = new RowKeysPairAnsi();
rowKeysPairAnsi.GetInstanceFromRowKeysStructFileNameInternal(rowKeysAnsiFileName, parallelOptions, fileAccess, fileShare);
return(rowKeysPairAnsi);
}
public IFileStream Open(string path, FileMode mode, FileAccess?access = null, FileShare share = FileShare.None)
{
Guard.NotNull(path, nameof(path));
AssertPathIsNotEmpty(path);
AbsolutePath absolutePath = owner.ToAbsolutePath(path);
var handler = new FileOpenHandler(container);
var arguments = new FileOpenArguments(absolutePath, mode, access, FileOptions.None);
return(handler.Handle(arguments));
}
/// <summary>
/// 从TXT文件反序列化
/// </summary>
/// <param name="path">文件路径</param>
/// <param name="mode">指定操作系统打开文件的方式</param>
/// <param name="access">定义用于控制对文件的读访问、写访问或读/写访问的常数</param>
/// <param name="share">包含用于控制其他 System.IO.FileStream 对象对同一文件可以具有的访问类型的常数</param>
/// <returns></returns>
public static object DeserializationFromTxt(string path, FileMode mode, FileAccess access, FileShare share)
{
BinaryFormatter formatter = new BinaryFormatter();
FileStream readFileStream = new FileStream(path, mode, access, share);
object temp = (object)formatter.Deserialize(readFileStream);
readFileStream.Close();
return(temp);
}
public IsolatedStorageFileStream(string path, FileMode mode, FileAccess access, FileShare share, IsolatedStorageFile?isf)
: this(path, mode, access, share, DefaultBufferSize, isf)
{
}
public IsolatedStorageFileStream(string path, FileMode mode, FileAccess access, FileShare share, int bufferSize, IsolatedStorageFile?isf)
: this(path, mode, access, share, bufferSize, InitializeFileStream(path, mode, access, share, bufferSize, isf))
{
}
// If IsolatedStorageFile is null, then we default to using a file that is scoped by user, appdomain, and assembly.
private static InitializationData InitializeFileStream(string path, FileMode mode, FileAccess access, FileShare share, int bufferSize, IsolatedStorageFile?isf)
{
ArgumentNullException.ThrowIfNull(path);
if ((path.Length == 0) || path.Equals(BackSlash))
{
throw new ArgumentException(
SR.IsolatedStorage_Path);
}
bool createdStore = false;
if (isf == null)
{
isf = IsolatedStorageFile.GetUserStoreForDomain();
createdStore = true;
}
if (isf.Disposed)
{
throw new ObjectDisposedException(null, SR.IsolatedStorage_StoreNotOpen);
}
switch (mode)
{
case FileMode.CreateNew: // Assume new file
case FileMode.Create: // Check for New file & Unreserve
case FileMode.OpenOrCreate: // Check for new file
case FileMode.Truncate: // Unreserve old file size
case FileMode.Append: // Check for new file
case FileMode.Open: // Open existing, else exception
break;
default:
throw new ArgumentException(SR.IsolatedStorage_FileOpenMode);
}
InitializationData data = new InitializationData
{
FullPath = isf.GetFullPath(path),
StorageFile = isf
};
try
{
data.NestedStream = new FileStream(data.FullPath, mode, access, share, bufferSize, FileOptions.None);
}
catch (Exception e)
{
// Make an attempt to clean up the StorageFile if we created it
try
{
if (createdStore)
{
data.StorageFile?.Dispose();
}
}
catch
{
}
// Exception message might leak the IsolatedStorage path. The .NET Framework prevented this by calling an
// internal API which made sure that the exception message was scrubbed. However since the innerException
// is never returned to the user(GetIsolatedStorageException() does not populate the innerexception
// in retail bits we leak the path only under the debugger via IsolatedStorageException._underlyingException which
// they can any way look at via IsolatedStorageFile instance as well.
throw IsolatedStorageFile.GetIsolatedStorageException(SR.IsolatedStorage_Operation_ISFS, e);
}
return(data);
}
/// <summary>Opens a file in the specified mode with read, write, or read/write access and the specified sharing option.</summary>
/// <returns>A <see cref="T:System.IO.FileStream" /> object opened with the specified mode, access, and sharing options.</returns>
/// <param name="mode">
/// A <see cref="T:System.IO.FileMode" /> constant specifying the mode (for example, Open or Append) in
/// which to open the file.
/// </param>
/// <param name="access">
/// A <see cref="T:System.IO.FileAccess" /> constant specifying whether to open the file with Read,
/// Write, or ReadWrite file access.
/// </param>
/// <param name="share">
/// A <see cref="T:System.IO.FileShare" /> constant specifying the type of access other FileStream
/// objects have to this file.
/// </param>
/// <exception cref="T:System.Security.SecurityException">The caller does not have the required permission. </exception>
/// <exception cref="T:System.IO.FileNotFoundException">The file is not found. </exception>
/// <exception cref="T:System.UnauthorizedAccessException">
/// The path is read-only or is a directory.
/// </exception>
/// <exception cref="T:System.IO.DirectoryNotFoundException">
/// The specified path is invalid, such as being on an unmapped
/// drive.
/// </exception>
/// <exception cref="T:System.IO.IOException">The file is already open. </exception>
public Stream Open(FileMode mode, FileAccess access, FileShare share = FileShare.None)
{
return(FileSystem.OpenFile(Path, mode, access, share));
}
public static FileStream Open(String path, FileMode mode, FileAccess access, FileShare share)
{
return(new FileStream(path, mode, access, share));
}
/// <include file='../_Doc/mscorlib.xml' path='doc/members/member[@name="M:System.IO.FileStream.#ctor(System.String,System.IO.FileMode,System.IO.FileAccess,System.IO.FileShare)"]/*' />
public FileStream(string path, FileMode mode, FileAccess access, FileShare share)
{
throw new PlatformNotSupportedException("PCL");
}
internal virtual FileStream CreateFileStream(string filePath, FileMode fileMode, FileAccess fileAccess, FileShare fileShare)
{
return(new FileStream(filePath, fileMode, fileAccess, fileShare));
}
protected override Stream DoGetInputStream(string contentName, out string encoding, FileMode mode, FileShare sharing)
{
long length;
return(WebFileSystem.DoGetInputStream(this, contentName, out encoding, mode, sharing, out creationDate, out exists, out length));
}
private static Stream OpenFile(CodeContext /*!*/ context, PlatformAdaptationLayer pal, string name, FileMode fileMode, FileAccess fileAccess, FileShare fileShare)
{
try {
return(pal.OpenInputFileStream(name, fileMode, fileAccess, fileShare));
} catch (UnauthorizedAccessException e) {
throw PythonFile.ToIoException(context, name, e);
} catch (IOException e) {
PythonFile.AddFilename(context, name, e);
throw;
}
}
public static Stream OpenForRead(this FileEntry self, FileMode fileMode = FileMode.Open,
FileAccess fileAccess = FileAccess.Read, FileShare fileShare = FileShare.Read)
{
return(self.Open(fileMode, fileAccess, fileShare));
}
// On .NET Framework FileStream has an internal no arg constructor that we utilize to provide the facade. We don't have access
// to internals in .NET Core so we'll do the next best thing and contort ourselves into the SafeFileHandle constructor.
// (A path constructor would try and create the requested file and give us two open handles.)
//
// We only expose our own nested FileStream so the base class having a handle doesn't matter. Passing a new SafeFileHandle
// with ownsHandle: false avoids the parent class closing without our knowledge.
private IsolatedStorageFileStream(string path, FileMode mode, FileAccess access, FileShare share, int bufferSize, InitializationData initializationData)
: base(new SafeFileHandle(initializationData.NestedStream.SafeFileHandle.DangerousGetHandle(), ownsHandle: false), access, bufferSize)
{
_isf = initializationData.StorageFile;
_givenPath = path;
_fullPath = initializationData.FullPath;
_fs = initializationData.NestedStream;
}
public static Stream OpenOrCreateForReadWrite(this FileEntry self, FileShare share = FileShare.Read)
{
return(self.Open(FileMode.OpenOrCreate, FileAccess.ReadWrite, share));
}
public IsolatedStorageFileStream(string path, FileMode mode, FileAccess access, FileShare share, int bufferSize)
: this(path, mode, access, share, bufferSize, null)
{
}
public static object LoadAs(this FileEntry self, Type type, FileShare fileShare = FileShare.Read)
{
using (var selff = self.Open(FileMode.Open, FileAccess.Read, fileShare)) { return(selff.LoadAs(type)); }
}
public override Stream openStream(String url, FileMode mode, FileAccess access, FileShare share)
{
return(zipFile.openFile(parseURLInZip(url)));
}
public static object LoadAs(this FileInfo self, Type t, FileShare fileShare = FileShare.Read)
{
using (FileStream s = File.Open(self.FullPath(), FileMode.Open, FileAccess.Read, fileShare)) { return(s.LoadAs(t)); }
}
//注意：序列化需要在需序列化的对像前设置属性，如下所示
//[Serializable]
//private struct structTest { public byte one; public int two; public string three; }
/// <summary>
/// 序列化至TXT文件
/// </summary>
/// <param name="path">文件路径</param>
/// <param name="source">序列化对象</param>
/// <param name="mode">指定操作系统打开文件的方式</param>
/// <param name="access">定义用于控制对文件的读访问、写访问或读/写访问的常数</param>
/// <param name="share">包含用于控制其他 System.IO.FileStream 对象对同一文件可以具有的访问类型的常数</param>
/// <returns></returns>
public static void SerializeToTxt(string path, object source, FileMode mode, FileAccess access, FileShare share)
{
BinaryFormatter formatter = new BinaryFormatter();
FileStream writeFileStream = new FileStream(path, mode, access, share);
formatter.Serialize(writeFileStream, source);
writeFileStream.Close();
}
public static T LoadAs <T>(this FileEntry self, FileShare fileShare = FileShare.Read)
{
using (Stream s = self.Open(FileMode.Open, FileAccess.Read, fileShare)) { return(s.LoadAs <T>()); }
}
public override Stream Open(string path, FileMode mode, FileAccess access, FileShare share)
{
return(File.Open(path, mode, access, share));
}
public static T LoadAs <T>(this FileInfo self, FileShare fileShare = FileShare.Read)
{
using (FileStream s = self.LoadAsStream(fileShare: fileShare)) { return(s.LoadAs <T>()); }
}
public Stream OpenFile(string path, FileAccess access = FileAccess.ReadWrite, FileShare share = FileShare.Read)
{
throw new System.NotImplementedException();
}
public static FileStream LoadAsStream(this FileInfo self, FileMode fileMode = FileMode.Open,
FileAccess fileAccess = FileAccess.Read, FileShare fileShare = FileShare.Read)
{
return(File.Open(self.FullPath(), fileMode, fileAccess, fileShare));
}
private void OpenSqlFileStream(string path, byte[] transactionContext, FileAccess access, FileOptions options, long allocationSize)
{
if (((access != FileAccess.Read) && (access != FileAccess.Write)) && (access != FileAccess.ReadWrite))
{
throw ADP.ArgumentOutOfRange("access");
}
if ((options & ~(FileOptions.Asynchronous | FileOptions.RandomAccess | FileOptions.SequentialScan | FileOptions.WriteThrough)) != FileOptions.None)
{
throw ADP.ArgumentOutOfRange("options");
}
path = GetFullPathInternal(path);
DemandAccessPermission(path, access);
FileFullEaInformation eaBuffer = null;
SecurityQualityOfService service = null;
UnicodeString str = null;
SafeFileHandle fileHandle = null;
int num2 = 0x100080;
uint num = 0;
uint num4 = 0;
FileShare none = FileShare.None;
switch (access)
{
case FileAccess.Read:
num2 |= 1;
none = FileShare.Delete | FileShare.ReadWrite;
num4 = 1;
break;
case FileAccess.Write:
num2 |= 2;
none = FileShare.Delete | FileShare.Read;
num4 = 4;
break;
default:
num2 |= 3;
none = FileShare.Delete | FileShare.Read;
num4 = 4;
break;
}
if ((options & (FileOptions.None | FileOptions.WriteThrough)) != FileOptions.None)
{
num |= 2;
}
if ((options & FileOptions.Asynchronous) == FileOptions.None)
{
num |= 0x20;
}
if ((options & FileOptions.SequentialScan) != FileOptions.None)
{
num |= 4;
}
if ((options & FileOptions.RandomAccess) != FileOptions.None)
{
num |= 0x800;
}
try
{
System.Data.SqlTypes.UnsafeNativeMethods.OBJECT_ATTRIBUTES object_attributes;
eaBuffer = new FileFullEaInformation(transactionContext);
service = new SecurityQualityOfService(System.Data.SqlTypes.UnsafeNativeMethods.SecurityImpersonationLevel.SecurityAnonymous, false, false);
str = new UnicodeString(InitializeNtPath(path));
object_attributes.length = Marshal.SizeOf(typeof(System.Data.SqlTypes.UnsafeNativeMethods.OBJECT_ATTRIBUTES));
object_attributes.rootDirectory = IntPtr.Zero;
object_attributes.attributes = 0x40;
object_attributes.securityDescriptor = IntPtr.Zero;
object_attributes.securityQualityOfService = service;
object_attributes.objectName = str;
uint mode = System.Data.SqlTypes.UnsafeNativeMethods.SetErrorMode(1);
uint status = 0;
try
{
System.Data.SqlTypes.UnsafeNativeMethods.IO_STATUS_BLOCK io_status_block;
Bid.Trace("<sc.SqlFileStream.OpenSqlFileStream|ADV> %d#, desiredAccess=0x%08x, allocationSize=%I64d, fileAttributes=0x%08x, shareAccess=0x%08x, dwCreateDisposition=0x%08x, createOptions=0x%08x\n", this.ObjectID, num2, allocationSize, 0, (int)none, num4, num);
status = System.Data.SqlTypes.UnsafeNativeMethods.NtCreateFile(out fileHandle, num2, ref object_attributes, out io_status_block, ref allocationSize, 0, none, num4, num, eaBuffer, (uint)eaBuffer.Length);
}
finally
{
System.Data.SqlTypes.UnsafeNativeMethods.SetErrorMode(mode);
}
switch (status)
{
case 0:
break;
case 0xc000000d:
throw ADP.Argument(Res.GetString("SqlFileStream_InvalidParameter"));
case 0xc0000034:
{
DirectoryNotFoundException e = new DirectoryNotFoundException();
ADP.TraceExceptionAsReturnValue(e);
throw e;
}
case 0xc0000043:
throw ADP.InvalidOperation(Res.GetString("SqlFileStream_FileAlreadyInTransaction"));
default:
{
uint num6 = System.Data.SqlTypes.UnsafeNativeMethods.RtlNtStatusToDosError(status);
if (num6 == 0x13d)
{
num6 = status;
}
Win32Exception exception3 = new Win32Exception((int)num6);
ADP.TraceExceptionAsReturnValue(exception3);
throw exception3;
}
}
if (fileHandle.IsInvalid)
{
Win32Exception exception2 = new Win32Exception(6);
ADP.TraceExceptionAsReturnValue(exception2);
throw exception2;
}
if (System.Data.SqlTypes.UnsafeNativeMethods.GetFileType(fileHandle) != System.Data.SqlTypes.UnsafeNativeMethods.FileType.Disk)
{
fileHandle.Dispose();
throw ADP.Argument(Res.GetString("SqlFileStream_PathNotValidDiskResource"));
}
if (access == FileAccess.ReadWrite)
{
uint ioControlCode = System.Data.SqlTypes.UnsafeNativeMethods.CTL_CODE(9, 0x958, 0, 0);
uint cbBytesReturned = 0;
if (!System.Data.SqlTypes.UnsafeNativeMethods.DeviceIoControl(fileHandle, ioControlCode, IntPtr.Zero, 0, IntPtr.Zero, 0, out cbBytesReturned, IntPtr.Zero))
{
Win32Exception exception = new Win32Exception(Marshal.GetLastWin32Error());
ADP.TraceExceptionAsReturnValue(exception);
throw exception;
}
}
bool flag = false;
try
{
new SecurityPermission(SecurityPermissionFlag.UnmanagedCode).Assert();
flag = true;
this.m_fs = new FileStream(fileHandle, access, 1, (options & FileOptions.Asynchronous) != FileOptions.None);
}
finally
{
if (flag)
{
CodeAccessPermission.RevertAssert();
}
}
}
catch
{
if ((fileHandle != null) && !fileHandle.IsInvalid)
{
fileHandle.Dispose();
}
throw;
}
finally
{
if (eaBuffer != null)
{
eaBuffer.Dispose();
eaBuffer = null;
}
if (service != null)
{
service.Dispose();
service = null;
}
if (str != null)
{
str.Dispose();
str = null;
}
}
}
public static extern SafeFileHandle CreateFile(string fileName, [MarshalAs(UnmanagedType.U4)] FileAccess fileAccess, [MarshalAs(UnmanagedType.U4)] FileShare fileShare, IntPtr securityAttributes, [MarshalAs(UnmanagedType.U4)] FileMode creationDisposition, [MarshalAs(UnmanagedType.U4)] FileAttributes flagsAndAttributes, IntPtr template);
public override Stream OpenFileStream(string path, FileMode fileMode, FileAccess fileAccess, FileShare shareMode, FileOptions options, bool flushesToDisk)
{
ReusableMemoryStream stream;
this.ExpectedOpenFileStreams.TryGetValue(path, out stream).ShouldEqual(true, "Unexpected access of file: " + path);
if (this.maxOpenFileStreamFailures > 0)
{
if (this.openFileStreamFailureCount < this.maxOpenFileStreamFailures &&
string.Equals(path, this.openFileStreamFailurePath, System.StringComparison.OrdinalIgnoreCase))
{
++this.openFileStreamFailureCount;
if (this.openFileStreamFailureCount % 2 == 0)
{
throw new IOException();
}
else
{
throw new UnauthorizedAccessException();
}
}
}
else if (this.failuresAcrossOpenExistsAndOverwritePath != null)
{
if (this.failuresAcrossOpenExistsAndOverwriteCount == 0 &&
string.Equals(path, this.failuresAcrossOpenExistsAndOverwritePath, System.StringComparison.OrdinalIgnoreCase))
{
++this.failuresAcrossOpenExistsAndOverwriteCount;
throw new IOException();
}
}
if (fileMode == FileMode.Create)
{
this.ExpectedFiles[path] = new ReusableMemoryStream(string.Empty);
}
this.ExpectedFiles.TryGetValue(path, out stream).ShouldEqual(true, "Unexpected access of file: " + path);
return(stream);
}
/// <inheritdoc />
public IFileStream Open(FileMode mode, FileAccess access, FileShare share)
{
return(_instance.Open(mode, access, share).ToInterface());
}
