Solid Code

PLINQ with the LINQ to Excel Provider

2010-06-09T16:49:00.000-07:00

In .Net 4.0 there are new extensions methods to take advantage of PLINQ (Parallel LINQ). These extension methods can be used quite easily in the LINQ to Excel Provider described in the post. All you need to do is add the AsParallel method to the end of the LINQ query.

Let Python Speak using COM

2009-12-05T08:57:00.001-08:00

What I have wanted to try and do is create a .Net assembly, make it COM accessible, and call it from Python through COM with pyWin32. There are plenty examples out on the web getting this to work for a simple math class or to call to Microsoft Excel. What I thought would be more interesting is to create a .Net assembly to expose the SpeechSynthesizer class so you could send string phrases from Python and have them spoken by the computer. I think that is a cooler example than a Microsoft Excel integration.

Prerequisites:
Python library for Windows: pyWin32
Visual Studio 2005 or greater (I used Microsoft Visual C# 2008 Express Edition)

Step 1. Create the .Net interface and class in a .Net Class Library (DLL)

Step 2. In the class project be sure to select COM Interop

Step 3. Register the .Net Assembly as a COM component from its build location

regasm SolidCode.Speech.dll /tlb: SolidCode.Speech.tlb

Step 4. Run this simple program from Python.

>>> import win32com.client
>>> speech = win32com.client.Dispatch("SolidCode.Speech")
>>> speech.speak('Hello world');

Step 5. Enjoy.

Age Extension Methods for .Net DateTime Type

2009-09-15T19:45:00.000-07:00

There is not really a straightforward method to calculate a person’s age using the .Net DateTime type. Subtracting years is not a correct means. What is required is to round down a person’s age until that person’s birthday has passed for the given year it is being calculated against. This is what these simple set of extensions to the .Net DateTime class intend to provide.

IsNullOrEmpty Extension Method for .Net Collections

2009-09-07T13:47:00.000-07:00

One of the methods on the string class in .Net framework that was added in .Net 2.0 was the IsNullOrEmpty method. This was implemented as a shortcut mechanism for what developers had been doing which was something like:
if (str == null || str.length == 0) {
//do something
}
Or probably more often
if(!(str == null || str.length == 0)) {
//do something
}

If you think about it the string class in .Net is just a specialized type of collection. I see myself performing that similar pattern for other types of collections in .Net. Why not create an IsNullOrEmpty method to support the .Net collection classes and array types?

It is a pretty simple extension and I plan on incorporating this function in any new .Net 3.5 work that I do. It is just a handle shortcut to use.

.Net Extension Method to Load ASP.Net ListControls from Xml

2009-08-29T19:38:00.000-07:00

Several months ago I joined a group of developers who were in the middle of development of an enterprise web application. What the application does is not as important as some of the interesting implementation techniques they used. One of them was the loading of static, common ASP.Net ListControls from embedded Xml files. I am talking things such as Yes/No radio lists, a list of states, a list of counties, etc. You know, for things that are not going to change at all or not very often.

In browsing through their code, the one thing that caught my attention was that they had developed their own Xml schema to define the items in the lists. My initial thought was, why not use an Xml schema format that allows one to use the Xml serialization functionality of .Net and not have to go through the effort of performing that translation yourself?

So that’s my experiment in this post. Create an Xml file format so Xml serialization can be used, and since I am using .Net 3.5, use extensions methods to handle the translation instead of developing a special purpose utility class to handle that for me.

Here is the extension class used to translate the Xml file into the ListControl. A ToXml method is provided just as a means to obtain a copy of what the Xml schema will look like for a ListControl.

An embedded Xml file that includes a Yes, No and Maybe option with the Maybe option being the defaulted selected item.

<?xml version="1.0"?>
<ArrayOfListItem xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<ListItem>
<Text>Yes</Text>
<Value>yes</Value>
</ListItem>
<ListItem>
<Text>No</Text>
<Value>no</Value>
</ListItem>
<ListItem>
<Text>Maybe</Text>
<Value>maybe</Value>
<Selected>true</Selected>
</ListItem>
</ArrayOfListItem>

This image shows the properties that need to be set to embed an Xml file in a Visual Studio project

This example shows how to load an embedded Xml file into an ASP.Net ListControl on the Page_Load method of an ASP.Net page

Forth as a Web Service

2009-06-28T16:22:00.001-07:00

This is my latest iteration of developing a Forth system. I started with Forth in .Net, Forth interpreter in JavaScript, Forth to script Google Street View and now Forth as a web service. This latest work builds upon a Python web service framework I developed. It is hosted in the Google App engine and the Forth interpreter is a Python port form my JavaScript Forth implementation.

What I like about this implementation is that I now have a Forth system that is accessible to other systems. Also it stores the state of the Forth interpreter between calls. This allows users to develop Forth programs still using the iterative Forth programming style. It stores state by persisting the stacks, and the user dictionary using the Google App Engine data store. These structures are pickled using Python to ease storing and retrieval. Developers can choose to pass in a session value to the web service to identify a Forth interpreter instance to use. This is beneficial so you do not have multiple callers manipulating the state of the same Forth interpreter instance and getting unpredictable responses back.

To the Forth Web Service Console

MVP Pattern in JavaScript

2009-05-13T15:49:00.000-07:00

I have been using the Model View Presenter (MVP) pattern when building some ASP.Net applications and I thought it would be an interesting experiment to try and implement that pattern entirely in JavaScript.

In this experiment, the JavaScript page would be laid out in the following manner.

1. The View is a JavaScript class that encapsulates the interaction of the UI components of the JavaScript through the DOM. Usually this is an interface plus a class implementation to do this in programming languages like in .Net. However since JavaScript doesn’t have interfaces, I just went with a straight implementation. Since JavaScript is a dynamic language it worked out the same.

2. The Model is a web service, a CacheService discussed in this post, and handles getting and retrieving data from the data store.

3. The Presenter is a JavaScript class that takes in an instance of the View. It also encapsulates the Ajax logic used to read and write data from the Model.

Granted this is a very small application, but I really liked the way application ended up being organized. It seemed very clean, easy to follow, and common routines were easily reusable. For example, getting and setting values, and enable or disabling the UI while in the middle of an Ajax call.

I think the next step is to try this pattern out on a larger more complex JavaScript application.

Check out the JavaScript page.

All the code for the implementation of the MVP pattern is embedded within the page so one can just view the source from the browser.

Calling a Python Web Service from JavaScript

2009-05-10T17:53:00.000-07:00

This entry is a continuation of a caching web service developed using a Python Web Service Framework discussed in this post. Here I am experimenting with invoking that web service from JavaScript using Ajax. I have used Ajax before but never to interact with a web service directly. The only thing that was really new here was adding logic to parse out the SOAP response and a general routine to discover and interpret SOAP faults.

In the JavaScript page you will also notice I have mentioned organizing the JavaScript to conform to the Model View Presenter pattern. I plan on including an entry in coming days to discuss that aspect of the page further.
Update Added this entry on 5/13/09. Check it out here

I didn’t include any source because it is just as easy to view the source of the JavaScript page to see what is going on.

On to the JavaScript page!

Python Web Service and the Google App Engine Data Store

2009-05-10T17:22:00.000-07:00

In the last post I discussed and provided code for a Basic Python Web Service Framework for the Google App Engine. This post continues on that work and provides an example of a simple service built in that framework which interacts with the Google App Engine’s data store.

The service is a caching service. It allows users to store a string value referenced by key; a hash table using the Google App Engine’s data store. The operations allowed on this service are get a value by a key, set a key value pair, and delete a key value pair. Two additional operations are get the key value object as Xml, and get the key value object as JSON. Together all these operations provide an example of each of the CRUD operations on the data store. Further, each one is wrapped in a transaction, so there are examples on how to code for transactions as well. The one thing that is missing is an operation that performs a query using GQL.

Link to the source for the CacheService

Link to the live web service on the Google App Engine

I have built a simple JavaScript application to call the service. This is why the operations to get the key value object as Xml and as JSON are included in the service. It was a fun experiment to try and call the web service from JavaScript using Ajax. I think it provides a nice simple interface for users to experiment with the service.

CRON Job
I have implemented a Google App Engine Cron job to delete entries after a defined period of time in order to add expiration to the service. All it does is perform a GQL query looking for entries that are older than week, via the update_date property, and deletes them. You can see the logic for it within the expire method on the CacheService. Should note that method is not exposed as a service call and for the cron job it is getting called directly.

Simple Python Web Service Framework

2009-04-22T17:34:00.000-07:00

This post came about as an effort to combine three things that I have been interested in lately. The “ins and outs” of WSDL and SOAP in web services, Python, and the Google App Engine. I have used web services a fair amount, but have never taken the time to explore the inner workings of WSDL and SOAP messaging. My experience has been with WCF and ASP.Net web services and they both take care of those items for you. To dive into that area I came up with the idea to create a simple web service framework in Python and host it in the Google App Engine.

This is the list of requirements and goals for the project.

1. In effort to keep it simple it will only support primitive data types.

2. Creating a web service class should be easy. Do not want to require inheriting from a special class.

3. Be able to view the WSDL in a browser by issuing a ?WSDL query to the Http endpoint.

4. Want to be able to generate a proxy class for the service in .Net based off the WSDL.

To create a service class in this Python framework is fairly straightforward. There is one unique aspect and that is you need to adorn your class with “attributes” to define, for the framework, which methods are exposed as service calls along with adorning the class itself with a namespace for the service. Python doesn’t have attributes directly (at least that I am aware of) so I used the documentation function ‘__doc__’ to hold the attributes. The attribute for the methods are a simple Xml format describing the input parameters and data types and return data type if there are any. Likewise with the namespace attribute for the class, it is a simple Xml format containing the namespace to uniquely define the service. If you do not define a namespace the framework will default to http://tempuri.org.

Example:

class TestService:
"<namespace>http://solidcoding.blogspot.com</namespace>"

def add(self, x,y):
  "<op><name/><args><arg type="int">x</arg><arg type="int">y</arg></args><ret type="int"/></op>"
  return x + y

def divide(self, x,y):
  "<op><name/><args><arg type="int">x</arg><arg type="int">y</arg></args><ret type="int"/></op>"
  return x / y

def getDate(self):
  "<op><name/><args></args><ret type="dateTime"/></op>"
  return datetime.utcnow().isoformat()

def save(self, message):
"<op><name/><args><arg type="string">message</arg></args><ret/></op>"
  return

Full namespace Xml format (web service class attribute):

<namespace>your namespace here</namespace>

Full method Xml format (web service method attribute):

<op><name>alternate name for method</name><args><arg type='arg1 data type'>argument 1</arg><arg type='arg2 data type'>argument 2</arg></args><ret type='return data type'/></op>

I should note here the data types that you can use in your service calls. They are all Xml data types and are listed below for reference. In the attribute there is no need to add an Xml namespace prefix for these types. The framework will handle those for you.

The data types:

string
boolean
decimal
float
double
duration
dateTime
time
date

All the heavy lifting in the framework is performed by the ServiceController class. You just supply it with an instance of your service along with a Request object and Response object. These later two objects are expected to be the Request and Response objects from the webapp Framework in the Google App Engine. I’ll discuss more on integrating this class into the webapp Framework in the next section. Finally, to round out this class, it has two methods on it doPost and doGet which are meant to be called with performing an Http Get or Http Post respectively. I have implemented the doGet method to supply the WSDL definition of the service when the endpoint Url is appended with a ?WSDL query string. If it is not supplied it defaults to rendering an Html page with a description of your service. The doPost has been implemented to receive the SOAP requests, call the method on your service class and send the SOAP responses back to the caller.

In the webapp Framework, developers implement Http endpoints by creating Python classes that inherit from the webapp RequestHander class. Developers then implement a get and or post method on this class to handle Http requests. It is in these methods that you would create an instance of the ServiceController class, supplying it with an instance of your web service and then calling ‘doGet’ or ‘doPost’ depending on which method for the RequestHandler you are implementing.

Generating a Proxy in .Net

I had hoped to be able to generate a proxy class right within Visual Studio using the Add Service Reference menu item on the Solution Explorer. I couldn’t get that to work. So I left that as is for now and went to ‘Plan B’ which was to use the wsdl.exe in the Microsoft SDK folder to generate a proxy class for me. That worked. I am not sure of an exact default location of where to find wsdl.exe on developers’ machines. My best advice is to just do a search for it.

Uri of the live Test Service in Google App Engine

Links to the code
An example of the .Net Proxy class I generated to use the Test Service
Source for the Python web service framework
Source for the TestService Python class
Source for the integration of Python Web Service into Google App Engine webapp Framework

Python String Slice as .Net Extension Method

2009-03-18T15:31:00.000-07:00

I have extended the Python list slicing functionality from this post to the .Net string class to allow users a mechanism to "slice and dice" .Net strings like you can in Python. This is accomplished by providing an extension method, Slice(), to the .Net string class and using LINQ under the covers to zero in on the section of the string we are interested in.

You may ask, .Net already has a substring method why would you need another? This one has more functionality (I think at least). Optional start and stop indexes along with support for counting back from the end of a string provides the user with a more flexible solution. How to count back from the end of a string? Provide negative index values for the start and/or stop index arguments.

Example program showing how to use Slice:

static void Main(string[] args)
{
  string hello = "hello";
  Console.WriteLine("Test word hello");
  Console.WriteLine("Expected on the left, result on the right");
  Console.Write("e == ");
  Console.WriteLine(hello.Slice(1, 2));

  Console.Write("he == ");
  Console.WriteLine(hello.Slice(null, 2));

  Console.Write("llo ==");
  Console.WriteLine(hello.Slice(2, null));

  Console.Write("hel == ");
  Console.WriteLine(hello.Slice(null, -2));

  Console.Write("lo == ");
  Console.WriteLine(hello.Slice(-2, null));

  Console.Write("el == ");
  Console.WriteLine(hello.Slice(-4, -2));

  Console.Write("ell == ");
  Console.WriteLine(hello.Slice(1, -1));

  Console.WriteLine("Press Enter to end");
  Console.ReadLine();
}

Source Code for the Slice extension method

Objective-C Messaging in .Net

2009-03-16T20:24:00.000-07:00

First off, I should clarify the title of this post. It really should be “Mimic Basic Objective-C Style Messaging in .Net”. A little history on how this post came to be. I was reading about individual developers creating applications for the iPhone. This got me interested in searching out the iPhone SDK. I found it, read about the XCode development environment and the language used for the iPhone and MaC OS, Objective-C. I had not heard of Objective-C before so I had to find out more.

Objective-C

Like I said I was not familiar with Objective-C so my first stop was to the Wikipedia article about it. As I started reading, the area that jumped out to me was the approach Objective-C took to invoke a method. As stated in the article, “in Objective-C you send a message to an object while in C++, C# or Java you call a method”. The receiver of the message can choose to provide an implementation for the message. From my understanding, if the message is not implemented nothing happens and code execution moves on. Interesting. Throw on top of that an object can choose to forward a message to another object; and it just got me thinking that it would be an interesting experiment to try and mimic that behavior in .Net.

The Experiment

How to implement this? Of course reflection would be needed to dynamically find the method corresponding to the message and then invoke it. The other thing was to figure out how to implement the forwarding of messages.

What I decided to do was create some .Net extension methods on the Object class to allow for the sending of a message to an object, querying an object to see if it implements the message, and finally querying the object to see if it has implemented message forwarding if need be. In Objective-C forwarding is accomplished by the class overriding the forward method. Of course .Net doesn’t have this. What I decided to do was to look for a forward method on the object that had a signature of the first argument being a string (for the message name) and an object array (for the arguments to the message). I would assume that to be the object’s forwarding implementation. I really didn’t need to provide an interface for this since I am dynamically looking for the forward method at runtime. However, for the experiment I did choose to implement one. It is optional and its only functional purpose is to provide the implementer the signature of what the forward method needs to look like.

Method Outline of the Extension Methods on Object

static class ObjectCExt
{
public static T Msg<T>(this object obj, string method, params object[] args)

public static object Msg(this object obj,string method, params object[] args)

public static bool RespondsTo(this object obj, string method, params object[] args)
}

Basic Example

public class MathClass
{
public int Add(int x, int y)
{
  return x + y;
}
}

class Program
{
static void Main(string[] args)
{
  MathClass m = new MathClass();
  int result = m.Msg<int>("Add", 2, 2);
  Console.WriteLine(result.ToString());
}
}

Forwarding Example

public class MathController
{
private MathClass math;
public MathController()
{
math = new MathClass();
}

public object Forward(string message, params object[] args)
{
  if (math.RespondsTo(message, args))
  {
   return math.Msg(message, args);
  }
return null;
}
}

class Program
{
static void Main(string[] args)
{
MathController mc = new MathController();
result = mc.Msg<int>("Add", 2, 2);
Console.WriteLine(result.ToString());

}
}

Source Code

Compress Byte Arrays in .Net

2009-03-07T13:43:00.000-08:00

This is some utility code I have been using to compress and decompress byte arrays using the .Net Framework’s compression classes. There are two compression classes available, GZipStream and DeflateStream, and they are found in the System.IO.Compression namespace. This example uses GZipStream. I did find a lot of examples on how to use the classes in relation to compressing file streams, but had to do a little more digging and experimenting to make it work with memory stream and byte arrays. I have found this code to be very useful in compressing items such as images for storage in a database. Though I haven’t tried it, it should work quite well in messaging scenarios too.

This example reads in a file, compresses data in memory, decompresses the data in memory and then writes the results out to a new file. Try your own file in the example. When it is completed, paste the contents of each file into NetDiff (a web based diff utility I wrote) to verify the files are identical.

Example:

using System;
using System.Text;
using System.Collections.Generic;
using System.IO;
using System.IO.Compression;

namespace ConsoleZip
{
class Program
{
  static void Main(string[] args)
  {
   byte[] data = File.ReadAllBytes("c:\\test.log");
   byte[] compressed = Compress(data);
   byte[] decompressed = Decompress(compressed);
   File.WriteAllBytes("c:\\test2.log", decompressed);
}

static byte[] Compress(byte[] input)
{
  using (MemoryStream output = new MemoryStream())
  {
   using (GZipStream zip = new GZipStream(output,CompressionMode.Compress) )
   {
    zip.Write(input, 0, input.Length);
   }
  return output.ToArray();
  }
}

static byte[] Decompress(byte[] input)
{
  using (MemoryStream output = new MemoryStream(input))
  {
   using (GZipStream zip = new GZipStream(output, CompressionMode.Decompress))
   {
    List<byte> bytes = new List<byte>();
    int b = zip.ReadByte();
    while (b != -1)
    {
     bytes.Add((byte)b);
     b = zip.ReadByte();

    }
    return bytes.ToArray();
   }
  }

}
}

ASP.Net SQL Session State Not Expiring

2009-03-06T15:02:00.001-08:00

I was debugging an ASP.Net web application that was using SQL Server session state and it wasn’t appearing to timeout. What I discovered, after some digging online, is that you need to have the SQL Agent service up and running. It handles the expiration of session states stored in SQL Server and if it is not running your session states will not expire.

Set WCF Metadata Exchange in Code

2009-02-28T13:09:00.000-08:00

I was looking for an example on how to setup a MetadataExchange binding for a WCF ServiceHost in code. I readily found examples how to do it with a configuration setting, but had to do some digging to find how to configure it in code. I am posting what worked for me for others to use and for an easy reference for me to go back to. This example is for a simple MathService to add two integers.

Uri baseAddress = new Uri("http://localhost:2202/MathService");

BasicHttpBinding binding = new BasicHttpBinding();

ServiceHost myServiceHost = new ServiceHost(typeof(MathService), baseAddress);
myServiceHost.AddServiceEndpoint(typeof(IMathService), binding, baseAddress);
myServiceHost.Description.Behaviors.Add(new ServiceMetadataBehavior());
myServiceHost.AddServiceEndpoint(typeof(IMetadataExchange), MetadataExchangeBindings.CreateMexHttpBinding(), "MEX");

myServiceHost.Open();

FxCop Double Thunk Rule

2009-02-20T19:58:00.001-08:00

A few years ago I was working on a project that was converting an enterprise business application from being compiled in unmanaged C++ to compiling it in managed C++. The purpose was to get it running on the CLR to expose it for integration with other .Net projects we were working on that were using C#. One of the issues with converting an existing C++ application to build on the .Net Framework is the problem known as a double thunk. A double thunk occurs when program execution hops from managed code to native code and then back to managed code. Why is it an issue? You take a performance hit each time you switch from managed to unmanaged code or vice versa. And with a double thunk you get hit twice. In managed C++ this happens with function pointers and calling virtual functions. However there is a C++ keyword you can use __clrcall to fix the issue. Check out this MSDN article for more information on it.

To help track down those issues I developed an FxCop rule to check for these double thunks. This rule works on the FxCop 1.35 version. I have includes a zip file of the source code for this rule and provided a link to it at the bottom of this post. In that project are references to two assemblies from FxCop. So if you decide to upgrade to newer versions of FxCop you would probably need to replace those assemblies. Anyways, assuming FxCop 1.35, once you build the code you just need to copy the resulting assembly to the Rules folder of the FxCop install location. FxCop will then be able to load and use the rule from that location.

I have verified this rule works with the C++ example in the MSDN article I referred to earlier.

Double Thunk Rule zip file

Sharks and Fish Computer Simulation

2009-02-13T10:36:00.000-08:00

Back in one of my first C++ programming classes in college we had an assignment to build a computer simulation to model the population dynamics of sharks and fish. It is based on a Scientific American’s “Computer Recreation” column in 1984. This is the document I used to refresh my memory on the topic. I thought it was a fun assignment then and decided to revisit it now, but this time use JavaScript as the programming language.

The world the fish and sharks reside in is called ‘Wator’ and there are rules on how the sharks and fish behave and live in this environment. The basics of the simulation are as follows:

The sharks and fish live in an ocean represented by a grid. For this example, our grid is going to be a 20 x 20 Html table. There are no boundaries in the grid. Items can move off one side of the grid and reappear on the opposing side. The sharks and fish can only move in the horizontal or vertical direction and can only move one space in each round of the simulation.

Rules for Sharks:
1. Each round a shark looks for a fish next to it and it eats it if it finds one. The shark will then move to that fish’s position in the grid. Remember, the shark (and fish) can only look north, south, east or west.

2. If a shark cannot find a fish it then looks for a free cell to swim to. If none are found, the shark stays where it is.

3. A shark must eat a fish in certain number of rounds or it will die. This is a parameter the can be adjusted as part of simulation set up.

4. A shark, after it lives certain number of rounds, will attempt to breed. It can only breed it there is room for it to move to a free cell. The child occupies the cell left by the parent. If there is no room to move; no action is taken and the shark will attempt to breed again in the next round.

Rules for Fish:
1. Each round a fish will attempt to swim to a free cell next to it. If none are found it stays in the same location.

2. After certain number of rounds the fish will attempt to breed. It follows the same pattern as for the sharks.

The Simulation

Virtual Florida Keys Vacation with Forth

2009-01-26T14:32:00.000-08:00

I have been itching to take a vacation to some place warm this winter, but it is just not in the budget this year. So I decided to use my Script Google Street View with Forth site and take a little virtual vacation to the Florida Keys. I have put together 5 panoramic slides of some places I found while “Google vacationing” around the Florida Keys. I listed out the slides below along with a link to view the slide show. I can’t wait to go back :). Enjoy!

Slides
1. Over Sea Highway near Middle Key, FL
2. Ocean View at Summerland Key, FL
3. Ocean view Key West, FL
4. Front Street in Key West, FL
5. Beach view in Key West, FL

To the slide show

Check out this post for more detail on how to share Google Street View scripts by adding them as a query string to the Url.

Share Google Street Scripts as Hyperlinks

2009-01-12T13:31:00.000-08:00

Background
I have created a site that allows users to create scripts to automate the panoramas in Google Street View using the programming language Forth. I am able to use Forth in the browser by using a JavaScript based Forth interpreter I developed.

Sharing a script that you have written is easy. Just append the script as a query string to the Program Google Street View site and send it to whomever or place it on a page as a hyperlink. This configuration will cause the site to load the script into the Forth console and execute the program when the site is loaded in a browser.

Let’s look at an example. The following program performs a 360 pan of Times Square in New York City.

100 pace 40 757584 -73 985642 latlng 360 0 do i yaw 5 +loop

To share this program, create a hyperlink as such:
http://solidcodingarchive.appspot.com/resources/StreetView.htm?100%20pace%2040%20757584%20-73%20985642%20latlng%20360%200%20do%20i%20yaw%205%20+loop

I have added a new tool to the Program Google Street View site to assist in the creation of these hyperlinks. To open the tool, click on the ‘Share Script’ button at the bottom center of the page.

Additional Examples

Geno’s Steaks, Philadelphia, PA
http://solidcodingarchive.appspot.com/resources/StreetView.htm?39%20933588%20-75%201590154%20latlng%2010%20yaw

Sears Tower, Chicago IL
http://solidcodingarchive.appspot.com/resources/StreetView.htm?41%20877654%20-87%20634887%20latlng%200%20yaw%20next%20next%2090%200%20do%20i%20-1%20*%20%0D%20pitch%205%20+loop

Empire State Building, New York NY (program includes Forth word definition to look west)
http://solidcodingarchive.appspot.com/resources/StreetView.htm?:%20west%20270%20yaw%20;%20100%20pace%2040%207483491%20-73%209846147%20latlng%20270%20west%2090%200%20do%20i%20-1%20*%20pitch%205%20+loop

Grauman's Chinese Theatre, Los Angeles CA
http://solidcodingarchive.appspot.com/resources/StreetView.htm?100%20pace%2034%201015533%20-118%203409672%20latlng%200%20yaw%20360%200%20do%20i%20yaw%205%20+loop%2045%200%20do%20i%20-1%20*%20pitch%205%20+loop%205%20pitch

Embedding and Extending wForth

2009-01-03T06:21:00.000-08:00

Recently I had a comment on one of my wForth posts inquiring about how I embedded wForth with Google Street View. First, I should probably provide a little background on the wForth implementation. wForth is built around the ability to dynamically execute JavaScript code using JavaScript’s eval() function. There are two main JavaScript classes that make up wForth, ForthEngine which is the wForth virtual machine and the Forth class which contains the core Forth words (keywords) that are used to manipulate the wForth virtual machine. Below I have provided a brief outline of the functionality of each of these classes.

ForthEngine

1. It is the virtual machine of wForth

2. Found in wForth.js

3. Can be referenced by the global variable, engine, which is initialized when the wForth.js is loaded by the browser.

4. Manages the stacks, code execution pointers, function call stacks, loop management and console feedback

5. Includes a system dictionary containing a list of the Forth core words
a) Stored as a simple dictionary table using the Forth word as the key and the corressponding Forth class function (as a string) as the value. The string value of the Forth class function is executed using the JavaScript eval function

