Adam Things

Ensure Threads Finish Before Method Continues Thread Join

Coding, CSharp, ,

So I wrote a post a few weeks back using a different method for the same thing.  I used a counter to count how many threads I started, and then decremented them as they finished.  Once the counter was equal to zero, I let the method continue and finish.  However, I realized since then that using Thread.Join() (Thread Join) was a lot easier to use and manage to handle the same task.

So the set up is that we are spinning off a handful of threads, but we don’t want the method, such as Main() to continue until all threads are finished. So we start off by needing a list to add all the threads to once we start them.

protected List _threadList = new List();

Then in our methods where we create and start the threads we will add them to this list we just created.

//Create new thread
Thread logThread = new Thread(LogServiceCall);

//Start new thread
logThread.Start(logParams);

//Add thread to thread list
_threadList.Add(checkThread);

So after we have spun off all our threads; the next call in the method basically calls Thread.Join() on all threads within that list.  What Thread.Join() does is block the calling thread from terminating before all the other threads do.  So by doing this we can ensure that the main method won’t be able to finish until all the threads have since we cause the calling thread to hang.
This is the little snippet to call Thread.Join() on the thread list.

foreach (Thread thread in _threadList){
     thread.Join();
}

Once this completes, all the threads we started have to finish before the main calling thread can continue and terminate allowing the method to continue.  I find this to be a more compact and less heavy way to complete this task instead of using a counter.


Check Database Connectivity Using Stored Procedure

Coding, CSharp, , ,

This may not be the best way to go about checking database connectivity from within your app, but it is a method that works for me.  If you have a different way, please comment.  The point of this is to make a dummy call out to the database and if the call succeeds, then we have access to the database.  If the call fails or fails to connect, we then know something is wrong and it can trigger an alert.

It’s relatively simple and rather I am thinking about renaming the post to calling a stored procedure through C# but never the less let’s look.

protected void CheckDBHealthStatus()
{
    try
    {
        using (SqlConnection conn = new SqlConnection(ConnectionString)) //Create new SqlConnection with ConnectionString to DB
        {
            using (SqlCommand sqlCommand = new SqlCommand())//Create a new SqlCommand to call stored proc
            {
                sqlCommand.Connection = conn; //Add the Connection
                sqlCommand.CommandTimeout = 60; //Timeout After 1 mins
                sqlCommand.CommandText = "dummyProc_HealthCheck"; //Name Of Stored Procedure
                sqlCommand.CommandType = CommandType.StoredProcedure; //Type obviously Stored Procedure

                //add the parameters
                SqlParameter newParam = new SqlParameter("@ID", SqlDbType.VarChar, 10) { SqlValue = "Adam" }; //Create New Parameter
                sqlCommand.Parameters.Add(newParam); //Add to the SqlCommand we created above.

                conn.Open();//Open Our Connection to the DB
                sqlCommand.ExecuteNonQuery();//Execute the query.
            }
        }
    }
    catch (Exception ex)
    {
        string errorMessage = "Critical - Error when connecting to Database." + ex.Message;
    }
}

All the comments are inline.  Obviously there is not really a need to have a parameter but I think it could come in useful for a person looking for how to add one.  Overall, fairly simple and a quick and dirty way of reaching out to the database, making some dummy call, and reporting if it succeeded or if it failed.  You can then take this farther and capture the error message and exception and have a service report to you when this goes wrong.


Ensure Threads Have Finished Before Method Continues

.Net, Coding, CSharp, ,

**Update – Please see here for a better way of doing this.  It’s a better solution that came around after writing this post.

This post is part extension off of my Multithreading with Parameters.  I came into a spot where I am building a monitoring page that on page load, spins off about 20-30, and then displays the outcome of those threads.  However, if you spin off a bunch of threads and don’t do anything else, the page load method finishes and you’re left with little to no content on the page because it finished before your threads.  So I implemented a thread counter.  It was a simple solution and makes the method wait until all threads have completed before it can move on.
We need a few things; a counter object, a lock object, an increment method, and a decrement method.  These are pretty straight forward and are as follows.


protected static int threadCounter = 0;
protected static object lockObject = new object();

protected void IncrememntCounter()
{
    lock (lockObject)
    {
        threadCounter++; //Increment Thread Count By 1
    }
}

protected void DecrementCounter()
{
    lock (lockObject)
    {
        threadCounter--; //Decrement Thread Count By 1
    }
}

