Parsing C #, finding methods and setting try / catch for all methods

Perhaps whoever came up with this requirement doesn't understand that you can still catch all exceptions (above) without putting a try in every function. You can see an example on how to catch all unhandled exceptions here . I think this is a much better solution as you can do something with the exception and report it rather than blindly burying all exceptions, making it extremely difficult to track errors.

This is similar to Scott's solution, but also adds an event handler to the Application.ThreadException that can happen if you are using threads. It is probably best to use both to catch all exceptions.

See my answer here , which outlines some of the performance tradeoffs you will have to live with if you use "gotta catch em all" exception handling.

As Scott said, the best way to do the same is with the UnhandledException event. I think jeff actually discussed this issue in an early SO podcast.

I'm with StingyJack, don't do it!

However, if the gods are at a high pointer to be executed, see my answer to this question Get method content from cs file

First of all, I am with StingyJack and Binary Worrier. There's good reasons for exceptions not caught by default. If you really want to catch exceptions and die a little better, you can put a try-catch block around the call Application.Run()

and work from there.

When working with external sources (files, internet, etc.), you need to (usually) catch certain exceptions (bad connection, missing file, blah blah). However, in my book, an exception elsewhere means either 1) error, 2) faulty logic, or 3) bad data validation ...

Finally, and not to fully answer your question, are you sure you want to do this?

I wanted to write this as an answer to all the answers, then you can find out through the RSS question; the requirement comes from our technical manager: here's the reason: we don't need to figure out which func has problems in production code, any problem was reported as a warning, we put unique code in the ecery catch block and we see where the problem is. It knows there is global error handling, but that doesn't help in this scenario, and the stacktrace is not propagated in release mode, so it requires a try catch block like this:

everyMethod(...){
    try
    {
    ..
    catch(Exception e)
    {
       RaiseAlert(e.Message.. blabla)
    }
}

      

        
        
        
      

    

If you put a call to RaiseAlert in all methods, you can end up with erroneous stacks that will be very confusing if not inaccurate if you use reusable methods. The logging method should really only need events or the topmost method (s). If someone insists that exception handling should be in every method, they don't understand exception handling.

After a couple of years, we implemented the practice of handling exceptions in every case, and one developer read it as "every method". When they were finished, we had weeks to cancel because no exceptions were reproduced. I assume they knew better than you do, but never doubted the validity of their interpretation.

The AppDomain.UnhandledException implementation is a good fallback, but your only way to use this method is to kill the application after registering the exception. You need to write a global exception handler to prevent this.

so here is an example for those interested; 5006 is unique to this method;

public static LogEntry Authenticate(....)
        {
            LogEntry logEntry = null;
            try
            {
                ....
                return logEntry;
            }

            catch (CompanyException)
            {
                throw;
            }

            catch (Exception ex)
            {
                logEntry = new LogEntry(
                    "5006",
                    RC.GetString("5006"), EventLogEntryType.Error,
                    LogEntryCategory.Foo);

                throw new CompanyException(logEntry, ex);
            }
        }

      

        
        
        
      

    

I am guessing that you could use Aspect Oriented programming, something that I would like to get my hands dirty. For example http://www.postsharp.org/aopnet/overview

Although such demands are really evil.

If you really need to , why would you need to fix the source code when you can directly compile the executable / library

Have a look at Cecil (see website ). It is a library that allows you to directly modify the bytecode using this approach, your whole problem can be solved in a few hundred lines of C # code.

Since you are posting a question here, I'm sure this is one of those things you just have to do. So instead of banging your head against an unshakable wall, why not do what Scott suggested and use the AppDomain event handler. You will meet the requirements without wasting hours on quality billable hours doing grunt work. I'm sure that once you tell your boss how long to check for each file update, using an event handler will be no problem!

So, you really don't want to put the same exact try-catch block in every function, right? You will have to adapt every try to every feature. Wow! This seems like a long way to "simplify" debugging.

If a user reports a bug in production, why can't you just start Visual Studio and reproduce the steps and debug?

If you absolutely need to add a try / catch block for each method and scott's answer (AppDomain.UnhandledException) is not enough, you can also look at interceptors. I believe the Castle project has a pretty good implementation of method interceptors.

If you really need to do this, an alternative to wrapping the exception every time would be to use Exception.Data to capture additional information and then reverse engineer the original exception ...

catch (Exception ex)
{
  logEntry = new LogEntry("5006",
                    RC.GetString("5006"), EventLogEntryType.Error,
                    LogEntryCategory.Foo);
  ex.Data.Add("5006",logEntry);
  throw;
}

      

        
        
        
      

    

Now at the top level, you can simply dump the contents of ex.Data to get all the extra information you might want. This allows you to put filenames, useragents, ... and any other useful information in the .Data collection to understand why the exception occurred.

I have done some research work requiring parsing C # code about 2 years ago and found that the SharpDevelop project has source code that does it really well. If you checked out the SharpDevParser project (this was two years ago, it is not clear if the project name is the same as the source code base), you can use the parser object like this:

CSharpBinding.Parser.TParser = new CSharpBinding.Parser.TParser();
SIP.ICompilationUnitBase unitBase = sharpParser.Parse(fileName);

      

        
        
        
      

    

this gives you compUnit.Classes which you can iterate through each class and find a method in it.