.NET tip: Getting the Users Home, Temp or My Documents Directory by Charlie Calvert

A common need for programmers is to get the users home directory and other commonly used directories. In .NET, this involves using a combination of the Environment.SpecialFolders enumeration, and the Environment.GetEnvironmentVariable() function. The code in this article is written in C#, but it should be easy to translate it into Pascal code.

Special Folders

Here is the Environment.SpecialFolder enumeration:

Here is how to use this enumeration:

After executing this code, the variable PersonalFolder should contain the value of your My Documents directory.

Special Folders, Integer value of Enum, Dir on My System

In Listing 1 you see the values of all the special folders on my system. Note that this enumeration is not sequential. In particular, the integer value for the first member of the enumeration in .NET 1.1 is 0, the next is 2, then 5, then 6, etc. I got these values by writing this code: int i = (int)sp. If someone sees a pattern here, let me know!
Listing 1: The values of the SpecialFolder enumeration on my system. The number in the first column is the integer value of the particular SpecialFolder member shown in the second column.

Listing 2 shows the code for getting the values found in the previous listing. Note the use of the IList interface to access the list of strings stored in a ListBox. Becoming comfortable with interfaces is one of the core tasks for programmers migrating from Win32 to .NET. Java programmers should already be familiar with this paradigm.
Listing 2: The code for retrieving the values displayed in Listing 1.

This code begins with the last method, button1_Click_1, which will be called when the user clicks on a button. The button click method calls the GetAllSpecialFolders() method. GetAllSpecialFolders() has one call to ShowSpecialFolders for each of the special folders that the C# API tracks for you. Each call to ShowSpecialFolders creates one of the strings shown in Listing 1:

The ShowSpecialFolders method begins by getting the integer value of the member of the SpecialFolders enumeration that is passed in as a parameter:

This integer value appears at the beginning of the strings shown in Listing 1. For instance, it is the 0 before the word Desktop. This value is normally not important to developers, but I am showing it to you in case you are curious about the declaration of the SpecialFolders enumeration.In Microsoft’s implementation of C#, we never see the source, so it is interesting to guess how it must be declared. For instance, in this case, the enumeration might look something like this:

The next line of my ShowSpecialFolders method begins with a call to String.Format. The String.Format() method has a peculiar, but useful, syntax I have only seen in C#. Each of the instances of code that appears in curly braces is replaced by one of the latter parameters passed to the method. For instance {0}, {1} and {2} get replaced with one of the parameters such as ‘\t’ or sp.ToString() which is passed to String.Format. Note that ‘\t;’ is the second parameter. It is the tab character, and will replace all instances of {0}. The variable i is the third parameter, and the value stored in that variable will replace each instance of {1}.

The code {2} is replaced by each instance of sp.ToString(). sp is a member of the SpecialFolder enumeration, and the ToString() method conveniently converts sp into a string representation of the enumeration member. That is, it converts sp into a string such as “Desktop”, “Programs”, “Personal”, etc. In the String shown above, the value of i appears as 0, and sp.ToString() appears as Desktop. Again, programmers don’t normally need to make a call to find out the string value of an enumeration, but it is interesting to know that you can do it if you so desire.

The last parameter, the one that goes into {3}, is the path, such as C:\Documents and Settings\Charlie\Desktop. I retrieved the path string by making the following call: Environment.GetFolderPath(sp). Note that I place three tabs in front of the path, to separate it from the rest of the code:

I still had to manually edit some of the tabbing to make it come out as evenly as it appears in Listing 1.

Useful Methods

Listing 3 shows some other useful methods. Note that I use the GetEnvironmentVariable call to retrieve the Home Directory and in the call to GetEnvTempDir(). Since environment variables are mutable, these calls are probably less reliable than other calls. Also, they may be OS dependant. In particular, I have only tested them on XP. Note, however, the GetTempDir() call, which uses what should be a more reliable method of retreiving the temporary directory. In particular, it uses the Path object. The GetMyDocumentsDir() method is a wrapper around the Environment.SpecialFolder enumeration.
Listing 3: Routines for getting the users home directory, their My Documents directory, and the temp directory.

Summary

In this article you have learned a few simple tricks for getting system dependant information while using .NET. In particular, you learned about the Environment.SpecialFolder enumeration, and about the Environment.GetEnvironmentVariable method. The Environment class is part of the System namespace, so you should not have to add any special Using statements to your code other than the default Using System reference which should appear at the top of all C# files.

By Charlie Calver Ref from: CodeGear

Pushing Data to a Silverlight Client with Sockets: Part IIDan Wahlin's WebLog

In Part 1 of this two part series on socket support in Silverlight 2 I discussed how a server could be created to listen for clients using classes in the System.Net.Sockets namespace.  In that post the TcpListener class was used to listen for client connections and the client stream was accessed using the TcpClient class's GetStream() method.  In this post I'll cover how a Silverlight client can connect to a server using sockets and receive data pushed by the server asynchronously.