Now let’s look how this gets applied.  [more]In our method where we spin off the threads, we simply call the increment method.


//Create new thread
Thread logThread = new Thread(LogServiceCall); 
//Start new threadlog
Thread.Start(logParams);
//Increment our thread 
counterIncrementCounter();

As I am sure you have figured out, the method that gets spun off in the thread, we need to call the decrement counter upon completion of that method.


private void LogServiceCall(object parameterObject)
{
    LogginParams pLoggingParams = (LogginParams)parameterObject;
    lock (lockObject)
    {
        LogServiceCall(pLoggingParams.Log, pLoggingParams.Info, pLoggingParams.Number);
    }

    DecrementCounter();
}

Now we have our counter set up.  When we spin off a new thread we are adding one to the counter, and then when our thread finishes we are decrementing the counter by one. Now the last piece of the puzzle is in the method that you are wanting to wait for the threads to complete, we simply check our thread counter for number remaining.


while (threadCounter > 0)
{
    Thread.Sleep(500); //Make it pause for half second so that we don’t spin the cpu out of control.
}

This was a nice way to ensure threads have finished and that the method would not continue until everything was done.  My threads were small and often times finish quickly.  I added asynchronous threads and chopped the page loading speed over half.  If you have another way of going about doing this please share, I would love to hear to if there are better and different ways of doing this.


Rounding using Math Ceiling to 5 and 0 in CSharp

.Net, Coding, CSharp, ,

Rounding has always been a bit of a struggle.  Recently I had a requirement to do some rounding for a rating type of system (i.e. x / 5 stars).  As it has been long know, the Math.Round method handles .5 a bit differently than we would like.  So let’s take a look at the specific requirements and dig into this example a bit deeper.

If greater than .0 and less than or equal to .5, display half a star

If greater than .5 and less than or equal to .0 display whole star

This made for a little bit of a trickier approach since we are want a value such as 1.1 to round to 1.5 and then wanting 1.7 to round to 2.0.  When you start breaking it apart it’s not too bad.  We are going to take advantage of the Math.Ceiling method.  Math.Ceiling returns the smallest integral value that is greater than or equal to the specified double-precision floating-point number.  In a real basic sense it’s going to round the number up.  So in our context of ratings, the following ratings of say 1.2, 1.7, and 1.9 all will round up to 2.  How does this help us?  Let’s take a look at the line doing our rounding.

double roundedRating = (Math.Ceiling(2 * currentRating)) / 2;

I think the easiest way to understand is to plug in some numbers. Lets run an example.  So per our requirements, we would expect 1.1 to give us a final rounded rating of 1.5.

double roundedRating = (Math.Ceiling(2 * 1.1)) / 2;
double roundedRating = (Math.Ceiling(2.2)) / 2;
double roundedRating = (3) / 2;
double roundedRating = 1.5;

Following through the logic above, by doubling our initial rating, we are allowing ourselves to round to a whole number, and then divide that in half to achieve our .5 rating system that is required.  Overall, not entirely complicated but turned out to be a helpful little method to round to either .5 or .0 depending on the initial rating.


Postfix increment and decrement operators in CSharp

Coding, CSharp, , ,

Postfix increment and decrement operators are great for doing quick addition and subtraction. Using your C# knowledge and not your compiler, what will the output be?

int i = 1;
string result = String.Format("{0},{1},{2}", i--, i++, i++);
Console.WriteLine(result);

Have your guess?

The output reads as follows. 1,0,1 and the last value of i is actually 2. Why is this?  We are using post operators, meaning, the compiler is going to read the value of i, then it will increment or decrement depending.  In the above example, the last i++ happens after the value of {2} is read, so it will not be seen as 2 in the console window and is not used in any execution path.  So let’s take a look at the opposite of above.

int i = 1;
string result = String.Format("{0},{1},{2}", --i, ++i, ++i);
Console.WriteLine(result);

Have your answer for this version?

The output ends up being 0,1,2 with a final value of i =2.  The reasoning is opposite of the above.  These operators will apply the increment or decrement prior to reading i.


Friends

Alpha 46 Studios - Custom Web Design
Developer Memes : Hilarious!
Mr. D's Carpet Cleaning In Arizona
Alienware Fx Themes

StackOverflow Profile

profile for Adam at Stack Overflow, Q&A for professional and enthusiast programmers