b) Can be edited at runtime to add additional Forth words to the system dictionary. This is what I did to intergrate wForth with Google Street View

6. Maintains the linked list for the user defined Forth words created within the wForth system

7. There are functions to push, pop, and peek both the parameter stack and return stack. That is what the Forth class uses to interact with the wForth virtual machine

Forth
1. Provides a JavaScript function for each of the core set of Forth words found in the system dictionary

2. Provides it own eval function to allow Forth programs to be entered as a string and translated

3. Contains the parser to extract Forth words from strings

4. Loads Forth programs into the wForth virtual machine

5. Contains the interpret function which executes the next Forth word in the wForth virtual machine

6. Found in wForth.js

At its simplest in code, all that needs to be done to run a Forth program in wForth is to call the eval function on the Forth class. You will not get any feedback without a console, but the program will run.

Ex.
Forth.eval(“ 2 2 +”) leaves the number 4 on the stack

There is another eval function as well, Forth.eval_i. The difference between the two is that the eval() will write output to the console when it finishes executing. Eval_i() will write output after the execution of each Forth word, if there is any. So the latter provides more interactive feedback.

To add a console just supply the wForth virtual machine with a reference to a Html element that you want to use as the console. The engine then has all it needs to write output to the user. To send programs to the wForth virtual machine from the console; just call one of the Forth eval functions when the data is done being entered.

