Quote

So recently I was up on my Linked In profile and started floating around some of the "questions" on that site. An interesting question that appears was "Can Anyone Explain Delegates in .Net?" This got me thinking about these wonderful little objects and how many people don't understand all of their usefulness. So I figured I would try my hand at explaining delegates in C# terms.

A delegate is a type-safe way of encapsulating a method. What does that mean? In short, it's an object that references a method. Similar to the concept of function pointers, but with some added functionality.

So what does that look like? First let's create a method:

private void SomeMethod(string sometext) { Console.Write(sometext); }

Now this is not an exciting method but it does allow us to see a delegate in action. When creating a delegate we need to create it to a specific method signature. That way the delegate knows about which "methods" it can work with:

public delegate void SomeDelegate(string sometext);

Notice that the delegate is very similar to the method that was created. The delegate contains the same signature so that it knows what methods can be executed. Now if we were to put this delegate to work we could easily use it like this:

public void Main() {

     SomeDelegate sdNew = new SomeDelegate(SomeMethod);

     sdNew(sometext);

}

Now the method is executed via a delegate call instead of calling the method directly. This seems an incredibly indirect way of calling a method. But it does have its uses, and many of those uses are found with events. Here is a sample event code:

private delegate void SomeEventDelegateHandler(object sender, EventArgs e);  /*** NOTE: This is typical event nomenclature.  ***/

public event SomeEventDelegateHandler SomeEvent;

private void Main() {

     /***

         To Subscribe to the event the object needs a method then add to the event listing

         this.SomeEvent += new SomeEventDelegateHandler(SomeObject.SomeMethod);

     ***/

     /*** This will raise the event ***/

     if (SomeEvent != null) /*** Always check to see if something has subscribed to the event ***/

          SomeEvent(this, EventArgs.Empty);

}

Now typical "Event Delegates" are called Handlers, so most of the time your delegate will end with "Handler." And almost always the signature is (object sender, EventArgs e) where the EventArgs object is a descendant of the EventArgs class. So if you create your own Event Arguments then you should descend from the EventArgs class:

public class CustomEventArgs: EventArgs {

     string m_CustomString = string.empty;

     public CustomEventArgs(string sometext) { m_CustomString = sometext; }


     public string CustomEventText { get { return m_CustomString; } }

}

The benefit of the delegate in events is multicasting. The delegate can be aware of multiple subscribers so when the event is fired then the delegate will be raised for all the subscribing methods. This is fantastic and allows a stronger publish/subscribe methodology to the world of events. Many objects can subscribe to the event and get notified when needed. This is really cool when using a disconnected service like Remoting to connect to many events. Delegates even allow us to trap the calls being made by the subscribing mechanisms. This helps if a remoted object loses connection somewhere along the way:

public void RaiseEventMethod(string sometext) {

     foreach(Delegate del in SomeEvent.GetInvokationList()) {

          try {

               SomeEventDelegateHandler sedhTemp = del as SomeEventDelegateHandler;

               sedhTemp.BeginInvoke(sometext, null, null);

           } catch {

                SomeEvent -= (SomeEventDelegateHandler)del; /*** Remove the delegate if errored sending message ***/

           }

     }

}

Now this is cool if you ever need to trap who, what, when and where a delegate is being called. This also shows another reason why I love delegates … Asyncronous Calls. The BeginInvoke() method is an asynchronous way of executing a method then having to go through the System.Threading model. A couple of benefits: Being able to pass parameters and multicast options. When creating a delegate the BeginInvoke will take whatever parameters are needed to use in the method as the first parameters of the BeginInvoke method. The last two parameters are added by the compiler and are standard across the board. First is a AsyncCallback delegate that can be used to post a callback method once the method is finished executing and the Second is an object you can pass that could be data needed for the async callback. Here is an example:

private int SomeCallbackMethod(IAsyncResult ar) {

     int  iReturnThreadId;

     SomeDelegate sedhTemp = ai.AsyncState as SomeDelegate; /*** The location of the object passed as information ***/

     string ret = sedhTemp.EndInvoke(out iReturnThreadId, ar); /*** Retrieve the End Results ***/

     return iReturnThreadId;

} 

