Branimir Giurov's blog

Silverlight RIA - Jason Beres for SofiaDev.org today. Now available online

branimir — Thu, 10 Jan 2008 09:55:00 GMT

Today the SofiaDev.org US will host its monthly meeting. The talk will be about Silverlight and will be held by Jason Beres, MS MVP and an author of a few books for .NET and one for Silverlight.

The event will be broadcasted online at the following address: mms://srv1.msbgregistration.com/sofianet. We'll be online at 7:00 pm local time.

Want to join us? Send me an email at contact _at_ sofaidev.org.

Cheers,
Br

European Siverlight Challenge Contest - The Details

branimir — Tue, 27 Nov 2007 20:55:00 GMT

I haven't got the chance to post anything interesting in the last few months, but I believe now's a good time to do that.

I'm proud to present the first INETA European Contest - the European Silverlight Challenge in its Bulgarian version. The web site (http://silverlight.sofiadev.org) will be live after our UG meeting, scheduled for Thursday, Nov 29th. That means that you can start submitting your projects at that point.

The competition will continue by the end of January, 2008. Then we'll have a dedicated jury for selecting the winners. The #1 is going to qualify for the next round - in which he/she will be able to measure his/hers qualities in software design and development with the rest of Europe's finest.

It's about time you start working on that Silverlight project of yours. Visit the competition web after Nov 29th, register, then submit your project and get ready for becomming #1 Silverlight Developer/Designer in Bulgaria.

Back to Bulgaria

branimir — Thu, 29 Mar 2007 21:35:00 GMT

Hello boys, I'm baaaack.

As March 1st '07 I've got back home. Moving-in toghether with my girlfriend right in the center of Sofia. Kicking it up with a nice project for Tam Tam - the best place I've worked for.

Playing with strings (part 2 of n)

branimir — Sun, 21 Jan 2007 20:52:00 GMT

Do you know, that there's a build-in check for empty/null strings in .NET 2.0?

So instead of doing this:

string strValue = "";

if (null == strValue || strValue.Length <= 0)
{
//do something
}

You can do this:

string strValue = "";

if (string.IsNullOrEmpty(strValue))
{
//do something
}

Basically the method implementation looks like this:

public static bool IsNullOrEmpty(string value)
{
   if (value != null)
   {
      return (value.Length == 0);
   }

return true;
}

Happy coding!!!

Starting a pet project for SofiaDev.org registration web

branimir — Mon, 15 Jan 2007 10:52:00 GMT

I've started a pet project of mine during the holidays, for automating the registration for SofiaDev.org.

For now, the only way for registering is to get in touch with me (usually IM or email) and ask for an account. At the last meeting, a couple of guys, attending the event for the fist time, asked how they can register with the group.

It turned out that there are more people out there that want to get in, and can't do it, since there's no way to tell how you can get to an event, or even get an account for the site.

That's why I've started a simple pet project of mine, aiming at simplify the whole thing.

I've applied for a new project @ codeplex.com, but I'm still waiting for an approval there. I think they have problems with scaling the whole site out - a lot of new projects are getting stared there and just adding HDW is not that simple.

Nikola Kasev will do a code review, once I've something to show (I do, but it's still in our RnD repository, and I can't get him access). I'm also looking for volunteers for testing the registration and provide some feedback. If you're interested, send me an email at branimir _at_ gmail.com.

The requirements I've for now are published here: http://sofiadev.org/Pages/Requirements.aspx

Microsoft .NET Framework 3.0 goes Live

branimir — Tue, 07 Nov 2006 06:31:00 GMT

http://msdn.microsoft.com/windowsvista/support/relnotes/netfx3/default.aspx

Running Outlook Web Access on Vista

branimir — Tue, 17 Oct 2006 07:41:11 GMT

A colleague of mine had a problem today, sending emails through Outlook Web Access, while the web access URL was in he’s “Trusted sites” in IE 7.0.

A while ago, MS published an article, called “Replacing the DHTML Editing Control in Windows Vista and Beyond”.

If you click on the “New” button in Outlook Web Access, running Vista, you won’t be able to edit the body of the message – the window looks like this:

Essentially, the problem relates to a missing ActiveX control in Vista, which will not be a part of any Windows from now on. A quick search into the body of the HTML source of the page, finds a reference to the GUID of the ActiveX control.

