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

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

[复制链接]

该用户从未签到

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

EDA365欢迎您登录!

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

x
文件流3 h1 U2 A, P& k2 ]; F) y# Z

: D5 d2 n: G% @' }6 d* h- @3 u一、流的概述
8 r( |+ H: X# f# w+ e​ 要完成文件的读写操作,就必须了解C#中另外一个重要的概念——流(Stream)
- l2 O& K7 Q/ p. ^. A4 K2 M: k; O​ C#中流的概念可以和生活中的流相对应。在生活中有水流和电流,首先要有一个源头,还需要有传输的管道,
' o" {. @4 ^( C; ^. {; Y水流有河道、水管作为传输管道,电流有电线,而这些流都会有一个目的,就是它的流向。C#的流也需要源头——文件、数据流入流出管道以及数据的访问。
1 L3 G- s5 D! b. R, T2 Q1、输出流和输入流 .Net Framework中进行的所有输入、输出工作都需要用到流。
/ K, U% Z" s. \/ ?* x/ x​ 1、输出流:当向某些外部目标写入数据时,就要用到输出流。$ e, B- ]) y3 }8 W3 i" ~5 Z, ^: E- |
​ 2、输入流:用于将数据读到程序访问的内存或变量中。
- S1 ^% [- N6 e/ V3 |# g
在程序的控制台中的可以理解为:
8 k# U: Q8 \9 t) j) ^输出流:控制台程序中,将信息从程序中输出的处理:Console.WriteLine();
7 D( g# j. x2 Y% T2 h9 T" h  o4 ^& C5 P输入流:通过用户键盘来输入到程序当中处理:Console.ReadLine();# h: S* i& Y: `& o0 K7 U* {
2、文件读写,常用的三个类对于文件读写,常见的三个类:& T6 K* f" X/ J3 E8 z$ [% y7 `* R
​ 1、FileStream(文件流):这个类主要用于在二进制文件中读写二进制数据——也可以使用它读写任何文件
9 L8 ]5 |/ t$ |' ?- ]7 [​ 2、StreamWriter(流写入器)和StreamReader(流读取器):这二个类是专门用来读写文本文件的。. ^, t3 o6 t+ N$ E# w8 G
二、FileStream对象### 1、FileStream对象的二种重载​ FileStream对象表示在磁盘或网络路径上指向文件的流。这个类提供了在文件中读写字节的方法。
0 f1 \: @0 x9 F" ^# {9 F( `​ 有多种方法可以创建FileStream对象,FileStream类的构造函数有很多的重载版本,最简单的重载版本仅带有二个参数,即文件路径和FileModel枚举值。# C2 }7 g+ U( Z4 v# Y, l
1.1、第一种重载:  @+ [4 @$ s, [: Z' D

: D" C# l/ f3 @% Q
& ]7 r: E7 |3 X
    6 }3 U" y- u6 J2 O1 v( H# r5 R
  • FileStream aFile = new FileStream( 文件路径 , FileMode.成员值);
    4 Y. {2 S6 i- S  h
+ M+ u0 ^) C) m: b3 j; L

! z* Y9 B; {1 v/ M0 _2 I

. L+ V! |: R* D5 L' g9 e) g1 ~: J( k; [. w0 W. @; F
FileModel的枚举成员:
5 t" p4 }# P0 N5 P
, p6 A) a$ t: a. |! [- n8 Q7 A
1.2、第二种重载:
! u4 @. L5 y. R  y1 K& v* n7 l( A* J( Q( k2 L9 k( M: z3 }' f

6 d' j5 k% E9 h% B

    ' D: d6 A6 K$ \7 K3 v
  • FileStream aFile = new FileStream( 文件路径, FileMode.成员值, FileAccess.成员值);
    % B# w2 t5 g) M) Q4 `' e

" v4 v; }0 i( k* d: B# t
* L& ~! }0 V8 t4 T1 v! M

. F. R0 k# S! T( w$ s0 t: t' `  i6 N, s8 q( J; a( z
FileAccess的枚举成员:
+ l4 h* D! `, z
2 z, Q9 H1 s% G# a3 o, v& s
在FileAccess构造函数不使用FileAccess枚举参数的版本中,使用默认值FileAccess.ReadWrite。
1 }' v: g) \, C3 _: N​ File和FileInfo类中都提供了OpenRead()和OpenWrite()方法,使程序更易于创建FileStream对象。前者打 开了只读访问的文件,后者只允许写入文件。6 F8 U3 r5 c/ i+ S* _. Q, S
​ 这些都提供了快捷方式,因此不一定要以FileStream构造函数的参数形式提供前面所有的信息。例如,下面的代码行打开了用于只读访问的Data.txt文件。
$ Y& l! u' e( \4 q, u  ]
% ]7 s0 H! ]+ D* I8 ^% J+ |. C% T: O7 f+ u  {1 E' O  x* G/ D
; o& J, a3 \( L' Q$ q

    " t" v4 J" {5 V' ]7 O/ ?  `
  • FileStream aFile=File.OpenRead(@“C:\Data.txt”);
      A4 y' o6 j) B/ W/ x
- W0 u- B; |9 H, x+ `; \- C% }

& Z! V4 z( T5 {; k2 @9 ~; x' [( }" v6 O, V% O+ U& C8 ]/ S

7 D6 D. i& \3 \+ b) ~
4 {3 u6 X9 Z; p  o* Y% @或者
* E% t& w# p; o% X7 G9 Y. I
7 L. M# v: m% e1 i- G' [5 C+ c: j( Z( h1 ~1 ]/ T( v! y
: P9 F: \1 L# n8 _3 V
    ! S: G' W  x2 l- a6 |
  • FileInfo aFileInfo=new FileInfo(@“C:\Data.txt”);7 \7 O2 m# B* l0 G9 i

' @  p6 J2 {! P. v5 c: y9 z8 n
' y5 O' S5 I( Y
  L$ z; L) O+ A/ x

. O9 O; u* ]& C# Z" i* U4 w  O
: c# @, a1 w  _5 ~/ N3 k' k" s8 E' q7 n* ?$ F2 }
& c$ f$ K9 y% h

$ ^0 I# w5 d; |  i

    % O8 [2 p2 g$ [5 H# v2 f
  • FileStream aFile=afileInfo.OpenRead();$ r  M  o" l9 r" O) ]

' J( X5 Y: ]1 K( D9 u6 I  v% b7 H6 }$ p
4 U7 S+ ?: O2 ?- j5 F9 a, n0 G
7 ?; T2 v7 F# U
2、使用FileStream读取数据和写入数据​ 使用FileStream类读取数据并不容易,这是因为FileStream类只能处理原始字节(Raw Byte)。4 _1 J: a$ H# o: o
​ FileStream对象的Read()方法是从FileStream对象所指向的文件访问数据的主要手段。这个方法从文件中读取数据,再把数据写入一个字节数组。( T: g' [9 l: C, {. T" c) H5 s( Y+ Q

' p  m) ?0 P! W7 I% R$ `) t  u: F: h​ 该方法有三个参数:第一个参数是传入的字节数组,用以接收FileStream对象中的数据。第二个参数是字节数组中开始写入数据的位置。通常是0,表示从数组开端开始放置读入的字节。最后一个参数指定从文件中读出多少字节。- T& n4 I$ J- B6 @7 Z

) A0 }" [& o1 u. ]' J& Z, [/ Y2.1、读取数据:
% ?3 y: n9 ]" b: i$ y% h在编写程序代码前,需导入Sysytem.IO命名空间。此应用程序打开了磁盘上某个文件,用于读取其中的部分数据。首先,通过实例化一个FileStream的对象,将流指向这个文件。
1 M2 p# [" h, k. X6 C这可以通过:( Q8 M' P3 T9 J6 y6 S( I8 w
* \3 B# W/ I0 P2 d: Q4 }
, g  W3 d4 s/ ]. u! Y