public void Main() {

     AsyncDelegate adTemp = new AsynDelegate(SomeCallbackMethod); /** Create a Delegate for Callback Method ***/

     SomeDelgate sdTemp = new SomeDelegate(SomeMethod);

     sdTemp.BeginInvoke("Hello World", adTemp, sdTemp); /*** Pass the Async Delegate and original delegate for information **/

}

If you don't need all that overhead you can just call the BeginInvoke passing a null value into each of the other two parameters. That will mean that there is no callback needed. Note that the AsyncDelegate has to point to a method that uses the same signature. It is a delegate, and those rules still apply.

So there is a quick snapshot of what you can do with Delegates. There are a couple other things that are really cool about delegates, especially if you don't know what the methods are that you are going to fire, or you need to fire methods based upon reflection, but the complexity of those ideas are better left to another post. And with Generics the ideas become even more complicated. For now, this should be enough to get you started using delegates in a better fashion … or at least … using them in a fashion.

Happy coding!!!

So I've been playing around recently with XML Stylesheets (XSLT) and have come across a bunch of different elements that are "Microsoft" specific. These are Microsoft elements that are only used when running the Stylesheet through the .Net XML objects. I have yet to find another parser that works with these functions. Since I've found them I thought that I would let other people out there know a little about them because, hey, I had to find them out somehow and there is not that much out there to help with this stuff.

Here they are:

1. <msxsl:assembly> element – MSDN article
2. <msxsl:script> element – MSDN article
3. <msxsl:using> element – MSDN article
4. msxsl:node-set() function – MSDN article

Ok. So here is the skinny on how to use these. If you are going to incorporate any of the "msxsl " items you need to include the XML namespace to your declaration header. This is done like so:

<xsl:stylesheet xmnls:xsl = "http://www.w3.org/1999/xsl/transform"
xmnls:msxsl = "urn:schemas-microsoft-com:xslt" >

This will allow you to use the msxsl functions. NOTE: the namespace doesn't matter. I use msxsl to show that it is the Microsoft standard, but you can use xmnls:Bob and then call everything via the Bob namespace. It doesn't matter.

msxsl:node-set() function

It is sometimes a good thought within stylesheets to create an in memory variable that contains a node set. However, when processing that variable later in the stylesheet the .Net parser won't be able to fully process that information unless it knows that it's a nodeset to process. This is where this function is handy. Here is a quick example

<xsl:variable name="NodeSetTest">
<ElementOne>
<ElementTwo>Hello World</ElementTwo>
</ElementOne>
</xsl:variable>

So here is our node set variable able to be used in our stylesheet. The problem is if I try to call it from a standard <xsl:value-of> I will raise an error from the .Net Parser:

<xsl:value-of select="$NodeSetTest/ElementOne/ElementTwo" /> -- This will throw an error

So to make this work we have to wrap the variable using the msxsl:node-set() function.

<xsl:value-of select="msxsl:node-set($NodeSetTest)/ElementOne/ElementTwo" /> -- This is good

This allows the variable to be seen as a node set and looped through like a standard set of values.

<msxsl:script> element

This element allows the stylesheet to embed code and other functions from other languages. This is nice if you need to have some functionality that cannot be created directly from the stylesheet. This element contains the following attributes:

• language = "language name"
• implements-prefix = "prefix of user's namespace"

So let's say you need to create a date function that allows a user to return a formatted Date String depending on different formats you want to provide. This may be useful to describe a date as a string instead of as a date. This type of function can be created in the stylesheet using this element:

<msxsl:script language="C#" implements-prefix="user">
public string ReturnDateAsFormattedString(DateTime date, string format)
{
return date.ToString(format);
}
</msxsl:script>

Now you have a function that is added to your stylesheet that can be called via an xPath string. Before you can use this code you need to append to the namespace of the XSLT the "user" namespace. That is done like so:

