Wim De Cleen

Using IEnumerable to read a file

I'm a very big fan of readable code, that is why I use a lot of foreach statements, and I would like to iterate through all the buffers of a specific file and then do something on them. So why not use the IEnumerable interface for this. The following simple example is just that.

The first thing we need to do is make a method that returns an IEnumerable<byte[]>. This way we can use an foreach statement on the method. Then we need to open our file, very convenient with a using statement so we can be sure that whatever happens the filestream will be closed and we don't hold resources to long.

class Program {
    public static IEnumerable<byte[]> GetBuffers(string filename) {
        int numBytes = 0;
        using (FileStream fs = new FileStream(filename, FileMode.Open)) {
            do {
                byte[] buffer = new byte[1024 * 8];
                numBytes = fs.Read(buffer, 0, 1024 * 8);
                if (numBytes > 0) {
                    yield return buffer;
                }
            } while (numBytes > 0);
        }
    }
    
    static void Main(string[] args) {
        foreach (byte[] buffer in Program.GetBuffers
               (@"testfile.dat")) {
            Console.WriteLine(buffer.Length);
        }
        Console.ReadLine();
    }
}

At this moment it is really easy to access the buffers in the stream and take action on the buffers. Off course there should be some exceptionhandling, but that is easy enough.

TechEd Developers : Coding for Fun and more

After seven days of Barcelona, I'm all loaded up for the next step in development. I was updated on the technologies of tomorrow in a 5 days during training on a few km of the sea and in temperature of about 20 degrees while the sun was shining.

Of course there are a lot of post on the web about the top sessions in Barcelona, but there were two others that need some special attention because development doesn't always need to be about keeping your boss happy, but also keep yourself happy with "Coding for Fun". I was pleasantly surprised to see these sessions on TechEd Developers.

First of all there was the session about Microsoft Robotics Studio given by Martin Calsyn that was a really good introduction about the studio in general. I was pleased to see the the room was full. I was amazed about how many people like Robotics, it seems we need to see our code move things.

Then there was the session about XNA Game Studio given by Rob Miles, (this guy really rocks) he talked about writing games not only for fun but also professional. He gave a good impression on XNA and how easy it is to write games. I loved his cheese game and so did the all the others off the fully loaded room.

Conclusion, TechEd is about professional coding, but also about FUN. So check out the links and get started.

Robotics Studio : November CTP released

The new CTP of Robotics studio has been released since 7 november. Here are the links.

Concurrency And Coordination Runtime : A Really Simple Sample

Long ago I wrote an Example on threading with the WinApi using Delphi, now we have AsyncCallBacks and managed threading. But since a few months we also have the CCR and take my word for it, this baby rocks. I will supply you guys with another run of the "Really Simple Sample" series and now it will be on the CCR. Here goes the first sample.

First off all I tried to build a winforms application running in the CCR way, I used the Ccr.Adaptors.WinForms namespace to accomplish this in a simple way. Just create a new WinForms application and change the Program class like follows.

static class Program {
        
        //Expose the dispatcher queue for use in all your forms
        public static DispatcherQueue DQueue {
            get {
                return _DispatcherQueue;
            }
        }
        
        //Expose the WinFormsService Port for use in all your forms
        public static WinFormsServicePort WFServicePort {
            get {
                return _WFServicePort;
            }
        }

        private static DispatcherQueue _DispatcherQueue;
        private static WinFormsServicePort _WFServicePort;
        
