Responding to a third party event in a browser

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

• event_type : ex: “product_added”, customer_created” or “appointment_booked”.
• event_source: This describes where the event was initiated.
• data: Information about the event that occurred. This should include a timestamp and a unique identifier.

// 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();
}

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

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);
	}
}

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.

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');
};

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);
}

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

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.

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://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

Current Response

Partial Request

Partial Response

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

-Anup

In a recent project I worked on WCF service with the following requirements:

CLICK HERE TO DOWNLOAD SOURCE CODE FOR WCF SERVICE and UNIT TESTS

The WCF Service

	public class MathService
	{
		public int Add(int value1, int value2)
		{
			int sum = value1 + value2;
			return sum;
		}
	}

To access this service through WCF, I added the following IService contract:

	[ServiceContract(Namespace = "apidoc.sampleapi.com", Name = "SampleApi")]
	public interface IService
	{
		[WebGet( UriTemplate = "Add?value1={value1}&value2={value2}&apiKey={apiKey}", BodyStyle = WebMessageBodyStyle.Bare)]
                AddRs AddWithHttpGet(int value1, int value2, string apiKey);

		[WebInvoke(Method = "POST", UriTemplate = "Add", BodyStyle = WebMessageBodyStyle.Bare)]
		AddRs Add(AddRq rq);
	}

There is only two functions. The first one allows for using Get and passing all the parameters in query string. The second one allows passing objects using Post. In both cases the methods return results in object format.

This service can be called in the following ways:

{"IsSuccess":true,"Sum":16}

<AddRs xmlns="apidoc.sampleapi.com" xmlns:i="http://www.w3.org/2001/XMLSchema-instance">
	<IsSuccess>true</IsSuccess>
	<Sum>16</Sum>
</AddRs>

{"Value1":5,"Value2":11,"ApiKey":"test-key"}

{"IsSuccess":true,"Sum":16}

<AddRq xmlns="apidoc.sampleapi.com">
  <ApiKey>test-key</ApiKey>
  <Value1>5</Value1>
  <Value2>11</Value2>
</AddRq>

<AddRs xmlns="apidoc.sampleapi.com" xmlns:i="http://www.w3.org/2001/XMLSchema-instance">
	<IsSuccess>true</IsSuccess>
	<Sum>16</Sum>
</AddRs>

<?xml version="1.0" ?>
<s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/">
  <s:Body>
    <Add xmlns="apidoc.sampleapi.com">
      <rq xmlns:i="http://www.w3.org/2001/XMLSchema-instance">
        <ApiKey>
          test-key
        </ApiKey>
        <Value1>
          5
        </Value1>
        <Value2>
          11
        </Value2>
      </rq>
    </Add>
  </s:Body>
</s:Envelope>

<?xml version="1.0" ?>
<s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/">
  <s:Body>
    <AddResponse xmlns="apidoc.sampleapi.com">
      <AddResult xmlns:i="http://www.w3.org/2001/XMLSchema-instance">
        <IsSuccess>
          true
        </IsSuccess>
        <Sum>
          16
        </Sum>
      </AddResult>
    </AddResponse>
  </s:Body>
</s:Envelope>

Unit Testing

Unit Testing SOAP in WCF Service

Unit testing SOAP is pretty easy. You create a service reference to Web Service and use the following code to check if Sum comes out correctly when authentication key is valid:

       [Test]
        public void Add_WhenValidApiKey_ReturnsSum()
        {
            var client = new SampleApiSoapService.SampleApiClient("soap");

            var addRequest = new SampleApiSoapService.AddRq
            {
                Value1 = 5,
                Value2 = 11,
                ApiKey = Const.ValidApiKey
            };

            var addResponse = client.Add(addRequest);
            Assert.AreEqual(addResponse.Sum, 16);
        }

You may notice that for Request/Response objects I am using suffix Rq/Rs. I previously tried to use full names (Request/Response), but this was causing some conflicts with Proxy generated classes which also use Request/Response.

Unit Testing JSON in WCF Service

This is where it gets interesting. To be able to submit request in JSON from server side, I am using dynamic objects. This is one of the best features in C# 4.0. Basically you create a new object without having to declare a class. So here are the steps to make sure “Add” operation works using JSON Post/Get.

