dasBlog 2.3 was released last Monday March 16, 2009. It's a minor release that fixes a few bugs in the code base. Congrats dasBlog team for this release.

Below is the list of changes for this release:

New version of dotNetOpenId
Small bug fixes
Several small JavaScript errors
Captcha now works more reliably
Better Time handling in timeline
New 32/64 bit version of the Basic DatePicker
Centralized handling of binary files to a BinaryDataService

On a side note, I've been thinking for the past few months now about updating my site theme. I think I've been using this theme for the past 2 years and it's starting to look bland. I think this new release of dasBlog will give me the chance to upgrade my site theme. I don't know how  it's gonna look yet but i'm sure its going to be better than what it is today (Hopefully!). ;)

I saw this on the ASP.NET MVC download page and it seems like it was released yesterday.

I haven't seen any official announcement anywhere yet but I expect to hear something coming out of the MIX09 event regarding ASP.NET MVC 1.0 RTM. I was able to confirm with Ben Scheirman via twitter that it's RTMed. I don't know where he got the news but judging by the screenshot above it looks like its true.

In case you are interested in learning about ASP.NET MVC, Microsoft has released an application called NerdDinner.com which is a event management website that enables users to register for "geek dinners". I believe that application was built using ASP.NET MVC 1.0 RC2 but it should be compatible with the RTM version (I haven't compiled it with the latest version yet). It's a really nice sample application that shows you how to build an application using ASP.NET MVC. Whats neat about NerdDinner.com is that it part of the book that Scott, Scott, Phil  & Rob are writing and they have been kind enough to let as peek at their upcoming book by giving a free chapter that details how they built the NerdDinner.com website step-by-step using ASP.NET MVC.

Wow, I'm really stoked! This is going to be a fun day! Thanks MS!

Tooltips are great additions to any interface and in this article I'm going to show you how to attach a tooltip to control in Silverlight 2.

To start, let's assume that we have a button that we want to add a tooltip to:

[XAML]

          
            <UserControl
x:Class="KeithRull.Silverlight.CreatingTooltips.Page" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" Width="400" Height="300">
<Grid x:Name="LayoutRoot" Background="#FF1E238E">
<Button Content="Hover
over me!" Height="20" Width="100" Margin="30
40" VerticalAlignment="Top" HorizontalAlignment="Left">
</Button> </Grid> </UserControl>
          
        

[Rendered UI]

In order or us to attach a tooltip to our button we need to create a reference to the TooltipService.Tooltip inside the our button's XAML declaration. We also need to setup the Tooltip.Content to tell the compiler what to show when the user hover's to our button.

[XAML]

          
            <UserControl
x:Class="KeithRull.Silverlight.CreatingTooltips.Page" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" Width="400" Height="300">
<Grid x:Name="LayoutRoot" Background="#FF1E238E">
<Button Content="Hover
over me!" Height="20" Width="100" Margin="30
40" VerticalAlignment="Top" HorizontalAlignment="Left">
<ToolTipService.ToolTip> <ToolTip> <ToolTip.Content> <TextBlock
TextWrapping="Wrap">
Hooray! I'm alive!. </TextBlock> </ToolTip.Content> </ToolTip> </ToolTipService.ToolTip>
</Button> </Grid> </UserControl>
          
        

[Rendered UI (at runtime)]

The message "Hooray! I'm alive!" appeared when the user hovers over our button. We can also cutomize how our tooltip appears by adding more XAML elements in the Tooltip.Content property.

[XAML]

          
            <UserControl
x:Class="KeithRull.Silverlight.CreatingTooltips.Page" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" Width="400" Height="300">
<Grid x:Name="LayoutRoot" Background="#FF1E238E">
<Button Content="Hover
over me!" Height="20" Width="100" Margin="30
40" VerticalAlignment="Top" HorizontalAlignment="Left">
<ToolTipService.ToolTip> <ToolTip Background="#FFFFFF" Width="150">
<ToolTip.Content> <StackPanel> <Image Source="images/silverlight.png" />
<TextBlock HorizontalAlignment="Right">
It rocks like a champ! </TextBlock> </StackPanel> </ToolTip.Content>
</ToolTip> </ToolTipService.ToolTip> </Button> </Grid> </UserControl>
          
        

[Rendered UI (at runtime)]

Another customization that you might want to do is specifying the HorizontalOffset and the VerticalOffset. This allows you to specify where the tooltip will appear in reference to your target control.

I just saw this twitter...

Sweeeeet!

Time to start polishing my ASP.NET MVC skills. I've played with ASP.NET MVC before but never had the chance to use it other than building small samples. I might be rusty but I know I'll have a great companion book in learning ASP.NET MVC 1.0 once Rob, Scott, Scott and Phil's upcoming book comes out.

A user a devpinoy.org posted a question on the forum section asking if there's a way to restrict files from being saved in a directory. I know you can do this via the FileSystemWatcher class so I quickly whipped my Visual Studio 2008 IDE and started building a prototype application to demonstrate the solution.

The first thing that you need to do is to set-up some key details on what we want to watch/monitor

          
            private
            const
            string ALLOWED_FILE_EXTENSION =".doc"; privateconststring DEFAULT_WATCH_FOLDER =@"E:\Test
Folder\";
        

Next, the FileSystemWatcher specify what directory you want to monitor.

          FileSystemWatcher
watcher =new FileSystemWatcher(DEFAULT_WATCH_FOLDER);
        

After that you need to setup the notification filters on what type of filesystem changes you want to watch;

          watcher.NotifyFilter = NotifyFilters.LastAccess | NotifyFilters.LastWrite | NotifyFilters.FileName | NotifyFilters.DirectoryName | NotifyFilters.CreationTime;
        

And finally, we need to set-up the FileSystem events you want our FileSystem. In this case, we only want to monitor Created and Renamed events.

          watcher.Created
+= new FileSystemEventHandler(watcher_Created);
watcher.Renamed += new RenamedEventHandler(watcher_Renamed);
        

Now, let's start coding our event handlers.

For our event handler, I decided to use one method that would handle both the Created and Rename event. Ideally you want to seperate this to into two different methods because you might want to handle the tow events differently but since all I want to do is to block files\folders that doesn't match my criteria i decided to handle them both using a single method called FileSystemHandler.

          
            void watcher_Renamed(object sender,
RenamedEventArgs e) { FileSystemHandler(e.Name, e.FullPath); } void watcher_Created(object sender,
FileSystemEventArgs e) { FileSystemHandler(e.Name, e.FullPath); }
        

Below is the implementation detail for our FileSystemHandler method.

          
            void FileSystemHandler(string name, string fullpath)
{ try { //read
the contents of our directory DirectoryInfo di =new DirectoryInfo(DEFAULT_WATCH_FOLDER); //get
the filesysteminfo[] objects FileSystemInfo[] fileSystemInfoArray = di.GetFileSystemInfos(); //there's
always going to be one object matching this criteria all the time FileSystemInfo
found = fileSystemInfoArray.Single(f
=> f.FullName.Equals(fullpath)); //if
it finds somethingif (found
!=null)
{ //cast
the found object to directoryinfo DirectoryInfo d = found as DirectoryInfo; //if
it's null it means it's a FileInfo objectif (d
== null)
{ //cast
found to a fileinfo object FileInfo f = found as FileInfo; //delete
the file if the extension doesn't match our desired/allowed extensionif (!f.Extension.Equals(ALLOWED_FILE_EXTENSION))
{ f.Delete(); } } else { //directories
are not allowed on this folder too! d.Delete(true);
} } } catch { //let
it sleep for 30 seconds Thread.Sleep(30000); //it
failed so we need to try again recussively/*
note: it's a good idea to set a retry limit here because if we don't then the app
will retry to infinity but i'll leave that up to you. */ FileSystemHandler(name,
fullpath); } }
        

What the function above is doing is that it checks to see if the filesystem object that was created on the directory is either a file or a directory. If it is a directory, automatically delete it since we dont want any directory to be saved on our folder. If it is a file we need to check if it's extension matches the allowed file extension. If it matches the allowed extension we let it thru. If it doesn't we call the the Delete method on the FileInfo object to delete the file.

All we need to do now is to tell the watcher to start monitor our folder

          watcher.EnableRaisingEvents =true;
        

Setting EnableRaisingEvents to true triggers our watcher to start monitoring the folder. Setting it to false will stop the watcher.

And we are done! Now we have an application that blocks saving or renaming of files in a folder that doesn't match the allowed file extension.

Below is the full listing of the code for the demo project I built for this article:

          
            using System; using System.Linq; using System.Windows.Forms; using System.IO; using System.Threading; namespace KeithRull.FolderSpy
{ public partial class MainForm
: Form { privatebool IsCurrentlyWatching =false; privateconststring ALLOWED_FILE_EXTENSION =".doc"; privateconststring DEFAULT_WATCH_FOLDER =@"E:\Test
Folder\"; FileSystemWatcher watcher; public MainForm()
{ InitializeComponent(); } privatevoid MainForm_Load(object sender,
EventArgs e) { SetUpWatcher(); } privatevoid watchButton_Click(object sender,
EventArgs e) { if (!IsCurrentlyWatching)
{ watchButton.Text ="Stop
watching"; IsCurrentlyWatching =true; //start
the watcher watcher.EnableRaisingEvents =true;
} else {
watchButton.Text ="Start
watching"; IsCurrentlyWatching =false; //stop
the watcher watcher.EnableRaisingEvents =false;
} } void watcher_Renamed(object sender,
RenamedEventArgs e) { FileSystemHandler(e.Name, e.FullPath); } void watcher_Created(object sender,
FileSystemEventArgs e) { FileSystemHandler(e.Name, e.FullPath); } void FileSystemHandler(string name, string fullpath)
{ try { //read
the contents of our directory DirectoryInfo di =new DirectoryInfo(DEFAULT_WATCH_FOLDER); //get
the filesysteminfo[] objects FileSystemInfo[] fileSystemInfoArray = di.GetFileSystemInfos(); //there's
always going to be one object matching this criteria all the time FileSystemInfo
found = fileSystemInfoArray.Single(f
=> f.FullName.Equals(fullpath)); //if
it finds somethingif (found
!=null)
{ //cast
the found object to directoryinfo DirectoryInfo d = found as DirectoryInfo; //if
it's null it means it's a FileInfo objectif (d
== null)
{ //cast
found to a fileinfo object FileInfo f = found as FileInfo; //delete
the file if the extension doesn't match our desired/allowed extensionif (!f.Extension.Equals(ALLOWED_FILE_EXTENSION))
{ f.Delete(); } } else { //directories
are not allowed on this folder too! d.Delete(true);
} } } catch { //let
it sleep for 30 seconds Thread.Sleep(30000); //it
failed so we need to try again recussively/*
note: it's a good idea to set a retry limit here because if we don't then the app
will retry to infinity but i'll leave that up to you. */ FileSystemHandler(name,
fullpath); } } void SetUpWatcher()
{ watcher =new FileSystemWatcher(DEFAULT_WATCH_FOLDER);
watcher.NotifyFilter = NotifyFilters.LastAccess | NotifyFilters.LastWrite | NotifyFilters.FileName | NotifyFilters.DirectoryName | NotifyFilters.CreationTime;
watcher.Created += new FileSystemEventHandler(watcher_Created);
watcher.Renamed += new RenamedEventHandler(watcher_Renamed);
} } }
        

As always, you can download the code for the complete project here: KeithRull.FolderSpy.zip (40.38 KB)