To add your own Forth words to the system dictionary, which I did with Google Street View integration, you just need to add those words to the system dictionary. This is done in the wForth virtual machine by adding an entry for each new Forth word and its JavaScript implementation. Remember it is the JavaScript function which is used to interact with the wForth virtual machine and any other system you need to work with. Like in my case the Google Street View API. The best place to add these new words is on a page load. As an example, here is code snippet from my Google Street View implementation showing how to intregate wForth with Google Street View.

Add Forth Words to Google Street View Scripts

2008-12-14T11:12:00.000-08:00

In my last post I introduced scripting Google Street View with Forth. I would like to build on that post by providing some Forth words (subroutines) you can write to handle some common tasks in programming against Google Street View. For example a 360 pan and change the position to face north. You should be able to paste the following program into the Forth console and have it perform a 360 pan of Times Square in New York and then finish with the view looking to the east. Once pasted in the Forth console, hit enter to execute the program.

Link to the Program Google Street View web page IDE.

: 360pan 360 0 do i yaw loop ;

: north 0 yaw ;

: south 180 yaw ;

: east 90 yaw ;

: west 270 yaw ;

: times_sqr 40 757584 -73 985642 latlng ;

100 pace times_sqr 360pan east

Script Google Street View with Forth

2008-12-09T20:25:00.000-08:00

Utilizing wForth, check this post for an introduction on it, I have created a customized Forth to Google Street View dictionary that allows programmers to automate manipulating Google Street View using a Forth programming language.

The wForth console has been improved since my first post. The console is more interactive with feedback; the results display instantaneously instead at the end of a program execution. Also there is the ability to paste Forth programs into the console window and have them parsed correctly.

Check out the Google Street View and Forth integration IDE page here.

Also checkout my virtual Florida Keys vacation slide show I built using this site.

wForth - A JavaScript Forth Interpreter

2008-12-03T16:36:00.000-08:00

‘wForth’ is a JavaScript based Forth interpreter. It is a simplified version of Forth and doesn’t contain all the functionality of a ANSI Forth system. The main goal of it is to provide a basic web based platform for people to try out programming with Forth. At the same time though, I wanted it flexible enough to allow programmers to write their own JavaScript Forth dictionaries to customize and extend the system. For example, allow wForth to interact with others aspects of the browser or to hook into Ajax calls to interact with servers.

Why wForth? jForth, jsForth, webForth were all taken. So wForth is for web based Forth.

What is supported:

1. New Forth word creation
2. Standard math operators on integer types only
3. Parameter stack manipulation
4. Infinite loops
5. Do loops
6. Pass data to and from the parameter stack to the return stack
7. Conditionals (if. then.else)

Try it out:

Future Items:
Storing user defined Forth word dictionaries in cookies or serializing them to and from JSON format to mimic loading them from a disk.

Netdiff - A JavaScript Based File Comparison Utility

2008-11-11T07:16:00.000-08:00

Lately I have been interested in developing an internet application built in pure JavaScript to provide a service that does not rely on post backs to a server to process logic. The project I have been working on is NetDiff, which is a pure JavaScript based file comparison utility.

There are some challenges in doing such an application in JavaScript. One of the first ones I discovered, because of security considerations, was the finding and loading of the files I wanted to compare. There is no such direct mechanism to do this. I did find examples and suggestions of using ActiveX to read files, but that would have limited me to Internet Explorer. I also tried uploading the files using the input file tag with some additional JavaScript hocus pocus. I would use the browse functionality to locate the file and provide the path. Once I located both files, I would click a button which would copy the paths to a set of hidden IFrames and have it load the file contents for me. After it loaded, I would then read the contents of the hidden IFrame and store it in a JavaScript string. The issue with that was you can only read the contents of those IFrame if the source came from the same location as the main html page. So, it wouldn’t work either. So I just decided to have the users paste in the contents of the files and compare from there.

The other issue, I guess it wasn’t that bad, was encoding the lines from the document correctly so it would display in HTML. That included the common culprits of ‘less than’ and 'greater than’ along with trying to maintain tabs from the original document.

The core of the algorithm is finding the longest common sequence (LCS) of the files. Once you find that, the files can be aligned along that sequence. After that you move in a recursive manner to find the next LCS above and below the one you just aligned the files on. I learned about this algorithm from this post: A Fast Diff Algorithm in Visual Basic .Net.

I chose Microsoft’s windiff as the model on how to display the file comparison results to the user. I know some people like it, and others hate it. It was just a fairly simple and familiar model to follow.

Please follow this link to check out NetDiff.

Send MSMQ Messages to Biztalk with .NET

2008-10-09T09:41:00.000-07:00

I had been looking to use an MSMQ to send messages to a Biztalk server from a .NET WSE 3.0 enabled web service. The item of concern for me was how to setup the message correctly in .NET in order for it to be read in Biztalk. The web service was accepting the incoming XML messages as a string and I wanted to keep it in that format to send to Biztalk. It would be just like Biztalk accepting XML files from a file adapter.

There are resolutions out there on how to do it, but I hadn’t found a code example to show how. That’s what I wanted to provide here. The trick to use MSMQ from .NET to send messages described above, is to skip using the Body property on the Message class or in the constructor and instead write to the BodyStream property. The reason is, if you use the Body property or constructor, it will serialize the message as XML. We don’t need to do that, we just need to send the message as is. That is performed by writing directly to the BodyStream property of the Message class.

This example shows how to read an XML file and stream it into the Message class. You can easily convert to read from any string you want. You will need to add a reference to System.Messaging.dll and use the System.Messaging namespace.

MessageQueue queue = new MessageQueue(@".\private$\queue1");
Message msg = new Message();
using (StreamWriter writer = new StreamWriter(msg.BodyStream))
{
  writer.Write(File.ReadAllText("example.xml"));
  writer.Flush();
  queue.Send(msg);
}

Full Outer Join in LINQ

2008-09-16T16:07:00.000-07:00

While I haven’t found any direct support for a right outer join or full outer join in LINQ, I did work out a solution to mimic a fuller outer join. I started by building a left outer join like I did in my post, Left Outer Join in LINQ, and then union those results with another left outer join LINQ query which swaps the sides of the join from the first query. So in effect what you are doing, using the C# classes from my previous post, is performing a left outer join from Person to PersonAddress and union the results with a second query performing a left outer join from PersonAddress to Person. The key is to make sure to use the same columns in each select like would be required performing a union in SQL. It isn’t pretty, but it seems to work.

LINQ Query

var query = (from p in dc.GetTable<Person>()
join pa in dc.GetTable<PersonAddress>() on p.Id equals pa.PersonId into tempAddresses
from addresses in tempAddresses.DefaultIfEmpty()
select new { p.FirstName, p.LastName, addresses.State }).Union(
from pa2 in dc.GetTable<PersonAddress>()
join p2 in dc.GetTable<Person>() on pa2.PersonId equals p2.Id into tempPersons
from persons in tempPersons.DefaultIfEmpty()
select new { persons.FirstName, persons.LastName, pa2.State });

SQL Translation

SELECT [t4].[FirstName], [t4].[LastName], [t4].[value] AS [State]
FROM (
SELECT [t0].[FirstName], [t0].[LastName], [t1].[State] AS [value]
FROM [Person] AS [t0]
LEFT OUTER JOIN [PersonAddress] AS [t1] ON [t0].[Id] = [t1].[PersonId]
UNION
SELECT [t3].[FirstName] AS [value], [t3].[LastName] AS [value2], [t2].[State]
FROM [PersonAddress] AS [t2]
LEFT OUTER JOIN [Person] AS [t3] ON [t2].[PersonId] = [t3].[Id]
) AS [t4]
-- Context: SqlProvider(Sql2005) Model: AttributedMetaModel Build: 3.5.21022.8

Roomba Web Remote

2008-09-11T14:36:00.000-07:00

This project is a combination of two prior projects with the additional help of JSON serialization and Ajax to provide an interactive web page to start and monitor a Roomba. The Python web server project is merged with the Python Roomba SCI project to provide a web server capable of handling Roomba commands from and providing sensor data to a web page. The current implementation I have allows one to start the clean process and then monitor the sensor data of the robot while it cleans. This latter functionality is achieved by making Ajax calls requesting the sensor information to the web server in a timed loop. The web server forwards the sensor data request to the Roomba and then packages up the result using JSON to send back to the web page. The web page deserializes the sensor data and displays it on the page. Once the clean process is started, there is also functionality to stop the clean process and shut off the Roomba.

The bottleneck in the application is the wait time getting the sensor information from the robot to the web server. Another issue is when the Roomba gets out of range for my Bluetooth connections causing the sensor information to not get updated in the web page.

The source for the web server and Roomba integration can be found here

If you want to see the web page it is here. Should note, though, this version isn’t pointing to my web server so it will not actually work. There is a line in the source to point it to your own web server, and that will make it work.

Boolean Extension Methods for UI Conversions

2008-09-08T11:19:00.000-07:00

Recently I was working with a teammate on a user interface project. There was a requirement to display a Yes or No value in a textbox. The data type choice used to record that value in the underlying database was a Boolean value; which makes sense. However, what that forces one to do is provide conversions from the Yes or No value to the text box to a Boolean value and vice versa, from a Boolean to a Yes or No value. That gets cumbersome.

The solution we chose to consolidate those conversions was to add extension methods to the Boolean data type to handle changing to and from a Yes or No value to a Boolean value. Also, in this example I added functionality to convert from an int and from an On or Off string.

class Program
{
static void Main(string[] args)
{
  bool x = false;
  x = x.FromYesNo("yes");
  string s = x.ToYesNo();
}
}

public static class BooleanExt
{
public static string ToYesNo(this bool val)
{
  return val ? "Yes" : "No";
}

public static bool FromYesNo(this bool val, string yesOrNoString)
{
  return yesOrNoString.ToLowerInvariant() == "yes";
}

public static int ToInt(this bool val)
{
  return val ? 1 : 0;
}

public static bool FromInt(this bool val, int value)
{
  return value > 0;
}

public static string ToOnOff(this bool val)
{
  return val ? "On" : "Off";
}

public static bool FromOnOff(this bool val, string onOffString)
{
  return onOffString.ToLowerInvariant() == "on";
}
}

Host a WCF Service in a Windows Form Application

2008-08-19T15:52:00.000-07:00

I have been working on a prototype Windows application that is being used to provide a user interface to a WCF service I have been working on. The goal was to quickly get an application up and provide some data entry forms to allow users to interact with the WCF service. My team wanted to get some early feed back from the users on the computations provided by the service. To ease the implementation, I had the idea to have the Windows applications not only to be the client but to also host the service.

I initially got the service up and running but I could not get the client portion to work correctly. It was always timing out on me. I had placed the service host code in the start up form of the application. After some experimenting it seems the location that the service host code needs to be in is in the Main function of the application. This is easily found in C# in the generated Program.cs file. There is a little more work involved to get this to work in VB.Net.

In a VB.Net Windows application, the Main function and all that start up code is hidden from you by default. However, there are options in the project file that allow you to override this and have a Main function you can manipulate like C#. In a VB.Net Windows application do the following in order to setup your own Main function.

1. Right click the project folder and select Properties

2. In the Application tab, uncheck Enable Application Framework

