如何逐行读取文本文件中的数据时，如何捕获并忽略或处理异常

Question

I am reading a file line by line from text file and do some processing. The problem is that if some error occurs at some line. Then an exception is generated, what I want is that I want to ignore that error and move to the next line to read. But if an exception is generated then I cant continue reading input lines. Please help.

Answer 1

If I'm assuming what you're asking for correctly, here's a basic outline of what your code could look like:

using (StreamReader reader = File.OpenText("Path\to\your\file"))
{
    string line = null;
    while ((line = reader.ReadLine()) != null)
    {
        try
        {
            ProcessLine(line);
        }
        catch { /* Ignore exceptions */ }
    }
}

It's generally not a good idea to blindly catch all exceptions, so if you can, you should filter the exceptions caught by your catch block to something more specific.

Answer 2

See exception handling. http://msdn.microsoft.com/en-us/library/0yd65esw(v=vs.71).aspx

Answer 3

If you really want to "ignore" exceptions, you can do something like:

try
{
    foo(); // Something that may throw an exception
}
catch
{
}

See http://msdn.microsoft.com/en-us/library/0yd65esw(v=vs.80).aspx for more info.

But usually, an exception means something bad happened, and you'll probably want to handle that somehow.

Answer 4

try
{
//put the statement throwing the exception here
}
catch
{
//will eat the exception
}
//execution will continue here

Answer 5

Difficult to understand what you want to achieve, but you probably are asking for something like this:

while(condition)
{
    try {
        //process file line here
    }
    catch (Exception ex) {
        LogException(ex);
    }
}

Not a good design decision in my opinion, by the way. Avoid it if you can.

Answer 6

You need:

using System.IO;

to get this to work.

---

You can try:

try
{
    string path = ""; // You must add the path here. Else it won't work.
    string[] lines = File.ReadAllLines(path);
    foreach(string line in lines)
    {
        Console.WriteLine(line);
    }
} catch (Exception ex, IOException ioex) {
    // It's optional. You can remove "Exception ex, IOException ioex" if you want. You can delete the code below too.
    Console.WriteLine(ex.ToString());
    Console.WriteLine();
    Console.WriteLine(ioex.ToString());
} finally
{
    // in this "finally" section, you can place anything else. "finally" section isn't important, just shows that method has no exceptions.
    // you can add something else like: Console.WriteLine("Code has no exceptions. Great!");
}

Good for advanced notepads.

---

EDIT : If you don't like the previous solution, this one can help you.

string path = ""; // Again, path.
string[] lines = File.ReadAllLines(path);
foreach(string line in lines)
{
    try
    {
        Console.WriteLine(line);
    } catch(Exception ex, IOException ioex)
    { /* exception */ }
}

----- or -----

string path = Console.ReadLine();
int turns = 0;
int maxturns = (File.ReadAllLines(path)).Count();
while (turns < maxturns)
{
    try
    {
        Console.WriteLine(File.ReadLines(path).Skip(turns).Take(1).First());
    } catch (Exception ex, IOException ioex) { /* exception */ }
    turns++;
}

Answer 7

Use a try catch and log the error . Your code would look like this:

try
{
   //read lines here
}
catch(Exception ex)
{
   //log the exception but don't throw anything.
}

You may be tempted to do nothing in the catch, but you will likely regret it later.

Try catch article:

http://www.homeandlearn.co.uk/csharp/csharp_s5p6.html

Answer 8

You simply need to wrap your processing code in a try / catch block.

 try
 {
     DoSomeProcessing(lineThatIreadFromFile);
 }
 catch
 {
    // Log or Ignore error here
 }

However, please note that typically, just swallowing exceptions is never a good idea. You should either fail your program (if unrecoverable), or potentially log those somewhere so you can fix why your program is failing.

Answer 9

This is not a good approach. You should be proactive and catch specific exceptions you can recover from. Catch them as close to the place where they are thrown from. And let the rest of them bubble up and terminate the process. By swallowing all exceptions you will get an illusion of robustness while in fact your code may be full of bugs. There is simply no 'quick and dirty' approach to exception handling. See this answer .

Avoid handling errors by catching non-specific exceptions, such as System.Exception, System.SystemException, and so on, in application code. There are cases when handling errors in applications is acceptable, but such cases are rare.

An application should not handle exceptions that can result in an unexpected or exploitable state. If you cannot predict all possible causes of an exception and ensure that malicious code cannot exploit the resulting application state, you should allow the application to terminate instead of handling the exception.

Answer 10

Based on the very limited information you provide there are two things you can do:

• Enclose the offending line with an empty catch block. Wait for next maintainer to do bad things to you.

• Understand why the exception is happening and modify the code such that the next maintainer understands why it is safe that you ignored a certain condition