找回密码
 注册
关于网站域名变更的通知
查看: 347|回复: 2
打印 上一主题 下一主题

ARM开发中的的文件流是什么?

[复制链接]

该用户从未签到

跳转到指定楼层
1#
发表于 2021-10-21 14:13 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式

EDA365欢迎您登录!

您需要 登录 才可以下载或查看,没有帐号?注册

x
文件流& c7 H; `& L8 B
' e; v' w7 M+ V( f4 e! q( J
一、流的概述8 k! }3 Q! `6 q# X* d8 l8 g
​ 要完成文件的读写操作,就必须了解C#中另外一个重要的概念——流(Stream)( g& @5 A2 o0 L* g) V7 d
​ C#中流的概念可以和生活中的流相对应。在生活中有水流和电流,首先要有一个源头,还需要有传输的管道,# A. a- y) g% ^. K
水流有河道、水管作为传输管道,电流有电线,而这些流都会有一个目的,就是它的流向。C#的流也需要源头——文件、数据流入流出管道以及数据的访问。, A4 K* u8 v! e* P# y2 R
1、输出流和输入流 .Net Framework中进行的所有输入、输出工作都需要用到流。
9 Y2 X% |& G4 m$ ^! D$ O* p  F, ~​ 1、输出流:当向某些外部目标写入数据时,就要用到输出流。
) K3 S: Q% I6 l) |8 P5 v: Y3 D​ 2、输入流:用于将数据读到程序访问的内存或变量中。$ D' S5 h7 r: j; f3 X+ C
在程序的控制台中的可以理解为:
4 m" ~0 J; a' d/ f0 X% h输出流:控制台程序中,将信息从程序中输出的处理:Console.WriteLine();3 {' q' o. k2 j- N
输入流:通过用户键盘来输入到程序当中处理:Console.ReadLine();
1 I* g4 v5 o, b9 p  [
2、文件读写,常用的三个类对于文件读写,常见的三个类:/ f: _# ^( ~4 X, U" B# }8 w
​ 1、FileStream(文件流):这个类主要用于在二进制文件中读写二进制数据——也可以使用它读写任何文件
: k: G8 I2 q" A1 e5 D0 W! W​ 2、StreamWriter(流写入器)和StreamReader(流读取器):这二个类是专门用来读写文本文件的。! O) j) |/ V: g
二、FileStream对象### 1、FileStream对象的二种重载​ FileStream对象表示在磁盘或网络路径上指向文件的流。这个类提供了在文件中读写字节的方法。# g8 w% e) K9 S- k. Y/ |: E5 Z) Q
​ 有多种方法可以创建FileStream对象,FileStream类的构造函数有很多的重载版本,最简单的重载版本仅带有二个参数,即文件路径和FileModel枚举值。
" e6 K; j5 Y* b7 Z0 k7 o9 x1.1、第一种重载:- I0 d: \3 U/ m* O( h
  Z  ]( X2 d5 W  I/ _+ @8 Y6 N+ u
3 y' i$ R  O- P. n2 s! w! z

    + D4 n  s0 r- z3 v+ U/ B1 j9 I
  • FileStream aFile = new FileStream( 文件路径 , FileMode.成员值);) y# {8 \9 N7 [+ {( b" ]
3 R0 ?/ m( B5 X& L4 t: f

# n1 R# I- J. N1 }5 ?
: N6 T) H! e% s; E# p/ e1 q

/ W" y  I  I' M: U% z3 I3 [1 UFileModel的枚举成员:' O7 I7 R0 ~- L( c. C