3. In Start Up Object, select Sub Main

4. Back in the Solution Explorer, add a new Module file with a Sub named Main

5. Add the following code to Main, replacing Form1 with your startup form

   System.Windows.Forms.Application.EnableVisualStyles()
   System.Windows.Forms.Application.SetCompatibleTextRenderingDefault(False)
   System.Windows.Forms.Application.Run(New Form1())

To now add the service host what I did was wrap the service host in a using statement and then added the code from above inside the using statement. It would like the following in VB.Net.

Public Sub Main()
Using host As ServiceHost = New ServiceHost(GetType(MyWCFService))
   host.Open()
   System.Windows.Forms.Application.EnableVisualStyles()
   System.Windows.Forms.Application.SetCompatibleTextRenderingDefault(False)
   System.Windows.Forms.Application.Run(New Form1())
End Using
End Sub

Unit Testing WCF

2008-08-06T21:11:00.001-07:00

I was working on trying to develop some unit tests for a WCF service I had written using Visual Studio test services and came up with solution to initialize a host and client instance inside the same unit test. In order to generate the proxy classes for the client, I did have to create a temporary console application to host the service. Once the proxy code was in place I copied the relevant service configuration code in the app.config and moved it to the app.config of my unit testing class library. So the app.config in the unit test library contains configuration information for both the client and host.

In the following unit test example the WCF service is AddService and the client proxy is AddServiceClient.

[TestMethod()]
public void AddTest() {
using (ServiceHost host = new ServiceHost(typeof(AddService))) {
  host.Open();
  using (AddServiceClient client = new AddServiceClient()) {
   Assert.AreEqual<int>(4,client.Add(2,2));
  }
}
}

Python Library for the Roomba SCI

2008-07-17T13:13:00.000-07:00

I had created a .Net library for the Roomba SCI, so in a quest to learn more about Python, I decided to duplicate that work and create an implementation of the same API using Python. It uses the pyserial module for serial communication which is available for download at http://pyserial.wiki.sourceforge.net/pySerial.

This class library only works with the new RooTooth modules. To work with older RooTooth modules, or direct serial connects, one could overwrite the ‘Connect’ and ‘Wakeup’ functions on the RoombaAPI class.

Like the .Net version, all the Roomba SCI commands are methods on the RoombaAPI class with the exception of the sensor information which is available via the sensors property. That property returns an instance of the SensorData class which breaks out each sensor value into its own property or for related sensors as propeties of a sub class off of SensorData. For example the cliff sensors are grouped together in the Cliff class which is available as a property off of the SensorData class.

The source is available here. Also included in this source is a simple example of using the API to start the robot and send it a few commands and also ask for some sensor information.

Python List Slicing in LINQ

2008-06-19T10:59:00.000-07:00

I have been working with Python lately and I really like its list slicing functionality. Working with that gave me the idea of trying to incorporate the same functionality into LINQ and also to make it available in LINQ to SQL.

As a refresher, in Python, you are able to perform the following types of slice operations on a list. Negative numbers indicate counting is beginning from the back of the list (moving right to left). Ex. -1 points to the last item in the list.

>>> li = [“a”,”b”,”c”,”d”,”e”,”f”]

>>> print li[0:3]
[“a”,”b”,”c”]

>>> print li[1:3]
[“b”,”c”]

>>> print li[1:-1]
[“b”,”c”,”d”,”e”]

>>> print li[-6:-4]
[“a”,”b”]

The most interesting part in the implementation of this for LINQ and LINQ to SQL is the handling of the negative indexes. Like I stated earlier, it is an indication to count from the back of the list. That means you need to know the number of items in the list. That’s easy with LINQ, but using LINQ to SQL a call to get the count would generate a SQL statement to get the count of items in the underlying table. I wanted to avoid that and try and build one LINQ to SQL statement to get the data. I was able to get it to work in the LINQ case using a combination of Skip, Take, Reverse, Union, and Intersect. However I ran into issues in LINQ to SQL stating the Reverse operator is not supported. So I went back to getting the count and adding the negative indexes to that to get the position of the start and stop. Even though it is two calls to the database, it is probably more efficient than the SQL statement it would have (if it could have) generated. I left the original implementation in place for the LINQ case for those interested in how that worked.

The source file is available here.

The following is a set of tests run against the LINQ to SQL slice functionality to see what the generated SQL would look like. It shows how the operation is performed in Python, how to perform the same thing in LINQ to SQL, and what the generated SQL statements looks like.

In the LINQ examples variable dc is an instance of DataContext

Test 1
Python Slice

li[0:3]

LINQ Slice

(From p In dc.GetTable<Person>.Slice(0, 3)).ToList()

Generated SQL

SELECT TOP (3) [t0].[Id], [t0].[FirstName], [t0].[LastName]
FROM [Person] AS [t0]

Test 2
Python Slice

li[1:3]

LINQ Slice

(From p In dc.GetTable<Person>.Slice(1, 3)).ToList()

Generated SQL

SELECT [t2].[Id], [t2].[FirstName], [t2].[LastName]
FROM (
SELECT [t1].[Id], [t1].[FirstName], [t1].[LastName], [t1].[ROW_NUMBER]
FROM (
SELECT ROW_NUMBER() OVER (ORDER BY [t0].[Id], [t0].[FirstName], [t0].[LastName]) AS [ROW_NUMBER], [t0].[Id], [t0].[FirstName], [t0].[LastName]
FROM [Person] AS [t0]
) AS [t1]
WHERE [t1].[ROW_NUMBER] BETWEEN @p0 + 1 AND @p0 + @p1
) AS [t2]
ORDER BY [t2].[ROW_NUMBER]

Test 3
Python Slice

li[1:-1]

LINQ Slice

(From p In dc.GetTable<Person>.Slice(1, -1)).ToList()

Generated SQL

SELECT COUNT(*) AS [value]
FROM [Person] AS [t0]

SELECT [t2].[Id], [t2].[FirstName], [t2].[LastName]
FROM (
SELECT [t1].[Id], [t1].[FirstName], [t1].[LastName], [t1].[ROW_NUMBER]
FROM (
SELECT ROW_NUMBER() OVER (ORDER BY [t0].[Id], [t0].[FirstName], [t0].[LastName]) AS [ROW_NUMBER], [t0].[Id], [t0].[FirstName], [t0].[LastName]
FROM [Person] AS [t0]
) AS [t1]
WHERE [t1].[ROW_NUMBER] BETWEEN @p0 + 1 AND @p0 + @p1
) AS [t2]
ORDER BY [t2].[ROW_NUMBER]

Test 4
Python Slice

li[-6:-4]

LINQ Slice

(From p In dc.GetTable<Person>.Slice(-6, -4)).ToList()

Generated SQL

SELECT COUNT(*) AS [value]
FROM [Person] AS [t0]

SELECT TOP (2) [t0].[Id], [t0].[FirstName], [t0].[LastName]
FROM [Person] AS [t0]

.Net Class Library for the Roomba SCI

2008-06-12T09:38:00.000-07:00

This is the class library I have been using to interact with the Roomba. It is a class library written in C# targeting the .Net 3.5 Framework. I have used some LINQ queries to parse out the byte array that is returned when you request sensor information. The main class to work with in the library is the RoombaAPI class. It is used to connect to the Roomba, send commands to it, and retrieve sensor data from the robot.

I am not sure if others have done this or not, but in my opinion the most usefully part of the library is the parsing out of the sensor information into a set of objects and properties to allow easy access by a user. The way it works is that you ask the Roomba for all the sensor information, 26 bytes, and the information is returned in a class named SensorData. Some of the data such as the cliff sensors are broken out into their own class Cliff which has properties Left, FrontLeft, FrontRight and Right and is accessed via the SensorData’s Cliff property. Other sensor data, such as Temperature is a property of type short on the SensorData class.

This class library only works with the new RooTooth modules. To work with older RooTooth modules, or direct serial connects, one could override the ‘Connect’ and ‘Wakeup’ functions on the RoombaAPI class.

To use in your code add a reference to the class library and add the namespace RoombaSCI. All the command functions and the ‘Sensors’ properties are marked as virtual so developers can override as needed. I haven’t gotten around to implementing the Song function to record your own songs. So that would be a good candidate to override and provide an implementation for.

I also have implemented a “Log” property so you can hookup any log writers you want to the class libray. I have one implemented, DebugWriter, that writes log info out to the debug window in Visual Studio.

Just the .dll, in a .zip file, is available here

A .zip file of the source project is here

Example code to connect to the Roomba, starts the clean sequence, and asks for some sensor data.

using (RoombaAPI api = new RoombaAPI("COM5",115200))
{
api.Log = new DebugWriter();
api.Connect();
api.Control();
api.Clean();
System.Threading.Thread.Sleep(5000);
Console.WriteLine(api.Sensors.Angle.ToString());
api.Off();
}

Wake Up Roomba Using Latest RooTooth

2008-06-02T21:12:00.000-07:00

I was able to finally figure out the commands needed to ‘wake up’ the Roomba using the new RooTooths based on the Roving Network Bluetooth Module. You need to set the module to command mode and toggle pin GPIO 7.

Here are the commands that worked for me. The SendToRoomba function is just a wrapper function around the SerialPort.Write(string) function in .Net 3.5.

SendToRoomba("$$$");
//Set GPIO 7 as output
SendToRoomba("S@,8080\n");
//set GPIO 7 low
SendToRoomba("S&,8000\n");
System.Threading.Thread.Sleep(500);
//set GPIO 7 high
SendToRoomba("S&,8080\n");
//exit command mode
SendToRoomba("---\n");

Also another thing I did was to turn off the config timer so that the command mode is always available.

Voice Controlled Roomba Using .Net 3.5

2008-05-22T21:45:00.000-07:00

I am developing a C# application that listens for voice commands, translates them to instructions understood by Roomba, and sends the request to the robot. A Bluetooth headset is used to send the voice commands to the application which is using the .Net Framework’s System.Speech.Recognition classes to process the commands. Recognized commands are converted to opcode instructions understood by the Roomba’s Serial Command Interface. Also, those commands are echoed to the screen and spoken using the .Net Framework’s speech synthesizer to provide feedback to the user. A Bluetooth adaptor on the Roomba, a Rootooth, receives the translated opcodes from the application and passes them through to the Roomba.

Source code for the voice controller part of the application is available here. I am still working on cleaning up the code that communicates with the Roomba. I'll try and post that at a later date. There is functionality I haven't tested yet such as playing and recording songs that I would like to get implemented.

I have also included a video demo of the application in action.

Screenshot of the application:

5/29/08 -- Doing some more work with the voice commands by adding the ability to query some of the sensors on the Roomba. The video shows, getting the battery temperature, battery charge, and the presence of any virtual walls.

Fuel Cost and Trip Planner

2008-05-01T17:06:00.000-07:00

I improved the original fuel cost calculator by incorporating it into Google Maps. You can now choose a start and end destination and the calculator will retrieve the distance traveled from the Google Map API. The application will display the route in a Google Map as well as displaying the step by step directions. There is another new feature in the calculator that allows you to state the size of the vehicle’s gas tank. With that information along with the MPG of the vehicle, the calculator can determine how many miles the user can travel on a tank of gas. What it will then do is add markers to the map to inform the user that they may need to refuel at that point in their journey. When the user clicks the marker, a balloon window will contain a link to a GasBuddy.com map which contains fuel stations in that area along with current prices.

The application can be viewed here.

Python Web Server

2008-04-29T15:09:00.000-07:00

I have been working with Python recently and it has been really fun getting to learn the language. I had built my own simple web server with C# and I decided to try my hand at building one in Python in an effort to learn the language. There are several examples out there, but the ones I found where really simple and just returned html files or plain text. I wanted one that could serve up several different types of Internet files, such as .html, .gif, .jpg, pdf, .xls, etc. Also it needed to support a simple virtual directory mechanism.

I have one up and running that achieves these goals. It has been tested with .html, .zip, .doc. .pdf, .jpeg and has worked in all those cases.

The source file can be obtained here.

This server uses the Python mime type module to map file extensions to mime types. It uses an in memory list of virtual directory mappings and allows a developer to add more directories as needed. However that would then require a restart of the server. It would be very simple to move to a database lookup, but I left it this way so it can easily be tested and used by others.

Fuel Cost Calculator

2008-04-27T13:38:00.000-07:00

With fuel prices projected to reach $4.00 a gallon this summer, this fuel cost calculator will allow to determine how much that trip will affect your budget. Just enter the cost of gas per gallon, the mile per gallon your vehicle gets, and the length of your trip in miles. The calculator will compute how much it costs you per mile to drive your vehicle, the amount of fuel you will you, and the estimated cost to make that trip.

Forth.Net Update: Source File Support

2008-04-19T10:52:00.000-07:00

Functionality has been added to compile Forth.Net programs from source files. Previously, Forth.Net programming had to be done interactively in the Forth interpreter or by building Forth words in Visual Studio. To use this feature simply supply the full path of the source file to the Forth.exe on the command line. Any Forth word definitions, variables and constants in the source file are added to the well known assembly ForthWords.dll while Forth words for execution are added to the compiled .Net console application. The name of this console application will be the name of the source file.

Additional information, along with the source code, on the Forth.Net environment is available here

