获取本地硬盘信息

最新推荐文章于 2021-08-06 15:02:51 发布
最新推荐文章于 2021-08-06 15:02:51 发布
阅读量3.3k 收藏 2
点赞数
分类专栏： .Net 文章标签： byte descriptor struct query string

using System;
using System.Runtime.InteropServices;
using System.Text;

namespace driverId
{
    [Serializable]
    public struct HardDiskInfo
    {
        /// <summary>
        /// 型号
        /// </summary>
        public string ModuleNumber;
        /// <summary>
        /// 固件版本
        /// </summary>
        public string Firmware;
        /// <summary>
        /// 序列号
        /// </summary>
        public string SerialNumber;
        /// <summary>
        /// 容量，以M为单位
        /// </summary>
        public uint Capacity;
    }

    #region Internal Structs

    [StructLayout(LayoutKind.Sequential, Pack = 1)]
    internal struct GetVersionOutParams
    {
        public byte bVersion;
        public byte bRevision;
        public byte bReserved;
        public byte bIDEDeviceMap;
        public uint fCapabilities;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
        public uint[] dwReserved; // For future use.
    }

    [StructLayout(LayoutKind.Sequential, Pack = 1)]
    internal struct IdeRegs
    {
        public byte bFeaturesReg;
        public byte bSectorCountReg;
        public byte bSectorNumberReg;
        public byte bCylLowReg;
        public byte bCylHighReg;
        public byte bDriveHeadReg;
        public byte bCommandReg;
        public byte bReserved;
    }

    [StructLayout(LayoutKind.Sequential, Pack = 1)]
    internal struct SendCmdInParams
    {
        public uint cBufferSize;
        public IdeRegs irDriveRegs;
        public byte bDriveNumber;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
        public byte[] bReserved;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
        public uint[] dwReserved;
        public byte bBuffer;
    }

