After some research, I determined that there is no 100% way to detect if file is binary or text. But I did find a solution that worked in all my tests. It is mentioned here:
http://stackoverflow.com/questions/910873/how-can-i-determine-if-a-file-is-binary-or-text-in-c

Here is the implementation of detecting 4 consecutive binary zeroes using C#:

	private bool IsBinaryFile(string filePath, int sampleSize = 10240)
	{
		if (!File.Exists(filePath))
			throw  new ArgumentException("File path is not valid", "filePath");

		var buffer = new char[sampleSize];
		string sampleContent;

		using (var sr = new StreamReader(filePath))
		{
			int length = sr.Read(buffer, 0, sampleSize);
			sampleContent = new string(buffer, 0, length);
		}

		//Look for 4 consecutive binary zeroes
		if (sampleContent.Contains("\0\0\0\0"))
			return true;

		return false;
	}

Default value of sample size is 10KB. I tried lowering it to 1KB, but then detection stopped working for some of the PDF files. So with 10KB limit you should be pretty safe.

I created a very simple sample application, so you can try this code out for yourself:

CLICK HERE TO DOWNLOAD SAMPLE EXE (Single file CheckBinaryFile.exe 11K)

Here is the code for Sample Application

CLICK HERE TO DOWNLOAD SAMPLE CODE (CheckBinaryFile.zip 16K)

I wanted to write a simple browser alert app which, as the name implies, alerts the browser when something occurs server side. I just want to show a little popup of sorts in the window alerting the user of whatever happened on the server. And, to take it a step further, I want to have the browser respond to something that occurs on a remote server using a WebHook.

Awesome! Let’s do it!

Two (big) problems:

1. This is going to take a lot of dev time to implement. Sure, browsers can support the protocol, but now we have to code the server side. This is low level stuff that involves managing connections. I don’t want to do this. After all, I’m a .NET programmer not a C++ programmer.

2. Not all browsers support it. More importantly, even when the latest browsers do all support it, we really can’t tell all our users to upgrade just so we can take advantage of this cool new technology.

Luckily, these two obstacles aren’t really obstacles. Someone already invented the wheel so we don’t have to. The wheels we will use are called Microsoft.WebSockets and SignalR.

ASP.NET 4.5 WebSocket Support

Running ASP.NET 4.5 on Windows 8 allows you to take advantage of the Microsoft.WebSockets library. This takes care of all the work necessary to manage WebSocket connections on the server side. There is a class called WebSocketHandler which you can inherit and simply override methods like OnOpen, OnClose, and OnMessage to handle requests. Clients are stored in a WebSocketCollection and completely managed. You need to do little more than inherit this class. I am not including an example of this because there are already a few excellent articles and samples. You need to run .NET 4.5 on IIS8 with the WebSocket feature enabled. You can learn all about it by watching Paul Batum’s wonderfully informative presentation and following his step by step instructions here: http://www.paulbatum.com/2011/09/getting-started-with-websockets-in.html.

So problem # 1 is solved as soon as we upgrade to Windows 8. But what about our users on old browsers. And what if we don’t yet have Windows 8. In terms of old browsers, generally the approach is to fallback to long polling when WebSockets are not supported. OK, we can long poll. But now we need to write a whole bunch of code to manage this.

SignalR

This is where SignalR comes in. SignalR is a set of .NET libraries that does all this and more. In a nutshell, SignalR lets you declare client side JavaScript methods which can be called server side, and server side C# methods that can be called from the browser. It uses WebSockets but gracefully falls back to long polling when it is not supported, so we don’t have to worry about our users using old browsers. There is a SignalR.WebSockets library which depends on Microsoft.WebSockets for use on Windows 8. You can install this library and SignalR will automatically use web sockets when it can. More Info

This is how you do it:

1. Create a new empty Web Application project.

2. Add SignalR to your project. Go to “Tools” –> “Library Package Manager” –> “Package Manager Console”. Simply type “Import-Package SignalR” at the command prompt and it will install all the libraries you need into your project. It will add compiled libraries as well as JavaScript files, including jQuery.

Now you’re ready to start coding. And there won’t be much of that!

Create a new server side class which inherits from SignalR’s “Hub” class. The SignalR framework will know that all classes derived from “Hub” should be exposed to the client side.

using SignalR.Hubs;
using System.Threading.Tasks;

 public class ChatHub : Hub
  {
        public Task Join()
        {
            // tells SignalR to call client side method "receiveAlertMessage" with these params
            return Clients.receiveAlertMessage (Context.ConnectionId + " joined the server");

       }
  }

The methods in this class will be available on the client side. So in JavaScript we can call the “Join” method. On the server side in this method, we will use the “Clients” object to reference all connected client browsers, and then we can call a client side method “receiveAlertMessage” on all of the browsers. All the browsers will have this method invoked and receive the data passed to it.

On the client side of things, you need to make some JavaScript references and create the connection.

These are the JavaScript libraries:

  <script src="Scripts/jquery-1.6.4.js" type="text/javascript"></script>
  <script src="Scripts/jquery.signalR.js" type="text/javascript"></script>
  <script src="/signalr/hubs" type="text/javascript"></script>

jQuery and the signalR.js will be installed with the signalR package. The signalr/hubs file does not actually exist on the server. It is a dynamically generated JavaScript file. You must include this line for signalR to work.

Once you have these scripts included, the browser can create a connection using $.connection.chatHub where “chatHub” is the name of your server side class inheriting from “Hub”. Once initiated, our connection is established and we can talk back and forth.

       $(function () {
            // Create proxy
            var chatHub = $.connection.chatHub;

           // Start the connection
            $.connection.hub.start();
        });

The object you created on the client, chatHub, is your proxy to the server. You can use it to call methods on the server. In this example the client won’t call the server, the server only calls the client to alert it when something happens.

To create a method on the client side to be called by the server, simply assign a function to the connection object you created, chatHub. Here I have a client side method called “receiveAlertMessage” which the server can call whenever it wants to tell the browser something.

Here is the client side code in its totality.

      $(function () {
            // Create proxy
            var chatHub = $.connection.chatHub;

            // Assign client side function to be called by the server
            chatHub.receiveAlertMessage = function (source, type, data) {
                closeAlert();
                $('<li/>').html(data).appendTo($('#alert-messages'));
                showAlert();
            };

            // Start the connection
            $.connection.hub.start(function () {
                // connection may take some time to initiate
                $('.loading').hide();
                $('.content').show();
            });
        });