Hosting Forth.Net in a Windows Form

2008-04-14T08:11:00.000-07:00

With gas prices increasing I thought it would be interesting to create a Forth.Net program to calculate the cost per mile to drive my vehicle. The program will take in the price of gas, the miles per gallon of my vehicle and will compute the cost to drive it per mile. For example, if gas is $3.25 and I am getting 17 MPG it is costing me 19 cents per mile to drive my vehicle.

The twist with the Forth.Net program is the end product will be hosted in a Windows form. First, we will create the Forth words for the program in the Forth.Net compiler. Them we will create a Windows form to hold a textbox for the cost of gas, the miles per gallon and the result of cents per mile. A calculate button will be placed on the form, and the code behind that button will start the Forth program, pass in the inputs, and call the necessary Forth words, and get the result left on the Forth stack placing it in the cents per mile textbox.

The Forth.Net environment is available here

Open the Forth.Net compiler, Forth.exe, and implement the following Forth words.

: ToCents (dollar cents – cents) swap 100 * + ;

: CentsPerMile (gasdollar gascents mpg -- cents_per_mile)
rot swap ToCents swap / ;

In Visual Studio 2008, create a new Windows Application.

Add references to ForthAPI.dll and ForthWords.dll. ForthWords.dll contains the Forth words that you just created.

Setup the UI like the one shown and enter the following code in the button click event

private void button1_Click(object sender, EventArgs e)
{
  Forth f = new Forth();
  //f.Lit() is the function to add values to the stack.
  //'Lit' short for literal
  f.Lit(Convert.ToInt32(txtDollar.Text));
  f.Lit(Convert.ToInt32(txtCents.Text));
   f.Lit(Convert.ToInt32(txtMPG.Text));
  f.Centspermile();
  txtCentsPerMile.Text = f.DotGet().ToString();
}

The windows application project is available with the Forth words already implemented in the ForthWords.dll here and the components to just run the application are here

Diff Algorithm with LINQ

2008-04-07T07:48:00.000-07:00

A year or so ago I wrote a diff application similar to windiff based upon the core algorithm discussed in A Fast Diff Algorithm in Visual Basic .Net. Somewhere along the way of upgrading my computer I lost that application. I decided to go back and recreate that application, but this time focus on using LINQ as much as possible in the implementation. It is probably not the fastest, but it is intended to be an exercise in incorporating LINQ in the implementation of an algorithm.

What I have at this point is code that will find the longest common sequence (LCS) of two string arrays. An extension method, LCS, is available on any string collections that implements the IEnumerable interface. You start with an original string collection, and pass the LCS function another string collection that you would like to diff against the original. What you are returned is a DiffInfo class which contains the start index of the LCS in the original string collection, the start position of the LCS in the comparing string collection, and finally the length of the LCS. With that information we have a foundation on which to build an application to show the diff of the two string collections. I will build that application in later posts.

Example:

string[] org = {"A","A","z", "A"};
string[] cmp = {"z", "A", "A", "A", "A"};
DiffInfo d = org.LCS(cmp);
//index = 0
Console.WriteLine("LCS start in orginal " + d.OriginalStartPos.ToString());
//index = 1
Console.WriteLine("LCS start in compared " + d.ComparedStartPos.ToString());
// length = 2
Console.WriteLine("Length of LCS " + d.Length);

Code available here

Roomba Hacking, Forth Style

2008-03-12T14:09:00.000-07:00

After developing my Forth.Net implementation I began trying to come up with ideas on how I could use it. About that same time the vacuum motors on our Roomba went down, so we decided we would replace it with a new one. I had been thinking about getting the Roomba Create robot, but with my Roomba Scheduler going down, I decided to hold on to it and try my hand at hacking it instead. It still runs, but it just doesn’t vacuum. I had read about the Roomba Serial Command Interface (SCI), and it looked like it would be a great candidate to try and build a Forth.Net dictionary around.

So my current Forth.Net project is a Forth.Net to Roomba dictionary. At this stage I am developing a Forth word for each of the commands in the Roomba SCI. The Forth words are being developed as extension methods of the ForthAPI class and are getting compiled into a .Net class library. C# is the language being used to tie the Forth words to the Roomba SCI.

The Forth.Net to Roomba dictionary hasn’t been tested yet; I am still working on getting a Bluetooth adaptor, the RooTooth, from SparkFun Electronics. I am not sure if my serial port connection implementation is going to work. I am opening and closing the port between each Roomba command. I might need to keep the port open the entire duration that I am sending commands to the Roomba. There are some tricks I can do for that.

Anyways, I am putting this out there now to share while I work on getting a RooTooth adaptor. The source code is available here.

A simple Forth.Net to Roomba program to start the Roomba cleaning

Start Control Clean

LINQ to SQL Code Generator

2008-03-10T09:20:00.000-07:00

Last month I created an online, pure Javascript, LINQ to Excel code generator for use with the LINQ to Excel provider that I have developed. I decided to take that code and modify it slightly to create a code generator for LINQ to SQL. This will allow one to easily map a SQL Server table to a .Net LINQ to SQL class. This generator, however, is not able to generate relationships between tables using EntitySet or EntityRef.

Check it out here

LINQ to SQL Multi Tier Example

2008-02-27T14:59:00.001-08:00

After some experimenting I have come up with what I think is a viable implementation to provide support for multi tier development using LINQ to SQL. One of the major issues with providing multi tier support in LINQ to SQL is how to attach the entity back on the DataContext and have it save the data correctly, or in many instances not to get LINQ to throw an exception.

Here is what I am doing:

- Attaching the inbound entity to a data context using the Attach method off the Table object. This object can be found off the DataContext on the GetTable generic method

- After attaching the inbound entity, I will then refresh it with a copy from the database using the Refresh method on the DataContext. I am using the KeepCurrentValues option which forces a comparison to see and set what has changed with the entity. This allows me to only persist the properties of the entity that have changed,and not update all the properties of the entity.

- Since I am using the Attach method that takes just one entity, it forces me to define a property on my entity that should be used for version checking. If I don’t do this, I get an exception stating to set the IsVersion property on one of my entity’s properties ColumnAttributes or turn off the update checking. Version checking allows for the ability to determine if the data of an entity has been changed by some else in the database after you had retrieved it. This action is performed when you try to submit changes to the database. To allow for this, I am going to add a timestamp column to my underlying SQL table that is updated using triggers when a row is updated or inserted. The column will be mapped as a read only property on my entity.

What is update checking? It is a technique LINQ uses to determine if the data for an entity instance has been changed since the entity was retrieved from the database. What it does is a build a where clause in the update statement that consists of the original values of all the entity‘s mapped properties. If any of those values have changed the update will fail and LINQ will throw an exception saying the row was deleted or changed.

Version checking does the same thing but you are setting what property, or maybe even properties (haven’t tried it) is built in that update where clause.

Here is what my sample entity looks like