It looks like this:

<OBJECT class="MSGBODY" classid="clsid:2D360201-FFF5-11D1-8D03-00A0C959BC0A"

You can find it around line #249.

I’m not aware of any plans by MS, on releasing a patch for Exchange. However, I believe that pretty soon (maybe around or after RTM for Vista) they will act on it.

Playing with strings (part 1 of n)

branimir — Wed, 28 Jun 2006 17:34:00 GMT

I was writing a method today, one that has to concatenate and format 2 strings. As every other developer on the planet, I’m using System.Text.StringBuilder class when I work with strings (for concatenating and formatting – because that’s what we’re using it for).

There’s also a very well known static method of System.String class called string.Format(string, string).
It’s being used when you want to do a quick and dirty string formatting, without having to initialize a new instance of System.Text.StringBuilder.

So today, I’ve asked myself: What does the string.Format(string, string) use internally?

There are 3 ways of getting an answer on that question.

1. Becoming a MVP and then becoming a member of the Shared Source Initiative program, under a very special NDA. That gives you access to the source of the Windows OS, and .NET as a part of it. After that you can’t discuss what you’ve seen with people outside that program. So writing a blog post like this one is not an option

2. Doing some refactoring with Resharper. It’s one of the best tools out there, when it comes to trying to find out what’s going on under the covers of any .NET assembly that haven’t been obfuscated.

3. Getting the source of SSCLI implementation of .NET. SSCLI is an open source initiative by Microsoft, that represents a good portion of the .NET Framework. Microsoft has released the v2 of SSCLI a couple of months ago, so it’s publicly available. While there is no guarantee that what you’ll see will be the same thing running in .NET 1.0/1.1/2.0, but it’s the closest thing you have. And it has the source of the CLR implementation of SSCLI along with some of the tools you get with .NET Framework SDK – something you can’t get to work with Resharper – most of those are native code.
You can get the SSCLI here: http://www.microsoft.com/downloads/details.aspx?FamilyId=8C09FD61-3F26-4555-AE17-3121B4F51D4D&displaylang=en.

At Tam Tam, we have the SSCLI under our source control database (we use Vault for source control system – it has very comfortable Web UI for accessing your sources).

So I’ve opened the repository were I’ve put the SSCLI into a few weeks ago, and found the implementation of the before mentioned method.

Here it is:

public static String Format(String format, Object arg0) {

return Format(null, format, new Object[] {arg0});

}

public static String Format(String format, Object arg0, Object arg1) {

return Format(null, format, new Object[] {arg0, arg1});

}

public static String Format(String format, Object arg0, Object arg1, Object arg2) {

return Format(null, format, new Object[] {arg0, arg1, arg2});

}

public static String Format(String format, params Object[] args) {

return Format(null, format, args);

}

public static String Format( IFormatProvider provider, String format, params Object[] args) {

if (format == null || args == null)

throw new ArgumentNullException((format==null)?"format":"args");

StringBuilder sb = new StringBuilder(format.Length + args.Length * 8);

sb.AppendFormat(provider,format,args);

return sb.ToString();

}

The important one is the last – the others are simply calling it with some default parameters.

It turns out that the method itself uses System.Text.StringBuilder. So it’s safe to use it, when we have a simple concatenation or formatting and concatenation cases. Like the one I had.

Running Intel Core Duo

branimir — Mon, 19 Jun 2006 17:36:40 GMT

I’ve just got my new Toshiba Portege M400 – my first Intel Core Duo and Tablet PC @ the same time. And it’s great. It came just a couple of days before I went back to Sofia, for DevDays 2006.

However, I think Toshiba has some problems with the preinstalled software they ship. A colleague orf mine has the same (although he’s not a Dev) and he shared with me that he has some major problems with the performance. It turned out (at least for me) that when I run virtual machines, for example, I get much better performance after I’ve uninstalled Toshiba Bluetooth Stack – a sort of a pack of drivers and software for managing and working with Bluetooth devices that came with the preinstalled OS. The bad thing is that so far I haven’t found another way of enabling Bluetooth on my tablet – MS’s drivers that come with XP SP2 doesn’t seem to find the hardware components. And I need those, because I want to be able to use Internet over GPRS (which is pretty cheap in The Netherlands these days – 10 EUR per a month for unlimited access). So I’ll keep searching.

