A simple solution to see the inside of your code

Introduction

Have you ever wanted to see what happens inside of your code? This project catches in real time every trace message from your application, centralizes them, and shows them on your screen in a friendly way.

The package contains five projects:

Tracer is a pipe server, and it receives all the trace messages and shows them on the interface.
EsiListener is a custom listener and also the pipe client. It sends all the trace messages to the server.
CPPEsiListener a C++ DLL used to send messages to MyTracer.
Client is a C# demo application. It can be your application.
CPPClient is a C++ demo application.

How it looks

Features

It is very easy to add or remove without changing your code.
Works with every application which respects standard tracing mode.
Works with different applications at the same time.
Locates the trace messages inside your application.
Traces objects and display all their properties and values.

How to use it

The Listener can be added from the source code:

Trace.Listeners.Add( new Esi.Diagnostics.Listener() );

The Listener can be added from your application Config file like shown below:

<system.diagnostics>  
    <trace>    
      <listeners>    
          <add name="myListener" 
             type="Esi.Diagnostics.Listener, esiListener"/>    
          <remove 
             type="System.Diagnostics.DefaultTraceListener"/>
      </listeners>   
    </trace> 
</system.diagnostics>

For tracing, just use the standard tracing:

Trace.WriteLine( " Hello world :) " ); 
Trace.Write( "Hello again :P" );

If you want MyTracer to recognize your message as an error, information, or warning, use the convention described below:
- error -> message has to start with [E],
- warning -> message has to start with [W],
- information -> message has to start with [I],
- service -> message has to start with [S] (reserved for MyTracer application),
- unknown messages -> any other messages.
```
Trace.Write( "[E]Uuuups error :( " );
```
An interesting option is that you can trace object values with one call:
```
Point p1 = new Point( 5, 5);
Trace.WriteLine( p1 );
```
If you don't want to copy esiListener.dll in every application directory, you can insert esiListener.dll in the global assembly cache.
```
gacutil -i esiListener.dll
```
For C++, copy the EsiListenerCPP.dll near the application. Add in the application project, Diagnostics.h and cpp (Set option: Do not use the precompiled header for the Diagnostic.cpp file). Before starting tracing, call:
```
Trace::Init();
```
For trace, call:
```
Trace::WriteLine("Trace from C++");
```
Convention for erorr[E], warning[W], and information[I] works here.