<xsl:stylesheet xmnls:xsl = "http://www.w3.org/1999/xsl/transform"
xmnls:msxsl = "urn:schemas-microsoft-com:xslt"
xmnls:user = "http://somethingyouwanttoaddhere.com">

And now you can start using your new function like such:

<Element><xsl:value-of select="user:ReturnDateAsFormattedString(@Date, 'MMddyy')" /></Element>

And just like that you've added embedded code to your stylesheet.

<msxsl:assembly> element

What if you wanted to create a .Net Assembly library that you could call from your stylesheet? Then you implement the <msxsl:assembly> element. This element contains the following attributes:

• name = "Class Name" – Can be simple form or full form
• href = "location of the assembly" – Can be a filepath or URI

So you need to reference a binary of an image you can now append your code to contain the System.Drawing Assembly to make your new procedure work. Like so:

<msxsl:script language="C#" implements-prefix="user">
<msxsl:assemble name="System.Drawing.dll" />
public Image GetImage(string pathname)
{
return Image.FromFile(pathname);
}
</msxsl:script>

This will now allow you to load the assemblies as needed and start using them were they can be the most helpful to you. But will this work? Not without the last element.

<msxsl:using> element

The <msxsl:using> element works the exact same way as a using statement in C#. It tells what namespaces you have to work against without having to fully qualify the values. This element contains the following attributes:

• namespace = "references namespace in the script block"

So to fully implement the System.Drawing namespace in the above example we need to include a using so we don't have to fully qualify all the values. This is done like so:

<msxsl:script language="C#" implements-prefix="user">
<msxsl:assemble name="System.Drawing.dll" />
<mxsl:using namespace="System.Drawing" />
public Image GetImage(string pathname)
{
return Image.FromFile(pathname);
}
</msxsl:script>

This now allows for a fully functioning .Net Assembly call from within a stylesheet. This can allow you to extend stylesheets to all sorts of crazy implementations.

Happy extending!!!

So recently I've been downloading a number of PDA utilities to search for the cool and productive. And due to the Microsoft Windows Mobile web-site I stumbled upon a Microsoft utility that I've really started to dig. It's called Live Search and I've really started to enjoy using it.

Live Search is a utility that allows you to find out things that are happening in your area. You can enter in the location that you are at and instantly you have a wide number of phonebook-esque categories to select from to find out what you want to do. Say you're traveling to Boston, MA and want to find a good seafood restaurant, you just type "seafood" in the search menu, enter "Boston" on your location and click enter and automatically you get a listing of seafood restaurants in the area. It even has a cool little voice recognition for those people who can't type, but would rather talk.

After the query is made a selection of choices appear on the screen. You select the location you want and then you have a number of options at your fingertips. You can "Call" the location, "Get Directions" to the location, "Send a Text" message to your friends to tell them to meet you there … all by a quick touch of the button. It even has a cool map feature, brought to you from NavTeq, that will show you how to get to your location. But that's just the searching features … which are cool, but not recently what I've been using LiveSearch for.

A couple cool things that I really dig on Live Search are the up-to-date traffic information that is given via Traffic.com. This downloads the recent traffic activity in your area and shows (via red, yellow and green lines) what routes are congested and what routes are good. This has been great for me recently since I have been doing more commuting to SLC from the Provo area. It's nice to see what is in store on the highway. When I get into my car I always listen to CDs and forget to turn on the traffic report, or if I do turn on the traffic report I am always 2 seconds shy of hearing what is important to me. Now, by quickly touching my phone, I get all the information I need without much delay.

There is also a "Gas Prices" option that you can get an update about who has the lowest gas prices in your area. This is fantastic, with gas prices on the rise, to be able to find the lowest gas price in your vicinity, get directions to the location and fill up all within the block of when traffic is clearing up. I've found myself becoming a little more effective on my car usage lately.

