Anton Gochev's Weblog

Hide complexity and inconsistency of legacy classes using facade

ganton — Fri, 21 May 2010 21:14:00 +0000

Very often in a system we may have modules that are implemented by different persons for a long period of time that are inconsistent and it is difficult to use them in a new implementation. Here in this post you can find a sample of solving these problems using facade design pattern, unique interface and IoC.

Let’s assume that we have a set of report building classes that have no common interface but they need similar data in order to build different report views. These are the sample legacy classes that we need to use.

public class BanchmarkReportBuilder
{
    public Stream CreateBenchmarkReport(Data data, AnotherData anotherData, ReportType type)
    {
        return null;
    }
}
  
public class MonitoringReportBuilder
{
    public Stream CreateMonitoringReport(int dataId, int anotherDataId)
    {
        return null;
    }
}
  
public class AdditionalReportBuilder
{
    public Stream CreateAdditionalReport(Data data, int anotherDataId, IList<int> someIds, ReportType type)
    {
        return null;
    }
}

Here are the sample data classes.

public class Data
{
    public int Id { get; set; }
    public string Info { get; set; }
}
  
public class AnotherData
{
    public int Id { get; set; }
    public IList<object> Data { get; set; }
}
  
public enum ReportType
{
    Word = 1,
    Pdf = 2
}
  
public class ReportData
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string ClassReferenceName { get; set; }
}

It is obvious how they were used. Everywhere the same data retrieved in different web pages and then supplied to the report classes. So, we have these old not very nice implementations and they are used even “better”. Let’s say that at some point it is required to have an automated system that will send e-mails with link(s) to a specific report(s) and the user should be able to click on the link and to go to a general report page. This page should somehow build the report and send it back to the end-user. But it may be a problem with the implementations demonstrated above. For sure, we can re-factor all the implementations and then their usage and then to use them in our new implementation but this will cost us plenty of time. In order to reduce the time of the implementation we can skip re-factoring part and to build an unique interface around these legacy classes and to implement just the simple method of the unique interface. This action can be assumed as re-factoring .Below is the interface and its implementation in legacy classes.

public interface IReportBuilder
{
    Stream Build(Data data, AnotherData anotherData, ReportType type, params int[] someIds);
}
  
public class BanchmarkReportBuilder : IReportBuilder
{
    public Stream CreateBenchmarkReport(Data data, AnotherData anotherData, ReportType type)
    {
        return null;
    }
  
    public Stream Build(Data data, AnotherData anotherData, ReportType type, params int[] someIds)
    {
        return CreateBenchmarkReport(data, anotherData, type);
    }
}
  
public class MonitoringReportBuilder : IReportBuilder
{
    public Stream CreateMonitoringReport(int dataId, int anotherDataId)
    {
        return null;
    }
  
    public Stream Build(Data data, AnotherData anotherData, ReportType type, params int[] someIds)
    {
        return CreateMonitoringReport(data.Id, anotherData.Id);
    }
}
  
public class AdditionalReportBuilder : IReportBuilder
{
    public Stream CreateAdditionalReport(Data data, int anotherDataId, IList<int> someIds, ReportType type)
    {
        return null;
    }
  
    public Stream Build(Data data, AnotherData anotherData, ReportType type, params int[] someIds)
    {
        return CreateAdditionalReport(data, anotherData.Id, someIds, type);
    }
  
}

What we have now is an unique interface and a very simple implementation of the interface’s method. Actually, the implementation of Build method in all of the legacy classes is just a wrapper around existing legacy method. The next problem that we need to solve is how the new general implementation will now which builder class to instantiate. In my case we use IoC container where it is possible declaratively to specify classes in a XML file configuration. Let’s say that we have a class like those below that holds a general instance of IoC container for all application.

public static class IoCInstance
{
    public static TResult GetObject(string name)
    {
        return default(TResult);
    }
}