    [StructLayout(LayoutKind.Sequential, Pack = 1)]
    internal struct DriverStatus
    {
        public byte bDriverError;
        public byte bIDEStatus;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)]
        public byte[] bReserved;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)]
        public uint[] dwReserved;
    }

    [StructLayout(LayoutKind.Sequential, Pack = 1)]
    internal struct SendCmdOutParams
    {
        public uint cBufferSize;
        public DriverStatus DriverStatus;
        public IdSector bBuffer;
    }

    [StructLayout(LayoutKind.Sequential, Pack = 1, Size = 512)]
    internal struct IdSector
    {
        public ushort wGenConfig;
        public ushort wNumCyls;
        public ushort wReserved;
        public ushort wNumHeads;
        public ushort wBytesPerTrack;
        public ushort wBytesPerSector;
        public ushort wSectorsPerTrack;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
        public ushort[] wVendorUnique;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 20)]
        public byte[] sSerialNumber;
        public ushort wBufferType;
        public ushort wBufferSize;
        public ushort wECCSize;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)]
        public byte[] sFirmwareRev;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 40)]
        public byte[] sModelNumber;
        public ushort wMoreVendorUnique;
        public ushort wDoubleWordIO;
        public ushort wCapabilities;
        public ushort wReserved1;
        public ushort wPIOTiming;
        public ushort wDMATiming;
        public ushort wBS;
        public ushort wNumCurrentCyls;
        public ushort wNumCurrentHeads;
        public ushort wNumCurrentSectorsPerTrack;
        public uint ulCurrentSectorCapacity;
        public ushort wMultSectorStuff;
        public uint ulTotalAddressableSectors;
        public ushort wSingleWordDMA;
        public ushort wMultiWordDMA;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 128)]
        public byte[] bReserved;
    }

    internal enum STORAGE_PROPERTY_ID
    {
        StorageDeviceProperty = 0,
        StorageAdapterProperty,
        StorageDeviceIdProperty,
        StorageDeviceUniqueIdProperty,
        StorageDeviceWriteCacheProperty,
        StorageMiniportProperty,
        StorageAccessAlignmentProperty
    }
    internal enum STORAGE_QUERY_TYPE
    {
        PropertyStandardQuery = 0,          // Retrieves the descriptor
        PropertyExistsQuery,                // Used to test whether the descriptor is supported
        PropertyMaskQuery,                  // Used to retrieve a mask of writeable fields in the descriptor
        PropertyQueryMaxDefined     // use to validate the value
    }
    [StructLayout(LayoutKind.Sequential, Pack = 1)]
    internal struct STORAGE_PROPERTY_QUERY
    {
        public STORAGE_PROPERTY_ID PropertyId;
        public STORAGE_QUERY_TYPE QueryType;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
        public byte[] AdditionalParameters;
    }


    internal enum STORAGE_BUS_TYPE
    {
        BusTypeUnknown = 0x00,
        BusTypeScsi,
        BusTypeAtapi,
        BusTypeAta,
        BusType1394,
        BusTypeSsa,
        BusTypeFibre,
        BusTypeUsb,
        BusTypeRAID,
        BusTypeiScsi,
        BusTypeSas,
        BusTypeSata,
        BusTypeSd,
        BusTypeMmc,
        BusTypeMax,
        BusTypeMaxReserved = 0x7F
    }
    [StructLayout(LayoutKind.Sequential, Pack = 1)]
    internal struct STORAGE_DEVICE_DESCRIPTOR
    {
        public UInt32 Version;
        public UInt32 Size;
        public byte DeviceType;
        public byte DeviceTypeModifier;
        public byte RemovableMedia;
        public byte CommandQueueing;
        public UInt32 VendorIdOffset;
        public UInt32 ProductIdOffset;
        public UInt32 ProductRevisionOffset;
        public UInt32 SerialNumberOffset;
        public STORAGE_BUS_TYPE BusType;
        public UInt32 RawPropertiesLength;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
        public byte[] RawDeviceProperties;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 1000)]
        public byte[] buffer;
    }

    [StructLayout(LayoutKind.Sequential, Pack = 1)]
    internal struct SRB_IO_CONTROL
    {
        public UInt32 HeaderLength;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)]
        public byte[] Signature;
        public UInt32 Timeout;
        public UInt32 ControlCode;
        public UInt32 ReturnCode;
        public UInt32 Length;

        public SendCmdInParams pin;
    }

    [StructLayout(LayoutKind.Sequential, Pack = 1)]
    internal struct OUT_BUFFER
    {
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 0x1c)]
        public byte[] sic;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 0x10)]
        public byte[] pout;
        public IdSector ids;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 512)]
        public byte[] buffer;
    }
    #endregion

    /// <summary>
    /// ATAPI驱动器相关
    /// </summary>
    public class DeviceID
    {
        #region DllImport
        [DllImport("kernel32.dll", SetLastError = true)]
        static extern int CloseHandle(IntPtr hObject);

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

        [DllImport("kernel32.dll")]
        static extern int DeviceIoControl(IntPtr hDevice,uint dwIoControlCode,IntPtr lpInBuffer,uint nInBufferSize,ref GetVersionOutParams lpOutBuffer,uint nOutBufferSize,ref uint lPBytesReturned,[Out] IntPtr lpOverlapped);

        [DllImport("kernel32.dll")]
        static extern int DeviceIoControl(IntPtr hDevice,uint dwIoControlCode,ref SendCmdInParams lpInBuffer,uint nInBufferSize,ref SendCmdOutParams lpOutBuffer,uint nOutBufferSize,ref uint lpBytesReturned,[Out] IntPtr lpOverlapped);

        [DllImport("kernel32.dll")]
        static extern int DeviceIoControl(IntPtr hDevice, uint dwIoControlCode, ref STORAGE_PROPERTY_QUERY lpInBuffer, uint nInBufferSize, ref STORAGE_DEVICE_DESCRIPTOR lpOutBuffer, uint nOutBufferSize, ref uint lpBytesReturned, [Out] IntPtr lpOverlapped);

        [DllImport("kernel32.dll")]
        static extern int DeviceIoControl(IntPtr hDevice, uint dwIoControlCode, ref SRB_IO_CONTROL lpInBuffer, uint nInBufferSize, ref OUT_BUFFER lpOutBuffer, uint nOutBufferSize, ref uint lpBytesReturned, [Out] IntPtr lpOverlapped);

        const uint DFP_GET_VERSION = 0x00074080;
        const uint DFP_SEND_DRIVE_COMMAND = 0x0007c084;
        const uint DFP_RECEIVE_DRIVE_DATA = 0x0007c088;

        const uint SMART_GET_VERSION = 0x00074080;
        const uint SMART_RCV_DRIVE_DATA = 0x0007c088;

        const uint IOCTL_STORAGE_QUERY_PROPERTY = 0x002d1400;
        const uint IOCTL_SCSI_MINIPORT_IDENTIFY=0x1b0501;
        const uint IOCTL_SCSI_MINIPORT = 0x0004D008;
        const byte IDE_ATA_IDENTIFY = 0xec;

        const uint GENERIC_READ = 0x80000000;
        const uint GENERIC_WRITE = 0x40000000;
        const uint FILE_SHARE_READ = 0x00000001;
        const uint FILE_SHARE_WRITE = 0x00000002;
        const uint CREATE_NEW = 1;
        const uint OPEN_EXISTING = 3;

        const byte ID_CMD = 0xec;

        #endregion

        #region GetHddInfo

        public static string GetHddInfo(byte driveIndex)
        {
            switch (Environment.OSVersion.Platform)
            {
                case PlatformID.Win32Windows:
                    throw new NotSupportedException("Win32s is not supported.");
                case PlatformID.Win32NT:
                    return GetHddInfoAsScsiDriveInNT(driveIndex);
                case PlatformID.Win32S:
                    throw new NotSupportedException("Win32s is not supported.");
                case PlatformID.WinCE:
                    throw new NotSupportedException("WinCE is not supported.");
                default:
                    throw new NotSupportedException("Unknown Platform.");
            }
        }

        #region GetHddInfoNT

        //ReadPhysicalDriveInNTWithAdminRights (void)
        public static string GetHddInfoNTWithAdminRights(byte driveIndex)
        {
            GetVersionOutParams vers = new GetVersionOutParams();
            SendCmdInParams inParam = new SendCmdInParams();
            SendCmdOutParams outParam = new SendCmdOutParams();
            uint bytesReturned = 0;

            // We start in NT/Win2000
            IntPtr hDevice = CreateFile(string.Format(@"\\.\PhysicalDrive{0}", driveIndex), GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, IntPtr.Zero, OPEN_EXISTING, 0, IntPtr.Zero);
            if (hDevice == IntPtr.Zero)
                return "";

            if (DeviceIoControl(hDevice, DFP_GET_VERSION, IntPtr.Zero, 0, ref vers, (uint)Marshal.SizeOf(vers), ref bytesReturned, IntPtr.Zero) == 0)
            {
                CloseHandle(hDevice);
                return "";
            }
            // If IDE identify command not supported, fails
            if ((vers.fCapabilities & 1) == 0)
            {
                CloseHandle(hDevice);
                return "";
            }
            // Identify the IDE drives
            if ((driveIndex & 1) != 0)
            {
                inParam.irDriveRegs.bDriveHeadReg = 0xb0;
            }
            else
            {
                inParam.irDriveRegs.bDriveHeadReg = 0xa0;
            }
            if ((vers.fCapabilities & (16 >> driveIndex)) != 0)
            {
                // We don''t detect a ATAPI device.
                CloseHandle(hDevice);
                return "";
            }
            else
            {
                inParam.irDriveRegs.bCommandReg = 0xec;
            }
            inParam.bDriveNumber = driveIndex;
            inParam.irDriveRegs.bSectorCountReg = 1;
            inParam.irDriveRegs.bSectorNumberReg = 1;
            inParam.cBufferSize = 512;

            if (DeviceIoControl(hDevice, DFP_RECEIVE_DRIVE_DATA, ref inParam, (uint)Marshal.SizeOf(inParam), ref outParam, (uint)Marshal.SizeOf(outParam), ref bytesReturned, IntPtr.Zero) == 0)
            {
                CloseHandle(hDevice);
                return "";
            }
            CloseHandle(hDevice);

            return GetHardDiskInfo(outParam.bBuffer).SerialNumber;
        }
        //ReadPhysicalDriveInNTUsingSmart
        public static string GetHddInfoNTUsingSmart(byte driveIndex)
        {
            GetVersionOutParams vers = new GetVersionOutParams();
            SendCmdInParams inParam = new SendCmdInParams();
            SendCmdOutParams outParam = new SendCmdOutParams();
            uint bytesReturned = 0;

            IntPtr hDevice = CreateFile(string.Format(@"\\.\PhysicalDrive{0}", driveIndex), GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, IntPtr.Zero, OPEN_EXISTING, 0, IntPtr.Zero);
            if (hDevice == IntPtr.Zero)
                return "";

            if (DeviceIoControl(hDevice, SMART_GET_VERSION, IntPtr.Zero, 0, ref vers, (uint)Marshal.SizeOf(vers), ref bytesReturned, IntPtr.Zero) == 0)
            {
                CloseHandle(hDevice);
                return "";
            }

            inParam.irDriveRegs.bCommandReg = ID_CMD;
            if (DeviceIoControl(hDevice, SMART_RCV_DRIVE_DATA, ref inParam, (uint)Marshal.SizeOf(inParam), ref outParam, (uint)Marshal.SizeOf(outParam), ref bytesReturned, IntPtr.Zero) == 0)
                return "";

            CloseHandle(hDevice);

            return GetHardDiskInfo(outParam.bBuffer).SerialNumber;
        }
        //ReadPhysicalDriveInNTWithZeroRights
        public static string GetHddInfoNTWithZeroRights(byte driveIndex)
        {
            IntPtr hDevice = CreateFile(string.Format(@"\\.\PhysicalDrive{0}", driveIndex), 0, FILE_SHARE_READ | FILE_SHARE_WRITE, IntPtr.Zero, OPEN_EXISTING, 0, IntPtr.Zero);
            if (hDevice == IntPtr.Zero)
                return "";

            STORAGE_PROPERTY_QUERY query=new STORAGE_PROPERTY_QUERY();
            query.PropertyId = STORAGE_PROPERTY_ID.StorageDeviceProperty;
            query.QueryType = STORAGE_QUERY_TYPE.PropertyStandardQuery;

            uint bytesReturned = 0;
            STORAGE_DEVICE_DESCRIPTOR descrip=new STORAGE_DEVICE_DESCRIPTOR();
            if (DeviceIoControl(hDevice, IOCTL_STORAGE_QUERY_PROPERTY, ref query, (uint)Marshal.SizeOf(query), ref descrip, (uint)Marshal.SizeOf(descrip), ref bytesReturned, IntPtr.Zero) == 0)
            {
                CloseHandle(hDevice);
                return "";
            }
            CloseHandle(hDevice);

            uint offset = descrip.SerialNumberOffset - 0x25;
            int len=0;
            for(int i=0;i<descrip.buffer.Length;i++)
            {
                if(descrip.buffer[offset+i]==0)
                    break;
                len++;
            }
            byte[] temp=new byte[len];
            for (int i = 0; i < len; i++)
            {
                temp[i] = descrip.buffer[offset + i];
            }

            System.Text.ASCIIEncoding converter = new System.Text.ASCIIEncoding();
            string aa = converter.GetString(temp);
            byte[] mc = new byte[aa.Length/2];
            for (int i = 0; i < aa.Length / 2; i++)
                mc[i] = Convert.ToByte(aa.Substring(i * 2, 2), 16);

            ChangeByteOrder(mc);

            string id = converter.GetString(mc);

            id.Replace(" ", "");

            return id;
        }
        //ReadIdeDriveAsScsiDriveInNT
        public static string GetHddInfoAsScsiDriveInNT(byte driveIndex)
        {
            IntPtr hDevice = CreateFile(string.Format(@"\\.\Scsi{0}:", driveIndex), GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, IntPtr.Zero, OPEN_EXISTING, 0, IntPtr.Zero);
            if (hDevice == IntPtr.Zero)
                return "";

          
            SRB_IO_CONTROL sic = new SRB_IO_CONTROL();
            sic.HeaderLength =0x1c;
            sic.Timeout = 10000;
            sic.Length = 0x211;
            sic.ControlCode = IOCTL_SCSI_MINIPORT_IDENTIFY;
            sic.Signature = new byte[8];
            sic.Signature[0]=(byte)'S';
            sic.Signature[1] = (byte)'C';
            sic.Signature[2] = (byte)'S';
            sic.Signature[3] = (byte)'I';
            sic.Signature[4] = (byte)'D';
            sic.Signature[5] = (byte)'I';
            sic.Signature[6] = (byte)'S';
            sic.Signature[7] = (byte)'K';

            sic.pin.irDriveRegs.bCommandReg = IDE_ATA_IDENTIFY;
            sic.pin.bDriveNumber = driveIndex;

            OUT_BUFFER ob = new OUT_BUFFER();

            uint bytesReturned = 0;
            if (DeviceIoControl(hDevice, IOCTL_SCSI_MINIPORT,ref sic, 0x3c, ref ob, (uint)Marshal.SizeOf(ob), ref bytesReturned, IntPtr.Zero) == 0)
            {
                CloseHandle(hDevice);
                return "";
            }

            IntPtr pnt = Marshal.AllocHGlobal(1000);
           

            CloseHandle(hDevice);

            return (GetHardDiskInfo(ob.ids)).SerialNumber;
        }


        #endregion

        private static HardDiskInfo GetHardDiskInfo(IdSector phdinfo)
        {
            HardDiskInfo hddInfo = new HardDiskInfo();

            ChangeByteOrder(phdinfo.sModelNumber);
            hddInfo.ModuleNumber = Encoding.ASCII.GetString(phdinfo.sModelNumber).Trim();

            ChangeByteOrder(phdinfo.sFirmwareRev);
            hddInfo.Firmware = Encoding.ASCII.GetString(phdinfo.sFirmwareRev).Trim();

            ChangeByteOrder(phdinfo.sSerialNumber);
            hddInfo.SerialNumber = Encoding.ASCII.GetString(phdinfo.sSerialNumber).Trim();

            hddInfo.Capacity = phdinfo.ulTotalAddressableSectors / 2 / 1024;

            return hddInfo;
        }

        private static void ChangeByteOrder(byte[] charArray)
        {
            byte temp;
            for (int i = 0; i < charArray.Length; i += 2)
            {
                temp = charArray[i];
                charArray[i] = charArray[i + 1];
                charArray[i + 1] = temp;
            }
        }
        #endregion
    }
}