Intellisense for MS SQL Server 2000/2005

branimir — Tue, 06 Jun 2006 12:01:00 GMT

There’s a limited time free of charge offer by Red Gate Software for their product “SQL Prompt”. Check it out @ http://www.red-gate.com/products/SQL_Prompt/index.htm

"My Custom C# CAML generator" article is now online

branimir — Wed, 10 May 2006 18:24:00 GMT

Check it out here:

http://blogs.sofiadev.org/blogs/branimir/articles/MyCSharpCaml_Generator.aspx

Generic event-handlers in .NET 2.0

branimir — Tue, 02 May 2006 07:33:00 GMT

I was writing-up an event handler with custom event arguments, getting ready for defining the event args class along with a delegate for the event definition (as you’re supposed to in .NET 1.1), when I’ve noticed that in VS intellisense is helping me with an advice saying that I can use a generic event argument. Cool !!!

So I’ve decided to take a couple of minutes off and see what’s can I do with .NET 2.0.

In .NET 1.x, we had to do the following:

Define a delegate type that holds the signature for the even type.
Define a custom class that inherits from System.EventArgs.
Define a class that will raise the the event instance
And encapsulate an event of the delegate type in the class from #2.
Attach event handlers for the event
And then consume the event

Here’s a simple event definition compatible with MS.NET 1.1 (and still working in 2.0)

using System;

namespace SofiaDev.Events.dn11
{
      public delegate void CustomEventHandler(object sender, CustomEventArgs e);

      /// <summary>
      /// Event Args class. Holds data, specific for the event instance.
      /// </summary>
      public class CustomEventArgs : System.EventArgs
      {
            private DateTime m_dtEventSend;
            private string m_strMessage;

            /// <summary>
            /// returns a message send to the mesasge subscriber.
            /// </summary>
            public string Message
            {
                  get { return m_strMessage; }
            }
            /// <summary>
            /// another specific field for the event subscriber
            /// </summary>
            public DateTime DateEventSend
            {
                  get { return m_dtEventSend; }

}

            /// <summary>
            /// Initializes a new instance of the custom event arg instance
            /// </summary>
            public CustomEventArgs(string message, DateTime dateEventSend)
            {
                  m_strMessage = message;
                  m_dtEventSend = dateEventSend;
            }
      }
}

So that’s the event args definition and the delegate.
Then we need the class that does the incapsulation and raises the event.

Like this:

using System;
using System.ComponentModel;
using System.Threading;

namespace SofiaDev.Events.dn11
{
      /// <summary>
      /// Class that raises events of the type we've defined in dn11_Event.cs
      /// </summary>
      public class SomeClassThatRaisesEvent
      {
            /// <summary>
            /// This is the event subscription hook. You should attach you're handler to it. When the moment is right, the class will
            /// call your handler with the appropriate event args data.
            /// </summary>
            public event CustomEventHandler CustomEvent;

            /// <summary>
            /// This method actually does the calling. If the event handler queue is not empty, it should call
            /// the delegate, passing the appropriate event arguments.
            /// </summary>
            /// <param name="e"></param>
            protected virtual void OnCustomEvent(CustomEventArgs e)
            {
                  if ( null!=CustomEvent )
                  {
                        CustomEvent(this, e);
                  }
            }

            /// <summary>
            /// calls a method that will return in 2 seconds
            /// </summary>
            public void CallEventhandlersIn2Seconds()
            {
                  BackgroundWorker bgw = new BackgroundWorker();
                  bgw.DoWork += new DoWorkEventHandler(bgw_DoWork);
                  bgw.RunWorkerCompleted += new RunWorkerCompletedEventHandler(bgw_RunWorkerCompleted);

bgw.RunWorkerAsync();
}

            /// <summary>
            /// Actual work being done here.
            /// </summary>
            /// <param name="sender"></param>
            /// <param name="e"></param>
            void bgw_DoWork(object sender, DoWorkEventArgs e)
            {
                  Thread.Sleep(2000);
            }

