Basics of File Handling in C# Tutorial | The Ultimate Guide
File Handling in C ACTE

Basics of File Handling in C# Tutorial | The Ultimate Guide

Last updated on 28th Jan 2022, Blog, Tutorials

About author

Karan Baski (C# .Net Developer )

Karan Baski is a C# .NET developer expert and subject specialist who has experience with Git, WPF,VB,.NET Framework,.NET Core, SVN,HTTP,.NET technology stack, WPF, C#, SQL Server, Web API, and ASP.NET. His articles help the learners get insights into the domain.

(5.0) | 18241 Ratings 2340
    • Introduction to File Handling in C#
    • What is the record dealing with?
    • When will a file be made?
    • File Handling in C
    • Operation of File handing in C#
    • What is exemption dealing with in C#?
    • C# I/O Classes
    • The File Stream Class
    • Features of File Handling
    • Data Types
    • Instructions to Read PDF Files in C#s
    • The Scopes of Variables in C#
    • Advantage of File Handling in C#
    • Conclusion

    Subscribe For Free Demo

    [custom_views_post_title]

      Introduction to File Handling in C#:

    • A document is an assortment of information put away in a circle with a particular name and a registry way. At the point when a record is opened for perusing or composing, it turns into a stream.
    • The stream is fundamentally the succession of bytes going through the correspondence way. There are two standards: the info stream and the result stream. The info stream is utilized for perusing information from the record (read activity) and the result stream is utilized for composing into the document (compose activity).

    • What is the record dealing with?

      Record Handling is the putting away of information in a document utilizing a program. In the C programming language, the projects store results, and different information of the program to a document utilizing record dealing with in C. Likewise, we can extricate/get information from a record to work with it in the program. The tasks that you can perform on a File in C are.


      Fundamentals of File Handling in C Programming:

      Document Handling is the putting away of information in a record utilizing a program. In the C programming language, the projects store results, and different information of the program to a record utilizing document dealing with in C. Additionally, we can remove/bring information from a record to work with it in the program.

      The activities that you can perform on a File in C are –

    • Making another record
    • Opening a current record
    • Perusing information from a current record
    • Composing information to a record
    • Moving information to a particular area on the record
    • Shutting the record

    • Making or opening record utilizing open():

      The fopen() work is utilized to make another record or open a current document in C. The fopen work is characterized in the studio.h header record. Presently, lets see the grammar for production of another document or opening a record


      • “file = fopen(“file_name”, “mode”)”

      This is a typical linguistic structure for both opening and making a document in C.


      Parameters:

      file_name − It is a string that indicates the name of the record that will be opened or made utilizing the fopen strategy. mode: It is a string (normally a solitary person ) that determines the mode wherein the record is to be opened. There are different modes accessible to open a document in C, we will find out pretty much every one of them later in this article.


      When will a file be made?

      • document = fopen(“hello.txt”, “w”)

      The fopen capacity will make another file when it won’t track down any record of the predefined name in the predetermined area. Else, assuming the record is observed it will be opened with the mode determined. We should see a can model which will make the idea understood, Suppose we are opening a file named hello.txt utilizing the fopen work. The accompanying will be the assertion.


    • This will look for a document named hello.txt in the current index. Assuming the document exists, it will open the record any other way it will make another document named “hello.txt” and open it with compose mode (indicated utilizing “w”).
    • Presently, we should see a wide range of modes that are accessible for us to peruse or compose a document in C, and see code scraps that will show test runs of the code.
    • Mode = “r” − open for perusing, this mode will open the file for perusing reason just, for example, the substance must be seen, nothing else like alters should be possible to it.
    • This mode can’t make another document and open() returns NULL if we attempt to make another record utilizing this mode.

      • Model,
      • #incorporate <'stdio.h>
      • int main(){
      • Document * record;
      • if (record = fopen(“hello.txt”, “r”)){
      • printf(“File opened effectively in read mode”);
      • }
      • else
      • printf(“The record is absent! can’t make another record utilizing r mode”);
      • fclose(file);
      • bring 0 back;
      • }

      Yield:

    • “The record opened effectively in reading mode”.
    • We have made a record named hello.txt in our present registry yet on the off chance that we attempt to get to another document, we will get “The record is absent! can’t make another record utilizing r mode” as result.
    • Mode = “RB” − open for perusing in twofold mode, this mode will open the record for perusing in paired mode just, for example, the substance must be seen and nothing else like alters should be possible to it.
    • This mode can’t make another record and open() returns NULL if we attempt to make another document utilizing this model.

    • File Handling in C#:

      A record is an assortment of information put away on a plate with a particular name and a catalog way. Whenever a document is opened for perusing or composing, it turns into a stream.

      In C#, you really want to make a FileStream object to make another record or open a current document. The grammar for making a FileStream object is as per the following –


      • FileStream <'object_name> = new FileStream( <'file_name>, <'FileMode Enumerator>,
      • <'FileAccess Enumerator>, <'FileShare Enumerator>);

      Course Curriculum

      Learn Advanced C and C Plus Plus Certification Training Course to Build Your Skills

      Weekday / Weekend BatchesSee Batch Details

      Operation of File handing in C#:

      Here, the record tasks are likewise included as displayed underneath. The File Mode enumerator characterizes different techniques for opening records. The individuals from the File Mode enumerator are −

      Add: It opens a current record and puts cursor toward the finish of the document, or makes the record if the document doesn’t exist.

      Create: It makes another record.

      Create New: It indicates to the working framework, that it ought to make another record.

      Open: It opens a current document.

      Open Or Create It determines to the working framework that it should open a record assuming it exists, any other way it ought to make another document.

      Shorten: It opens a current document and shortens its size to zero bytes.

      File Access The File Access enumerators have individuals: Read, Read Write, and Write.

      File Share The File Share enumerators have the accompanying individuals −

      Inheritable It permits a document handle to pass a legacy to the youngster processes

      None: It decays sharing of the current document

      Peruse: It permits opening the document for readingb>

      Read Write It permits opening the document for perusing and composing

      Writeb> It permits opening the record for composing


      Allow us to see a guide to get the registries.

      • “//making a DirectoryInfo object
      • DirectoryInfo mydir = new DirectoryInfo(@”d:\Demo”);
      • // getting the records in the registry, their names and size
      • FileInfo [] f = mydir.GetFiles();
      • foreach (FileInfo record in f) {
      • Console.WriteLine(“File Name: {0} Size: {1}”, file.Name, file.Length);
      • }”

      What is exemption dealing with in C#?

      Special cases are an issue that emerges when a program is executed. The accompanying watchword handles exemptions in C#.

      Attempt: An attempt block distinguishes a square of code for which specific exemptions are actuated.

      Get: The catch catchphrase demonstrates the getting of a special case.

      At last: Execute a given arrangement of proclamations, whether or not an exemption is tossed.

      Toss: A special case is tossed when an issue appears in a program.


      C# I/O Classes:

      The System.IO namespace has various classes that are used for performing numerous operations with files, such as creating and deleting files, reading from or writing to a file, closing a file etc. The following table shows some commonly used non-abstract classes in the System.IO namespace –

      1 Binary Reader

      Reads primitive data from a binary stream.

      2 Binary Writer

      Writes primitive data in binary format.

      3 Buffered Stream

      A temporary storage for a stream of bytes.

      4 Directory

      Helps in manipulating a directory structure.

      5 Directory Info

      Used for performing operations on directories.

      6 Drive Info

      Provides information for the drives.

      7 File

      Helps in manipulating files.

      8 File Info

      Used for performing operations on files.

      9 File Stream

      Used to read from and write to any location in a file.

      1

      10 Memory Stream

      Used for random access to streamed data stored in memory.

      11 Path

      erforms operations on path information.

      12 Stream Reader

      sed for reading characters from a byte stream.

      13 Stream Writer

      s used for writing characters to a stream.

      14 String Reader

      s used for reading from a string buffer.

      15 String Writer

      String Writer is used for writing into a string buffer.


      Course Curriculum

      Get JOB Oriented C and C Plus Plus Training for Beginners By MNC Experts

      • Instructor-led Sessions
      • Real-life Case Studies
      • Assignments
      Explore Curriculum

      The File Stream Class:

      The File Stream class in the System.IO namespace helps in perusing from, writing to, and shutting documents. This class gets from the theoretical class Stream. You want to make a FileStream object to make another document or open a current record. The sentence structure for making a FileStream object is as per the following −

      • FileStream <'object_name> = new FileStream( <'file_name>, <'FileMode Enumerator>,
      • <'FileAccess Enumerator>, <'FileShare Enumerator>);

      Progressed File Operations in C#:

      The previous model gives basic record activities in C#. Nonetheless, to use the colossal powers of C# System.IO classes, you want to know the regularly utilized properties and strategies for these classes.


      Features:

      C#: Creating a vacant record:

      We should see the execution of how to make an unfilled text document.

      C#: Deleting a document:

      We should see the execution of how to erase a record if exist in a predefined area.

      C#: Writing text in a File:

      We should an illustration of how to compose information in a text record,

      C#: Appending text in a File:

      We should accept a model on adding the information in a current text document utilizing StreamWriter class,

      C#: Copy and Move a File:

      We should accept a model on the most proficient method to duplicate and move a text document starting with one drive then onto the next,

      C#: Creating another Directory:

      How about we see one final model on the best way to make a registry utilizing the Directory class


      Data Types:

      C# is a specifical language and we should announce the sort of a variable that demonstrates the sort of qualities it will store, like the number, float, decimal, text, and so on. The sorts of C# language are separated into two fundamental classifications.

    • Esteem types
    • Reference types.

    • Instructions to Read PDF Files in C#

      1. Download Read and Write PDF C# Library.

      2. Install with NuGet to Test the Library.

      3. Extract Images or Text from PDF.

      4. Read and Find Words in Specific Documents.

      5. View PDF Output from your unique archive.


      Features:

      C# is an article arranged programming language that was created by Microsoft in 2000. It is upheld by various working frameworks. C# is the essential language that is utilized to make .Net programming applications. It permits us to make Windows UI applications, backend administrations, controls, libraries, android applications, and even blockchain applications. C# chips away at the idea of classes and items very much like Java. A portion of the C# highlights are as per the following:

    • Follows organized methodology
    • Boundaries passing is simple
    • Code can be gathered on an alternate stage
    • Open-source
    • Object-situated
    • Adaptable and versatile

    • The Scopes of Variables in C#:

      The piece of the program where a specific variable is available is named as the Scope of that variable. A variable can be characterized in a class, strategy, circle, and so on in C/C++, all identifiers are lexically (or statically) checked, i.e. Scope of a variable not entirely set in stone at arranging the time and autonomous of the capacity call stack. Be that as it may, the C# programs are coordinated as classes.

      So, C# scope rules of factors can be separated into three classifications as follows:

    • Class Level Scope
    • Technique Level Scope
    • Block-Level Scope

    • Class Level Scope:

    • Pronouncing the factors in a class yet outside any strategy can be straightforwardly gotten to anyplace in the class.
    • These factors are additionally named as the fields or class individuals. Class level checked variable can be gotten to by the non-static strategies for the class where it is announced.
    • Access modifier of class-level factors doesn’t influence their extension inside a class.
    • Part factors can likewise be gotten to outside the class by utilizing the entrance modifiers.

    • Strategy Level Scope:

    • Factors that are announced inside a technique have a strategy-level degree. These are not open external the technique.
    • Notwithstanding, these factors can be gotten to by the settled code blocks inside a technique.
    • These factors are named as the nearby factors.
    • There will be a gather time blunder assuming these factors are pronounced two times with a similar name in a similar degree.
    • These factors don’t exist after the strategy’s execution is finished.

    • Block Level Scope:

    • These factors are for the most part announced inside the for, while articulation and so forth
    • These factors are likewise named as the circle factors or proclamations variable as they have restricted their degree up to the body of the assertion wherein it is pronounced.
    • By and large, a circle inside a strategy has three degrees of settled code blocks (i.e., class level, technique level, circle level).
    • The variable which is proclaimed external the circle is likewise open inside the settled circles. It implies a class-level variable will be available to the techniques and all circles. Technique level variable will be open to circle and strategy inside that strategy.
    • A variable that is proclaimed inside a circle body won’t be apparent to the outside of the circle body.

    • Advantage:

      Memory security:

      The code is trash gathered. Never stress over a wanderer reference getting missed someplace – except if you have something that is some way or another clutching references to stuff, any memory with nothing pointing at it will ultimately get liberated. Memory spills are GONE! (It’s as yet conceivable to spill memory in C#, it’s simply much harder to do).


      Reflection:

      C# classes have metadata that can be gotten to at runtime, including the class name, all the property names, and information about strategies, and this large number of things can be gotten to and summoned on objects at runtime. This empowers you to compose code that can use classes that were not been aware of when that code was made, making things like runtime serialization, reliance infusion, and a wide range of metaprogramming a snap contrast with C++. C++ is equipped for run-time type ID (RTTI) however it’s not even close as strong as C# reflection.


      You can likewise add discretionary metadata to pretty much anything utilizing Attributes – classes, properties, fields, techniques, even strategy boundaries. Reflection even can produce new classes and techniques at runtime, empowering runtime intermediaries, strategy block attempts from there, the sky is the limit. It further can investigate and alter code utilizing Expressions.


      Language Integrated Query (LINQ):

      Working with assortments utilizing LINQ takes a great deal of contemplating circles out of the situation. Rather than composing your sort, channel, guide, join, and other set tasks in circles that another software engineer would need to unroll to sort out what they’re for, C# has a modest bunch of elements that, when consolidated, transform all that into profoundly expressive useful programming.


      Task Parallel Library (TPL):

      Doing offbeat and additionally equal programming in C# is simply utilizing the errand equal library. (All things considered, as simple as parallelism can get). Indeed, C# upholds strings, however, a lot simpler than following strings is utilizing Tasks – sharing units of work as opposed to contemplating strings.


      Heaps of syntactic sugar:

      Assuming that it is done constantly, there’s presumably shorthand for it. Invalid checking and invalid mixing administrators? also ?? kill off the if (x == invalid) checks you would some way or another see out of control. Offbeat state machines can be produced rapidly utilizing the async and anticipate administrators (which wind up wrapping errands in any case). Identification classes can be produced quickly utilizing the yield bring watchwords back. Design matching was presented in a genuinely late form and it has been improving from that point onward, and it is quite a lot more expressive and adaptable than switch/case blocks.


      Disadvantages:

    • Quick as C# is, the idea of overseen code is it winds up running slower than unmanaged code, given a similar calculation. Checks cost some time and everything is checked.
    • In addition to the fact that it is slower, trash assortment is generally non-deterministic, making it through and through unacceptable for constant applications without doing a few quite certain things.
    • The metadata et al that empowers reflection, memory security, and different treats imply you end up with more runtime memory utilization.
    • Assuming you need pointers, they exist, yet you can involve them in unwieldy ‘dangerous’ blocks.
    • It’s a major language. For some, enormous scaring.

    • C and C Plus Plus Sample Resumes! Download & Edit, Get Noticed by Top Employers! Download

      Conclusion:

      We trust this article with loads of down-to-earth models assisted you with understanding the idea of document submitting C# language. On the off chance that you have any questions, if it’s not too much trouble, let us know in the remark segment. We are glad to address your questions.


    Are you looking training with Right Jobs?

    Contact Us
    Get Training Quote for Free