<Table(Name="Person")>
public class Person {
<Column(Name="Id", Storage="_id", IsPrimaryKey=true, IsDbGenerated=true)>
public int Id {
  //add get set details }

<Column(Name="FirstName", Storage="_firstName")>
public string FirstName {
  //add get set details
}

<Column(Name="LastName", Storage="_lastName")>
public string LastName {
  //add get set details
}

<Column(Name="RowModifiedDate", Storage="_date", IsVersion=true)>
public DateTime RowModifiedDate {
  //add get details
}

}

Now in the example I am about to show I am going to convert my entity to and from Xml using some extension methods I described in my C# ToXml extension method post. This is just used to mimic sending a message back and forth to another tier of my application.

Finally the example

Person outPerson = null;
Person inPerson = null;
string transport = string.Empty;
using (DataContext dc = new DataContext("connectioninfo")) {
  outPerson = dc.GetTable<Person>().First();
}
//mimic transport to and from another tier of the application
transport = outPerson.ToXml();
inPerson = transport.FromXml<Person>();
//Force a change to the entity
inPerson.FirstName = "John";

//save the inbound entity back to the database
using(DataContext dc = new DataContext("connectioninfo")) {
  dc.GetTable<Person>().Attach(inPerson);
  dc.Refresh(RefreshMode.KeepCurrentValues, inPerson);
  dc.SubmitChanges();
}

LINQ to Excel Code Generator

2008-02-22T15:47:00.001-08:00

I have noticed that there has been some interest in my LINQ to Excel Provider. I thought it might be beneficial and fun to try and build an online code generator to create one’s LINQ to Excel class. This code generator is a pure JavaScript application and it should be pretty straightforward to use.

The purpose of this generator is to build a .Net class than can be used to interact with my LINQ to Excel Provider 2.5 and perform CRUD operations on an Excel sheet.

To run the generator:

1. Determine with language you want to use (C# or VB).
2. Supply the name of your .Net class
3. Set the name of the Excel sheet you want to map your .Net class to.
4. Supply the column names and data types from the Excel sheet that you want to incorporate into your .Net class.
5. Click the Generate Code button.
6. Copy the contents of the bottom textbox into a class file in Visual Studio.
7. Refer to LINQ to Excel Provider 2.5 for an example on how to interact with your class and read data from Excel.

Enjoy and if you have any comments or suggestions let me know.

Check the generator out here

Microsoft Tech Ed 2008 Registration Open

2008-01-30T15:45:00.001-08:00

The Microsoft Tech Ed 2008 conference is now open for registration. The conference will be held in Orlando, Florida at the Orange County Convention Center. This year the conference is actually broken down to two conferences, the Developer conference from June 3-6 followed by the IT Professional conference from June 10-13. Bill Gates will keynote the Developer conference and Bob Muglia, Vice President Server and Tools Business will do likewise for the IT Professional conference.

Register before April 4 and save $200. Software, programming, sun, Florida, theme parks; sounds like fun to me

LINQ to Excel Provider 2.5

2008-01-29T18:48:00.000-08:00

This version of the provider, evolving from LINQ to Excel Provider 2.0, adds change tracking in order to allow a user to update, insert, and delete Microsoft Excel data from any .Net code. It follows the LINQ to SQL model of change tracking. To track updates in a class the class will need to implement the System.ComponentModel.INotifyPropertyChanged interface. On the property setters, a developer will write code to raise the PropertyChanged event when a new value is set in the property. The example shows how to write a helper method to ease raising this event. To add or delete records one would call either InsertOnSubmit or DeleteOnSubmit on the generic GetSheet method of the provider. When you would like to commit your changes to Excel, simply call SubmitChanges on the provider and all the inserts, updates, and deletes are committed to the Excel spreadsheet.

The C# source file is available here

A VB.Net version of the source is available here

An online code generator to build the LINQ to Excel class is available here

ExcelProvider provider = ExcelProvider.Create(@"c:\deploy\Book1.xls");
foreach (Person per in (from p in provider.GetSheet<Person>() where p.LastName == "Johnson" select p))
{
per.LastName = "Smith";
}
Person p = new Person();
p.Id = 10.0;
p.FirstName = "Alex";
p.LastName = "Zander";
p.BirthDate = new DateTime(1980, 4, 4);
provider.GetSheet<Person>() InsertOnSubmit(p);
provider.SubmitChanges();
Console.WriteLine("Done");

[ExcelSheet(Name="Sheet1")]
public class Person: System.ComponentModel.INotifyPropertyChanged
{
private double id;
private string fName;
private string lName;
private DateTime bDate;

public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;

protected virtual void SendPropertyChanged(string propertyName)
{
System.ComponentModel.PropertyChangedEventHandler handler = PropertyChanged;
if (handler != null)
{
handler(this, new System.ComponentModel.PropertyChangedEventArgs(propertyName));
}
}

public Person()
{
id = 0;
}
[ExcelColumn(Name="ID",Storage="id")]
public double Id
{
get { return id; }
}

[ExcelColumn(Name = "FirstName", Storage = "fName")]
public string FirstName
{
get { return this.fName; }
set { fName = value;
SendPropertyChanged("FirstName");

}
}

[ExcelColumn(Name = "LastName", Storage = "lName")]
public string LastName
{
get { return this.lName; }
set { lName = value;
SendPropertyChanged("LastName");

}
}

[ExcelColumn(Name = "BirthDate", Storage = "bDate")]
public DateTime BirthDate
{
get { return this.bDate; }
set { bDate= value; }
SendPropertyChanged("BirthDate");

}
}
}

LINQ to Excel: SQL Import

2008-01-27T19:20:00.001-08:00

Here is a simple technique you can use to import data from Microsoft Excel to Microsoft SQL Server by using a combination of LINQ to Excel and LINQ to SQL. All that is really required is to adorn your class with the LINQ to SQL attributes and also with the LINQ to Excel attributes. With that simple addition, your class is now capable of handling both LINQ providers and you can now move data from Microsoft Excel to Microsoft SQL Server using LINQ.

ExcelProvider provider = ExcelProvider.Create(@"c:\deploy\Book1.xls");
DataContext dc = new DataContext("yourSqlConnection");
foreach (Person per in (from p in provider.GetSheet<Person>() where p.LastName == "Johnson" select p))
{
   dc.GetTable<Person>().InsertOnSubmit(per);
}

dc.SubmitChanges();
Console.WriteLine("Done");

[ExcelSheet(Name="Sheet1")]
[Table(Name="Person")]
public class Person
{
private double id;
private string fName;
private string lName;
private DateTime bDate;

public Person()
{
    id = 0;
}
[ExcelColumn(Name="ID",Storage="id")]
[Column(Name="ID",Storage="id", IsPrimaryKey=true)]
public double Id
{
    get { return id; }
}

[ExcelColumn(Name = "FirstName", Storage = "fName")]
[Column(Name = "FirstName", Storage = "fName")]
public string FirstName
{
    get { return this.fName; }
    set { fName = value; }
}

[ExcelColumn(Name = "LastName", Storage = "lName")]
[Column(Name = "LastName", Storage = "lName")]
public string LastName
{
    get { return this.lName; }
    set { lName = value; }
}

[ExcelColumn(Name = "BirthDate", Storage = "bDate")]
[Column(Name = "BirthDate", Storage = "bDate")]
public DateTime BirthDate
{
     get { return this.bDate; }
    set { bDate= value; }
}
}

Forth .Net Tax Example Program

2008-01-23T15:34:00.001-08:00

I have been looking to develop a larger Forth .Net example program but had been struggling coming up with a good example. (You can refer to my Forth .Net implementation I have created here.) Finally I got the idea, with income tax time coming around, of creating a Forth .Net application to automate the tax formula that people need to use if their income falls above the provided tax tables. What this example program will do is create one of the IRS tax formulas on page 75 in the IRS 2007 Form 1040 instructions document. The formula this example program will build is the one for the people with a filing status of Single, Section A.

The first thing this program will need to do is create conversions to cents and to dollars.

: ToCents (dollar cents – cents) swap 100 * + ;
: ToDollar (cents – dollar cents) dup 100 / swap 100 mod ;

The next thing we need to do is build a Forth word to handle calculating percentages. We will assume that this word is going to work with cents only. The if section is handling rounding fractions up if they are larger than .5

: Percent (cents percentRate – cents) * dup 100 / swap 100 mod 49 > if 1 + then ;

Since we are dealing with tax brackets, we need a Forth word to test if a value falls in between two values. Note 0 = false and 1 = true

: InRange (value lowValue highValue – 0/1) rot dup rot >= rot <= = ;

Now that the ‘helper’ words are in place, we need to create Forth words to handle the tax brackets for the single filer.

: SingleTooLowBracket (cents -- ) 100000 00 ToCents < if .”Use Tax Table” cr drop then ;

: SingleLowBracket (cents --) 100000 00 ToCents 160850 00 ToCents
InRange true = if
28 Percent 5889 25 ToCents – ToDollar swap .”$” . .
Then ;

: SingleMiddleBracket (cents --) 160850 01 ToCents 349700 00 ToCents
InRange true = if
33 Percent 13931 75 ToCents – ToDollar swap .”$” . .
Then ;

: SingleHighBracket (cents --) 349700 00 ToCents > if
35 Percent 20925 75 ToCents – ToDollar swap .”$” . .
Then ;

With the brackets all in place all that is left is to encapsulate all this work into one Forth word.

: SingleTax (dollar cents --) ToCents dup dup SingleTooLowBracket dup SingleLowBracket dup SingleMiddleBracket dup SingleHighBracket drop ;

To now use this program all you need to do is enter an income followed by the Forth word SingleTax

146000 00 SingleTax

And you should get
$34990 75 ok

LINQ to Excel Provider 2.0

2008-01-19T07:49:00.000-08:00

Note: View the newest version of the provider in this post

This LINQ to Excel provider is an improvement based on the provider discussed in my first LINQ to Excel Provider post. This provider strives to mimic the LINQ to SQL model which provides the developer a strongly typed .Net class to represent the Microsoft Excel sheets. A developer will map an Excel sheet to a .Net class by adorning the class with the ExcelSheetAttribute, and the properties with the ExcelColumn attribute.

This provider still uses an OleDB connection to load data from Excel into a queryable memory collection at which point normal LINQ queries can be performed. The generic GetSheet method is called on the provider with a mapped Excel sheet class in order to initiate this process. This is similar to calling the generic GetTable method on the DataContext in the LINQ to SQL model.

The next steps I am working on is to track changes, and save or delete data.

The source file is available here

Here is example that is querying the following sample Excel data. Data is assumed to be in Sheet1.

ID	FirstName	LastName	BirthDate
1	John	Anderson	12/12/1980
2	Frank	Johnson	11/10/1976
3	Bob	Olson	5/7/1973

ExcelProvider provider = ExcelProvider.Create(@"c:\deploy\Book1.xls");
foreach (Person per in (from p in provider.GetSheet<Person>() where p.LastName == "Johnson" select p))
{
   Console.WriteLine(per.FirstName);
   Console.WriteLine(per.LastName);
}

Console.WriteLine("Done");

[ExcelSheet(Name="Sheet1")]
public class Person
{
private double id;
private string fName;
private string lName;
private DateTime bDate;

public Person()
{
    id = 0;
}
[ExcelColumn(Name="ID",Storage="id")]
public double Id
{
    get { return id; }
}

[ExcelColumn(Name = "FirstName", Storage = "fName")]
public string FirstName
{
    get { return this.fName; }
    set { fName = value; }
}

[ExcelColumn(Name = "LastName", Storage = "lName")]
public string LastName
{
    get { return this.lName; }
    set { lName = value; }
}

[ExcelColumn(Name = "BirthDate", Storage = "bDate")]
public DateTime BirthDate
{
     get { return this.bDate; }
    set { bDate= value; }
}
}

LINQ : Query Types With Reflection

2008-01-10T20:15:00.001-08:00

I had the idea of doing a simple experiment with LINQ in conjunction with Reflection to provide a more efficient and flexible means to inspect and query types in my assemblies. The code below shows a simple example of using LINQ with Reflection in order to find all the public classes in my assembly that have a certain attribute.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Reflection;

namespace ReflectLinq
{
class Program
{
  static void Main(string[] args)
  {
    List<Type> results =
        (from t in Assembly.GetExecutingAssembly().GetTypes()
        where t.HasAttribute(typeof(TestAttribute)) == true &&
                t.IsPublic ==true select t).ToList();
        foreach (Type t in results)
        {
          Console.WriteLine(t.FullName);
        }

  }
}

public static class TypeExt
{
  public static bool HasAttribute(this Type t, Type attribute)
  {
    object[] results = t.GetCustomAttributes(attribute, true);
    return results.Length > 0;
  }
}
}

Let Forth Speak

2007-12-30T19:14:00.001-08:00

This is an example showing how an extension method can be created in a .Net class library to add new Forth words to the Forth environment I described in the 'Forth in .Net 3.5 Framework' post.

This example creates a new Forth word, Say, which utilizes the System.Speech.Synthesis namespace to allow the computer to say the value that is on top of the Forth stack.

Here’s the source for the Forth word Say:

using System;
using System.Collections.Generic;
using System.Speech.Synthesis;
using ForthAPI;

namespace ForthSpeak
{
  public static class ExtendedForthWords
  {
    public static void Say(this Forth f)
    {
    int arg = f.DotGet();
    using (System.Speech.Synthesis.SpeechSynthesizer speak = new SpeechSynthesizer())
     {
       speak.Speak(arg.ToString());
     }
    }
  }
}

To try this out I have created the assembly ForthSpeak.dll which has this word defined. It is available here. Copy this assembly to the same directory that the Forth.exe resides in. If you do not have Forth.exe, you can get it along with the ForthAPI.dll here.

Now launch Forth.exe and type in this Forth program, also make sure your speakers are on.

10 0 do I dup . cr say loop .”done”

Or if you prefer to count by twos

10 0 do I dup . cr say 2 +loop .”done”

Forth in the .Net 3.5 Framework

2007-12-28T04:10:00.001-08:00

A project containing a Forth API in C# 3.0, extendable using extension methods, and a Forth to .Net compiler/interpreter

This effort began as an experiment on how extension methods can be used to extend the functionality of a .Net class. What I wanted was an interesting test platform. I had experimented with Forth in college, and was familiar with how you can create new Forth ‘words’ (subroutines) to add functionality to Forth. So I thought it would be interesting to try and mimic a Forth based language as a .Net class and then use extension methods as the mechanism to allow users to add their own Forth words to extend the class.

Well, what I have now goes well beyond that original goal. Here is a high level list of features implemented thus far:

1. A Forth API, exposed as a .Net class library, contains the base Forth keywords as methods on the class.

2. A start to a Forth compiler/interpreter that will provide the familiar iterative Forth programming experience.

    a. The Forth words are converted into IL instructions to call the appropriate method on the Forth API or out to other class libraries containing Forth words. The compiler searches for Forth words in the Forth API class, and if it cannot find it there, will search other .Net dlls residing in the same location. Its searching for any extension method for the Forth API class and then is doing a simple method name comparison.

   b. This application is able to switch between compile mode and execution mode depending on if the source input is creating a new word definition, executing a word or being asked to do both.

   c. When the application is executing words, the compiled IL code is run in a dynamic assembly and then discarded after the program is finished

   d. The states of the Forth stacks are saved after execution of a program and put back in place at the start of the execution of the next program. This provides the developer the ability to execute word by word and examine how those word(s) affect the stack. This is really useful, probably required, with the iterative Forth programming style.

3. New Forth words built in the compiler/interpreter are built into a well known assembly named ForthWords.dll.

   a. The words built in this assembly are constructed as extension methods so they are available when using the Forth API directly.

   b. Because of the iterative Forth programming experience, this assembly stores the source code for its words so the entire ForthWords.dll can be rebuilt whenever a new Forth word is added.

4. Forth words can also be added in C# or Visual Basic .Net by creating class libraries which have extension methods on the Forth API class. From there a developer can use the Forth API methods to write their own Forth words and also to expose Forth to the entire .Net Framework.

At this point the base Forth stack manipulation, variables, constants, math operators, loops, and condition words have been implemented. Even with that, there might be some words I have missed.

To try it out, download the components here. Note: The components require the .Net 3.5 Framework to be installed.

The source code is available here. The project was built using Microsoft C# Visual Studio 2008 Express Edition

To begin a session, start the Forth.exe.

A simple calculation example
Enter

2 2 + . cr

You should see:

4
ok.

An example of the compiler/interpreter switching between new word compilation and then word execution

: hello .”Hello World” cr ; hello

You should see:

Hello World
ok.

This should have added a new .Net assembly named ForthWords.dll in the same directory as Forth.exe

To inspect the stack type .S

To close a session type bye

Check out:
JavaScript Forth Interpreter. Forth in the browser?
Hacking Roomba with Forth

4/22/08 Compiling from source files now supported

LINQ to Excel Provider

2007-12-20T18:08:00.000-08:00

View the newest version of the provider in this post

This is a very simple and generic provider to allow a developer to build LINQ queries to access Microsoft Excel data. The provider uses an OleDB connection to load data from Microsoft Excel into a queryable memory collection. From that point LINQ queries can filter and manipulate the data.

You will build your LINQ queries against the ExcelProvider class which will return a generic ExcelRow data type. ExcelRow has an indexer, column counter, and conversion to string method to allow access to the columns in the row. This class can be extended to handle conversion for other data types.

The source file is available here

All the example code I have written has been done using Microsoft C# Visual Studio 2008 Express Edition

Here is example that is querying the following sample Excel data. Data is assumed to be in Sheet1.

ID	FirstName	LastName	BirthDate
1	John	Anderson	12/12/1980
2	Frank	Johnson	11/10/1976
3	Bob	Olson	5/7/1973

ExcelProvider provider = ExcelProvider.Create(@"c:\test\Book1.xls", "Sheet1");
foreach (ExcelRow row in (from x in provider where x.GetString(2) == "Johnson" select x))
{
Console.WriteLine(row.GetString(1) + " " + row.GetString(2));
}

Console.WriteLine("Done");

LINQ: Query Reuse Part 3

2007-12-15T06:36:00.000-08:00

Another topic I would like to discuss on the LINQ query reuse implementation I have been describing is a strategy to limit the number of entity references on the DataContext.

Using extension methods to ‘hook’ the DataContext in order to reference our entity's data access layer sets us up in great position to control which entities we want to see on the DataContext. This is done by organizing your entity implementations into sets of namespaces. In this way an entity’s data access layer can only show up on the DataContext instance if its namespace has been referenced.

For example, let say our Person entity and data access layer was implemented in a namespace MyCompany.HumanResources. If that namespace is not referenced where you are using the DataContext; the Person data access layer is not found. However, once it is referenced, you have access to it. This seems to me to be a very slick approach to referencing entities on the DataContext. It is a much better implementation than inheriting from the DataContext and adding all your entity references to that, or creating multiple inherited DataContexts with entity references with a goal of them being used in different parts of an application.

LINQ: Query Reuse Part 2

2007-12-12T17:07:00.000-08:00

This is a continuation from yesterday’s blog and would like to show another example of reusing base queries. With the way I separated out the logic yesterday it sets us up well for building a set of queries on the entity’s derived collection, the data access layer, which can take a different set of parameters and can be exposed to the user as a simple overloaded method.

public class Persons : TableView<Person>
{
public Persons(DataContext dc)
: base(dc)
{

}

public IQueryable<Person> FindByName(string lastName)
{
return (from names in this where names.LastName == lastName select names);
}

public IQueryable<Person> FindByName(string firstName, string lastName)
{
return FindByName(lastName).Where(p => p.FirstName == firstName);
}

public IQueryable<Person> FindByName(string firstName, string middleName, string lastName)
{
return FindByName(firstName, lastName).Where(p => p.MiddleName == middleName);
}

public Person FindById(int id)
{
return (from p in this where p.Id == id select p).FirstOrDefault();
}

}

LINQ: A Query Reuse Mechanism

2007-12-11T19:38:00.000-08:00

Another item I have been working on with LINQ is an effective means to expose LINQ queries I write throughout my application. I have seen Microsoft recommend inheriting from the DataContext and adding properties that encapsulate making calls to the DataContext’s GetTable generic method. That’s OK, but I wanted something more flexible. What I am planning on doing is three things.

1) Create my own base collection that encapsulates the functionality of the GetTable method.