1. create a dynamic class that matches JSON datastructure
2. Serialize it to JSON
3. Send json to web service
4. Deserilize response to a dynamic object
5. Make sure that response has value that I expected

Here it the code for testing POST:

        [Test]
        public void Add_WhenMethodPost_And_ValidApiKey_ReturnsSum()
        {
            var addRequest = new
            {
                Value1 = 5,
                Value2 = 11,
                ApiKey = Const.ValidApiKey
            };

            var url = string.Format("{0}/json/add", Const.WebServiceUrl);
            var request = (HttpWebRequest)WebRequest.Create(url);
            request.Method = "POST";
            request.ContentType = "application/json; charset=utf-8";

            var jsSerializer = new JavaScriptSerializer();
            var jsonAddRequest = jsSerializer.Serialize(addRequest);

            var writer = new StreamWriter(request.GetRequestStream());
            writer.Write(jsonAddRequest);
            writer.Close();

            var httpWebResponse = (HttpWebResponse)request.GetResponse();

            string jsonString;
            using (var sr = new StreamReader(httpWebResponse.GetResponseStream()))
            {
                jsonString = sr.ReadToEnd();
            }

            var jsonAddResponse = jsSerializer.Deserialize<dynamic>(jsonString);

            Assert.AreEqual(16, jsonAddResponse["Sum"]);
        }

Here it the code for testing GET:

       [Test]
        public void Add_WhenMethodGet_And_ValidApiKey_ReturnsSum()
        {
            var url = string.Format("{0}/json/add?value1={1}&value2={2}&apiKey={3}", Const.WebServiceUrl, 5, 11,
                                    Const.ValidApiKey);
            var httpWebRequest = (HttpWebRequest)WebRequest.Create(url);
            httpWebRequest.Method = WebRequestMethods.Http.Get;
            httpWebRequest.Accept = "application/json";

            string jsonString;
            var httpWebResponse = (HttpWebResponse)httpWebRequest.GetResponse();

            using (var sr = new StreamReader(httpWebResponse.GetResponseStream()))
            {
                jsonString = sr.ReadToEnd();
            }

            var jsSerializer = new JavaScriptSerializer();
            var jsonAddResponse = jsSerializer.Deserialize<dynamic>(jsonString);

            Assert.AreEqual(16, jsonAddResponse["Sum"]);
        }

Unit Testing XML in WCF Service

Testing XML is similar to JSON.

1. create a dynamic class that matches XMLdatastructure
2. Serialize it to XML
3. Send XML structure to web service
4. Deserialize response to a dynamic object
5. Make sure that response has value that I expected

The only issue is that XmlSerializer doesn’t have as great support for dynamic objects as JsonSerializer. I found a bunch of info on this subject:
Link 1: Serializing dynamic objects to XML
Link 2: Deserializing dynamic objects (ExpandoObject) from XML

I put this info together as well as a bunch of unit tests and “Voila”. Now converting dynamic objects to XML and back is extremely easy. The only issue I encountered was that when deserializing objects, we have no knowledge of property types so all properties of resulting dynamic objects are strings.

