Learned something new from Mark’s blog: Windows Server 2008 R2 is 64bit ONLY( The news is not new, but I only learned it tonight.) It will still support 32 bit applications, but only via OPTIONAL WoW64 functionality that is not added by default. I’ve heard about Microsoft stopping 32bit OS development a while back, but seeing this actually done…. This is BIG.
Subversion 1.6 (And so is TortoiseSVN 1.6 and Subclipse 1.6) is released.
New Functionality includes
TortoiseSVN includes a completely rewritten Revision Graph
Get it while its hot www.tigris.org
IE8 is now released and I’ve just upgraded my home laptop to it (I try not to mess around with betas on my main machine) So far so good. Speed of the browser is definitely something to brag about. I’ve also liked accelerators that come with IE. When you select a block of text with a mouse, a menu pops up that allows you to blog, email, search and even translate. Very useful functionality that can be extended by third-parties.
Download the new Internet Explorer at http://www.microsoft.com/windows/internet-explorer/default.aspx
In previous post I published about a Linq for Oracle Coherence. Linq makes it very convenient to add functionality to a provider, however creating a functionally reach and complete provider is a very complicated process.
Latest functionality I’ve added was ability to use coherence extractors in the query. Linq does not allow you to change its keywords and syntax, however, all functions are converted to linq expressions and are passed to the ExpressionVisitor for evaluation. First thing is to create an extended function to provide the functionality
public static T Extractor<T>(this object obj, string Name) { throw new NotSupportedException(); } public static T ChainedExtractor<T>(this object obj, string Name) { throw new NotSupportedException(); }
The functions themselves do not have any functionality and are used solely to be converted to a linq expression. I’ve created them as Generic functions to be able to strongly type against extracted data
In the QueryTranslator class VisitMethodCall() function, we add functionality to evaluate the expression
if (m.Method.DeclaringType == typeof(LinqFunctions)) { if (m.Method.Name == "Extractor") { this.Visit(m.Arguments[1]); string right = (string)globalFilter; globalFilter = new Tangosol.Util.Extractor.ReflectionExtractor(right); return m; } else if (m.Method.Name == "ChainedExtractor") { this.Visit(m.Arguments[1]); string right = (string)globalFilter; globalFilter = new Tangosol.Util.Extractor.ChainedExtractor(right); return m; } }
m.Arguments[0] has the reference to the parent object. m.Arguments[0] contains the argument. This allows us to create a Coherence Extractor that is used in the filters higher in the expression tree.
A Note: I hope that the project gets some visibility and comments. Oracle Coherence is an excellent product with great .NET potential. Check out the project on google code: http://code.google.com/p/linqtocoherence
I am very impressed with Coherence from Oracle. Coherence provides a distributed in-memory cache and processing fabric. However it is a lot more then just a cache. It can be used for everything from messaging to cross platform communication medium. There is too much to talk say about it, so read more information at Oracle: http://www.oracle.com/technology/products/coherence/index.html
Coherence works very nicely with .Net however, in the days of Linq, I wanted to write a Linq provider for it. My code is based largely on the Linq provider documentation on MSDN (http://msdn.microsoft.com/en-us/library/bb546158.aspx) and excellent series on creating a linq provider by Matt Warren (http://blogs.msdn.com/mattwar/pages/linq-links.aspx)
I am using Google Code to host the project under Artistic License. Please check out the full source code at http://code.google.com/p/linqtocoherence/.
Below is a rundown on two main classes. The main part of the code that deals with Coherence is in two classes CoherenceQueryProvider and CoherenceQueryTranslator.
CoherenceQueryProvider accepts a connection to the INamedCache – a reference to coherence cache that will be queried.
public class CoherenceQueryProvider : IQueryProvider { public INamedCache Cache { get; set; } public CoherenceQueryProvider () { } public CoherenceQueryProvider(INamedCache cache) { Cache = cache; }
In the Execute method, CoherenceQueryProvider translates the Where clause to a Coherence Filter and executes the filter against the Cache objects to return array of values.
public object Execute(Expression expression) { if (Cache == null) throw new InvalidOperationException("Cache is not properly set"); // Find the call to Where() and get the lambda expression predicate. InnermostWhereFinder whereFinder = new InnermostWhereFinder(); MethodCallExpression whereExpression = whereFinder.GetInnermostWhere(expression); LambdaExpression lambdaExpression = (LambdaExpression)((UnaryExpression)(whereExpression.Arguments[1])).Operand; // Send the lambda expression through the partial evaluator. lambdaExpression = (LambdaExpression)Evaluator.PartialEval(lambdaExpression); IFilter filter = new CoherenceQueryTranslator().Translate(lambdaExpression); object[] data = Cache.GetValues(filter); Type elementType = TypeSystem.GetElementType(expression.Type); return data; }
CoherenceQueryTranslater uses the visitor pattern to convert the Linq Expression from the where clause to Coherence Filter. Coherence filters are nested to converting one to the other is relatively simple
protected override Expression VisitBinary(BinaryExpression b) { this.Visit(b.Left); object lastGlobal1 = globalFilter; this.Visit(b.Right); object lastGlobal2 = globalFilter; switch (b.NodeType) { case ExpressionType.AndAlso: globalFilter = new AndFilter((IFilter) lastGlobal1, (IFilter)lastGlobal2); break; case ExpressionType.OrElse: globalFilter = new OrFilter((IFilter) lastGlobal1, (IFilter)lastGlobal2); break;
There is a lot more code in the classes to handle other filters, but a lot of it is pretty repetitive. The work on the linq provider is not done and I still have to implement some of the coherence functionality. Full code and usage sample is available on google code http://code.google.com/p/linqtocoherence/
Check it out and post your comments / suggestions.
We as developers spend our careers creating tools, innovating, making things better through technology. However, as a developer we also constantly deal with users who are refusing to change. Examples are everywhere
The world is changing all the time. Technology accelerates this change and we can either fight it, or embrace it and make it work for us. I say – Embrace Change
I generally don’t link to other blog entries since that doesn’t add that much value to people. However, this post is not regarding the specific blog entry. Jurgen has an excellent blog dedicated to software development and management of development teams.
He also created excellent lists of TOP *EVERYTHING*. The last one published is Top 50 New Software Development Books. Other lists are at http://www.noop.nl/top-lists/
This is one of the blogs I would definitely recommend subscribing to.