        [STAThread]
        static void Main() {
            System.Threading.ManualResetEvent MainThreadEvent = new System.Threading.ManualResetEvent(false);
            // Create the Dispatcher that will execute our delegates that we add to the 
            // DispatcherQueue
            using (Dispatcher dispatcher = new Dispatcher(0, "BlogExample Dispatcher")) {
                _DispatcherQueue = new DispatcherQueue("BlogExample DispatcherQueue", dispatcher);

                Application.EnableVisualStyles();
                Application.SetCompatibleTextRenderingDefault(false);
                
                // Bind the DispatcherQueue to the WinformsAdaptor and
                // create the WinFormServicePort.
                _WFServicePort = WinFormsAdaptor.Create(_DispatcherQueue);
                
                // Use the WinFormsServicePort to create a MainForm.
                // We use a delegate to create the form on the right thread and 
                // bind a delegate to the HandleDestroy event of the form to let the 
                // application stop when the MainForm closes.
                _WFServicePort.Post(new RunForm(
                    delegate { Form1 form = new Form1();
                    form.HandleDestroyed += delegate(object sender, EventArgs e) { MainThreadEvent.Set(); };
                    return form;
                    }
                   ));
                
                // Wait for the form to be closed, the WinFormsAdaptor is taking 
                // care of the Application.Run in its own thread, we just need
                // to make sure the application keeps on running by blocking the
                // current thread.
                MainThreadEvent.WaitOne();
                
                // We need to inform the WinFormsAdaptor that it is oke to quit.
                _WFServicePort.Post(new Shutdown());
            }
        } 
    }

Now that we have a running form, let's build a sample that queries a webservice several times with different parameters and show the result in a listbox, off course async. Add a listbox and a button to the MainForm and write the following code.

public partial class Form1 : Form {        
        public Form1() {
            InitializeComponent();
        }

        //The port that receives the responses of the webservices.
        private Port _ResponsePort;
        //The port that receives any exceptions of the requests to the webservices.
        private Port _FailurePort;


        // A simple method to call a webservice async and fill our ServiceResponse instance with
        // the city.
        private void CallTemperatureServiceAsync(localhost.TemperatureService service, string city) {
            ServiceResponse response = new ServiceResponse();
            response.city = city;
            service.GetTemperatureAsync(city, response);   
        }
        
        private void button1_Click(object sender, EventArgs e) {
            localhost.TemperatureService temperatureService = new localhost.TemperatureService();

            //Create the ports
            _ResponsePort = new Port();
            _FailurePort = new Port();

            // Define the GetTemperatureCompleted event. We use this delegate to post to the correct port.
            temperatureService.GetTemperatureCompleted += new CCRBlogExample.localhost.GetTemperatureCompletedEventHandler(temperatureService_GetTemperatureCompleted);
            
            // Make the calls to the webservice.
            CallTemperatureServiceAsync(temperatureService,"Brussels");
            CallTemperatureServiceAsync(temperatureService,"Antwerp");
            CallTemperatureServiceAsync(temperatureService,"Ghent");

            // And here it happens, this is the cool stuff here.
            // We use an Interleave Arbiter to coordinate the results of 
            // the webservicerequest. We define here that we should stop all processing
            // when there is one exception on the requests, so even if you call the webservice
            // 100 times, any excpetion will stop the processing.
            // Furthermore we define here we can handle all request concurrently, if we would access
            // non-threadsafe resources we could put them in the ExclusiveReceiverGroup and the CCR
            // will make sure there is only one thread handling them.
            Arbiter.Activate(Program.DQueue, Arbiter.Interleave(
                new TeardownReceiverGroup(
                    Arbiter.Receive(false, _FailurePort,
                    delegate(Exception ex) { })),
                new ExclusiveReceiverGroup(),
                new ConcurrentReceiverGroup(
                    Arbiter.Receive(true, _ResponsePort,
                        delegate(ServiceResponse response) {
                            Program.WFServicePort.FormInvoke(delegate {
                                ResultListBox.Items.Add(response.city + ":" + response.Temperature.ToString());
                            });    
                        }))));
        }

        //Here we handle all posting to the correct ports depending on the output of the async request of the 
        //webservice. 
        void temperatureService_GetTemperatureCompleted(object sender, CCRBlogExample.localhost.GetTemperatureCompletedEventArgs e) {
            if (e.Cancelled) {
                //Post exception;
                _FailurePort.Post(new Exception("cancelled"));
                return;
            }
            if (e.Error != null) {
                //Post exception;
                _FailurePort.Post(e.Error);
                return;
            }
            //Post ServiceResponse
            ServiceResponse response = e.UserState as ServiceResponse;
            response.Temperature = e.Result;
            _ResponsePort.Post(response);
        }
    }

    // A simple class to transport data and to use 
    // in the Ports.
    public class ServiceResponse {
        public int Temperature;
        public string city;
    }