The final "app" on Live Search that I really have started using was the "Movies" function. You can find a list of movie theaters in your area as well as get their listings of movies and show times. This is great for me because I really enjoy watching movies and want to know when the next show is, but I'm not always at the computer or in a place where I can get the information. Now I can just thumb-press and get all my information in a matter of milliseconds. Then I just text my friend Rob the show and he meets me at the theater. 10 minutes later, with popcorn in hand, we're watching the next great Hollywood flop. Why? Because that's just how we roll!! The "Movies" application also has star ratings to see from others what they think of the movie … just in case you need that extra push to urge you into the correct movie of choice. All updated from AMG.com with the latest information that they have on the movies.

So in final review … if you're looking for a great way of extending your mobile phone with a good searching tool with extra perks, I highly recommend Live Search for windows mobile. It is a fantastic application that really, truly extends your phone/PDA without being overly complicated or cluttering up your phone. Plus with all the additional functionality … you just might find yourself being able to sneak away for a little extra "you" time.

Happy Mobiling!!

Technorati Profile

So I've decided to use my livespaces.com account to update things that I've done with Microsoft and all the offerings that they provide to the general public. So this is my "Microsoft" review/product test bed for all the people out there.

Keeping up with the spirit o fthe blog … I recently upgraded my phone with the new Windows Mobile 6 OS. Previously I had Windows Mobile 5, and now … well … so I can keep up to date with the latest and greatest stuff … I've upgraded. And to be honest the upgrade process was a little more … undepth … then I thought it needed to be, but I think that is because of Samsung and all the things I needed to do for my BlackJack. Oh, by the way, I own a Samsung BlackJack (SGH - i607). I don't want to talk about the upgrade process, that can be shown here, but I would much rather like to focus on the new things that were pleasant surprises, and frustrations, that I found once I upgraded.

