At this point, you can run the application but nothing will happen as we are yet to glue the buttons to the code.

The program is not yet ready to run the way we want it to. However, let's check out the rationale behind the declaration of these variables.

We want to ask the kid questions, as shown in the previous screenshot.

The first line of the preceding code snippet, ObservableCollection<int> numbers, will be used to capture the response given by the kid.

The second line of the preceding code snippet, ObservableCollection<KeyValuePair<string, TimeSpan>>questions, which is a collection of KeyValuePair<string, TimeSpan>, for storing the questions asked and the response time (time taken to answer the question) of the kid to answer each question.

Following are the variables we just introduced:

We just created the skeleton to be able to run the program. All the placeholders are ready and we just need to fill them. Let's see how these are connected.

We want to monitor the responses given by the kid and we also want to store the questions and response time of the kid. The ObservableCollection<T> class implements the INotifyCollectionChanged interface. This interface has only one event:

eventNotifyCollectionChangedEventHandlerCollectionChanged;

This event gets triggered whenever the collection gets changed. When a new item gets added to the collection, or an existing item gets deleted, or a couple of existing items swap their locations in the collection, this event is triggered.

We want to monitor the kid's response. The kid's response will be stored in the collection numbers. So, whenever that collection gets changed, we need to know. Thus, the event handler numbers_CollectionChanged is attached to the CollectionChanged event of the collection numbers by the following code listing:

numbers.CollectionChanged += new System.Collections.Specialized.NotifyCollectionChangedEventHandler(numbers_CollectionChanged);

So, every time a new entry is added or deleted or existing items move, this event will be called.

We also want to store the questions asked to the kid and the response time taken by the kid to answer those questions. In order to do that, I have attached an event handler for the questions collection by declaring an event handler as follows:

questions.CollectionChanged += new System.Collections.Specialized.NotifyCollectionChangedEventHandler(questions_CollectionChanged);

So, whenever a new question is added, the questions_CollectionChanged event handler will be called.

The method NewGame( ) loads a new question and displays it on the screen. And as soon as the new question starts, we must start the timer.

The System.Collections.Specialized.NotifyCollectionChangedEventArgs namespace has an enum called Action and it's of type NotifyCollectionChangedAction, which has the values as shown in the following screenshot:

When a new item is added to the collection, the Action is internally set to Add. When an item is removed from the collection, the Action is set to Remove. When two existing items in the collection swap their location, Action is set to Move. When an existing item is replaced with another element, Replace is set as the Action. If all the elements in the collection are deleted, then Action is set to Reset.

When new items are added to the collection, these items are stored in the collection called NewItems, which is of type IList.

The first event handler, that is:

e.Action == System.Collections.Specialized.NotifyCollectionChangedAction.Add

will be true whenever a new element is being added to the numbers collection.

The (int)e.NewItems[0]() method returns the last integer added, as the NewItems collection returns IList<object> typecasting it to int is necessary.

If the last element added to this collection—which is actually entered by the kid—is not an even number, then it gets reported. If, however, the kid selects a number that is even, but not in the given range, then that is also a wrong answer and the application must be able to catch that. That's what happens in these two if-blocks in the preceding event handler.

When the kid finally answers the question correctly, we want to log the question asked and the response time taken by the kid to answer the question. That's what happens in the second event handler.

Note that the ObservableCollection<T> class is similar to any another collection, as it inherits from the Collection<T> class, so we can monitor any collection of any type.

Actually, there are two overloaded constructors to create an observable copy of an existing collection as follows:

List<int>firstHundredNaturalNumbers = Enumerable.Range(1, 100).ToList();
ObservableCollection<int>observableFirstHundredNaturalNumbers = new ObservableCollection<int>(firstHundredNaturalNumbers);

