Phil Gilmore : Visual Studio, .NET 3.5

How to support file uploads in ASP.Net MVC

Phil Gilmore — Wed, 03 Jun 2009 22:57:37 GMT

06/03/2009, Phil Gilmore

ASP.NET MVC can support file uploads. You need two components to support file uploads.

A form in your markup (view) which contains an <input type="file"...> tag and which has the proper enctype attribute.
A controller action which will receive the upload information and perform a task with it.

Your form can be as simple as this:

<form action="/MyController/SendFile" enctype="multipart/form-data" method="post">
    <input type="file" id="SourceFile" name="SourceFile" />
    <br />
    <input type="submit" value="Send" name="btnUpload" id="Submit1" />
</form>

Notice the enctype attribute on the <form...> tag. This is required to support file uploads. Notice too that the action points to our controller action which knows how to work with the uploaded file. Lastly, you'll see the <input type="file...> tag inside the form.

Here is a screen shot of the form, rendered in Firefox 3.0.

The form as shown above contains only Html and is fairly universal regardless of the web framework you are using. This means it should be familiar to you. You have probably seen the enctype attribute on a form with its accompanying. The id attribute of the <input type="file"... > tag will be mapped by the MVC framework to a property of your model or to a parameter in the action method (in this case the SendFile action). Here is an example of an action which takes the file as a parameter.

public ContentResult SendFile(HttpPostedFileBase SourceFile)
{

}

This action gets an HttpPostedFileBase object containing properties for the original local filename and the content of the file itself. Notice that the MVC framework only maps this parameter to the file data if the parameter name (SourceFile) matches the id and name parameters from the <input type="file"...> tag in the form.

If you have a strange circumstance which prohibits you from organizing your form and action in this way and MVC cannot map the file data to an HttpPostedFileBase parameter, you can retrieve it manually from the Request object.

public ContentResult SendFile()
{
    HttpPostedFileBase SourceFile = Request.Files[0];
    //...
}

Here is an evaluation of the HttpPostedFileBase object as provided to the SendFile action method.

Once you have an HttpPostedFileBase object, you can work with the file data. Here are the members of the HttpPostedFileBase class.

protected HttpPostedFileBase();
public virtual int ContentLength { get; }
public virtual string ContentType { get; }
public virtual string FileName { get; }
public virtual Stream InputStream { get; }
public virtual void SaveAs(string filename);

This is pretty simple stuff. You can save the file, read the file or get the file's name and mime type (ContentType). ContentLength is generally not necessary since the InputStream already contains the data of the correct size.

Here is a working action that displays the content of any file uploaded to it.

public ContentResult SendFile()
{
    if (Request.Files.Count == 0)
        return new ContentResult() { ContentType = "text/plain", Content = "File upload failed." };
    else
    {
        HttpPostedFileBase SourceFile = Request.Files[0];
        ContentResult result = new ContentResult();
        result.ContentType = "text/plain";

        StreamReader reader = new StreamReader(SourceFile.InputStream);
        string content = reader.ReadToEnd();
        result.Content = content;

        return result;
    }
}

This method doesn't use the MVC-mapped HttpPostedFileBase parameter. This is not as elegant, but doesn't require a matching name or id on the file upload element in the form markup. This may be useful in some cases.

Lastly, entering that <input type="file"...> markup into the form can be error-prone. While the element is not large or hard to read, it must be exact and is inconsistent with styles supporting strongly-typed views mapped to an MVC model. Therefore it may be prudent to extend the HtmlHelper class to make this easier, cleaner and more consistent. I have written an extension method to do this. It has 2 overloads.

public static string Upload(this HtmlHelper helper, string name)
{
    string result = string.Format("<input type=\"file\" id=\"{0}\" name=\"{0}\" />", name);
    return result;
}

public static string Upload(this HtmlHelper helper, string name, object htmlAttributes)
{
    string attributes;
    if (htmlAttributes is IEnumerable<KeyValuePair<string, object>>)
        attributes = (htmlAttributes as IEnumerable<KeyValuePair<string, object>>).ToAttributeString();
    else
        attributes = (new RouteValueDictionary(htmlAttributes)).ToAttributeString();

    string result = string.Format("<input type=\"file\" name=\"{0}\" {1} />", name, attributes);
    return result;
}

Using this extension, my markup can be changed to this:

<% using (Html.BeginForm("SendFile", "MyController", FormMethod.Post, new { id = "sendFileForm", enctype = "multipart/form-data" }))

{ %>

    <%= Html.Upload("SourceFile", new { style="width: 300px;" })%>

    <br />

    <input type="submit" value="Send" name="btnUpload" id="Submit1" />

<% } %>

Personally, I don't think this is as pretty as straight HTML, but it's easier to write consistently, and if you're using MVC, your whole page probably looks like this already anyway. It's your choice. Either way you build the markup, the controller action is unaffected.

None of this is very complicated but I recently had to run through it and construct a proof-of-concept for some coworkers and figured I'd publish it for the masses. I hope it was helpful.

Building data sequences in C#

Phil Gilmore — Tue, 19 May 2009 20:03:00 GMT

05/19/2009, Phil Gilmore

Beyond the overlap they share with enumerable collections, sequences are mostly unsupported in C#. A notable exception are some of the static methods of the Enumerable class. Check them out. This support is all I need for most sequence work I do. But the support therein is insufficient for anything complex. To augment this support, I have written some extension methods to various CLR classes to add pseudo-support for sequences and sets. One that seems to be especially useful is a sequence generator method. It immediately became useful in many instances, so I thought I'd share it.

