Related Posts

1. Retaining The LastWriteTime Value For A File About To Be Overwritten Via FTP / FileUpload By Using ASP.NET's FileInfo Class (22.1)
2. An ASP.NET 2.0 Script To Share Files Among Users (20.7)
3. Displaying A Random Image From A Directory Via PHP (18)

The numbers inside parentheses are relevance scores. Scoring is based, in order of priority, on title, category, content and tags. The higher the score, the more likely that post relates to this post. ]]> Recently asked on Yahoo! Answers:

Reading file names in VB.NET?
I am making a program that I will use to read files in a particular folder and put those file names into a text file. How can I do this?

This is actually pretty easy to do in VB.NET, and there are several other examples on the Web. But it’s been a while since I’ve written anything on VB.NET, so I figured I would do this one.

I will accomplish this task with two subroutines. The first is a recursive subroutine that accepts a file path (e.g., C:pathtosomedirectory), scans all its subdirectories for files, and returns the name of each file to a second subroutine.

That second subroutine adds the passed file name to a text file.

Step 1: The GetAllFiles() Subroutine

As previously noted, our first subroutine accepts the opening file path as its argument.

• The subroutine ensures the directory exists.
• If the directory exists, the subroutine gets a list of all current subdirectories, and sends each of those subdirectories to this same function via a For Each loop. If you do not want to scan subdirectories for file names, then simply comment out the first For Each loop.
• The subroutine finally gets all the files in the directory and sends their names to the AddFileName subroutine.

Imports System.IO

Sub GetAllFiles(strPath As String)
	Dim objRoot As New DirectoryInfo(strPath)
	Dim objSubDir As DirectoryInfo()
	Dim objFile As FileInfo()

	If objRoot.Exists Then
		'if you don't want this to be recursive, remove this for loop
		For Each objSubDir In objRoot.GetDirectories
			GetAllFiles(objSubDir.FullPath)
		Next

		'keep this for loop
		For Each objFile In objRoot.GetFiles
			AddFileName(strPath & "\" & objFile.Name)
		Next
	End If
End Sub

Step 2: The AddFileName() Subroutine

The AddFileName subroutine will actually add our file name, its only argument, to the text file.

• It checks to see if the output file exists; if not, the file is created.
• A StreamWriter is created and the output file is opened for appending.
• The file name is added as a line to the text file, which is then closed.

Sub AddFileName(strName As String)
	Dim strOutput As String = "C:pathtooutput.txt"
	If Not File.Exists(strOutput) Then
		File.CreateText(strOutput)
	End If

	Dim objStream As StreamWriter = File.AppendText(strOutput)
	objStream.WriteLine(strName)
	objStream.Flush()
	objStream.Close()
End Sub

That’s all there is to it.

Related Posts

1. An ASP.NET 2.0 Script To Share Files Among Users (15.9)
2. Displaying Static, Random HTML And Images On A Web Page Via AJAX (14.8)
3. A Simple Link Rewriting Script In PHP (13.2)

The numbers inside parentheses are relevance scores. Scoring is based, in order of priority, on title, category, content and tags. The higher the score, the more likely that post relates to this post. ]]> Recently asked on Yahoo! Answers:

How do I set Windows XP to rename same named files when in same directory?
I’m putting thousands of images and other files in the same folder so that I can sort from that folder, I want to keep all the versions that I may have the same file name with different names when I put them in that folder. If I can I would also like to leave the () out of the new rename. I’ve seen other computers that do the renaming automatically, this would save me time from the current setting in which it asks with each file if I want to overwrite it and if it doesn’t overwrite it just leaves the file where it was before without putting it in!

This is simple enough to do if you have a little knowledge of VBScript; in this case, as it pertains to the Windows Scripting Host (or whatever Microsoft calls it these days).

Basically, a few lines of VBS can quickly get all the files in a directory, maintain their current sort order, rename them to be 100 percent unique, and move those files from whatever directory they are currently in to wherever we want them to go.

Let’s do it. As always, code you can download appears at the end of this listing.

Some important notes about this solution before we get into the code proper:

• This script only works for files that end in .jpg or .jpeg (case-insensitive). It won’t rename / move other image types.
• This script is not recursive. It deals only with files in the specified source directory, not with the subdirectories or the files in any subdirectories. You need to change the source folder path and continue running this script for all subdirectories.
• Images are moved from the source directory to the destination directory.
• Images are permanently renamed in this format: YYYYMMDDhhmm_X (that is, today’s year, month, day, hour, minute, an underscore, and a padded image number.
• There is no way for two images to have the same name with this system.
• Images are sorted in this script in alphanumeric order before processing, so that sets may be renamed in their original order.
  • The Files collection — which is the most convenient way to go about getting all the files in a given folder — does not return file names in a specific order and there is no way to work directly with the collection to reorder it.
  • If we want an explicit sort, we must do so with an intermediary array. More on that shortly.

We’ll start by declaring the source and destination directory variables, which you need to change to match the file paths for the directories you want to use. Note that all file paths must end with a trailing slash!

'@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
'DO NOT CHANGE THE LINE BELOW!
Dim SourcePath, DestinationPath
'@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@

'################################################################################################
'CHANGE THE PATH VARIABLES BELOW to match your source / destination folders!
'Folder paths MUST have trailing slashes!

SourcePath = "C:testinput"
DestinationPath = "C:testoutput"
'################################################################################################

That’s all the user changes the script needs. Now, to the nuts & bolts.

We start with some variables, including the basic pattern of the new file name:

'Variables
Dim I, Y, strName, FileCount, ZeroPad, strTemp
strName = CStr(Year(Now)) & CStr(Month(Now)) & CStr(Day(Now)) & CStr(Hour(Now)) & CStr(Minute(Now)) & "_"

'FSO variables
Dim objFSO, objInput, objOutput, objFile

With variables out of the way, we can create the FileSystemObject, then the source folder, and get a count of the files in the source folder:

'create FSO
Set objFSO = CreateObject("Scripting.FileSystemObject")

'Open source folder
Set objInput = objFSO.GetFolder(SourcePath)

'Compute size of file name
FileCount = Len(CStr(objInput.Files.Count))

We need to declare an array that will contain all the image file names in the source folder, so that we can later sort the files alphanumerically:

'Declare array to hold file names
Dim theFiles()
ReDim theFiles(objInput.Files.Count)

We need to initialize a short string with zeros, so that our newly named files will follow the same alphanumeric sorting rules we’re trying to preserve with the array.

For example, if there are 234 images in the folder, we want to name them 001 to 234. To do that, we will create a string with three zeros, and later, we’ll use that three-zero string to pad out the current image number.

'Create padding for file rename
For I = 1 To FileCount
	ZeroPad = ZeroPad & "0"
Next

'Reset I
I = 0

With the preliminaries out of the way, we can go through each file in the folder.

If it’s an image file — a fact we establish by looking for the file extension .jpg or .jpeg in the file name — we add it to the array we declared earlier. After we go through the entire list, we reset the array size to be the same as the number of items it contains.

'Process all files in folder
For Each objFile In objInput.Files
    'if file has JPG or JPEG extension, add to files array
    If InStr(1, objFile.Name, ".jpg", 1) > 0 Or InStr(1, objFile.Name, ".jpeg", 1) > 0 Then
	    theFiles(I) = objFile.Name
	    I = I + 1
    End If
Next
ReDim Preserve theFiles(I)

Now, we bubble sort the array, to maintain alphanumeric order:

'bubble sort files array
For I = (UBound(theFiles) - 1) To 0 Step -1
    For Y = 0 To I
        If UCase(theFiles(Y)) > UCase(theFiles(Y + 1)) Then
            strTemp = theFiles(Y + 1)
            theFiles(Y + 1) = theFiles(Y)
            theFiles(Y) = strTemp
        End If
    Next
Next

'Reset I
I = 1

And now, we simply iterate through the array, renaming the files it contains and moving them to the destination folder:

'Rename and move files
For Each strTemp In theFiles
    If objFSO.FileExists(SourcePath & strTemp) Then
	    objFSO.MoveFile SourcePath & strTemp, DestinationPath & strName & Right(ZeroPad & I, FileCount) & ".jpg"
	    I = I + 1
	End If
Next

A little cleanup, and a message telling us how many items were moved from where to where, just to let us know the script is done:

'Clean up objects
Set objFile = Nothing
Set objInput = Nothing
Set objFSO = Nothing

'Report script complete
MsgBox("Processing completed for " & SourcePath & ". Renamed and moved " & UBound(theFiles) & " image files to " & DestinationPath & ".")

That’s it. I distribute all code under the GNU GPL version 3.

Related Posts

1. Displaying A Random Image From A Directory Via PHP (61.1)
2. Display A Random Image With JavaScript / DOM (27.8)
3. Displaying A Random Yahoo! Search Every 30 Seconds With JavaScript And PHP (25.2)

The numbers inside parentheses are relevance scores. Scoring is based, in order of priority, on title, category, content and tags. The higher the score, the more likely that post relates to this post. ]]> In a recent blog post about randomly displaying an image from a directory via PHP and its built-in image and filesystem functions, I promised to expand upon the answer I had given to demonstrate some other cool filesystem tricks.