To call this method from the server, simply use the following code anywhere in your application. This code gets all the clients and calls the client side method “receiveAlertMessage” with the specified parameters. The client side will do what it wants with this information. In our case it displays an alert to the user.

using SignalR.Infrastructure;
using SignalR.Configuration;
using SignalR.Hosting.AspNet;
using SignalR;
using System.Threading.Tasks;

var connectionManager = AspNetHost.DependencyResolver.Resolve<IConnectionManager>();
dynamic clients = connectionManager.GetClients<ChatHub>();
clients.receiveAlertMessage(source, type, data);

Taking it further with WebHooks

To take this a step further, the browser can respond to something that happens on a remote system by being a consumer of a WebHook. A WebHook provider is some system that will post data to a callback url you supply when something happens that you want to know about. As a WebHook consumer, upon receiving this data on your server, you can use SignalR to let the browser know.

In my sample app, there are two web applications called “RemoteServer” and “MySocketApp”. The “RemoteServer” application acts as a WebHook provider. When something happens on this server, it will tell all of the subscribed WebHook clients by sending an HTTP post request to the callback urls supplied by the these clients. “MySocketApp” contains a WCF service which serves as a callback url and listens for any data sent by the “RemoteServer”. When the service receives some data, it will use SignalR to alert the browser of the new data it received.

I will not go into more details about the WebHook implementation as it is described in detail in my last blog.

Demo

I created a poor quality screen cast so you know it works without opening the sln. Sorry, it is much more fun to play with the actual app and I will try to put one online. Here is the video: http://vimeo.com/39857434.

The video demonstrates FireFox, IE, and Chrome all responding to an event from a “RemoteServer” by showing an alert on the screen.

Download

VS2011 sln:
http://sarahleahwolfe.com/MySocketApp.zip

The solution contains two web projects, RemoteServer and MySocketApp.

To run the projects, run MySocketApp’s default.html in a browser. Then run RemoteServer’s CreateEvent.html in a browser. Enter some text into the form on this CreateEvent page. The text you enter will be posted to a callback url on MySocketApp. The callback url will use SignalR to then send this data to the browser and display it on the screen. You will see your text appear in the browser running MySocketApp’s default.html.

Note: This sample does not rely on Microsoft.WebSockets and can be ran in older versions of Windows. For it to use Microsoft.WebSockets on Windows 8, we need to install SignalR.WebSockets and we can not use Express IIS. More Info

Warning

While not difficult to prevent with some HTML encoding, the combination of WebHooks and pushing data to the browser is potentially a recipe to get your site hacked by JavaScript injection. Also, the issues of performance, server load, and how well signalR will scale are critical considerations.

Links

SignalR Hubs QuickStart ( Basically sums up my entire article )
https://github.com/SignalR/SignalR/wiki/QuickStart-Hubs/

SignalR
http://signalr.net/

Performance Tuning SignalR
https://github.com/SignalR/SignalR/wiki/Performance

Microsoft.WebSockets
http://nuget.org/packages/Microsoft.WebSockets

Paul Batum’s Samples and Presentation
http://www.paulbatum.com/2011/09/getting-started-with-websockets-in.html

WebSockets
http://www.websocket.org

WebHooks
http://wiki.webhooks.org/w/page/13385124/FrontPage

The new version contains several fixes and improvements.

Added Cancel button to cancel long running Find or Replace operations

Allow multiple File Masks

Previously you would need to either use “*.*” or run Replace multiple times, once for each file mask. This new feature allows you to specify multiple, comma delimited file masks to limit which files you would like to process.

Can exclude File Mask

In many cases it is a lot more efficient to explicitly exclude known binary files like *.exe, *.dll instead of having fnr.exe detect that they are binary.

Detect text file encoding

There was a bug in last release where fnr.exe would load a file with some foreign characters like ‘ç’ and ‘ã’, but wouldn’t detect the encoding of the file. When file with replacements was saved, some of these characters could have been replaced with ‘invalid’ chars.
This issue has been fixed and now fnr.exe supports all international files.

While testing this new feature on command line I discovered that batch files are not very good in dealing with characters above, passed in findText or replaceText. I found a good solution here:
http://stackoverflow.com/questions/1427796/batch-file-encoding. It worked great.

Persist form values in Registry

When user clicks Find or Replace button and validation passes – the application will save form values into registry, so when you open fnr.exe next time, the form values will be pre-filled with last valid state.

Download Link

You can download fnr.exe 1.1 from here:
http://findandreplace.codeplex.com

Windows Communication Foundation (WCF) is a framework that provides a runtime environment to expose and consume services.

A service is a unit of functionality exposed to the world. The client of a service consumes the functionality provides by the service.

Clients and services talk with each other by sending and receiving messages, usually SOAP, XML, or JSON messages.

WCF services communicate over transport schemes – HTTP/HTTPS, TCP, IPC, Peer network, MSMQ, Service bus.

WCF exposes metadata describing the available functionality and possible ways of communicating with the service.  Metadata is published in WSDL (Web Services Description Language) format.

Client always use proxy to forward calls to the service and never interacts with the service directly. All services expose contracts namely -

• Service Contracts: Describe what operation the client can perform on service
• Data Contracts: Define what data types are passed to and from the service
• Fault Contracts: Define errors raised by service and how the service handles and forwards the error to the client
• Message Contracts:  Allow the service to interact directly with message.

WCF service is hosted in a Windows process called host process. A single host process can host multiple services, and the same service type can be hosted in multiple host process.

WCF groups together sets of communication aspects called bindings. Binding is a set of choices regarding the transport protocol, message encoding, communication pattern, reliability, security, transaction propagation, and interoperability. Clients must use the exact same binding values as the service.

Every service is associated with an address that defines where the service is, a binding that defines how to communicate with the service, and a contract that defines what the service does. The fusion of the address, contract, and binding is the Endpoint.

Every service must expose at least one business endpoint, and each endpoint has exactly one contract. All endpoints on a service have unique address, and a single service can expose multiple endpoints.

A client needs to import the service contract to its native representation to invoke operation on a service.

History of WCF

• First release as part of .NET 3.0
• Second release as part of .NET 3.5
• Third release as part of .NET 4.0
• With addition of various new features as of .NET 4.5 beta