Creating a Silverlight Socket Client

Silverlight 2 provides a Socket class located in the System.Net.Sockets namespace (a Silverlight namespace...not the .NET Framework namespace mentioned earlier) that can be used to connect a client to a server to send and/or receive data.  The Socket class works in conjunction with a SocketAsyncEventArgs class to connect and send/receive data.  The SocketAsyncEventArgs class is used to define asynchronous callback methods and pass user state between those methods (such as the Socket object that originally connected to the server).  An example of using the Socket and SocketAsyncEventArgs classes is shown next:

This code first identifies the application's host server along with a port of 4530 (Silverlight can only connect to servers on a port between 4502 and 4532).  A Socket object capable of communicating using the TCP protocol is then created.  Once the Socket object is created, a SocketAsyncEventArgs object is instantiated and the socket object is assigned to the UserToken property so that it is passed through to other methods.  The target endpoint of the server is set using the RemoteEndPoint property and the argument object's Completed event is hooked to an asynchronous callback method named OnSocketConnectCompleted.  Once these objects are created and ready to use, the Socket object's ConnectAsync() method can be called which accepts a SocketAsyncEventArgs object as a parameter.

When the client is connected to the server the following method is called which creates a buffer to hold data received from the server and rewires the SocketAsyncEventArgs's Completed event to a different callback method named OnSocketReceive:

The Socket object's ReceiveAsync() method is then called to begin the process of accepting data from the server.  As data is received the OnSocketReceive() method is called which handles deserializing XML data returned from the server into CLR objects that can be used in the Silverlight client. 

The deserialization process is handled by the XmlSerializer class which keeps the code nice and clean.  Alternatively, the XmlReader class could be used or the LINQ to XML technology that's available in Silverlight.  Notice that data is routed back to the UI thread by using the Dispatcher class's BeginInvoke() method.  If you've worked with Windows Forms before then this should look somewhat familiar.  That's all there is to work with sockets in a Silverlight client.  There's certainly some work involved, but many of the complexities are hidden away in the Socket and SocketAsyncEventArgs classes which both minimize the need to work with threads directly.  I've already shown what the client interface looks like as data is updated but here it is one more time (click the image to see an animated gif of the application in action):

The complete code for the Silverlight client and server application can be downloaded here.

Using Silverlight 2 ItemsControl TemplatesDan Wahlin's WebLog

Building Silverlight 2 applications reminds me of the first time I built an ASP.NET application.  There are so many new features and controls that it takes a little time to get up-to-speed with what's available and how it can be used.  It's definitely fun but at times you just want to throw the monitor out the window when something doesn't work like you think it should (disclaimer:  I've never actually thrown a monitor anywhere...but I'm definitely guilty of wanting to do it).  The good news is that the learning curve flattens out pretty quickly once you grasp a few key concepts which probably makes my monitor feel much better.  :-)

I was building a sample application for a Silverlight 2 book I'm working on and after I finished a particular feature I realized that there was an easier way to do what I wanted without writing much C# code.  I needed to dynamically output Rectangles with images and was doing it all programmatically mainly because it was comfortable and easy to do.  Here's an example of the code I initially wrote:

The code worked fine and I was able to generate the desired output for the interface.  It never felt quite right though....it seemed too code intensive for such a simple task.

In researching some other controls available in Silverlight 2 I came across ItemsControl which turns out to be what I needed in the first place.  ItemsControl allows a panel template to be defined (StackPanel, Canvas, Grid, etc.) as well as an items template.  It's like the DataList in ASP.NET in some ways.  Using it allows a collection of objects to be data bound and output without having to write custom looping code with C# or VB.NET.  Here's an example of using ItemsControl in XAML:

This code uses a really nice WrapPanel control created by lneir as the panel template.  The WrapPanel control automatically wraps UIElements to the next line once the width of the screen has been exceeded.  The ItemTemplate defines a data template that outputs a Rectangle with an ImageBrush used for the fill as objects are bound.

Once the templates were defined I was able to bind my photo collection to the ItemsControl control (named icPhotos) using the following code.  Very nice and more along the lines of what I'm used to doing with ASP.NET controls.

VS 2005 ActiveX failed to load in browser windows (Microsoft.mshtml).

Recently I was struggled with issue where ActiveX component developed in Visual Studio 2005 was working on some machines and failed to load into browser window on another.

It was no evidence on what is missing until I spot a message where it was complaint about missing Miscrosoft.mshtml assembly.

It turnout that the Visual Studio 2005 Setup wizard is not adding this assembly into dependency list and therefore into package.

To fix the problem I manually added Miscrosoft.mshtml.dll and stdole.dll to the setup project to copy them into application folder without registration.