BingyBot - A Google Wave Bot written in .NET, that interfaces with Bing APIs

Labels: , Friday, September 18, 2009 | By Anoop Madhusudanan

After spending my last weekend hack on the API, I've rolled together my first simple .NET bot, the Bingy Bot. You can try Bingy either in the Google Wave Sandbox (add bingybot@appspot.com to your wave), or in these public test waves.


See Bingy in action.



Bingy bot answers user's questions, and even allows users to create FAQ waves collaboratively.

See this Google WAVE FAQ here, built by asking questions to Bingy. If you've wave sand box access, you can invite bingybot@appspot.com to your wave.
Google Wave exposes an excellent API to create extensions, and to embed Waves. Some time back, I had a quick look towards the Wave Robot API, and thought it'll be great if I've a .NET client API to work on. So, when I saw Jon Skeet tweeted about his C# Wave Bot API Port some time back, I found it interesting.


About Bingy

Sing in the tune "Twinkle Twinkle.."
 
"Bingy Bingy what you say, How I wonder what you say,
Up above the bots of Wave, Like a wavelet in the Web"


A little bit of Irony here - Bingy bot tries to find answer for your questions using Bing APIs, and post it back if it knows. Type a question, like "what is an elephant?" or just key in a flight number to get the status. Bingy will answer if it knows. Bingy interfaces with Bing using the XML APIs to do instant searches. I'll spend more time on Bingy to make it smarter, so that it can process tokens, and give better information other than flight status etc.

Though Jon has a well written tutorial (his code itself is simple enough to start hacking), I'll post a detailed example with my experiments with the wave bot api, specifically on the Bing interfacing. As I already mentioned, the best part of Bingy is that it is implemented in .NET.

Basically, a python proxy is hosted in google app engine that routes all calls to your custom domain. These steps are already mentioned in Jon's wiki post. I'll upload the code soon so that this can be a reference point for a first cut implementation.

Resources For You To Start With

Here are a couple of references
By the time you start exploring the wave model, I'll write another detailed post about the implementation of Bingy, with source code.
Here is the code for embedding the wave if you like. But no guarantee that I'll continue to host it for another 10 years!! 
<html xmlns="http://www.w3.org/1999/xhtml" xmlns:v="urn:schemas-microsoft-com:vml"> 
  <head> 
    <meta http-equiv="content-type" content="text/html; charset=utf-8"/> 
    <title>Bingy Bot Wave Test</title> 
    <script src="http://wave-api.appspot.com/public/embed.js" type="text/javascript"></script> 
    <script type="text/javascript"> 
    function initialize() {
      var wavePanel = new WavePanel('http://wave.google.com/a/wavesandbox.com/');
      wavePanel.loadWave('wavesandbox.com!w+4T_YGl-u%BH');
      wavePanel.init(document.getElementById('waveframe'));
    }
    </script> 
  </head> 
  <body onload="initialize()" style="background:white"> 
  <font face="arial"> 
    <h1>bingybot@appspot.com</h1> 
    <div id="waveframe" style="width: 100%; height: 90%;background:white"></div> 
  </body> 
  </font> 
</html>

 

Enjoy, happy coding!!

Shout it
Read more >>

View Comments

ExpandoObject in C# 4.0 Inside Look - 'Attaching' Members (Properties, Methods etc) To Objects At Runtime

Labels: , , Saturday, September 05, 2009 | By Anoop Madhusudanan

About .NET 4.0 Series - I'll be covering various aspects of .NET 4.0 and related technologies in these posts

In my previous post and related article, I gave a quick introduction towards creating and using your own custom dynamic types, inheriting from the DynamicObject class. .NET framework 4.0 has a cool new ExpandoObject class, in System.Dynamic namespace. What makes this special is, it allows you to create an object with members that can be dynamically added and removed at run time.

To clarify the point, have a look at this example. 

  
            dynamic obj = new ExpandoObject();
            obj.Value = 10;
            var action = new Action<string >((line) => Console.WriteLine(line));
            obj.WriteNow = action;
            obj.WriteNow(obj.Value.ToString());

And you'll get 10 as output in your console. As you can see, the property 'Value' and method 'WriteNow' is attached at runtime, when the invocation happens.

The objective of this post is to examine how the ExpandoObject itself is implemented. To make this clear, let us create a MyExpando class, a minimal implementation of ExpandoObject.