These are some basic concepts on WCF to help anyone get started.

Credit: Materials in the blog is derived from the book “Programming WCF Services, 3rd edition” by – Juval Löwy

It contains some major improvements and bug fixes that make fnr.exe the best free open source utility to do batch text replace. At this time it is the only utility that seamlessly supports both windows form as well as command line interface.

You can download release 1.0 from here:
http://findandreplace.codeplex.com

Here is a list of the features added in this release:

Preview Matches

Selecting a row in results grid will display a preview box highlighting all the occurrences of matching text

Stats

Recording and displaying the statistics related to the search, such as
Number of files processed, with matches, failes to open, etc..

The statistics in windows form are updated in real time as the search is happening.
When running find/replace on command line statistics are displayed at the end.

File errors for read/write

If file can’t be open for read or write, we indicate that in the results and statistics

Support for regular expressions

Added checkbox to allow finding text using regular expressions

Fixed a bug that required you to press enter to continue after running fnr.exe from command line

This issue made it difficult to include call to fnr.exe in batch files.

Context menu to display containing folder or open the file

Double click on results row to open the file (similar to double clicking in windows explorer)

Displaying results on command line has been changed from tabular view to the list.

It makes results much much more readable, without any messy word wrapping.

Binary detection – skip files that are binary

This detection is not 100%, so if possible it is better to use appropriate mask like “*.txt”, to limit files to text files.

Download Link

You can download fnr.exe 1.0 from here:
http://findandreplace.codeplex.com

100% bug free code

I used to work for a company that had a slogan “100% BUG FREE CODE” (all slogans must be in caps or they are not taken seriously).

It turned out that “100% bug free code” was easily achievable using one of the following approaches.

1. The application you are writing will never be released to actual users. As they say the only way to win is not to play.
2. By using code like this:

         try
         {
            //do something important, like
            SaveTheWorld();
         }
         catch
         {
             //do nothing.  The world is never saved, and no one knows why.
         }
   

   This one I have seen many times, sometimes in a scope of a single function, other times in scope of the whole application. In theory it solves the problem at hand very nicely. In reality it just sweeps exceptions under the rug and makes debugging, maintenance and customer support much much harder.

   If you know a developer who writes code like this, you are allowed to just walk over and punch (or spin kick) him in the liver. Then give him a look of “I pity the fool” and quickly run away before he recovers. You are only helping him to pay back for some of pain and suffering that he has and will cause.

3. Using unit testing and believing that 100% code coverage is the same as “100% bug free code’. I used to go to the church of unit testing every sunday and after chanting “Unit tests will result in 100% bug free code” about a 100 times it really did feel like all my bugs were just a bad dream (It was a nightmare with an actual huge insect running after me). The only problem was that as much as I would like to think that I can put myself into actual end user shoes (I do have special orthopedic shoes for that), that is 100% impossible. As soon as your application launches, your customers will generate all kinds of exceptions, some real and some only in the minds of the customers, but mostly real.

There are other lesser known approaches, like whenever there is an exception just redirect a customer to the latest “cute chipmunk” video on youtube. When customer sees those cute chipmanks any memories of what they were doing will be quickly forgotten.

That works really great the first several times, but you have to be really careful because in no time customer may be sending you error reports that YouTube videos are freezing.

Bug vs Unhandled Exception

Unhandled exceptions are only a subset of all the bugs you will encounter. Let’s say there is an error in calculating Order Total, where you forget to add the tax at the end. This is not going to result in exception, but it still a bug since original business requirement was not implemented. This type of bug is much harder to track since you may have to rely on customer to notice the issue and then report it to you with a bonus of some colorful language. On the other hand when unhandled exception is triggered – there are ways to setup your application to log it or send it to you by email. In this way you can buy yourself a little bit of time by diverting customer to a very informative page:

An internal system error has occurred. Support has been notified and is looking into the issue. Would you like to play a game of chess while you wait for the resolution?

And while customer is taking a well deserved break playing chess, you can try to fix the exception or at least add it to your TODO list.

In this post we will only talk about bugs related to unhanded exception being thrown.

Minimizing Unhanded Exceptions

In a rare case that one of the approaches in ’100% bug free code’ section fails, here are some ways to minimize your unhandled exceptions.

Defensive programming

It may come as a total surprise to you, but writing good code will actually result in less bugs and unhanded exceptions. Please spread the word.

From Wikipedia: “defensive programming is a form of defensive design intended to ensure the continuing function of a piece of software in spite of unforeseeable usage of said software”. That should apply to any code that you write, unless your hobby is to spend your weekends fixing unhanded exceptions that should not have happened in the first place. There are plenty of articles written on the subject of defensive programming, so I will not go into too much details.

I would like to highlight a technique called Parameter Checking that will make your functions a lot less error-prone. Here is one example:

void JustAnotherFoo(string iAmNotNull, int iAmPositiveInteger)
{
    //Check that parameters are valid
    if (iAmNotNull == null)
          throw new ArgumentException("I have identity crisis", "iAmNotNull");

     if (iAmPositiveInteger <=1)
           throw new ArgumentException("I am having a bad day", "iAmPositiveInteger");

     //Do some stuff that will sometimes break if iAmNotNull is null
     ....

     //Do some other stuff that could break if iAmPositiveInteger is
     //not what he says he is
     ...
}

With code like this, you will catch many of the previously unhandled exceptions before they get a chance to cause all kinds of unforeseen errors.

There are many approaches in C# to implementing parameter checking.

• using fluent notation
  http://conditions.codeplex.com
• with code contracts already included in CLR
  http://visualstudiomagazine.com/articles/2010/06/23/code-contracts.asp
• using extension methods
  http://weblogs.asp.net/fredriknormen/archive/2008/05/08/how-to-validate-a-method-s-arguments.aspx

Unit testing

As much as I like to harp on the idea that 100% code coverage can solve all life’s problems, including better night sleep, more satisfying sex life and even a better customer experience in some cases, writing unit tests can most certainly prevent many cases of unhanded exceptions. When a new exception is reported, it is a great practice to write a unit test to reproduce the exception (what in unit testing world is called red circle of doom). Then you fix the issue and make unit test pass (which in unit testing world is called green circle of awesome happiness).

Automated testing

