DataBatrix » .NET 2.0

.NET Serialization: Binary, SOAP, and XML (VB)

Eric — Thu, 08 Oct 2009 23:43:50 +0000

In .NET when you need to shrink an object into a more portable format you have 3 choices. Binary, SOAP, or XML. The process of shrinking and expanding the object is called serialization and deserialization. Each option has it’s own advantages which I will explain.

Binary

You can serialize an object into binary format quite easily using the .NET Framework. This is the quickest and smallest way to serialize; however, the binary format can only be deserialized using the same .NET Framework. This may be a problem for interoperability. It must be noted that this format will serialize Public and Private members (unlike XML serialization).

The example below shows how to serialize an object called “newCustomer”:

        Dim newCustomer As Contact = GetSampleContact()

        Using fs As New IO.FileStream(filePathandName & ".bin", IO.FileMode.Create)
            Dim binFormatter As New Runtime.Serialization.Formatters.Binary.BinaryFormatter()
            binFormatter.Serialize(fs, newCustomer)
        End Using

And here is the reverse to deserialize:

        Dim readCustomer As Contact

        Using fs As New IO.FileStream(filePathandName & ".bin", IO.FileMode.Open, IO.FileAccess.Read)
            Dim binFormatter As New Runtime.Serialization.Formatters.Binary.BinaryFormatter()
            readCustomer = CType(binFormatter.Deserialize(fs), Contact)
        End Using

SOAP

SOAP is another method. This is similar to the binary method except the serialized data is stored in a standardized form (SOAP) which will easily allow interoperability. Public and Private members are serialized using this method as well.
To serialize:

        Dim newCustomer As Contact = GetSampleContact()
        Using fs As New IO.FileStream(filePathandName & "SOAP.xml", IO.FileMode.Create)
            Dim soapFormattter As New Runtime.Serialization.Formatters.Soap.SoapFormatter()
            soapFormattter.Serialize(fs, newCustomer)
        End Using

And to deserialize:

        Dim readCustomer As Contact
        Using fs As New IO.FileStream(filePathandName & "SOAP.xml", IO.FileMode.Open, IO.FileAccess.Read)
            Dim soapFormattter As New Runtime.Serialization.Formatters.Soap.SoapFormatter()
            readCustomer = CType(soapFormattter.Deserialize(fs), Contact)
        End Using

XML

A third choice is using the XMLSerializer class. This method will only serialize Public properties and members and the object must be marked with the Serializable attribute and contain an empty constructor. This method of serialization will be smaller in size than the SOAP method since less information is serialized. Here is an example of such class:

      Class Contact

        Private _FirstName As String
        Public Property FirstName() As String
            Get
                Return _FirstName
            End Get
            Set(ByVal value As String)
                _FirstName = value
            End Set
        End Property

        Private _LastName As String
        Public Property LastName() As String
            Get
                Return _LastName
            End Get
            Set(ByVal value As String)
                _LastName = value
            End Set
        End Property

        Private _MiddleI As String
        Public Property MiddleI() As String
            Get
                Return _MiddleI
            End Get
            Set(ByVal value As String)
                _MiddleI = value
            End Set
        End Property

        Private _PIN As String
        Public WriteOnly Property PIN() As String
            Set(ByVal value As String)
                _PIN = value
            End Set
        End Property

        Sub New()

        End Sub

        Sub New(ByVal fName As String, ByVal middleI As String, ByVal lName As String, ByVal p As String)
            _FirstName = fName
            _MiddleI = middleI
            _LastName = lName
            _PIN = p
        End Sub
    End Class

Here is how you would serialize using the XMLSerializer:

        Dim newCustomer As Contact = GetSampleContact()
        Using fs As New IO.FileStream(filePathandName & ".xml", IO.FileMode.Create)
            Dim xmlFormatter As New Xml.Serialization.XmlSerializer(GetType(Contact))
            xmlFormatter.Serialize(fs, newCustomer)
        End Using

And to deserialize:

        Dim readCustomer As Contact
        Using fs As New IO.FileStream(filePathandName & ".xml", IO.FileMode.Open, IO.FileAccess.Read)
            Dim xmlFormatter As New Xml.Serialization.XmlSerializer(GetType(Contact))
            readCustomer = CType(xmlFormatter.Deserialize(fs), Contact)
        End Using

You can download a sample serialization demo project that I created to demonstrate: SerializationDemoProject.zip.

JobTime: Time Clock Web Application And Job Cost Tracking

Eric — Sat, 05 Sep 2009 13:18:06 +0000

Background