In this case, observableFirstHundredNaturalNumbers is an observable copy of the firstHundredNaturalNumbers collection. So if you make changes to the firstHundredNaturalNumbers collection, it will not be monitored unless you have specific home-grown event handlers dedicated for that job. However, firstHundredNaturalNumbers is ObservableCollection and so you can use the CollectionChanged event to monitor any change that happens to this copy.

There is another overloaded version to create an observable copy from an IEnumerable<T> interface. This helps to form a bridge between the non-generic collection and generic collection as IEnumerable<T> implements IEnumerable.

So, using this overloaded constructor, we can create an observable copy of a non-generic collection, such as Array or ArrayList.

We need some code to start a new game by loading a new question with a new range. Every time we need to do the same thing. So, putting that logic inside a method makes a lot of sense. The method NewGame() does just that.

When the Next Question button is clicked, the answer field must be cleared out so that the kid can enter a new answer there. Also, the timer has to be restarted so that we can capture the new response time.

When the kid clicks on the Submit button, the program evaluates the answer. Only if it is absolutely correctly answered, the timer is stopped. At this point, the question gets added to the log along with the time taken to answer the question.

The call:

questions.Add(newKeyValuePair<string, TimeSpan>(lblQuestion.Text, endingTime.Subtract(startingTime)));

will in turn call the question_CollectionChanged event handler, where the question and the time the kid took to answer the question correctly is logged in a text file.

Later, teachers/parents can review this log to see how the kid is progressing. A large response time for an easy question will be a bad indication.

The following screenshot shows a few entries that are logged in the questions log file:

The variables mentioned in the previous code are going to be used for the following purposes:

We want to monitor the changes being made in the list of Twitter user IDs in the first tab. So, whenever the control leaves this textbox, we want to see whether there is any change.

The first loop in the preceding code snippet checks whether any of the names are new in the current list. If yes, then it will try to add that name to the tweeterUserNames collection. The call to the Add() method of the collection by the statement tweeterUserNames.Add(tok) will raise the CollectionChanged event handler and the action is of type add.

However, we are also interested to know whether some names have been deleted from the list. In order to do that, we maintain a copy of the tweeterUserNames collection. This copy is needed because we can't modify a collection while iterating over it. So, if a name is found that exists in the tweeterUserNames collection but is not present in the current list in the first tab, then we know for sure that the user doesn't want to follow this name any further and that gets deleted from the tweeterUserNames collection as well.

The first time the form loads, we want to make sure that the CollectionChanged event handler is properly attached. So, whenever a name gets added to the collection tweeterUserNames or gets deleted from it, we can monitor it.

When a name gets added to the list of Twitter user IDs that we want to follow, the tweeterUserNames_CollectionsChanged() method gets called and e.Action will be of type Add.

e.NewStartingIndex returns the index of the newly added item in the list. If the tableLayoutPanel1 doesn't already exist, we will have to create that and add a newly created TweetViewer control in that. However, if it already exists, then we just have to add the newly created TweetViewer control and increase the current row count of the table layout panel by unity.

Once this TweetViewer control is added, a new BackgroundWorker object has to be created to get the details for this particular Twitter user ID that just got added to the list.

After that we have to run the newly created BackgroundWorker with the argument. Every time a new name gets added, it increases the count of names by unity. Thus, this last loop in the first if block in the preceding code, will run only once, every time.

When an existing username gets deleted from the list of names in the first tab, this event will be raised and e.Action will be of type Remove. e.OldStartingIndex returns the index of the item that gets deleted. So, once we know which one to delete by e.OldStartingIndex, the code just deletes that particular row of the tableLayoutPanel1.

If you want to get the details for all the Twitter user IDs sequentially, then it's going to take forever and the operation might leave the app screen frozen. To avoid this situation, we must share the workload evenly among many threads. BackgroundWorker classes are very handy in these type of situations.

The GetUserTimeline() method of the NTwitter API fetches the last 19 tweets, by default, of the user whose screen name is passed as an argument.