Next question to answer is how we will know which of the reports we need to build. Fortunately, we have a report meta-data stored in the database. For example, a table with columns id, name, timestamp and classReferenceName is more then enough for this sample. In a real case, you will have more tables and more info based on your needs. We also need to have some repository classes that will retrieve the information from the database. All these sample classes are below.

public interface IReportRepository
{
    ReportData GetReport(int id);
}
  
public interface IDataRepository
{
    Data GetData(int id);
    AnotherData GetAnotherData(int id);
}
  
public class ReportRepository
{
    public ReportData GetReport(int id)
    {
        return new ReportData { Id = 1, Name = "Banchmark Report", ClassReferenceName = "BanchmarkReportBuilder" };
    }
}
  
public class DataRepository
{
    public Data GetData(int id)
    {
        return new Data { Id = 1, Info = "info" };
    }
  
    public AnotherData GetAnotherData(int id)
    {
        return new AnotherData { Id = 1, Data = "data" };
    }
}

As we discussed above using the IReportBuilder interface we solve the inconsistence and complexity of all legacy classes. Having reports’ meta-data in the database we can add in the link a parameter containing report id. Then in the general page we will use it to receive all the information that we need for a specific report. Then having the IoC we can use it to get the right builder instance. All of this is fine but we also want to hide the complexity of using all these different classes. To solve this we will use a facade class that will be able to return a stream of a generated report and the report name based on the general set of parameters that we will send with the link. A sample of a facade class is below.

public interface IReportBiuldingFacade
{
    Stream Build(int reportId, int dataId, int anotherDataId, ReportType documentType, int[] answersetIds, out string reportName);
}
  
public class ReportBiuldingFacade
{
    private IReportRepository reportRepository;
    private IDataRepository dataRepository;
    private string applicationRootPath;
  
    public ReportBiuldingFacade(IReportRepository reportRepository, IDataRepository dataRepository, string applicationRootPath)
    {
        this.reportRepository = reportRepository;
        this.dataRepository = dataRepository;
        this.applicationRootPath = applicationRootPath;
    }
  
    public Stream Build(int reportId, int dataId, int anotherDataId, ReportType documentType, int[] answersetIds, out string reportName)
    {
  
        ReportData reportData = reportRepository.GetReport(reportId);
        Data data = dataRepository.GetData(dataId);
        AnotherData anotherData = dataRepository.GetAnotherData(anotherDataId);
  
        IReportBuilder reportBuilder = IoCInstance.GetObject(reportData.ClassReferenceName);
  
        reportName = reportData.Name.Trim() + "." + documentType.ToString().ToLower();
  
        return reportBuilder.Build(data, anotherData, documentType, answersetIds);
    }
}

And to make the sample complete below you can find a unit test class with methods for the facade. The unit test methods are implemented using NUnit framework and Rhino.Mocks framework. You can see that the tests target is the facade logic and all other classes are mocked. In order to be able to mock the repositories the IoC in the facade constructor was used. In order to abstract from the report builder a stub was created and declared in IoC container XML configuration file for the tests. The stub contains an Action that is used in the test in order to check that the stub method was executed. The first class is the stub and the next is the unit test for the facade.

public class ReportBuilderStub : IReportBuilder
{
    public System.Action MethodExecuted;
  
    public Stream Build(Data data, AnotherData anotherData, ReportType reportType, IList<int> somIds)
    {
        if (MethodExecuted != null)
        {
            MethodExecuted();
        }
  
        return null;
    }
}

[TestFixture]
public class ReportBuildingFacadeTestFixture
{
    [Test]
    [TestCase(false, true, null, ExpectedException = typeof(ArgumentNullException))]
    [TestCase(true, false, null, ExpectedException = typeof(ArgumentNullException))]
    [TestCase(true, true, null, ExpectedException = typeof(ArgumentNullException))]
    [TestCase(true, true, "", ExpectedException = typeof(ArgumentOutOfRangeException))]
    public void ConstructorTest(bool initializeReportRepository, bool initializeDataRepository, string path)
    {
        IReportRepository reportRepository = null;
        IDataRepository dataRepository = null;
        MockRepository repository = new MockRepository();
  
        if (initializeReportRepository)
        {
            reportRepository = repository.Stub();
        }
  
        if (initializeDataRepository)
        {
            dataRepository = repository.Stub();
        }
  
        IReportBuildingFacade facade = new ReportBuildingFacade(reportRepository, dataRepository, path);
    }
  
