 Alright, so with the lazy class you can cast exceptions that are thrown from the initialization. So when we use this basic version of lazy constructor, exception caching is not enabled. So for this demo code in this class we have a different constructor and as you can see here that when we initialize this object this constructor will first this log this message on the console and then throws this exception with this message. Now one thing to notice here is that we have log exit date and time when the exception is thrown. So when we run this application first it will create an object of the lazy class and then we access this value property but this method will never gonna call as in the constructor we throw this exception and then we will catch that exception over here and then we are doing the same thing again. Now let's run this code. So here the exception is thrown and then for the second call we get the same exception. So as you can see here that the first exception was created at 1.52 and 55 seconds and then we got the second exception at 1.53 and 9 seconds and one thing to note here is that our constructor is called twice and we got the two distinct exception message. Now you can cache this exception when we use an old constructor of lazy class and what this means is if the first time we access the value property the constructor throws an exception and this exception will be cached by this lazy class and any subsequent access to this value property will return the same cached exception and this also means that the constructor won't be called a second time. So let's see this in action. So now when I hit enter we'll get an exception message. So now here in the output you can see that we got our first exception as 157 and 51 second and on the second attempt we got the same exception message with same time and notice here that our constructor is called only one time and that's because we are using this overload of the lazy constructor and when we do this exception casing is automatically enabled for us.