The output or input redirection is often used by the command line script guys. The output redirection (”>”) is usually to the file instead of the standard output. The input redirection (”<”) is to have a file as input instead of the standard input. It is sometimes needed in the programs too.

Interoperability with other programs is another concept especially when developing interoperable application. To do that the programming framework often sports different libraries for interoperability. However sometimes, for a simple code you don’t want to call the low level heavy libraries for doing the operation while there is a simple workaround.

There might be three ways of doing it.

1. Trusting to the environment shell or command prompt.
2. Use the Java internal process libraries and do the redirection ourselves.
3. Use JNI class libraries for doing cross platform operation with the native code.

In one of the projects I was working with one of the earthquake modules that does some calculations. The program is in compiled form that it won’t worth the reimplementation. Instead I needed to call from the environment and display the output.

In order to use the system command prompt it is needed to use the “exec” method of the Runtime. This solution might not be guaranteed to work if the command line is broken or it is not with the standard names. Also it is not really beautiful to have if statements detecting the operating system and behaving on that.

Runtime.getRuntime().exec(cmdCommand);

void creatproc()
{
	String osName = System.getProperty("os.name");
	Process p;
 
	if (osName.startsWith("Windows"))
	{
		String cmdwin = "cmd /c C:EWv6.2binhyp2000.exe < C:EWv6.2bininput.txt";
		try
		{
			File f = new File("C:EWv6.2bin");
			Runtime.getRuntime().exec(cmdwin, null, f);
		}
		catch (IOException e)
		{
 
			e.printStackTrace();
		}
	}
	else
	{
		String[] cmdlinux = new String[3];
		cmdlinux[0] = "/bin/sh";
		cmdlinux[1] = "-c";
		cmdlinux[2] = "hypo2000 < input.txt";
		try
		{
			Runtime.getRuntime().exec(cmdlinux);
		}
		catch (IOException e)
		{
 
			e.printStackTrace();
		}
	}
}

After detecting the operating system it for windows it is needed to call cmd and for Linux> it is needed to call sh. There is one implementation between the command prompt of those operating systems as well. Likewise Windows could tell the difference of a single string while in Linux you have to specify the command arguments as the arrays of string. Other than that everything works exactly the same as you would expect.

A better implementation would be to use the java.io.BufferedReader; and feed the process that we have opened with the file contents. It is like implementing the behind scenes in our Java code. We create the process and write to the process output while reading from the file.

public void Redirect()
{
	BufferedReader freader = null;
	PrintStream fout = null;
	java.io.PipedReader pRead = null;
	PipedOutputStream po = null;
	Process p = null;
	try
	{
		freader = new BufferedReader(new FileReader("C:EWv6.2bininput.txt"));
 
	}
	catch (FileNotFoundException e1)
	{
 
		e1.printStackTrace();
	}
	try
	{
		File f = new File("C:EWv6.2bin");
 
		p = Runtime.getRuntime().exec("C:EWv6.2binhyp2000.exe",
				null, f);
		fout = new PrintStream(p.getOutputStream());
	}
	catch (IOException e)
	{
 
		e.printStackTrace();
	}
	String line = "";
	try
	{
		while ((line = freader.readLine()) != null)
		{
			fout.println(line);
		}
		fout.flush();
	}
	catch (IOException e1)
	{
 
		e1.printStackTrace();
	}
	try
	{
		p.waitFor();
	}
	catch (InterruptedException e)
	{
 
		e.printStackTrace();
	}
}

I found the usage of Java process libraries better than the others, but for quick solution the others might be helpful as well. Also it doesn’t look good in terms of “portability” of the application code.

I really liked the XML expressiveness of Visual Basic, let’s build a very simple MSN History Search Engine using LINQ and XML Literals in Visual Basic.

The best thing is those literals could be used in LINQ expressions. Remember the simple XML file that MSN stores as a history.

• .@AttributeName : Accesses the attribute element in XML
• .<ElementName> : Accesses the element in XML
• …<Descendant name>: Accesses the descendant name in XML

Modifying the XML content is very neat as well either using the LINQ expressions or even in loops.

