Ramblings about C#, .NET and Programming
As we’ve seen in the last post of the series, we can use the thread pool for scheduling several “types” of asynchronous operations and to amortize the penalty we pay when we need to create extra threads. In fact, I’d say that most operations should be performed by using a thread from the thread pool. […]
If you enjoy dark themes and love VS 2010, then you know you’re into trouble. The problem is that VS looses the dark background after being closed and you need to go to the options, fonts and colors and then apply the current settings (which still have the correct color) again. The good news is […]
Not sure on how I should classify this, but I’d say that getting this error in 2009 from a page served by a company like redgate is incredible! Today I needed to download reflector, so I went to redgate’s site and chose the download option. When you do that, you’ll be redirected to a page […]
Until now, we’ve been starting threads by creating instances of the System.Threading.Thread class in the samples. Thread creation isn’t cheap! If we’re creating a thread just to run a small task, then the thread’s creation might completely outweigh the advantage of running such a small task. In most cases, instead of creating new threads, we […]
There is no excerpt because this is a protected post.
There are times when a thread needs to wait for a specific condition to be true. Since this condition tends to involve shared state, then you know that you must use some sort of synchronization to ensure proper update of the data used by the condition. When we looked at kernel objects, we’ve seen that […]
Currently, I’m following Dan Garcia’s CS61C course (which is freely available online). On lesson 6, there’s an interesting puzzle (which, btw, I got it wrong – I’ll tell you why on the next post). The question is: which snippets prints always 5? 1,,) main() { int *a-ptr; *a-ptr = 5; printf(“%d”, *a-ptr); } 2) […]
This is not a technical post, so if you’re not interested, just skip it! Here’s the deal: a few days back, my good friend Filipe (aka, “super-loide” – long story, ok? but he knows why he’s called that:),,) started laughing when I said that I would reach the 10km mark on my treadmill. His words: […]
In the previous posts, we’ve seen how we can use monitors and any CLR object for getting a critical region. Whenever you need to get a critical region, using a CLR lock for ensuring proper access. However, there will be times when, for instance, you’ll have much more reads than writes. In these cases, using […]
Eric Lipert has another very interesting entry which explains why the team decided to use the last type parameter as the return value of a Func compatible delegate. I think that Eric should put his thoughts on a book so that I could read everything all over again while I’m on the bus. What I’m […]
In the previous post we’ve taken a quick peek at how we can use the CLR lock primitive. In this post we’re going to talk about some interesting things you might need to know when you work with these locks. According to Joe’s reference, the CLR locks use some spinning internally before waiting on a […]
When we looked at the kernel objects, we’ve seen that we could use a mutex to achieve critical regions. Whenever we need to build a critical section, we should use the CLR locks instead of relying directly on mutexes. In .NET, any object can be used as a lock when you need to build a […]
In the latest posts, we’ve taken a look at several kernel objects which we can use for data and control synchronization. Today we’re going to start looking at the synchronization primitives. These structures should always be used (whenever possible, of course) instead of the kernel objects we’ve met in previous posts. Why? Because they’re cheaper. […]
2011-01-12 13:12:03
Until now, we’ve seen how we can wait on several synchronization kernel objects until a specific condition is met. All the examples we’ve seen ended up using the simple WaitOne method.Today we’re going to take a look at the other “waiting” methods inherited from the base WaitHandle class: WaitAny and WaitAll. You’ll need these static […]
Ok, now that we’ve seen the basic kernel synchronization objects that you can use in .NET programming, I guess that it’s a good time to talk about how we can wake up a waiting thread without signaling the kernel object on which the thread is waiting for. In .NET, any blocked thread can be awakened […]
Currently, I’ve got three wonderful cats. Luna, a cat that I’ve found in the street when she was two months old, got really sick in the last months…in fact, the vet had told us to get ready because her liver problems wouldn’t let her live much longer. All her blood tests returned some pretty bad […]
[If you’ve just seem a one post sentence, then you’re probably seeing the first Luna’s post :,,) . She has just managed to publish a one line post while I was checking what was on the TV:)] In the previous post, we’ve taken a quick glance at how we can use the ManualResetEvent. At the […]
Just noticed this package that should be useful for all .NET developers that want to use the new Windows 7 features.
2011-01-12 13:11:31
After the introductory theory associated with events, it’s time to take a look at how we can use an AutoResetEvent for synchronizing access to a protected resource. The first thing we need to do to start using an AutoResetEvent is getting a reference to a valid instance of this type. We can get one by […]
I’ve already posted about this topic in the past. However, it looks like there are still some people which don’t take full use of this new (ok, not so new anymore!") cool feature. In my opinion, extension methods are great and they end up simplifying (a lot) the code we need to write. If you’ve […]
Windows OS offers two kinds of events: auto and manual-reset events. As you might expect by now, any event can be in a signaled or non-signaled state (after all, both of these events are kernel objects). Instead of using signaled and non-signaled terms, you’ll probably hear the words set and reset when talking about these […]
In the previous post we’ve seen several concepts associated with semaphore usage. In this post we’re going to see some code that shows how to use this synchronization kernel object. Creating a new semaphore is accomplished through one of the existing constructors: public Semaphore(int initialCount, int maximumCount); public Semaphore(int initialCount, int maximumCount, string name); public […]
It was only yesterday that I’ve finished reading this book which consists on several essays written by different software architects on the super interesting topic that is Software Architecture. Overall, it’s an interesting book with lots of good advice. Perhaps even more important is the fact that all of the essays are 2 pages long […]
Interesting post which presents several important info on how to get started on Server 2008 R2.
This post is all about theory…you’ve been warned :,,) Semaphores have different usage semantics than mutexes. A thread can perform two operations over a semaphore: you can run a put or a take. Internally, the semaphore maintains a count of the numbers of takes and puts through the use of a counter: whenever a thread […]
In the previous post, we’ve looked at some important features provided by the Mutex kernel object. Today we’re going to keep looking at mutexes and we’ll take a look at how we can create named mutexes and use them for synchronizing access to shared state. true that using kernel objects has costs: when you wait, […]
Ok, now that we understand the basics of waiting on a kernel object, it’s time to keep going and start looking at some code (hurray!). Today we’re going to take a look at the mutex kernel object. In .NET, a mutex kernel object is represented by an instance of type Mutex. As we’ve seen yesterday, […]