It’s about time I made good on that promise.

We’ll start by showing how to display a random image on a Web page, rather than forging the PHP to represent itself as an image; and we’ll also make a thumbnail gallery of all the images in the folder, which even shows the active image.

Displaying The Random PHP Image On The Page

The script to randomly select and display an image on a Web page is remarkably similar to the original script in this post, except that we’re going to find the image’s URL to apply as the src attribute for an IMG tag, rather than putting the image directly to the output buffer.

That URL we’ll store as the variable $img_src:

$img_path = "images/";
$exts = "/(.jpg)|(.jpeg)|(.gif)|(.png)$/i";

if(is_dir($img_path)) {
	$img_handle = opendir($img_path);

	while (false !== ($img_file = readdir($img_handle))) {
		if (preg_match($exts, $img_file)) {
			$img[] = $img_file;
		}
	}

	mt_srand();
	$len = count($img) - 1;
	$index = mt_rand(0, $len);
	$img_src = $img_path . $img[$index];

	closedir($img_handle);
}
else {
	die("no such directory!");
}

And now, to display the “random” image, we simply echo out $img_src inside an IMG tag:

A Thumbnail Gallery That Shows The Current Image

Using the same methods we employed to select a random, full-size image on the page, we can use to display a series of thumbnail images. In fact, we can even combine the scripts, to apply a background color to the thumbnail that is currently being displayed in full size.

We’ll sort of cheat on layout by using a table to display the thumbnails. (Technically, this can be considered tabular data, but best practices would be to not use a table here).

$i = 0;
$TN_COLS = 3;
$tn_path = "images/tn/";

Next, we’ll use the same method we did above to open the directory and begin iterating through the thumbnails, dumping them into an array as well:

if(is_dir($tn_path)) {
	$tn_handle = opendir($tn_path);

	while(false !== ($tn_file = readdir($tn_handle))) {
		if(preg_match($exts, $tn_file)) {
			$tn_img[] = $tn_file;
		}
	}

Now for the first real change: We apply a natsort on the array.

We do that not only because the filesystem stores icons in an unpredictable manner — that is, any old item in the directory could be listed first in any one iteration of the directory — but because we want the pictures ordered in a way that makes sense to most people.

Unlike a normal array sort, natsort will sort an array more like a human would. For example, if you have thumbnails named 1.jpg through 15.jpg, a normal array sort would place 11.jpg-15.jpg, after 1.jpg but before 2.jpg. Natsort will put 11.jpg-15.jpg at the end of the array, the way most humans would.

	natsort($tn_img);

With the array sorted, we can begin outputting each item in the array as a cell in our table.

We’re going to dynamically create rows in the table based on the $TN_COLS variable we declared earlier. For example, since we declared 3 as the value of $TN_COLS, any time we have a cell that is divisible by 3, we’re going to break for a new row.

We’re also going to see if the thumbnail image we are using is the same as the currently displaying large image. If it is, we apply a class to the table cell; in that class, we define the background color we want to have appear.

	foreach($tn_img as $thumb) {
		if($i % $TN_COLS == 0) {
			echo "
";
		}

		echo "
";
		echo "";
		echo "";
		echo $thumb;
		echo "

n";

		$i++;
		if($i % $TN_COLS == 0) {
			echo "

n";
		}
	}

We have one last housekeeping item: It’s possible we don’t have enough cells to complete the last row. To fix that problem, we add another loop that “pads” the last row with enough empty cells to complete it.

	if($i % $TN_COLS != 0) {
		for($x = $i; $x % $TN_COLS > 0; $x++) {
			echo "
 

n";
		}
		echo "

n";
	}

	closedir($tn_handle);
}
else {
	die("no such thumbnail image path!");
}

