This blog entry, unlike my previous ones, is not about .NET, although there are a few technical links .

The end-of-year period has always been a period for resting, meeting with family and friends, reflecting on the year just past … thanking god for the good life and the good people around me … and thinking about what could come soon …

For resting, I really enjoyed the reading of a comic book serie called “Les Naufragés d’Ythaq” or in english “Ythaq: The Forsaken World“ (see references below):

The scenario is from Christophe Arleston and the drawings by Adrien Floch. I started the reading 3 years ago but the serie was not finished at the time. Now the first cycle (book #1 to #9) is finished – no more wait, so hurry !

Obvously, in France, resting is one side of the story – Family/friends gathering around a good table, i.e. good food and wine, is the other side story – no more comments.

Going back to Technical subjct, I also read and searched about “Testing Quadrants” (big picture here).

I have ordered the book “Agile Testing” written by Lisa Crispin and Janet Gregory, but I have not read it yet. “Testing Quadrants” are useful to help any technical team to build a safety net of tests for their system and explore new ways about testing their systems, see further References below.

2013 is here … I remember back in early 2003, people were saying that 10 years later the programming world would be dominated by Java and .NET languages (C# / VB.NET). Looking at the figures and the graph from TIOBE.com web site, the TIOBE programming indexes, no one could have forecasted the succes of “Objective-C” the language used to develop iOS applications. So forecasts are just forecasts, i.e. an indication, sometimes in the good direction sometimes not. The other interesting point is to note that C is still widely used - C was created beginning of 1970′s, more than 40 years ago, thanks to Dennis Ritchie. Incredible for a programming language to last that long!!

Another thing I remember at the time in 2003 were the talks about car self-driving. What happened in may 2012?

Google got a Nevada driving licence for self-drive car, a modified Pryus car from Toyata. Whahouh !!

Google/Toyata Self-driving car

And Toyata carries on “Toyota sneak previews self-drive car ahead of tech show (BBC)“. Maybe in 10 years time from now, my kids would not have to learn driving. What about old people or disabled people? they will have a car and go where they want.

Now a few more links to keep thinking what might come in the near future :

• IBM: The 5-in-5 senses computer [IBM web site] and [BBC web site].

• Microsoft : Meet Microsoft, the world’s best kept R&D secret (PC World).

• Bendable phone and others [BBC].

I hoped you enjoyed this first blog entry and if you have other links about what the future might bring us in the next 5 to 10 years, please post them and we will see in 2023 what really happened. Again Happy New Year 2013 to you !!

References:

• Happy New Year 2013 ! picture
  • I took it from a fantastic selection on this web site. Thank you XeBii Mj.
• Les Naufragés d’hytaq, Christophe Arleston / Adrien Floch / CrazyToons / Claude Guth / Sébastien Lamirand
  • Wikipedia, Les Naufragés d’Ythaq.
  • Ythaq web site.
  • Amazon.fr .
  • Amazon UK, “Ythaq – The Forsaken World “ .
• Testing Quadrants:
  • http://blog.jonasbandi.net/2010/02/agile-testing-quadrants.html
  • http://www.betterprojects.net/2010/08/lisa-crispins-test-quadrants.html
  • http://www.agiletester.ca/downloads/Chapter__9x_Quadrant_Summary_v3.pdf
  • http://blog.jonasbandi.net/2010/08/cassandra-syndrome-knowing-that-failure.html
  • The book at Amzon UK .

In this post, I am going to talk more about the implementation details of IDisposable and Finalize().

For reference, I have split this matter into two posts:

• # 1 – What + Why + references
• #2 – A guide about ‘how to implement it’ + samples (this post)

You should know by now when and why you should implement IDisposable and Finalize() method according to the type of resource(s) your class owns. In order to answer the question “How?” we still do need to look at two more aspects: 1) Inheritance (as in Object-Oriented Programming) & 2) Some remaining considerations.

OOP – Inheritance

There is one more aspect to take into consideration in object-oriented programming and that is inheritance. When you define a public base class (or any public class that can be instantiated and is not marked as “sealed”) you should consider that even though you have not any managed or unmanaged resources, you might still need to think about the potential classes that would derived from it. They might require managed or unmanaged resources. In that case, you should make the finalization code (IDisposable + Finalize()) in your base class, so that it is part of the contract and derived-class or client-code could use it correctly (i.e. calling Dispose() whenever it is required).

Obviously, if you are SURE to be  in control of ALL the client code of your class, then you can wait for your derived classes to really require this resource management code (IDisposable + Finalize()) before implementing it.

As for me, as soon as I create a new class, my first step is to make it “sealed” – I found this “habit” very effective, because it closes a lot of questions about inheritance (which method must be declared “virtual”, which method/properties/field should be declared “protected”, …). If later the class must become a base class, then I can review the changes and needs at that time. This is my way, everyone is different

 Some remaining considerations

Finalizers:

• Be careful, if an exception is thrown in the constructor, the finalizer code will still be executed, so make sure to check whether a field (to a native resource) has been correctly initialized before calling any clean up code on it.

Dispose() method:

• To help to ensure that resources are always cleaned up appropriately, a Dispose() method should be callable multiple times without throwing an exception.
• The object must dispose all of the resources it owns.
• A disposed object cannot be used anymore (i.e. once its Dispose() method has been called), so it must become ”garbage” so next time the garbage collector will kick off its managed memory can be reclaimed (or if it has a Finalizer(), it will be place on the “f-reachable” list).
• Once an object has been disposed, all of its public methods must throw the exception of type “ObjectDisposedException”.
• You must make sure that no delegates (from Rooted object) are pointing to it, usually done via “events“. Here, you have two choices:
  1. The instance which is running Dispose() exposes event(s) (aka source of event(s)), then it must reset the list of its subscribers (you might want to define a ‘OnDisposing’ event, so that client code might register and have a chance to be notified when Dispose() is called on the source).
  2.  The instance which is running Dispose() consumes event(s) (aka subscriber of event(s)), then it must unsubscribe itself from the source(s) of events.

Versioning:

• You have to be careful when adding “IDisposable” to your class.
  • If you are in control of all the assemblies using it, then you can add it and review its usage amongst all your code.
  • If you have shipped or distributed your class to customers/partners, you cannot add it like that, because this change the semantics of your class and the client code is not aware of it. In that case, one option to make your existing class “Obsolete” and create a new one with the implementation of IDisposable and let your clients know about the new class.

Native Handle