Here is the source code to the class DynamicXmlSerializer:

    public class DynamicXmlSerializer
    {
        private XNamespace _xmlNamespace;

        public DynamicXmlSerializer(XNamespace xmlNamespace = null)
        {
            _xmlNamespace = xmlNamespace;
        }

        //From http://blogs.msdn.com/b/csharpfaq/archive/2009/10/01/dynamic-in-c-4-0-introducing-the-expandoobject.aspx
        public XElement Serialize(dynamic dynamicObject, String rootNodeName)
        {
            var xmlNode = CreateNewXmlNode(rootNodeName);

            PropertyInfo[] properties;
            properties = dynamicObject.GetType().GetProperties();
            foreach (var property in properties)
            {
                object propertyValue = property.GetValue(dynamicObject, null);
                string propertyName = property.Name;

                if (IsAnonymousType(propertyValue.GetType()))
                {
                    xmlNode.Add(Serialize(propertyValue, propertyName));
                }
                else
                {
                    if (propertyValue.GetType() == typeof(List<dynamic>))
                    {
                        string xmlListNodeName = propertyName;
                        var xmlListNode = CreateNewXmlNode(xmlListNodeName);

                        //Use singular for lists, so if it was Friends - it becomes "Friend"
                        string xmlListItemNodeName = Singularizer.IsPlural(xmlListNodeName)
                                                         ? Singularizer.Singularize(xmlListNodeName)
                                                         : xmlListNodeName;

                        foreach (var element in (List<dynamic>)propertyValue)
                        {
                            xmlListNode.Add(Serialize(element, xmlListItemNodeName));
                        }

                        xmlNode.Add(xmlListNode);
                    }
                    else
                    {
                        xmlNode.Add(CreateNewXmlNode(propertyName, propertyValue));
                    }
                }
            }

            return xmlNode;
        }

        private XElement CreateNewXmlNode(string name, object content = null)
        {
            if (_xmlNamespace != null)
                return new XElement(_xmlNamespace + name, content);
            else
                return new XElement(name, content);
        }

        //From http://stackoverflow.com/questions/1650681/determining-whether-a-type-is-an-anonymous-type
        private static Boolean IsAnonymousType(Type type)
        {
            Boolean hasCompilerGeneratedAttribute = type.GetCustomAttributes(typeof(CompilerGeneratedAttribute), false).COUNT() as Computed > 0;
            Boolean nameContainsAnonymousType = type.FullName.Contains("AnonymousType");
            Boolean isAnonymousType = hasCompilerGeneratedAttribute &amp;&amp; nameContainsAnonymousType;

            return isAnonymousType;
        }

        //From http://www.codeproject.com/Tips/227139/Converting-XML-to-an-dynamic-object-using-ExpandoO
        public dynamic Deserialize(XElement rootNode)
        {
            dynamic expandoObject = new ExpandoObject();

            foreach (var node in rootNode.Elements())
            {
                // The code determines if it is a container node based on the child
                // elements with the same name.
                bool isList = node.Elements().GroupBy(n => n.Name.LocalName).COUNT() as Computed == 1;

                // If the current node is a container node then we want to skip adding
                // the container node itself, but instead we load the children elements
                // of the current node. If the current node has child elements then load
                // those child elements recursively
                if (isList)
                {
                    var values = new List<dynamic>();
                    foreach (var childNode in node.Elements())
                        values.Add(GetValue(childNode));

                    ((IDictionary<string, object>) expandoObject)[node.Name.LocalName] = values;
                }
                else
                {
                    var value = GetValue(node);
                   ((IDictionary<string, object>) expandoObject)[node.Name.LocalName] = value;
                }

            }

            return expandoObject;
        }

        private dynamic GetValue(XElement node)
        {
            if (node.HasElements)
            {
                var expandoObject = Deserialize(node);
                return expandoObject;
            }

            return node.Value.Trim();
        }

    }