You can see this script in action at:

http://www.dougv.com/demo/php_random_image/example2.php

You can download this script and its related images from here: Displaying A Random Image From A Directory Via PHP Source Code

I distribute all code under the GNU GPL 3.

Related Posts

1. Displaying A Random Yahoo! Search Every 30 Seconds With JavaScript And PHP (26.1)
2. Display A Random Image With JavaScript / DOM (25.8)
3. Displaying A New Image Based On Image Choices Via Checkboxes, the HTML DOM and JavaScript (24.5)

The numbers inside parentheses are relevance scores. Scoring is based, in order of priority, on title, category, content and tags. The higher the score, the more likely that post relates to this post. ]]> Recently asked on Yahoo! Answers:

How would one code a rotating image (using PHP) that can be hosted on Geocities Pro for, say, a forum?

In the past, I’ve been able to host a rotating image using another method by naming a folder ‘something.png’ to fool a forum into thinking the folder is a picture and it reads the index.php file, which in turn pulls up one of the images I have coded. Now that I’m on Geocities Pro, I cannot make such a folder but would like to still use my rotating image. Is there another way I can code this and still be able to use it with forum BBCode?

Basically, this questioner wants a PHP script to look through the contents of an image directory, randomly select one of the images in that directory, and pass the script itself off as the image.

That’s fairly simple to do in PHP, but it does require a number of steps and a few tricks to overcome some limitations of PHP’s built-in filesystem functions.

This question also gives me a chance to explain working with the filesystem in PHP, and to demonstrate how loops and arrays can be used to produce some really neat results, so I’ll expand on that in a follow-up post.

As always, a working demo and source code will be available for download at the end of this article.

Step 1: Declare Basic Variables

We’ll start by declaring two variables:

• The path, relative to the script, of the folder containing the images we want.
• A regular expression that gives us the allowed extensions for our images.

For those who are new to the term, a regular expression is basically a text pattern you want to find. It uses special characters and syntax to indicate what you want to find; in our case, we’re going to search for file extensions.

Don’t worry if you don’t understand the expression; trust me that this one will allow you to use image files with the extension .jpg, .jpeg, .gif or .png; the test will also be case-insensitive, so .JPG is the same thing as .jpg.

More on all that later. Let’s look at the opening code.

$img_path = "images/";
$exts = "/(.jpg)|(.jpeg)|(.gif)|(.png)$/i";

Step 2: Open The Directory And Iterate Through The Files

Our next step is to make sure the image directory we declared actually exists. If it does, we want to go ahead and open the directory, then begin looking through the files.

An aside on the difference between evaluating equivalence vs. identity: Notice, in the code below, that we use the identity operator (===), and not the equivalence operator (==), to test whether we have read all the files in the directory.

We do that because, as the PHP documentation notes, readdir() may not return a Boolean “false,” but may return another value that is the same as false.

The identity operator allows us to compare two variables not on the basis of them having the same value (equivalence), but being the same thing.

If we just use the equivalence operator, and readdir() returns a value that means the same as Boolean false, that won’t be equal to Boolean false; our loop would continue and we’d get an error. If we use the identity operator, we know that whatever false value readdir() actually returns, it means the same, for all intents and purposes, as Boolean false; our loop will stop executing. (End of aside.)