We don't want to stare at this twitView list all the time to check whether some of the users whom we are monitoring have tweeted recently or not. So, the Tweets property of the TwitView control is an ObservableCollection. So, whenever some new tweets come in, we want to be able to identify the person who tweeted recently.

That's why the NewTweetCount property has been introduced. The following code initializes the NewTweetCount property to the number of new tweets the person at index has created in the last monitoring frequency (which I have set to 20 minutes):

twitViews[index].NewTweetCount = newTweets.ToList().IndexOf(tweetsSofar.ElementAt(0));

tweetsSofar is the list of tweets acquired since the last time. And newTweets is the list of new tweets that we gathered just now.

If there is a new tweet available, we want to make sure that we identify the person who tweeted. So, we are changing the back color to some other color as follows:

if (twitViews[index].NewTweetCount > 0)
{
    twitViews[index].TweeterPicBackColor = Color.DarkSlateBlue;
}

So that we can easily identify the person who has tweeted recently, if we click on the next or previous button, we can go to the next or the previous tweet. As long as there is a new tweet available apart from those we have already seen in the past scan, the color will stay as DarkSlateBlue, as shown in the previous screenshot.

You can take a look at this behavior at http://sudipta.posterous.com/twitview-control-for-net-changing-backcolor-w.

Now that we have everything in place, let's query every now and then to check whether anything has changed. To do that, we need to add one timer to Form1 and add the following event handler:

private void timer1_Tick(object sender, EventArgs e)
{
  try
  {
    for (int i = twitterDemons.Count - 1; i >= 0; i--)
    {
      if (!twitterDemons[i].IsBusy)
      {
        twitterDemons[i].RunWorkerAsync(i.ToString() + "-" + names[i]);
      }
    }
  }
  catch
  {
    return;
  }
}

The application offers a functionality to move a particular tweet of any person to the top. This way we will ensure that a tweet stays in our visibility for a long time because the last tweet gets deleted when new ones show up.

Remember that we added a context menu strip to directly go to the first and last tweet and to mark a tweet as "Moved" so that it can stay there for a longer period. The application stores only the last 19 tweets of the individual. After downloading the app from the website, try checking this functionality.

Can you explain how it works? Moreover, can you tweak it to monitor tweets from different people containing any of the keywords from a given list of keywords. Think of it as an exercise to monitor some Twitter trend.

Using a similar structure, can you write a program to monitor weather at different locations? You can create a similar control to show a picture of the weather. You can download the startup code from the website for this book—search for WeatherDeck in the chapter's source.

You can use the Anima Online Weather API. It provides a nice wrapper against the Google weather API. You can download the API from http://awapi.codeplex.com/.

I have created a control similar to TweetViewer for weather monitoring called WeatherBlock. You can get it from the website for this book. With this control and the previously mentioned API, you can get and set weather conditions for any location as follows:

private void Form1_Load(object sender, EventArgs e)
{
  WeatherBlock wblock = new WeatherBlock();
  string place = "NYC";
  GoogleWeatherData nycWeather = GoogleWeatherAPI.GetWeather(Animaonline.Globals.LanguageCode.en_US,place);

  WebClient client = new WebClient();
  client.DownloadFile("http://www.google.com/" + nycWeather.CurrentConditions.Icon, "Temp.png");

  wblock.Location = place;
  wblock.ConditionTempCel = nycWeather.CurrentConditions.Temperature.Celsius.ToString() + "C";
  wblock.ConditionTempFer = nycWeather.CurrentConditions.Temperature.Fahrenheit.ToString()+ "F";
  wblock.WeatherImage = Image.FromFile("Temp.png");
  wblock.WeatherText.Text = nycWeather.CurrentConditions.Condition;
  wblock.WeatherHumidity = nycWeather.CurrentConditions.Humidity;
  wblock.WeatherWind = nycWeather.CurrentConditions.WindCondition;
  wblock.BackColor = Color.Black;
  this.Controls.Add(wblock);
}

It generated the following output. It shows the weather conditions in NYC (New York City, U.S.):