Skip to main content

Posts

How throw works in .Net

As we all know, Exception handling plays a very important role in any developer’s life. When talking about exception handling, throw is the first thing, which comes into our mind. Today, we will see, how actually throw works. The given code catches the exception and just throws it again, without passing any explicit Exception object.  Now, let’s take another version of this above code: This given code will create the object of Employee and will catch the exception and from catch block it will throw the catched exception via ex (our Exception class object). Now question is how these two code snippets are different. For more analysis, let’s open ILDasm and drop your .EXE into it. For the first snippet, we will see something like below: From this given image, we can see ex (Exception class object) has been defined as local variable using .local, but in the catch block, compiler changes the throw statement int

Finalize in .Net

We implement the Finalize method to release the unmanaged resources. First let’s see, what is managed and unmanaged resources. Managed ones are those, which we write in .Net languages. But when we write code in any non .Net language like VB 6 or any windows API, we call it as unmanaged. And there are very high chances that we use any win API or any COM component in our application. So, as managed resources are not managed by CLR, we need to handle them at our own. So, once we are done with unmanaged resources, we need to clean them. The cleanup and releasing of unmanaged is done in Finalize(). If your class is not using any unmanaged resources, then you can forget about Finalize(). But problem is, we can’t directly call Finalize(), we do not have control of it. Then who is going to call this. Basically GC calls this. And one more thing to remember is, there is no Finalize keyword that we will write and implement it. We can define Finalize by defining the Destructor. Destructor is us

Memory Leak Analysis for .Net application

Memory leaks in .Net applications are always proven to be the nightmare for developers. Many times we get “OutOfMemoryException”, which is nothing but due to memory leak only. There are many reasons, which lead to memory leak situation. For example, sometimes we forget to release unmanaged resources, dispose heavy objects (i.e., drawing objects), even holding reference of managed objects, longer than necessary can also lead to memory leaks. So, if the application is small, one can analyze the code and figure it out, which object is causing memory leak. But when it comes to a large application, it is not at all possible to figure out manually. In that case, we need some tool, which can help us to figure out the area or object, which is causing memory leak. So, today I surf internet and came up with a tool called .Net Memory Profiler, which can do analysis for us and give us the statistics of all the instances. Ok, instead of getting more into theory, let’s jump quickly to the

Computer performance & Clock speed

Many people use clock speed as a measure of a computer’s total computing power, but that term can be very misleading for a couple of reasons. The computer keeps all its devices synchronized by using its clock. This isn’t a regular clock—it’s a “clock in a chip,” which keeps highly accurate time and ticks much more rapidly than a wall clock. The faster the computer’s clock ticks, the more quickly the device can move on to a new task. The central processing unit  needs a certain number of clock ticks to  execute each of its instructions. Therefore, the faster the clock ticks (that is, the “clock speed”), the more instructions the CPU can execute per second.  However, that’s not the end of the story. Different processors use different instruction sets, each of which can require a different number of ticks. That means different kinds of processors may execute different numbers of instructions per second, even if they have the same clock speed. You can use clock rate to compare two of th

Laptops vs Notebooks vs Netbooks vs Tablets

A laptop is a computer that is intended to run anywhere as it is portable. Laptops have integrated screens and keyboards and run on batteries. Heavy use to some hardware such as GPU, DVD drives can quickly drain the batteries. Laptops have a touchpad, pointing stick, trackball, or other pointing device. Nowadays, we can add external devices like mouse, keyboard etc. Notebooks are stripped-down laptops. They are thin and have relatively small screens and are ultra-light. They rarely have CD-ROM or DVD and also have very limited graphics capabilities. As notebooks doesn’t have external media (DVD, etc), they typically have integrated network connection hardware so one can load software on to them. Network hardware can be used to access the internet. Netbooks are even more stripped down than notebooks. They typically have less powerful processors and are primarily used for networked applications as web browsers, where most of the processing happens on a remote server. A tablet is simi

WPF: Significance of x:Key attribute

Each object declared as resource must set x : Key property. This property will be used by another elements to access the resource. But for Style objects, there is an exception. Style objects that set the TargetType property do not need to set x : Key explicitly because it is set implicitly behind the scenes. Scenario1: When x:Key is defined < Style x : Key ="myStyle" TargetType ="Button">       < Setter Property ="Background" Value ="Yellow"/> </ Style > In above example, x : Key property is used, so, style will be visible on Button, only when Style property is used explicitly on element, as shown in below snippet: < Button Style ="{ StaticResource myStyle }" Width ="60" Height ="30" /> Scenario2: When x:Key is not defined < Style TargetType ="Button">     < Setter Property ="Background" Value ="Yellow"/> </ Style > In above exam

WPF: StaticResource vs DynamicResource

Logical resources allow you to define objects in XAML, which are not part of visual tree but can be used in your user interface. One of the examples of logical resource is Brush, which is used to provide a color scheme. Generally those objects are defined as resource, which are used by multiple elements of the applications.    < Window.Resources >         < RadialGradientBrush x : Key ="myGradientBrush">             < GradientStop Color ="Green" Offset ="0"/>             < GradientStop Color ="Blue" Offset ="2"/>          </ RadialGradientBrush >            </ Window.Resources > Now, above declared resource could be used as either static or dynamic resource. One point to remember is that, when using static resources, it should be first defined in XAML code, before it can be referred. Static and Dynamic resources can be used as: < Grid Background ="{ StaticResource myGradientBrush }&