2) Create derived classes from that collection for each of my entities and then add the LINQ queries as methods to that class.

3) Create an extension method for each of the classes built in item 2 to expose them on the DataContext.

What this gives you is access to the LINQ queries for your entities on any DataContext instance.

Step 1. Build the Base Collection Class

You can get the source file here.

Step 2.
Create the derived collection for the entity. I’ll use the Person entity for this example

public class Persons : TableView<Person>
  {
  public Persons(DataContext dc)
   : base(dc)
   {

   }

public IQueryable<Person> FindByLastName(string name)
  {
   return (from names in this where names.LastName == name select names);
  }

public Person FindById(int id)
  {
   return (from p in this where p.Id == id select p).FirstOrDefault();
  }
}

Step 3. Adding the Extension Method on the DataContext

public static class PersonsDataAccess
{
  public static Persons Persons(this DataContext dc)
  {
   return new Persons(dc);
  }
}

The Result: Accessing the LINQ queries from the DataContext

using (DataContext dc = new DataContext(@"connestringstring"))
  {
   List<Person> pers = dc.Persons().FindByLastName("Anderson").ToList();
  }

My Favorite Part: Extending the Base Queries

You might be wondering why I have a return type of IQueryable<Person> on the FindByLastName query. The reason is it allows us to add additional LINQ criteria to the query. Starting with the base query you can add additional conditions like an order by, more where conditions, or even narrow down the select. One word: crazy! I will get into that more in future posts. Here’s an order by example teaser

using (DataContext dc = new DataContext(@"connectionstring"))
  {
   List<Person> pers = (from p in dc.Persons().FindByLastName("Anderson") orderby p.LastName descending select p).ToList();
  }

LINQ: Handling No Result Queries

2007-12-09T07:41:00.000-08:00

One of the things I struggled with at first with LINQ is finding a simple way to return null for a query that returns no results. I found some examples that used the First extension method. However, if the query returned no results, calling the First extension method would throw an exception.

Person per = (from p in dc.GetTable<Person>() where p.Id == id select p).First();

The simple solution is to use the FirstOrDefault extension method instead.

Person per = (from p in dc.GetTable<Person>() where p.Id == id select p).FirstOrDefault();

Left Outer Join in LINQ

2007-12-08T17:31:00.000-08:00

I found out how to perform a left outer join using LINQ from Bilal Haidar's blog. My example shows how to perform a left join from Person to Person Address.

LINQ Query

SQL Translation

-- Context: SqlProvider(Sql2005) Model: AttributedMetaModel Build: 3.5.21022.8
SELECT [t0].[FirstName], [t0].[LastName], [t1].[State] AS [State]
FROM [dbo].[Person] AS [t0]
LEFT OUTER JOIN [dbo].[PersonAddress] AS [t1] ON [t0].[Id] = [t1].[PersonID]

Need a break?

Checkout my virtual Florida Keys vacation slide show I built using a site I created that allows programmers to automate scripts for Google Street View using the programming language Forth.

SQL In Clause in LINQ

2007-12-06T13:19:00.000-08:00

I had been trying to figure how to perform an equivalent SQL ‘in’ clause using LINQ. What I discovered is you need to call the Contains method on the collection that is holding your argument list and pass that method the property of the object you want to search for.

So this example uses a class named Person which has an Id, FirstName and LastName property and the property we want to perform an in clause on is LastName. We want to see if it is equal to Anderson or Johnson

  using (DataContext dc = new DataContext("connectionstring"))
   {
     List<string> names = new List<string>();
    names.Add("Anderson");
    names.Add("Johnson");
    List<Person> list = (from p in dc.GetTable<Person>() where names.Contains(p.LastName) select p).ToList();
  }

This is the SQL generated by LINQ. (I am performing some formatting on it from the Log property in order to setup the parameters so I can paste the SQL into query analyzer, but the select statement is untouched)

DECLARE @p1 NVarChar(8);
DECLARE @p0 NVarChar(7);

Select @p1 = 'Johnson';
Select @p0 = 'Anderson';

-- Context: SqlProvider(Sql2005) Model: AttributedMetaModel Build: 3.5.21022.8
SELECT [t0].[Id], [t0].[FirstName], [t0].[LastName]
FROM [dbo].[Person] AS [t0]
WHERE [t0].[LastName] IN (@p0, @p1)

Diff List LINQ Extension Method

2007-12-05T21:08:00.000-08:00

An example extension method that will allow you to diff lists of the same type with a LINQ extension method.

static class NotInExtension
{
  public static List<T> NotIn<T>(this IEnumerable<T> source, IEnumerable<T> dest)
  {
  List<T> notinList = new List<T>();
  foreach (T s in source)
  {
    bool found = false;
    foreach (T d in dest)
    {
     if (d != null && s != null)
     {
      if (d.Equals(s))
      {
      found = true;
       break;
      }
     }
    }
    if (found == false)
     notinList.Add(s);
  }
  return notinList;
  }
}

In action

List<int> a = new List<int>();
a.AddRange(new int[] {1,2,3});

List<int> b = new List<int>();
b.AddRange(new int[] {2, 4,5 });

List<Tint> result = a.NotIn(b);

Using LINQ Extension Methods

2007-11-30T17:37:00.001-08:00

One of the many cool things about LINQ is the extension methods you can use to manipulate results from a LINQ query. In a prior post I used LINQ to query a calendar month to find U.S. holidays. Many holidays fall on the day of the month. For example, Thanksgiving is on the 4th Thursday of the month. Using the LINQ extension methods it is easy to pick that date out of calendar.

First we need to build a calendar for November; we’ll use 2007 for our year.

List <DateTime> november = new List<DateTime>();
for (int count = 1; count < 31; count++)
{
november.Add(new DateTime(2007, 11, count));
}

Next we will create a DayOfWeek class instance to apply as a filter to our LINQ query

DayOfWeek thursdays = DayOfWeek.Thursday;

Now to build our LINQ query we will start by finding all the Thursdays in November.

var temp = (from d in november where d.DayOfWeek == thursdays orderby d.Day ascending select d);

We can trim this to just return the first 4 Thursday s buy using the Take extension method as such. It is same principle as SQL select top command.

var temp = (from d in november where d.DayOfWeek == thursdays orderby d.Day ascending select d).Take(4);

To pull the last Thursday from that list, the fourth Thursday of the month, we will add another LINQ extension method Last to pull the last item from the query. Since this extension method returns one value, a DateTime, we can store the results in a DateTime variable

DateTime thanksgiving = (from d in november where d.DayOfWeek == thursdays orderby d.Day ascending select d).Take(4).Last();

Another alternative to this is to simply use the ElementAt extension

DateTime thanksgiving = (from d in november where d.DayOfWeek == thursdays orderby d.Day ascending select d).ElementAt(4);

Paging With LINQ

2007-11-30T17:33:00.001-08:00

Here is a simple C#3.0 extension method to page LINQ queries. It will allow you to declare where in the results you would like to start, and then how many results to return from that point.

public static class PagingExtensions
{
//used by LINQ to SQL
public static IQueryable<TSource> Page<TSource>(this IQueryable<TSource> source, int page, int pageSize)
{
return source.Skip((page - 1)*pageSize).Take(pageSize);
}

//used by LINQ
public static IEnumerable<TSource> Page<TSource>(this IEnumerable<TSource> source, int page, int pageSize)
{
return source.Skip((page - 1)*pageSize).Take(pageSize);
}

}

class Program
{
static void Main(string[] args)
{
List<string> names = new List<string>();
names.AddRange(new string[]{"John","Frank","Jeff","George","Bob","Grant", "McLovin"});
foreach (string name in names.Page(2, 2))
{
Console.WriteLine(name);
}

}
}

Since counting starts at 1, the above example will take Jeff and George

ODBC Destination Script for SSIS

2007-11-29T06:32:00.001-08:00

I recently helped, and have seen some posts with the same question, on how to use ODBC destinations in Microsoft SQL Server Integration Services (SSIS). The solution I came up with was to develop a Visual Basic .Net class that can be used in a Script Component Destination to save data to a database using ODBC connections.

Add this class to Script Destination component. If you are wondering where to locate it, paste it after the class that the Script Component creates for you. It is usually named ScriptMain.

A couple good resources on SSIS:

Source code for VB.Net class:

Public Class ODBCDestination
Private _columns As System.Collections.Generic.Dictionary(Of String, Object)
Private _connection As String
Private _table As String

Public Sub New()
_columns = New System.Collections.Generic.Dictionary(Of String, Object)()
End Sub

Public Property Connection() As String
Get
Return _connection
End Get
Set(ByVal value As String)
_connection = value
End Set
End Property

Public Property Table() As String
Get
Return _table
End Get
Set(ByVal value As String)
_table = value
End Set
End Property

Public Sub AddColumn(ByVal name As String, ByVal value As Object, ByVal isNull As Boolean)
If _columns.ContainsKey(name) = False Then
If isNull Then
_columns.Add(name, Nothing)
Else
_columns.Add(name, value)
End If
Else
If isNull Then
_columns(name) = Nothing
Else
_columns(name) = value
End If
End If
End Sub

Public Sub Save()
Using cn As System.Data.Odbc.OdbcConnection = New System.Data.Odbc.OdbcConnection(_connection)
cn.Open()
Using cmd As System.Data.Odbc.OdbcCommand = BuildInsert(cn)
cmd.ExecuteNonQuery()
End Using
End Using
End Sub

Private Function BuildInsert(ByVal cn As System.Data.Odbc.OdbcConnection) As System.Data.Odbc.OdbcCommand

Dim cmd As System.Data.Odbc.OdbcCommand = cn.CreateCommand()
cmd.CommandType = CommandType.Text

Dim buildCol As System.Text.StringBuilder = New System.Text.StringBuilder()
Dim buildVal As System.Text.StringBuilder = New System.Text.StringBuilder()

Dim firstTimeIn As Boolean = True
Dim count As Integer = 0
For Each key As String In _columns.Keys
If firstTimeIn = False Then
buildCol.Append(", ")
buildVal.Append(", ")
End If

buildCol.Append(key)
buildVal.Append("?")

Dim arg As Object = _columns(key)
If arg Is Nothing Then
cmd.Parameters.AddWithValue(key, DBNull.Value)
Else
cmd.Parameters.AddWithValue(key, arg)
End If

firstTimeIn = False
count = count + 1
Next
Dim insertBuilder As System.Text.StringBuilder = New System.Text.StringBuilder()

insertBuilder.Append("insert into ")
insertBuilder.Append(_table)
insertBuilder.Append(" (")
insertBuilder.Append(buildCol.ToString())
insertBuilder.Append(")")
insertBuilder.Append(" values (")
insertBuilder.Append(buildVal.ToString())
insertBuilder.Append(")")
cmd.CommandText = insertBuilder.ToString()
Return cmd
End Function

End Class

Now add the following code to the main script component class

The next step is to map the columns. This is done by calling the AddColumn method. The interesting point with this function is that you are required to pass three arguments. The first argument is the name of column in the destination table. The second argument is the value you want to save to that column. The third argument is a Boolean flag to state if the data is null.

Why are you required to pass the value of the column, and a flag if it is null or not? It is required because of the way .Net handles certain data types. For example the integer type in .Net is not allowed to be null it always has a value. However databases allow integer columns to be null. Double, Float, DateTime, are some other data types that behave this way in .Net. SSIS worked around this by representing each column in the InputBuffer with two properties. One contains the value of the column, the other a flag if it is null or not. The null property is always the name of the column with ‘_IsNull’ appended to the end of the name

Once you have mapped all the column call the Save method to persist the data to the destination database.

Sample implementation

Public Class ScriptMain
Inherits UserComponent

Public Overrides Sub Input0_ProcessInputRow(ByVal Row As Input0Buffer)
'
'Add your code here
'
Dim cmd As ODBCDestination = New ODBCDestination()
cmd.Table = "TableName"
cmd.Connection = "ODBC connection string"
cmd.AddColumn("id", Row.id, Row.id_IsNull)
cmd.AddColumn("Column1", Row.Column1, Row.Column1_IsNull)
cmd.AddColumn("Column2", Row.Column2, Row.Column2_IsNull)
cmd.Save()

End Sub
End Class

Public Class ODBCDestination
...

C#3.0 Extension Method to Check Holidays

2007-11-27T16:12:00.000-08:00