• Since .NET 2.0, Microsoft has released a new abstract class ‘SafeHandle‘ [Ref-01 & 02] that can help you in disposing native handles. Most of the .NET classes that wrap native handles (File, Pipe, Wait handle, Registry key, …) use internally specialized classes derived from ‘SafeHandle’ (read the doc on .NET v4.0 or above of MSDN about this subject). So you might consider, if needed, to create your own SafeHandle derived class for disposing native handles.

Decision Matrix

So, now we have all the bits of information that should be taken into consideration to find out what really is needed in the code for your class:

• Sealed class or base class?
• What type of resources does your class own?

Once you answered to those questions, then the matrix below provides you with the bits that are required for you case:

Nota:

• Finalize():
  • Must only release unmanaged resources. E.g. native/unsafe handles on file, windows etc.
    No cleaning code on .NET object field(s) should be done inside a Finalizer. (i.e. calling Dispose(), Close() or removing event handlers …).
• Dispose(bool): implement it when the release logic is shared by Dispose() and Finalizer()

Here is a link for downloading a sample solution (VS 2010, C# source code).

The sample code I am providing respect the decision matrix above (and is deliver “AS -IS”, the usual formula for “disclaim”). However, because of refactoring and reuse of code you will find some differences. E.g. for “non-sealed class” instead of defining a “protected virtual Dispose(bool)” method I instead defined a “private” one with the hard-coded ”Dispose(bool) logic” in it and defined two virtual methods: one for disposing Managed Resources and one for Unmanaged Resources (I did not update the decision matrix, because it is close to what you can find on current MSDN documentation, so most developers should be familiar with it – the principles are here).

Fx-Cop to the rescue

If you are using Visual Studio 2005 and above and have the “FX-Cop” as part of your edition (also referred as “Code Analysis”) it is a good practice to enable the following checking rules:

This way, every time you add code to your project, FX-Cop can look for you for new usage of Disposable resources and warn you about your usage in your code. This is not bullet proof (I had some cases, long chain of inheritance, where FX-Cop did not detect and did not warn about the not use of IDisposable.Dispose() – but this was more the exception than the rule, so use it).

Conclusion

That is it for me. I hope you have now a better understanding about “how to implement IDisposable”.

References:

• [REF-01] ”Safe Handles and Critical Finalization“, MSDN online.
• [REF-02] “SafeHandle Class“, MSDN online.
• “Microsoft.Win32.SafeHandles Namespace“, MSDN online (from Donald’s comment)

(It took me more than a year to finish writing this article – a “hot topic” and I wanted it to be clear, simple and right. Also, I was busy and did not want to publish anything “unfinished”. As usual, your feedback and comments are more than welcome. Thank you in advance)

Recently (February 2011), I had to review some .NET code and came across of some wrong implementations of IDisposable.

After discussing with the developers, there were many reasons for what I found, ranging from:

• Not knowing the difference between a “CLR memory resource”, a “managed resource” and an “unmanaged resource”;
• Not understanding “how and when”  resources are “released”;
• Not knowing when to override the “Finalize()” method and what should be released by a finalizer?

Even if the recent publications are becoming better, documentation from Microsoft is not fully clear on this subject. There are still some ambiguous areas about when you should implement a Finalizer (I must admit, since I started to do .NET programming back in 2002 (with .NET 1.1), MSDN documentation has improved a lot, but it took me a lot of time to understand this topic – thanks to the books like the ones from Jeffrey Richter [REF-01], Don Box [REF-02] and Bill Wagner [REF-03]).

I have split this matter into two posts :

• # 1 – What + Why + references (this post)
• #2 – A guide about ‘how to implement it’ + samples

If you already know about the IDisposable pattern and what are the types of resources managed by the .NET CLR (Common Language Runtime – Microsoft implementation of the managed runtime environment on the .NET platform), please go directly to the second post. If you do not know or want to learn more about it, please keep reading.

What are memory resources on .NET CLR?

In managed environments (like the .NET CLR or the Java JVM), “memory management on the heap” is taken care by the runtime engine, i.e. CLR on the .NET platform – The rest of the discussion will focus only on the  .NET platform.

Like a supervisor, the runtime engine knows everything about heap memory allocation in its world, aka the managed environment. However, this managed environment lives and is hosted in a less “managed” environment, e.g. the Windows operating system.  Your application might need some resources that are not managed by the CLR and even living outside your process. They could be locally allocated on the same machine or remotely far away on another machine. The important point is that you can use them from your code in .NET.

From this picture we can see 3 types of memory resources for a .NET application:

• CLR memory resources, such as _myNetObj or the string “Hello world!”. Their memory space and fields (int and string) are all allocated on the CLR’s heap memory.
• Managed resources, such as _myObjWindow, _myObjFile, _timer1, _file1, _connection1. They are .NET classes which have direct unmanaged fields and/or other managed resource as fields. Their memory space is managed by the CLR.
• Unmanaged resources, such as window, timer, file, DB. They live outside the CLR’s heap memory. They can be referred as “native resources” as well.

The CLR only controls and manages its memory. The CLR has its own algorithms to allocate/move/release its memory (heap, large object heap, …). The CLR’s heap memory management is based on a “generational garbage collection”.  I am not digging too much in details inside the CLR implementation of its “garbage collector”, because it would require many posts , but the aim of the garbage collector is to reclaim not reachable managed memory and re-compact the memory to prevent memory fragmentation as much as possible. For further details, please see [REF-01] [REF-07] and [REF-08].

The bold statement above requires a shift of mind from the way development is done in a “native memory management”, such as in C and C++ language, compare to a managed environment like the .NET CLR.

In native memory management, the developer that you are is in charge of the memory allocation, you will do a malloc() (or new()) method to allocate memory, use your object and when you do not need it anymore you will call de-allocate() (or delete()) method to free the memory. You have “great powers”, but also great responsibilities about the management of your memory. This style of memory management is also referred as “deterministic memory management“. By opposition, CLR’s style is referred as “non-deterministic memory management“.

In the “deterministic memory management” style, there are a few drawbacks:

• First you end up managing handlers/pointers to memory area. You have to be careful and aware of the size of the “right portion of the  memory allocated” when writing and reading from it.
  • Overrun buffer, stack data corrupted, memory corrupted are results of misuse of those handlers/pointers.
• For some applications, the repetition of the cycle  “allocation/de-allocation” on a native heap space will fragment the memory and the process will end up at some point with an “out-of-memory” error, even though it still has a lot of free space (the free space is fragmented and not contiguous).
• From a security point of view, the system cannot verify the stack and its memory pointers and apply security checks/rules.

To address some of those issues, managed environments (which have existed since the 70s, “hello Smalltalk !”) have been revisited and refreshed with the latest features. For the CLR, this includes the following features (not a thorough list):  “generational garbage collectors” and “Code Access Security (CAS) for .NET”.

Now, in this new managed environment world, the developers are not concerns anymore about memory allocation/de-allocation of CLR memory resources. However, as your application does not lived (yet!) in a full managed operating system, you must pay attention to managed resources and unmanaged resources.

The other key point to retain is that once you have finished using an object allocated on the CLR’s heap it might be de-allocated at some point but nothing is certain and there is no guaranty (i.e. about “when” and whether it would be de-allocated at all).

In fact, in the “non-deterministic memory management” style you have:

• Not sure the CLR will re-use the memory space used be your object (if there is no need to claim memory, why bother).
• You do not know when this space will be re-used.

That leaves the .NET developer with 2 problems:

1. How can he “force/trigger” the release of resources?
2. How can he make sure that managed resources and unmanaged resources will still be released (at some point)?

To help you with that task about releasing other resources than CLR memory resources, the .NET team came up with the IDisposable interface [Ref-04]  and the Dispose pattern [Ref-05]. The other .NET feature that will help you is the Finalize() method (a protected method define at the System.Object level).

What about IDisposable ?

.NET objects live in a managed world (aka CLR). We know that the CLR memory management style is non-deterministic, i.e. developers do not have to worry about releasing the CLR heap memory allocated by CLR memory resources. However, for other types, managed resources and unmanaged resources, we do not want those objects to stay in memory for long after we have finished to use them. Some of those objects have a Close() method, some have a Free() method, some have a Release() method, and some have even a mix of them.

So, how can I (as a developer) know which one to call to free up the managed and native resources? (like DB connections, files, …)

The .NET team came up with a single interface named IDisposable with a single method called Dispose() to standardize the way resources are disposed:

• Because it is an interface, it does not prevent your class to inherit implementation from whatever class it needs to (remember, you are only allow one implementation class inheritance, but many interface inheritances);
• As you decorate your class with that interface, it adds semantics (interfaces are like contracts) and intention to your class. So, developers using your class should know about it.
• The dispose method is simple – no parameters – and its name is clear: dispose any resources you have.
• Developers should only be aware if a class Implements IDisposable to call a single method, Dispose(), to release all resources by an instance of that class.

The .NET C# team went a step further by providing a construct in the language called “using” that will allow you to declare, use and call the Dispose() method in a try/finally block.

Why do you a need a Finalizer?

You only need to implement  a Finalizer (i.e. override Finalize() method) in your class if your class directly creates a native resource (aka unmanaged resource) like a memory space in the unmanaged heap, a GDI handle or a file handle.

Otherwise, if your class is using the .NET objects provided by the .NET framework (e.g.System.IO. Stream), those classes are managed resources and they already implement IDisposable and have a Finalize() method overridden. So, you only need to call their Dispose() method from your implementation. YOU DO NOT HAVE TO implement a Finalizer() in that case.

Jeffrey Ritcher [Ref-01] has some other examples that you might want to implement a Finalizer() in your class even though your class does not have a (direct) native resource (e.g. if you want to monitor garbage collection). I do think this is the exception to the rule.

In the “non-deterministic memory management” style the finalization is as follows:

• Exact time of finalization is unspecified. (When? => you do not know)
• Order of finalization is unspecified. (Order? => you do not know)
• Thread running the Finalize() method is unspecified. (Which Thread? => you do not know)

Objects with a Finalize() method overridden have an extra cost associated with them in order to reclaim the CLR memory used by your object [REF-01][REF-06][REF-07][REF-08] . It will take at least two garbage collections:

• First one to put your object in the “f-reachable” list;
• Run your Finalizer() code
• Then remove your object from the “f-reachable” list, so that your object becomes unreachable (i.e. no roots referencing it);
• Its managed heap memory will be reclaimed in the next full garbage collection (i.e. generation 2, current maximum generation level in the CLR as I am writing these lines).

The .NET C# team provided a destructor syntax (only the syntax, not the semantics !!), but the piece of code written in that method will be placed inside the Finalize() method by the C# compiler in a try/finally block, with a call to the base class in the finally block. This is maybe one of the ambiguous area and syntax for C# developers to understand: the Finalize() method is not a destructor, i.e. like in C++.

If your class has one (or more) unmanaged resource then you will need to:

• Override the Finalize() method;
• Call GC.SuppressFinalize() from your public Dispose() method;
• Your Dispose() method must release any managed and unmanaged resources;
• Your Dispose() method can be called multiple times without failing.
• Once your object has been disposed, it cannot be (re-)used anymore. It is garbage !!
• Once your object has been disposed, all public instance methods should raise the exception “ObjectDisposedException”.
• Only release unmanaged resources in your Finalize() method.

Please, refer to the second post, there is a detailed matrix about what needs to be implemented in various scenarios and some sample code.

End of part 1

I hope that by now you have a better understanding about:

• The different types of memory resources available in the CLR (CLR memory resource, managed resource and unmanaged resource).
• The IDisposable interface.
• The Finalize() method and when to implement it.

My second post has a detailed matrix to help you find out, depending in your context, what needs to be implemented and some code samples.

References:

• [REF-01] Jeffrey Richter, CLR via C#, 3rd Edition, Microsoft Press (see Chapter 21).
• [REF-02] Don Box and Chris Sells, Essential .NET – Volume 1 (p. 147-152).
• [REF-03] “Effective C#”, Bill Wagner, second edition, Addison Wesley (Ch2 p.69-74; item-17)
• [REF-04] “IDisposable Interface“, MSDN online
• [REF-05] “Implementing a Dispose Method“, MSDN online
• [REF-06] “Finalize Methods and Destructors“, MSDN online
• [REF-07] “Garbage Collection: Automatic Memory Management in the Microsoft .NET Framework (Part-1)“, Jeffrey Richter, MSDN November 2000.
• [REF-08] “Garbage Collection: Automatic Memory Management in the Microsoft .NET Framework (Part-2)“, Jeffrey Richter, MSDN December 2000.

Good news, Microsoft just put out last Wednesday, 29th February 2012, their new ”Windows 8 - Consumer Preview” [Ref 01]. I had the “Developer Preview” on my beautiful tablet (gift from Samsung and Microsoft to the BUILD conference attendees last September, thank you!), but it was not that stable, so I have been patient and I was looking forward this new release.

So, I updated my tablet (I did not sell it like some did ) on Thursday 1st March and played with it for the last 2 days. I must say it is a lot more stable and it boots on my tablet in about 10 seconds : that’s a change !

I went to the “Appication Store” and started to download almost everything they had on the first page – it was free. Then, As I developer, I started to install Visual Studio 11 Beta from the link provided by “Microsoft App Dev Center page” [Ref 02]. It is only at the end of the installation that I noticed it was “Express edition” and not “Ultimate” or “Pro” edition. This was not the edition I wanted – sorry, nothing wrong with “Express” : it is a fantastic product and its is free, but I am used to “Pro” and “Ultimate”. So, after half-hour of installation I am reduced to unsinstall “Visual Studio 11 Beta Express Edition” and start again.

Wait a minute ! Where is the “Add/Remove Programs” on Windows 8?

I spent nearly 15 minutes to find out where “Add/Remove Programs” is located now. I hope this is something that Microsoft will improve. Here are the steps I had to do (I will talked about the gestures I did as I am running this on my tablet):

Step	Description
1	Press the “Start” button to be on the “Start” page of Windows 8.
2	Swipe your finger from the right side to display the “Charm bar”.
3	Press “Settings”, the “Charm bar” will disapear and another panel on the right side will be displayed:
4	At the top, press on “Settings” (a second time).
5	The “Start Settings” panel will be displayed. Switch on the feature “Show administrative tools”.
6	Now, go back to the “start” page (Press button “Start”)
7	Slide your finger “from right to left” and go to the end.
8	Try to find the “System Configuration” tile. Press it.
9	Windows will navigate to the “Old desktop App”, and a Window “System Configuration” will be displayed.
10	Go to the “Tools” tab and look for a tool named “Programs”. Select it and click on the button “Launch” (maybe you can double-click it, but I am not doing it on my tablet because my finger is too big and the regular windows buttons are small).
11	Now you can select the program you want to uninstall – for me it was VS 11 Beta Express Edition. This list only contains the programs for “regular” windows, i.e. not designed and developed as “Metro-App style”. For “Metro-App style” I am assuming you can uninstall them from the “Store” – but I have not yet tried.

I hope this helps.

If like me you want to install VS 11 Beta Ultimate edition see [Ref-03].

Happy “swiping” on the new Windows 8.

References

• [Ref-01] Download “Windows 8 – Consumer Preview”.
• [Ref-02] MSDN, Windows | Dev Center – Metro style apps, “Download for Developers”.
• [Ref-03] Download Visual Studio 11 Beta Ultimate edition.

You can watch the videos on YouTube [REF-03]. The challenge results are interesting, specially for a phone OS which have only about 1.5 % of the global phone shares market (see my previous entry on that).

Overall results for Windows Phone 7.5 (aka Mango):

• 30 wins.
• 3 loses
• 1 draw

=> 88% wins. Not bad !!

Let’s see by the end of 2012 where Windows Phone will be – Nokia and HTC launched this week new phones in USA, that should boost Windows Phone sales and shares market.

Ok, I might seem a bit too “Pro-Windows Phone”, but I do think  that Microsoft has done a tremendous OS for the phones, specially around the “people hub” for communicating with people and social networks. People should have a try at it before buying their new phone!

References:

• [REF-01] Microsoft CES 2012 Gallery page .
• [REF-02] “Smoked By Windows Phone Challenge at CES 2012″, by Ben Rudolph, Windows Phone Team blog, 12-Jan-2012.
• [REF-03] Videos on YouTube.

I know, this might seem a little too basic, but there are still some misuses of Exception and misunderstanding about how to raise/re-raise exception without losing the original information. So here it is my contribution to help to improve the “good” use of Exception programming in .NET (samples are in C#, but the principles are valid for the .NET platform).

(Source code available here ExceptionsDemo.zip – rename the file with a “.zip” extension)

1 – The basics

You can think of an Exception as a piece of data (with hopefully useful information) that once raised will disrupted the normal flow of function or application. By catching it, your code can then decide on whether or not to return to a normal flow, let it raise again or even add further information.

Exception can be raised in one place to indicate an unexpected failure or an abnormal use of a function/method. Then another piece of code would catch the exception and act upon it for various reasons (logging, audit, security, retry ….). The decoupling between the location that ’raise’ and the one that do the ‘catch’ is for me the main added value of Exception programming.

In .NET, if an exception raises up to the CLR without finding a catch block that handles the exception, the default exception handler handles it and the process will be terminated.

The good things about Exception programming are:
- The source (i.e. the location) raising the exception is decoupled from where it will be caught and act upon. It might be the direct callee method, or it could be the previous 100th call method on the stack.
- Along the raising path, there might be more than one location to caught the exception and act on it.
- The exception can be enriched along its raising path.

Andrew Pardoe [Ref -03] wrote a good article about the evolution from return codes to Exception programming.

I must also mention that Exception programming add a “little overhead” and could have in some circumstances a negative impact on performance (e.g. looping 1,000,000 with many try/catch embedded). It is up to you to test your code – normal path and abnormal path – to find out how your code react. However, as I said earlier, your code will run most of its time in the PRODUCTION environment, and to me having usuful information when facing a PRODUCTION issue has a bigger value that counter balance the “little overhead” issue.

In this blog I will present the different ways to raise, re-raise and catch exceptions.

1.1 – How to raise an exception?

In .NET C#, you will raise an exception by using the keyword ‘throw’, like this:

throw new InvalidOperationException("Zero cannot be a valid result for this implementation.");

Or like this:

   InvalidOperationException ex = new InvalidOperationException("Zero cannot be a valid result for this implementation.");
ex.Data.Add("m", m);
ex.Data.Add("n", n);
ex.Data.Add("result", result);
throw ex;

Raising the exception is the first step in providing useful information: a clear error message and the call stack.

The important thing to note is that the number of the line in the call stack will be the one where the exception was raised, i.e. where the call to ‘throw’ is made (line #5) – not the number of line where the exception was instantiated (i.e. ‘new…’ in line #1) - Line numbers in the call stack are only available if the “.pdb” (Program database files – you have to switch the compilation switch to produce those files in ‘Release’ flavour – they are automatically generated in ‘Debug’ flavour) files are deployed and available when the exception is raised.

In the last example above, the code is showing the use of the property ‘Data’ to add further information. This is a good thing that application can use to transmit further information about the exception (paramerters, local value).  ’Data’ is a dictionary the old fashion way: Dictionary[object; object] (that was before the generics existed on .NET).  So you have to be becareful about:

• The type use for ‘key’. I usually use ‘string’, but as an object it could be anything.
• The ‘key’ must be unique, so if you use ‘string’ there might be some naming collision. Usually, I use a name based on pattern like this: <MyApp>.<MyClass>.<MyMethod>.<MyKeyName>.
• ‘Value’ can be anything.

As you will see further down, the exception can go through many exception handling blocks before being used, so you have to think about the data you want to store in ‘Data’ and decide whether or not in your case storing sensitive data is fine or not. Also, if you put any reference to object(s) they will be directly accessible (via ‘Data’) by any code above your method, so maybe you should consider cloning your objects or only pass value types.

1.2 – How to catch an exception?

Using the try/catch block, you can catch an exception:

try
{
// some code that will raise an exception
}
catch (Exception ex) // Exception handling block
{
// You have access to the exception raised here;
}

You can define more than one exception handling block. In that case, you must attention to the existing inheritance between the various exception classes you will be using for your handling blocks: define the more specialized exception class first, then the more generic ones.

E.g. from an inheritance point of view we have the following inheritance relationship for ‘ArgumentNullException’:

System.Object
  System.Exception
    System.SystemException
      System.ArgumentException
        System.ArgumentNullException

In that case you should defined you handling block like that:

            ...
            catch (ArgumentNullException nullEx)
            { ... }
            catch (SystemException sysEx)
            { ... }
            catch (Exception ex)
            { ... }

1.3 – What is available?

The base class System.Exception [Ref-01] has defined some useful fields:

Please note that some properties are not available on all the .NET Frameworks -  E.g. ‘Data’ and ‘Source’ are not available on the .NET Compact Framework. Please refer to the corresponding MSDN documentation for your version of .NET Framework.

2 – What to do with the exception caught?

At this stage, you caught an exception, you have mainly 3 choices:

1. Do nothing.
2. Re-raise the exception
   1. The original one + stack trace. Optionally, can add further info via ‘Data’ property.
   2. Reset the stack trace.
3. Raise a new exception
   1. Brand new one – lost info about the original
   2. Use of InnerException

2.1 – Do nothing (NOT RECOMMENDED, BUT SOMETIMES CANNOT DO OTHERWISE)

At least you should log or trace the exception.
In some occasions, you may have to refer to this case, i.e. ignore or swallow the exception raised. E.g., using a third-party assembly, the first call to their initialisation code was failing the first time and raising an exception. The second time it was working. While waiting for a fix from the editor, I implemented a catch() block that ignore the exception the first time (but logged it).

On other occasions, I have to refer to this case when writting another ‘try/catch’ block within a ‘finally’ block (see below for further details).

2.2 How to re-raise an exception?

During a chain of method calls, a piece of code might catch an exception to do some process on it (logging, audit, …), but does not want to stop the exception handling here. In that case, it must re-raise (or re-throw) the exception.
There 2 possibilities:
1) Re-raise the original Exception (with the original stack trace)
2) Re-raise the original Exception and reset the call stack

2.2.1 Re-raise as it was

In this case we want to re-raise the exception as it was (line #8):

try
{
// some code that will raise an exception
}
catch (Exception ex)
{
// You have access to the exception raised here;
throw;
}

In this case, just use the word, “throw;”. The original exception and its call stack will be preserved.

2.2.2 Re-raise it by resetting the call stack – NOT RECOMMENDED

In this case, you can re-throw the same exception like this (line #8):

try
{
                // some code that will raise an exception
}
catch (Exception ex)
{
// You have access to the exception raised here;
throw ex1; // Reset the call stack to this frame (i.e. this line of code becomes the bottom of the call stack !!!)
}

I do not recommend this usage because the call stack is reset, so you will lose a lot of useful information during the support phase of your application:
=> You loose the original line of code that thrown the exception, and all the call chain.
=> The new line fo code in the call stack is the line #8 of “throw ex1;” – not so useful!

Also, I could not think of a valid scenario for this case – I do not even understand why the CLR allows this case – Please, I am curious, shared with me if you have a valid scenario for this one. As for me, I keep chasing down this usage on every project I worked on, because when it happens in PRODUCTION we will not have the original call stack.

2.3 Raise a new exception

Again here there are 2 possibilities:
1) Raise a brand new exception and forget about the original one.
2) Raise a new exception and set the InnerException field with the old one.

2.3.1 Raise a brand new exception

In this case we want to raise a fresh new exception and forget about the original one (line #8):

try
{
// some code that will raise an exception
}
catch (Exception ex)
{
// You have access to the exception raised here;
                throw new ArgumentException("Wrong Argument");
}

This is sometimes necessary, e.g. when you want to prevent some sensitive data (server name, IP address, user info, …) to bubble up to the surface. Creating a brand new one with a general but useful message is a solution in that case.
However, I will advise to still log the original one, e.g. in an encrypted log file if it is required, but log it.

2.3.2 Raise a new exception and set the innerException field

In this case, you want to add some information along side the original exception like this (setting the parameter name to “m” – line #8):

try
{
// some code that will raise an exception
}
catch (Exception ex)
{
// You have access to the exception raised here;
                throw new ArgumentException("Wrong Argument", "m", ex);
}

This is fine, as the original exception is preserved with its information (mainly the call stack) and further information was added.

3 – The default AppDomain exception handler

The code you write in .NET will execute within an ApplicationDomain (System.AppDomain). This is the secure boundary context on the .NET platform to run code.  A process could have more than one AppDomain. The AppDomain has an event called ‘UnhandledException’ [Ref-02] to which your code can regsiter a handler like this:

static void Main(string[] args)
{
AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException);
...
}
static void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e)
{
Console.Out.WriteLine("CurrentDomain_UnhandledException");
if (e != null)
{
Console.Out.WriteLine("IsTerminating: '{0}'", e.IsTerminating);
if (e.ExceptionObject != null)
Console.Out.WriteLine("ExceptionObject: '{0}'", e.ExceptionObject.ToString());
}
}

The .NET platform had various behaviours regarding how dealing with this event. Please refer to the MSDN documentation for further details, but here are the main points:

• This event (UnhandledException) provides notification of uncaught exceptions.
• The system default handler reports the exception to the user (debuging options).
  • .NET 1.1 : debugging options are reported to the user before this event is raised.
  • Since .NET 2.0: event is raised then debugging options are reported to the user.
• The system default handler terminatesthe application.
  • .NET 1.1 : An unhandled exception that occurs in a thread other than the main application thread is caught by the runtime and therefore does not cause the application to terminate. Thus, it is possible for the UnhandledException event to be raised without the application terminating.
  • Since .NET 2.0: This backstop for unhandled exceptions in child threads was removed, because the cumulative effect of such silent failures included performance degradation, corrupted data, and lockups, all of which were difficult to debug.
• This event can be handled in an application domain.
  • .NET 1.1 : this event occurs only for the default application domain that is created by the CLR when an application is started.
  • Since .NET 2.0 (extract from MSDN [Ref-02] ):

If the UnhandledException event is handled in the default application domain, it is raised there for any unhandled exception in any thread, no matter what application domain the thread started in. If the thread started in an application domain that has an event handler for UnhandledException, the event is raised in that application domain. If that application domain is not the default application domain, and there is also an event handler in the default application domain, the event is raised in both application domains.

For example, suppose a thread starts in application domain “AD1″, calls a method in application domain “AD2″, and from there calls a method in application domain “AD3″, where it throws an exception. The first application domain in which the UnhandledException event can be raised is “AD1″. If that application domain is not the default application domain, the event can also be raised in the default application domain.

Please, refer to the MSDN documentation, [Ref-02] & [Ref-04], as there are other special cases that you might need to look at more in details depending in your code and usage of threads. E.g. what happens for the ‘finalizer thread’ or ‘worker thread’ from the .NET thread Pool (I am not putting this information here, otherwise this entry will start deriving on ‘multithread programming’ and I want it to stay on ‘Exception programming on the .NET platform’).

As I mentioned early, there some exceptions for which the CLR will not execute your catch{} or finally{} blocks, e.g. when a “StackOverflow” or “Access violation” exception is raised. In those cases, the CLR will assume that your process is in a very bad state and will terminate your process. With the .NET v4.0 the CLR put in place a flag (either in the config file or by using an attribute in code called ‘[HandleProcessCorruptedStateExceptions]‘) that you can use to indicate you want your handler to be called.

There is also an excellent article about “Handling Corrupted States Exceptions” (aka, StackOverflow and Access violation) written by Andrew Pardoe [Ref #03].

4 - The optional ‘finally’ block

You can add a ‘finally’ block at the end of your try/catch block(s).

‘finally‘ is an interesting construct as it allows your code inside it to be executed whatever happened in the try/catch block(s) (except for a few cases, e.g. if a “StackOverflow” exception is raised).

However, you should be careful about what you are doing inside the ‘finally’ block:
1) Check for ‘null’ references before using a object
2) You might need to have another try/catch block to catch any new exception, so you do not loose the original exception.

