Roger Alsing Weblog

Patrik Löwendahl blogged about using C#3 features in .NET 2 via VS.NET 2008 a few days ago:
http://www.lowendahl.net/showShout.aspx?id=191

There are quite a few of the new features that works straight out of the box.
However, Linq does not, alot of the code that Linq uses is simply not present in the .NET 2 BCL.

So, inspired by Patriks post I opened up an old custom Linq engine that I wrote a while back and spiced it up and adapted it for .NET 2.
I also added a few of the standard list extensions such as “Take” “Skip” etc.

The code can be found here:
www.puzzleframework.com/Roger/LinqForNet2.zip

And before you get all excited, this is only Linq to objects, NOT Linq to SQL….

The code supports the following Linq constructs, features and list extensions:

• from (ok ok, I didn’t have to code anything for that)
• where
• join
• groupby
• orderby
• select
• Take
• Skip
• TakeWhile
• SkipWhile
• Distinct
• Deferred execution

Enjoy : - )

 //Roger

I’ve been digging through the ObjectDataSource today and I was trying to figure out how they created the datasource instance from the type name.

Now some clever reader might say “I know, I know, Type.GetType(string)”… But that’s wrong..
Type.GetType(string) requires full type names with assembly name and the whole shebang.

The ObjectDataSource is able to create instances w/o all that information.
So after a while of digging I found a precious gem, hidden in System.Configuration:
“BuildManager.GetType(string)”

Very very nice

I can now inherit ObjectDataSource and fetch the type via buildmanager and then call NAspect to proxy the type and get an AOP enabled datasource.

Thats all for now, just wanted to share this one

I’ve created a little sample on how to make your own .NET compiler.
The compiler uses Gold parser for parsing and Reflection.Emit to generate the compiled .exe file.

Initially I intended to make a sample on how to use Gold parser to parse and then compile Linq expressions, thus the name GoldLinq, however, Linq have now been replaced with Reflection.Emit.

Links:
My compiler source: http://www.puzzleframework.com/Roger/GoldLinq.zip
(C# VS.NET 2008 solution)

Gold parser: http://www.devincook.com/goldparser/
Grammar: http://www.devincook.com/goldparser/grammars/index.htm

How it works:

• Gold parser - Calitha engine is used to parse the source code into a parse tree
• The parse tree is transformed into a typed AST
• The AST is verified using visitor pattern, the verifier handles type inferrence and auto casts.
• The AST is optimized using visitor pattern, the optimizer replaces constant expressions and statements.
• The AST is compiled into CIL/MSIL using visitor pattern.
• If successful, the compiler will generate a file called “output.exe” in the same folder as the compiler

Samples:

Hello world 

display 'Hello World!'

 Have a nice day:

Display 'What is your name?' Read Name
Display 'Hello, ' & Name & '. Have a nice day!'

Blastoff: 

assign n = 10
while n >= 1 do
    display n
    assign n = n - 1
end
display 'Blast off!'

Miles and kilometers: 

Display
'Do you want to convert 1) Miles to Kilometers or 2) Kilometers to Miles?'
Read Choice        

if Choice == 1 then
    Display 'Please enter the number of miles' Read Miles
    Display Miles & ' Miles = ' & (Miles * 1.609)  & ' Kilometers'
else
    Display 'Please enter the number of kilometers' Read Kilometers
    Display Kilometers & ' Kilometers = ' & (Kilometers / 1.609)  & ' Miles'
end

Secret number: 

Assign SecretNumber = 64 

Display 'Please guess the secret number'
Read Guess          

While Guess <> SecretNumber Do
    If Guess < SecretNumber Then
        Display 'Your guess was too LOW. Try again.' Read Guess
    End    
If Guess > SecretNumber Then
        Display 'Your guess was too HIGH. Try again.' Read Guess
    End
End     

Display 'Correct!'

How to compile the samples:

First you need a source file to compile, just create a normal textfile and paste one of the samples above into it.
Once you have the code file you can compile it using the compiler:

c:whatever\bin\debug> GoldSample.exe mysource.txt

When the compiler is done, you can start the compiled application with:

c:\whatever\bin\debug> output.exe

The code is somewhat too big to cover in a blog post, so if you have any questions feel free to ask in the comment section.

//Roger