C# 目录、文件操作【分分快三计划】

作者:编程技术

五、多少个措施

Copy()------将文件复制到规定的职位

string path = @"f:t.txt";
//制造并写入(将蒙蔽原来就有文件)
if (!File.Exists(path))
{
    using (StreamWriter sw = File.CreateText(path))
    {
        sw.WriteLine("Hello");
    }
}
//读取文件
using (StreamReader sr = File.OpenText(path))
{
    string s = "";
    while ((s = sr.ReadLine()) != null)
    {
        Console.WriteLine(s);
    }
}
//删除/拷贝
try
{
    File.Delete(path);
    File.Copy(path, @"f:tt.txt");
}
catch (Exception e)
{
    Console.WriteLine("The process failed: {0}", e.ToString());

2.FileStream参数的坑

Long offset是明确文件指针以字节为单位的移位间隔;SeekOrigin origin是规定在此以前妄图的最初地点,此枚举包罗3个值:Begin,Current和End。

NetworkStream//互联互联网上的流 

本身的Usb设备是半双工的,並且数据唯有64字节,全体用了联合读。

Create()------在明确的恢蒙洗唇ㄎ募?/FONT>

string[] str=Directory.GetFileSystemEntries(@"D:");//获取钦点目录中的目录及文件名

诚如会重临繁多少个文本名,那哪个是您要的呢?方法有二:

Append------若是文件存在,就张开文件,将文件地方移动到文件的结尾,并创办一个新文件。FileMode.Append仅能够与枚举FileAccess.Write联合使用

BufferedStream//为诸如互连网流的别样流加多缓冲的风流罗曼蒂克种流类型

 3.Write的巨坑

StreamReader------从流中读取字符数据,并可透过利用FileStream被创建为基类。

Encoding e1 = Encoding.Default;//获得本页暗中认可代码 
Byte[] bytes = e1.GetBytes("中黄炎子孙民共和国人民解放军"); //转为二进制

_UsbFileStream = new FileStream(new SafeFileHandle(fileHandle, true), FileAccess.ReadWrite, System.Math.Max(caps.OutputReportByteLength, caps.InputReportByteLength), true);

FullName------检索文件的完好路线

Stream//对字节的读写操作(富含对异步操作的援助)

1.CreateFile参数的坑

FileMode枚举具有三种成员:

fs.Close(); 

都以从种种地点复制过来的。最终的协会注释从微软那里复制了乌克兰(Ukraine)语,翻译了一句中文。因为这一个坑最大。

   例3:aFile.Seek(-5,SeekOrigin.End)//在文件末端地点上马,尾数5个字节。

StringReader和StringWriter//在字符串中读写字符 

        private int _InputBufferSize;
        private int _OutputBufferSize;
        private FileStream _UsbFileStream = null;

     当在.NET代码中规定路线名时,您能够行使相对化路线名,也足以行使相对路行名。相对路线名显式地规定文件或目录来自于哪—个己知的职责——举个例子是c:驱动器。它的—个轨范是C:\work\LogFile.txt。注意它淮确地定义了其地点。

FileStream//文件流操作 

             if (_UsbFileStream == null)
                 throw new Exception("Usb设备未有开端化");

DirectoryInfo------代表磁盘上的大意目录,具备可以拍卖此目录的法子

五、流文件操作 

太小读写错误,大点就如无妨

写入文件:

要读写,首先要开采

写入数据的流程是先拿走字节数组,再把字节数据转变为字符数组,然后把那几个字符数组用Write()方法写入到文件中,当然在写入的进程中,能够规定在文件的什么样岗位写入,写多少字符等等。

string str = Encoding.GetEncoding("UTF-8").GetString(bytes); //转回UTF-8编码 

本身动用2,然后User.config里面把他记下来。

在.NET Framework中张开的有所的输入和出口职业都要运用到流。流是串行化设备的用空想来安慰自己串行化设备能够以线性形式存款和储蓄数据,并得以以同等的艺术访问:一回访谈—个字节。此设备能够是磁盘文件、打字与印刷机、内部存款和储蓄器地点和或其它其余支持以线性方式读写的靶子。

二、目录操作

三、Dll封装

   例2:afile.Seek(2,SeekOrigin.Current)//在近些日子职责上马,再移动2个字节。

string name = "Test.data";
//张开文件或通过File创立fs = File.Create(path, 1024)
FileStream fs = new FileStream(name, FileMode.CreateNew);
//转变为字节 写入数据(可写入中文)
Byte[] info = new UTF8Encoding(true).GetBytes("This is some text in the file.");
//字节数组,字节偏移量,最多写入的字节数
fs.Write(info, 0, info.Length);
fs.Close();
//展开文件
fs = new FileStream(name, FileMode.Open, FileAccess.Read);
//读取
BinaryReader r = new BinaryReader(fs);
for (int i = 0; i < 11; i )
{
    Console.WriteLine(r.ReadInt32());
}

        /// <summary>
        /// 过滤设备,获取需要的设备
        /// </summary>
        /// <param name="ClassGuid"></param>
        /// <param name="Enumerator"></param>
        /// <param name="HwndParent"></param>
        /// <param name="Flags"></param>
        /// <returns></returns>
        [DllImport("setupapi.dll", SetLastError = true)]
        private static extern IntPtr SetupDiGetClassDevs(ref Guid ClassGuid, uint Enumerator, IntPtr HwndParent, DIGCF Flags);
        /// <summary>
        /// 获取设备,true获取到
        /// </summary>
        /// <param name="hDevInfo"></param>
        /// <param name="devInfo"></param>
        /// <param name="interfaceClassGuid"></param>
        /// <param name="memberIndex"></param>
        /// <param name="deviceInterfaceData"></param>
        /// <returns></returns>
        [DllImport("setupapi.dll", CharSet = CharSet.Auto, SetLastError = true)]
        private static extern Boolean SetupDiEnumDeviceInterfaces(IntPtr hDevInfo, IntPtr devInfo, ref Guid interfaceClassGuid, UInt32 memberIndex, ref SP_DEVICE_INTERFACE_DATA deviceInterfaceData);
        /// <summary>
        /// 获取接口的详细信息 必须调用两次 第1次返回长度 第2次获取数据
        /// </summary>
        /// <param name="deviceInfoSet"></param>
        /// <param name="deviceInterfaceData"></param>
        /// <param name="deviceInterfaceDetailData"></param>
        /// <param name="deviceInterfaceDetailDataSize"></param>
        /// <param name="requiredSize"></param>
        /// <param name="deviceInfoData"></param>
        /// <returns></returns>
        [DllImport("setupapi.dll", SetLastError = true, CharSet = CharSet.Auto)]
        private static extern bool SetupDiGetDeviceInterfaceDetail(IntPtr deviceInfoSet, ref SP_DEVICE_INTERFACE_DATA deviceInterfaceData, IntPtr deviceInterfaceDetailData, int deviceInterfaceDetailDataSize, ref int requiredSize, SP_DEVINFO_DATA deviceInfoData);
        /// <summary>
        /// 删除设备信息并释放内存
        /// </summary>
        /// <param name="HIDInfoSet"></param>
        /// <returns></returns>
        [DllImport("setupapi.dll", CharSet = CharSet.Auto, SetLastError = true)]
        private static extern Boolean SetupDiDestroyDeviceInfoList(IntPtr HIDInfoSet);


        /// <summary>
        /// 获取设备文件
        /// </summary>
        /// <param name="lpFileName"></param>
        /// <param name="dwDesiredAccess">access mode</param>
        /// <param name="dwShareMode">share mode</param>
        /// <param name="lpSecurityAttributes">SD</param>
        /// <param name="dwCreationDisposition">how to create</param>
        /// <param name="dwFlagsAndAttributes">file attributes</param>
        /// <param name="hTemplateFile">handle to template file</param>
        /// <returns></returns>
        [DllImport("kernel32.dll", SetLastError = true)]
        private static extern IntPtr CreateFile(string lpFileName, uint dwDesiredAccess, uint dwShareMode, uint lpSecurityAttributes, uint dwCreationDisposition, uint dwFlagsAndAttributes, uint hTemplateFile);
        [DllImport("kernel32.dll", SetLastError = true)]
        [return: System.Runtime.InteropServices.MarshalAsAttribute(System.Runtime.InteropServices.UnmanagedType.Bool)]
        private static extern bool WriteFile(System.IntPtr hFile, byte[] lpBuffer, uint nNumberOfBytesToWrite, out uint lpNumberOfBytesWritten, IntPtr lpOverlapped);
        [DllImport("kernel32.dll", SetLastError = true)]
        private static extern int CloseHandle(int hObject);

        /// <summary>
        /// 获得GUID
        /// </summary>
        /// <param name="HidGuid"></param>
        [DllImport("hid.dll")]
        private static extern void HidD_GetHidGuid(ref Guid HidGuid);
        [DllImport("hid.dll")]
        private static extern Boolean HidD_GetPreparsedData(IntPtr hidDeviceObject, out IntPtr PreparsedData);
        [DllImport("hid.dll")]
        private static extern uint HidP_GetCaps(IntPtr PreparsedData, out HIDP_CAPS Capabilities);
        [DllImport("hid.dll")]
        private static extern Boolean HidD_FreePreparsedData(IntPtr PreparsedData);
        [DllImport("hid.dll")]
        private static extern Boolean HidD_GetAttributes(IntPtr hidDevice, out HID_ATTRIBUTES attributes);

文件读写的圭表:

生机勃勃、文件操作

 

namespace CommaValues
{
     class Program
     {
         static void Main(string[] args)
         {
             while (true)
             {
                 string strLine;
                 string[] strArray;
                 char[] charArray = new Char[] { ‘,‘ };
                 Console.Write("请输入文件内容以逗号分隔的文件路径及文件名:");
                 string name = Console.ReadLine();

四、文本文件操作 

Usb设备的读写跟磁盘文件的读写没分别,需求展开文件、读文件、写文件,最终关闭文件。

 
◆StreamWriter对像

MemoryStream//无缓冲的流 

            byte[] inBuffer = new byte[_InputBufferSize];
            _UsbFileStream.Read(inBuffer, 0, _InputBufferSize);
            return inBuffer;
        }

Create------创设新文件;要是存在这里么的文书,就破坏它。

System.Diagnostics.Process.Start("Explorer.exe", ”); 

        private const short INVALID_HANDLE_VALUE = -1;
        private const uint GENERIC_READ = 0x80000000;
        private const uint GENERIC_WRITE = 0x40000000;
        private const uint FILE_SHARE_READ = 0x00000001;
        private const uint FILE_SHARE_WRITE = 0x00000002;
        private const uint CREATE_NEW = 1;
        private const uint CREATE_ALWAYS = 2;
        private const uint OPEN_EXISTING = 3;
        private const uint FILE_FLAG_OVERLAPPED = 0x40000000;
        private const uint FILE_ATTRIBUTE_NORMAL = 0x00000080; 

FileStream aFile=new FileStream(”Log.txt”,fileMode.OpenOrCreate,FileAccess.Write)

//打开文件夹
System.Diagnostics.Process.Start(FilePath);
//张开文件夹中某些文件
System.Diagnostics.Process.Start(FilePath "/" FileName);
//张开文件夹并当选单个文件
System.Diagnostics.Process.Start("Explorer", "/select,"  FilePath "" FileName);
//或
System.Diagnostics.Process.Start("Explorer.exe", "/select,"  FilePath "" FileName);
//用IE展开文件
System.Diagnostics.Process.Start("Explorer",FilePath "" FileName);
System.Diagnostics.Process.Start("Explorer.exe",FilePath "" FileName);
//注:(explorer,explorer.exe,select,不区分朗朗上口写,"/selecet,"个中"/,"都不可能少,File帕特h为文件路径不包涵文件名)
//张开文件夹并当选网页

四、几特本性

例:
using System;
using System.Collections.Generic;
using System.Text;
using System.IO;

StreamReader和StreamWriter//在流中读写字符 

        /// <summary>
        /// 构造
        /// </summary>
        /// <param name="usbFileName">Usb Device Path</param>
        public UsbApi(string usbFileName)
        {
            if (string.IsNullOrEmpty(usbFileName))
                throw new Exception("文件名不能为空");

            var fileHandle = CreateFile(
                 usbFileName,
                 GENERIC_READ | GENERIC_WRITE,// | GENERIC_WRITE,//读写,或者一起
                 FILE_SHARE_READ | FILE_SHARE_WRITE,//共享读写,或者一起
                 0,
                 OPEN_EXISTING,//必须已经存在
                 FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED,
                 0);
            if (fileHandle == IntPtr.Zero || (int)fileHandle == -1)
                throw new Exception("打开文件失败");

            HidD_GetAttributes(fileHandle, out var attributes);// null);// out var aa);
            HidD_GetPreparsedData(fileHandle, out var preparseData);
            HidP_GetCaps(preparseData, out var caps);
            HidD_FreePreparsedData(preparseData);
            _InputBufferSize = caps.InputReportByteLength;
            _OutputBufferSize = caps.OutputReportByteLength;

            _UsbFileStream = new FileStream(new SafeFileHandle(fileHandle, true), FileAccess.ReadWrite, System.Math.Max(caps.OutputReportByteLength, caps.InputReportByteLength), true);
        }

Truncate------张开现成文件,清除其内容,然后大家能够向文件写入崭新的数量,不过保留文件的起头创造日期,必需存在有文件,不然就抛出拾叁分

string[] drives = Directory.GetLogicalDrives();//本地驱动器名称
string path = Directory.GetCurrentDirectory();//获取应用程序的当前工作目录
string[] files = Directory.GetFiles(@"D:Projects");//获取内定目录中的文件名
string[] directories= Directory.GetDirectories(@"D:");//获取钦赐目录中的目录名
DirectoryInfo di = new DirectoryInfo(@"D:MyDir1");//构造函数创造目录
di.Create();
DirectoryInfo di1 = Directory.CreateDirectory(@"D:MyDir2");//创设对象并创立目录
DirectoryInfo di2 = di.CreateSubdirectory("SubDir");//以相对路线创造子目录

 

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;

三、编码调换 

1.先获取三遍文件名列表,然后插拔或然剥夺启用一回Usb设备,变化的丰富就是

             try
             {
                 FileStream aFile = new FileStream("", FileMode.Open);//实例化三个FileStream对象,用来操作data.txt文件,操作类型是
               
                 aFile.Seek(55, SeekOrigin.Begin);//把公文指针指向,从文件早先地点向前五15位字节所指的字节
                 aFile.Read(byData, 0, 100);//读取FileStream对象所指的公文到字节数组里
             }
             catch (IOException e)
             {
                 Console.WriteLine("close");
                 return;
             }
             Decoder d = Encoding.UTF8.GetDecoder();//
             d.GetChars(byData, 0, byData.Length, charData, 0);//将编码字节数组转变为字符数组

向文件中追加文本 File.AppendText FileInfo.AppendText
重命名或移动文件 File.Move FileInfo.MoveTo
删除文件 File.Delete FileInfo.Delete
复制文件 File.Copy FileInfo.CopyTo
获取文件大小 FileInfo.Length
获取文件属性 File.GetAttributes
设置文件属性 File.SetAttributes
确定文件是否存在 File.Exists
检索文件扩展名 Path.GetExtension
检索文件的完全限定路径 Path.GetFullPath
检索路径中的文件名和扩展名 Path.GetFileName
更改文件扩展名 Path.ChangeExtension

现将种种坑和自身要好的一些推断记录一下,也供各位参照他事他说加以考查。

行使FileStream类读取数据不像使用StreamReader和StreamWriter类读取数据那么轻易,那是因为FileStream类只可以管理原始字节(raw byey),那使得FileStream类能够用于别的数据文件,而不仅仅是文件文件,通过读取字节数据就足以读取相通图像和声音的文本。这种灵活性的代价是无法采用它平素读入字符串,而采纳StreamWriter和StreaMeader类却可以那样管理,从是有三种转变类能够非常轻易地将字节数组调换为字符数组,也许实行相反的操作。

BinaryReader和BinaryWriter//从字符串或原始数据到各类流之间的读写操作 

(二)打开Usb设备

StreamWriter类有多个着力的艺术read和readLine

二、结构、枚举、类定义

FileStream对象的构造函数:

public void Write(byte[] data)
这个data长度必须与缓冲区大写一样,而且数据要从data[1]开始写,如你要写“AB”,
var data=new byte[]{0,(byte)'A',(byte)'B'};

事后发现HIDP_CAPS里面的某个值可能告诉我了。

趟了这些坑后,搞定了,能用线程了^-^,发文纪念。

FileStream对象表示在磁盘或互连网路线上针对文件的流。当类提供向文件读写字节的诀要时,平常采用StreamReader或StreamWriter实施那么些效率。那是因为FileStream类操作字节和字节数组,而Stream类操作字符数量。字符数据易于使用,可是多少操作比方随机文件访谈,就必须要由FileStream对象实行。

(意气风发)获取具备Usb设备文件名

fileInfo类提供了下边包车型的士关于基础性的文本的习性,这么些属性也许用来更新文件。

        /// <summary>
        /// 写数据
        /// </summary>
        /// <param name="array"></param>
        public void Write(byte[] data)
        {
            if (_UsbFileStream == null)
                throw new Exception("Usb设备没有初始化");
            if (data.Length > _OutputBufferSize)
                throw new Exception($"数据太长,超出缓冲区长度({_OutputBufferSize})");
            byte[] outBuffer = new byte[_OutputBufferSize];
            Array.Copy(data, 0, outBuffer, 1, data.Length);
            _UsbFileStream.Write(outBuffer, 0, _OutputBufferSize);
        }

用作实用类,File和Directory类都提供了无数方法,用于拍卖文件系统以至个中的文件和目录。那几个是静态方法,涉及移动文件、查询和校勘属性并创办FileStream对象。

        /// <summary>
        /// 同步读
        /// </summary>
        /// <param name="array"></param>
        public byte[] Read()
        {

File类一些最常用的静态方法:

 var fileHandle = CreateFile(
                 usbFileName,
                 GENERIC_READ | GENERIC_WRITE,// | GENERIC_WRITE,//读写,或者一起
                 FILE_SHARE_READ | FILE_SHARE_WRITE,//共享读写,或者一起
                 0,
                 OPEN_EXISTING,//必须已经存在
                 FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED,
                 0);
这些参数是针对我的Usb设备,各种调整后达到了能读写、能异步。

CreationTime------拿到当前文件的创导日期和时间

生机勃勃、常量定义

OpenOrCreate------若是文件存在,则分明张开文件,不然就创办新文件,假诺文件已经存在,则保留在文书中的数据

谈到底写了几行代码测量检验,巨坑:

例:
using System;
using System.Collections.Generic;
using System.Text;
using System.IO;

        public void Close()
        {
            if (_UsbFileStream != null)
                _UsbFileStream.Close();
        }

Path------ 实用类,用于拍卖渠道名称。

2.轮岗写然后读一次文件名,获取到精确结果的便是

◆FileStream对象

缓冲区大大小小最后使用 System.Math.马克斯(caps.OutputReportByteLength, caps.InputReportByteLength)

GetDirectories()------重返表示当前目录之下的目录的Directory对像的数组

        /// <summary>
        /// 获取所有Usb设备文件名
        /// </summary>
        /// <returns></returns>
        public static List<string> GetUsbFileNames()
        {
            List<string> items = new List<string>();

            //通过一个空的GUID来获取HID的全局GUID。
            Guid hidGuid = Guid.Empty;
            HidD_GetHidGuid(ref hidGuid);

            //通过获取到的HID全局GUID来获取包含所有HID接口信息集合的句柄。
            IntPtr hidInfoSet = SetupDiGetClassDevs(ref hidGuid, 0, IntPtr.Zero, DIGCF.DIGCF_PRESENT | DIGCF.DIGCF_DEVICEINTERFACE);

            //获取接口信息。
            if (hidInfoSet != IntPtr.Zero)
            {

                SP_DEVICE_INTERFACE_DATA interfaceInfo = new SP_DEVICE_INTERFACE_DATA();
                interfaceInfo.cbSize = Marshal.SizeOf(interfaceInfo);

                uint index = 0;
                //检测集合的每个接口
                while (SetupDiEnumDeviceInterfaces(hidInfoSet, IntPtr.Zero, ref hidGuid, index, ref interfaceInfo))
                {
                    int bufferSize = 0;
                    //获取接口详细信息;第一次读取错误,但可取得信息缓冲区的大小
                    SP_DEVINFO_DATA strtInterfaceData = new SP_DEVINFO_DATA();
                    var result = SetupDiGetDeviceInterfaceDetail(hidInfoSet, ref interfaceInfo, IntPtr.Zero, 0, ref bufferSize, null);
                    //第二次调用传递返回值,调用即可成功
                    IntPtr detailDataBuffer = Marshal.AllocHGlobal(bufferSize);
                    Marshal.StructureToPtr(
                        new SP_DEVICE_INTERFACE_DETAIL_DATA
                        {
                            cbSize = Marshal.SizeOf(typeof(SP_DEVICE_INTERFACE_DETAIL_DATA))
                        }, detailDataBuffer, false);


                    if (SetupDiGetDeviceInterfaceDetail(hidInfoSet, ref interfaceInfo, detailDataBuffer, bufferSize, ref bufferSize, null))// strtInterfaceData))
                    {
                        string devicePath = Marshal.PtrToStringAuto(IntPtr.Add(detailDataBuffer, 4));
                        items.Add(devicePath);
                    }
                    Marshal.FreeHGlobal(detailDataBuffer);
                    index  ;
                }
            }
            //删除设备信息并释放内存
            SetupDiDestroyDeviceInfoList(hidInfoSet);
            return items;
        }

拜会品级

        private struct HID_ATTRIBUTES
        {
            public int Size;
            public ushort VendorID;
            public ushort ProductID;
            public ushort VersionNumber;
        }
        private struct SP_DEVICE_INTERFACE_DATA
        {
            public int cbSize;
            public Guid interfaceClassGuid;
            public int flags;
            public int reserved;
        }
        [StructLayout(LayoutKind.Sequential)]
        private class SP_DEVINFO_DATA
        {
            public int cbSize = Marshal.SizeOf<SP_DEVINFO_DATA>();
            public Guid classGuid = Guid.Empty;
            public int devInst = 0;
            public int reserved = 0;
        }
        [StructLayout(LayoutKind.Sequential, Pack = 2)]
        private struct SP_DEVICE_INTERFACE_DETAIL_DATA
        {
            internal int cbSize;
            internal short devicePath;
        }
        private enum DIGCF
        {
            DIGCF_DEFAULT = 0x1,
            DIGCF_PRESENT = 0x2,
            DIGCF_ALLCLASSES = 0x4,
            DIGCF_PROFILE = 0x8,
            DIGCF_DEVICEINTERFACE = 0x10
        }
        [StructLayout(LayoutKind.Sequential)]
        private struct HIDP_CAPS
        {
            /// <summary>
            /// Specifies a top-level collection's usage ID.
            /// </summary>
            public System.UInt16 Usage;
            /// <summary>
            /// Specifies the top-level collection's usage page.
            /// </summary>
            public System.UInt16 UsagePage;
            /// <summary>
            /// 输入报告的最大节数数量(如果使用报告ID,则包含报告ID的字节)
            /// Specifies the maximum size, in bytes, of all the input reports (including the report ID, if report IDs are used, which is prepended to the report data).
            /// </summary>
            public System.UInt16 InputReportByteLength;
            /// <summary>
            /// Specifies the maximum size, in bytes, of all the output reports (including the report ID, if report IDs are used, which is prepended to the report data).
            /// </summary>
            public System.UInt16 OutputReportByteLength;
            /// <summary>
            /// Specifies the maximum length, in bytes, of all the feature reports (including the report ID, if report IDs are used, which is prepended to the report data).
            /// </summary>
            public System.UInt16 FeatureReportByteLength;
            /// <summary>
            /// Reserved for internal system use.
            /// </summary>
            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 17)]
            public System.UInt16[] Reserved;
            /// <summary>
            /// pecifies the number of HIDP_LINK_COLLECTION_NODE structures that are returned for this top-level collection by HidP_GetLinkCollectionNodes.
            /// </summary>
            public System.UInt16 NumberLinkCollectionNodes;
            /// <summary>
            /// Specifies the number of input HIDP_BUTTON_CAPS structures that HidP_GetButtonCaps returns.
            /// </summary>
            public System.UInt16 NumberInputButtonCaps;
            /// <summary>
            /// Specifies the number of input HIDP_VALUE_CAPS structures that HidP_GetValueCaps returns.
            /// </summary>
            public System.UInt16 NumberInputValueCaps;
            /// <summary>
            /// Specifies the number of data indices assigned to buttons and values in all input reports.
            /// </summary>
            public System.UInt16 NumberInputDataIndices;
            /// <summary>
            /// Specifies the number of output HIDP_BUTTON_CAPS structures that HidP_GetButtonCaps returns.
            /// </summary>
            public System.UInt16 NumberOutputButtonCaps;
            /// <summary>
            /// Specifies the number of output HIDP_VALUE_CAPS structures that HidP_GetValueCaps returns.
            /// </summary>
            public System.UInt16 NumberOutputValueCaps;
            /// <summary>
            /// Specifies the number of data indices assigned to buttons and values in all output reports.
            /// </summary>
            public System.UInt16 NumberOutputDataIndices;
            /// <summary>
            /// Specifies the total number of feature HIDP_BUTTONS_CAPS structures that HidP_GetButtonCaps returns.
            /// </summary>
            public System.UInt16 NumberFeatureButtonCaps;
            /// <summary>
            /// Specifies the total number of feature HIDP_VALUE_CAPS structures that HidP_GetValueCaps returns.
            /// </summary>
            public System.UInt16 NumberFeatureValueCaps;
            /// <summary>
            /// Specifies the number of data indices assigned to buttons and values in all feature reports.
            /// </summary>
            public System.UInt16 NumberFeatureDataIndices;
        }

Move()------将分明的目录移动到新任务。能够在新岗位为文件夹规定贰个新名称

哪弄来的?头大了吧,作者也头大,什么鬼?百度了,未果,所以索性不管了。先来三个列出任何Usb设备文件名的办法

     前面那一个Boolean值规定是附加文件依然创制新文件,借使此值为false,则就创立一个新文件,大概截取现成文件并开采它。假设此值设置为true,则展开文件,保留原本的数码,假诺找不到文件,则开创叁个新文件。注意:当成立FileStream对象时,您不可能获得选项的限制。除了使用Boolean值附加或创办新文件外,大家根本就无法像使用FileStream类时那么规定FileMode属性;并且,您也无力回天设置FileAccess属性.由此你总是有着对文本的读写特权,为了利用其余高端参数,您必需在FileStream构造函数中鲜明这一个参数,然后在FileStream对象中开创StreamWriter。

(三)写

   读取数据

重在用于CreateFile时用。

当向一些外界对象写多少时,将要动用输出流,那足以是大要磁盘文件、互联网地方、打字与印刷机或其余程序。

烦心了,想自身一向通过usb读写,种种百度,然后是成百上千的坑,最后化解。

  StreamWriter sw = new StreamWriter(“Log.txt”,true);

厂商用了生机勃勃台发卡机,usb接口,半双工,给了个dll,不帮忙线程操作,使得UI线程老卡。

CreateDirectory()------创制具备规定路线的目录

六、最后

1.读取文件

展开Usb设备作者是在构找函数里面完毕的,作者的类名称叫UsbApi。

读取文件
 using System;
using System.Collections.Generic;
using System.Text;
using System.IO;

磁盘文件大家都通晓,举例“c:datahello.txt”就是个文本名,前边加“\计算机A”则是其余Computer上的某文件名,Usb设备也可以有文件名,如自个儿的设备的文件名正是“\?hid#vid_5131&pid_2007#7&252e9bc9&0&0000#{4d1e55b2-f16f-11cf-88cb-001111000030}”。

namespace myFile
{
     class Program
     {
         static void Main(string[] args)
         {
             byte[] byData = new byte[100];//创设多个FileStream要用的字节组
             char[] charData = new char[100];//创建四个字符组

(五)关闭

FileStream aFile = new FileStream(“Log.txt”,FileMode.OpenOrCreate);

(四)读

 
◆StreamReader对象

namespace StreamReaderTest
{
     class Program
     {
       
         static void Main(string[] args)
         {
             string strLine;
             try
             {
                 Console.Write("请输入文件路径及文件名:");
                 string mess = Console.ReadLine();
                 FileStream aFile = new FileStream(mess, FileMode.Open);
                 Stream里德r sr = new StreamReader(aFile);//用FileStream对象实例化二个StreamReader对象
                 //strLine = sr.ReadToEnd();//读取完整的文书,借使用这些措施,就可以绝不上边包车型大巴while循环
                 strLine = sr.ReadLine();//   读取后生可畏行字符并赶回
                 while (strLine != null)
                 {
                     Console.WriteLine(strLine);
                     strLine = sr.ReadLine();
                 }
                 sr.Close();
                 Console.ReadLine();
             }
             catch (IOException e)
             {
                 Console.WriteLine("an IOexception has been thrown!");
                 Console.WriteLine(e.ToString());
                 return;
             }
             return;
         }
     }
}

      FileAccess枚举有三种等级次序:Read、Write、ReadWrite.此属性的法力是:基于顾客的身份验证等第更动客户对文本的拜候

Open------张开现存的文本,但是不设有所钦定的公文,则抛出十三分

FileInfo类不像File类,它未有静态方法,仅可用于实例化的对像。FileInfo对像表示在磁盘或互连网地方的文书,注意它不是流,为了读写文件,必得创建Stream对像。

Directory------实用类,提供多数静态方法,用于移动、删除和复制目录。

StreamWriter sw = new StreamWriter(aFile);

Open()-------在分明的路径上回来FileStream对像

也可直接从文件中开创StreamWriter对象:

Public int Read(byte[] array,int offset, int count)//第贰个参数是被传输进来的字节数组,用以选用FileStream对象中的数据。第4个参数是字节数组中开首写入数据的职位,它平时是0,表示从数组的启幕的文书中向数组写多少,尾数参数是规定从文件中读出有个别字节。

                     strLine = sr.ReadLine();
                     while (strLine != null)
                     {
                         strArray = strLine.Split(charArray);
                         for (int x = 0; x <= strArray.GetUpperBound(0); x )
                         {
                             Console.WriteLine(strArray[x].Trim());
                         }
                         strLine = sr.ReadLine();
                     }
                     sr.Close();
                     //Console.ReadLine();
                 }
                 catch (IOException e)
                 {
                     Console.WriteLine(e.ToString());
                     return;
                 }
                 //return;
             }
         }
     }
}

Name------仅仅重回文件的名号,实际不是总体的公文位置路线、

例:
using System;
using System.Collections.Generic;
using System.Text;
using System.IO;

FileStream-------表示能够被写或被读,或双边都可的公文,此文件能够一同或异步读和写

File------实用类,提供点不清静态方法,用于移动、删除、和复制文件。

◆File和Directory类

Exists------决断是还是不是存在文件

GetFiles()-------重回在当前目录中的File对像的数组

ReadEnd()方法读小文件最佳,它直接读取完整的文书并视作字符串再次回到。

Directory类的部分常用的静态方法

写入数据

                 try
                 {
                     FileStream aFile = new FileStream(name, FileMode.Open);
                     StreamReader sr = new StreamReader(aFile);

 读取文件的职位用seek:public long Seek(long offset,SeekOrigin origin)

             try
             {
                 FileStream aFile = new FileStream("", FileMode.Open);//实例化叁个FileStream对象,用来操作data.txt文件,操作类型是
              
                 charData = "小编是什么人?111?".ToCharArray();//将字符串内的字符复制到字符组里
                 aFile.Seek(0, SeekOrigin.End);
                 Encoder el = Encoding.UTF8.GetEncoder();//编码器
                 el.GetBytes(charData, 0, charData.Length, byData, 0, true);

常用的类:

 后面包车型客车构造函数私下认可以只读形式展开文件,必要几个叠合参数规定不相同的拜见品级,此参数是FileAccess参数。

用FileWriter来随机读取文件是个好主意,而用StreamWriter能够直接把字符串写入文件中,它管理首要的转换和向FileStream对像写入工作。创造StreamWriter有好些个措施:

 
2.分隔文件

Delete()------删除文件

ReadLing()方法是读取并赶回风姿浪漫行字符,假诺回到为空,那么就算达到了流的最终。

namespace myFile
{
     class Program
     {
         static void Main(string[] args)
         {
             byte[] byData = new byte[100];//建设构造叁个FileStream要用的字节组
             char[] charData = new char[100];//创建七个字符组

Read()方法是从FileStream对象所指向的文件访谈数据的严重性花招:

Move()------将明确的文件移动到新岗位,能够在新岗位给文件鲜明不一致的名字

StreamWriter------向流写字符数据,可通过运用FileStream被制造为基类。

FileInfo------表示磁盘上的大意文件,具备能够管理此文件的艺术,要到位对文件的读写专业,就非得成立Stream对像。

             Console.WriteLine(charData);
             Console.ReadLine();
             return;
         }
     }
}

输入流用于从表面源读取多少,在重重场地下,数据源能够是磁盘上的文书或互连网的一些地方,任何可能发送数据的岗位都得以是数据源,比方互联网应用程序,web服务,甚至是调节台。StreamReader是二个通用类,能够用于其他流;StreamReader对象的创建格局特别周边于StreamWriter对象的开创情势。

Attributes-----获取或安装当前文件的属性

DirectoryName------获取文件目录的门道

Delete()------删除规定的目录以至中间的持有文件

Length------获得文件的容积

C# 目录、文件操作【分分快三计划】。FileSystemWatcher---- FileSystemWatcher是用来监察和控制文件和目录,并在这里些职责产生变化时,给出应用程序能够捕获的平地风波。

CreateNew------创立新文件,然而只要已经存在这里文件,则抛出十一分

  相对路径名相对于应用程序在文件系统上运营的职位。通过应用相对路径名称,无需规定已知的驱动器或职分;当前的目录正是起源。比如,假使应用程序运营在c:\DeVelopment\FileDemo目录上(这里的应用程序是指代码生成后的exe文件),并运用了相对路线“LogFile.txt,”,则该公文就坐落C:\DeVelopmentFileDemoLogFile.txt中。为了上移目录,则采纳.. 字符。那样,在同贰个应用程西路径“../test.txt”是指向应用程序所在的目录的上拔尖目录里的文书test.txt。

FileStream aFile = new FileStream(“Log.txt”,FileMode.CreatcNew);

namespace StreamWriterFile
{
     class Program
     {
         static void Main(string[] args)
         {
             try
             {
                 FileStream aFile = new FileStream("data1.txt", FileMode.OpenOrCreate);//创建二个fileStream对象
                 StreamWriter sw = new StreamWriter(aFile);//用FileStream对像实例二个StreamWriter对象
              
                 sw.Write("first.");
                 sw.WriteLine("hello world!!!");//写入字符串,方法WriteLine写入时背后跟一个换行符
                 sw.Write("This is a");//写入字符串,方法Write写入时未有换行符
                 sw.Write("string of characters.");
                 sw.Close();//用完后必得关闭对像
             }
             catch (IOException e)
             {
                 Console.WriteLine(e.ToString());
             }
         }
     }
}

   例:aFile.Seek(8,SeekOrigin.Begin);// SeekOrigin.Begin指得是文件指针从文件的首先个字节起;而参数‘8‘指得是移动到文件的第8个字节

读取使用逗号分隔的文件,string类提供了风华正茂种叫做Split()的主意,能够用来将字符串依据提供的相间符分隔成字符组.

                 aFile.Write(byData, 0, byData.Length);
             }
             catch (IOException e)
             {
                 Console.WriteLine("close");
                 return;
             }
          
         }
     }
}

FileInfo 类

Read()方法将流的下贰个字符作为正整数值再次来到,如若达到了流的结尾处,则赶回-1

本文由分分快三计划发布,转载请注明来源

关键词: 分分快三计划 .NET