/ [6 K6 \: Z2 q$ x3 N1.2、第二种重载:
$ c1 m9 U, N* O( m; q" S7 ~, U/ ~* j; Q- c, V- L

; ?# F6 R# h: p, ^- m4 [
    ( E  d) d9 \( S1 f/ M
  • FileStream aFile = new FileStream( 文件路径, FileMode.成员值, FileAccess.成员值);- c% k# i2 ?: Y; U! d
( q2 _4 D9 N/ v0 U/ Z

3 I  Z4 O  a! D
2 h6 C* S7 t' Z, @& u
% ~4 e. r2 [3 }! @
FileAccess的枚举成员:6 s) K" u. k% W5 n% L
& j' u% C! H( J
在FileAccess构造函数不使用FileAccess枚举参数的版本中,使用默认值FileAccess.ReadWrite。
2 W; {# z, u+ h+ K0 q. I* e( M; U3 r​ File和FileInfo类中都提供了OpenRead()和OpenWrite()方法,使程序更易于创建FileStream对象。前者打 开了只读访问的文件,后者只允许写入文件。
3 U' _, Z! J% Z& A# [" Z​ 这些都提供了快捷方式,因此不一定要以FileStream构造函数的参数形式提供前面所有的信息。例如,下面的代码行打开了用于只读访问的Data.txt文件。" N8 g7 u1 w1 _2 E& o) c
* C4 U7 S2 G6 n, N/ }' B

' w4 Z3 z8 F5 a2 A& {- }% I+ y+ {% d' k! O

    7 [  ]% {  _  y; L8 B3 G
  • FileStream aFile=File.OpenRead(@“C:\Data.txt”);& g$ T9 p3 c; e$ z3 a6 u, m

9 f2 A" A2 y2 X+ Z
; n- p, p* ?7 u0 K# {. C  P' X/ g1 J5 Y2 R) C6 V' x$ Q. z
1 x" B# k* `1 r( F' B
/ ?; e* T1 m& Z. L0 g; E8 T. u, D
或者
* j$ |' R( A0 Q) ?, _- s0 H) F9 d  K* z/ k
2 @$ r  f& g/ j2 @6 E- }

5 b( ~5 n! N& j7 r# u; [7 j' D

    4 b. Y3 Z7 h/ ?+ W
  • FileInfo aFileInfo=new FileInfo(@“C:\Data.txt”);4 v8 O7 x1 ^2 K& P1 Y' ^) i0 w
5 b5 L& C, \; i6 y4 g: W3 [9 G5 S
* ?  O8 ]6 w# r% d2 U: }+ |
/ C/ L) C* W( j$ J1 J

' k1 f9 F2 h" v# }5 m$ e& g% b: z, e+ B" N4 y) b0 @3 {9 F" x

) Y/ O( ~$ @* Y- _% {) {- U* w" [/ H2 s1 Q( S  S4 Y$ T

1 V% m, i+ U  Z, \0 Y$ v! a

    8 Z# T, v( o. A
  • FileStream aFile=afileInfo.OpenRead();) G' _* o8 q, W( `# y+ |5 s
3 d# i+ e& L1 W$ l* I& V/ Q
  Q" t! X$ C- b5 m

7 \9 e( z+ Y# D* Y( E; \" V& Y8 Y' R% v$ c
2、使用FileStream读取数据和写入数据​ 使用FileStream类读取数据并不容易,这是因为FileStream类只能处理原始字节(Raw Byte)。
0 `2 i) N/ G- d8 l8 X​ FileStream对象的Read()方法是从FileStream对象所指向的文件访问数据的主要手段。这个方法从文件中读取数据,再把数据写入一个字节数组。
8 d4 A1 r* U1 K7 l9 _& u* W( M: [6 }+ }+ p7 ]- U) x
​ 该方法有三个参数:第一个参数是传入的字节数组,用以接收FileStream对象中的数据。第二个参数是字节数组中开始写入数据的位置。通常是0,表示从数组开端开始放置读入的字节。最后一个参数指定从文件中读出多少字节。
; ~. ~$ R1 ]6 |1 S/ l
4 t3 \  i+ u$ O. P0 _  Q" j
2.1、读取数据:3 o: @4 R6 C' Z, x% X- J! F9 |
在编写程序代码前,需导入Sysytem.IO命名空间。此应用程序打开了磁盘上某个文件,用于读取其中的部分数据。首先,通过实例化一个FileStream的对象,将流指向这个文件。
5 C/ y, o5 l  k6 W# V这可以通过:
  I- m; |" j) A9 U- N: u- {6 G0 R% _( x1 b* W7 \  y% Q; e6 W! N
" f9 u! n1 g) s: i+ f
7 U! m$ f4 j3 e2 ]
    - U) c# u3 X- ~/ h, u' g
  • FileInfo aFileInfo =new FileInfo(@"C:\My Document\ReadMe1.txt");
  • FileStream aFileInfo =aFileInfo.OpenRead();
    4 K' \8 ~- @" f$ i* y' q9 s
5 G; L. M  w7 J: B* S
2 U* X& t% c% F% m5 \3 _1 u

4 u, Q5 V1 M: y2 R+ _$ G
' @/ B2 n! l4 R/ A  M2 {+ @步骤:创建FileStream对象,并指向文件流——得到文件大小(字节单位)——创建一个相同大小的字节数组——将文件的字节内容读到数组中——将数组中字节转为字符——输出显示——关闭流" Y6 |* ^; z$ B

1 G7 c7 K: t7 F; R, ~. q+ d9 g& n2 Y5 G) E5 M6 C0 {. _3 }7 ~/ O
  }6 m! a5 E2 j3 \7 b4 U: l! s

    3 E- |7 T6 ]1 K3 Z
  •   /// <summary>
  •         /// 读取数据
  •         /// </summary>
  •         /// <param name="sender"></param>
  •         /// <param name="e"></param>
  •         private void button1_Click(object sender, EventArgs e)
  •         {
  •             //以只读方式创建FileStream对象
  •             FileStream afile = new FileStream(@"C:\My Document\ReadMe1.txt",FileMode.OpenOrCreate);
  •             //得到文件的长度/大小
  •             long length = afile.Length;
  •             //使用文件的长度创建一个字节数组。
  •             byte[] Buffers = new byte[length];
  •             //将流中的数据的字节内容读到字节数组中
  •             afile.Read(Buffers, 0, Buffers.Length);
  •             //将读到的数据进行转码,转为字符串
  •             string content = Encoding.Default.GetString(Buffers, 0, Buffers.Length);
  •             //将字符串在文件框中显示
  •             richTextBox1.AppendText(content);
  •             //关闭流对象,释放文件引用。
  •             afile.Close();
  •         }/ j6 e" S4 o! g- f7 l

9 T2 `5 F& o7 l# k# ~
7 e+ {, T& M- ]# |' s/ C

9 L- Y+ i. A8 P; G( t$ J% K$ x6 l$ H; B5 l: o; U$ o  F
2.2、写入数据:" i3 Q$ X4 c% C! `6 n
步骤:创建FileStream对象,并指向文件流——声明一个数组是写入数据字节的2倍——使用Encoding类的GetBytes()方法将字符串中的一组字符编码到字节数组中,(1、编码的字符集的字符串,2、表明第一个编码的字符的索引,3、要编码的字符的数量,4、表明要包含所产生的字节序列的字节数组,5、开始写入所产生的字节序列索引位置)
# T' j& t0 P0 c5 T7 ^5 h1 V* r- ~. ~0 U* v
/ b. w+ s4 y" Z! j
& G" M6 _0 Z0 W9 d, ]% N7 B

    9 Z1 w/ g, {6 U
  • /// <summary>
  •         /// 写入数据
  •         /// </summary>
  •         /// <param name="sender"></param>
  •         /// <param name="e"></param>
  •         private void button2_Click(object sender, EventArgs e)
  •         {
  •             //创建一个写文件的文件流对象
  •             FileStream aFile = new FileStream(@"C:\My Document\ReadMe1.txt",FileMode.OpenOrCreate, FileAccess.Write);
  •             //创建字节数组
  •             byte[] buffers;
  •             //获取传入闻见的字符串
  •             string content = richTextBox1.Text;
  •             //为字节数组分配字符串
  •             //可能会包含中文,可以将长度设为字符串长度的二倍
  •             buffers = new byte[content.Length * 2];
  •             //将字符串转成字节放入字节数组中
  •             Encoding.Default.GetBytes(content, 0, content.Length, buffers, 0);
  •             //将字节数组写入文件中
  •             aFile.Write(buffers, 0, buffers.Length);
  •             //关闭流对象,释放文件引用。
  •             aFile.Close();
  •         }
    % q5 i7 ~0 q, _  u/ }, V2 A

+ `4 ~+ {  e- m9 D. {; y
( K1 o4 `% @; ?  c) s
+ X( c4 }; V4 d( Y! \+ B

& ]" |6 G; Y% c, P1 D, j" m( U三、StreamWrite和StreamReader对象1、StreamWriter对象( C; O. ?/ W, a2 y# {9 ]- b) M) w
StreamWriter对象只能用于写入文件(或另一个流),StreamWriter类的构造方法有很多版本。最常用的有以下三种。8 }; g% v' |9 E

  o+ R& R" |0 T7 f
6 l/ d, R7 F3 Y$ _; i1 V  U
: C4 K* d, }: J/ ?4 h8 M! m6 h; ]

    % J* G8 a! D) s5 A! P
  • StreamWriter sw=new StreamWriter(@ “C:\test.txt”);
    $ z/ ^+ m5 }# m, b

2 W* z. d& s1 o8 t. x# T+ s% b6 K0 N* \7 j% K7 [% P- B) _7 g- K6 [
3 b" m+ r  a5 R3 ]5 Y1 |
0 V. n- f7 m  z! F! m+ ?
将使用UTF-8的编码方式创建StreamWriter对象,.NET把这种编码设置为默认的编码方式。* P# y7 {9 Z! R# N- c- Z

: p" \7 o; L6 r
% [# l4 H! H: [8 H. |
0 _) h6 P3 R3 ?
    ! x8 K2 s; `0 z* B
  • StreamWriter sw=new StreamWriter(@ “C:\test.txt”, true);
    * Y4 ?  H! H9 a" p- Q; n/ G

- z( |6 o4 e3 _1 K/ O9 K5 S8 ?( _  U3 l- E; A
1 m6 P( Z9 b8 z8 {, i9 j4 s: U/ O6 P

/ h: c. L9 _* |- g$ {
, a& F2 ~" y: K9 `- O在这个构造函数中,第二个参数是bool类型,表示文件是否以追加的方式打开。
  B: G& F* A/ W; G/ `; ?6 W# \6 S# [' q- ^/ `% a% w

0 O, k( b( k& r% T" v- e9 G
( H0 P' F5 \8 C6 q3 P

    4 Q8 ]) w8 L- p2 d% k7 r6 _3 `
  • StreamWriter sw=new StreamWriter(@ “C:\test.txt”,true,Ecoding.ASCII);
    . _- I7 ?4 j) ~
3 `& C0 ^2 p+ g7 u

% D+ p- p% E; c0 W/ S
0 F8 F0 @* r* t9 @4 x
: S4 c6 K) [0 U! p: [, ]9 L
4 ]( s; j( Q( N6 F3 I: f7 E
在第三个函数中,第三个参数可以指明要使用的编码方式ASCII来创建StreamWriter对象。但不能仅以文件名和编码方式来创建对象。2 ?$ E3 a1 Z' K/ e
当然,也可以将StreamWriter关联到一个文件流上,以获得打开文件的更多控制选项。例如以下代码。
# V4 e( o5 O+ W4 K: n8 N& X7 `6 V7 T( v+ R% @% B; v

+ H: D5 ~$ A& g% }  N4 m' Z7 X5 o8 `5 W

    + V* j; K+ ]8 B. `$ G2 q
  • FileStream fs=new FileStream(@“C:\1.txt”,FileMode.Append,FileAccess.Write);: m/ {# u$ h8 v4 E+ h5 \( h: O
, L3 G1 p; Q( ?: f; h" [7 I, z
8 D( j: Z) ^0 H

  b# ^  l8 }' C
$ Q; Q3 z: J8 t4 U- M  k' O& l( e

0 Z" _" k2 `  U6 b$ D: E$ C' J+ Q2 @3 }- u* Y

4 q# k9 O0 r6 |. I! B# d
    , o# H  ^  S! \. t6 `. Q
  • StreamWriter sw=new StreamWriter(fs);: i) H7 T. [( ^0 y9 }) t

7 x# U0 K5 Z8 a
& A  e1 A$ w- @, O2 V$ M
4 m: H& s( j( d, R5 m6 b& Q1 `2 L
! [2 p  `, M& `. l

$ E1 y" `6 ~2 o' K9 `StreamWriter对象有两个方法来完成向文件或流中写入数据的功能。5 i* n  k5 a# Z
WriteLine()方法:一次写入一行文本,流会自动把回车符合换行符添加到文本的末尾。4 w- m; p# H' Z
Write()方法:向流或文件中写入文本,但不会在末尾添加回车和换行符。  ]6 J: k& u! H: O; n8 c6 X
StreamWriter对象和FileStream对象一样,功能执行完毕后要使用Close()方法关闭以释放资源。5 H5 ^+ R; j! a, a, B
2、StreamReader对象StreamReader对象用于读取文本文件。用某些方式构造StreamReader对象要比构造FileStream对象更简单,因为使用StreamReader时不需要FileStream的一些选项。特别是不需要模式和访问类型,因为它只能执行读取操作。
! z. b% D! r+ O2 b" H4 zStreamReader类的构造方法的版本比较多,最简单的构造函数只带一个文件名参数。
, D- q' P# ], O' gStreamReader sr=new StreamReader(@“C:\test.txt”);4 n# b4 x+ u; V" X, c
StreamReader sr=new StreamReader(@“C:\test.txt”,Encoding.UTF8);# F# `% L$ R8 I9 }+ e& F. t: _
也可以把StreamReader关联到FileStream对象上。例如以下代码。; o5 V9 Y/ b# Q: t+ R6 O5 C3 a
FileStream fs=new FileStream(@ “C:\test.txt”,FileMode.Open,FileAccess.Read);: g) ^$ @- U+ T1 R
StreamReader sr=new StreamReader(fs);* v5 ^- F8 ^) X& t7 \7 y
StreamReader对象读取数据的方法主要有三个。
* h% r6 l- J$ u" c  m$ V(1) Read()方法:此方法每次读取一个字符,返回的是代表这个字符的一个正数,当独到文件末尾时返回的是-1。
- v+ }9 D' O3 E# a6 N(2) ReadLine()方法:此方法每次读取流中的一行数据,但不包括回车和换行符。当读到文件末尾将返回null。
: @2 O6 `/ r3 {" m4 T(3) ReadToEnd()方法:此方法一次性读取文件中的所有数据。8 I( J% X* ~' Q6 ~+ U
/ n- w; m& P/ i" L
3、使用StreamWriter对象写入数据和StreamReader对象读取数据

2 F% {' n& x/ x. ^3.1、StreamWriter对象写入数据
7 u9 V: y, C* Q5 D2 s/ f" Q8 }% E
: E1 M  J$ t; d( S2 o. l9 A. |, K5 ^$ l8 M$ c) r7 [

    % E8 K. l6 }/ T  p& |: k, G
  • //读取数据
  •         private void button1_Click(object sender, EventArgs e)
  •         {
  •             //创建StreamReader对象
  •             //编码方式和写入数据时保持一致
  •             StreamReader sr = new StreamReader(@"C:\My Document\ReadMe1.txt", Encoding.Default);
  •             //利用StreamReader对象的ReadToEnd()方法读取文件中所有数据
  •             richTextBox1.Text = sr.ReadToEnd();
  •             //关闭StreamReader对象以释放资源
  •             sr.Close();
  •         }
    . A. Q! ?" Q/ O4 g/ y

6 C8 E. o3 A; i/ A  R, w) Z
& s( E! E2 w' Z/ Y/ R) \: b  e9 N6 v

9 Q  N. j  ~2 D6 w
4 E! F0 ?. _8 |5 `$ C3.2、StreamReader对象读取数据" R  K& m) b% N+ ]- O