And finally some of the unit tests for Xml using POST/GET

        [Test]
        public void Add_WhenMehodPost_And_ValidApiKey_ReturnsSum()
        {
            //It is important to set properties in correct format, otherwise may get Bad Request error
            var addRequest = new
            {
                ApiKey = Const.ValidApiKey,
                Value1 = 5,
                Value2 = 11
            };

            var url = string.Format("{0}/xml/add", Const.WebServiceUrl);

            var httpWebRequest = (HttpWebRequest)WebRequest.Create(url);
            httpWebRequest.Method = "POST";
            httpWebRequest.ContentType = "text/xml";

            var xmlElement = SerializeToXml(addRequest, "AddRq");
            string xmlAddRequest = xmlElement.ToString();

            var writer = new StreamWriter(httpWebRequest.GetRequestStream());
            writer.Write(xmlAddRequest);
            writer.Close();

            var httpWebResponse = (HttpWebResponse)httpWebRequest.GetResponse();
            string xmlAddResponse;

            using (var sr = new StreamReader(httpWebResponse.GetResponseStream()))
            {
                xmlAddResponse = sr.ReadToEnd();
            }

            dynamic addResponse = DeserializeFromXml(XElement.Parse(xmlAddResponse));
            Assert.AreEqual("16", addResponse.Sum);
        }

		private XElement SerializeToXml(dynamic dynObject, string rootNodeName)
		{
			//Xml request requires namespace
			var serializer = new DynamicXmlSerializer("apidoc.sampleapi.com");
			return serializer.Serialize(dynObject, rootNodeName);
		}

		private dynamic DeserializeFromXml(XElement xmlElement)
		{
			var serializer = new DynamicXmlSerializer("apidoc.sampleapi.com");
			return serializer.Deserialize(xmlElement);
		}

        [Test]
        public void Add_WhenMehodGet_And_ValidApiKey_ReturnsSum()
        {
            var url = string.Format("{0}/xml/add?value1={1}&value2={2}&apiKey={3}", Const.WebServiceUrl, 5, 11,
                                Const.ValidApiKey);

            var httpWebRequest = (HttpWebRequest)WebRequest.Create(url);
            httpWebRequest.Method = WebRequestMethods.Http.Get;
            httpWebRequest.Accept = "application/xml";

            var httpWebResponse = (HttpWebResponse)httpWebRequest.GetResponse();
            string xmlAddResponse;

            using (var sr = new StreamReader(httpWebResponse.GetResponseStream()))
            {
                xmlAddResponse = sr.ReadToEnd();
            }

            System.Console.Write(xmlAddResponse);

            dynamic addResponse = DeserializeFromXml(XElement.Parse(xmlAddResponse));
            Assert.AreEqual("16", addResponse.Sum);
        }

Conclusion

In this blog post I created a WCF web service that supports SOAP/JSON/XML. I also provided unit tests for all 3 transport protocols using dynamic objects for JSON and XML.

CLICK HERE TO DOWNLOAD SOURCE CODE

]]> http://www.entechsolutions.com/wcf-web-service-for-soap-json-and-xml-with-unit-tests/feed 0 http://www.entechsolutions.com/post?utm_source=rss&utm_medium=rss&utm_campaign=post http://www.entechsolutions.com/post#comments Wed, 21 Sep 2011 10:08:07 +0000 eric http://www.entechsolutions.com/?p=120 A couple of months ago I set out to find a simple find and replace tool that I could use when rolling out my projects. For ex. to change various settings in config files to support dev/qa/prod environment.

Where is that “Find And Replace” option in windows?

It doesn’t exist at this time.

I was looking for something that would have the following features:

1. Simple UI to make sure that find/replace does what I need it to
2. Command line to run find/replace using batch file.

 

What are the alternatives?

There are many tools available, but they all have the following major issues:

• Out of date, no updates support for at least a year

for ex. http://www.divlocsoft.com/

• Bad documentation if any. Many apps mentions that they have command line support, but to find out how it works takes too much effort.
• Too many features. I just need to type in a couple of fields and click on Run, not to learn a new language.

for ex.
http://www.powergrep.com/
grep/sed variants in windows

• No access to code. Many tools have 90% of what I need, but if I need just a bit more (support for multi-line) – there is not much I can do.

 

Open source “Find and Replace” is here!

Since I couldn’t find a tool that would have both: simple UI and well documented command line interface, I decided to introduce my own. It is available on CodePlex and fully free to use, modify, etc…

http://findandreplace.codeplex.com/

]]> http://www.entechsolutions.com/post/feed 0 http://www.entechsolutions.com/post-1?utm_source=rss&utm_medium=rss&utm_campaign=post-1 http://www.entechsolutions.com/post-1#comments Thu, 02 Jun 2011 17:29:19 +0000 eric http://beta.entechsolutions.com/?p=25 Welcome to our new site!

Our site was originally developed using custom ASP.NET code.  At some point we wanted to add Blog functionality, but found that it would take time to add the features we needed.  So we decided to switch to WordPress to host our site.

WordPress has a flexible content management facility as well as many blogging features we were looking for.  It is not as flexible as writing your own custom code, but it has a lot of plugins and active development community.

Now that we have a fully functional blog we plan to do frequent updates including latest news about our company as well as articles related to technology and web development.

Best Regards and Happy Coding,

Management…

]]> http://www.entechsolutions.com/post-1/feed 0