            /// <summary>
            /// we'll call the event handler from here.
            /// </summary>

void bgw_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{

string strMessage = string.Format("hello from the second thread at {0}", DateTime.Now.ToString("dd-MM-yyyy hh:mm:ss"));

                  //init the custom event args instance with specific data
                  CustomEventArgs args = new CustomEventArgs(strMessage, DateTime.Now);

                  //call our internal method that does the actual call of the events on clients.
                  OnCustomEvent(args);
            }
      }
}

In this one, we have a couple of additional methods that will help us demonstrate the event call itself. Check out the comments for more info.

Then we can use the whole thing. Like this:

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using SofiaDev.Events.dn11;

namespace EventArgs
{
      class Program
      {
            static bool StillWaiting = true;

            static void Main(string[] args)
            {
                  //init the instance that will we're gonna be waiting on.
                  SomeClassThatRaisesEvent instance = new SomeClassThatRaisesEvent();

//attach an event handler of our own
instance.CustomEvent += new CustomEventHandler(instance_CustomEvent);

//call method that will call us in a couple of secs (when he's ready
instance.CallEventhandlersIn2Seconds();

Console.WriteLine("about to start waiting");

                  while ( StillWaiting )
                  {
                        Console.Write(".");
                  }

                  Console.WriteLine("\n\nExiting!!!");
            }

             static void instance_CustomEvent(object sender, CustomEventArgs e)
            {
                  Console.WriteLine("\nCall returned. ");
                  Console.WriteLine("Message: {0},\ndate: {1}", e.Message, e.DateEventSend.ToString());

                  StillWaiting = false;
            }
      }
}

The problem here is that when you author an extensive library, it takes a lot of time to do the same code over and over again.

The new thing in .NET 2.0, is the possibility to use a generic delegate (there is one within the .NET BCL already) and use it everywhere. To be able to do that, you only need to define your custom event class holding the data specific to your event. In fact we can use the same class declaration as in the .NET 1.1 example and still be able to use a generic delegate as the event type.

Here’s how the same class will look with a generic event declaration:

using System;

namespace SofiaDev.Events
{
      /// <summary>
      /// same class as in the .NET 1.1 example
      /// </summary>
      public class SomeClassThatRaisesEvent
      {
            /// <summary>
            /// Only this time the event handler will have a generic definition
            /// </summary>
            public EventHandler<CustomEventArgs> CustomEvent;

            protected void OnCustomEvent(object sender, CustomEventArgs e)
            {
                  if (null != CustomEvent)
                        CustomEvent(this, e);
            }
      }
}

An example solution with both ways of doing the event declaration is available as an attachment.

Comparing and Sorting with Generics

branimir — Wed, 26 Apr 2006 11:06:00 GMT

I’m working on a project on which I need to sort some custom classes. Today, I’ve decided to play around and find easier and faster way to deal with different sorting scenarios with the use of generics.

I’ve a simple class hierarchy with a root abstract class called DataObject. From there I’ve inherited with a number of implementation classes that are used as a data containers (I’m using nHibernate for accessing the data in my MS SQL database).

I need to be able to sort arrays of instances of my data container classes. Some of them by a property A, and other by property B. Property A and B might have different types (string and int for example), and I don’t want to write a number of IComparer implementations.

So, I wrote that:

using System;
using System.Collections;

namespace SofiaDev.Generic
{
      public abstract class DataObjectSortableBy<T> : DataObject, IComparer where T : IComparable<T>
      {
            protected abstract T SortOnThisField
            {
                  get;
            }

            public virtual int Compare(object o1, object o2)
            {
                  T t1 = ((DataObjectSortableBy<T>)o1).SortOnThisField;
                  T t2 = ((DataObjectSortableBy<T>)o2).SortOnThisField;

                  if (null != t1 && null == t2)
                        return 1;
                  if (null == t1 && null != t2)
                        return -1;
                  if (null == t1 && null == t2)
                        return 0;

return t1.CompareTo(t2);
}

            public abstract object Empty
            {
                  get;
            }
      }
}

Now I can define base abstract classes for sorting.
Like this:

namespace SofiaDev.Generic
{
public abstract class DataObjectSortableByString : DataObjectSortableBy<string>
{

}

public abstract class DataObjectSortableByInt : DataObjectSortableBy<int>
{

}
}

And then inherit from them and oiverride the SortOnThisField method.

.NET RULEZ :)