纹路猫
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
VB.NET 取磁盘容量信息
12-09 918
在本文中通过，“GetDiskFreeSpaceEx / 取磁盘空闲空间EX”获取到关于磁盘的容量信息 如“磁盘总容量”、“磁盘空闲容量”、“磁盘已用容量”、“调用方可用容量”，有必要著名下 “调用方可用容量”与“磁盘空闲容量”两者近乎相同，但不代表完全相同 两者只是说反馈的 值相近或相同，不代表一定说含义完全等价、 函数示意： GetDiskFreeSpaceEx 取磁盘空闲空间扩
易语言获取本地盘符
08-22
易语言获取本地盘符源码系统结构:磁盘驱动器_, ======窗口程序集1 || ||------__启动窗口_创建完毕 || || ======调用的Dll || ||---[dll]------磁盘驱动器_ 调用的DLL命令: .DLL命令磁盘驱动器_,整数型
Win32 读取硬盘信息实例
Albert_song的博客
02-03 689
WIN32 API读取硬盘信息打开硬盘句柄IDSECTOR方式读取STORAGE_PROPERTY_QUERY方式读取参考 打开硬盘句柄 使用CreateFile方式打开硬盘。 QString filePath = QString("\\\\.\\PhysicalDrive%1").arg(index); fileHandler = CreateFileA(filePath.toLocal8Bit().data(), GENERIC_READ | GEN
windows的磁盘操作之九——区分本地磁盘与移动硬盘
Akin的博客
08-06 1067
转载自：windows的磁盘操作之九——区分本地磁盘与移动硬盘_bunny技术坊的技术博客_51CTO博客 原文如下： 最近碰到了个新问题，记录下来作为windows的磁盘操作那个系列的续篇吧。 一些时候我们的程序需要区分本地存储设备和USB存储设备。在网上搜一搜一般会找到一个最直接的API，GetDriveType，其原型为 UINT GetDriveType(LPCTSTR lpRootPathName) 参数lpRootPathName是存储设备的根目录，例如C:\，返回值即为设备类型。
实战DeviceIoControl：通过API访问设备驱动程序
legion8169的专栏
07-06 3946
Q 在MSDN的那个demo中，将设备名换成“A:”取A盘参数，先用资源管理器读一下盘，再运行这个程序可以成功，但换一张盘后就失败；换成“CDROM0”取CDROM参数，无论如何都不行。这个问题如何解决呢？A 取软盘参数是从软盘上读取格式化后的信息，也就是必须执行读操作，这一点与硬盘不同。将CreateFile中的访问方式改为GENERIC_READ就行了。IOCTL_DISK_GET_DRI
实战DeviceIoControl 系列 之四：获取硬盘的详细信息
09-05 2386
实战DeviceIoControl 之四：获取硬盘的详细信息 Q 用IOCTL_DISK_GET_DRIVE_GEOMETRY或IOCTL_STORAGE_GET_MEDIA_TYPES_EX只能得到很少的磁盘参数，我想获得包括硬盘序列号在内的更加详细的信息，有什么办法呀？ A 确实，用你所说的I/O控制码，只能得到最基本的磁盘参数。获取磁盘出厂信息的I/O控制码，微软在VC/
VC学习资料收集（25）：获取硬盘ID信息及网卡MAC地址的代码
王君的专栏
01-07 1万+
获取硬盘ID信息及网卡MAC地址的代码作者：佚名     点击数： 473    更新时间：2003-7-30转贴于 华夏黑客同盟 http://www.77169.org // Posted by coldsnake/*+++HDID.CPPWritten by Lu Linhttp://lu0.126.com2000.11.3---*/#incl
C# 获取本地磁盘目录 实例源码（文件处理）
04-26
C# 获取本地磁盘目录 实例源码（文件处理）
Delphi获取当前磁盘信息和磁盘空间信息
12-14
Delphi10.3获取当前磁盘、磁盘空间、扇区字节等信息；仅供初学者交流学习
获取本地硬盘大小.html
06-30
获取本地硬盘大小.html js代码！修改后，可以获取本地C、D、E、F...盘的大小！ 若提示：automation 服务器不能创建对象请修改activeX控件。 IE：如果Javascript脚本中报这个错误是因为IE的安全设置不允许运行未标记...
获取本地磁盘的相关信息
07-04
包括获取内存，机器名，IP，物理内存，等相关信息
读取光驱序列号、型号、分位
Tody Guo的专栏
05-19 6723
获取光驱序列号、分位、型号代码 #include "StdAfx.h" #include #include #include #include #include #include #include #define debug 1 void ChangeByteOrder(PCHAR szString, USHORT uscStrSize) {
VC++获取网卡MAC、硬盘序列号、CPU ID、BIOS编号
Never too late to study
02-21 2838
以下代码可以取得系统特征码（网卡MAC、硬盘序列号、CPU ID、BIOS编号）    BYTE szSystemInfo[4096]; // 在程序执行完毕后，此处存储取得的系统特征码    UINT uSystemInfoLen = 0; // 在程序执行完毕后，此处存储取得的系统特征码的长度    // 网卡 MAC 地址，注意: MAC 地址是可以在注册表中修改的     {
VB取硬盘的物理序列号
barenx的专栏
03-31 3143
网上有很多获取硬盘序列号的代码，大部分都只能取得逻辑分区的序列号，而不能取得硬盘的物理序列号；或虽然能取得物理序号，但需要外带一个VC编写的DLL文件......我们知道，逻辑分区的序列号是FORMAT时产生的，重新FORMAT将会改变，这对于要求唯一识别码的程式来说是致命的。下面的 VB 代码利用 Windows API 可以取得物理硬盘的很多特性，包括硬盘出厂时的唯一编号。这段代码我是从 CS
vb获取cpuid 硬盘物理序列号和逻辑盘序列号 的方法
热门推荐
志超的专栏
07-13 1万+
vb获取硬盘物理序列号和逻辑盘序列号
Qt获取本机硬盘序列号，不受IDE硬盘与SCSI硬盘类型影响
Heyuzhe1996的博客
03-30 7305
以下是在Qt下可以直接使用的代码，如果想在其他平台使用请修改一些内容： #pragma argsused #define DFP_GET_VERSION 0x00074080 #define DFP_SEND_DRIVE_COMMAND 0x0007c084 #define DFP_RECEIVE_DRIVE_DATA 0x0007c088 #define SEND
如何获取硬盘序列号
weixin_33755649的博客
05-20 767
如何获取硬盘序列号？ 作者：cg1摘自：access911.net编辑：cg1更新日期：2003-8-2浏览人次： 2255 专题地址： [url]http://www.access911.net/?kbid;77FAB01E10DC[/url] 简述：如何获取硬盘序列号？ 阅读前需掌握： 难度等级： 等级未评定 ...
node-v12.16.3-x86.msi
最新发布
04-25
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
云计算基础课件—架构dr.pptx
04-25
云计算基础课件—架构dr.pptx
将获取的数据通过IO流保存到本地磁盘
05-18
好的，您可以使用以下代码将数据保存到本地磁盘： ```python import os # 保存数据到本地磁盘 def save_data_to_disk(data, file_path): # 创建目录 dir_path = os.path.dirname(file_path) if not os.path....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值