Conclusion

I hope that by now you have a better understanding of try/catch/finally blocks and better knoweldge on the various away to raise/re-raise, add information or ignore the exception.

My last advise will be ‘no exception should go completely silent, at least it should be logged for later analysis’.

You will find the in the sample C# project the various implementation of the cases exposes in this entry blog. Have fun with it.

References:

• [REF-01] MSDN, Exception Class.
• [REF-02] MSDN, AppDomain.UnhandledException Event.
• [REF-03] “Handling Corrupted State Exceptions”, Andrew Pardoe, MSDN Magazine, CLR Inside Out (2009-February).
• [REF-04] MSDN, “Exceptions in Managed Threads”.

It can help to isolate CPU- and memory-related performance issues. As I do a few performance analysis per month, this is a very good news – something new to try.

it looks like it can handle large memory dump files (a lot of Gb). Very good news because now with 64 application processes, dump files are getting bigger (greater than 4Gb of data and code to be analysed) and finding the right information is taking more time than before. Hopefully this tool will help us in that new world …

Here a few other links on the subject:

• Blog entry from Vance Morrison,  28th Dec 2011, “Publication of the PerfView performance analysis tool!”.
• Blog entry from DougSte,  4th Jan 2012, “New CLR and .NET Performance tool”.

Thanks to my colleague Julien Brunet to point out this tool to me this morning.

