Empty Collections

It is better to return empty collections rather than null when writing methods. The reason being that any code calling your method then doesn’t need to explicitly handle a special null case. Returning an empty collection makes the null check redundant and results in much cleaner method calling code. In C#, the System.Linq.Enumerable class has a useful generic method called Empty. When called with a type parameter, this method returns an empty instance of IEnumerable<T> (where T is your type parameter).

An example use:

public class House
public IEnumerable<Person> CurrentOccupants { get; set; }

public House()
CurrentOccupants = Enumerable.Empty<Person>();

I also find that this method of instantiating (or returning) a collection states my intent more clearly than something like:

CurrentOccupants = new List<Person();

The MSDN documentation for Enumerable.Empty states that it caches the returned empty sequence of type TResult – so using this consistently for the same types can give (probably negligible) performance or memory usage advantages.

This pattern also reduces the chances of null reference errors from being raised in calling code. As mentioned above, the calling code then doesn’t need to go through the usual boiler-plate null check code on the returned collection. Naturally, this leads to cleaner code as the calling code can process the collection the same way if it has items or doesn’t have items within it.

CsQuery – JQuery for .NET

I’m currently working on a personal use utility application which requires some web scraping to extract data (from HTML) which can be locally processed by the application. Getting the raw HTML was straightforward enough using the HttpWebRequest and HttpWebResponse classes in the System.Net namespace.

I then reached the point where I had some raw HTML in a string that I needed to parse. After doing a quick search I found CsQuery (available as a NuGet package) which is an open source JQuery port for .NET. I was able to easily extract the data I required from the HTML using the familiar JQuery-like selectors. There is an example code snippet below which shows just how easy it is to use CsQuery.

var html = new StringBuilder();
html.Append(“<h1>Hello, world!</h1>”);
html.Append(“<p class=’intro’>This program is using CsQuery.</p>”);
html.Append(“<p id=’author’>CsQuery is a library written by James Treworgy.</p>”);
html.Append(“</body></html>”);var dom = CsQuery.CQ.Create(html.ToString());

// Get the inner text of an element by element name selector

// Get the inner text of an element by class name selector

// Get the inner text of an element by id selector

// Add a class to an element

// Update the title text using new class in selector
dom[“.title”].Text(“CSQuery – a JQuery port for .NET”);

// Now retrieve the new title by a class selector

// Pause console


CSharp – Zip Compression and Decompression .NET 4 and Earlier

Quick post about a useful third-party zip compression library if you’re working in .NET framework version 4 or earlier.

I had been working on a SQL Server Integration Services (SSIS) package. One of the steps in the package is to decompress a set of zip archives. Unfortunately, .NET script tasks in the SSIS package can only target .NET framework version 4 and earlier. This means that I couldn’t make use of the new zip compression classes introduced in .NET 4.5 (see System.IO.Compression).

Fortunately though, there are a handful of open source .NET zip libraries available. The one I opted for is called DotNetZip. DotNetZip has an intuitive API and is working well with a large number of files (I am decompressing approximately 15,000 archives). The library is available as a NuGet package. The two snippets below show just how easy it is to compress and decompress files using zip.

To compress a file into a zip archive:

using (var zipFile = new ZipFile())
// The empty string parameter ensures the file is archived to the 
// root of the archive

To decompress files out of a zip archive:

using (var zipFile = new ZipFile(@“C:\Test\Data.zip”))

Csharp How To: Start a Program/Process

To start a program in C#, you can use the Process class. The Process class has a static method called Start which accepts a filename as a parameter. The example below shows how easy it is to start Microsoft Notepad from a C# application. Remember to include the “using System.Diagnostics;” directive at the top.

const string ProgramPath = “Notepad”;


Note that if you need to start a program which accepts command line arguments, then you can use an overload of the Start method which accepts a ProcessStartInfo object. The following snippet shows how to open a file within notepad from your C# application.

const string ProgramPath = “Notepad”;