In .NET Framework 2.0 VB has one more feature called MY namespaces. It is very nice to access some dynamic data available like application or forms information. It also contains some helper functions to do some common tasks. Now I also found it very handy in a Windows Forms application.

Get the history files from the location and operate the XLINQ query:

Private Sub btnSearch_Click(ByVal sender As System.Object, ByVal e As System.EventArgs)
 
For Each file In My.Computer.FileSystem.GetFiles(dirLocation)
ProcessFile(file)
Next
txtOutput.Text = sBuild.ToString()
 
End Sub

The XLINQ query that does search magic for the messages is as follows :

Function ProcessFile(ByVal s As String) As Boolean
If s.EndsWith("xml") Then
Dim msn = XElement.Load(s)
Dim q = From message In msn.<message> _
Where message.<text>.Value.Contains(txtSearch.Text) _
Select From = (message.<from>.@FriendlyName), Too = (message.<to>.@FriendlyNam), _
Message = message.<text>.Value
For Each msgFound In q
sBuild.AppendLine(msgFound.From + " says to " + msgFound.Too + _
" :  " + msgFound.Message)
Next
End If
End Function

What makes this different is the usage of literals. In C# that query would be longer than that.
In the sample message.<From>.@FriendlyName
means that it will get the From element and get the friendlyname attribute from it.

It is basically like having the XML data in your hands but there is no need to parse it or access the elements using the classes provided rather this work is done by the compiler at the compile time.

In a couple lines of code we have a fully featured MSN history searching. Let me know if you still want the source code (although that is all about it) or even the executable in case you are not into programming.

Here is the summary of new language features as mentioned on the “What’s new on ORCAS

• C# 3.0 Language Support: This CTP implements all of the C#3.0 language features from the May LINQ CTP including:
  • Query Expressions
  • Object and Collection Initializers
  • Extension Methods
  • Local Variable Type Inference and Anonymous Types
  • Lambdas bound to Delegates and Expression trees
  • Complete design-time support: Intellisense, Formatting, Colorization

• VB 9.0 Language Support: This CTP contains the following language features:
  • Query Expressions: Basic querying, filtering, and ordering support
  • Object Initializers
  • Extension Methods
  • Local Variable Type Inference
  • Anonymous Types
  • XML literals
  • XML properties
  • New Line and Expression IntelliSense

LINQ is all in both of the languages and indeed this is the main feature for .NET Framework 3.5. Writing any type of queries is the purpose of LINQ at the end. Considering the abilities of LINQ, everything was possible before as well. LINQ makes us to get rid of the strings (the red coloured stuff) from the program in order to minimise the typo errors, easy to read programs by syntax highlighting. But all the best is that gives the ability to write declarative and functional style programs.

Beside the new language features, as a compiler improvement, it is very surprising that C# still doesn’t have background compilation. There is background syntax checking but no compilation. I believe this is a definite need for C# because it is really helpful. For instance the F# projects do background compilation and syntax checks, that way it easy to investigate “silly errors” while coding. Also this was one of the powerful features that I found on eclipse while working on a Java project.

Visual basic has that feature moreover it has also automatic syntax fixing as well. Likewise if you call a method with lower case letters it is automatically converted to the actual method on the next line. Actually in a type inferenced language this is needed, because it is not easy to recognise the type information of all the members.

Anyway I just wrote a quick macro to give the feeling of background compilation for C#. It is not really sophisticated but it works. Just put it into EnvironmentEvent macro in Visual Stuio.

Dim lastbuilt As DateTime
    Private Sub TextDocumentKeyPressEvents_AfterKeyPress(ByVal Keypress As String, ByVal Selection As EnvDTE.TextSelection, ByVal InStatementCompletion As Boolean) Handles TextDocumentKeyPressEvents.AfterKeyPress
        Dim doc = DTE.ActiveDocument
        Dim diff = DateTime.Now.Subtract(lastbuilt)
 
        If Not Char.IsLetterOrDigit(Keypress(0)) And diff.Seconds > 5 Then
            DTE.ExecuteCommand("Build.BuildSelection")
            lastbuilt = DateTime.Now
            doc.Activate()
        End If
    End Sub

XML in Language