1 H: q6 X. i+ i" x

    - J. M) h. X$ ?8 l6 n( x0 ^/ M
  • FileInfo aFileInfo =new FileInfo(@"C:\My Document\ReadMe1.txt");
  • FileStream aFileInfo =aFileInfo.OpenRead();! O. ^9 L+ K3 u: N9 P8 v

7 V" j+ L8 U3 u9 K# B# R  o) H

9 }) e  [) x! B" G4 k! ~' j3 ]- z0 n2 e2 Q" Y3 O" _5 O! P: p
步骤:创建FileStream对象,并指向文件流——得到文件大小(字节单位)——创建一个相同大小的字节数组——将文件的字节内容读到数组中——将数组中字节转为字符——输出显示——关闭流
% h4 Q; r/ S9 T* k8 A: q& v0 P. Y- |  r2 j& {( d1 T
, n  k7 @" j0 b$ z/ O* V9 x) V
5 z: e7 r/ E$ b% k* y1 j" J

    - Y6 m, ]: g& E- I' t/ U( J
  •   /// <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();
  •         }
    : d  l* Z# s* O/ J/ G8 g0 G8 \

/ a) w+ k1 P, N. P# Z: p  w! P2 m1 K+ A6 o6 ]
  }6 v/ F" f# b" O2 r8 y  |