if(is_dir($img_path)) {
	//open directory
	$img_handle = opendir($img_path);

	//iterate through all items in directory
	while (false !== ($img_file = readdir($img_handle))) {

Step 3: Put All Image Files Into An Array

We’re going to read the names of all image files into a dynamic array, the reasons for which will be clearer in a moment. For now, you’ll notice we use preg_match, the preferred method for running a regular expression match against a string, to make sure that the file we’re currently looking has an extension that’s in our allowable extensions list.

An added bonus of this approach is that it resolves problems with subdirectories in PHP.

Basically, in PHP, if you are iterating through a directory and it has subdirectories, the built-in functions in PHP will treat all subdirectories as files; you can’t even evaluate if the subdirectory is a directory.

Needless to say, that’s a major problem, and the only effective way to work around it, via the filesystem, is to read each “file,” then see if trying to enter it, as if it were a directory, works. If so, you’ve found a subdirectory, not a file.

That’s pretty wasteful, in my opinion, and possibly dangerous. It makes much more sense, and is far less resource-intensive, to simply look at the name of the file and see if it matches the kind of file we want.

Note that not all Web hosts will have compiled support for Perl-Compatible Regular Expressions (PCRE). Virtually all do, but yours may not have; if not, this script won’t be of much use to you.

Lastly, once we’re done looping through the files in the directory, we want to close the directory to free up the considerable resources PHP uses to work with the filesystem.

if (preg_match($exts, $img_file)) {
	$img[] = $img_file;
}

closedir($img_handle);

Step 4: Select The Random Image Via A Random Number

Here’s the magic: Since we’ve dumped all the file names into an array, all we need to do is randomly generate an index number, and pull out from the array the name of the file that is at that index.

So, our task list for this step is:

• Initialize our random number generator;
• Get the total number of items in the array and subtract one, which will give us the index of the last item in the array. If there are no items in the array, we’ll die and report that fact;
• Generate a random number between 0 and the integer we get from the step above, which gives us a random index for the array;
• Append the file path to the array cell contents at the index we generated, which gives us a full file path to one of the images in the directory.

mt_srand();

if(count($img) == 0) {
	die("no images in image directory");
}
else {
	$len = count($img) - 1;
}

$index = mt_rand(0, $len);
$img_src = $img_path . $img[$index];

Step 5: Get The Content-Type

The way we’re going to make this PHP script act like an image is by forging the HTTP header’s content-type value. Instead of outputting “text/html”, which Web pages send, we’ll send one of the image types, depending on our file’s extension.

So first, we need to get the extension from our file.

• We set the basic part of the content-type string as a variable.
• We split the file’s name into an array, around the periods.
• We then remove the last item of the array, which will contain our extension. We know that because by virtue of the regular expression we used to sort files earlier, we know all files will end with one of our four image file extensions.
• We cast the extension down to lower-case, to make sure we get a case-insensitive match.
• We run the extension through a switch that assumes the file is a JPEG, but changes the content-type to GIF or PNG if that’s what we actually have.

$ct = "Content-type: image/";

$temp = explode(".", $img_src);
$temp = array_pop($temp);
$temp = strtolower($temp);

switch($temp) {
	case "png":
		$ct .= "png";
		break;
	case "gif":
		$ct .= "gif";
		break;
	default:
		$ct .= "jpeg";
}

Step 6: Echo Out The Forged Header And The Image

Outputting our image is as simple as sending the forged header (via the cleverly-named header() function) and then dumping the image file’s contents directly to the output buffer via readfile().

header($ct);
readfile($img_src);

And, as a final step, we’ll add an else statement to the opening if statement; if the path we specified in Step 1 doesn’t lead to a directory, we’ll die the script and report that.

else {
	die("no such directory!");
}

And that’s all there is to it. You can see the script in action here:

http://www.dougv.com/demo/php_random_image/index.php

Just reload the page to see a different image.

A final aside on randomness: When selecting a random number, the larger the range, the more random the number. Thus, the more images that act as a source for this script, the more random your results. I’m using 15 images. (End of aside.)

You can download the source code here: Displaying A Random Image From A Directory Via PHP Source Code

I distribute all code under the GNU GPL 3.

Related Posts

1. A Simple PHP Script (MySQL, Too) To Track Radio Station Song Requests, Part 4 (13.3)
2. A Simple PHP Script (MySQL, Too) To Track Radio Station Song Requests, Part 1 (12.1)
3. A Simple PHP Script (MySQL, Too) To Track Radio Station Song Requests, Part 2 (12.1)

The numbers inside parentheses are relevance scores. Scoring is based, in order of priority, on title, category, content and tags. The higher the score, the more likely that post relates to this post. ]]> Recently asked on Yahoo! Answers:

How could I enable user to upload and download file from server using asp.net 2?

How could I enable a user to upload file to the server and then view link to download this file from the server to anthor user i when he enters the site using ASP.NET 2?

The problems here could be handled very easily simply by using the built-in FileUpload class and the DirectoryInfo / FileInfo classes to display the files in the targeted directory.

So, let’s run that simple code today.

Web.config Settings

We’ll set a few application variables in the web.config file to make our application very portable. We need to record:

• The URI (that is, the physical path) to the file
• The URL (that is, the hyperlink) to the file
• We’ll also add the System.IO namespace to the namespaces

