РАБОТА С ДИСКАМИ НА С#

Question

Здраствуйте посдкажите фунции работы с дисками на с# winform

Answer 1

вам бы лучше обратиться на msdn forum

по идее System.IO вы сможете найти то что вам нужно (хотя не совсем ясно что вы хотите делать с дисками и какими собственно дисками)

---

The opinion expressed by me is not an official position of Microsoft

Answer 2

Добрый день.

Из чистого c# с дисками особо не поработаешь (кстати, а что вы подразумеваете под работой с дисками?). Есть класс DriveInfo, позволяющий получить информацию о дисках. А все остальное это работа с директориями, файлами. Что конкретно вы хотите сделать?

Answer 3

https://msdn.microsoft.com/en-us/library/windows/desktop/aa365188(v=vs.85).aspx

Добрый день.

Из чистого c# с дисками особо не поработаешь (кстати, а что вы подразумеваете под работой с дисками?). Есть класс DriveInfo, позволяющий получить информацию о дисках. А все остальное это работа с директориями, файлами. Что конкретно вы хотите сделать?

Я нашел только вот что на с++ а мне нужно на с#   





















Answer 4

Это называется не C++, а WinAPI. Для работы с окнами, и частью системных объектов вызовы WinAPI были зарыты в дебрях C#. А вот для многих других вещей, приходится писать самому ручками. Например, вот так можно установить активный раздел диска:
Класс:

namespace PartitionWrapper
{
    using System;
    using System.Diagnostics;
    using System.Windows.Forms;
    using System.Runtime.InteropServices;

    public class IOWrapper
    {
        public static bool SetActivePartition(string selectedDrive)
        {
            bool RetCode = false;

            try
            {
                bool bSuccess = false;
                uint dwBytesReturned = 0;

                IntPtr hDisk = OpenVolume(selectedDrive);
                if (hDisk == null || hDisk == FSConstants.INVALID_HANDLE_VALUE)
                {
                    RetCode = false;
                    goto FINAL;
                }

                // Get the partition information
                uint PartitionInfomations = (uint)(Marshal.SizeOf(typeof(FSStructures.DRIVE_LAYOUT_INFORMATION_EX)) + 3 * Marshal.SizeOf(typeof(FSStructures.PARTITION_INFORMATION_EX)));
                byte[] DBuffer = new byte[PartitionInfomations];

                GCHandle handle = GCHandle.Alloc(DBuffer, GCHandleType.Pinned);

                FSStructures.DRIVE_LAYOUT_INFORMATION_EX pDriveLayout = (FSStructures.DRIVE_LAYOUT_INFORMATION_EX)Marshal.PtrToStructure(handle.AddrOfPinnedObject(), typeof(FSStructures.DRIVE_LAYOUT_INFORMATION_EX));

                IntPtr pDriveLayoutPtr = Marshal.AllocHGlobal(Marshal.SizeOf(pDriveLayout));

                Marshal.StructureToPtr(pDriveLayout, pDriveLayoutPtr, false);

                bSuccess = FSStructures.DeviceIoControl(hDisk, FSConstants.IOCTL_DISK_GET_DRIVE_LAYOUT_EX, default(IntPtr), default(uint), pDriveLayoutPtr, PartitionInfomations, ref dwBytesReturned);

                pDriveLayout = (FSStructures.DRIVE_LAYOUT_INFORMATION_EX)Marshal.PtrToStructure(pDriveLayoutPtr, typeof(FSStructures.DRIVE_LAYOUT_INFORMATION_EX));

                if (bSuccess || dwBytesReturned != PartitionInfomations)
                {
                    RetCode = true;
                }
                else { RetCode = false; goto FINAL; }

                if (!pDriveLayout.PartitionEntry[0].Mbr.BootIndicator)
                {
                    pDriveLayout.PartitionEntry[0].PartitionStyle = FSStructures.PARTITION_STYLE.MasterBootRecord;
                    pDriveLayout.PartitionEntry[0].Mbr.BootIndicator = true;
                    pDriveLayout.PartitionEntry[0].RewritePartition = true;
                    {
                        pDriveLayoutPtr = Marshal.AllocHGlobal(Marshal.SizeOf(pDriveLayout));
                        Marshal.StructureToPtr(pDriveLayout, pDriveLayoutPtr, false);
                    }
                    bSuccess = FSStructures.DeviceIoControl(hDisk, FSConstants.IOCTL_DISK_SET_DRIVE_LAYOUT_EX, pDriveLayoutPtr, PartitionInfomations, default(IntPtr), default(uint), ref dwBytesReturned);
                    if (bSuccess)
                    {
                        RetCode = true;
                    }
                    else { RetCode = false; }
                }

            FINAL:

                // Close the disk handle.
                if (hDisk != null && hDisk != FSConstants.INVALID_HANDLE_VALUE)
                {
                    FSStructures.CloseHandle(hDisk);
                }
            }
            catch { return false; }

            return RetCode;
        }

        private static IntPtr OpenVolume(string DeviceName)
        {
            try
            {
                IntPtr hDevice;
                hDevice = FSStructures.CreateFile(
                    @"\\.\" + DeviceName,
                    FSConstants.GENERIC_EXECUTE | FSConstants.GENERIC_READ | FSConstants.GENERIC_WRITE | FSConstants.FILE_SHARE_READ | FSConstants.FILE_SHARE_WRITE,
                    FSConstants.FILE_SHARE_WRITE,
                    IntPtr.Zero,
                    FSConstants.OPEN_EXISTING,
                    0,
                    IntPtr.Zero);


                if ((int)hDevice == -1)
                {
                    throw new Exception(Marshal.GetLastWin32Error().ToString());
                }

                return hDevice;
            }
            catch { return FSConstants.INVALID_HANDLE_VALUE; }
        }