What I like most is the possibility to use local variables in other threads. Like you see in the RunForms delegate. You don't need to declare them somewhere global, they are defined local and your code stays really clean and readable.

This is cool stuff, easy to use and easy to follow. Think of all projects you did with threading and look at this. The next sample will be a sample on how to program async in a sequential way. A feature of the CCR, that will change the way we program async.

Microsoft Robotics Studio : Bluetooth header

if you see the message "Garbled data received from LEGO NXT. Bluetooth header (31) does not match expected packet length (0) for command: GetDeviceInfo: 155." in your VS2005 output window or in the logging in the dsshost webpage do not panic, this is only a warning. If you want to remove this just add the following code to the switch statement in the ReturnPacketDataSize method of the LegoHelper class

case 0x9B:
return 31;

Under the Hood of Microsoft Robotics Studio : Concurrency and Coordination Runtime (CCR)

When working with the tutorials of Microsoft Robotics Studio I found some really unfamiliar code like "Arbiter.Activate(Arbiter.Receive<bumper.Update>(true, bumperNotificationPort, BumperHandler))". If I find code like this I want to know what it is, the kid in me will never die I suppose... So this piece of code is using the Concurrency and Coordination Runtime (in short CCR), a very nice and easy library to use threading in your applications, it is really amazing how easy it is to create workerthreads and a responsive application. There is a great article on MSDN magazine in the column Concurrent Affairs of Jeffrey Richter on the CCR, but in short it goes like this. There are 4 main classes in the CCR.

Dispatcher : A thread pool ready to use, you can create more than one.
DispatcherQueue : A Queue that contains delegates for a Dispatcher.
Port : A workitem data, by posting data to the Port the DispatcherQueue gets filled with delegates
Arbiter : A binding between a Port and a DispatcherQueue, in effect it combines a delegate with data posted on a Port and posts it in a DispatcherQueue.

There are more possibilities in the CCR but read the article and view the video on channel9 with Jeffrey Richter and George Chrysanthakopoulos. Definitly some really cool stuff you should check out, and not only for Robotics Studio.

Robotics Studio Connected to NXT

Okay, after one week of connecting bluetooth to the NXT, which included one new Bluetooth dongle, about 200 cigarets and a lot of my hair, it finally happend, I have connected Robotics Studio and the NXT. Time to get programming and do some nice things with this NXT. In order to make everyone's live easier who want to try this out, there is one solution to make this work within 5 minutes. Rebuild the LegoNxt Service and change the baudrate to 115200 in the legoNxt.cs file like this "if (_legoBlock.Open(_state.Comport, 115200))". After rebuilding this it works all fine and you should see something like this in your command line screen.

The main program should start on your NXT and if all goes well the hourglass should disappear. At that time your NXT is connected and ready to serve you, how humble.

Another tip set the sleep option in the settings on the NXT to "never", it will avoid several minutes of search why your NXT is not connectable if you know what I mean.

Will the NXT bot code my projects ?

Finally some time to blog. Let's see what I did the last few days, on saturday I did some calls to get my LEGO mindstorms NXT. It took me about 16 phonecalls to find a local store that had it in stock, yes in stock because I don't like waiting for things that I want to have now. After a road trip of 63 km I finally got home with it and started playing. When I was done building I had to install the software and most off all I had to pair it with the Microsoft Robotics Studio. Installing the software was not really difficult but getting the NXT to connect through bluetooth was hell, I had to install the driver several times and today I finally managed to get a connection. Now it is time to get it connected with Robotics Studio, when I manage to get it working I will surely blog about that one, it is already exciting to get connected to my personal robot.

On the other hand I was in Portugal, Lisbon for a business meeting on a really nice project which will get me really started with the DotNet framework 3.0, so expect some nice examples in the next months (if I have time and otherwise later, because it is a really hard shedule). It was rather rainy but they have great restaurants and even better food, I should plan more meetings overthere.

And the best news of the last month arrived today with email, I finally got registered for TechEd : Developers. Yep, yep, I will attend the event from 7-10 november in Barcelona.