The company needed to track time logged to particular jobs/projects. The initial idea was to use a site like ClickTime. However, for an employee to log time against a job, you would need to tell ClickTime all of your jobs (which would be tedious) or configure an integration app to automatically populate the available jobs/projects.

Solution

I created a web application that would allow employees to log time against jobs/projects. It would search instantly against their project management software for a list of available jobs. The type of work was categorized for reporting. Since we would have the employee’s hours, it would be used for payroll. I implemented an export feature for preparing the payroll information for ADP and EDH. Work time for each project was then entered into the project management software to be calculated as job cost. As a bonus, you could use the gathered data to calculate each employees “utilization”.

Landing page.	Enter time for a particular project/job.
Apply costs to each job.	Payroll export options.
Utilization

Automatic Email Alerts From Any SQL Query

Eric — Wed, 02 Sep 2009 13:24:40 +0000

Problem

Reminder emails were needed to be sent out to remind sales staff to follow up on projects.

Solution

I developed a simple command line executable that takes 1 parameter which is an XML file. The contents of the XML file would look something like:



	
		email@gmail.com
	
	
		email@gmail.com
	
	
		SELECT * FROM Projects
		WHERE Cancelled = 0 And Completed = 0 AND BookDate IS NULL
		AND FollowUpBy <= getdate()
	
	Server=SQLServer;Database=MainDatabase;Persist Security Info=True;Integrated Security=true
	EmailTemplate.txt
	Alert Email For Project#<:ProjectID:>
	mycompany.com
	Salesperson
	0
	
		smtp.gmail.com
		1
		1
		email@gmail.com
		*******
		587
		email@gmail.com
	
	Daily

The command line executable would then run the query () against the supplied database in the XML file. For each row returned, the program will send out an email to the user. Which user? What email? The recipients email address would need to be one of the fields returned from the query and noted in the XML file in the element . The template for the email body is supplied by the element. To make the email custom, it is possible to insert fields returned from the database into the email template. For example, lets say the query returned a field called “FirstName”. In the email template text file, you could have:

Hello <:FirstName:>,

When the program ran, it would swap “<:FirstName:>” with the contents from the database. This is similar to a mail merge for emails. Since all of the values are configurable in the XML file, the usage possibilities are unlimited! Let say you needed to run this once a week, no problem. Set up a Windows Scheduled Task to run the executable at the specified interval.

A .NET Bit.ly API Helper Class (Visual Basic.NET)

Eric — Mon, 24 Aug 2009 21:19:19 +0000

I decided to write a helper class for using the Bit.ly API for creating short urls. You know, those tiny links that you see all over Facebook, Twitter, etc. The snippet below shows how you would use the helper class. Not only can you shorten an url, you can shorted multiple urls in a single call as well as get stats and info about a bit.ly url. If you are looking to incorporate bit.ly short urls in your application using their API access, this will save you some time. The class uses the XmlSerializer for reading bit.ly’s response.

        ' Pass username and API key to instantiate
        Dim newbitlyAPI As New DataBatrix.bitlyAPI.bitlyAPI("bitlyapidemo", "R_0da49e0a9118ff35f52f629d2d71bf07")

        ' Sample of creating 1 short URL
        Dim shortenResponse As DataBatrix.bitlyAPI.bitlyShortenResponse = newbitlyAPI.Shorten("http://www.databatrix.com")
        Dim shortURL As String = ""
        If shortenResponse.results.Count > 0 Then
            shortURL = shortenResponse.results(0).shortUrl
        End If

        ' Sample of creating multiple short URLs
        Dim longUrls() As String = {"http://www.databatrix.com", "http://www.google.com"}
        Dim shortenResponses As DataBatrix.bitlyAPI.bitlyShortenResponse = newbitlyAPI.Shorten(longUrls)
        Dim shortURLs(1) As String
        For i As Integer = 0 To shortenResponses.results.Count - 1
            shortURLs(i) = shortenResponses.results(i).shortUrl

        Next

        ' Sample of getting bit.ly info...
        Dim info As DataBatrix.bitlyAPI.bitlyInfoResponse = newbitlyAPI.Info("2bYgqR")

        ' Sample of getting bit.ly stats...
        Dim stats As DataBatrix.bitlyAPI.bitlyStatsResponse = newbitlyAPI.Stats("http://bit.ly/1RmnUT")

Below is the helper class that I created. You can download the VB file bitlyAPI.vb or a sample project TestBitly Project Files.

Imports System.Web
Imports System.Xml
Imports System.Xml.Serialization

