public VolumeInfo GetVolumeInformation(string devicePathName)
{
StringBuilder volumeName = new StringBuilder(256);
StringBuilder fileSystem = new StringBuilder(256);
ErrorModes mode = SetErrorMode(ErrorModes.SEM_FAILCRITICALERRORS);
try {
bool success = Kernel32.GetVolumeInformation(devicePathName,
volumeName, volumeName.Capacity, out uint volumeSerial,
out uint _, out FileSystemFlags flags, fileSystem, fileSystem.Capacity);
if (!success)
{
m_Win32Error = Marshal.GetLastWin32Error();
return(null);
}
return(new VolumeInfo()
{
VolumeLabel = volumeName.ToString(),
VolumeSerial = string.Format("{0:X4}-{1:X4}", (volumeSerial & 0xFFFF0000) >> 16, volumeSerial & 0xFFFF),
Flags = flags,
FileSystem = fileSystem.ToString(),
});
} finally {
SetErrorMode(mode);
}
}
/// <summary>
/// loads a shared library (on Windows: dynamic link library, *.dll; on Unix: shared object, lib*.so)
/// </summary>
/// <param name="LibName"></param>
/// <returns>library handle, for the use in functions <see cref="LoadSymbol"/> and <see cref="UnloadDynLib"/></returns>
/// <remarks>
/// On Windows, this function redirects to the 'LoadLibrary'-function in kernel32.dll;<br/>
/// On Unix, this function redirects to the 'dlopen'-function in libdl.so;
/// </remarks>
/// <param name="errstr">
/// on success, null;
/// if call failed (return value is null), an error information provided by the operating system
/// </param>
/// <param name="loadGlobal">
/// only effective on Linux/UNIX systems; if true, a library is loaded with the 'RTDL_GLOBAL' flag:
/// thereby, it can be used automatically by the operating system to resolve symbols in other libraries.
/// </param>
public static DynLibHandle LoadDynLib(string LibName, out string errstr, bool loadGlobal)
{
PlatformID plattid = System.Environment.OSVersion.Platform;
errstr = null;
DynLibHandle ret;
switch (plattid)
{
case PlatformID.Win32NT:
// Try to load but suppress ugly dialog box error
ErrorModes originalMode = SetErrorMode(ErrorModes.SEM_FAILCRITICALERRORS);
ret.val = LoadLibrary(LibName);
SetErrorMode(originalMode);
if (ret.val == IntPtr.Zero)
{
errstr = GetLastWin32Error();
}
break;
case PlatformID.Unix:
ret.val = dlopen(LibName, loadGlobal ? (2 | 256) : 2); // 2 == RTLD_NOW, 256 == RTDL_GLOBAL
if (ret.val == IntPtr.Zero)
{
errstr = _dlerror();
}
break;
default:
throw new NotImplementedException("Dynamic Library Loading for " + plattid + " is not supported.");
}
return(ret);
}
private static void InitializeErrorHandling()
{
AppDomain.CurrentDomain.UnhandledException += CurrentDomainUnhandledException;
const ErrorModes desiredErrorModes = ErrorModes.SEM_FAILCRITICALERRORS | ErrorModes.SEM_NOGPFAULTERRORBOX;
var dwMode = SetErrorMode(desiredErrorModes);
SetErrorMode(dwMode | desiredErrorModes);
}
public ChangeErrorMode(ErrorModes mode)
{
_oldMode = (int)ErrorModes.Default;
if (!IsLinux)
{
_oldMode = SetErrorMode((int)mode);
}
}
private static ErrorModes SetErrorModeWithCheck(ErrorModes uMode)
{
if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
throw new PlatformNotSupportedException("Windows only feature yet");
}
return(SetErrorMode(uMode));
}
internal static void DisableShellModalErrorDialogs()
{
if (ApplicationInfo.IsWindows)
{
const ErrorModes newErrorMode = ErrorModes.SEM_FAILCRITICALERRORS |
ErrorModes.SEM_NOGPFAULTERRORBOX |
ErrorModes.SEM_NOOPENFILEERRORBOX;
SetErrorMode(newErrorMode);
}
}
public System.IO.FileAttributes GetFileAttributes(string pathName)
{
ErrorModes mode = SetErrorMode(ErrorModes.SEM_FAILCRITICALERRORS);
try {
return((System.IO.FileAttributes)Kernel32.GetFileAttributes(pathName));
} finally {
SetErrorMode(mode);
}
}
public int GetDriveType(string devicePathName)
{
ErrorModes mode = SetErrorMode(ErrorModes.SEM_FAILCRITICALERRORS);
try {
return(Kernel32.GetDriveType(devicePathName));
} finally {
SetErrorMode(mode);
}
}
public ChangeErrorMode(ErrorModes mode)
{
try
{
oldMode = SetErrorMode((int)mode);
}
catch (Exception ex) when(ex is EntryPointNotFoundException || ex is DllNotFoundException)
{
oldMode = (int)mode;
}
}
public ChangeErrorMode(ErrorModes mode)
{
try
{
oldMode = SetErrorMode((int)mode);
}
catch (EntryPointNotFoundException)
{
oldMode = (int)mode;
}
}
/**
* Display all available interfaces that have at least one device available.
*
* @return List of the detected interfaces.
*/
static HTuple showAvailableInterfaces()
{
HTuple deviceInfo, deviceValue, interfacesAll, temp;
HTuple interfaces = new HTuple();
Console.WriteLine(System.Environment.NewLine +
"Detect and show all available interfaces..." +
System.Environment.NewLine);
interfacesAll = HInfo.GetParamInfo("info_framegrabber", "Name", "values");
if (interfacesAll.Length > 0)
{
Console.WriteLine("Available interfaces:");
}
else
{
Console.WriteLine("Found no interfaces.");
return(interfaces);
}
ErrorModes errorMode = GetErrorMode();
// Disable error dialog boxes on interface detection.
SetErrorMode(ErrorModes.SEM_FAILCRITICALERRORS |
ErrorModes.SEM_NOGPFAULTERRORBOX |
ErrorModes.SEM_NOOPENFILEERRORBOX);
for (int i = 0; i < interfacesAll.Length; i++)
{
try
{
temp = interfacesAll.TupleSelect(i);
deviceInfo = HInfo.InfoFramegrabber(temp.S.ToString(), "device",
out deviceValue);
}
catch (HalconException)
{
// Interface not available.
continue;
}
if (deviceValue.Length > 0)
{
interfaces.Append(interfacesAll.TupleSelect(i));
Console.WriteLine(interfaces.Length + ")" +
interfacesAll.TupleSelect(i).S.ToString());
}
}
// Restore previous error mode.
SetErrorMode(errorMode);
return(interfaces);
}
public DiskFreeSpace GetDiskFreeSpace(string devicePathName)
{
DiskFreeSpace space = new DiskFreeSpace()
{
SectorsPerCluster = 0,
BytesPerSector = 0,
UserBytesFree = 0,
TotalBytesFree = 0,
TotalBytes = 0
};
ErrorModes mode = SetErrorMode(ErrorModes.SEM_FAILCRITICALERRORS);
try {
bool successEx = GetDiskFreeSpaceEx(devicePathName, out ulong freeBytes, out ulong totalBytes, out ulong totalFreeBytes);
if (!successEx)
{
m_Win32Error = Marshal.GetLastWin32Error();
}
else
{
space.UserBytesFree = (long)freeBytes;
space.TotalBytes = (long)totalBytes;
space.TotalBytesFree = (long)totalFreeBytes;
}
bool success = Kernel32.GetDiskFreeSpace(devicePathName, out int sectorsPerCluster, out int bytesPerSector, out int _, out int _);
if (!success)
{
m_Win32Error = Marshal.GetLastWin32Error();
}
else
{
space.SectorsPerCluster = sectorsPerCluster;
space.BytesPerSector = bytesPerSector;
}
if (!success && !successEx)
{
return(null);
}
return(space);
} finally {
SetErrorMode(mode);
}
}
public SafeHandle CreateFileFromDevice(string pathName)
{
ErrorModes mode = SetErrorMode(ErrorModes.SEM_FAILCRITICALERRORS);
try {
SafeObjectHandle hDevice = CreateFile(pathName, 0,
FileShare.FILE_SHARE_READ | FileShare.FILE_SHARE_WRITE, IntPtr.Zero, CreationDisposition.OPEN_EXISTING,
0, SafeObjectHandle.Null);
if (hDevice == null || hDevice.IsInvalid)
{
m_Win32Error = Marshal.GetLastWin32Error();
int e = Marshal.GetHRForLastWin32Error();
Marshal.ThrowExceptionForHR(e, INVALID_HANDLE_VALUE);
throw new System.IO.IOException("Couldn't open device for reading", e);
}
return(hDevice);
} finally {
SetErrorMode(mode);
}
}
public ChangeErrorMode(ErrorModes mode)
{
try
{
this.oldMode = SetErrorMode((int)mode);
}
catch (Exception ex) when(ex is EntryPointNotFoundException or DllNotFoundException)
{
this.oldMode = (int)mode;
}
}
void IDisposable.Dispose()
{
try
{
SetErrorMode(this.oldMode);
}
catch (Exception ex) when(ex is EntryPointNotFoundException or DllNotFoundException)
{
// NOTE: Mono doesn't support DllImport("kernel32.dll") and its SetErrorMode method, obviously. @asbjornu
}
}
public ErrorModeContext(ErrorModes mode)
{
_oldMode = SetErrorMode((int)mode);
}
private static extern ErrorModes SetErrorMode(ErrorModes newMode);
/// <summary> Инициализирует новый экземпляр структуры <see cref="ChangeErrorMode"/>, устанавливая режим обработки ошибок. </summary>
/// <param name="mode"> Режим. </param>
public ChangeErrorMode(ErrorModes mode)
{
oldMode = ErrorModes.Default; // https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/compiler-messages/cs0188
oldMode = SetErrorModeWithCheck(mode);
}
private static extern ErrorModes SetErrorMode(ErrorModes modes);
public ChangeErrorMode(ErrorModes mode)
{
oldMode = SetErrorMode((int)mode);
}
private static extern ErrorModes SetErrorMode(ErrorModes newMode);
public static extern ErrorModes SetErrorMode(ErrorModes newMode);
public ErrorModeContext(ErrorModes mode) {
_oldMode = SetErrorMode((int) mode);
}
public ErrorModeManager(ErrorModes errorMode)
{
_oldErrorMode = Unmanaged.SetErrorMode(errorMode);
}
public static Win32Process StartProcessAsUser(WindowsIdentity winIdentity, string applicationName, string commandLine, string workingDirectory, Win32NativeEnvironmentBlock environment, out Stream stdin, out Stream stdout, out Stream stderror)
{
STARTUPINFO si = new STARTUPINFO();
si.cb = Marshal.SizeOf(typeof(STARTUPINFO));
/*
* When a process is started using CreateProcessAsUser function, the process will be started into a windowstation
* and desktop combination based on the value of lpDesktop in the STARTUPINFO structure parameter:
* lpDesktop = "<windowsta>\<desktop>"; the system will try to start the process into that windowstation and desktop.
* lpDesktop = NULL; the system will try to use the same windowstation and desktop as the calling process if the system is associated with the interactive windowstation.
* lpDesktop = <somevalue>; the system will create a new windowstation and desktop that you cannot see.
* lpDesktop = ""; it will either create a new windowstation and desktop that you cannot see, or if one has been created by means of a prior call by using the same access token, the existing windowstation and desktop will be used.
*/
si.lpDesktop = "";
IntPtr stdinRead, stdinWrite, stdoutRead, stdoutWrite, stderrorRead, stderrorWrite;
SECURITY_ATTRIBUTES sa = default(SECURITY_ATTRIBUTES);
sa.nLength = Marshal.SizeOf(sa);
sa.lpSecurityDescriptor = IntPtr.Zero;
sa.bInheritHandle = true;
if (!CreatePipe(out stdinRead, out stdinWrite, ref sa, 0))
{
throw new Win32Exception(Marshal.GetLastWin32Error());
}
if (!SetHandleInformation(stdinWrite, HANDLE_FLAGS.INHERIT, HANDLE_FLAGS.None))
{
throw new Win32Exception(Marshal.GetLastWin32Error());
}
if (!CreatePipe(out stdoutRead, out stdoutWrite, ref sa, 0))
{
throw new Win32Exception(Marshal.GetLastWin32Error());
}
if (!SetHandleInformation(stdoutRead, HANDLE_FLAGS.INHERIT, HANDLE_FLAGS.None))
{
throw new Win32Exception(Marshal.GetLastWin32Error());
}
if (!CreatePipe(out stderrorRead, out stderrorWrite, ref sa, 0))
{
throw new Win32Exception(Marshal.GetLastWin32Error());
}
if (!SetHandleInformation(stderrorRead, HANDLE_FLAGS.INHERIT, HANDLE_FLAGS.None))
{
throw new Win32Exception(Marshal.GetLastWin32Error());
}
si.dwFlags = STARTF_USESTDHANDLES;
si.hStdInput = stdinRead;
si.hStdOutput = stdoutWrite;
si.hStdError = stderrorWrite;
SECURITY_ATTRIBUTES processAttr = CreateSecurityAttributes(winIdentity == null ? WellKnownSidType.AuthenticatedUserSid : WellKnownSidType.NetworkServiceSid);
SECURITY_ATTRIBUTES threadAttr = CreateSecurityAttributes(winIdentity == null ? WellKnownSidType.AuthenticatedUserSid : WellKnownSidType.NetworkServiceSid);
lock (_createProcessLock) {
PROCESS_INFORMATION pi;
ErrorModes oldErrorMode = SetErrorMode(ErrorModes.SEM_FAILCRITICALERRORS);
try {
if (winIdentity == null)
{
if (!CreateProcess(applicationName, commandLine, ref processAttr, ref threadAttr, true,
(uint)(CREATE_PROCESS_FLAGS.CREATE_UNICODE_ENVIRONMENT | CREATE_PROCESS_FLAGS.CREATE_NO_WINDOW),
environment.NativeEnvironmentBlock,
workingDirectory,
ref si,
out pi))
{
throw new Win32Exception(Marshal.GetLastWin32Error());
}
}
else
{
if (!CreateProcessAsUser(
winIdentity.Token, applicationName, commandLine, ref processAttr, ref threadAttr, true,
(uint)(CREATE_PROCESS_FLAGS.CREATE_UNICODE_ENVIRONMENT | CREATE_PROCESS_FLAGS.CREATE_NO_WINDOW),
environment.NativeEnvironmentBlock,
workingDirectory,
ref si,
out pi))
{
throw new Win32Exception(Marshal.GetLastWin32Error());
}
}
stdin = new FileStream(new SafeFileHandle(stdinWrite, true), FileAccess.Write, 0x1000, false);
stdout = new FileStream(new SafeFileHandle(stdoutRead, true), FileAccess.Read, 0x1000, false);
stderror = new FileStream(new SafeFileHandle(stderrorRead, true), FileAccess.Read, 0x1000, false);
} finally {
SetErrorMode(oldErrorMode);
if (processAttr.lpSecurityDescriptor != IntPtr.Zero)
{
Marshal.FreeHGlobal(processAttr.lpSecurityDescriptor);
}
if (threadAttr.lpSecurityDescriptor != IntPtr.Zero)
{
Marshal.FreeHGlobal(threadAttr.lpSecurityDescriptor);
}
}
return(new Win32Process(pi));
}
}
public static IEnumerable <FileSystemInfo> GetFileSystemInfos(DirectoryInfo dir, string pattern, SearchOption searchOption, bool includeDirectories, bool includeFiles)
{
// We suppressed this demand for each p/invoke call, so demand it upfront once
new SecurityPermission(SecurityPermissionFlag.UnmanagedCode).Demand();
// Validate parameters
if (dir == null)
{
throw new ArgumentNullException("dir");
}
if (pattern == null)
{
throw new ArgumentNullException("pattern");
}
// Setup
WIN32_FIND_DATA findData = new WIN32_FIND_DATA();
Stack <DirectoryInfo> directories = new Stack <DirectoryInfo>();
directories.Push(dir);
// Process each directory
ErrorModes origErrorMode = SetErrorMode(ErrorModes.FailCriticalErrors);
try
{
while (directories.Count > 0)
{
// Get the name of the next directory and the corresponding search pattern
dir = directories.Pop();
string dirPath = dir.FullName.Trim();
if (dirPath.Length == 0)
{
continue;
}
char lastChar = dirPath[dirPath.Length - 1];
if (lastChar != Path.DirectorySeparatorChar && lastChar != Path.AltDirectorySeparatorChar)
{
dirPath += Path.DirectorySeparatorChar;
}
// Process all files in that directory
SafeFindHandle handle = FindFirstFile(dirPath + pattern, findData);
if (handle.IsInvalid)
{
int error = Marshal.GetLastWin32Error();
if (error == ERROR_ACCESS_DENIED ||
error == ERROR_FILE_NOT_FOUND)
{
continue;
}
else
{
throw new Win32Exception(error);
}
}
else
{
try
{
do
{
if ((findData.dwFileAttributes & FileAttributes.Directory) == 0)
{
if (includeFiles)
{
yield return(new FileInfo(dirPath + findData.cFileName));
}
}
else
{
if (includeDirectories && findData.cFileName != "." && findData.cFileName != "..")
{
yield return(new DirectoryInfo(dirPath + findData.cFileName));
}
}
}while (FindNextFile(handle, findData));
int error = Marshal.GetLastWin32Error();
if (error != ERROR_NO_MORE_FILES)
{
throw new Win32Exception(error);
}
}
finally { handle.Dispose(); }
}
// Add all child directories if that's what the user wants
if (searchOption == SearchOption.AllDirectories)
{
try
{
foreach (DirectoryInfo childDir in GetDirectories(dir, "*", SearchOption.TopDirectoryOnly)) //Top only, as we're all ready handling recursion here.
{
try
{
if ((File.GetAttributes(childDir.FullName) & FileAttributes.ReparsePoint) == 0)
{
directories.Push(childDir);
}
}
catch (Exception childDirEx)
{
//Can't get subfolders
System.Diagnostics.Trace.WriteLine("Can't search inside: " + childDir.Name);
System.Diagnostics.Trace.Indent();
System.Diagnostics.Trace.WriteLine(childDirEx.Message);
System.Diagnostics.Trace.Unindent();
}
}
}
catch (Exception e)
{
//Can't get subfolders
System.Diagnostics.Trace.WriteLine("Can't search inside: " + dirPath);
System.Diagnostics.Trace.Indent();
System.Diagnostics.Trace.WriteLine(e.Message);
System.Diagnostics.Trace.Unindent();
}
}
}
}
finally { SetErrorMode(origErrorMode); }
}
public ChangeErrorMode(ErrorModes mode)
{
oldMode = SetErrorMode((int)mode);
}
internal static extern ErrorModes SetErrorMode(ErrorModes mode);
static extern ErrorModes SetErrorMode(ErrorModes uMode);
public static IEnumerable <FileInfo> GetFiles(DirectoryInfo startDirectory, string pattern, bool recurse)
{
// We suppressed this demand for each p/invoke call, so demand it upfront once
new SecurityPermission(SecurityPermissionFlag.UnmanagedCode).Demand();
// Validate parameters
Verify.IsNotNull(startDirectory, "startDirectory");
Verify.IsNeitherNullNorEmpty(pattern, "pattern");
// Setup
var findData = new WIN32_FIND_DATAW();
var directories = new Stack <DirectoryInfo>();
directories.Push(startDirectory);
// Process each directory. Only push new directories if we're recursing.
ErrorModes origErrorMode = NativeMethods.SetErrorMode(ErrorModes.FailCriticalErrors);
try
{
while (directories.Count > 0)
{
// Get the name of the next directory and the corresponding search pattern
DirectoryInfo dir = directories.Pop();
string dirPath = dir.FullName.Trim();
if (dirPath.Length == 0)
{
continue;
}
char lastChar = dirPath[dirPath.Length - 1];
if (lastChar != Path.DirectorySeparatorChar && lastChar != Path.AltDirectorySeparatorChar)
{
dirPath += Path.DirectorySeparatorChar;
}
// Process all files in that directory
using (SafeFindHandle handle = NativeMethods.FindFirstFileW(dirPath + pattern, findData))
{
Win32Error error;
if (handle.IsInvalid)
{
error = Win32Error.GetLastError();
if (error == Win32Error.ERROR_ACCESS_DENIED || error == Win32Error.ERROR_FILE_NOT_FOUND)
{
continue;
}
Assert.AreNotEqual(Win32Error.ERROR_SUCCESS, error);
((HRESULT)error).ThrowIfFailed();
}
do
{
if (!Utility.IsFlagSet((int)findData.dwFileAttributes, (int)FileAttributes.Directory))
{
yield return(new FileInfo(dirPath + findData.cFileName));
}
}while (NativeMethods.FindNextFileW(handle, findData));
error = Win32Error.GetLastError();
if (error != Win32Error.ERROR_NO_MORE_FILES)
{
((HRESULT)error).ThrowIfFailed();
}
}
// Push subdirectories onto the stack if we are recursing.
if (recurse)
{
// In a volatile system we can't count on all the file information staying valid.
// Catch reasonable exceptions and move on.
try
{
foreach (DirectoryInfo childDir in dir.GetDirectories())
{
try
{
FileAttributes attrib = File.GetAttributes(childDir.FullName);
// If it's not a hidden, system folder, nor a reparse point
if (!Utility.IsFlagSet((int)attrib, (int)(FileAttributes.Hidden | FileAttributes.System | FileAttributes.ReparsePoint)))
{
directories.Push(childDir);
}
}
catch (FileNotFoundException)
{
// Shouldn't see this.
Assert.Fail();
}
catch (DirectoryNotFoundException) { }
}
}
catch (DirectoryNotFoundException) { }
}
}
}
finally
{
NativeMethods.SetErrorMode(origErrorMode);
}
}
[DllImport("kernel32.dll", SetLastError = true)] static extern ErrorModes SetErrorMode(ErrorModes uMode);
[DllImport("kernel32.dll")] public static extern ErrorModes SetErrorMode(ErrorModes uMode);
public ChangeErrorMode(ErrorModes mode)
{
Environment.ExitCode = oldMode = (int)mode;
}
internal static extern ErrorModes SetErrorMode(ErrorModes mode);
public void SetErrorMode_Works()
{
ErrorModes oldMode = SetErrorMode(ErrorModes.SEM_DEFAULT);
}
static extern ErrorModes SetErrorMode(ErrorModes uMode);
/// <summary>
/// Gets the files.
/// </summary>
/// <param name="dir">The dir.</param>
/// <param name="pattern">The pattern.</param>
/// <param name="searchOption">The search option.</param>
/// <returns></returns>
public static IEnumerable <FileInfo> GetFiles(DirectoryInfo dir, string pattern, SearchOption searchOption)
{
// We suppressed this demand for each p/invoke call, so demand it upfront once
new SecurityPermission(SecurityPermissionFlag.UnmanagedCode).Demand();
// Validate parameters
if (dir == null)
{
throw new ArgumentNullException("dir");
}
if (pattern == null)
{
throw new ArgumentNullException("pattern");
}
// Setup
WIN32_FIND_DATA findData = new WIN32_FIND_DATA();
Stack <DirectoryInfo> directories = new Stack <DirectoryInfo>();
directories.Push(dir);
// Process each directory
ErrorModes origErrorMode = SetErrorMode(ErrorModes.FailCriticalErrors);
try
{
while (directories.Count > 0)
{
// Get the name of the next directory and the corresponding search pattern
dir = directories.Pop();
string dirPath = dir.FullName.Trim();
if (dirPath.Length == 0)
{
continue;
}
char lastChar = dirPath[dirPath.Length - 1];
if (lastChar != Path.DirectorySeparatorChar && lastChar != Path.AltDirectorySeparatorChar)
{
dirPath += Path.DirectorySeparatorChar;
}
// Process all files in that directory
SafeFindHandle handle = FindFirstFile(dirPath + pattern, findData);
if (handle.IsInvalid)
{
int error = Marshal.GetLastWin32Error();
if (error == ERROR_ACCESS_DENIED)
{
continue;
}
else if (error != ERROR_FILE_NOT_FOUND)
{
throw new Win32Exception(error);
}
}
else
{
try
{
do
{
if ((findData.dwFileAttributes & FileAttributes.Directory) == 0)
{
yield return(new FileInfo(dirPath + findData.cFileName));
}
}while (FindNextFile(handle, findData));
int error = Marshal.GetLastWin32Error();
if (error != ERROR_NO_MORE_FILES)
{
throw new Win32Exception(error);
}
}
finally { handle.Dispose(); }
}
// Add all child directories if that's what the user wants
if (searchOption == SearchOption.AllDirectories)
{
foreach (DirectoryInfo childDir in dir.GetDirectories())
{
if ((File.GetAttributes(childDir.FullName) & FileAttributes.ReparsePoint) == 0)
{
directories.Push(childDir);
}
}
}
}
}
finally { SetErrorMode(origErrorMode); }
}
public static extern ErrorModes SetErrorMode(ErrorModes newMode);
public ChangeErrorMode(ErrorModes mode)
{
try
{
oldMode = SetErrorMode((int)mode);
}
catch (EntryPointNotFoundException)
{
oldMode = (int)mode;
}
}