Robotics Studio October 2006 CTP

Ever wanted to build a robot that finishes your project on time for you while you are drinking a good glass of red wine in the sun ? Well than you should install immediately the Robotics Studio October 2006 CTP. I'm not really an expert on robotics but I did some embedded development in my early programming years, if it would have been like it is now in Robotics Studio than I would probably never have become a DotNet developer, but would be surrounded by robots doing my work.

It includes a VPL (visual programming language) that has no learning curve at all, imagine what you would have to do to let the PC say some text. It took me 3 minutes including learning the basics of VPL. Here it is.

This tool is the best example I have seen of SOA since long, everything here is a service, sensors, lights, cameras, batteries, engines and so on. All interacting through soap messages, at a speed of 90.000 soap messages in a second, pretty performant I think. You can link it with external robots or you can simulate it, this simulation is rendered in managed DirectX, and excuse me, it looks amazing, for more information on simulation read the Microsoft Robotics Studio Simulation Overview.

Want to play ?

Sandcastle : The new NDoc

Sandcastle is the new help file generator for developers, like NDoc it generates library documentation from your source and managed assemblies.

It has three major components

MRefBuilder: produces XML-formatted reflection information files
BuildAssembler: binds your xml comments and the generated MRefBuilder files into HTML files
XslTransform: Generates and manipulates auxiliary data files.

Of what I could read in a small amount of time, this tool is highly customizable, not only by configuration files but also by coding. You can download the September CTP here .

Resources:

MSDN Evenings And Visug Sessions

I think we Belgian developers are probably the most spoiled developers of them all, after an MSDN event on Framework 3.0 and a MSDN evening on Internet Explorer again two evenings on planned. Be fast because seats are probably limited and I can testify that these evenings are well worth the time so register as fast as lightning.

October 18th, Developing solutions with Windows SharePoint Services v3 and Office SharePoint Servers 2007
From the website:

Windows SharePoint Services v3 and Office SharePoint Server 2007 is a huge platform for developing custom web portal, content management, business process management and Business Intelligence (BI) solutions. This session shows the overall architecture of Windows SharePoint Services v3 and how Office SharePoint Servers 2007 are built on top of Windows SharePoint Services. Learn how to develop custom solutions based on SharePoint by leveraging key enhancements like content types, the new feature framework and new possibilities for extending the user interface (UI) and how-to deploy and enable these custom solutions.

This session will be given by Joris Poelmans from Dolmen he delivers Information Worker solutions using Windows SharePoint services and SharePoint Portal Server.
November 15th, Introducing Visual Studio Team Edition for Database Professionals
From the website:

Visual Studio Team Edition for Database Professionals is a database development product designed to manage database change and improve software quality through database testing. Additionally this product brings the benefits of Visual Studio Team System and life cycle development to the database professional. During this session you'll get an overview of this product, including the integration with source code control, the schema and data compare functionalities, rename refactoring, the new T-SQL editor and database testing.

This session will be given by Gunther Beersarts, a Senior Technical Specialist at Microsoft

I would have liked to attended both events but unfortunate me, I need to go on a business trip to Portugal on October 18th. Always work and no pleasure, some have all the luck !!!.

On the other hand Visug (Visual Studio User Group Belgium) will have two sessions.

Windows Workflow Foundation on October 5th.
This session will be given by Kurt Claeys, he already published and article on the subject at the local MSDN site. And his blog contains some really nice posts about WF, and in particular this "linky" post of resources on WF.
Security Development Lifecycle October 25th
This session will be given by Wim Verhaeghen, he will talk about the Security Development Lifecycle, a methodology to help reduce the number of security defects in code.

MSN Search Service : A Simple Sample

After a really busy week of events and work I managed to do some programming this weekend. I'm trying to get familiar with XAML so I'm building UI's with it and do something usefull meanwhile. I attended the MSDN evening of IE7 friday and Cyra Richardson was talking about the integration of OpenSearch in IE7, David Boschmans has some great links on this, while browsing these I remembered something like the MSN Search Service. Why wouldn't I consume it in a XAML application ? So here it is, it is ofcourse simple.