So first things first … the new skin of Mobile 6 is very "Vista" oriented. So if you are like me (and I sincerely hope you aren't) and have upgraded to Windows Vista your phones skin will now look similar. Oh it doesn't have the same skin features as Vista, like transparency and other stuff, but it does have a more rounded approach and blending themes. Which, if your into that stuff, can bring joy to those who want a stimulating visual counterpart. Personally … I care more about functionality than looks so let's take a look at some useful things that I really dug in Mobile 6.

ActiveSync – Nothing much has changed here, except with a couple new features to sync with Exchange server. There are also some newer connectivity items to be able to use with the phone, but this is a more nerd/admin thing that is for Exchange users more than the average Joe. So let's look at something else.

Calendar – I use the calendar ALL THE TIME! And I really dug the "Agenda" view that was previously on the calendar app. The Agenda view lists all of your appointments for the day only. And it lists them sorted by earliest-to-latest fashion. This is great because you can quickly scroll down the list of items you have scheduled for the day. However, in Mobile 6 they added one additional feature: A time bar at the top of the screen to show you the schedules/gaps that you have in your day. This is great for me since I will put my Lesson schedule in the calendar and sometimes forget about what times I DON'T have to be somewhere. By using the agenda view I can now see quickly what is scheduled and what is available, without having to guess time slots. It's great. The week view now has a display as to what the event is that you are hovering in a larger fashion. This is great if you use the week view often to see what your schedule looks like. The month view doesn't appear to have anything new added to it. The last thing that I noticed that I didn't remember seeing before was that you can now view attendees who will be at the appointment. This is great because from the attendees you can email or phone directly from the appointment. This is great for keeping track of everything around the appointment.

Contacts – At first glance nothing really appears different in this application. At second glance you can notice that there are a lot more fields editable for each person. A lot of the fields that were in your contact listing in outlook are now part of the contacts on your Mobile Device. The other big part of the "Contacts" application is when you are calling someone on the phone. Before, when typing out a phone number or a contact, the parts of the name would be highlighted. This still happens, but also on the top of the listing is how the filtering is being applied. This is cool to show you so you can look for a number of different people without really knowing who you are searching for. The filtration will allow you to keep a different thought flowing when you are in the middle of another thought. It's a pretty simple addition which is a nice additional feature.

Email/Messaging – New features have been added to make the messaging smoother and quicker here, but the BIG addition is the ability to configure an email from the phone and not just sync it up through ActiveSync. This is fantastic because there are some emails I wouldn't mind having on my phone, but I don't want to bother with it unless I needed it. There was a way to do this without ActiveSync before, but now the Messaging made it a little easier and I believe also now supports IMAP not just POP3.

Office Applications (Word, Excel, PowerPoint) – There are numerous items here that have greatly improved. If you are an Office-On-The-Go person like myself you will notice that these applications have grown with the new Office applications. I especially like that the conversion will allow you to use the new xml formatted documents that Office2007 is supporting. This allows for more compact documents and transfers. If you like using the old Pocket Office you will really like using the new Pocket Office.

Other Applications – There doesn't appear to be a whole lot of other features that I use regularly on the phone that has changed. The "Tasks" appears to be the same. "Speed Dial", "Java", "Calculation", "Stopwatch" all have the same functionalities as previously used. I'm hoping that Mobile 6 comes with a version of the Compact .Net framework, but I haven't checked that out yet. The nice thing is that it appears that there is better memory management then what was previously show with Mobile 5 but I haven't used it much yet to be certain if that is true.

Conclusion: All in all I'm pretty happy with the transition. I got a little frustrated because the custom ringtones size has been dropped. Before you could have any sound be a custom ringtone no matter what the size. Now the sound file has to be fewer than 300k, but if you are using a 22500k – 56bit sound file that should give you enough time to actually run around 30-38 seconds. This is fine when dealing with ringtones and the sound quality doesn't have to be great, because … I mean … it's a phone speaker, not a stereo. But other than that little inconvenience I like what they've done with the new Windows Mobile OS. Do I recommend the upgrade … well … if you don't have to go through the same process as I did, then sure. The upgrade process for my phone wasn't difficult, but it was a lot more of a super user install then the average Joe. For me … it saves me the trouble of buying a new phone to get the latest and greatest. And for that … I would defiantly recommend the upgrade.

Happy mobile computing!!

So recently I've been playing around with MS Word's new "Publish to Blog" function. I've really come to like it. You get the power of Word (red squiggly spelling, green squiggly grammar, styles, etc.) and the ease of having your post automatically uploaded to your specific servers. This is both extremely cool and incredibly simple to use. I've been posting to 3 different blogs with it and using 2 different blog providers: Community Server and Live Spaces.

A quick comment on Community Server …

I love using Community Server to get a simple community up off the ground. There are a number of different "portal" applications out there, but Community Server seems to be easier to maintain and simple to install. I've used DNN (Dot Net Nuke) and even thought the community as a whole is larger with DNN, the maintenance of it seems to be a beast. DNN has a lot of power in creating whatever you want, but with great power comes great maintenance overhead. Community Server was simple to install and in a few mouse clicks I had a web-site up and running that had blogs, photo galleries, file system, and forums. The problem I have with Community Server is if you want MORE than that type of idea then you will be doing development to get it off the ground. It's not overly simple to extend, but with a little ASP.Net understanding and CS Admin understanding you can get your site to where you want to be in no time.

If you would like to see my simple Community Server sites, visit: http://www.everythingenoch.com or http://www.nativemusicenthusiast.com.

A quick comment on Live Spaces …

Live Spaces is a nice little community that showcases your messenger friends and let's people get involved with information about you. There are A LOT of sites out there on the internet now that will do roughly the same type of thing, but this has a smooth integration with MS Live Messenger, which makes it a great tool. I also like having separate comments all over the internet so people can see how integrated you are in the world. Of course I don't publish any of this stuff out to people, but hey … at least I'm there in spirit. The way I figure it is if I took time with everything that I'm connected to I wouldn't be able to get any work done at all during the day … and that can be problematic.

A quick comment on Word as a Blogging tool ….

It's great if for any other reason than I can save a copy of the post as a Word Document. I'm a big believer in keeping the things that you do so I have back-ups of everything. And since I post to a lot of different places, keeping all my posts in one central repository is fantastic. Also … if I ever get my other business ideas off the ground … I can start posting all the other docs that I've worked on as blogs to get the information out there.

So here is to my first post on Live Spaces.