This is more of UI testing using tools like selenium. This way you can automate common workflows in your application and run through them before each rollout. These types of tests run a lot slower then unit tests, but are much better at simulating actual end user experience. The approach where you write unit test to reproduce exception before fixing it, can also be used with Automated tests, in case unit tests are not sufficient to reproduce the issue.

Manual QA

In some cases it is very hard to automate a test or try to cover every possible edge case. Like double clicking on every shiny button on the screen, all at the same time. Basically what a normal end user does. In this case we need manual intervention, as in actual humans doing testing.

For this scenario what you do is:

1. Get a couple of QA people
2. Train them that every time they find an unexpected exception they get a tasty biskit (something you can get in large volume from Costco)
3. But if they don’t find any exceptions in certain period of time – you zap them with ever increasing wattage
4. By the end of the week you will be out of Biskits and QA people

The truth about Unhandled Exceptions

You may want to seat down as it may come as a total shock to you,

A program of any complexity is going to have unhandled exceptions.

This is really important concept, so please to take your time to fully comprehend it. At first you may feel a little dizzy and nauseous, but unless your are pregnant, these symptoms may go away in a couple of minutes. In case you are pregnant though, try prune juice. I hear good things…

You may repeat the phrase above several times. Maybe combine it with a bit of Buddhist chanting. Only when you have accepted the deep meaning in it and you are at peace with yourself, you are ready to proceed.

Oh “Wise Exception Guru”, how should we deal with all these unhandled exceptions?

There are several ways to deal with unhandled exceptions:

1. Use a 3rd party tool, like ELMAH (worst or best name evar? you decide). These tools are usually easy to integrate with your projects. After integration, when exception occurs it will be handled by the 3rd party tool and will be stored in DB or another type of storage. Afterwards you can use UI provided by the 3rd party tool to browse the exceptions.
2. Write your own custom implementation. Why? Because the gods of coding gave you a rare gift of writing the most readable, most maintainable and most testable code on this planet. Unfortunately it came with one of the biggest heads on the planet which makes it extremely difficult to get through the door. An alternative, but much less common reason is that you were looking for some of the features not offered by any of the 3rd party tools.
3. Just change a name from “unhandled exceptions” to “user errors”. Whenever one of these “user errors” is reported, there is a scripted reply:

   You must have done something wrong.
   * If you are using windows, please reboot your computer at least 3 times.
   * If you are using IPhone, try pressing THE button or combination of THE button with turn off switch. That’s really all you can do.
   * If you are using Linux, use Emacs to modify config file to enable detailed logging. If that doesn’t present you with the error of your ways, your kernel may require recompiling.

What do I want in my Exception Logging And Reporting Software (ELARS, because I can)?

Before evaluating 3rd party solutions, I used a custom solution which worked like this:
Anytime unhandled exception would occur it would trigger an email sent to a gmail account which was setup just for this purpose. Gmail is extremely nice tool for searching and filtering. It also has some shortcomings that I wanted to address by introducing 3rd party tool or writing a custom solution specifically for handling unhandled exceptions.

Here is a list of features that are a MUST for exception handling software:

• Integration with various project types
  At minimum it should support:
  • Web Project (ASP.NET, MVC)
  • Exe Project (Console, Windows Service)
  • Web Service (WCF)
• Log context information at the time of exception
  To fix unhandled exception you must be able to reproduce it. Regular ASP.NET exception page usually includes just an error message and stack trace. Sometimes it is sufficient to reproduce the error, but most of the time we will require input from the end user, like what data they entered in the form, what is their username, what browser they used, etc…

  Instead, it is a lot more efficient for both developer and the end user, if for every unhandled exception, the application would automatically log all such information.

  For web application I would need:
  * Full Url and Query String
  * Session Variables
  * Request Form Items
  * Cookies

  For WCF service at a minimum we need to log RawData of the request being passed.

  There should also be an option to add custom fields to logged information. For example let’s say I store current CustomerID in session variable. Whenever I need to find out which customer triggered the exception, I need to run DB query to get customer name. Instead I could just add a custom field to Exception Log called “CustomerName” and run DB query at the time when exception is logged. Using this custom field can save you a lot of time.

• UI to search exceptions
  When customer reports an unhanlded exception, the first thing I want to do is to find that exception in logs. As long as the context information related to exception is properly logged this task is pretty trivial, given that there is a flexible UI to list and find exceptions. I would like to be able to search by error message and any other context information mentioned in previous section.
• Grouping similar exceptions
  Some exceptions may occur only once or twice a month, while others may be happening 1000s of times a day. To be able to prioritize the errors it is important to know how frequently they occur. When you start logging exceptions in ASP.NET you may find that you are quickly overwhelmed with large number of exceptions being logged. The solution in most cases is to stop using error log and go back to assuming that your system is working just fine and any end user reports to the contrary are just fabrications from communists. A better approach is to allow grouping unhandled exceptions by stack trace, error message, url and maybe some other fields specific to your system. This way instead of list of all error occurrences – you will get a list of unique errors and how many times they occurred.
• Integration with bug tracking software
  Everyone knows that the first step to fixing unhandled exception or any bug is creating a new entry in a bug tracking software. This way, QA department will know what to test for the next rollout and your boss will know that you are spending most of your time fixing bugs from the last release instead of working on new features that were promised 2 months ago. It would be great to be able to link the “Error Group” from previous bullet point to a bug in Bug Tracking software, so that whenever bug actually gets resolved it can also be udpated Exception Logging software and then we can watch for it to make sure it never (ever ever ever) occurs again.
• Reporting (nice to have)
  To intelligently judge the health of the application, reports should provide information like:
  * Number of errors per time period (like day, week, month, etc..). So you can see if your system is getting healthier over time or dying from untreated flu.
  * Regions (or namespaces) in your application where most exceptions occur. So that the developers with least exceptions can order developers with most exceptions to go get coffee, wash their car and maybe even walk the dog.

What Exception Logging and Reporting software is currently available?

• Elmah
  http://code.google.com/p/elmah
  - the grand daddy of them all. Supports only Web Projects out of the box.

• Exceptioneer
  http://www.exceptioneer.com
  - Saas solution to error logging. Seems like a great fit for all the features I mentioned, except it seems like the company went out of business 2 years ago and all that is left is a zombie-site that is down half of the time. When the site is down the error message is “Internal exception has been handled by our Excepioneer”. Oh the Irony of it all.