Windows Phone 7

In 2010, I attended the TechEd Europe in Berlin and Windows Phone was one of the keynotes at the time and the fact that it was launched in Europe in October 2010. Fourteen months later, where are we?

• 1.5% of global market [ref-01] (Gartner source).
• 14 months to get up to 50,000 applications available on Windows Phone 7 Marketplace (To reach that number, apple took 12 months and android 18 months) [Ref-02].

An interesting blog entry by Charlie Kindel, “Windows Phone is Superior; Why Hasn’t it Taken Off?” [Ref-03].

As a owner of Samsung Omnia 7 and user of Windows Phone 7 and now 7.5 (aka Mango) I can say that:

• I really loved the way “Windows Phone” was done as a “start from a green field and forget about windows mobile !!”.
• I am very happy with my Windows phone, specially with the various Hubs (People, Games, Messaging …) were your information is aggregated and linked for you, making those ‘information spaces’ more useful;
• The upgrade, from 7.0 to 7.5 went smoothly and was successful;
• I use Zune to sync my mobile with my computer (notes, pictures, movies, podcats…) and never had any serious issue.
• It took sometime to get the applications available, but they are coming.

I hope that the partnership between Microsoft and Nokia, and Microsoft and Skype will bring and put Windows Phone in to a better place and position regarding global market place and more end users will be able to have a good and different experience with their phones.