        internal static class FSConstants
        {
            public const uint FILE_SHARE_READ = 0x00000001;
            public const uint FILE_SHARE_WRITE = 0x00000002;
            public const uint OPEN_EXISTING = 3;
            public const int GENERIC_EXECUTE = 0x10000000;

            public const uint GENERIC_READ = (0x80000000);
            public const uint GENERIC_WRITE = (0x40000000);

            public static IntPtr INVALID_HANDLE_VALUE = new IntPtr(-1);

            public const uint IOCTL_DISK_GET_DRIVE_LAYOUT_EX = 0x00070050;

            public const uint IOCTL_DISK_SET_DRIVE_LAYOUT_EX = 0x7C054;
        }

        internal static class FSStructures
        {

            [DllImport("kernel32.dll", SetLastError = true)]
            public static extern IntPtr CreateFile(
                string lpFileName,
                uint dwDesiredAccess,
                uint dwShareMode,
                IntPtr lpSecurityAttributes,
                uint dwCreationDisposition,
                uint dwFlagsAndAttributes,
                IntPtr hTemplateFile);

            [DllImport("kernel32.dll", SetLastError = true)]
            public static extern int CloseHandle(IntPtr hObject);

            [DllImport("kernel32.dll", SetLastError = true)]
            public static extern bool DeviceIoControl(
                IntPtr hDevice,
                uint dwIoControlCode,
                [Optional] IntPtr lpInBuffer,
                uint nInBufferSize,
                [Optional] [Out] IntPtr lpOutBuffer,
                uint nOutBufferSize,
                [Optional] ref uint lpBytesReturned,
                [Optional] IntPtr lpOverlapped);


            [StructLayout(LayoutKind.Sequential)]
            public struct DRIVE_LAYOUT_INFORMATION_EX
            {
                public PARTITION_STYLE PartitionStyle;

                public int PartitionCount;

                public DRIVE_LAYOUT_INFORMATION_UNION DriveLayoutInformatiton;

                [MarshalAs(UnmanagedType.ByValArray, ArraySubType = UnmanagedType.Struct, SizeConst = 0x16)]
                public PARTITION_INFORMATION_EX[] PartitionEntry;
            }

            [StructLayout(LayoutKind.Sequential)]
            public struct PARTITION_INFORMATION_EX
            {
                [MarshalAs(UnmanagedType.U4)]
                public PARTITION_STYLE PartitionStyle;
                public long StartingOffset;
                public long PartitionLength;
                public int PartitionNumber;
                public bool RewritePartition;
                public PARTITION_INFORMATION_MBR Mbr;
                public PARTITION_INFORMATION_GPT Gpt;
            }

            [StructLayout(LayoutKind.Sequential)]
            public struct PARTITION_INFORMATION_MBR
            {
                public byte PartitionType;
                [MarshalAs(UnmanagedType.U1)]
                public bool BootIndicator;
                [MarshalAs(UnmanagedType.U1)]
                public bool RecognizedPartition;
                public uint HiddenSectors;
            }


            [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
            public struct PARTITION_INFORMATION_GPT
            {
                public Guid PartitionType;
                public Guid PartitionId;
                [MarshalAs(UnmanagedType.U8)]
                public EFIPartitionAttributes Attributes;

                [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 36)]
                public string Name;
            }

            [Flags]
            public enum EFIPartitionAttributes : ulong
            {
                GPT_ATTRIBUTE_PLATFORM_REQUIRED = 0x0000000000000001,
                LegacyBIOSBootable = 0x0000000000000004,
                GPT_BASIC_DATA_ATTRIBUTE_NO_DRIVE_LETTER = 0x8000000000000000,
                GPT_BASIC_DATA_ATTRIBUTE_HIDDEN = 0x4000000000000000,
                GPT_BASIC_DATA_ATTRIBUTE_SHADOW_COPY = 0x2000000000000000,
                GPT_BASIC_DATA_ATTRIBUTE_READ_ONLY = 0x1000000000000000
            }


            [StructLayout(LayoutKind.Explicit)]
            public struct DRIVE_LAYOUT_INFORMATION_UNION
            {
                [FieldOffset(0)]
                public DRIVE_LAYOUT_INFORMATION_MBR Mbr;

                [FieldOffset(0)]
                public DRIVE_LAYOUT_INFORMATION_GPT Gpt;
            }

            [StructLayout(LayoutKind.Sequential)]
            public struct DRIVE_LAYOUT_INFORMATION_GPT
            {

                public Guid DiskId;

                public long StartingUsableOffset;

                public long UsableLength;

                public int MaxPartitionCount;
            }

            [StructLayout(LayoutKind.Sequential)]
            public struct DRIVE_LAYOUT_INFORMATION_MBR
            {
                public uint Signature;
            }

            public enum PARTITION_STYLE : int
            {
                MasterBootRecord = 0,
                GuidPartitionTable = 1,
                Raw = 2
            }
        }
    }
}

Использование:

PartitionWrapper.IOWrapper.SetActivePartition("K:"); //Where K: is your partition to make as active.

Пример честно взят вот здесь.

Answer 5

а где бы подучиться такому мастерству.

Answer 6

Как использовать в C# из примера вроде понятно, ну а про сами функции, можно или книжку почитать про WinAPI, или в MSDN.