• CodeSmith Insight
  http://www.codesmithtools.com/product/insight
  - exception handling, reporting, bug tracking, customer communication and also makes coffee. But for a price. Plus it only makes regular coffee. Capuccino addon will cost you extra.

  WARNING: I would like to serve notice to CodeSmith marketing deapartment. I noticed that every blog post on the internet that talks about exception handling is usually followed by a comment from you about how your product is all that and makes coffee too. For ex. check out comments section here. This is spam and not the good type.

• Enterprise Library Error Logger
  http://weblogs.asp.net/sukumarraju/archive/2009/10/04/microsoft-enterprise-library-4-1-exception-handling-block.aspx
  - built on top of logging block. Allows logging exceptions to event log, DB, email, etc.

Indepth evalutation for these tools

This blog post is getting really long and majority of the people probably dosed off by this point. So I will leave it for another post.

Conclusion

In this article I talked about various approaches to handling unhanded exceptions.

• If you are a developer you will come away empowered with knowledge that Unhanded exceptions can be handled.
• If you are a pregnant woman you will learn of home remedies to use when you feel sick and nauseous
• If you are a Unit test junky, you will add scathing comments to this article that will reinforce your beliefs

Either way everyone will be happy.

In the next article of this series, we will do a full review of various products available to help with logging and reporting unhandled exceptions.

]]> http://www.entechsolutions.com/logging-and-reporting-unhandled-exceptions/feed 0 http://www.entechsolutions.com/stripe-for-card-present-swiped-transactions?utm_source=rss&utm_medium=rss&utm_campaign=stripe-for-card-present-swiped-transactions http://www.entechsolutions.com/stripe-for-card-present-swiped-transactions#comments Mon, 27 Feb 2012 04:57:20 +0000 admin http://www.entechsolutions.com/?p=723 There is a lot of innovation happening in Payment space led by Stripe, Square and Paypal and we’ve been thinking about building few simple APIs to process the payments for Card present transactions.

We love Stripe and what they have done with the payment API. We think they have one of the best payment APIs.  We’ve used it on some of our client’s site and suffice it to say we found it pretty awesome. While Stripe provides an amazing API for the internet transactions (card not present), there is a room for a simple API that can process card present (swiped) transactions. As far as I know, Stripe does not yet provide ‘Card Present’ types of transactions.

As developers, we help clients build Point of Sale applications where credit card are swiped in a physical terminal and these type of transactions are called ‘Card Present’ transactions. Simply, Card Present (CP)transactions are those in which a credit card is physically present with the person and are swiped in physical terminals. Merchants are charged different levels of fees by the card transaction processors (such as Visa, MasterCard), depending on the level of fraud risk, and because the card is available for inspection, are considered less risky and therefore carry lower fees than online or phone transactions.

Why:
It is getting quite easy to make payment terminals on the web, tablets and mobile devices and since these devices are always connected on the web, they can be much smarter and feature rich much like what Square is doing. The web and hand held terminals are much easier to deploy as it just needs browser or an installed app and internet connection and the devices to swipe the credit cards are getting cheaper and readily available, so there are many possibilities to provide innovative payment services to merchants than its current form. Also, considering the mobile handset market is poised to be the biggest market ever – providing a low-cost, easy-to-use API for any developers to hook payment system will definitely add a lot of excitement and value.

A simple Stipe like API that will be able to simply send the encrypted credit card data through and have all the usual methods like Charge, Void, Sale, Refund etc. would be quite exciting.

These are my initial thought and I will expand more in the future as we hash out more details and as we work on them. If you know of anyone doing similar API for Card Present data, we would love to know. Please leave a note on our comments section.

]]> http://www.entechsolutions.com/stripe-for-card-present-swiped-transactions/feed 0 http://www.entechsolutions.com/hooks-and-sockets-for-web-apps?utm_source=rss&utm_medium=rss&utm_campaign=hooks-and-sockets-for-web-apps http://www.entechsolutions.com/hooks-and-sockets-for-web-apps#comments Thu, 16 Feb 2012 18:42:21 +0000 sarah http://www.entechsolutions.com/?p=423 WebHook

“The concept of a WebHook is simple. A WebHook is an HTTP callback: an HTTP POST that occurs when something happens; a simple event-notification via HTTP POST.”   http://wiki.webhooks.org

Using WebHooks, you can request event notification from some third party by supplying a callback url. The WebHook provider will post information to your callback url whenever something happens. This way you don’t have to periodically, or worse, constantly, poll the third party to ask if anything has happened. It is a super simple concept with powerful implications.

When an event occurs, a WebHook provider will gather 3 pieces of information to send to a client:
 
1. event_type : ex: “product_added”, “customer_created”
2. event_source: This describes where the event was initiated.
3. data: Information about the event that occurred. This should include a timestamp and a unique identifier.

What the client does with this information is, of course, entirely up to the client. The power of WebHooks lies in what the client does with the data it receives. If the client doesn’t do anything useful, there’s not much power to it.

Here is a simple example of a WebHook provider implementation in C#.

In this example I gather the relevant data into an object called an “Event”, serialize it to JSON, and post it to the callback urls.

// This method should be called after any event occurs
public Event OnEventOccurred(EventType eventType, EventSource eventSource, object data)
{
	var e = RecordEvent(eventType, eventSource, data);
	PostToClients(e);
	return e;
}

//  Record event with a unique identifier and timestamp
private static Event RecordEvent(EventType eventType, EventSource eventSource, object data)
{
	var e = new Event()
			    {
			        ID = Guid.NewGuid(),
			        EventType = eventType.ToString(),
			        EventSource = eventSource.ToString(),
			        Data = data,
			        TimeStamp = DateToTimeStamp(DateTime.Now.ToUniversalTime())
			    };

	e.Save();
	return e;
}

// This method serializes the event data into JSON and posts to the callback urls
private void PostToClients(Event e)
{
	JavaScriptSerializer ser = new JavaScriptSerializer();
	string postData = ser.Serialize(e);

	// Retrieve list of callback urls
	var subscribers = GetWebHookClients(e);
	foreach (var subscriber in subscribers)
	{
		MakeHttpRequest(subscriber.CallBackUrl, postData);
	}
}