2 g0 l6 o6 m4 i& S5 E; L+ P" i+ \2.2、写入数据:' Z8 ]% F# j! _8 p
步骤:创建FileStream对象,并指向文件流——声明一个数组是写入数据字节的2倍——使用Encoding类的GetBytes()方法将字符串中的一组字符编码到字节数组中,(1、编码的字符集的字符串,2、表明第一个编码的字符的索引,3、要编码的字符的数量,4、表明要包含所产生的字节序列的字节数组,5、开始写入所产生的字节序列索引位置)3 z; s# i% F% S8 c

0 }4 y) m$ ~: w8 Z) v8 u/ m% m1 m, W; j6 e+ }, C7 q  G
; M9 _: {/ w4 N) }+ H# g4 ^

    5 u5 c* e$ `7 c! d  l; }( H) ?5 s
  • /// <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();
  •         }
    1 W8 m3 N. w3 r3 {! J- X
9 L& ?: k; a+ e& l7 e; J1 ^2 \
, d/ v8 q' X8 d; O

6 R. j! F- l% S! z
$ D  i5 k/ ^; [) [8 |' M* v三、StreamWrite和StreamReader对象1、StreamWriter对象- d) o7 l* w: \- E4 @7 I* O
StreamWriter对象只能用于写入文件(或另一个流),StreamWriter类的构造方法有很多版本。最常用的有以下三种。& X# w8 g" \# e% v- o% W- e) Q4 r
' K' |- z+ W; V
9 u. U2 z9 O3 g) S

& W5 r$ `: L5 `9 {9 U( ^

    5 V" z- Q- Q5 d4 f. C
  • StreamWriter sw=new StreamWriter(@ “C:\test.txt”);9 |7 d' @) v  u# D( R

. S& ~) I  s; Q! M3 [/ s+ W
) D: Z) v! {' [! c

4 t$ N) {+ C" Q. q; z, R
* H- c; j+ Y6 s3 |: l将使用UTF-8的编码方式创建StreamWriter对象,.NET把这种编码设置为默认的编码方式。9 i  S8 T# z& x3 ]6 p
$ J2 O& }- y2 x0 P  U- N4 w
/ m5 `7 U8 {- C; b, y

4 Q- z( N1 p9 v3 ~$ r

    , Z* x# f, h0 w1 d: z, B
  • StreamWriter sw=new StreamWriter(@ “C:\test.txt”, true);+ m; Q$ B% S- }
1 {; }# y4 Q" ?4 g! E

7 I/ j9 q7 i# e- U$ G) e) }/ q! P# R, M' t
; `! [; _% ]* |

6 A- v& w5 j' I8 l0 m在这个构造函数中,第二个参数是bool类型,表示文件是否以追加的方式打开。
- E. u8 H. g- q
% g! v% L# O) \/ _# u7 q  Y& O3 ]2 _$ L9 c" }0 s( r

* J4 P: B: ~" Q3 K; o# }. H/ q

    : c1 @2 \" Y9 T6 [
  • StreamWriter sw=new StreamWriter(@ “C:\test.txt”,true,Ecoding.ASCII);
    . b9 F) S$ Y6 C" j# i2 N7 n  M
% |1 S! V# w! k4 ~" C
5 l+ F8 F" t' C, U; C- ^1 v
  O' ^  A' s: G  t- T
, H9 Q- x* g6 l7 a' v
, g" {4 A& h' _0 [! L
在第三个函数中,第三个参数可以指明要使用的编码方式ASCII来创建StreamWriter对象。但不能仅以文件名和编码方式来创建对象。
" K/ D( w3 p* m' I7 ]当然,也可以将StreamWriter关联到一个文件流上,以获得打开文件的更多控制选项。例如以下代码。
* f' \/ P" h7 F7 T
& {2 q6 h: U) {0 C, Y, m2 z- z, z4 D- T! I3 k+ g! e
% j3 v9 e  A' ~6 S3 ^' W2 u5 r, |

    & m2 {, f5 f# }6 J
  • FileStream fs=new FileStream(@“C:\1.txt”,FileMode.Append,FileAccess.Write);
    6 E2 Q& z( @/ n& X( k* ^( s1 Q
" X& a& X9 V. K/ u

7 y0 d2 R# x0 H" m' W
2 g  G7 C" \  [# J, J2 z3 _
& P5 d/ y( z# z# A" h6 f

0 g; p# R7 z2 p6 ^3 ^6 x( p; K- Y  I# ], Q3 W
( Z6 d' ]: w) H6 M' B& z
    / n& d2 j7 b$ V9 V+ b5 }7 X/ B  R
  • StreamWriter sw=new StreamWriter(fs);# U* \% V( o& v6 o
1 B+ V- O  ?! K) c

9 Q# ^- L8 Z: J) p' s' G/ P
0 Q" {+ ]: H0 ~
5 \9 C+ t& H( @' R7 E! k% `

! }  J2 @9 _; ~9 f/ M! p0 HStreamWriter对象有两个方法来完成向文件或流中写入数据的功能。1 m9 s2 w7 N* l9 L: }/ U8 y$ Y, c
WriteLine()方法:一次写入一行文本,流会自动把回车符合换行符添加到文本的末尾。
  ~( E' |: w6 V3 \- HWrite()方法:向流或文件中写入文本,但不会在末尾添加回车和换行符。
' P6 _" T+ [1 z4 JStreamWriter对象和FileStream对象一样,功能执行完毕后要使用Close()方法关闭以释放资源。8 v* N/ g2 U  f4 B/ n
2、StreamReader对象StreamReader对象用于读取文本文件。用某些方式构造StreamReader对象要比构造FileStream对象更简单,因为使用StreamReader时不需要FileStream的一些选项。特别是不需要模式和访问类型,因为它只能执行读取操作。* ~8 x6 z- R7 x) q8 }; l
StreamReader类的构造方法的版本比较多,最简单的构造函数只带一个文件名参数。; Z' c, l+ v. u* I$ X6 C8 @
StreamReader sr=new StreamReader(@“C:\test.txt”);
1 G/ n# M* W" t6 EStreamReader sr=new StreamReader(@“C:\test.txt”,Encoding.UTF8);
0 m1 \$ T' p2 o/ s& Q) l也可以把StreamReader关联到FileStream对象上。例如以下代码。
7 J% R; p  U0 V( Y4 }1 I  s* P! TFileStream fs=new FileStream(@ “C:\test.txt”,FileMode.Open,FileAccess.Read);8 Q5 b' a& W6 `
StreamReader sr=new StreamReader(fs);
1 H' ?; m- h  ^0 {& jStreamReader对象读取数据的方法主要有三个。
2 B" ?+ j% q9 }. }$ j(1) Read()方法:此方法每次读取一个字符,返回的是代表这个字符的一个正数,当独到文件末尾时返回的是-1。
' D$ I( W$ l, F0 Y(2) ReadLine()方法:此方法每次读取流中的一行数据,但不包括回车和换行符。当读到文件末尾将返回null。
, M" v4 e- h  K(3) ReadToEnd()方法:此方法一次性读取文件中的所有数据。
' i' T& h7 P; e* x' \( O: ]% A- n- E: m, m
3、使用StreamWriter对象写入数据和StreamReader对象读取数据

