Read Text File in C# Using Streamreader
Important Terminology
What is the File Descriptor?
File descriptor is integer that uniquely identifies an open file of the process.
File Descriptor table: File descriptor tabular array is the collection of integer array indices that are file descriptors in which elements are pointers to file tabular array entries. One unique file descriptors table is provided in operating system for each process.
File Table Entry: File tabular array entries is a construction In-memory surrogate for an open file, which is created when process request to opens file and these entries maintains file position.
Standard File Descriptors: When any process starts, then that process file descriptors table's fd(file descriptor) 0, 1, 2 open automatically, (By default) each of these 3 fd references file tabular array entry for a file named /dev/tty
/dev/tty: In-memory surrogate for the terminal
Terminal: Combination keyboard/video screen
Read from stdin => read from fd 0 : Whenever we write whatever character from keyboard, it read from stdin through fd 0 and save to file named /dev/tty.
Write to stdout => write to fd 1 : Whenever we see any output to the video screen, it's from the file named /dev/tty and written to stdout in screen through fd 1.
Write to stderr => write to fd ii : We see whatsoever error to the video screen, it is also from that file write to stderr in screen through fd 2.
I/O Organization calls
Basically in that location are total five types of I/O system calls:
1. Create: Used to Create a new empty file.
Syntax in C linguistic communication: int create(char *filename, mode_t style)
Parameter:
- filename : name of the file which you want to create
- style : indicates permissions of new file.
Returns:
- return first unused file descriptor (generally iii when first create employ in process because 0, 1, 2 fd are reserved)
- return -1 when fault
How it work in Os
- Create new empty file on disk
- Create file table entry
- Fix commencement unused file descriptor to point to file table entry
- Return file descriptor used, -1 upon failure
2. open: Used to Open the file for reading, writing or both.
Syntax in C language #include<sys/types.h> #include<sys/stat.h> #include <fcntl.h> int open (const char* Path, int flags [, int style ]);
Parameters
- Path: path to file which you want to utilize
- utilize accented path begin with "/", when you are not work in aforementioned directory of file.
- Utilise relative path which is only file name with extension, when y'all are work in same directory of file.
- flags : How you lot like to use
- O_RDONLY: read only, O_WRONLY: write but, O_RDWR: read and write, O_CREAT: create file if information technology doesn't exist, O_EXCL: prevent creation if information technology already exists
How it works in Os
- Notice the existing file on disk
- Create file table entry
- Set kickoff unused file descriptor to bespeak to file table entry
- Return file descriptor used, -1 upon failure
C
#include<stdio.h>
#include<fcntl.h>
#include<errno.h>
extern int errno ;
int main()
{
int fd = open up( "foo.txt" , O_RDONLY | O_CREAT);
printf ( "fd = %d/n" , fd);
if (fd ==-1)
{
printf ( "Error Number % d\n" , errno );
perror ( "Program" );
}
return 0;
}
Output:
fd = 3
3. close: Tells the operating system you are done with a file descriptor and Close the file which pointed by fd.
Syntax in C language #include <fcntl.h> int close(int fd);
Parameter:
- fd :file descriptor
Render:
- 0 on success.
- -1 on mistake.
How it works in the OS
- Destroy file table entry referenced by element fd of file descriptor table
– As long every bit no other process is pointing to it! - Ready element fd of file descriptor table to Zero
C
#include<stdio.h>
#include <fcntl.h>
int main()
{
int fd1 = open( "foo.txt" , O_RDONLY);
if (fd1 < 0)
{
perror ( "c1" );
exit (one);
}
printf ( "opened the fd = % d\n" , fd1);
if (close(fd1) < 0)
{
perror ( "c1" );
exit (i);
}
printf ( "closed the fd.\n" );
}
Output:
opened the fd = three closed the fd.
C
#include<stdio.h>
#include<fcntl.h>
int principal()
{
int fd1 = open( "foo.txt" , O_RDONLY, 0);
close(fd1);
int fd2 = open( "baz.txt" , O_RDONLY, 0);
printf ( "fd2 = % d\northward" , fd2);
leave (0);
}
Output:
fd2 = 3
Here, In this code first open up() returns iii because when chief process created, so fd 0, one, 2 are already taken past stdin, stdout and stderr. So start unused file descriptor is three in file descriptor table. Afterward that in close() arrangement call is gratis it this 3 file descriptor and then after set iii file descriptor equally naught. And so when nosotros called second open(), then get-go unused fd is too three. So, output of this program is 3.
4. read: From the file indicated by the file descriptor fd, the read() function reads cnt bytes of input into the memory area indicated by buf. A successful read() updates the admission time for the file.
Syntax in C linguistic communication size_t read (int fd, void* buf, size_t cnt);
Parameters:
- fd: file descriptor
- buf: buffer to read data from
- cnt: length of buffer
Returns: How many bytes were really read
- return Number of bytes read on success
- return 0 on reaching stop of file
- return -1 on error
- return -1 on signal interrupt
Important points
- buf needs to betoken to a valid memory location with length not smaller than the specified size because of overflow.
- fd should be a valid file descriptor returned from open() to perform read functioning because if fd is Nada so read should generate error.
- cnt is the requested number of bytes read, while the return value is the bodily number of bytes read. Also, some times read system phone call should read less bytes than cnt.
C
#include<stdio.h>
#include <fcntl.h>
int principal()
{
int fd, sz;
char *c = ( char *) calloc (100, sizeof ( char ));
fd = open( "foo.txt" , O_RDONLY);
if (fd < 0) { perror ( "r1" ); go out (1); }
sz = read(fd, c, ten);
printf ( "called read(% d, c, 10). returned that"
" %d bytes were read.\n" , fd, sz);
c[sz] = '\0' ;
printf ( "Those bytes are every bit follows: % s\north" , c);
}
Output:
called read(3, c, 10). returned that ten bytes were read. Those bytes are equally follows: 0 0 0 foo.
Suppose that foobar.txt consists of the 6 ASCII characters "foobar". Then what is the output of the post-obit program?
C
#include<stdio.h>
#include<unistd.h>
#include<fcntl.h>
#include<stdlib.h>
int master()
{
char c;
int fd1 = open( "sample.txt" , O_RDONLY, 0);
int fd2 = open( "sample.txt" , O_RDONLY, 0);
read(fd1, &c, one);
read(fd2, &c, 1);
printf ( "c = %c\n" , c);
exit (0);
}
Output:
c = f
The descriptors fd1 and fd2 each have their ain open file table entry, so each descriptor has its own file position for foobar.txt . Thus, the read from fd2 reads the start byte of foobar.txt , and the output is c = f, not c = o.
v. write: Writes cnt bytes from buf to the file or socket associated with fd. cnt should not be greater than INT_MAX (defined in the limits.h header file). If cnt is zero, write() simply returns 0 without attempting any other action.
#include <fcntl.h> size_t write (int fd, void* buf, size_t cnt);
Parameters:
- fd: file descriptor
- buf: buffer to write data to
- cnt: length of buffer
Returns: How many bytes were really written
- render Number of bytes written on success
- return 0 on reaching end of file
- render -ane on mistake
- return -1 on signal interrupt
Important points
- The file needs to exist opened for write operations
- buf needs to be at least as long as specified by cnt because if buf size less than the cnt then buf will lead to the overflow condition.
- cnt is the requested number of bytes to write, while the return value is the actual number of bytes written. This happens when fd have a less number of bytes to write than cnt.
- If write() is interrupted by a signal, the effect is one of the post-obit:
-If write() has not written any data still, it returns -1 and sets errno to EINTR.
-If write() has successfully written some data, it returns the number of bytes it wrote earlier it was interrupted.
C
#include<stdio.h>
#include <fcntl.h>
master()
{
int sz;
int fd = open( "foo.txt" , O_WRONLY | O_CREAT | O_TRUNC, 0644);
if (fd < 0)
{
perror ( "r1" );
exit (one);
}
sz = write(fd, "hello geeks\n" , strlen ( "howdy geeks\n" ));
printf ( "called write(% d, \"hello geeks\\n\", %d)."
" It returned %d\n" , fd, strlen ( "hello geeks\n" ), sz);
close(fd);
}
Output:
chosen write(3, "hello geeks\northward", 12). it returned 11
Here, when y'all see in the file foo.txt after running the lawmaking, you get a "hello geeks". If foo.txt file already accept some content in it and then write system phone call overwrite the content and all previous content are deleted and only "hello geeks" content will have in the file.
Print "hello world" from the program without utilize any printf or cout function.
C
#include<stdio.h>
#include<string.h>
#include<unistd.h>
#include<fcntl.h>
int chief ( void )
{
int fd[2];
char buf1[12] = "hello earth" ;
char buf2[12];
fd[0] = open up( "foobar.txt" , O_RDWR);
fd[1] = open( "foobar.txt" , O_RDWR);
write(fd[0], buf1, strlen (buf1));
write(one, buf2, read(fd[ane], buf2, 12));
close(fd[0]);
shut(fd[1]);
render 0;
}
Output:
hello world
In this code, buf1 array'due south string "hello world" is commencement write in to stdin fd[0] and so after that this string write into stdin to buf2 array. After that write into buf2 assortment to the stdout and print output " hello world ".
This article is contributed by Kadam Patel. If you similar GeeksforGeeks and would like to contribute, you can also write an commodity using write.geeksforgeeks.org or mail your commodity to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and aid other Geeks.
Please write comments if you find anything incorrect, or you want to share more than information about the topic discussed to a higher place.
Source: https://www.geeksforgeeks.org/input-output-system-calls-c-create-open-close-read-write/
0 Response to "Read Text File in C# Using Streamreader"
ارسال یک نظر