private void MakeHttpRequest(string callbackUrl, string data)
{
	var uri = new Uri(callbackUrl);

	var req = (HttpWebRequest)WebRequest.Create(uri);
	req.KeepAlive = true;
	req.Method = "POST";
	Stream reqStream = req.GetRequestStream();

	if (data != null)
	{
		byte[] reqBytes = Encoding.UTF8.GetBytes(data);
		reqStream.Write(reqBytes, 0, reqBytes.Length);
	}

	reqStream.Close();
	reqStream.Close();
	WebResponse res = req.GetResponse();
	StreamReader read = new StreamReader(res.GetResponseStream());
	string fullResponse = read.ReadToEnd();
}

Now that we have a WebHook provider, we need a client.


Here is an example of a WebHook Client using a RESTful WCF service.
You will see from the code that a client is just an endpoint that receives data and does something with it.

The resulting callback url from this code will be http://localhost:53927/WebHookListenerService.svc/listen.

In this example, the listener just saves the data to a text file when it receives it. In a real world application, I would probably want to store this data in a distributed cache so the app can share the data with another app. Also, since WebHooks are meant to find out about things that are happening now, a caching mechanism in which the data expires makes sense.

This is the WCF service contract:

[ServiceContract]
public interface IWebHookListenerService
{
	[WebInvoke(Method = "POST",
	BodyStyle = WebMessageBodyStyle.Bare,
	RequestFormat = WebMessageFormat.Json,
	ResponseFormat = WebMessageFormat.Json,
	UriTemplate = "/listen")]
	void Receive(Stream postedData);
}

And the implementation:

public class WebHookListenerService : IWebHookListenerService
{
	// Endpoint to receive data posted by a webhook server
	public void Receive(Stream postedData)
	{
		string data = new StreamReader(postedData).ReadToEnd();
		if (String.IsNullOrEmpty(data)) return;

		DoSomethingWithTheData(data);
	}

	// Do something with incoming messages.
	// For demo, we will simply persist them to a file.
	private void DoSomethingWithTheData(string jsonData)
	{
		FileDataStore.StoreMessage(jsonData);
	}
}


This is very nice, but I haven’t done anything useful with the information I received from the WebHook. I just wrote it to a file.

For a web based application, I want do something in a web browser when an event occurs.
The problem is, now that I have been notified that an event has occurred, how do I notify a browser?

This is where WebSockets can help.

WebSocket

The WebSocket Protocol is essentially an independent TCP-based protocol where a connection is established between a client/browser and a server and then both sides can send data back and forth without a new handshake.

This means we can open a connection from a browser to the server and, once the connection is established, the server can begin to push messages to the client at will. Then the browser can do something when it receives a new message such as show something on the screen, play a ringtone, etc.

For a browser to initiate a websocket connection to a server, it sends an HTTP request with the following headers:

“Connection:Upgrade”
“Upgrade:WebSocket”

The server will respond with a status code “101 Switching Protocols”.
This is sample of the request and response:

Request URL: ws://localhost:8080/websession
Request Method: GET
Status Code: 101 Switching Protocols

Request Headers
Connection: Upgrade
Host: localhost:8080
Origin: http://localhost:53927
Sec-WebSocket-Key: vPkYt7muES+evHN2AxXasw==
Sec-WebSocket-Version: 13
Upgrade: websocket
(Key3): 00:00:00:00:00:00:00:00

Response Headers
Connection: Upgrade
Sec-WebSocket-Accept: 4+7cCQ4YGQh9jjDlnIRv6qwgVlM=
Upgrade: WebSocket
(Challenge Response): 00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00

This is the JavaScript for a browser to initiate the WebSocket connection.