% B1 n" {/ |* r, M% S9 R3 U& M3.1、StreamWriter对象写入数据# W7 U3 u" V( y: M

/ n7 g  s8 U3 ]% [# j
& h) w" H; `  V7 j) c

    . _9 t" a8 g" @% D" ^' U$ \
  • //读取数据
  •         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();
  •         }# R$ [* u9 T# Z+ {# o% M

% L# M1 j$ ^* A  d6 o% Y- y; [+ `# E/ @2 O" p
; Y! z" |+ C/ ?5 C+ I+ z
# I+ I! G) i/ R# Z: Y. o
8 N; I& @) \. F0 a, B! v2 j
3.2、StreamReader对象读取数据7 b* n9 |1 }2 N' }

. K+ A7 v; k2 k3 {4 T! R1 f( r- o3 U6 a: W9 I* q' J% n( A
    " S- y! ^; K' @5 O5 j
  •         //写入数据
  •         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();
  •         }
    5 O5 I3 |3 U6 u0 {

! u; o# @; m: {# R, w% ]
! k3 }5 j, E" L5 m3 W3 L2 {

! I9 `: h8 q6 S7 b. W( P" D3 V7 {2 ^& f. U% K
四、总结​ 1、如果要对文件的内容进行读写,就需要用到流。
7 m. x, g' {# u3 e9 [/ W8 x​ 2、FileStream只能处理原始字节(Raw Byte)。处理原始字节的功能使FileStream类可以用于任何数据文件,而不仅仅是文本文件。通过读取字节数据,FileStream对象可以用于读取图像和声音的文件。这种灵活性的代价是,不能使用FileStream对象直接读入字符串,需要将字节数组转换为字符数组或者字符串。
8 l; r) D, [& L1 }! B​ 3、虽然直接操作FileStream对象可以读取和显示文本文件,但是操作字节数组比较麻烦。如果知道某个文件包含文本,通常就可以使用StreamWriter和StreamReader类更方便的对这些文件进行写入和读,而不是FileStream对象。这是因为这些类工作的级别比较高,特别适合于读写文本。它们执行的方法可以根据流的内容,自动检测出停止读取文本较方便的位置。
! a8 c6 Y7 j! ~, M+ |- g6 _! [* o! @3 D, b  y, _. A' v6 G/ a

( L9 T: |  e; D9 Y. m& E7 R' D
# D/ ]% B: G% i' V) C) L# a. t0 b+ z7 `

5 [  x6 M. D9 s! b* g* b$ m& y7 N8 X
' I, K# M/ `- p5 P0 W/ R
' [9 Q, o, c  d& V- {0 F
- I  w" o. ~; j/ S9 a& K& |( K" V

该用户从未签到

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 14:27 , Processed in 0.187500 second(s), 23 queries , Gzip On.

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

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

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