So, this will be my last one for this year. Happy new year 2012 !!

References

• [Ref-01] Gartner Press Release, 15th Nov 2011, “Gartner Says Sales of Mobile Devices Grew 5.6 Percent in Third Quarter of 2011; Smartphone Sales Increased 42 Percent”.
• [Ref-02] All About Windows Phone, by Rafe Blandford, 27th Dec 2011, “Windows Phone Marketplace passes 50,000 apps”.
• [Ref-03] Charlie Kindel’s blog entry, 26th Dec 2011, “Windows Phone is Superior; Why Hasn’t it Taken Off?”.

I am looking forward to coming to this event in the USA and also to visiting my friends.

Earlier this year, TechEd Europe 2011 (usually in November) was cancelled (or “postponed” to June 2012). So, it had to be in USA.

Since last March, I was searching the web for the PDC or TechEd conference in USA – 2012 is going to be a major year in term of releases from Microsoft (a lot of new products, enhancement on .NET platform and development tools and maybe a new OS – Windows 8). It was a relief when I managed to get a little more information about the Build conference back in May. However, there was not any agenda and even the dates were not settled. Finally, on 13th June I managed to book it. Apparently, MS started to sell tickets on 1st June and they sold out on 1st August (2 months – no surprise, when you cancel (or “postpone”) other events).