<appSettings>
	<add key="UploadBaseURI" value="c:physicalpathtoyouruploaddirectory" />
	<add key="UploadBaseURL" value="http/path/to/your/upload/directory/"/>
</appSettings>

<namespaces>
	<add namespace="System.IO"/>
</namespaces>
1

<h3>The HTML Form</h3>

With the keys and namespaces added, we can move on to the HTML.

<ul>
	<li>We need the FileUpload control, as well as a RequiredFieldValidator to make sure that if someone uploads a file, they've entered something in the control.</li>
	<li>We need a button to submit the form.</li>
	<li>Finally, we have a div that we will programmatically update with the available file list.</li>
</ul>

1
<html xmlns="http://www.w3.org/1999/xhtml" >
	<head runat="server">
		<title>Simple File Upload</title>
	</head>
	<body>
		<form id="form1" runat="server">
			<h1>Uploaded Files</h1>
			<div runat="server" id="divFiles"></div>
			<br />
			<h2>Upload Your File</h2>
			<asp:Label runat="server" ID="lblStatus" />
			<table>
				<tr>
					<td>File To Upload:</td>
					<td><asp:FileUpload runat="server" ID="fuMain" /></td>
					<td><asp:RequiredFieldValidator runat="server" ID="rfvFU" ControlToValidate="fuMain" ErrorMessage="Please provide a file to upload" Display="Dynamic" /></td>
				</tr>
			</table>
			<br />
			<asp:Button runat="server" ID="btnSubmit" Text="Upload File" OnClick="btnSubmit_onClick" />
		</form>
	</body>
</html>

With the HTML out of the way, we need three subroutines:

• A Page_Load subroutine that will show all users the file list upon first visiting the page.
• A subroutine to show us the files
• A subroutine to upload user files, then refresh the file list

The Page_Load Subroutine

It doesn’t get more rudimentary than this: Check for page postback; if the page isn’t posting back, show the list of files.

Sub Page_Load(ByVal Sender As Object, ByVal E As EventArgs)
	If Not Page.IsPostBack Then
		'as the name says, show files
		ShowAvailableFiles()
	End If
End Sub

The ShowAvailableFiles Subroutine

Showing the files is fairly straightforward.

• We create an HTML table
• We open the directory up with DirectoryInfo, then get all the files from it
• We load those files into an array of FileInfo objects
• We check the length of the array. If it’s 0, we know there are no files. If it’s longer, we know there are files to display.
• We iterate through the FileInfo array we created, constructing URLs for each file and showing its upload (LastWriteTime) time.
• We finish the HTML table, and then assign the table to the display DIV’s InnerHtml