var socketserver_url = 'ws://localhost:8080/websession';
var socket = new WebSocket(socketserver_url);
socket.onopen = function () {
	alert('handshake successfully established. May send data now...');
};
socket.onmessage = function (e) {
	//var d = JSON.parse(e.data);
	console.log(e);
	$('#received_messages').append('WebSockets message received: ' + e.data + '
');
	alert('data received');
};
socket.onerror = function (data) {
	console.log(data);
	alert('errors occurred: ' + data);
};
socket.onclose = function () {
	alert('connection closed');
};

Once the connection is open, the browser will raise the socket.onmessage() event when a new message is received from the server.


The server side code for a WebSocket is as follows.
It is shown here as a console app that listens for WebSocket requests at ws://localhost:8080/websession.

static void Main(string[] args)
{
	var listener = new TcpListener(IPAddress.Loopback, 8080);
	listener.Start();

	while (true)
	{
		Listen(listener);
	}
}

// Listen for some connection request
private static void Listen(TcpListener listener)
{
	using (var client = listener.AcceptTcpClient())
	using (var stream = client.GetStream())
	{
		var headers = new Dictionary();
		string line = string.Empty;
		while ((line = ReadLine(stream)) != string.Empty)
		{
			var tokens = line.Split(new char[] {':'}, 2);
			if (!string.IsNullOrWhiteSpace(line) && tokens.Length > 1)
			{
				headers[tokens[0]] = tokens[1].Trim();
			}
		}

		// Get key sent by client and compute socket accept value
		var key = headers["Sec-WebSocket-Key"];
		String secWebSocketAccept = ComputeWebSocketHandshakeSecurityHash09(key);

		// Setup headers for response
		var response =
			"HTTP/1.1 101 Switching Protocols" + Environment.NewLine +
			"Upgrade: WebSocket" + Environment.NewLine +
			"Connection: Upgrade" + Environment.NewLine +
			"Sec-WebSocket-Accept: " + secWebSocketAccept + Environment.NewLine +
			Environment.NewLine;

		var bufferedResponse = Encoding.UTF8.GetBytes(response);
		stream.Write(bufferedResponse, 0, bufferedResponse.Length);

		SendMessageToClient(stream);
	}
}

// Determine which data is ready to receive and push to client
private static void SendMessageToClient(NetworkStream stream)
{
	// Add data to response.  Get messages received from webhook
	string responseData = String.Empty;
	List messages = GetDataAlreadyReceivedFromWebHook(null, null);
	foreach (string message in messages)
	{
		responseData += message + ",";
	}
	responseData = responseData.TrimEnd(",".ToCharArray());

	List lb = new List();
	lb.Add(0x81);
	lb.Add(0x04);
	// add the payload
	lb.AddRange(Encoding.UTF8.GetBytes("Test"));
	//write it!
	stream.Write(lb.ToArray(), 0, 6);
}

When the server wants to send a new message to the browser, it will write to the client’s stream like this:

stream.Write(bufferedMessage, 0, bufferedMessage .Length);

Now, a browser can respond to some event that happens on some third party system.


Some words of caution on WebSockets

There are a few things you should be aware of before attempting to implement WebSockets.

1. First, this example only performs an initial handshake and sends one message to the client. The full implementation of WebSockets is more complicated having to handle multiple connections.
   This is a really nice full implementation in C#: http://ashishware.com/websocksample.shtml
   
   Also, .NET 4.5 has some low level socket functionality with the System.Net.WebSockets namespace and there is also a really promising NuGet library. You should definitely check this out before trying to implement WebSockets.
   
   http://paulbatum.github.com/WebSocket-Samples/AspNetWebSocketEcho/
   http://www.techbubbles.com/aspnet/websockets-in-asp-net-4-5/
   
   
2. Second, but more importantly, the protocol for WebSockets has rapidly evolved. Many examples you will find implement Hixie-75 or Hixie-76. This article is based on Hybi-09. Given that not all browsers support this protocol, in particular IE, you can not really implement WebSockets for critical functionality in an enterprise application at this time.
   
   Here is a related article: You users don’t care if you use websockets
   
   This is the protocol evolution:
   hixie-75
   hixie-76
   hybi-00
   hybi-06
   hybi-07
   hybi-09
   hybi-10
   RFC 6455
   
   

Some Links

.NET 4.5 WebSockets
http://www.techbubbles.com/aspnet/websockets-in-asp-net-4-5/
http://paulbatum.github.com/WebSocket-Samples/AspNetWebSocketEcho/

http://html5demos.com/web-socket
WebSocket Demo based on Node

http://nowjs.com/
SUPER COOL NODE LIBRARY which provides easy to use functionality for the browser and server to talk back and forth. (No, this is not a Node article, but you should check it out anyway!)

http://websocket.org/





---

Download

CLICK TO DOWNLOAD SOURCE CODE FOR THIS ARTICLE

The download contains a Visual Studio 2010 .NET solution which implements both the client and the server side parts of WebHooks and WebSockets. It contains the following 3 projects:


1. WebClient.csproj
   
   This contains the WebHook listener service at http://localhost:53927/WebHookListenerService.svc.
   
   Run this application so the callback url is available when the WebHookServer wants to post to it when new events occur. When the ClientApp receives a new event, it simply writes the data to a text file at c:/temp/webhook.txt. Check this file to see that you are receiving messages.
   

2. WebHookServer.csproj
   
   Contains a RESTful WCF Service which simply posts event information to the ClientApp’s callback url. To invoke the service to post an event:
   
   http://localhost:53936/WebHookService.svc/event/post?eventType=APPOINTMENT_CREATED&eventSource=API&data=some_thing_happened
   
   Note: This is a simplified example. In a real application you will want to add code to verify that the client receives the data successfully, deactivate unresponsive callback urls, add signature to your messages so the client can verify who you are, and more.
   
   
3. WebSocketServer.csproj
   
   A console application which listens for socket connection requests and also monitors the c:/temp/webhook.txt file for new data. When new data is detected, it pushes it to the connected clients.
   
   To run this project and make a connection between it and the ClientApp, run the console app. Then open the default page in the ClientApp, http://localhost:53927/Default.aspx, which will make the connection to the socket server at ws://localhost:8080/websession.
   
   Note: The WebSocket implementation in this download only performs the initial handshake and sends one message to the client. The full implementation of WebSockets is more complicated having to handle multiple connections.
   This is a nice full implementation in C#: http://ashishware.com/websocksample.shtml

   Note: This sample does not run in FireFox. Please run the socket client in Chrome.

]]> http://www.entechsolutions.com/hooks-and-sockets-for-web-apps/feed 2 http://www.entechsolutions.com/wcf-and-dynamic-ssl?utm_source=rss&utm_medium=rss&utm_campaign=wcf-and-dynamic-ssl http://www.entechsolutions.com/wcf-and-dynamic-ssl#comments Fri, 03 Feb 2012 16:42:19 +0000 Mike http://www.entechsolutions.com/?p=344 Here at ENTech Solutions we maintain several environments which include production, staging, QA and development. Each of these environments has its own setup with production and QA having their own SLL certificates.  Stable and most of our local development environments do not. We can use self signed certs on our local development systems, but for staging this is not an option.  We need a way to enable or disable SSL depending on environment.  In this post I’ll show you how to work with WCF and SSL at run time.  It assumes you have a working service running with a configuration file with one endpoint.

Setting SSL via Configuration Files

Adding SSL support to a WCF app is rather easy.  In the config file (web.config or app.config) set the bindings security to Transport.  For basic http binding it is set as:

 <bindings>
  <basicHttpBinding>
   <binding name="HttpBinding">
    <security mode="Transport">

For web binding it is set similarly as:

 <bindings>
  <webHttpBinding>
   <binding name="HttpBinding">
    <security mode="Transport">

Programmatically working with SSL

Instead of having the system automatically create the service host, we are going to:

1. Override the method that creates the service host
2. Create it manually while still using the configuration settings
3. Make changes to the service objects as needed

To start off we will set up our service with a standard configuration, one end point, and using Transport security mode binding.  I have found it is easier and safer to have SSL turned on by default and turn it off as needed.

To override the service host code we need to create a service factory class.

public class OurServiceFactory : ServiceHostFactory
{
 public override ServiceHostBase
                   CreateServiceHost(string constructorString, Uri[] baseAddresses)
 {
  return null; // null for now
 }
}

We need a way to have the system use our factory instead of the default code.  To do this in a WCF web site modify the Service.svc file.

<%@ ServiceHost  language="c#"  Factory="OurServiceFactory" %>

To create the service host manually we modify CreateServiceHost method as:

public override ServiceHostBase
          CreateServiceHost(string constructorString, Uri[] baseAddresses)
{
 var serviceHost = new ServiceHost(typeof(OurService), baseAddresses);

 return serviceHost;
}

When the above CreateServiceHost method is called, a new service host is created.  The ServiceHost constructor tries to match the name of the service type with the configuration file and uses those settings.  This allows us to use the configuration file while giving the ability to make changes programmatically.

In this example EnableSSL can be set true on production and QA environments, false otherwise.