Summer is gone in Europe. In a few hours time, I will be on my way to this conference…

Like last year, at TechEd Europe in Berlin, I will post information/observations about the sessions. See you there !!

“The Max Pool Size attribute of the ConnectionString property sets the maximum number of connections for a connection pool. If a new connection is requested, but no connections are available and the limit for Max Pool Size has been reached, then the connection pooling service waits for the time defined by the Connection Timeout attribute. If the Connection Timeout time has been reached, and there are still no connections available in the pool, the connection pooling service raises an exception indicating that the connection pool request has timed-out.” [Ref-01, p3-6]

This post is about enabling the tools (traces and performance counters) that will help you to monitor and trace Oracle DB pooling activities in your applications. Also, I am providing some information about the way Oracle client connection pooling works from my observations. In the end, this helped me to track down the “leak” in my application.

We are using on the client side the Oracle Data Provider for .NET (aka ODP.NET) for Oracle DB 11g and our server is using Oracle DB 10g.

The “Connection pool performance counters” is a new feature of  the ODP.NET for Oracle DB 11g.

Enabling ODP.NET Traces

The first thing I tried was to enable Oracle ODP.NET traces. However, the way oracle ODP.NET was installed on the machine was by “copy deployment”, so the registry entries were not set.

Oracle documentation (see [Ref-01] for the doc) provides the required information, i.e.:

1. ODP.NET tracing features are controlled by registry values under the entry key “HKEY_LOCAL_MACHINE\Software\Oracle\ODP.NET\<version>“.
   1. <version> is the version number of your “Oracle.DataAccess.dll”.
   2. This DLL should found under “<ORACLE_HOME>\odp.net\bin\2.x”
      1. “2.x” for .NET 2.0 applications (and also 3.0 and 3.5)
      2. “1.x” for .NET 1.1 applications
   3. Mine is version “2.112.2.0″, so my entry key is “HKEY_LOCAL_MACHINE\SOFTWARE\ORACLE\ODP.NET\2.112.2.0″.
2. There are 3 keys that really matters for Tracing (all ‘sz’ entries, i.e. string values):
   1. “TraceLevel”
      • Traces is enabled depending on the value of key.
      • Here are the possible values:

      • Value	Description
        0	None
        1	Entry, exit, and SQL statement information
        2	Connection Pooling statistics
        4	Distributed transactions (enlistment and delistment)
        8	User-mode dump creation upon unmanaged exception
        16	HA Event Information
        32	Load Balancing Information
        64	Self Tuning Information
        127	All the above
        Default:	0

      • ODP.NET does bit-wise checking on the value, so you can enable multiple logs by adding their values.
3. “TraceFileName” (string value)
   • A valid path and filename for the log. E.g. “C:\temp\oracle.txt”
   • TraceFileName specifies the filename that is to be used for logging trace information. If TraceOption is set to 0, the name is used as is. However, if TraceOption is 1, the Thread ID is appended to the filename provided.
4. “TraceOption” (string value)
   • TraceOption specifies whether to log trace information in single or multiple files for each Thread ID. If a single trace file is specified, the filename specified in TraceFileName is used. If the multiple trace files option is requested, a Thread ID is appended to the filename provided to create a trace file for each thread.
• 0 = Single trace file
• 1 = Multiple trace files

For pooling info, I used “Traceslevel=2″. However, this was not enough and too verbose. So I turned to “Perfomance counters”.

32/64-bit – Specific details

Be careful regarding whether your application runs as a 32-bit or 64-bit image, as the registry entry key is not the same:

• In a 32-bit OS, all applications will run as a 32-bit image and the registry key in that case is “HKEY_LOCAL_MACHINE\Software\Oracle”.
• In a 64-bit OS, applications might run either as a 32-bit image or 64-bit image.
  • If it runs as 32-bit image, then the entry key in the registry is “HKEY_LOCAL_MACHINE\Software\WOW6432node\Oracle”.
  • If it runs as 64-bit image, then the entry key in the registry is “HKEY_LOCAL_MACHINE\Software\Oracle”.

Enabling ODP.NET Performance Counters

As for the “enabling Traces”, because Oracle was not installed in the machine by a deployment tool, I had to configure the performance manually.

Registering the Performance counters

In order to find what performance counters ODP.NET was instantiating, I used Reflector on “Oracle.DataAccess.dll” and found these counters:

Those counters are “multi-instance”, aka different applications running at the same time have each their set of counters. Furthermore, ODP.NET creates a set of counters per Application domain for .NET processes (See [Ref-03] for further details about “single-instance” vs. “multi-instance” of performance counters).

I did a little C# application to create those counters using the class “System.Diagnostics.PerformanceCounterCategory” to create (or delete) a caterogy of  performance counter (here, ODP.NET uses “” as its category of counters, so I used the same).

Here is a sample of code to create the category of performance counters:

// Create the collection for the counters

CounterCreationDataCollection counterDataCollection = new CounterCreationDataCollection();
 // Add counters
 CounterCreationData rateCount64 = new CounterCreationData();
 rateCount64.CounterType = PerformanceCounterType.RateOfCountsPerSecond64;
 rateCount64.CounterName = "HardDisconnectsPerSecond";
 rateCount64.CounterHelp = "Number of sessions being severed with the Oracle Database Server every second";
 counterDataCollection.Add(rateCount64);

...

// Create and Register the category.
 string categoryName = OracleCategoryConst;
 string categoryHelp = @"Oracle Data Provider for .NET counters";

PerformanceCounterCategory.Create(categoryName, categoryHelp, PerformanceCounterCategoryType.MultiInstance, counterDataCollection);

To remove it, you can use this piece of code:

PerformanceCounterCategory.Delete(categoryName);

Enabling PerfCounters for ODP.NET

Once the performance counters are created and registered in the performance system, you need to tell ODP.NET to start creating and updating the counters. To achieve that, you need to add another string key in the registry called “PerformanceCounters” under “HKEY_LOCAL_MACHINE\Software\Oracle\ODP.NET\<version>” (see section “Enabling ODP.NET Traces”).

The possible values are:

Launching PerfMon.exe

Launch “Perfmon.exe” from a command line window. You should be able to see the Oracle ODP.NET performance counters called “Oracle Data Provider for .NET” when trying to add them to the monitoring screen:

Be careful to not confuse it with “.NET Provider for Oracle” which is the category of performance counters registered and exposed by Microsoft .NET Provider.

In screenshot below I have added both categories of counters:

• The top one is from Microsoft (in fact from Visual Studio “Server Explorer” view that I used to connect to Oracle databases for development).
• The bottom one is from ODP.NET (from a test application).

The naming convention for the instance of perfomance counters for ODP.NET is as follow:

<AppDomain name>[<ProcessID>, <AppDomain Index>]

So, we can see that in my test application there are 2 AppDomains, one called “ad #2” and the other one “testoraclepoolapp2.exe” both from the process (ProcessID: 5736). Each application pool has it owns set of pools (2 for “ad #2” and 1 for “testoraclepoolapp2.exe“) and connections.

* Before launching your application using ODP.NET, you should have the performance counters created and registered as well as enabling them via the registry entry “” (see previous sections). If your application was already running, you must restart it (this is because ODP.NET will create its counters when the application (to be more precise the AppDomain) is launched and uses Oracle Db connection the first time).

32-bit processes on 64-bit OS machines

On 64-bit OS machines, when you launch “Perfmon.exe” it will execute the 64-bit version which monitors 64bit counter applications. If like me you need to launch “Perfmon.exe” 32-bit to monitor 32 bit counter applications, then you can do it using this command: “mmc /32 perfmon.msc“  (thanks to Tony Rogerson’s post [Ref-02]).

Connection Pool (by ODP.NET)

Now that I have got access to traces and performance counters I can monitor my application more closely and see what is going on in the world of Oracle Db connections within my application.

However, to be able to read the information about ODP.NET performance counters you need first to understand how “connection pooling” works.

From Wikipedia

In software engineering, a connection pool is a cache of database connections maintained so that the connections can be reused when future requests to the database are required. Connection pools are used to enhance the performance of executing commands on a database. Opening and maintaining a database connection for each user, especially requests made to a dynamic database-driven website application, is costly and wastes resources. In connection pooling, after a connection is created, it is placed in the pool and it is used over again so that a new connection does not have to be established. If all the connections are being used, a new connection is made and is added to the pool. Connection pooling also cuts down on the amount of time a user must wait to establish a connection to the database.

The key – Connection string

How does oracle identifies you need a connection from the pool or not?

It is from the connection string. The connection for Oracle ODP.NET has about 22 parameters that can be set. Usually, you will pass at least 3 of them: “Data Source“, “User ID” and “Password“. All the others will be set with their default values (see [Ref-01]). The parameter that switch ON or OFF the pooling service for the the connection is named “Pooling“. By default, it is set to ‘True‘. So , if do not specify a value of ‘False‘, then your connections are coming from a pool.

As long as you used the same connection string (order does not matter, as ODP.NET internally will parse your connection string to rebuild a ordered one), then the Pooling service of ODP.NET can retrieve a connection from the pool.

There 7 parameters in the connection string that control the behavior of the Pooling service: “Connection Lifetime“, “Connection Timeout“, “Decr Pool Size“, “HA Events“, “Incr Pool Size“, “Load Balancing“, “Max Pool Size“, “Min Pool Size“, “Pooling“, “Validate Connection“. I am going to explained some of them but not all (for “HA Events” and “Load Balancing” see [Ref-01, p3-5] for further details]).

Life in the Pool and outside it

When you ask ODP.NET to open a connection [<OracleConnection>.Open()] and “Pooling” is enabled, then the pooling service will search for a pool that matches your connection string:

• If none exists (i.e. first time this connection was used in your application), then it will create a pool and initialize it with the number of <OracleConnection> defined by “Min Pool Size” (default: 1). This number is the lower limit of the pool, i.e. there will always be at least “Min Pool Size” connections in the pool. Only when the pool gets discarded/released the number of connection will go below this value.
•  If the pool already exists, it will check whether there is a connection available.
  • If there is one available, the connection is taken out of the pool and pass it back to the application.
    • If “Validate Connection” is enabled, then a round-trip to the database will be done to ‘validate’ the connection.
  • Else (there is none available) it will check whether the pool has reached its upper limit of connections defined by “Max Pool Size” (default: 100).
    • If ( NbConnectionsInPool == “Max Pool Size“), then it will wait for a period of time defined by “Connection Timeout” to see whether a connection gets back into the pool, so it can be reused.
      • If (at least) one connection got back into the pool, then  the connection is taken out of the pool and pass it back to the application.
      • Otherwise, it will raise the (in)famous ”Connection request timed out” exception (hence this blog entry).
    • Else it will create new instance(s) of <OracleConnection> defined by “Incr Pool Size” (default: 5).  One of the created connection is taken out of the pool and passed back to the application.

Once your application has finished to use the <OracleConnection>, then it must call Close()/Dispose(). The pooling service checks whether the lifetime of connection has exceeded the value defined by “Connection Lifetime” (default: 0 – i.e. no checks).:

• If the lifetime of the connection exceeds this property value, the connection is closed – i.e. the physical network connection between your process and the machine hosting the database is closed.
• The lifetime of a connection is only checked and enforced by the polling service when a connection is put back into the pool.
• However, Connections that have exceeded their lifetimes are not closed  if doing so brings the number of connections in the pool below the “Min Pool Size“.

The connection pooling service closes connections when they are not used – connections are closed every 3 minutes. The pooling service is allowed to close connection instances every 3 minutes up to the limit defined by the parameter “Decr Pool Size” (default: 1) of the connection string.

Also you have to remember that ODP.NET is for .NET applications. In .NET, the excution boundary is defined at the Application Domain level (aka AppDomain). ODP.NET manages the pools per AppDomain. This means that an application using a connection string “A” used in AppDomain #1 and the same connection string used in AppDomain#2 (within the same process) will end up with one pool created in AppDomain#1 and another in AppDomain #2.

Putting the information in Picture

Here is a sample picture that show you the relation ship between ODP.NET performance counters and the various connection objects in a fictive .NET:

I hope this information can help you. As for me, we identified the issue in our application: leak overtime of our connection objects – i.e. not being disposed/closed properly.

[Ref-01] Oracle ODP.NET, web documentation

[Ref-02] “Missing PERFMON counters using 64 bit Windows -> MMC /32 PERFMON.MSC”, Tony Rogerson’s blog

[Ref-03] BCL team Blog, PerformanceCounters: single instance, multi-instance and WMI [David Gutierrez]

[Ref-04] Connecting to Oracle Database, web documentation