First some requirements.

Download the MSN Search SDK
Get your application ID at Search Developer site
Add the webservice to your Web References of your project.

Once you did this all you have to do is consume the service as follows

public void Search() {
   MSNSearchService service = new MSNSearchService();

   SearchRequest request = new SearchRequest();
   request.AppID = this.AppID;
   request.Query = SearchTextBox.Text;

   // Always specify, no default
   request.CultureInfo = "nl-BE";
   request.SafeSearch = SafeSearchOptions.Off;
   request.Flags = SearchFlags.None;

   SourceRequest[] sourceRequests = new SourceRequest[1];

   sourceRequests[0] = new SourceRequest();
   sourceRequests[0].Source = SourceType.Web;
   sourceRequests[0].Count = 10;
   request.Requests = sourceRequests;
   LastResponse = service.Search(request);

   Result[] results = LastResponse.Responses[0].Results;
   SearchResults.ItemsSource = results;
}

It is pretty simple like I promised, there are 4 different classes that you need to use. First of all there is the SearchRequest class, this class contains the general settings for the search, every search must be further detailed with one ore more SourceRequest classes, these are used to specify where you are searching for, you can search the web, spelling suggestions and a phonebook at this time, more will be implemented. With this class you can also specify the offset and the number of results to return.
The service responds with a SearchResponse class, for every SourceRequest there is a SourceResponse class which contains a results array with the actual Result instances, these contain the url and other properties of the results you were looking for.

The resulting application looks like this.

I can conclude that this is really simple to consume and I see some possible nice implementations, like rss feeds in IE7 with your favourite searches. Maybe a next sample ? Who knows ?

If you want to implement other features of Windows Live then check out the Windows Live Developer Center and the Live Seach's WebLog

Dynamic User Interface using XAML

Dynamic user interface out of the box in a Windows application, the dream of every developer. Well it is available a this moment with XAML in the Dotnet Framework 3.0.

The following simple sample shows how you can load custom userinterface components from an external file at runtime.

First off all we need a xaml file for our user interface that hosts the custom user interface, it contains just a button and DockPanel where the custom user interface will be showed.

This creates the following window.

The Click event of the button contains the following code.

public void Button1Click(object Sender, RoutedEventArgs e) {
   FileStream fs = new FileStream(@"screen1.xml",FileMode.Open,FileAccess.Read);

   object xamlRoot = XamlReader.Load(fs);

   CustomDockPanel.Children.Clear();
   CustomDockPanel.Children.Add((UIElement)xamlRoot);
}

The screen1.xml file contains our custom user interface. Important here is to include the correct namespaces otherwise the Parsing of the XAML will fail.

If we push the button our custom UI will be shown like this.

Amazing, dynamic user interface in just 4 lines of code.

Busy week for Belgian Community

Events are being served to the belgian community. First of all we have the Msdn Event on Dotnet Framework 3.0, and like Tom says be quick to get the last seats. And should you want more, there is more like Wim says in his blog, a msdn evening session on IE7 for developers, Cyra Richardson the lead program manager for Layout and Rendering for the IE team will be talking about the new features of IE7, register here.

And for the Framework 3.0 freaks, there is a Microsoft Pre-Release Software Microsoft .NET Framework 3.0 - Release Candidate released on 01/09/2006 and it works with Orcas. Should you have any problems, suggestions or errors give feedback on the Microsoft Feedback site, on the following urls

Visual Studio : http://connect.microsoft.com/VisualStudio
Windows Communication Foundation : http://connect.microsoft.com/wcf
Windows Presentation Foundation : http://connect.microsoft.com/site/sitehome.aspx?SiteID=212
Windows Workflow Foundation : http://connect.microsoft.com/wf

Windows Live Custom Domains

If you have your own domain then your in for a treat, a 2GB inbox and unlimited amount of email adresses for free. Wim Verhaeghen wrote a complete howto in his latest post, check it out and start using it. We had to wait some time for a post of Wim but hey this is a great respawn, and if there was any doubt about his Windows Live addiction check out the new design on the local MSDN site where he did a great job on making it more readable. After David hereby my congratulations on a great job.