We are inheriting MyExpando class from the DynamicObject, and these are the major methods we are overriding.

  • TrySetMember- Provides the implementation of setting a member.
  • TryGetMember-Provides the implementation of getting a member.
  • TryInvokeMember- Provides the implementation of calling a member.
  • GetDynamicMemberNames- Returns the enumeration of all dynamic member names.

And Here is our minimal MyExpando class, inherited from DynamicObject, and overrides the above methods. 
  public class MyExpando : DynamicObject
    {

        private Dictionary < string, object > _members = new Dictionary < string, object > ();


        /// 
        /// When a new property is set, add the property name and value to the dictionary
        ///      
        public override bool TrySetMember(SetMemberBinder binder, object value)
        {
            if (!_members.ContainsKey(binder.Name))
                _members.Add(binder.Name, value);
            else
                _members[binder.Name] = value;

            return true;
        }

        /// 
        /// When user accesses something, return the value if we have it
        ///       
        public override bool TryGetMember(GetMemberBinder binder, out object result)
        {
            if (_members.ContainsKey(binder.Name))
            {
                result = _members[binder.Name];
                return true;
            }
            else
            {
                return base.TryGetMember(binder, out result);
            }
        }

        /// 
        /// If a property value is a delegate, invoke it
        ///      
        public override bool TryInvokeMember(InvokeMemberBinder binder, object[] args, out object result)
        {
            if (_members.ContainsKey(binder.Name) && _members[binder.Name] is Delegate)
            {
                result = (_members[binder.Name] as Delegate).DynamicInvoke(args);
                return true;
            }
            else
            {
                return base.TryInvokeMember(binder, args, out result);
            }
        }


        /// 
        /// Return all dynamic member names
        /// 
        /// 
        public override IEnumerable&ltstring> GetDynamicMemberNames()
        {
            return _members.Keys;
        }
    }
When ever a property set operation happens, the runtime will invoke TrySetMember, and there, we are pushing the property name and value to a dictionary. Similarly, when ever a get operation happens (TryGetMember), we are simply returning the value object if available in the dictionary. Also, when a method call is made (TryInvokeMember), if the value type is a delegate, we just invoke the same by passing the arguments we received. Pretty simple, huh?

Well, that is it. Now, let us try the above scenario with our MyExpando object 

           dynamic obj = new MyExpando();
            obj.Value = 10;
            var action = new Action((line) => Console.WriteLine(line));
            obj.WriteNow = action;
            obj.WriteNow(obj.Value.ToString());

Run the application, and guess what you get!!

Read more >>

0 comments

Fun with Dynamic Objects and MEF in C# 4.0

Labels: , , Friday, September 04, 2009 | By Anoop Madhusudanan




About .NET 4.0 Series - I'll be covering various aspects of .NET 4.0 and related technologies in these posts

C# 4.0 introduced the dynamic keyword, to support dynamic typing. If you assign an object to a dynamic type variable (like dynamic myvar=new MyObj() ), all method calls, property invocations and operator invocations on myvar will be delayed till the run time, and the compiler won't perform any type checks for myvar at compile time.

So, if you do something like myvar.SomethingInvalid(); it is valid at compile time, but invalid at runtime if the object you assigned to myvar doesn't have a SomethingInvalid() method.
The System.Dynamic namespace has various classes for supporting dynamic programming, mainly the DynamicObject class from which you can derive your own classes to do run time dispatching yourself.

A couple of points to note.
  • A dynamic call will be slower for the first time, and your calls will be jited and cached if possible for subsequent calls. As a first step, the DLR checks the cache to see if the given action has already been bound wrt to the arguments. If not, the DLR checks to see if the receiver is an IDynamicObject, and if so, asks the receiver to bind the action. If the receiver is not an IDO, then DLR calls into the language binder (i.e, the C# runtime binder), and cache this.
  • C#'s underlying type system has not changed in 4.0. As long as you are not using dynamic keyword, you are still statically typed (i.e, the types are known for the compiler at compile time).
  • Error handling when you use dynamic features is a bit difficult and can't be very specific, as you don't know much about the foreign objects to which you dispatch the calls.
Recently, I published this article in Codeproject; 
This article demonstrates a couple of interesting techniques, including.
  • Creating a dynamic wrapper around the file system so that we can access Files and Directories as properties/members of a dynamic object
  • A way to attach custom Methods and operators to our dynamic wrapper class and dispatch them to a plug in sub system.

Read more >>

0 comments
Subscribe to: Posts (Atom)
top