0 S4 ?, [# q; ]) \# _! f
/ e. t8 Y- M5 ]4 |6 [* Y" W
    2 J, m/ I  {8 \! X# g7 f; H
  •         //写入数据
  •         private void button2_Click(object sender, EventArgs e)
  •         {
  •             //创建StreamWriter对象
  •             StreamWriter sw = new StreamWriter(@"C:\My Document\ReadMe1.txt", true, Encoding.Default);
  •             //获取输入数据的文件并放入数组
  •             string[] data = richTextBox1.Lines;
  •             //遍历字符串数组
  •             foreach (string line in richTextBox1.Lines)
  •             {
  •                 //将文本通过StreamWriter对象逐行写入文件
  •                 sw.WriteLine(line);
  •             }
  •             //关闭StreamWriter对象以释放资源
  •             sw.Close();
  •         }- t. \' ]3 d3 p: [) j

7 T% a/ [- i( ], Z9 l
( D* l0 n! R$ @$ p4 [
0 _' ^, L0 e# [/ d. s9 n

6 t  L) N1 O" C9 r* `2 Q+ V四、总结​ 1、如果要对文件的内容进行读写,就需要用到流。! D% O* h/ X" \& Y3 {
​ 2、FileStream只能处理原始字节(Raw Byte)。处理原始字节的功能使FileStream类可以用于任何数据文件,而不仅仅是文本文件。通过读取字节数据,FileStream对象可以用于读取图像和声音的文件。这种灵活性的代价是,不能使用FileStream对象直接读入字符串,需要将字节数组转换为字符数组或者字符串。
8 P1 e+ J6 D$ N) P( ^​ 3、虽然直接操作FileStream对象可以读取和显示文本文件,但是操作字节数组比较麻烦。如果知道某个文件包含文本,通常就可以使用StreamWriter和StreamReader类更方便的对这些文件进行写入和读,而不是FileStream对象。这是因为这些类工作的级别比较高,特别适合于读写文本。它们执行的方法可以根据流的内容,自动检测出停止读取文本较方便的位置。0 P! S- t2 Y+ p) m2 l
* T, |' o0 F8 C
  x( S/ R0 Z9 T' S

8 L4 S4 i3 L: g( F1 J7 `3 U7 u0 U  `9 |' W. G: \% ^, M
( b3 I4 e2 }% a0 O2 ^. P" i) i6 O
% z: P0 Z  _8 N/ b0 E7 Z

" e- A( i$ C# g8 [
! U/ T- i" e8 P4 _0 O1 A0 @- U  A( ~( h3 @- }# r3 N# H

该用户从未签到

2#
发表于 2021-10-21 14:24 | 只看该作者
在FileAccess构造函数不使用FileAccess枚举参数的版本中,使用默认值FileAccess.ReadWrite

该用户从未签到

3#
发表于 2021-10-21 16:21 | 只看该作者
使用FileStream类读取数据并不容易,这是因为FileStream类只能处理原始字节(Raw Byte)。
您需要登录后才可以回帖 登录 | 注册

本版积分规则

关闭

推荐内容上一条 /1 下一条

EDA365公众号

关于我们|手机版|EDA365电子论坛网 ( 粤ICP备18020198号-1 )

GMT+8, 2025-11-24 01:15 , Processed in 0.140625 second(s), 23 queries , Gzip On.

深圳市墨知创新科技有限公司

地址:深圳市南山区科技生态园2栋A座805 电话:19926409050

快速回复 返回顶部 返回列表