    [Test]
    [TestCase(0, 1, 1, ExpectedException = typeof(ArgumentOutOfRangeException))]
    [TestCase(1, 0, 1, ExpectedException = typeof(ArgumentOutOfRangeException))]
    [TestCase(1, 1, 0, ExpectedException = typeof(ArgumentOutOfRangeException))]
    public void BuildWithWrongParametersTest(int reportId, int dataId, int anotherDataId)
    {
        MockRepository repository = new MockRepository();
        IReportRepository reportRepository = repository.Stub();
        IDataRepository dataRepository = repository.Stub();
  
        IReportBuildingFacade facade = new ReportBuildingFacade(reportRepository, dataRepository, "path");
  
        string reportName;
        facade.Build(reportId, dataId, anotherDataId, ReportType.Pdf, new int[] { 1 }, out reportName);
    }
  
    [Test]
    [TestCase(1, 1, 1, (int)DocumentType.Pdf)]
    public void BuildTest(int reportId, int dataId, int anotherDataId, int reportTypeId)
    {
        MockRepository repository = new MockRepository();
        IReportRepository reportRepository = repository.StrictMock();
        Expect.Call(reportRepository.GetReport(1)).Return(
            new ReportData
            {
                Id = reportId,
                Name = "report",
                ClassReferenceName = "BanchmarkReportBuilder",
            });
        IDataRepository dataRepository = repository.StrictMock();
        Expect.Call(dataRepository.GetData(dataId))
            .Return(new Data());
        Expect.Call(dataRepository.GetAnotherData(anotherDataId))
            .Return(new AnotherData());
  
        repository.ReplayAll();
  
        IReportBuildingFacade facade = new ReportBuildingFacade(reportRepository, dataRepository, "path");
        bool buildMethodExecuted = false;
  
        ReportBuilderStub reportBuilder = IoCInstance.GetObject("BanchmarkReportBuilder");
        reportBuilder.MethodExecuted = () => buildMethodExecuted = true;
  
        string reportName;
        facade.Build(reportId, dataId, anotherDataId, ReportType.Pdf, new int[] { 1 }, out reportName);
  
        repository.VerifyAll();
  
        Assert.AreEqual("report.pdf", reportName, "returned report name is not correct.");
        Assert.True(buildMethodExecuted, "Build Method of the report builder is not executed.");
    }
}

What to use where or inner join?

ganton — Fri, 07 May 2010 09:39:00 +0000

Actually, I received a question like this few days ago and if such a question appear to people why not to right the answer here. :) If you have two queries like those below what do you think is the difference?

select count(a.id)
from answer a, answerset aset
where a.answersetId = aset.id and aset.isReviewed = 1

select count(a.id)
from answer a
inner join answerset aset on a.answersetId = aset.id
where aset.isReviewed = 1

Logically, there is no difference. They will return the same result and the execution plan will be the same and it is obvious that the performance will be also the same. The execution plan is below. You can see that both queries share 50% of the query cost.

Then what to use? I think it is up to you and up to the coding styles that you may follow in your team. If your team prefer to use where just do it or vice versa.

EXECUTE permission denied on object ’sp_sdidebug’, database ‘master’, owner ‘dbo’.

ganton — Thu, 06 May 2010 09:58:00 +0000

An exception that you can get during application debugging when you attach to an aspnet_wp.exe process. If you use a published web site it is fine but attaching to it in some case can cause this exception to happened. What is the reason? By default the debugger tries to attach to and debug T-SQl code and if the user that your application uses doesn’t have rights to access stored procedures that are required for debugging this exception will appear. When attaching to a process we see the window below.