Namespace DataBatrix.bitlyAPI
    Public Class bitlyAPI
        Const BaseAPIUrl As String = "http://api.bit.ly/"
        Const version As String = "2.0.1"
        Const format As String = "xml"

        Public login As String = String.Empty
        Public apiKey As String = String.Empty

        Sub New(ByVal login As String, ByVal apiKey As String)
            Me.login = login
            Me.apiKey = apiKey

        End Sub

        Private Function BuildBaseRequestURL(ByVal applicationName As String) As System.Text.StringBuilder
            Dim RequestUrl As New System.Text.StringBuilder()
            With RequestUrl
                .Append(BaseAPIUrl & HttpUtility.UrlEncode(applicationName) & "?")
                .Append("version=" & HttpUtility.UrlEncode(version) & "&")
                .Append("format=" & HttpUtility.UrlEncode(format) & "&")
                .Append("login=" & HttpUtility.UrlEncode(login) & "&")
                .Append("apiKey=" & HttpUtility.UrlEncode(apiKey) & "&")
            End With
            Return RequestUrl
        End Function

        Public Function Shorten(ByVal longUrl As String) As bitlyShortenResponse
            Dim logUrls() As String = {longUrl}
            Return Shorten(logUrls)
        End Function

        Public Function Shorten(ByVal longUrl() As String) As bitlyShortenResponse
            Dim RequestUrl As System.Text.StringBuilder = BuildBaseRequestURL("shorten")
            For Each s As String In longUrl
                RequestUrl.Append("&longUrl=" & HttpUtility.UrlEncode(s))

            Next
            Dim responseObj As DataBatrix.bitlyAPI.bitlyShortenResponse = Nothing
            Try
                Dim serializer = New XmlSerializer(GetType(DataBatrix.bitlyAPI.bitlyShortenResponse))
                Using reader As XmlTextReader = New XmlTextReader(RequestUrl.ToString())
                    responseObj = CType(serializer.Deserialize(reader), DataBatrix.bitlyAPI.bitlyShortenResponse)
                End Using

            Catch ex As Exception

            End Try

            If responseObj.errorCode > 0 Then
                Throw New ApplicationException("Error from bit.ly: " & responseObj.errorMessage)
            End If
            Return responseObj
        End Function
        Public Function Info(ByVal hash As String) As bitlyInfoResponse
            Dim RequestUrl As System.Text.StringBuilder = BuildBaseRequestURL("info")
            With RequestUrl
                .Append("hash=" & HttpUtility.UrlEncode(hash))
            End With

            Dim responseObj As DataBatrix.bitlyAPI.bitlyInfoResponse = Nothing
            Try
                Dim serializer = New XmlSerializer(GetType(DataBatrix.bitlyAPI.bitlyInfoResponse))
                Using reader As XmlTextReader = New XmlTextReader(RequestUrl.ToString())
                    responseObj = CType(serializer.Deserialize(reader), DataBatrix.bitlyAPI.bitlyInfoResponse)
                End Using

            Catch ex As Exception
                Throw New ApplicationException("API Error: " & ex.Message)
            End Try
            If responseObj.errorCode > 0 Then
                Throw New ApplicationException("Error from bit.ly: " & responseObj.errorMessage)
            End If
            Return responseObj
        End Function

        Public Function Stats(ByVal shortUrl As String) As bitlyStatsResponse
            Dim RequestUrl As System.Text.StringBuilder = BuildBaseRequestURL("stats")
            With RequestUrl
                .Append("shortUrl=" & HttpUtility.UrlEncode(shortUrl))

            End With

            Dim responseObj As DataBatrix.bitlyAPI.bitlyStatsResponse = Nothing
            Try
                Dim serializer = New XmlSerializer(GetType(DataBatrix.bitlyAPI.bitlyStatsResponse))
                Using reader As XmlTextReader = New XmlTextReader(RequestUrl.ToString())
                    responseObj = CType(serializer.Deserialize(reader), DataBatrix.bitlyAPI.bitlyStatsResponse)
                End Using

            Catch ex As Exception
                Throw New ApplicationException("API Error: " & ex.Message)
            End Try
            If responseObj.errorCode > 0 Then
                Throw New ApplicationException("Error from bit.ly: " & responseObj.errorMessage)
            End If
            Return responseObj
        End Function

    End Class

    Public MustInherit Class bitlyResponseBase
         _
        Public errorCode As Integer = 0

         _
        Public errorMessage As String = String.Empty

         _
        Public statusCode As String = String.Empty

    End Class

     _
    Public Class bitlyShortenResponse
        Inherits bitlyResponseBase

         _
        Public results As New List(Of KeyVal)

        Public Class KeyVal
             _
             Public userHash As String

             _
             Public shortKeywordUrl As String

             _
             Public hash As String

             _
             Public longUrl As String

             _
             Public shortUrl As String

        End Class
    End Class

     _
    Public Class bitlyInfoResponse
        Inherits bitlyResponseBase

         _
        Public results As New List(Of bitlyInfoResultItem)

        Public Class bitlyInfoResultItem
             _
            Public shortenedByUser As String
             _
            Public keywords As String
             _
            Public hash As String
             _
            Public exif As String
             _
            Public surbl As String
             _
            Public contentLength As String
             _
            Public id3 As String
             _
            Public calais As String
             _
            Public longUrl As String
             _
            Public version As String
             _
            Public htmlMetaDescription As String
             _
            Public htmlMetaKeywords As String
             _
            Public calaisId As String
             _
            Public thumbnail As thumbnailObj
             _
            Public contentType As String
             _
            Public users As List(Of String)
             _
            Public globalHash As String
             _
            Public htmlTitle As String
             _
            Public metacarta As String
             _
            Public mirrorUrl As String
             _
            Public keyword As String
             _
            Public calaisResolutions As String
             _
            Public userHash As String

            Public Class thumbnailObj
                 _
                Public large As String
                 _
                Public small As String
                 _
                Public medium As String
            End Class

        End Class
    End Class

     _