Process.Start(new ProcessStartInfo
FileName = ProgramPath,
Arguments = @”C:\WriteTest.txt”

Csharp CSV Library and HTTP Handlers

A colleague and I was recently looking at some old ASP.NET WebForms code which generated a potentially large CSV string and returned it in a response to a HTTP request. The original code was placed in a standard ASP.NET WebForms page in the OnLoad event handler. As the code was working with the HttpResponse object and writing the CSV directly to the HTTP output stream, we determined that this code was better placed in a HTTP Handler. The primary advantage of using a HTTP handler to generate the file is that we can bypass the unnecessary ASP.NET WebForms page life cycle.

The existing code was using a StringBuilder to generate the CSV string in the page OnLoad event handler. As you may imagine, this looked messy and was a pain to maintain. To abstract the CSV string creation logic, my colleague introduced me to a useful CSV library called LINQ to CSV. The project page link for this library is here and the library is available as a NuGet package.

The LINQ to CSV library enabled us to decorate some properties in a model class with attributes that specify how to output the property in CSV form. The example below (from the library project page) shows how to apply the attributes:

public class Product
[CsvColumn(Name = “ProductName”, FieldIndex = 1)]
public string Name { get; set; }
[CsvColumn(FieldIndex = 2, OutputFormat = “dd MMM HH:mm:ss”)]
public DateTime LaunchDate { get; set; }
[CsvColumn(FieldIndex = 3, CanBeNull = false, OutputFormat = “C”)]
public decimal Price { get; set; }
[CsvColumn(FieldIndex = 4)]
public string Country { get; set; }
[CsvColumn(FieldIndex = 5)]
public string Description { get; set; }
Once your model class is decorated, you can then use other classes of the library to generate a CSV representation of a collection containing your model instances. This representation can be output to disk as demonstrated in the code example below:

IList products = new List();
new Product
Name = “Samung Galaxy S6”,
LaunchDate = DateTime.Today,
Price = 500,
Country = “United Kingdom”,
Description = “This is a Samsung phone product”

new Product
Name = “Apple iPhone 5”,
LaunchDate = DateTime.Today,
Price = 600,
Country = “United States”,
Description = “This is an Apple phone product”

CsvFileDescription inputFileDescription = new CsvFileDescription();
inputFileDescription.SeparatorChar = ‘,’;
inputFileDescription.FirstLineHasColumnNames = true;

CsvContext csvContext = new CsvContext();
csvContext.Write(products, @”C:\Products.csv”);

Usefully, the CsvContext class of the library also supports an overload to the Write method which accepts a TextWriter stream. Passing a TextWriter stream to this overload results in the library outputing the CSV representation to your stream rather than a file on disk. In our case, we used a StreamWriter that wrote to a MemoryStream. Once the CSV file content was in the MemoryStream instance, we sent the stream contents in the HTTP response from the HTTP handler. The full HTTP handler code is below (using the example product data).

public class ProductsExportHandler : IHttpHandler
public bool IsReusable { get { return true; } }

public void ProcessRequest(HttpContext context)
context.Response.ContentType = “application/vnd.text”;

IList products = new List();
// Add products…

var inputFileDescription = new CsvFileDescription();
inputFileDescription.SeparatorChar = ‘,’;
inputFileDescription.FirstLineHasColumnNames = true;

using (var memoryStream = new MemoryStream())
using (var streamWriter = new StreamWriter(memoryStream))
var csvContext = new CsvContext();
csvContext.Write(products, streamWriter);



Azure App Service – Forcefully redirecting from HTTP to HTTPS the easy way!

The easiest, non techie way is to add the ‘Redirect HTTP to HTTPS’ Extension kindly created by Greg Hogan (https://github.com/gregjhogan)

In the Azure Portal, select ‘Extensions’ in the App Service blade


Add a new Extension by clicking on the ‘+Add’ button at the top
Select the ‘Redirect HTTP to HTTPS’ extension from the list given.


Agree to the T&C’s
Wait till it’s installed and then restart the service (which you can find in the ‘Overview’)

After this when you access the website with http or without http/https, it will automatically redirect to https.