By default, selected options for aspnet_wp process are to attach to T-SQL code and Managed code. If you need to debug the T-SQL code you must give proper rights to your user but if you don’t need to debug it you can just reconfigure attach to options. For this just press [Select…] and reconfigure it like it is shown below.

As you can see T-SQL option is not selected and the debugger will not attach to this code and the error will disappear and it is ready for testing.

Secure VPN connection terminated locally by the client. Reason 414: Failed to establish a TCP connection.

ganton — Tue, 04 May 2010 19:00:00 +0000

At the end of last week I updated my Windows XP with SP3. After a while I’ve tried to connect to the company network using Cisco VPN client and it failed to connect with the error stated in post’s header. If you look in the log you can see that the client tries to connect the server but for some reason it is impossible.

8      13:33:29.058 05/04/10 Sev=Info/6    IPSEC/0×6370001F

TCP SYN sent to 0.0.0.0, src port 1076, dst port 443

9      13:33:29.058 05/04/10 Sev=Info/6    IPSEC/0×6370001C

TCP SYN-ACK received from 0.0.0.0, src port 443, dst port 1076

10     13:33:29.058 05/04/10 Sev=Info/6    IPSEC/0×63700020

TCP ACK sent to 0.0.0.0, src port 1076, dst port 443

11     13:33:34.558 05/04/10 Sev=Info/6    IPSEC/0×6370001D

TCP RST received from 0.0.0.0, src port 443, dst port 1076

12     13:33:34.558 05/04/10 Sev=Info/6    IPSEC/0×6370001F

TCP SYN sent to 0.0.0.0, src port 1076, dst port 443

13     13:33:40.058 05/04/10 Sev=Info/6    IPSEC/0×6370001F

TCP SYN sent to 0.0.0.0, src port 1076, dst port 443

14     13:33:44.074 05/04/10 Sev=Info/6    IPSEC/0×6370001F

TCP SYN sent to 0.0.0.0, src port 1076, dst port 443

15     13:33:49.074 05/04/10 Sev=Info/4    CM/0×6310002A

Unable to establish TCP connection on port 443 with server "0.0.0.0"

After analyzing what was installed and what was changed it was clear that the SP3 update causes the error. I’ve checked the version of my VPN client which was 4.0.3. According to the information in the internet this version of Cisco VPN client has problems with SP2. Well, I had SP2 and it worked fine but with SP3 it doesn’t. In Microsoft support has an article that says about problems with SP2. I replaced Cisco VPN client 4.0.3 with version 5.0.0 and it works fine now.

Convert file extension to MIME type - extended

ganton — Fri, 23 Apr 2010 15:23:00 +0000

In my last post I wrote a sample class that converts file extension to MIME type. Is it obvious that in many cases it is much better to have configurable list of mappings. For instance, you may have a configurable “white list” of file extensions that your web application allow to be uploaded and then downloaded. In this case to have a configurable mapping information will be very useful. I’ve changed the FileExtensionConverter from my previous post in a way to use configurable set of mappings. The updated version is below.

public class FileExtensionConverter
{
    private IDictionary<string, string> extensionMimeTypeMapping;
    private string defaultMimeType;
  
    public FileExtensionConverter(IMimeTypeMappingReader reader)
    {
        ParametersGuard.NotNull("reader", reader);
        reader.Load(out extensionMimeTypeMapping, out defaultMimeType);
    }
  
    public string ToMIMEType(string extension)
    {
        if (extension == null || extension.Length == 0)
        {
            return defaultMimeType;
        }
  
        string lowerExtension = extension.ToLower();
        string mime;
        if (!extensionMimeTypeMapping.TryGetValue(lowerExtension, out mime))
        {
            mime = defaultMimeType;
        }
  
        return mime;
    }
}

The main difference is that it now requires a reader to be provided to its constructor. This reader is a class that allows us to abstract the reading\parsing part from the converter class and this way we can use different implementations of the reader for reading data from plain text file, XML or database.