What can I do with a sequence generator?

Generate a time-of-day list to allow users to select a time from a drop-down list, perhaps in 15-minute intervals.
Generate a list of months to allow users to select a month from a drop-down list.
Generate a list of years to allow a user to select their birth year from a drop-down list.
Generate a list of any type of sequential data for user selection.
Build an "upline" of parent-child relationships in table of hierarchical data traversed through a self-join.
Any operation that would normally be constructed using a For loop or While loop to populate a list or collection.

Why not collections and loops?

Looking at this list, you might be pondering the usefulness of this since many of these things can be achieved using a collections built in a for-loop or through various Linq maneuvers. This is true. Consider the example above in building an upline from a hierarchical table. But the value of sequence generation is easier to see when considering that sequence data can be built by analyzing the last item in the sequence. For example, you could use a For loop to iterate through your file system and build a List of mp3 filenames in your music collection. This is more the function of a collection than a sequence. This data already exists as separate elements that are found and stored in a collection. If one mp3 file is deleted, the next does not change. In a sequence where elements are related by generation, the removal or change of an element may affect the generation of the rest of the sequence. For example, consider a sequence of incremental integers starting with 1000 and incrementing by 1 with a sequence size of 5. The elements of this sequence would be 1000, 1001, 1002, 1003 1004. If the first element were to change to 1002, the sequence would continue its pattern and become 1002, 1003, 1004, 1005, 1006. The generation of elements in a sequence also does not necessarily require existing data to be collected. Whereas a collection of mp3 filenames requires a filesystem that can be queried to retrieve these filenames, a sequence of incremental integer is generated from only a single seed element (1000 in my first example).

Building a sequence generator:

public static IEnumerable<T> CreateSequence<T>(
    this T startElement, Func<T, T> getNextElement, Predicate<T> isLastElement)
{
    T currentElement = startElement;

    while (!isLastElement(currentElement))
    {
        yield return currentElement;
        currentElement = getNextElement(currentElement);
    }
    yield return currentElement;
}

The first parameter (startElement) is the object on which the method is called. This is probably a primitive object, but can be anything. There are no constraints on the T type parameter so reference and value types are both game. Even literals work. You can call this method on the literal number 1. Of course, this is part of the syntax of C# extension methods. When consuming this method, you do not pass the first parameter. But it's important to understand that this is the first element in the sequence (the seed).

The getNextElement parameter (the first that you provide) is a function. This function can be a delegate to a method, an anonymous method, or a lambda expression. In my examples, I use a lambda expression. The function is given the current element and is expected to return the next element in the sequence. For simple sequences, it will probably just add or subtract some number to the current element to produce the next one.

The isLastElement parameter is another function. As each element is added to the sequence, this function is executed to determine if the end of the sequence has been reached. If the function returns false, then the sequence continues and getNextElement will be called again to get yet another element. If it instead returns true, the current element will be the last element added to the sequence and the CreateSequence method will return thereafter.

Beware of infinite loops when using this. If the IsLastElement function never returns true, you will encounter an infinite loop. For this reason, it may be a good habit to use >= and <= operators instead of == operators, for example. Even though your sequence may be simple as in our examples, better safe than sorry. For more complicated sequences, be even more careful.

The method can be refined if desired. It may be desirable to change the isLastElement predicate from an UNTIL condition to a WHILE condition (and hence renaming it to isValidElement instead), for example.

Using the sequence generator:

Most of these examples can be done using the static methods of the Enumerable class with a little more simplicity. But I'll still keep the examples simple. You can build up to the hard stuff yourself. Here is a simple example using the sequence generator method in an ASP.NET MVC web form where a TIME must be selected. First, the code to generate the view data:

// Create a sequence of times, 15 minutes apart.
DateTime referenceDate = DateTime.Now.Date;
List<DateTime> availableTimes = referenceDate.CreateSequence
(
    x => x.AddMinutes(15), 
    x => x.CompareTo(referenceDate.AddDays(1).AddMinutes(-15)) >= 0
).ToList();

// Convert times to a list of bindable objects for a dropdown list in the MVC view.
ViewData["DueTimesAvailable"] = availableTimes.Select(
    x => new SelectListItem()
    {
        Text = x.ToString("hh:mm tt"),
        Value = x.ToString("hh:mm tt"),
        Selected = x.Equals(referenceDate)
    }).ToList();

The first block of code creates a list of datetimes starting at midnight on the current date, every 15 minutes until 11:45pm on the same day. The second block converts these DateTimes to a List<SelectListItem> using Linq. Here's a simple example, creating a list of month names.

List<string> months = 1.CreateSequence(m => m + 1, m => m >= 12)
    .Select(i => System.Threading.Thread
        .CurrentThread.CurrentCulture
        .DateTimeFormat.GetMonthName(i)
    ).ToList();

Screen shots:

In the example above, we get month names in a sequence ("January", "Februrary", "March"...). Below are some of these examples in action in an ASP.NET MVC page. Notice that Months and Times are in ascending order and Years are in descending order. They were not sorted in this way. They were generated in those orders by either incrementing or decrementing the sequence seed.

So where does this leave sets?

Additional extension methods and classes can be used to treat these sequences and native Enums as sets. Watch for more details in another blog post.