Using Python and MapInfo with Callbacks


The other day I posted an entry about using MapInfo with Python and Qt (see https://woostuff.wordpress.com/2011/03/05/mapinfo-map-control-into-qt-python-form/), one big thing that I missed was support for callbacks, which if you want to do anything related to integrated mapping is a must for map tool support.

Turns out it is pretty easy, and today I worked out how.

You will need to create a class in python that looks something like this:

class Callback():
    _public_methods_ = ['SetStatusText']
    _reg_progid_ = "MapInfo.PythonCallback"
    _reg_clsid_ = "{14EF8D30-8B00-4B14-8891-36B8EF6D51FD}"
    def SetStatusText(self,status):
        print status

This will be our callback object that we will need to create for MapInfo.

First I will explain what some of the funny stuff is:

  • _public_methods_ is a Python array of all the methods that you would like to expose to COM eg MapInfo in this case. This attribute is a must for creating a COM object.
  • _reg_progid_ is the name of your COM application or object.  This can be anything you would like.
  • _reg_clsid_ is the GUID, or unique id, for the object or app.  Do not use the one I have, call the following in a Python shell to create your own.
             import pythoncom
             pythoncom.CreateGuid()
             
  • SetStatusText is the MapInfo callback method that is called when the status bar changes in MapInfo.

In order to use the class as a COM object we have two more steps to complete, one is registering the COM object and the other is creating it.

First, in oder to register the object we call the following code from our main Python method:

if __name__ == "__main__":
    print "Registering COM server..."
    import win32com.server.register
    win32com.server.register.UseCommandLine(Callback)
    main()

This will register the COM object which will mean it can then be creating for use by MapInfo.

In order to create our callback in Python we call:

callback = win32com.client.Dispatch("MapInfo.PythonCallback")

and set it as our callback object for MapInfo:

mapinfo.SetCallback(callback)

So after all that the final code looks like this:

def main():
    from PyQt4.QtCore import *
    from PyQt4.QtGui import *
    from win32com.client import Dispatch
    import sys

    app = QApplication(sys.argv)
    app.setAttribute(Qt.AA_NativeWindows,True)
    wnd = QMainWindow()
    wnd.resize(400, 400)
    widget = QWidget()
    wnd.setCentralWidget(widget)
    wnd.show()

    handle = int(widget.winId())
    mapinfo = Dispatch("MapInfo.Application")
    callback = win32com.client.Dispatch("MapInfo.PythonCallback")
    mapinfo.SetCallback(callback)
    mapinfo.do('Set Next Document Parent %s Style 1' % handle)
    mapinfo.do('Open Table "D:\GIS\MAPS\Property.TAB"')
    mapinfo.do('Map from Property')

    app.exec_()

class Callback():
    """ Callback class for MapInfo """
    _public_methods_ = ['SetStatusText']
    _reg_progid_ = "MapInfo.PythonCallback"
    _reg_clsid_ = "{14EF8D30-8B00-4B14-8891-36B8EF6D51FD}"
    def SetStatusText(self,status):
        print status

if __name__ == "__main__":
    print "Registering COM server..."
    import win32com.server.register
    win32com.server.register.UseCommandLine(Callback)
    main()

and the result is a map window and information printed to the console.

Information from MapInfo callback

I think Python could be a good language to prototype MapInfo based app, or even build a whole app itself. If you do end up making something of it let me know I am quite interested with what people could come up with.

Advertisements

Creating an instance of a MapInfo COM object in .NET – Speed Tests


A while ago I posted about how to create an instance of MapInfo in .Net, If you missed those posts then they can be found here.  In these posts I outlined how you can create a instance using three different methods, in the reflection based post I said that one of the disadvantages of doing it this way was that it was slower.   I said this due to just my observations but I thought it would be a good idea to put it to the test and show the speed difference.

I created a simple project to test and show me the results of three different things: Speed of complied MBX, calling a MapBasic function though the Do and via the interface (see posts 1 & 3) and calling Do and Eval via reflection (see post 2)

The code is simple, and is posted at the bottom of this post, the command “Fetch Next From {Table}” is called a number of times: 100;200;300;500;1000;2000;5000 and each block is timed.

After running each iteration set 3 times, these are the results :

SpeedTests

Behold my fancy graph making skills….or lack there of.  The time is in seconds, so the 0.032 in the Interface pass 1 is 0.032 seconds for 200 iterations which is still pretty quick.  You’ll notice that using the reflection based method starts to really take its toll when you are doing 5000 iterations, mind you ~1 second is still pretty quick.

The Mapbasic code I used:

Declare Sub Main
Declare Function Time(count as Integer) as Float
Declare Function GetTickCount Lib "kernel32" () As Integer

Sub Main
   Dim pass as Integer
   pass = 0
	Dim a,b,c,d,e,f,g as Integer
   a = 100
   b = 200
   c = 300
   d = 500
   e = 1000
   f = 2000
   g = 5000

	Do While pass <= 2
       Print "====PASS " + pass + "========="
       Print Time(a)
       Print Time(b)
       Print Time(c)
       Print Time(d)
       Print Time(e)
       Print Time(f)
       Print Time(g)
		pass = pass + 1
   Loop
End Sub

Function Time(count as Integer) as Float
    Dim a as Integer
    Dim b as Integer
	Dim i as Integer
	a = GetTickCount()
	For i = 0 to count
       Fetch Next From Untitled
    Next
	b = GetTickCount()
	Time = (b - a) / 1000
End Function

and the C# code:

class ReflectionMapInfo
    {
        private readonly object mapinfo;

        public ReflectionMapInfo(object mapinfo)
        {
            this.mapinfo = mapinfo;
        }

        public void Do(string commandstring)
        {
            this.mapinfo.GetType().InvokeMember("Do", BindingFlags.InvokeMethod,
                                                                null, this.mapinfo,
                                                                new[] {commandstring});
        }
    }

    class Program
    {
        [DllImport("kernel32.dll", CharSet = CharSet.Auto, ExactSpelling = true)]
        public static extern int GetTickCount();
        static MapInfoApplication mapinfo = new MapInfoApplication();
        static ReflectionMapInfo reflectionmapinfo = new ReflectionMapInfo(mapinfo);

        static void Main(string[] args)
        {
            mapinfo.Do(@"Open Table ""C:\Users\Woo\Documents\Untitled.TAB""");

            int pass = 0;
            while (pass <= 2)
            {
                Console.WriteLine("Interface Test, Pass " + pass + "Count 100 " + Time(100));
                Console.WriteLine("Interface Test, Pass " + pass + "Count 200 " + Time(200));
                Console.WriteLine("Interface Test, Pass " + pass + "Count 300 " + Time(300));
                Console.WriteLine("Interface Test, Pass " + pass + "Count 500 " + Time(500));
                Console.WriteLine("Interface Test, Pass " + pass + "Count 1000 " + Time(1000));
                Console.WriteLine("Interface Test, Pass " + pass + "Count 2000 " + Time(2000));
                Console.WriteLine("Interface Test, Pass " + pass + "Count 5000 " + Time(5000));
                pass++;
            }

            pass = 0;
            while (pass <= 4)
            {
                Console.WriteLine("Reflection Test, Pass " + pass + "Count 100 " + ReflectionTime(100));
                Console.WriteLine("Reflection Test, Pass " + pass + "Count 200 " + ReflectionTime(200));
                Console.WriteLine("Reflection Test, Pass " + pass + "Count 300 " + ReflectionTime(300));
                Console.WriteLine("Reflection Test, Pass " + pass + "Count 500 " + ReflectionTime(500));
                Console.WriteLine("Reflection Test, Pass " + pass + "Count 1000 " + ReflectionTime(1000));
                Console.WriteLine("Reflection Test, Pass " + pass + "Count 2000 " + ReflectionTime(2000));
                Console.WriteLine("Reflection Test, Pass " + pass + "Count 5000 " + ReflectionTime(5000));
                pass++;
            }
            Console.ReadLine();
        }

        public static double Time(int count)
        {
            int start = GetTickCount();
            for (int i = 0; i < count; i++)
            {
                mapinfo.Do("Fetch Next From Untitled");
            }
            int end = GetTickCount();
            mapinfo.Do("Fetch First From Untitled");
            return (end - start) / 1000d;
        }

        public static double ReflectionTime(int count)
        {
            int start = GetTickCount();
            for (int i = 0; i < count; i++)
            {
                reflectionmapinfo.Do("Fetch Next From Untitled");
            }
            int end = GetTickCount();
            reflectionmapinfo.Do("Fetch First From Untitled");
            return (end - start) / 1000d;
        }
    }

Creating an instance of a MapInfo COM object in .NET – Speed Tests


Blog has now moved to <a href="http://nathanw.net&quot;A while ago I posted about how to create an instance of MapInfo in .Net, If you missed those posts then they can be found here.  In these posts I outlined how you can create a instance using three different methods, in the reflection based post I said that one of the disadvantages of doing it this way was that it was slower.   I said this due to just my observations but I thought it would be a good idea to put it to the test and show the speed difference.

I created a simple project to test and show me the results of three different things: Speed of complied MBX, calling a MapBasic function though the Do and via the interface (see posts 1 & 3) and calling Do and Eval via reflection (see post 2)

The code is simple, and is posted at the bottom of this post, the command “Fetch Next From {Table}” is called a number of times: 100;200;300;500;1000;2000;5000 and each block is timed.

After running each iteration set 3 times, these are the results :

SpeedTests

Behold my fancy graph making skills….or lack there of.  The time is in seconds, so the 0.032 in the Interface pass 1 is 0.032 seconds for 200 iterations which is still pretty quick.  You’ll notice that using the reflection based method starts to really take its toll when you are doing 5000 iterations, mind you ~1 second is still pretty quick.

The Mapbasic code I used:

Declare Sub Main
Declare Function Time(count as Integer) as Float
Declare Function GetTickCount Lib "kernel32" () As Integer

Sub Main
   Dim pass as Integer
   pass = 0
	Dim a,b,c,d,e,f,g as Integer
   a = 100
   b = 200
   c = 300
   d = 500
   e = 1000
   f = 2000
   g = 5000

	Do While pass <= 2
       Print "====PASS " + pass + "========="
       Print Time(a)
       Print Time(b)
       Print Time(c)
       Print Time(d)
       Print Time(e)
       Print Time(f)
       Print Time(g)
		pass = pass + 1
   Loop
End Sub

Function Time(count as Integer) as Float
    Dim a as Integer
    Dim b as Integer
	Dim i as Integer
	a = GetTickCount()
	For i = 0 to count
       Fetch Next From Untitled
    Next
	b = GetTickCount()
	Time = (b - a) / 1000
End Function

and the C# code:

class ReflectionMapInfo
    {
        private readonly object mapinfo;

        public ReflectionMapInfo(object mapinfo)
        {
            this.mapinfo = mapinfo;
        }

        public void Do(string commandstring)
        {
            this.mapinfo.GetType().InvokeMember("Do", BindingFlags.InvokeMethod,
                                                                null, this.mapinfo,
                                                                new[] {commandstring});
        }
    }

    class Program
    {
        [DllImport("kernel32.dll", CharSet = CharSet.Auto, ExactSpelling = true)]
        public static extern int GetTickCount();
        static MapInfoApplication mapinfo = new MapInfoApplication();
        static ReflectionMapInfo reflectionmapinfo = new ReflectionMapInfo(mapinfo);

        static void Main(string[] args)
        {
            mapinfo.Do(@"Open Table ""C:UsersWooDocumentsUntitled.TAB""");

            int pass = 0;
            while (pass <= 2)
            {
                Console.WriteLine("Interface Test, Pass " + pass + "Count 100 " + Time(100));
                Console.WriteLine("Interface Test, Pass " + pass + "Count 200 " + Time(200));
                Console.WriteLine("Interface Test, Pass " + pass + "Count 300 " + Time(300));
                Console.WriteLine("Interface Test, Pass " + pass + "Count 500 " + Time(500));
                Console.WriteLine("Interface Test, Pass " + pass + "Count 1000 " + Time(1000));
                Console.WriteLine("Interface Test, Pass " + pass + "Count 2000 " + Time(2000));
                Console.WriteLine("Interface Test, Pass " + pass + "Count 5000 " + Time(5000));
                pass++;
            }

            pass = 0;
            while (pass <= 4)
            {
                Console.WriteLine("Reflection Test, Pass " + pass + "Count 100 " + ReflectionTime(100));
                Console.WriteLine("Reflection Test, Pass " + pass + "Count 200 " + ReflectionTime(200));
                Console.WriteLine("Reflection Test, Pass " + pass + "Count 300 " + ReflectionTime(300));
                Console.WriteLine("Reflection Test, Pass " + pass + "Count 500 " + ReflectionTime(500));
                Console.WriteLine("Reflection Test, Pass " + pass + "Count 1000 " + ReflectionTime(1000));
                Console.WriteLine("Reflection Test, Pass " + pass + "Count 2000 " + ReflectionTime(2000));
                Console.WriteLine("Reflection Test, Pass " + pass + "Count 5000 " + ReflectionTime(5000));
                pass++;
            }
            Console.ReadLine();
        }

        public static double Time(int count)
        {
            int start = GetTickCount();
            for (int i = 0; i < count; i++)
            {
                mapinfo.Do("Fetch Next From Untitled");
            }
            int end = GetTickCount();
            mapinfo.Do("Fetch First From Untitled");
            return (end - start) / 1000d;
        }

        public static double ReflectionTime(int count)
        {
            int start = GetTickCount();
            for (int i = 0; i < count; i++)
            {
                reflectionmapinfo.Do("Fetch Next From Untitled");
            }
            int end = GetTickCount();
            reflectionmapinfo.Do("Fetch First From Untitled");
            return (end - start) / 1000d;
        }
    }

Unofficial MapInfo feature request list – Updated Again!


EDIT:

So nothing official was decided however I really like the layout and usability of http://getsatisfaction.com/mapinfopro and Bill Theon added my wish list to the header of MapInfo-l so I guess we can use it for a while until something better comes along.   I am looking a buying some paid hosting and moving my blog and creating a better wish list, something that I have more control over.  Something like http://www.opensourcerails.com/projects/1785-OpenMind but money is tight so I don’t think that will happen for a while.

The other day I was looking around some GIS websites and found that ESRI have a place where people can go and post feature requests,bugs,ideas about all the different ESRI products.  Looking around I wasn’t able to find anything like this for any MapInfo products, so I thought it might be a good idea to start one.

A lot of information flows though the global MapInfo-l message board, things that would be nice to have down as feature requests or bugs so that people can comment and PBBI can really see what people would like in their products.  I am aware that you can send feature requests though the MapInfo Professional software however I think having a community effort would be much better as you can quickly see what other people
have thought of and if you support that idea also, which in turn lets PBBI see what the community wants.

I have trailed a few different feedback sites and I have gone with a site called getsatisfaction.com, it is user friendly, lets you post comments (even what mood the request or bug puts you in, handy to see what really bugs people). The only thing I wanted and it didn’t have is a vote up and vote down feature, it has it in the paid version put I am only using the free version because I don’t have a spare $20 a month.  My thoughts were, if you would like to see a feature or a bug fixed post a comment on the item and use the smiley face (you’ll see what I mean on the site) to show you support the idea.

I have added two new items which I would like to see, please feel free to add more.  Hopefully we can start building up a list of featuresthat we would like see, or bugs that we find.

MapInfo Pro Feature Requests – Things I would like to see – Better thematics


I have been working on a rather large mapping project over the last couple of months, and that thought I would write a blog post about some features that I would like to see implemented in MapInfo Pro to make map making a little bit easier.  This could get long so I might break in down into different posts.

Let us begin.

Linked thematic map templates:

Thematic maps are great, I use them all the time but unfortunately they are a big pain in the butt when it comes to using and applying them across a large range of maps and workspaces and using them to keep map updated.

I will elaborate a bit on that last point with a scenario.  Lets say you have a table with a series of maintenance points each with one of the following values:

  • Complete
  • Started
  • Failed

Now we can create a thematic map to show these values:

Sweet, now we can use the Save As… template option so we can save it as something like “Maintenance – Status – Standard”, we do this so that we can apply it to other maps later on.

Now I want to save a workspace because I have all sorts of maps open that need to keep their formating, so I do a Save Workspace…. as something like “Jobs.wor” , a couple of weeks later I would like to make a new set of maps, (say for a gridded map book for the field) using the same template so that I am using the same standard colors across all my maps.   I open the table, make my grid and apply the template to the maintenance layer, everything looks good, now I save the workspace… “Jobs Map book.wor”.  So by this time we have two workspaces: “Jobs.wor”;“Jobs Map book.wor”.

After a couple of weeks I realize that I have to change one of the colors that we use to show the job status.  So we open up the Maintenance.tab and apply the “Maintenance – Status – Standard” template that we have already set up, then we change the color of the Completed job status to yellow, and do a template Save As… and save it as the same name as the old template, overwriting the old one.

Now I want to generate my map book again to bring it up to the new standard colors, I open up the “Jobs Map book.wor” workspace, and what! my colors in the thematic for the maintenance job status are still the same as they were before I updated my template.  Opening up the “Jobs.wor” workspace I find the same thing, there is a disconnection between the template and where it is used.

The reason this happens is because when you save the workspace it hard codes the thematic values right into the workspace with the map. something like this:

shade 1 with Values values
“Complete” Symbol (34,16711680,12) ,
“Failed” Symbol (34,65280,12) ,
“Started” Symbol (34,255,12)
default Symbol (40,0,12)   # color 1 #

meaning that each map in the workspace now has its’ own independent thematic map regardless of the template changes.  If I would like my two workspaces to have the template  new colors I must open both of them and remove the thematic on each map that uses it and reapply it and save.  The problem with this is that it requires the user of the workspace to be aware of the changes in the template and reapply them.  In a multi user environment this becomes difficult.  I also becomes a problem when you have a large workspace 20+ maps all using the same thematic, that is 20+ changes every time you need to make a style change.

What I think would work

My idea is just like something Peter Horsboll Moller and Gentreau in this Mapinfo-l thread suggested beck in 2008, a syntax and command addition to MapBasic.
Something like the following:

Shade <tablename> Layer <layername> Using Template <full path to template> Column <column name>

This means you would be able to store templates in one place and any time somebody opens the workspace, the theme file is read and applied to the map, meaning you will always have the latest style changes.  By using the full path or just the theme name you could store theme files on a network drive or just with the workspaces if it is only going to be used for a selected job with lots of workspaces.

You could also store something like this in the tab file meta data, to use a theme file as the default shading:

\defaulttheme\path = “<full path to template>”

Why I think this word be good.

As it’s pretty obvious from the scenario that I outlined, if you are working on a large mapping project with a table and thematic being used in all the workspaces.  The ability to update just the template and not have to worry about updating each  independent  thematic stored for map in each workspace would greatly improve map making speed.  This feature become even more needed when projects become old and not knowing which workspace and maps need to be changed.

Notes.

Just saving the path to a theme template file would not always be needed(sometimes templates aren’t even needed, for one-off jobs), so hard coding the thematic into the workspace still needs to be an option, but by default it should save a template and the path to the template first rather than hard coding.

Please let me know what you think.

I am writing this as a public blog rather than just sending it straight to MapInfo because I would like to see what other people also think.  Maybe this idea can be expanded? Maybe you would like to say why it shouldn’t be done? Doesn’t matter the reason, let me know.  All comments are welcome, the more people behind an idea the better.

True floating and top most Mapbasic window.


<Rant>One thing that has always annoyed me with MapInfo is the Mapbasic window.</Rant>

That last statement is a bit bold so let me break it down, functionality wise it is great and I couldn’t use MapInfo without it, however it is part of the MDI Client (the gray bit in MapInfo  that the map windows belong to) this means that when you have a map or browser window and the Mapbasic window open they both have the same z-order in the MDI Client, meaning you can end up with this problem.

Not Cool

This is not cool, and I wonder how this even passed the user interface testing phase but I digress.

One of the problems that this can bring is that you can’t have a maximized map/browser window and just have a small Mapbasic window in the corner.  This may not seem like a big deal however due to the z-ordering issue it forces you to micro manage your windows in the MDI client, move the map a little bit now you have to move the Mapbasic window so that it doesn’t sit behind you map and so on, all in all wasting time you could be making your map.

Get on with it

So what is the point of this post, well a little while ago I was sitting writing some unrelated C# code and it hit me.  If I can call and show a .Net form from Mapbasic, parent it to MapInfo and embed the normal Mapbasic window in my new .Net form I could make a true top most floating Mapbasic window that lives above any other window in MapInfo and remove that z-ordering issue.

After doing some playing around in test projects I discovered what I wanted to do was possible and without to much effort, there was a few little things that caused problems but what software adventure doesn’t have those.

I complied all the code into a set of tools called the “Floating Windows Tools”, this set of tools also does a few other things but they will be covered in other blog posts.

The main thing the set of tools does is float the Mapbasic window above all the other window, here is an example of the result of using the tool.

The above image shows a maximized map window and the Mapbasic window sitting on top of the map, it will always be on top and never move behind the map or any other window in MapInfo for that matter.

More Information & Downloads

More information, downloads and examples can be found on my google code project page for the project:

Demo Video

Sorry about the low quality.

Contact me

I have spent a fair fews hours developing and testing this tool, however as with all software there are always things that could be improved or  bug to be squished.  So if you find anything or have a improvment idea don’t hesitate to contact me via here or on the google code page for this project.

Sneak Peek

And because software is never finished here is a sneak peek at the new version I am working on, this version will have syntax highlighting and code completion so that it will make it easier to type Mapbasic.

Since making the first release my time to work on this project has decrease a lot, so I can’t see me making a release of the new version anytime soon however I may have a  “all I do is code” weekend and may get it done faster then I think so stay tuned if your interested.

Embedding the whole Mapinfo application in a .Net form.


Not sure if I’ll ever have a need for this, but someone else may so I thought I would throw this up here, just in case.

A couple of days ago there was a question on MapInfo-l about embedding MapInfo into a .Net application(http://groups.google.com/group/mapinfo-l/browse_thread/thread/15dfc23ceff8ceef).
Embedding a map window into .Net is something that is covered in the Mapbasic manual however this is not what was needed, what was interesting was the person wanted to be able to embed the whole Mapinfo application menus and all into a .Net contol.

As I had not done this before or seen anyone else do it I thought it might be interesting to have a look into it, knowing also that by using Win32 libraries from .Net(eg User32.dll) you could do some cool stuff I figured why not?

The following code is what I managed to write that lets me embed the whole application into a .Net control(I let the code comments explain what is going on):

For this code to work you will need to create a .Net form with a picture box somewhere on it and a button that calls button1_click for it’s click handler, you will also need to reference Mapinfow.exe/Mapinfo COM server see https://woostuff.wordpress.com/2009/04/01/com-instance-mapinfo-main/ for details.

    public partial class Form1 : Form
    {
        // Sets the parent of a window.
        [DllImport("User32", CharSet = CharSet.Auto, ExactSpelling = true)]
        internal static extern IntPtr SetParent(IntPtr hWndChild, IntPtr hWndParent);

        //Sets window attributes
        [DllImport("USER32.DLL")]
        public static extern int SetWindowLong(IntPtr hWnd, int nIndex, int dwNewLong);

        //Gets window attributes
        [DllImport("USER32.DLL")]
        public static extern int GetWindowLong(IntPtr hWnd, int nIndex);

        //assorted constants needed
        public static int GWL_STYLE = -16;
        public static int WS_CHILD = 0x40000000; //child window
        public static int WS_BORDER = 0x00800000; //window with border
        public static int WS_DLGFRAME = 0x00400000; //window with double border but no title
        public static int WS_CAPTION= WS_BORDER | WS_DLGFRAME; //window with a title bar
        public static int WS_MAXIMIZE = 0x1000000;

        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            // Create a new instance of MapInfo.
            MapInfoApplication mapinfo = new MapInfoApplication();

            // Get the handle to the whole MapInfo application.
            // 9 = SYS_INFO_MAPINFOWND.
            string handle = mapinfo.Eval("SystemInfo(9)");

            // Convert the handle to an IntPtr type.
            IntPtr oldhandle = new IntPtr(Convert.ToInt32(handle));

            //Make mapinfo visible otherwise it won't show up in our control.
            mapinfo.Visible = true;

            //Set the parent of MapInfo to a picture box on the form.
            SetParent(oldhandle, this.pictureBox1.Handle);

            //Get current window style of MapInfo window
            int style = GetWindowLong(oldhandle, GWL_STYLE);

            //Take current window style and remove WS_CAPTION(title bar) from it
            SetWindowLong(oldhandle, GWL_STYLE, (style & ~WS_CAPTION));

            //Maximize MapInfo so that it fits into our control.
            mapinfo.Do("Set Window 1011 Max");
        }
    }

After the code is complied and run you should end up with a screen like this:
(Once the whole MapInfo application is embedded into our C# application, we can still do all the Do and Eval methods that we normally would when doing integrated Mapping)