public interface IMimeTypeMappingReader
{
    void Load(out IDictionary<string, string> mapping, out string defaultMIMEType);
}

This interface consists of only one method that reads/parses mapping information. I’ve created an implementation for this interface that works with an XML file like those below.

xml version="1.0" encoding="utf-8" ?>
<root>
  <default>
    <mime>application/octet-streammime>
  default>
  <mapping>
    <extension>txtextension>
    <mime>text/plainmime>
  mapping>
  <mapping>
    <extension>rtfextension>
    <mime>text/richtextmime>
  mapping>
  <mapping>
    <extension>wavextension>
    <mime>audio/wavmime>
  mapping>
  <mapping>
    <extension>gifextension>
    <mime>image/gifmime>
  mapping>
  <mapping>
    <extension>jpegextension>
    <mime>image/jpegmime>
  mapping>
  <mapping>
    <extension>pngextension>
    <mime>image/pngmime>
  mapping>
  <mapping>
    <extension>tiffextension>
    <mime>image/tiffmime>
  mapping>
  <mapping>
    <extension>bmpextension>
    <mime>image/bmpmime>
  mapping>
  <mapping>
    <extension>aviextension>
    <mime>video/avimime>
  mapping>
  <mapping>
    <extension>mpegextension>
    <mime>video/mpegmime>
  mapping>
  <mapping>
    <extension>pdfextension>
    <mime>application/pdfmime>
  mapping>
  <mapping>
    <extension>docextension>
    <mime>application/mswordmime>
  mapping>
  <mapping>
    <extension>dotextension>
    <mime>application/mswordmime>
  mapping>
  <mapping>
    <extension>docxextension>
    <mime>application/vnd.openxmlformats-officedocument.wordprocessingml.documentmime>
  mapping>
  <mapping>
    <extension>dotxextension>
    <mime>application/vnd.openxmlformats-officedocument.wordprocessingml.templatemime>
  mapping>
  <mapping>
    <extension>xlsextension>
    <mime>application/vnd.ms-excelmime>
  mapping>
  <mapping>
    <extension>xltextension>
    <mime>application/vnd.ms-excelmime>
  mapping>
  <mapping>
    <extension>csvextension>
    <mime>application/vnd.ms-excelmime>
  mapping>
  <mapping>
    <extension>xlsxextension>
    <mime>application/vnd.openxmlformats-officedocument.spreadsheetml.sheetmime>
  mapping>
  <mapping>
    <extension>xltxextension>
    <mime>application/vnd.openxmlformats-officedocument.spreadsheetml.templatemime>
  mapping>
  <mapping>
    <extension>pptextension>
    <mime>application/vnd.ms-powerpointmime>
  mapping>
  <mapping>
    <extension>potextension>
    <mime>application/vnd.ms-powerpointmime>
  mapping>
  <mapping>
    <extension>pptxextension>
    <mime>application/vnd.openxmlformats-officedocument.presentationml.presentationmime>
  mapping>
  <mapping>
    <extension>potxextension>
    <mime>application/vnd.openxmlformats-officedocument.presentationml.templatemime>
  mapping>
root>

Below is the implementation of IMimeTypeMappingReader for the XML file.

public class XmlMimeTypeMappingReader : IMimeTypeMappingReader
{
    private string fileContent;
  
    public XmlMimeTypeMappingReader(IFileReadWriter readWriter, string filePath)
    {
        ParametersGuard.NotNull("readWriter", readWriter);
        ParametersGuard.NotNullOrEmpty("filePath", filePath);
  
        fileContent = readWriter.ReadAllText(filePath);
        if (fileContent.Length == 0)
        {
            throw new ApplicationException("The file is empty. File - " + filePath);
        }
    }
  