The following is an extension method to determine if a DateTime instance falls on a US holiday. The code contains an algorithm to calculate Easter, Thanksgiving, Presidents Day, Memorial Day, Martin Luther King Day and Labor Day. LINQ functionality is used to search the listed holidays along with being used in some date calculations such as with Thanksgiving, and Presidents Day. There are probably better algorithms to find some of these holiday dates, but LINQ was chosen here to show how it can be used to query collections.

Here is the complete source code for the extension:

public static class DateTimeExtensions
{
public static bool IsHoliday(this DateTime currentDate)
{
int year = currentDate.Year;
List<DateTime> holidays = new List<DateTime>();
//New Years
holidays.Add(new DateTime(year, 1, 1));
//Martin Luther King Day
holidays.Add(MLKDay(year));
holidays.Add(PresidentsDay(year));
holidays.Add(Easter(year));
holidays.Add(MemorialDay(year));
//Independence Day
holidays.Add(new DateTime(year,7,4));
holidays.Add(LaborDay(year));
holidays.Add(Thanksgiving(year));
//X-mas
holidays.Add(new DateTime(year, 12, 25));

foreach (DateTime d in (from h in holidays where h.Month == currentDate.Month && h.Day == currentDate.Day select h))
{
   return true;
}
return false;
}

private static DateTime MLKDay(int year)
{

DateTime mlkDay = DateTime.MinValue;
List<DateTime> jan = new List<DateTime>();
for (int count = 1; count < 32; count++)
{
   jan.Add(new DateTime(year, 1, count));
}

DayOfWeek monday = DayOfWeek.Monday;
//Martin Luther King Day is the 3rd Monday of the month
//use LINQ query to find all Mondays and return in ascending order
//Use a combination of Take and Last to get the 3rd Monday
mlkDay = (from d in jan where d.DayOfWeek == monday orderby d.Day ascending select d).Take(3).Last();
return mlkDay;
}

private static DateTime PresidentsDay(int year)
{
DateTime leapYear = new DateTime(year, 2, 1);

DateTime presidentsDay = DateTime.MinValue;
List<DateTime> feb = new List<DateTime>();
for (int count = 1; count < 28; count++)
{
   feb.Add(new DateTime(year, 2, count));
}

DayOfWeek monday = DayOfWeek.Monday;
//use LINQ query to find all Mondays and return in ascending order
//Presidents Day is the 3rd Monday of the month
//Use a combination of Take and Last to get the 3rd Monday
presidentsDay = (from d in feb where d.DayOfWeek == monday orderby d.Day ascending select d).Take(3).Last();
return presidentsDay;
}

private static DateTime MemorialDay(int year)
{
DateTime memorialDay = DateTime.MinValue;
List<DateTime> may = new List<DateTime>();
for (int count = 1; count < 32; count++)
{
may.Add(new DateTime(year, 5, count));
}

DayOfWeek monday = DayOfWeek.Monday;
//use LINQ query to find all Mondays and return in descending order to get the last Monday of the month
//use First extension to get 1 Monday; the last one because of descending sort
memorialDay = (from d in may where d.DayOfWeek == monday orderby d.Day descending select d).First();
return memorialDay;
}

private static DateTime LaborDay(int year)
{
DateTime laborDay = DateTime.MinValue;
List<DateTime> sept = new List<DateTime>();
for (int count = 1; count < 31; count++)
{
   sept.Add(new DateTime(year, 9, count));
}

DayOfWeek monday = DayOfWeek.Monday;
//use LINQ query to find all Mondays and return in ascending order to get the first Monday of the month
//use First extension to get one Monday, the first one

laborDay = (from d in sept where d.DayOfWeek == monday orderby d.Day ascending select d).First();
return laborDay ;
}

private static DateTime Thanksgiving(int year)
{
DateTime thanksgiving = DateTime.MinValue;
List<DateTime> november = new List<DateTime>();
for (int count = 1; count < 31; count++)
{
november.Add(new DateTime(year, 11, count));
}
DayOfWeek thursdays = DayOfWeek.Thursday;

//Use LINQ query to find all the thursdays of the month of November.
//Thanksgiving is on the 4th thursday
//Use the combination of Take and Last to get the 4th thursday of the month
thanksgiving = (from d in november where d.DayOfWeek == thursdays orderby d.Day ascending select d).Take(4).Last();
return thanksgiving;
}

private static DateTime Easter(int year)
{
//This algorithm is a C# conversion of the one described at
//http://www.assa.org.au/edm.html#Computer
int firstDigit;
int remain19;
int temp;

int tableA;
int tableB;
int tableC;
int tableD;
int tableE;

int d; //day of easter
int m; //month of easter

firstDigit = year / 100;
remain19 = year % 19;

temp = (firstDigit - 15) / 2 + 202 - 11 * remain19;

int[] substract1 = {21, 24, 25, 27,28,29,30,31, 32, 34, 35, 38};
List<int> subtract1List = new List<int>(substract1);
if (subtract1List.Contains(firstDigit))
{
temp = temp - 1;
}

int[] substract2 = {33, 36, 37, 39, 40};
List<int> subtract2List = new List<int>(substract2);
if (subtract2List.Contains(firstDigit))
{
temp = temp - 2;
}

temp = temp % 30;
tableA = temp + 21;
if (temp == 29) {
tableA = tableA -1;
}
if (temp == 28 && remain19 > 10)
{
tableA = tableA - 1;
}
//find the next Sunday
tableB = (tableA - 19) % 7;

tableC = (40 - firstDigit) % 4;
if (tableC == 3)
{
   tableC++;
}
if (tableC > 1)
{
   tableC++;
}

temp = year % 100;
tableD = (temp + temp / 4) % 7;

tableE = ((20 - tableB - tableC - tableD) % 7) + 1;
d = tableA + tableE;

if (d > 31)
{
   d = d - 31;
   m = 4;
}
else
{
   m = 3;
}
return new DateTime(year,m,d);
}
}

C#3.0 ToXml Extension Method

2007-11-22T17:20:00.000-08:00

I know I stated in my last post I was going to work on extension methods for DateTime. However sometimes you do not know when an idea is going to spark your interest. I have this project where I am building business classes that inherited from a base class which has a method on it to allow the inherited classes to be converted to Xml via the .Net Xml Serialization functionality. As I was working with extensions I had the idea of creating that method as an extension method so it could be used by any data type.

The code is really quite simple. I set the first argument as object, so all types can reference the method. After that it just calls into the XmlSerialization classes to perform the conversion. Code is written C#. The previous post explains how to write extension methods in VB

You will need to add these namespaces.

using System.IO;
using System.Xml.Serialization;

Method Source Code

public static class XmlConvertExtensions
{
public static string ToXml(this object obj)
{
XmlSerializer s = new XmlSerializer(obj.GetType());
using (StringWriter writer = new StringWriter()) {
s.Serialize(writer, obj);
return writer.ToString();
}
}
}

Example showing the extension in action:

string input = "hello world";
string xmlData = input.ToXml();

That’s cool, but how can we get it back from Xml? Add this class. It has generic support to convert an Xml string back to a data type.

public class FromXml<T>
{
public T Convert(string data)
{
   XmlSerializer s = new XmlSerializer(typeof(T));
   using (StringReader reader = new StringReader(data))
   {
    object obj = s.Deserialize(reader);
    return (T)obj;
   }
}
}

Example showing moving a string to and from Xml.

string input = "hello world";
string xmlData = input.ToXml();
string backFromXml = new FromXml<string>().Convert(xmlData);

Update
Thanks to the comment from Steve for the suggestion of moving the conversion from an Xml string onto the string class as an extension method. It is a much cleaner solution than what I first had.

public static class FromXmlExt
{
public T FromXml<T>(this string data)
{
   XmlSerializer s = new XmlSerializer(typeof(T));
   using (StringReader reader = new StringReader(data))
   {
    object obj = s.Deserialize(reader);
    return (T)obj;
   }
}
}

Now you can simply do the following:

string input = "hello world";
string xmlData = input.ToXml();
string backFromXml = xmlData.FromXml<string>();

Thanks Steve!

C#3.0 and VB9 Extension Method How To

2007-11-21T16:15:00.000-08:00

.Net Extension Method Code Example for Integer Type

With the next release of Visual Studio, Microsoft is introducing the concept of extension methods. In a nutshell, what they do is allow you to add methods to data types you do not own. For example, let say in your code you are always testing that an integer is between a certain range before performing any work on it. Currently you need to write an If statement or a maybe even a helper method to do. With extension methods, you are creating a helper method, but the method will be visible as an instance method on the integer type. So now, for the most part, anywhere you use integers you will now have access to use that method.
What this example shows is how to create an extension method in C# and Visual Basic that will allow a developer to test if an integer falls between two numbers.
In Visual Basic extension methods need to be added to a Module file. Add a Module file to your project and paste in this code.

<System.Runtime.CompilerServices.Extension()> _
Public Function IsBetween(ByVal value As Integer, ByVal minvalue As Integer, ByVal maxvalue As Integer) As Boolean
Return value >= minvalue AndAlso value <= maxvalue
End Function

Overall it looks like a normal method. The two things that you need to be aware of is that the attribute Runtime.CompilerServices.Extension() is required to inform the compiler that this is an extension method. The second is that the first arguement always defines what type this extension method works on along with providing a reference to an instance of that type. Remember extension methods only work on instances of types, and this first argument provides access to that instance. Still confused? I think an example will clear it up.

An example of the extention method in action using Visual Basic:

Dim x as Integer = 5
If x.IsBetween(2,7) then
…
End if

You will notice that I only passed it two arguments. The reason is, the value of x is passed to IsBetween as the first arugment.

In C# the syntax to declare an extension method is slightly different. You need to define them in a static class and as a static method. Here is our working example now in C#

public static class IntExtensions {
public static bool IsBetween(this int value, int minValue, int maxValue) {
return value >= minValue && value <= maxValue;
}
}

Here there is no need to declare the extension attribute like in Visual Basic. Also the syntax of the first argument is easier to follow in C# to mean that it refers to the instance of the type from which this method was called.
An example of the extention method in action using C#

int x = 5;
x.IsBetween(2, 7);

This is just the tip of the iceberg. What I am working on next is adding some extension methods to DateTime that will try and incorporate LINQ to answer some questions such as:

Is the current date a holiday?
Is today a weekend day?
Given the current date, what will be the last Friday of that month?

I would like to here any other suggestions.

Internet Explorer Extension to Get Directions

2007-11-20T19:16:00.000-08:00

An Internet Explorer Add In to Get Directions from Google Maps

Many of you like me have found yourself highlighting an address to a place you have found on the web and then navigating to a site like Google Maps to paste in that address to get directions. This post will explain how to create an Internet Explorer extension to streamline that process. We will create an extension that will allow you to highlight and right click on an address which will open a new browser window containing Google Maps directions from a starting point you define to the address you just highlighted.

The first step is to create the script file used by the extension to read the highlighted text, build the url to Google Maps, and open the new browser window. Using you favorite text editor copy the example code below and save the file as GetDirections.html

<script >
var dest = new String(external.menuArguments.document.selection.createRange().text);
var rExp = "/ /g";
//format for google maps
dest = dest.replace(rExp, "+");
dest = dest.replace(/\n/g, ",+");
var start = "1234 Main St Anywhere, MN 55334";
var formatStart = start;
formatStart = formatStart.replace(rExp, "+");
formatStart = formatStart.replace(/\n/g, ",+");
// Google Maps
var address = "http://maps.google.com/maps?f=d&hl=en&saddr=" + formatStart + "&daddr=" + dest
window.open(address,"","menubar=yes,location=yes,resizable=yes,scrollbars=yes,status=yes");
</script >

The first line pulls the highlighted text from the current browser. The next 3 lines replace any spaces and carriage returns with a plus sign. This is to conform to how addresses are formatted in Google Maps. The next line is used to define your starting address. Enter what you would like to use as a starting address in this line. Type the address as you normally would, the next lines after it will format it correctly for use in Google Maps. After that, the url containing the formatted starting and ending addresses is assembled. The last line directs Internet Explorer to open the url in a new window.

The next step is to register the new extension with Internet Explorer. This is performed by adding an entry in the Windows registry under Internet Explorer.

1. Open the registry from the command line or from Start --> Run by typing regedit.
Within the registry navigate to //HKEY_CURRENT_USER/Software/Microsoft/Internet Explorer/MenuExt

2. From MenuExt right click, select New --> Key. Now the name of this folder will be the name of the menu item that appears in the context menu of Internet Explorer. Name this folder Get Directions.

3. With Get Directions selected, locate the key value on the right side named (default). Right click it, and select Modify. In the value data textbox write in or paste the path of the GetDirections.html file created in the first step.

4. With Get Directions selected again, right click and select New --> DWord Value. Name this key ‘Contexts’. Set its value to 10 and make sure the base is set to hexadecimal. This setting tells Internet Explorer when the Get Directions menu item is available. Hex 10 tells it to make this menu item visible only for highlighted text.

5. Close the registry.

Open the browser and navigate to a website with an address. Highlight the address and right click. There should be a menu option named Get Directions. Select it. A new browser window should appear with Google Map directions to that highlighted address from the starting address you set in GetDirections.html