Best way to future proof software that opens files with default application interactively

Question

I have created a VB .NET application that opens files in their default application - extracts information and returns it to a listview on a form.

All of the code is in my main form. The main form has in it

• Imports Microsoft.Office.Core
• Imports Microsoft.Office.Interop.Word
• Imports Microsoft.Office.Interop.Excel

If in the future I want to modify my software to include another filetype not thought of in this release, am I better off for all of the filetypes I wish to open (including office) adding new classes for each filetype and including the 'Imports' in the individual classes?

So for example I would have:

• OpenFileDWG.vb

• Imports Autodesk.AutoCAD.Runtime

• OpenFileDOC.vb

• Imports Microsoft.Office.Interop.Word

etc. etc. Is this a standard approach? If I were to do this, could I use:

If exists LCase(My.Computer.FileSystem.GetFileInfo(Filepath).Extension) THEN strFileOpener = OpenFileDWG & Extension Private fileOpener As strFileOpener

Would this approach work, or would I still need to reference the .dll in the main application, making this approach unworthy?

If I were to use this approach, could I just give the .vb file as part of an update?

Any advice is much appreciated.

Answer 1

Seems to me like a classing case to use factory design pattern

Basically, the factory design pattern provides loose coupling between the factory created classes and the class that uses them.

Begin by separating the different file types to different classes, and have them all inherit a basic abstract class (MustInherit in vb.net).
Then create an factory class to create create the concrete implementation of every file reader class. (meaning for each file type).

I'll try to illustrate with a simple example:

'' Defines an abstract class that all FileReaders should inherit
Public MustInherit Class FileReader
   Public MustOverride Function ReadFileContent(Path As String) As String
End Class

Now, all of the classes for reading files must inherit the FileReader class:

Public Class WordFileReader
   Inherits FileReader

   Public Override Function ReadFileContent(Path As String) As String
   '' TODO: Add code to read the content of the word document and return it as a string.
   End Function
End Class

Public Class ExcelFileReader
   Inherits FileReader

   Public Override Function ReadFileContent(Path As String) As String
   '' TODO: Add code to read the content of the excel file and return it as a string.
   End Function
End Class

Then you can use a simple factory method (read here to learn about the difference between factory methods and abstract factories) to create your classes:

Enum FileTypes
    Word,
    Excel
End Enum

Public Function GetFileReader(FileType As FileTypes) As FileReader
    Dim FileReader as FileReader = Nothing
    Select case FileType
        Case FileTypes.Word:
            FileReader = New WordFileReader()
        Case FileTypes.Excel:
            FileReader = New ExcelFileReader()
    End Select
    Return FileReader 
End Function

To enable new file types add-ins you can use MEF to load the concrete classes.