Sub ShowAvailableFiles()
	'display all available files in a table
	Dim strOut As String, strPath As String, strBase As String = ConfigurationManager.AppSettings("UploadBaseURL").ToString()

	'start building the table
	strOut = "<table>"
	strOut += "<tr><th>File</th><th>Date / Time Uploaded</th></tr>"

	'get all the files in our upload directory
	'load into an array of FileInfo objects
	Dim objDir As New DirectoryInfo(ConfigurationManager.AppSettings("UploadBaseURI").ToString())
	Dim objFiles() As FileInfo = objDir.GetFiles()
	Dim objFile As FileInfo

	'if we have no files, put message out
	If objFiles.Length = 0 Then
		strOut += "<tr><td colspan=""2"">No files</td></tr>"
	Else
		For Each objFile In objFiles
			'provide a link to each file, as well as its upload date / time
			'(LastWriteTime is the proper use here; CreateTime may be the
			'date the file was made, not the date it was uploaded
			strPath = strBase + objFile.Name
			strOut += "<tr><td><a href=""" + strPath + """>" + objFile.Name + "</a></td>"
			strOut += "<td>" + String.Format("{0:F}", objFile.LastWriteTime) + "</td></tr>"
		Next
	End If

	'close the table, set the HTML for the DIV to show the listing
	strOut += "</table>"
	divFiles.InnerHtml = strOut
End Sub

The btnSubmit_onClick Subroutine

The last task is the subroutine that handles file uploading.

• It checks if there was a file sent via the FileUpload control
• If so, it tries to save the uploaded file to the URI for our uploaded files
• If the file upload was bad, an error message is output
• The available file list is refreshed

Sub btnSubmit_onClick(ByVal Sender As Object, ByVal E As EventArgs)
	'check for good file
	If fuMain.HasFile() Then
		'set upload path string from app key
		Dim strPath As String = ConfigurationManager.AppSettings("UploadBaseURI").ToString() + fuMain.FileName
		'if we have a good upload, tell user;
		'otherwise, tell user the problem
		Try
			fuMain.SaveAs(strPath)
		Catch ex As Exception
			lblStatus.Text = "Error trying to save the file you uploaded: " + ex.Message
		Finally
			'no matter what, refresh the file list
			ShowAvailableFiles()
		End Try
	Else
		'warn that no file was sent to server
		lblStatus.Text = "No file was uploaded. Please try again."
	End If

Final Notes

You can download this code here:

ASP.NET 2.0 Simple Upload Code

There are all kinds of security holes in this code. Ideally, you should never place a writable directory in your public HTML path, nor should you allow people to upload any old thing they want. If you use this as is, someone could upload a malicious page to your Web site and do all sorts of damage with it; they could distribute illegal materials via your site; the list of potential mischief is endless.

As the license states, this code is provided as-is with no warranty whatsoever.

Related Posts

1. Using National Weather Service XML Feeds With ASP.NET, ADO.NET And XSL (69.9)
2. National Weather Service Current Observations PHP Script Project Has First Release (69.4)
3. Free Weather On Your Website Via The National Weather Service’s RSS Feeds (56.4)

The numbers inside parentheses are relevance scores. Scoring is based, in order of priority, on title, category, content and tags. The higher the score, the more likely that post relates to this post. ]]> As promised in my last article, here’s some ASP.NET 2.0 / VB.NET code to locally store / cache the National Weather Service’s current observations XML feeds.

The first step in this process is to create a directory on your Web server that is writeable. The second is to determine how, and when, you’ll update your feeds. Then, we can write the code.

In re: writeable directories on a Web server, the usual cautions:

• Where possible, you should grant write permissions on directories to specific user accounts you impersonate, or the ASPNET worker process for the machine you are using. Allowing “Everyone” or anonymous users to write to directories on your server is dangerous, especially if the directory is in your public HTTP path.
• You should place writeable directories outside your HTTP path. So, for example, if your Web files go in a directory named D:Inetpubwwwroot-myserver, you might want to make your writeable directory something like D:NWSXML. Of course, this assumes that you have a Web host that gives you the ability to place files outside a publicly accessible HTTP directory. Most do, some do not, so check.
• An alternative, if you can’t move your XML directory outside your HTTP path or easily impersonate a user on your system, is to obfuscate the writeable directory’s name. Don’t name it something obvious, such as “upload”; name it something odd and impossible to guess, such as “7zj32x5p6.” Then, don’t link to it from any of your Web pages, make mention of it in any site map or robots.txt files, etc. Treat it like Area 51: Deny its existence, even as you use it for secret purposes.

Once you have a directory to which you can write, you’ll need to determine how you’re going to go about scraping the XML feeds from weather.gov. You have two options:

1. You can check for the last update time when you have a new visitor, and grab the new file after you serve the current request. For lower-traffic sites, this is an acceptable option.
2. You can automate the retrieval of the file by firing your code off every 60 minutes. This is the better course, but requires additional resources beyond your Web site.
1. One method to automate the XML update is to write the code as a DLL and run it as a scheduled task on your Web server — something most shared hosting providers either won’t let you do, or want good money to let you do.
2. Another option, if you also have LAMP-based hosting, is to write the code into an ASP.NET page on your Windows box, then set up a cron job on your Linux box that instructs Lynx — the built-in text-only Web browser that comes with most *nix installs — to visit the ASP.NET page, and thus execute your code. Here’s a tutorial on how to set that up.

I’m going to provide code here that works per versions 1 and 2.2 above. For both these versions, we are going to need the System.IO and System.Net namespaces; either add them to your page via the Import directive or your web.config file.

Version 1: Check With Each New Visitor

Again, checking with each new visitor is best for low-traffic pages; those that are going to see no more than one or two visitors per minute (60-120 visitors per hour). If you’re getting more traffic than that, you’re wasting resources, because we need to run uncached file requests on the XML file on your Web server for every visitor, and asking a Web server to pick up and parse a file is one of the most resource-intensive things we can demand.

We’re going to do this in two parts: A function that will check whether we have a current version of the NWS XML feed stored locally, and return a Boolean; and a subroutine that will get the appropriate XML feed if it’s time to get an update.

Additionally, we’re going to add two application keys to the web.config file’s section. One will be the base URI of the local feed; the other will be the base URL of the NWS feeds.

<configuration>
	<appSettings>
		<add key="NWSBaseURI" value="c:pathtolocaldirectory" />
		<add key="NWSBaseURL" value="http://www.weather.gov/data/current_obs/" />
	</appSettings>
</configuration>

On to the function. It takes three parameters: A DateTime, which will be the current time; an Integer, which will be the number of minutes between pickups; and a String, which will be the file name of the feed we want to check.

Function CheckLastUpdateTime(ByRef dtTime As DateTime, ByRef intPickup As Integer, ByRef strFile As String) As Boolean
	'set default value for function
	Dim blResult As Boolean = False

	'multiply pickup period by -1, "add" it to the check time
	Dim intUpdate As Integer = intPickup * -1
	Dim dtUpdate As DateTime = dtTime.AddMinutes(intUpdate)

	'get local file
	Dim strPath As String = ConfigurationManager.AppSettings("NWSbaseURI").ToString() & strFile
	Dim objFI As New FileInfo(strPath)

	'check that file exists; return false if it does not
	If objFI.Exists() Then
		'compare last write time to update time;
		'if less than update time, return true;
		'else return false
		If objFI.LastWriteTime < dtUpdate Then
			blResult = True
		End If
	End If

	Return blResult
End Function

With that function complete, we can now move on to the subroutine that does the updating. What we’ll specifically do is request the file via WebRequest, then save it via a StreamWriter.

Also, I know that I could use different objects to read and write these files, or work directly from the StreamReader to the StreamWriter, etc. I’m doing it this way.

Sub UpdateNWSFeed(strFile As String)
	'set path strings
	Dim strLocalPath As String = ConfigurationManager.AppSettings("NWSbaseURI").ToString() & strFile
	Dim strRemotePath As String = ConfigurationManager.AppSettings("NWSbaseURL").ToString() & strFile

	'Create the WebRequest object;
	'give it 3 seconds to complete
	Dim objRequest as WebRequest = WebRequest.Create(strRemotePath)
	objRequest.Timeout = 3000

	Try
		'get the data as an WebResponse object
		'only overwrite old file if we have a good response
		Dim objResponse As WebResponse = objRequest.GetResponse()

		'convert the data into a string
		Dim objReader As New StreamReader(objResponse.GetResponseStream())
		Dim strResults As String = objReader.ReadToEnd()
		objReader.Close()

		'write results to file
		Dim objWriter As New StreamWriter(strLocalPath)
		objWriter.Write(strResults)
		objWriter.Close()

	Catch wex as WebException
		'You can add your own error-catching code here
		'Response.Write("Error getting " & strFile & ": " & wex.Message)
	End Try
End Sub

By virtue of making a new file with the StreamWriter object, we’ll overwrite the old file in the same location. Also, I should give full thanks to 4guysfromrolla.com for the WebRequest code above, which I pirated and fixed to avoid some strong typing issues with Option Strict.

Use Page_LoadComplete To Invoke Version 1

We’ll invoke the Version 1 subroutine with the Page_LoadComplete event, which occurs after all the controls — including XmlDataSource — have been loaded onto the page. We don’t want to interrupt the loading onto the page of the XmlDataSource or the DataGrid / other controls that bind to it, so we wait for them to be on the page before we go off to look for new XML.

Sub Page_LoadComplete(Sender As Object, E As EventArgs)
	If Not Page.IsPostBack Then
		If CheckLastUpdateTime(Now(), 60, "KAUG.xml") Then
			UpdateNWSFeed("KAUG.xml")
		End If
	End If
End Sub

Version 2.2: Running The Code With Crontab / Lynx

This is the best solution because it requires the least resources: However often you set the job up to run, Lynx fires and updates your feeds, using about the same amount of resources 2-3 visitors to your weather page would use under Version 1, but doing it in a fell swoop and in a manner that doesn’t impede any visitor’s experiences.

To use it, just create an ASP.NET page that fires off the UpdateNWSFeed subroutine from Version 1, above, in a Page_Load subroutine. Then, set up your Lynx crontab job to access that page however often you want to update the feeds.

I distribute code under the GNU GPL version 3.