All of the best is that now XML is a first class citizen in VB. I wouldn’t expect this as a serious feature but after trials it makes extremely relevant to use XML in Visual Basic. You get syntax highlighting and even intellisense for XML if the namespaces are specified and even more.

Having XML literals in the language, it makes really sense to use XLinq with VB.

Like consider the xml stored by messenger. You could just assign to a variable just like that.

        Dim msn = <?xml version="1.0"?>
                  <?xml-stylesheet type='text/xsl' href='MessageLog.xsl'?>
                  <Log FirstSessionID="1" LastSessionID="1">
                      <Message Date="25/03/2007" Time="22:35:47" DateTime="2007-03-25T21:35:47.173Z" SessionID="1">
                          <From><User FriendlyName="koko"/></From>
                          <To><User FriendlyName="opopop"/></To>
                          <Text Style="font-family:Comic Sans MS; font-weight:bold; color:#0000a0; ">151515</Text>
                      </Message>
                      <Message Date="25/03/2007" Time="22:35:55" DateTime="2007-03-25T21:35:55.344Z" SessionID="1">
                          <From><User FriendlyName="koko"/></From>
                          <To><User FriendlyName="opopop"/></To>
                          <Text Style="font-family:Comic Sans MS; font-weight:bold; color:#0000a0; ">5959959</Text></Message>
                  </Log>

It will have the type of System.Xml.Linq.XDocument.

Let’s define the XML Stylesheet :

        Dim xslt = <?xml version="1.0"?>
                   <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
                       <xsl:template match="Log">
                           <html>
                               <head>
                                   <title> Message Log for </title>
                               </head>
                               <body style='margin:0'>
                                   <table border='1'>
                                       <tr>
                                           <td> From </td>
                                           <td> To </td>
                                           <td> Message </td>
                                       </tr>
                                       <xsl:for-each select="/Log/Message">
                                           <tr>
                                               <td><xsl:value-of select="From/User/@FriendlyName"/></td>
                                               <td><xsl:value-of select="To/User/@FriendlyName"/></td>
                                               <td><xsl:value-of select="Text"/></td>
                                           </tr>
                                       </xsl:for-each>
                                   </table>
                               </body>
                           </html>
                       </xsl:template>
                   </xsl:stylesheet>

If we want to do an XSLT transformation to that snippet, it is even easier than it used to be.

Dim xTransform = New System.Xml.Xsl.XslCompiledTransform()
xTransform.Load(xslt.CreateReader())
xTransform.Transform(msn.CreateReader(), New System.Xml.XmlTextWriter("test.html", New System.Text.UnicodeEncoding()))

I think working with xml data using Visual Basic should be considered as a manipulation language. Since we are all becoming multilingual this shouldn’t be a problem.

JSON (JavaScript Object Notation) is a lightweight data-interchange format. JSON is an object notation in text format that Javacript engine fully understands and there is no need to parse for it.

The library contains some basic types that Javascript requires. IJSONObject, JSONElement, JSONNumber<T>, JSONString, JSONBoolean, JSONCollection, JSONArray and JSONObject.

• JSONObject : Represents JSON objects beginning and ending with curly braces ({}). It is a collection of JSONElement objects. Object members consist if string and values separated by colon in JSON notation.
• JSONArray : Represents a javascript array that begin and end with braces and contain values. In the notation values are separated by commas, but the library does all the syntactic issues.
• JSONCollection : A base type for JSONObject and JSONArray.
• JSONElement : Base class for all JSON types. It has the base properties and can be used with arrays or objects or individually.
• JSONString : Represents JavaScript string type and created by double quotes. It is inherited from a JSONElement
• JSONBoolean : Represents JavaScript boolean type
• JSONNumber<T> : Represents a javascript number type, it can be integer, or floating point numbers.

JSON Tools for .NET is the library that helps to build JSON objects from .NET Framework objects. I just wanted to share the code that I was working previously. It is not a complete library. There is a need for some helper classes for working with dynamic objects and collections. JSONReflector might be useful as a new feature.

You can download the JSON Tools for .NET and play with it. Also, you are very welcome to join and contribute to the project.

A simple example of JSON output looks like this:

{ 
"Total" : 45500, 
"Offset" : 0, 
"Result_List" : [ 
   { "Description" : "JSON (JavaScript Object Notation) (Pronounced like Jason, IPA /d?e?s?n/ ) is a lightweight computer data interchange format. It is a text-based, human-readable format for ... ", 
     "Title" : "JSON - Wikipedia, the free encyclopedia", 
     "URL" : "http://en.wikipedia.org/wiki/Json" } , 
 
   { "Description" : "object {} { members } members pair pair , members pair string : value array [] [ elements ] elements value value , elements value string number object array true false null", 
     "Title" : "JSON", 
     "URL" : "http://www.json.org/" } , 
 
] }

This example is the one of the outputs from the sample directory. It is actually a live search query displayed in JSON string.

In C#, each object is contracted with an IJSONObject interface. That interface has a single WriteObject Method that does the JavScript representation of the actual object.

Here is a sample implementation for a result type object.

public JSONObject WriteObject()
{   
    JSONNumber<int> jTotal = new JSONNumber<int>("Total", m_Total);
    JSONNumber<int> jOffset = new JSONNumber<int>("Offset", m_Offset); 
 
    List<JSONObject> ResultObjects = new List<JSONObject>(m_Results.Count);
    foreach (SearchResult r in m_Results)
    {
        ResultObjects.Add(r.WriteObject());
    } 
 
    JSONArray jResults = new JSONArray("Result_List", ResultObjects); 
 
    JSONObject js = new JSONObject("LiveResults", jTotal, jOffset, jResults);
    return js;
}

Another representation of a result by using different JSON types.

public JSONObject WriteObject()
       {    
           JSONString jDescription = new JSONString("Description", m_Description);
           JSONString jTitle = new JSONString("Title", m_Title);
           JSONString jURL= new JSONString("URL", m_URL); 
 
           JSONObject js = new JSONObject("Result", jDescription, jTitle, jURL);
           return js;
       }

I liked the way it creates JSON object out of an object. No reflection, no dynamic code emit, which means it should have no problems for busy heavy servers.  On the other hand a JSONReflector and a JSONParser could be implemented using the same class library.

It has been a long time since I haven’t blogged. Lots of things have happened on my side and on the development world. After finishing the internship at Microsoft Research Cambridge and submitting my thesis, I started to work at European Product Development Center in Dublin. I am very excited to work at Microsoft again.

I started a new project and used Visual Studio 2008 for that. I say used because the project is prematurely ended. That’s why I find time to write actually. Anyway that’s another story. From now on, I will try to blog more often about F#, C# 3.0, Parallel FX Library and Silverlight.

Here are the developer news :). There were so many exciting things happened.

First F# is getting productized. I want to congratulate for the achievement and looking forward for the next updates. It is great news for the developer  and research world. I am really happy for F# being a “product”. What does that mean as a developer point of view is that, the language will not die and it will be more stable and developped more quickly. A functional language getting to the main stream will involve lots of new development and research ideas. The team is now focusing on stability and feature fixing and I am really looking for the future releases.   

Moreover, Visual Studio 2008 is out there. At first it looks very similar in terms of user interface. But I have to admit that it’s lot better and faster. Here are the quick impressions. I like the window list when navigating between the tabs with Ctrl Tab with a small preview window. I liked the transparency of the code complete display. when you press Ctrl it becomes transparent so that it is possible to read the code underneath, you don’t have to navigate away. Of course beside the visual enhancements, the language extensions such as LINQ, DLINQ, XLINQ, collection initialisers and functional constructs in C# and VB (lambda expressions, anonymous types), new designers and  new classes (pipes..) in the framework are really welcome. More classes are now supporting the generic types and most of nongeneric types became abbreviated.I hope the same goes for all of the typed collection types as well. Such as XMLNodeList etc :). Typed is something good..

Finally the project management system of Visual Studio 2008 allows us to target to lower frameworks as well. So there is no need to hack visual studio to compile on other frameworks. This is also possible because there is no update on the CLR, on the other hand it is not possible to target 1.1 because of the CLR change but who wants to do that anymore ?

Happy coding…