    public void Load(out IDictionary<string, string> mapping, out string defaultMimeType)
    {
        mapping = new Dictionary<string, string>();
        defaultMimeType = "application/octet-stream";
        string mimeElementName = "mime";
        string extensionElementName = "extension";
  
        XDocument document = XDocument.Parse(fileContent);
  
        XElement defaultElement = document.Root.Element("default");
        XElement mimeElement;
        if (defaultElement != null)
        {
            mimeElement = defaultElement.Element(mimeElementName);
            if (mimeElement.Value.Length != 0)
            {
                defaultMimeType = mimeElement.Value;
            }
        }
  
        XElement extensionElement;
        foreach (XElement element in document.Root.Elements("mapping"))
        {
            mimeElement = element.Element(mimeElementName);
            extensionElement = element.Element(extensionElementName);
            if (mimeElement.Value.Length == 0 || extensionElement.Value.Length == 0)
            {
                throw new ApplicationException("Invalid mapping data. Mime type or extension is not specified.");
            }
  
            mapping.Add(extensionElement.Value, mimeElement.Value);
        }
    }
}

You may notice that the constructor of this class requires an implementation of IFileReadWriter. it is required in order to abstract the actual file read from file system from the reader. In other words, it should be a wrapper around file operations. It will allow us to abstract from these operations and to unit test our implementations without accessing the file system. I think it is good for this sample to also provide to you the test classes for FileExtensionConverter and XmlMimetypeMappingReader. For the unit testing NUnit and Rhino.Mocks libraries are used.

FileExtensionConverterTestFixture:

[TestFixture]
public class FileExtensionConverterTestFixture
{
    [Test]
    [TestCase(null, "application/octet-stream")]
    [TestCase("", "application/octet-stream")]
    [TestCase("exe", "application/octet-stream")]
    [TestCase("txt", "text/plain")]
    public void ToMIMETypeTest(string extension, string expectedResult)
    {
        MockRepository mockRepository = new MockRepository();
        IMimeTypeMappingReader reader = mockRepository.StrictMock();
        IDictionary<string, string> mapping = new Dictionary<string, string> 
        {
            { "txt", "text/plain" }
        };
        string defaultMimeType = "application/octet-stream";
        Expect.Call(delegate { reader.Load(out mapping, out defaultMimeType); }).OutRef(mapping, defaultMimeType);
        mockRepository.ReplayAll();
  
        FileExtensionConverter converter = new FileExtensionConverter(reader);
        string result = converter.ToMIMEType(extension);
  
        mockRepository.VerifyAll();
  
        Assert.AreEqual(expectedResult, result);
    }
}

And XmlMimetypeMappingReaderTestFixture:

[TestFixture]
public class XmlMimeTypeMappingReaderTestFixture
{
    [Test]
    [TestCase(false, null, ExpectedException = typeof(ArgumentNullException))]
    [TestCase(true, "", ExpectedException = typeof(ArgumentOutOfRangeException))]
    [TestCase(true, "path\\file.xml", ExpectedException = typeof(ApplicationException))]
    public void ConstructorErrorsTest(bool initialize, string path)
    {
        IFileReadWriter fileReadWriter = null;
        MockRepository mockRepository = new MockRepository();
        if (initialize)
        {                
            fileReadWriter = mockRepository.StrictMock();
            Expect.Call(fileReadWriter.ReadAllText(path)).Return(string.Empty);
        }
  
        mockRepository.ReplayAll();
  
        XmlMimeTypeMappingReader xmlReader = new XmlMimeTypeMappingReader(fileReadWriter, path);
    }
  
    [Test]
    public void ConstructorTest()
    {
        string path = "path//file.xml";
        MockRepository mockRepository = new MockRepository();
        IFileReadWriter fileReadWriter = mockRepository.StrictMock();
        Expect.Call(fileReadWriter.ReadAllText(path)).Return("test");
        mockRepository.ReplayAll();
  
        XmlMimeTypeMappingReader xmlReader = new XmlMimeTypeMappingReader(fileReadWriter, path);
  
        mockRepository.VerifyAll();
    }
  
