GooDotNet

Goo.NET uses the v146 distribution of Goo with some changes to enable .NET support. Download the Goo.NET distribution and unzip it in the same directory as the v146 installation. Overwrite any files that already exist. The distribution includes a precompiled binary compiled with the .NET Framework SDK.

Inside the dotnet-vc directory there is a makefile that can be used to re-build the binary. This makefile will need to be modified if you add any additional Goo or .NET code. I haven't worked out a means of this hapenning automatically yet.

As currently configured wrappers exist for the following .NET classes:

• System.Reflection.Assembly
• System.Type
• System.Reflection.MethodInfo
• System.Activator
• System.Net.WebProxy
• System.Net.WebRequest
• System.Net.HttpWebRequest
• System.Net.HttpWebResponse
• System.Net.WebResponse
• System.Net.CredentialCache
• System.IO.Stream
• System.Text.Encoding
• System.Windows.Forms.MessageBox

I wrapped the metatype classes (Assembly, etc) with the intention of writing some Goo libraries that allow wrapping and calling .NET functions from Goo without having to rebuild the Goo binary. I have not yet got around to this so the current way of wrapping .NET classes is a bit tedious due to the requirement of having to rebuild Goo (but it's fairly automated). The remaining classes were done to test out various parts of the wrapper system.

Some examples of using Goo.NET are below.

Showing a Message Box

(use double/dotnet/system_windows_forms_messagebox) 
(system-windows-forms-messagebox-show-string "Hello World!") 

Reading a web page

(use double/dotnet/base) 
(use double/dotnet/system_net_webrequest) 
(use double/dotnet/system_net_httpwebrequest) 
(use double/dotnet/system_net_webproxy) 
(use double/dotnet/system_net_credentialcache) 
(use double/dotnet/system_net_webresponse) 
(use double/dotnet/system_net_httpwebresponse) 
(use double/dotnet/system_io_stream) 
(use double/dotnet/system_text_encoding) 
(dv request (system-net-webrequest-create-string "http://radio.weblogs.com/0102385/")) 
(dv response (system-net-webrequest-getresponse request)) 
(dv stream (system-net-webresponse-getresponsestream response)) 
(dv buf (fab <vec> 8192)) 
(fill! buf #space) 
(dv count (system-io-stream-read-byteaa-int32-int32 stream buf 0 (len buf))) 
(dv s (as <str> (sub buf 0 count))) 
(msg out "%s\n" s) 
(system-io-stream-close stream) 

Running a thread

(use double/dotnet/system_windows_forms_messagebox)
(use time/threads)
(spawn
  (system-windows-forms-messagebox-show-string "Hello World!"))

Adding additional .NET classes

To automatically generate wrappers for .NET framework classes you need to use GooProxyGenerator.exe in the dotnet-vc/proxygen directory. Have a look at the examples in gp.bat in that same directory.

Basically you pass GooProxyGenerator an 'output type', an assembly name, The namespace of the class, and the class name. The output of GooProxyGenerator goes to standard output so you should redirect it somewhere sensible. The 'output type' can be one of:

• goo - Generates the goo wrapper code.
• c - Generates the C wrapper code.
• cheader - Generates the header file that must be added to grt.h.
• cpp - Generates the C++ wrapper code.

You will need all four generated files. When generated the Goo code must live anywhere in the Goo source code directory. You should also add a 'use' for it in eval/main.goo so it is included when you rebuild the Goo C code.

The 'c' and 'cpp' files need to be included in the makefile and the 'cheader' file included in grt.h.

Re-compile the Goo source to 'C' using:

(using eval/g2c)
(g2c-top)

Then recompile the C source using the makefile in dotnet-vc. You should now have a rebuilt goodotnet.exe which has the added functionality for calling the .NET framework classes you requested.

It's long and involved but it works. Ultimately things will be easier when/if some code is written to dynamically generate the wrapper functions on the fly without having to recompile the Goo system.

To Do List

• Get dynamic compilation working.
• Dynamic generation of wrapper code for .NET framework (using run time reflection capabilities of .NET).