Public Class bitlyStatsResponse
        Inherits bitlyResponseBase

         _
        Public hash As String
         _
        Public clicks As String

        Public Class bitlyStatsResultItem
             _
            Public None As String
             _
            Public direct As String
             _
            Public nodeKeyValue As List(Of KeyValue)
             _
            Public nodeKey As String

            Public Class KeyValue
                 _
            Public nodeValue As String
                 _
                Public nodeKey As String
            End Class
        End Class
    End Class

End Namespace

Custom Replace with Regular Expressions in .NET

Eric — Thu, 20 Aug 2009 19:05:34 +0000

This is the second time I have had to do something like this. So this time I am posting it for my reference. Regular expressions are amazing and amazingly difficult to understand sometimes, but they come in very handy. I was in a situation where I was going to need to feed in a custom template to be used similar to a “mail merge” situation. I would query a database, then for each record I would fill out an email using an email template. I decided to go with <:FieldName:> as the nomenclature of how a field would be inserted. For example, here are the query results:

FirstName	LastName	Company
Eric	Bridges	DataBatrix

My email template may look something like this:

Dear <:FirstName:> <:LastName:>,

You work for <:Company:>!

For the purpose of my project, I did not know what fields were going to be returned or what the email template looked like. I needed a simple way to replace all of the field placeholders with actual data. Regular expressions to the rescue! You can use a delegate to run your own replace function. I called my method MatchHandler which is passed a Match variable (the match that is found). In my example below, I replaced it with the corresponding item from _reader (my sqldatareader row).

    Private Function MatchHandler(ByVal m As Match) As String
        Dim fieldName As String = m.Groups("fieldName").ToString()
        If HasField(fieldName) Then
            Return _reader(fieldName)
        Else
            Return m.ToString()
        End If
    End Function

Next we have to create our delegate. Delegates are basically pointers for methods (functions/subs). I called my delegate “MatchDelegate” and pass it the address of my function I created above.

    Dim MatchDelegate As New MatchEvaluator(AddressOf MatchHandler)

Now to make it work! Define your regular expression pattern and instantiate a new RegularExpression object. Use the Replace method and pass the string to search and the delegate that we created.

    Private Function MergeFields(ByVal body As String) As String
        Dim returnValue As String = ""
        Dim pattern As String = "<:(?(.+?)):>"
        Dim regex As New Text.RegularExpressions.Regex(pattern)
        returnValue = regex.Replace(body, MatchDelegate)
        Return returnValue
    End Function

That’s it! Now you can do whatever you like when a match is found in your Replace method.

In case you were wondering what “(?(.+?))” in the pattern was all about, check out this link talking about regular expression groups.

Outlook Signature

Eric — Tue, 18 Aug 2009 00:53:25 +0000

Background:

My company wanted to standardize the email signature for all of the employees. The signature was to contain images and links.

Problem:

Creating a signature in Microsoft Outlook that contains images and links is not the easiest thing in the world. Not to mention having everyone in the company try to create their own, they would never end up being standardized and turn into a nightmare for training.

Solution:

The solution was to create a simple desktop application that helps the user create their Outlook signature. The basic template for the signature would originate from a central location so that updates would be easy. The email signature also contains a header that is placed at the top of the email.

Result:

Fig. 1

Fig. 2