public override ServiceHostBase
                 CreateServiceHost(string constructorString, Uri[] baseAddresses)
{
 var serviceHost = new ServiceHost(typeof(Service), baseAddresses);

 if (!EnableSSL)  // we enable SSL by default
 {
  var endpoint
        = serviceHost.Description.Endpoints[0]; // assume first and only endpoint.
  endpoint.Address
        = new EndpointAddress(baseAddresses[0].ToString().Replace("https", "http"));

  if (endpoint.Binding is WebHttpBinding)
   ((WebHttpBinding) endpoint.Binding).Security.Mode
        = WebHttpSecurityMode.None;

  if (endpoint.Binding is BasicHttpBinding)
   ((BasicHttpBinding) endpoint.Binding).Security.Mode
        = BasicHttpSecurityMode.None;
 }
 return serviceHost;
}

The above code demonstrates how to to set security mode for both WebHttpBinding and BasicHttpBinding, but only one would be necessary.

To consume this service using a standard service consumer C# application would look like:

WCFService.ServiceClient service = new ServiceClient();
if (!EnableSSL)
{
 service.Endpoint.Address
                   = new EndpointAddress("http://wcf/service.svc");
 (service.Endpoint.Binding as BasicHttpBinding).Security.Mode
                   = BasicHttpSecurityMode.None;
}

Conclusion

WCF provides a ton of configuration options that can be set via configuration or programmactially. The above factory can be used to programmatically change many settings and not just security options.

]]> http://www.entechsolutions.com/wcf-and-dynamic-ssl/feed 0 http://www.entechsolutions.com/using-partial-requestresponse-in-wcf?utm_source=rss&utm_medium=rss&utm_campaign=using-partial-requestresponse-in-wcf http://www.entechsolutions.com/using-partial-requestresponse-in-wcf#comments Mon, 30 Jan 2012 07:31:07 +0000 anup http://www.entechsolutions.com/?p=327 I got inspiration to research on this topic after reading partial request/response email a week ago. This was the link mentioned in the email.

http://googlecode.blogspot.com/2010/03/making-apis-faster-introducing-partial.html

Partial request/response is also used in LinkedIn APIs.  http://blog.linkedin.com/2009/07/08/brandon-duncan-java-one-building-consistent-restful-apis-in-a-high-performance-environment/
In their API documentation, they have sample partial requests. They call it FieldSelectors: More on this link https://developer.linkedin.com/documents/field-selectors

So what exactly is Partial request/response?

-    In API calls, we often use default request and retrieve default response. Partial request or Field Selector allows us to request the data that we want. The API response will contain just those data and elements that we have requested and not the whole default result.
Enabling partial request/response in our existing API calls will help in increasing efficiency. I think there is no doubt about it.

In our current application– If you want to retrieve just a location name, the city and state of one of the business. You will be using GetLocation with appropriate parameters. Current implementation returns a large response with many elements that you will not be using. The current response is 2007 bytes, where as partial response would be only 690 bytes. APIs will be much more efficient if we can avoid unnecessary data that just go wasted. This will save the bandwidth as well./

Current Request

GET /GetLocation

Current Response

<s:Envelope xmlns:s=”http://schemas.xmlsoap.org/soap/envelope/”>
<s:Body>
<GetLocationResponse xmlns=”https://www.spa-booker.com/soap/customer”>
<GetLocationResult xmlns:a=”https://www.spa-booker.com” xmlns:i=”http://www.w3.org/2001/XMLSchema-instance”>
<a:AccountName>spaladoc</a:AccountName>
<a:Address>
<a:City>Metuchen</a:City>
<a:Country>
<a:ID>1</a:ID>
<a:Name>United States</a:Name>
</a:Country>
<a:State>NJ</a:State>
<a:Street1>6500 New Ave</a:Street1>
<a:Street2 i:nil=”true”/>
<a:Zip>11215</a:Zip>
</a:Address>
<a:BusinessName>Spa La Documentation</a:BusinessName>
<a:BusinessType>
<a:ID>13</a:ID>
<a:Name>Spa</a:Name>
</a:BusinessType>
<a:CultureName>en-US</a:CultureName>
<a:CurrencyCode>USD</a:CurrencyCode>
<a:Description i:nil=”true”/>
<a:EmailAddress>gfdgfd@gfd.com</a:EmailAddress>
<a:FeatureLevel>Unlimited</a:FeatureLevel>
<a:FirstName>Test</a:FirstName>
<a:ID>3749</a:ID>
<a:LastName>Booker</a:LastName>
<a:Password i:nil=”true”/>
<a:Phone>6323197663</a:Phone>
<a:SpaFinderId i:nil=”true”/>
<a:Status>Demo</a:Status>
<a:TimeZone>
<a:ID>18</a:ID>
<a:Name>(GMT-05:00) Eastern Time (US &amp; Canada)</a:Name>
<a:StandardName>Eastern Standard Time</a:StandardName>
</a:TimeZone>
<a:WebSite i:nil=”true”/>
<a:ArgumentErrors i:nil=”true”/>
<a:ErrorCode>0</a:ErrorCode>
<a:ErrorMessage i:nil=”true”/>
<a:IsSuccess>true</a:IsSuccess>
</GetLocationResult>
</GetLocationResponse>
</s:Body>
</s:Envelope>

Partial Request

Get /GetLocation?fields=(businessname, city, state)

Or /GetLocation(businessname,city,state)

Partial Response

<s:Envelope xmlns:s=”http://schemas.xmlsoap.org/soap/envelope/”>
<s:Body>
<GetLocationResponse xmlns=”https://www.spa-booker.com/soap/customer”>
<GetLocationResult xmlns:a=”https://www.spa-booker.com” xmlns:i=”http://www.w3.org/2001/XMLSchema-instance”>
<a:City>Metuchen</a:City>
<a:State>NJ</a:State>
<a:BusinessName>Spa La Documentation</a:BusinessName>
<a:ArgumentErrors i:nil=”true”/>
<a:ErrorCode>0</a:ErrorCode>
<a:ErrorMessage i:nil=”true”/>
<a:IsSuccess>true</a:IsSuccess>
</GetLocationResult>
</GetLocationResponse>
</s:Body>
</s:Envelope>

This is the part I of the blog. I will try to add more on the implementation part.

-Anup

]]> http://www.entechsolutions.com/using-partial-requestresponse-in-wcf/feed 0