    [Test]
    [TestCase("text/plain", ExpectedException = typeof(ApplicationException))]
    [TestCase("txt", ExpectedException = typeof(ApplicationException))]
    [TestCase("txttext/plain")]
    [TestCase("application/octet-streamtxttext/plain")]
    public void LoadTest(string xml)
    {
        string path = "path//file.xml";
        MockRepository mockRepository = new MockRepository();
        IFileReadWriter fileReadWriter = mockRepository.StrictMock();
        Expect.Call(fileReadWriter.ReadAllText(path)).Return(xml);
        mockRepository.ReplayAll();
  
        XmlMimeTypeMappingReader xmlReader = new XmlMimeTypeMappingReader(fileReadWriter, path);
        IDictionary<string, string> mapping;
        string defaultMimeType;
        xmlReader.Load(out mapping, out defaultMimeType);
  
        mockRepository.VerifyAll();
  
        Assert.AreEqual("application/octet-stream", defaultMimeType);
        Assert.AreEqual(1, mapping.Count);
        Assert.AreEqual("text/plain", mapping["txt"]);
    }
}

That’s it. Have fun!

Convert file extension to MIME type

ganton — Thu, 22 Apr 2010 15:28:58 +0000

Sometimes in a web application you need to upload files to the server and then download them to the client. To send a file to the client for downloading we need to specify a MIME type into the response content type parameter. This way we provide an information to the client browser what is the type content type of the output stream. In the application that I work at the moment we need to upload different file types and then to allow the end-user to download them. For this purpose I created a class that converts file extension to a MIME type. I used two sources for information about file extensions and the corresponding MIME type – MIME Type Detection in Internet Explorer and Office 2007 File Format MIME Types for HTTP Content Streaming.

public static class FileExtensionConverter
{
    private static IDictionary<string, string> extensionMIMETypeMapping;
    private static string defaultMIMEType = "application/octet-stream";
  
    static FileExtensionConverter()
    {
        extensionMIMETypeMapping = new Dictionary<string, string>()
        {
            { "txt", "text/plain" },
            { "rtf", "text/richtext" },
            { "wav", "audio/wav" },
            { "gif", "image/gif" },
            { "jpeg", "image/jpeg" },
            { "png", "image/png" },
            { "tiff", "image/tiff" },
            { "bmp", "image/bmp" },
            { "avi", "video/avi" },
            { "mpeg", "video/mpeg" },
            { "pdf", "application/pdf" },
            { "doc", "application/msword" },
            { "dot", "application/msword" },
            { "docx", "application/vnd.openxmlformats-officedocument.wordprocessingml.document" },
            { "dotx", "application/vnd.openxmlformats-officedocument.wordprocessingml.template" },
            { "xls", "application/vnd.ms-excel" },
            { "xlt", "application/vnd.ms-excel" },
            { "csv", "application/vnd.ms-excel" },
            { "xlsx", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" },
            { "xltx", "application/vnd.openxmlformats-officedocument.spreadsheetml.template" },
            { "ppt", "application/vnd.ms-powerpoint" },
            { "pot", "application/vnd.ms-powerpoint" },
            { "pptx", "application/vnd.openxmlformats-officedocument.presentationml.presentation" },
            { "potx", "application/vnd.openxmlformats-officedocument.presentationml.template" }
        };
    }
  
    public static string ToMIMEType(string extension)
    {
        if (extension == null || extension.Length == 0)
        {
            return defaultMIMEType;
        }
  
        string lowerExtension = extension.ToLower();
        string mime;
        if (!extensionMIMETypeMapping.TryGetValue(lowerExtension, out mime))
        {
            mime = defaultMIMEType;
        }
  
        return mime;
    }
}

You can see that it is not a rocket science but I thought that it may be useful to have it ready and to write it from scratch. In this class a dictionary is used to store the mapping and it is initialized in a static constructor with hard coded mapping information. For sure, a better solution is to store this information outside of the application in a store such as a database table or xml file or even a simple plain text file. If the type is not in the mapping it returns a default mapping that is “application/octet-stream”.