I created a simple desktop application that allows the user to enter their specific signature details (Fig. 1). When you hit the “Create Signature” several things happen. First the email template is downloaded from a specified FTP site. I choose FTP so that the application would work when the user was at home connected to the Internet. Next the program inserts all of your specific info the template. Then it saves the signature files in the appropriate folders where signature and theme files are kept. Yes, THEME files too! Since my company wanted a header image at the top, I had to use a theme for the template. If I had kept everything as a signature it would always insert 3 lines at the top (that you would have to delete for every email) and spell check would not work (since Outlook does not spell check your signature). The final step the program does is set Outlook to use the new theme for new emails and the signature for all forwards and replies. Why not have the theme set for all emails and not even use a signature? Outlook only uses the theme for new emails…not sure why, but that’s the way it is (or was at the time). The program can be ran multiple times incase updates need to be made to the signature. (For example, we did a Happy Holidays theme that we ran for a few months.

Inventory Application

Eric — Tue, 18 Aug 2009 00:50:05 +0000

Background:

As for any company, physical inventory time is never fun. Our inventory software did not have a good interface for doing this.

Problem:

The process of taking physical inventory was long and tedious. The process typically involved printing our a huge list of parts, write in the quantity next to the part, then someone would enter that info in an Excel spreadsheet so that it could be imported back into our inventory software to reconcile. Another issue was finding the inventory items themselves, most items were organized well, but some could only be found by the "one guy" that knows where everything is located. Identification of parts and part numbers was needed.

Solution:

The solution was to create a desktop application that could be used to take physical inventory. The application would search against our existing parts database and store inventory quantities in a separate table that could later be reconciled. The application would also print out a part identification label on a thermal printer that was to be placed on the shelf of each item. This would make subsequent physical inventories much easier.

Result:

Fig. 1

Fig. 2

Fig. 3

I created a desktop application the keep track of inventory. The application also has the ability to print out part identification stickers on a thermal printer that included part information along with a barcode. Fig. 2 shows the part detail screen. You can find out various information from the Detail screen as well as adjust inventory levels. You can pull up a part by either searching by part number or scan the corresponding barcode the program had previously printed out.
The application was such a success, I created a web interface to allow certain other employees access to inventory levels. Also various reports were created that were needed Accounting purposes.

Desktop Tools

Eric — Mon, 17 Aug 2009 23:51:09 +0000

Background:

I created a single page web page that was set as the background using the Active Desktop function of Windows XP. This web page allowed you to search the employee database for phone numbers or extensions. It also had a section to calculate shipping for certain items my company sells.

Problem:

Active Desktop started messing up when laptop users would boot without a internet connection present. Also, since the web page was hosted on the company Intranet, a login dialog box would pop-up if IE was not configured properly which was confusing to some users.

Solution:

Rebuild the web page to not use Active Desktop, but still have the tools easily accessible. Having a bookmark to the web page was not considered "easily accessible".

Result:

Fig. 1

Fig. 2

Fig. 3

I decided to created a small application that runs in the system tray. Right-clicking the icon in the tray would expand a menu of available tools. Fig. 1 shows the menu and the employee search box that appears after clicking "People Finder". Certain menu items are shown/hidden depending on the user’s login. For example, my login shows 6 items, but "Support Ticket" and "Cams" are not show for others. Rights are stored in the SQL database and not in the application so allowing access is simple and does not require an application update. Since we are on the subject of databases…how should the application connect to it? I decided to not connect directly to the database since the user would have to be on the network or have their VPN connected, but instead indirectly by using web services. Using web services allowed the application to work as long as any Internet connection was present. If a connection was not present, the application hides menu items that require a connection or certain rights. I created a separate web site that hosted the web service application that basically would act as a proxy for my application.
Since I knew I would be updating the application as time went by, I wanted the application to be able to update itself. I accomplished this by using some of the "Click Once" features of Visual Studio. Instead of using the default settings, I handled the Click Once part programmatically so that I could force the update.
I added a "Sales Links" item that expands into a limitless list of links and sub-links. The links can be URLs, local folders, or anything that you can type into the Start>Run box! Users with permission can easily modify and add links. The application refreshes the links from the database every 30 minutes.
Lets talk security…
Since only a standard Internet connection is needed for the application to work, there were a couple of security concerns. The web service application was open to the public! That’s okay, lots of web service applications are open to the public…that’s kind of the point of them. I decided to use "keys" that had to be passed each time the application consumed a web service. In other words, a password (or key) is passed to the web service and every method (function) the web service has requires a password. What about updates? The application needs to look in a public place for updates. If its public then everyone could download the program. That’s okay too! I just had to put some security measures in place with the application is launched. Let’s just say that when the program starts it knows if it is suppose to be on that computer, if the check fails the application quits.