精华内容
下载资源
问答
  • Linux文件IO_01

    千次阅读 2019-04-08 16:22:43
    Linux文件IO0.综述1.Linux常用文件IO接口(API)3.IO实例3.1打开文件3.2读取文件内容3.3向文件中写入内容 0.综述 IO就是input和output,文件IO就是文件的读写。文件没有打开时是存放在块设备中的文件系统里的,这样...

    0.综述

    • IO就是input和output,文件IO就是文件的读写。文件没有打开时是存放在块设备中的文件系统里的,这样的文件叫做静态文件。
    • 操作一个文件一般是先打开(open)一个文件,得到这个文件的文件描述符,然后对文件进行读写(read/write)或其他操作,最后关闭(close)文件。
    • 当我们open一个文件的时候,内核在进程中建立一个打开文件的数据结构来记录我们打开的文件,然后在内存中申请一段内存,将静态文件的内容读取到内存中特定地址管理存放,此时内存中的就是动态文件。之后的读写等操作都是针对这份内存中的动态文件,当close关闭动态文件后,内核将内存中动态文件的内容同步更新到静态文件中。
    • 文件描述符的概念:一个程序打开一个文件就会得到一个文件描述符(整数),该数字用来区分一个程序打开的多个文件。文件描述符的作用域就是当前进程。

    1.Linux常用文件IO接口(API)

    open :open and possibly create a file·

    #include <sys/types.h>
    #include <sys/stat.h>
    #include <fcntl.h>
    int open(const char *pathname, int flags);
    int open(const char *pathname, int flags, mode_t mode);
    

    read : read from a file descriptor

    #include <unistd.h>
    ssize_t read(int fd, void *buf, size_t count);
    

    write : write to a file descriptor

    #include <unistd.h>
    ssize_t write(int fd, const void *buf, size_t count);
    

    close :close a file descriptor

    #include <unistd.h>
    int close(int fd);
    

    lseek: reposition read/write file offset

    #include <sys/types.h>
    #include <unistd.h>
    off_t lseek(int fd, off_t offset, int whence);
    

    2.IO实例

    2.1打开文件

    int open(const char *pathname, int flags);
    int open(const char *pathname, int flags, mode_t mode);
    

    open函数中的参数pathname是文件的路径,是一个字符串,例如"./test.txt"。而参数flags指定打开文件后的权限,打开的文件只能按照flags权限来操作。flags分为主类和副类。参数mode:如果文件被新建,指定其权限位(八进制权限码)。
    附:
    flags主类(这三类是互斥的):

    O_RDONLY O_WRONLY O_RDWR
    只读 只写 可读可写

    flags副类:

    flags 作用
    O_EXCL 如果使用O_CREAT选项且文件存在,则返回错误消息
    O_NOCTTY 如果文件为终端,那么终端不可以调用open系统调用的那个进程的控制终端
    O_TRUNC 如果文件已经存在则清除文件中的原有内容
    O_APPEND 若写文件则在文件内容后追加内容

    主副可以搭配使用,例如:O_RDWR|O_CREAT|O_TRUNC

    open函数的返回值是文件描述符(>=0的整数),一般用fd表示。

    实例:打开一个文件代码

    int fd = -1;	//fd
    char read_buff[100]={0};   //read buffer
    int ret = 0;	//return value of read
    char* file_path = "./test.txt";
    
    //step1:open file
    fd = open(file_path,O_RDWR);
    if(fd == -1)
    {
    	printf("open error!\n");
    }
    else
    	printf("open success,fd of %s is %d\n",file_name,fd);
    

    2.2读取文件内容

    ssize_t read(int fd, void *buf, size_t count);
    

    fd表示要读取哪个文件,一般由前面的open返回得到。buf是应用程序自己提供的一段内存缓冲区,用来存储读出的内容。count是要读取的字节数。返回值ssize_t类型是linux内核用typedef重定义的一个类型(其实就是int),表示成功读取的字节数。

    实例:读取文件中的内容代码

     //read file
    ret = read(fd,read_buff,20);
    if(ret < 0)
    {
    	printf("read failed!\n");
    }
    else
    {
    	printf("read success!\n");
    	printf("ret = %d,content is [%s].\n",ret,read_buff);
    }
    

    2.3向文件中写入内容

    ssize_t write(int fd, const void *buf, size_t count);
    

    实例:写入内容代码

    //write file
    char write_buff[20] = "hello linux!";
    ret = write(fd,write_buff,strlen(write_buff));
    if(ret<0)
    {
    	printf("write failed!\n");
    }
    else
    	printf("write success,ret = %d\n",ret);
    

    2.4关闭文件

    int close(int fd);
    

    实例:关闭文件代码

    //step3:close file
    close(fd);
    

    2.5完整代码

    #include<stdio.h>
    #include<sys/types.h>
    #include<sys/stat.h>
    #include<fcntl.h>
    #include<unistd.h>
    #include<string.h>
    
    int main(int argc,char**argv)
    {
        int fd = -1;
        char read_buff[100]={0};
        int ret = 0;
        char* file_name = "test.txt";
        char write_buff[20] = "hello linux!";
        //step1:open file
        fd = open(file_name,O_RDWR);
        if(fd == -1)
        {
            printf("open error!\n");
        }
        else
            printf("open success,fd of %s is %d\n",file_name,fd);
         //step2:wr file
    
    #if 0
        //read file
        ret = read(fd,read_buff,20);
        if(ret < 0)
        {
            printf("read failed!\n");
        }
        else
        {
            printf("read success!\n");
            printf("ret = %d,content is [%s].\n",ret,read_buff);
        }
    #endif
    #if 1
        //write file
        ret = write(fd,write_buff,strlen(write_buff));
        if(ret<0)
        {
            printf("write failed!\n");
        }
        else
            printf("write success,ret = %d\n",ret);
    #endif
        //step3:close file
        close(fd);
        return 0;
    }
    

    3.Linux如何管理文件

    3.1硬盘中的静态文件和inode(i节点)

    • 当文件没有被打开时,文件以一种固定的形式存放在硬盘中的,这时候的文件叫作静态文件。
    • 一块硬盘可以分为硬盘内容管理表项和真正存储内容的区域等两大区域。操作系统访问文件时是先去读取硬盘内容管理表,从中找到我们要访问的那个文件的扇区级别的信息,然后再用这个信息去查询真正存储内容的区域,最后得到我们要的文件。
    • 操作系统最初拿到的信息是文件名,最终得到的是文件内容。第一步就是去查询硬盘内容管理表,这个管理表中以文件为单位记录了各个文件的各种信息,每一个文件有一个信息列表(我们叫inode,i节点,其实质是一个结构体,这个结构体有很多元素,每个元素记录了这个文件的一些信息,其中就包括文件名、文件在硬盘上对应的扇区号、块号那些东西·····)
    • 硬盘管理的时候是以文件为单位的,每个文件一个inode,每个inode有一个数字编号,对应一个结构体,结构体中记录了各种信息。
    • 联系平时实践,格式化硬盘(U盘)时发现有:快速格式化和底层格式化。快速格式化非常快,格式化一个32GB的U盘只要1秒钟,普通格式化格式化速度慢。这两个的差异?其实快速格式化就是只删除了U盘中的硬盘内容管理表(其实就是inode),真正存储的内容没有动。这种格式化的内容是有可能被找回的。

    3.2内存中被打开的文件和vnode(v节点)

    • 一个程序的运行就是一个进程,我们在程序中打开的文件就属于某个进程。每个进程都有一个数据结构用来记录这个进程的所有信息(叫进程信息表),表中有一个指针会指向一个文件管理表,文件管理表中记录了当前进程打开的所有文件及其相关信息。文件管理表中用来索引各个打开的文件的index就是文件描述符fd,我们最终找到的就是一个已经被打开的文件的管理结构体vnode。
    • 一个vnode中就记录了一个被打开的文件的各种信息,而且我们只要知道这个文件的fd,就可以很容易的找到这个文件的vnode进而对这个文件进行各种操作。

    展开全文
  • 标准IO与文件IO 的区别

    千次阅读 2017-09-05 14:15:02
    在谈两者区别之前,先来了解下什么是标准IO以及文件IO。1 定义标准IO: 标准I/O是ANSI C建立的一个标准I/O模型,是一个标准函数包和stdio.h头中的定义,具有一定的可移植性。标准IO库处理很多细节。例如缓存...

    在谈两者区别之前,先来了解下什么是标准IO以及文件IO。

    1 定义

    标准IO:

       标准I/O是ANSI C建立的一个标准I/O模型,是一个标准函数包和stdio.h头中的定义,具有一定的可移植性。标准IO库处理很多细节。例如缓存分配,以优化长度执行IO等。标准的IO提供了三种类型的缓存。

      (1)全缓存:当填满标准IO缓存后才进行实际的IO操作。

      (2)行缓存:当输入或输出中遇到新行符时,标准IO库执行IO操作。

      (3)不带缓存:stderr就是了。

     

    文件IO:

       文件IO称之为不带缓存的IO(unbuffered I/O)。不带缓存指的是每个read,write都调用内核中的一个系统调用。也就是一般所说的低级I/O——操作系统提供的基本IO服务,与os绑定,特定于*nix平台。

    2区别                                                  

       首先:两者一个显著的不同点在于,标准I/O默认采用了缓冲机制,比如调用fopen函数,不仅打开一个文件,而且建立了一个缓冲区(读写模式下将建立两个缓冲区),还创建了一个包含文件和缓冲区相关数据的数据结构(FILE *)。低级I/O一般没有采用缓冲,需要自己创建缓冲区,不过其实在*nix系统中,都是有使用称为内核缓冲的技术用于提高效率,读写调用是在内核缓冲区和进程缓冲区之间进行的数据复制。使用标准IO就不需要自己维护缓冲区了,标准IO库会根据stdin/stdout来选择缓冲类型,也就是说当你使用标准IO的时候,要清楚它的stdin/stdou是什么类型以及其默认的缓冲模式,如果不合适,你需要用setvbuf先设置,再使用,例如协同进程的标准输入和输出的类型都是管道,所以其默认的缓冲类型是全缓冲的,如果要使用标准IO,就需要现设置行缓冲。对于文件IO,只要你自己能维护好缓冲区,完全可以不用标准IO。

    其次从名字上来区分,文件I/O主要针对文件操作,读写硬盘等,标准I/O,主要是打印输出到屏幕等。因为他们设备不一样,文件io针对的是文件,标准io是对控制台,操作的是字符流。对于不同设备得特性不一样,必须有不同api访问才最高效。

    最后来看下他们使用的函数

     

    标准IO

    文件IO(低级IO)

    打开

    fopen,freopen,fdopen

    open

    关闭

    fclose

    close

    getc,fgetc,getchar

    fgets,gets

    fread

    read

    putc,fputc,putchar

    fputs,puts,

    fwrite

    write

     

     

     

    1.fopen与open
       标准I/O使用fopen函数打开一个文件:
          FILE* fp=fopen(const char* path,const char *mode);
       其中path是文件名,mode用于指定文件打开的模式的字符串,比如"r","w","w+","a"等等,可以加上字母b用以指定以二进制模式打开(对于 *nix系统,只有一种文件类型,因此没有区别),如果成功打开,返回一个FILE文件指针,如果失败返回NULL,这里的文件指针并不是指向实际的文 件,而是一个关于文件信息的数据包,其中包括文件使用的缓冲区信息。
       Unix系统使用open函数用于打开一个文件:
         int fd=open(char *name,int how);
    与fopen类似,name表示文件名字符串,而how指定打开的模式:O_RDONLY(只读),O_WRONLY(只写),O_RDWR (可读可写),还有其他模式请man 2 open。成功返回一个正整数称为文件描述符,这与标准I/O显著不同,失败的话返回-1,与标准I/O返回NULL也是不同的。

    2.fclose与close
        与打开文件相对的,标准I/O使用fclose关闭文件,将文件指针传入即可,如果成功关闭,返回0,否则返回EOF
    比如:
    if(fclose(fp)!=0)  
       printf("Error in closing file");

       而Unix使用close用于关闭open打开的文件,与fclose类似,只不过当错误发生时返回的是-1,而不是EOF,成功关闭同样是返回0。C语言用error code来进行错误处理的传统做法。

    3.读文件,getc,fscanf,fgets和read
       标准I/O中进行文件读取可以使用getc,一个字符一个字符的读取,也可以使用gets(读取标准io读入的)、fgets以字符串单位进行读取(读到遇到的第一个换行字符的后面),gets(接受一个参数,文件指针)不判断目标数组是否能够容纳读入的字符,可能导致存储溢出(不建议使用),而fgets使用三个参数char * fgets(char *s, int size, FILE *stream); 第一个参数和gets一样,用于存储输入的地址,第二个参数为整数,表示输入字符串的最大长度,最后一个参数就是文件指针,指向要读取的文件。最后是fscanf,与scanf类似,只不过增加了一个参数用于指定操作的文件,比如fscanf(fp,"%s",words)
       Unix系统中使用read函数用于读取open函数打开的文件,函数原型如下:
         ssize_t numread=read(int fd,void *buf,size_t qty);

       其中fd就是open返回的文件描述符,buf用于存储数据的目的缓冲区,而qty指定要读取的字节数。如果成功读取,就返回读取的字节数目(小于等于qty)。

    4.判断文件结尾

    如果尝试读取达到文件结尾,标准IO的getc会返回特殊值EOF,而fgets碰到EOF会返回NULL,而对于Unix的read函数,情况有所不同。read读取qty指定的字节数,最终读取的数据可能没有你所要求的那么多(qty),而当读到结尾再要读的话,read函数将返回0.

    5.写文件:putc,fputs,fprintf和write
       与读文件相对应的,标准C语言I/O使用putc写入字符,比如:putc(ch,fp);

       第一个参数是字符,第二个是文件指针。而fputs与此类似:

          fputs(buf,fp);

       仅仅是第一个参数换成了字符串地址。而fprintf与printf类似,增加了一个参数用于指定写入的文件,比如:

          fprintf(stdout,"Hello%s.\n","dennis");\

       切记fscanf和fprintf将FILE指针作为第一个参数,而putc,fputs则是作为第二个参数。
       在Unix系统中提供write函数用于写入文件,原型与read类似:

          ssize_t result=write(int fd,void *buf ,size_t amt);

       fd是文件描述符,buf是将要写入的内存数据,amt是要写的字节数。如果写入成功返回写入的字节数,通过result与amt的比较可以判断是否写入正常,如果写入失败返回-1

    6.随机存取:fseek()、ftell()和lseek()
       标准I/O使用fseek和ftell用于文件的随机存取,先看看fseek函数原型:

          int fseek(FILE *stream, long offset, int whence);

       第一个参数是文件指针,

       第二个参数是一个long类型的偏移量(offset),表示从起始点开始移动的距离。

       第三个参数就是用于指定起始点的模式,stdio.h指定了下列模式常量:
         SEEK_SET            文件开始处
         SEEK_CUR            当前位置
         SEEK_END            文件结尾处
       看几个调用例子:
         fseek(fp,0L,SEEK_SET); //找到文件的开始处
         fseek(fp,0L,SEEK_END); //定位到文件结尾处
         fseek(fp,2L,SEEK_CUR); //文件当前位置向前移动2个字节数

       而ftell函数用于返回文件的当前位置,返回类型是一个long类型,比如下面的调用:
          fseek(fp,0L,SEEK_END);//定位到结尾
          long last=ftell(fp); //返回当前位置
       那么此时的last就是文件指针fp指向的文件的字节数。
       与标准I/O类似,Unix系统提供了lseek来完成fseek的功能,原型如下:

          off_t lseek(int fildes, off_t offset, int whence);

       fildes是文件描述符,而offset也是偏移量,whence同样是指定起始点模式,唯一的不同是lseek有返回值,如果成功就 返回指针变化前的位置,否则返回-1。whence的取值与fseek相同:SEEK_SET,SEEK_CUR,SEEK_END,但也可以用整数 0,1,2相应代替。

     

     

       lseek : fseek + ftell;

    展开全文
  • 文件IO和标准IO区别及其效率

    千次阅读 2016-10-16 21:10:20
    文件IO 就指的是我们通常讲的open、close、write、read等API函数构成的一套用来读写文件的体系,这套体系可以很好的完成文件读写,但是效率并不是最高的。 标准IO应用层C语言库函数提供了一些用来做文件读写的函数...

    文件IO:就指的是我们通常讲的open、close、write、read等API函数构成的一套用来读写文件的体系,这套体系可以很好的完成文件读写,但是效率并不是最高的。

    标准IO:应用层C语言库函数提供了一些用来做文件读写的函数列表,叫标准IO。标准IO有一系列的C库函数构成(fopen,fclose,fwrite,fread),这些标准IO函数其实是有文件IO封装而来的(fopen内部还是调用了open),我们通过fwrite写入的内容不是直接进入内核中的buf,而是先进入应用层标准IO库自己维护的buf中,然后标准IO库自己根据操作系统单次write的最佳count来选择好的时机来完成write到内核中的buf中。

    展开全文
  • Unity文件IO

    千次阅读 2018-12-13 14:50:50
    文件系统与IO 文件系统对应类 System.IO DriveInfo : 有关驱动器信息的类 主要方法:GetDrives 用于取得本计算机中所有驱动器信息对象 File: 有关对文件整体操作及内容读写的类 整体操作: Create :创建文件 Delete:...

    文件系统与IO
    文件系统对应类 System.IO
    DriveInfo : 有关驱动器信息的类
    主要方法:GetDrives 用于取得本计算机中所有驱动器信息对象
    File: 有关对文件整体操作及内容读写的类
    整体操作:

    Create :创建文件
    Delete: 删除文件
    Move:移动文件(剪切)
    Copy: 复制文件
    Exists: 检查设备中是否有该文件
    读写文件:
    ReadAllText : 一次将文件中所有内容读入内存,并转为字符串
    ReadAllLines: 一次将文件中所有内容读入内存,转为字符串,将字符串按行形成一个字符串数组
    ReadLines: 并不会主动文件中的内容,只有再迭代时才读一行,每迭代一次向下读一行.
    ReadAllBytes: 将文件中的内容一次读入内存,以字节数组的方式保存
    
    WriteAllText: 一次写入大段文本。
    WriteAllLines: 每写一行之后写一个换行符.
    WriteAllBytes: 一次写入大量字节
    

    FileInfo : 有关对文件整体操作及内容读写的类
    与File不同的地方:比File类多一个Length属性,通过该属性可以了解一个文件所占有字节
    Directory :有关对文件夹整体操作的类

    常用方法:
    CreateDirectory:创建文件夹
    Delete:删除文件夹
    Move:移动文件夹(不能跨驱动器移动)
    GetFiles: 取得文件夹下所有的文件名
    GetDirectoies:取得文件夹下所有的子文件夹名
    Exists:检查某文件夹在设备中是否存在
    

    DirectoryInfo 功能同Directory,只是所有成员为实例成员
    Path类,专用于对路径字符串的处理

    常用方法:
    GetFileName :取得文件名及扩展名
    GetFileNameWithOutExtension: 取得文件名不要扩展名
    GetDirectoryName : 取得路径中目录的名称
    Combine: 将多个字符串合并成为一个路径
    
    /// <summary>
    /// 文件夹处理
    /// </summary>
    public class DirectoryTest : MonoBehaviour
    {
        //在D盘创建文件夹
        private string myPath = @"D:/aa/bb";
        private void Start(){
            DirectoryInfo info = new DirectoryInfo(myPath);
            //判断路径中是否有文件夹
            if (!info.Exists)
                info.Create();
            //if (info.Exists)
             //   info.Delete(true);
            string myPath02 = Path.Combine(myPath, @"cc");//@"D:/aa/bb/cc"
            DirectoryInfo info02 = new DirectoryInfo(myPath02);
            if (!info02.Exists)
                info02.Create();
            if (info02.Exists)
                info.Delete(true);
            /*
            if (!Directory.Exists(myPath))
                Directory.CreateDirectory(myPath);
            if (Directory.Exists(myPath))
                Directory.Delete(myPath);
             */
        }
    }
    
        private string filePath = @"D:/Directory/file01.txt";
        private void Start()
        {
            //1.在D盘创建一个名字为Directory的文件夹,并创建一个file01.txt文件。
            string dirPath = Path.GetDirectoryName(filePath);
            if (!Directory.Exists(dirPath))
                Directory.CreateDirectory(dirPath);
            if (!File.Exists(filePath))
                File.Create(filePath);
            //2.(先在D盘放一个file02.txt文件)判断若存在,复制到D盘Directory文件夹下。
            if (File.Exists(@"D:/file02.txt"))
                File.Copy(@"D:/file02.txt", @"D:/Directory/file02.txt", true);
            //3.(先在D盘放一个Directory02文件夹,并创建几个子文件夹)
            //通过脚本打印出D盘Directory02文件夹下所有子文件夹的目录名
            string[] path = Directory.GetDirectories(@"D:/Directory02");
            foreach (var dirName in path)
            {
                print(dirName);
            }
        }
    
    /// <summary>
    /// 文件读写
    /// </summary>
    public class FileTest02 : MonoBehaviour
    {
        private string filePath = @"D:/File.txt";
        private void Start()
        {
            //File.WriteAllText(filePath, " Hello aaaaaaa");//写入一大段文本内容
            //File.WriteAllLines(filePath, new string[] { "Hello", "Hi~", "hhhh" });
            //string file = File.ReadAllText(filePath);//读取一大段文本内容
            string[] file = File.ReadAllLines(filePath);
            foreach(string read in file)
            {
                print("读到的内容 : " + read);
            }
        }
     
    }
    
    
    /// <summary>
    /// 文件处理
    /// </summary>
    public class FileTest : MonoBehaviour
    {
        private string filePath = @"D:/aa/bb/test.txt";//文件路径
        private string filePathTo = @"E:/cc";
        private void Start(){
            //取得路径中目录的名称
            string dirPath = Path.GetDirectoryName(filePath);
            if (!Directory.Exists(dirPath))
                Directory.CreateDirectory(dirPath);
            if (!File.Exists(filePath))
                File.Create(filePath);
            //剪切文件 新路径:@"E:/cc/test.txt"
            string newFilePath = Path.Combine(filePathTo
                ,Path.GetFileName(filePath));
            if (!Directory.Exists(filePathTo))
                Directory.CreateDirectory(filePathTo);
            if (!File.Exists(newFilePath))
                File.Move(filePath, newFilePath);
    
        }
     
    }
    

    数据流 IO:Stream

    流涉及三个基本操作:
    1.	可以读取流(Read)。读取是从流到数据结构(如字节数组)的数据传输。
    2.	可以写入流(Write)。写入是从数据结构到流的数据传输。
    3.	流可以支持查找(Seek、Position)。查找是对流内的当前位置进行的查询和修改。查找功能取决于流具有的后备存储区类型。例如,网络流没有当前位置的统一概念,因此一般不支持查找。
    FileStream FileMode
    StreamReader:流内容读取器
    	用于对数据流或本地文件简单的以字符的方式进行读取,
    	常用方法:ReadLine Read ReadToEnd
    StreamWriter:将内容写入流,写入器
    	用于对数据流或本地文件简单的以字符的方式进行写入,
    	常用方法:Write WriteLine
    
    public class StreamTest : MonoBehaviour
    {
        private string path = @"D:/Stream.txt";
        private string text = null;
        private void OnGUI()
        {
            if (GUILayout.Button("读取内容"))
                text = ReadFunc(path);
            GUILayout.Label("内容 : " + text);
        }
        private string ReadFunc(string filePath)
        {
            //创建流对象
            Stream stream = new FileStream(path, FileMode.Open);
            byte[] data = new byte[stream.Length];
            //读取流中所有字节
            stream.Read(data, 0, (int)stream.Length);
            //写入文件
            stream.Write(data, 0, (int)stream.Length);
            stream.Flush();//写完内容,需刷新
            //流用完需要关闭,否则资源得不到释放
            stream.Close();
            //解码
            return Encoding.UTF8.GetString(data);
        }
     
    }
    

    读取配置文件

    using UnityEngine;
    using System.Collections;
    using System.Collections.Generic;
    using System.IO;
    
    /// <summary>
    /// 读取配置文件
    /// </summary>
    public class ConfigTest : MonoBehaviour
    {
        private Dictionary<string, Dictionary<string, string>> dic
         = new Dictionary<string, Dictionary<string, string>>();
        private string path;
        private void Start()
        {
            //读取StreamingAssets文件下的文件路径
             path = Path.Combine(Application.streamingAssetsPath,
                "Config.txt");
            LoadConfig();
        }
        //读取所有数据
        private void LoadConfig()
        {
            string[] lines = null;
            if (File.Exists(path))
            {
                lines = File.ReadAllLines(path);
                BuildDic(lines);
            }
        }
        //处理所有数据
        private void BuildDic(string[] lines)
        {
            //主键
            string mainKey = null;
           //子键
            string subKey = null;
            //值
            string subValue = null;
            foreach (var item in lines)
            {
                string line = null;
                line = item.Trim();//去除空行
                if (!string.IsNullOrEmpty(line))
                {
                    //取主键
                    if (line.StartsWith("["))
                    {
                        mainKey = line.Substring(1, line.IndexOf("]") - 1);
                        dic.Add(mainKey, new Dictionary<string, string>());
                    }
                    //取子键以及值
                    else
                    {
                        var configValue = line.Split('=');
                        subKey = configValue[0].Trim();
                        subValue = configValue[1].Trim();
                        subValue = subValue.StartsWith("\"") ? subValue.Substring(1) : subValue;
                        dic[mainKey].Add(subKey, subValue);
                    }
                }
            }
        }
        private void OnGUI()
        {
            GUILayout.Label(dic["Login"]["Password"]);
        }
    }
    
    
    //配置文件内容
    [Game]  
    Version=1
    
    [Login]
    Account = 账号不输入,怎么给你保存数据呀
    Password = 没有密码,无法进入游戏
    Success = 账号注册成功,赶紧登陆游戏爽去吧
    Faild = 账号创建失败,赶快重新创建去吧,一会服务器满了,你就不能和其他小伙伴愉快玩耍啦
    Successful = 登陆成功
    LoginFaild = 账号或密码错误,请重新输入!!!
    
    [Job]
    Job1 = 战士
    Job2 = 法师
    Description1 = "    具有强大的近战攻击力,一直活跃在战斗的最前方。强大的力量和充沛的体力让他可以摧毁敌人的一切防御。(推荐新手使用)
    Description2 = "    将所有的精力都用在魔法奥义上,每当他向空中举手的时候,不可预测的灾难即将到来。由于自身体力较弱,法师靠法术远距离攻打敌人。
    Weapon1 = 砍刀
    Weapon2 = 法杖
    
    [Money]
    Gold = 100
    Diamond = 11.2
    
    [Scene]
    LoadFailed = 场景加载失败,重新加载~
    
    
    
    
    展开全文
  • C语言--Linux下的文件IO和标准IO

    千次阅读 2016-11-14 19:55:07
    文件IO与标准IO: 1.文件OI又称为低磁盘IO 遵循POSIX标准,标准IO又称为高磁盘IO,遵循ANSI C相关标准。 Linux中使用的的是GLIBC,它是标准C库的超集,不仅包含ANSI C中定义的函数,也包含POSIX标准中定义的函数。...
  • 文件IO消耗分析

    千次阅读 2013-02-07 11:05:38
    Linux在操作文件时,将数据放入文件缓存区,直到内存不够或系统要释放内存给用户进程使用,因此在查看Linux内存状况时经常会发现可用(free)的物理内存不多,但是cached用了很多,这是Linux提升文件IO速度的一种...
  • Linux 文件IO理解

    千次阅读 2011-07-14 11:04:46
    linux文件IO操作有两套大类的操作方式:不带缓存的文件IO操作,带缓存的文件IO操作。不带缓存的属于直接调用系统调用(system call)的方式,高效完成文件输入输出。它以文件标识符(整型)作为文件唯一性的判断依据...
  • 漫谈linux文件IO

    千次阅读 2012-08-23 16:40:18
    这篇文章写的比较全面,也浅显易懂,备份下。... 在Linux 开发中,有几个关系到性能的东西,技术人员非常关注:进程,CPU...剖析文件IO的细节。从多个角度探索如何提高IO性能。本文尽量用通俗易懂的视角去阐述。不copy内
  • 【Unix】文件IO与标准IO

    千次阅读 2010-02-09 10:16:00
    一、文件IO 大多数UNIX文件IO只需用到5个函数:open、read、write、lseek以及close。 这些函数经常被称为不带缓存的IO(unbuffered IO),不带缓存是指每个read和write都调用内核中的一个系统调用。 这些不带缓存的IO...
  • MySQL系列:innodb源码分析之文件IO

    千次阅读 2014-11-23 21:50:40
    innodb对文件IO操作可以是煞费苦心,其主要包括两方面,一个是对异步io的实现,一个是对文件操作管理和io调度的实现。在MySQL-5.6版本的innodb还加入了DIRECT IO实现。做了这么多无非是优化io操作的性能。在inno
  • Linux 文件IO: 缓冲与非缓冲

    千次阅读 2016-11-27 12:14:29
    本地普通文件IO一般都是同步阻塞的本地普通文件IO一般关注的是缓存,一般都是同步阻塞的。普通文件的file descriptor是block也是POSIX标准的。这点不同于网络IO,网络IO要考虑传输两边进程处理等,设计之初就提供了...
  • 文件IO: open、create、close、lseek、read、write、fcntl、ioctl等 标准IO: FILE、fopen、fwrite、fread、等 为了理解文件IO和标准IO的区别,可能要先理解下用户态与内核态,系统调用与库函数的概念。 用户...
  • 漫谈linux之文件IO

    千次阅读 2014-01-23 14:32:20
    同事的文章,觉得写得很清晰,收藏了。 在Linux 开发中,有几个关系到性能的东西,技术人员非常关注:...阐述之前,要先有个大视角,让我们站在万米高空,鸟瞰我们的文件IO,它们设计是分层的,分层有2个好处,一是
  • 标准IO与文件IO

    千次阅读 2016-12-30 16:34:21
    linux下文件操作包含下面4个头文件
  • Python 12:Python 文件io操作模块

    千次阅读 2016-08-02 22:11:45
    Python 文件io操作模块介绍IO操作是每种程序设计语言都会设计的模块,python的io操作设计的和C语言很类似,比较简便实用.反观Java语言对于io操作设计的模块就比较抽象和灵活,这也导致java的io学习成本远比Python语言的...
  • 文件IO(系统IO和标准IO)

    千次阅读 2016-02-18 09:33:43
    Linux系统下操作文件有两类基本API,一类由系统调用提供,被称为系统IO。一类由标准C库提供,被称为标准IO。   拓展: 它们都是Linux下操作文件的标准接口,那又有什么区别?我们该如何选择使用呢? 第...
  • linux 文件IO和标准IO的一些实现细节

    千次阅读 2010-03-25 16:53:00
     linux编程使用的open、close、read、write等文件IO函数属于系统调用的,其实现方式是用了fctrl、ioctrl等一些底层操作的函数。而标准IO库中提供的是fopen、fclose、fread、fwrite等面向流对象的IO函数,这些函数在...
  • Linux下用文件IO的方式操作GPIO

    千次阅读 2016-11-12 15:23:01
    通过sysfs方式控制GPIO,先访问/sys/class/gpio目录,向export文件写入GPIO编号,使得该GPIO的操作接口从内核空间暴露到用户空间,GPIO的操作接口包括direction和value等,...文件IO方式操作GPIO,使用到了4个函数
  • Python文件io

    千次阅读 2017-09-25 18:19:32
    使用open打开第一个参数是你要访问文件的路径,第二个参数是打开文件的模式,以下是具体模式。 r :以只读方式打开文件文件的指针将会放在文件的开头。这是默认模式。rb: 以二进制格式打开一个文件用于只读。...
  • Python中文件的读写包含三个步骤:打开文件,读/写文件,关闭文件文件打开之后必须关闭,因为在磁盘上读写文件的功能是由操作系统提供的,文件作为对象,被打开后会占用操作系统的资源,而操作系统在同一时间内...
  • C语言 文件IO的使用

    千次阅读 2018-01-22 17:10:57
    简单介绍C语言文件操作函数的用法(可以直接使用): fopen fclose fprintf fscanf fputc fgetc fread fwrite 头文件 #include 函数使用 fopen 函数原型: FILE *fopen( const char *...
  • java文件IO操作

    千次阅读 2012-07-11 02:38:14
    import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.FileWriter; import java.io.InputStream; import java.io.PrintWriter; public clas
  • Linux操作GPIO(文件IO方式)

    万次阅读 2016-04-28 21:47:37
    首先,看看系统中有没有“/sys/class/gpio”这个文件夹。如果没有请在编译内核的时候加入Device Drivers->GPIO Support ->/sys/class/gpio/… (sysfs ...gpio_operation通过/sys/文件接口操作IO端口GPIO到文件系统的
  • 文件IO(标准IO缓冲区)

    千次阅读 2016-02-16 09:07:02
    标准IO的缓冲区分成三类,分别是不缓冲、全缓冲和行缓冲。   拓展: 一般情况下,显示屏被打开两次,分别以行缓冲和不缓冲模式打开,即所谓的stdout和stderr,普通文件则默认是全缓冲。  文件的缓冲...
  • Flutter系列之Dart文件IO操作

    万次阅读 2018-10-21 10:19:08
    这一部分学习下Dart语法怎么进行IO文件操作。 本身而言,Dart语法进行文件操作是十分简便的,下图是简单写入操作; final filePath = r"E:\back.txt"; try { File file = new File(filePath); file....
  • NIO详解以及NIO的文件IO操作

    千次阅读 2020-01-27 17:05:20
    java.nio全称java non-blockingIO,是指JDK1.4开始提供的新API。从JDK1.4开始,Java提供了一系列改进的输入/输出的新特性,被统称为NIO(即NewIO)。新增了许多用于处理输入输出的类,这些类都被放在java.nio包及子包...
  • 本课程主要讲解linux中的文件读写和IO处理,包括API的概念、open函数的重要flag、linux内核管理文件的原理、inode和vnode、文件共享、标准IO等。终目的是让大家理解并掌握在linux中使用API和库函数进行文件操作的...
  • UEditor上传文件IO异常

    千次阅读 2015-08-28 15:33:58
    tomcat中的temp文件夹被删除,导致文件在上传,执行getTmpFile()时,不能创建临时文件,导致IO异常
  • Linux 文件IO之read() 函数

    千次阅读 2019-08-09 20:13:22
    Linux中最常见的读取文件系统调用是read()。 #include <unistd.h> ssize_t read (int fd, void *buf, size_t len); 从fd指向的文件读取len个字节到buf中,成功返回buf中的字节数,失败返回-1. 对read()...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,610,748
精华内容 644,299
关键字:

文件io