Finally a new version of SubSonic was released today with a lot of new features.  SubSonic is one of my favorite Data Access Layer (DAL) generators, that makes it super easy to create data access code.

As a developer you have a lot of control over what the generated code looks like, which is great because I do not like code generators to dictate the essence of my code.  But the beauty of SubSonic is that you never really have to interact with the generated code itself.  It’s automatically generated and compiled for you — you just need to learn how to use it, which is pretty simple.  What’s more, it’s free, and works with not only SQL Server, but also with MySQL, SQLite, and Oracle databases. 

SubSonic was originally started by Rob Conery as an open source project.  Later, Microsoft hired Rob and asked him to continue working on this project.  The latest 3.0 version took about a year to be completed.  According to Rob’s blog following are some of the new features:

A nice Linq engine which parses IQueryable “stuff” into SQL (thanks to Matt Warren’s excellent work with the IQToolkit, which we stole mercilessly).

A templating system which allows you to use ActiveRecord, good old Linq in Linq to SQL style, or whatever floats your boat.

A SimpleRepository which is just about zero-drag and even builds your database for you

A brand-new project site that will hopefully answer the question “is SubSonic dead”? Or probably not

A new docs site that has permanently crushed my ability to type. It’s a wiki so if you feel like being helpful and like SubSonic and want to help… nudge… nudge

ScottGu  just made available a free downloadable eBook in PDF format as well as a simple and easy-to-understand sample project called Nerddinner.

The eBook is actually a chapter from his upcoming book on MVC, but it is an end-to-end tutorial that walks through building a small but complete ASP.NET MVC application from scratch.

Download eBook.

Download Nerddinner sample code.

Buy ASP.NET MVC 1.0 Book at Amazon.com. 

If you do decide to read this book, please do not forget to share your thoughts with me.

Using this new feature, instead of defining private variables and creating explicit getters and setters, you can create properties like this:

public class Employee
{
   public string ID { get; set; }
   public string LastName { get; set; }
   public string FirstName { get; set; }
}

Developer Express and Microsoft provide a new version of CodeRush licensed exclusively for C# developers working in Visual Studio. The new product is called CodeRush Xpress, and it includes a slew of useful features to boost your productivity under Visual Studio.

You can download CodeRush Xpress here.

The latest beta version of FxCop 1.36 was recently made available for download. This new version includes various features and fixes that include:

• 200+ bug fixes that reduce noise, missing analysis and rule crashes
• Support for analyzing anonymous methods and lambda expressions
• New option for skipping analysis over tool generated code
• Better support for C++/CLI and the Compact Framework
• Language ‘friendly’ API names in the UI and resolutions
• New globalization, design and usage rules
• Performance improvements that cut analysis by 2x and use half as much memory
• Documentation that is now available on MSDN

FxCop is an excellent free static code analysis tool from Microsoft that checks .NET managed code assemblies for conformance to Microsoft’s .NET Framework Design Guidelines.

SubSonic is an excellent open source DAL generation tool developed by Rob Conery that has been around for almost a year. In most cases SubSonic can just be added to your project, pointed to a databse, and you magically and immediately gain access to a rich and strongly typed object model that can be used to query and persist data to and from your relational data source.

SubSonic also has a cool feature called the REST handler that essentially allows one to use HTTP protocol as an interface to data stored in a back-end relational database. It is URI based and returns data back in XML format. This data can then be used by decoupled client applications as they see fit. If you have never looked at SubSonic, you owe it to yourself to checkout this very cool tool.

Recently Microsoft unveiled their plans to release similar features codenamed Astoria and Jasper with .NET framework 3.5 and Visual Studio 2008. The CTP of Astoria and Jasper are available for download from Microsoft.

Jasper is described by Microsoft as:

Project Jasper is geared towards iterative and agile development. You can
start interacting with the data in your database without having to create
mapping files or define classes. You can build user interfaces by naming
controls according to your model without worrying about binding code. Project
Jasper is also extensible, allowing you to provide your own business logic and
class model. Since Project Jasper is built on top of the ADO.NET Entity
Framework, it supports rich queries and complex mapping.

Pablo Castro, the mastermind behind Astoria describes it as:

The goal of Microsoft Codename Astoria is to enable applications to expose data as a data service that can be consumed by web clients within a corporate network and across the internet. The data service is reachable over HTTP, and URIs are used to identify the various pieces of information available through the service. Interactions with the data service happens in terms of HTTP verbs such as GET, POST, PUT and DELETE, and the data exchanged in those interactions is represented in simple formats such as XML and JSON.

The Astoria web site also includes sample online services that showcases how this new technology can be used. It also allows anyone with a Passport account to design and host their own experimental data services .

The first version of Silverlight (formerly WPF/e) was recently released and can be downloaded from Microsoft’s web site.

Contrary to what many people believe, Silverlight is not simply a rich media player for the web. Nor is it just a replacement or a competing product for Adobe Flash. Silverlight is a technology that allows developers to deliver Windows-like rich user experience to the web. This includes animations, vector graphics, music, movies, etc., but it also includes the ability to develop WinForms-like applications with grids, treeviews, toolbars, and so on and so forth.

To get started with Silverlight, checkout these videos, or see this demo by Scott Guthrie and Jason Zander on the .NET Show. If you are looking to develop a WinForms-like user experience, you may also appreciate GOA WinForms which is an implementation of standard System.Windows.Forms .NET library for both Adobe Flash and Silverlight.

In the last couple of years I have noticed a steadily growing interest in the .NET community around the Inversion of Control (IoC) and Dependency Injection (DI) patterns.  This is partly due to the fact that a number of excellent frameworks have emerged and gained popularity that allow us to use these designs in our applications relatively painlessly.  One such framework is the open source Castle Project.  In my opinion Castle is the best implementation of IoC and DI among many others that I have come across including Spring.NET, NInject, and ObjectBuilder.  This is however my opinion; which framework you use largely depends upon your requirements and your preferences.

If you are just getting started with Castle or are curious about why the heck one should use IoC and DI, I strongly suggest you check out the 3-part article series by Simone Busoli.  I just came across these articles and I can’t stress enough how well they are written.

ASP.NET generates temporary files from the code-behind and aspx files that it compiles into assemblies behind the scenes. These temporary files are stored in %WINDIR%\Microsoft.NET\Framework\v2.0.50727\Temporary ASP.NET Files folder. Sometimes these files get out-of-sync with the user code and modifications to the code have no effect while debugging. In such situations it is safe to delete the contents of this folder and force ASP.NET to regenerate these files.

JavaScript and JScript languages provide a convenient Eval method that allows for dynamic evaluation of expressions. This functionality can be duplicated in C# using Microsoft’s JScript CodeDomProvider and Reflection.

Following class automatically compiles an in-memory assembly using JScript CodeDomProvider. The Eval method uses this assembly to dynamically evaluate specified expressions:

using System;
using System.CodeDom.Compiler;
using System.Reflection;
using Microsoft.JScript;

///
/// Implements JScript/JavaScript Eval like
/// functionality in C# to allow dynamic evaluation
/// of expressions.
///
public static class ExpressionEvaluator
{
    #region Private Members

    private static Type _evaluatorType;
    private static object _evaluatorInstance;
    private static readonly string _jscriptEvalClass =
    @"import System;
class JScriptEvaluator
{
public static function Eval(expression : String) : String
{
return eval(expression);
}
}";

    #endregion

    #region Private Methods

    ///
    /// Creates a dynamic in-memory assembly using JScript.NET
    /// to evaluate expressions.
    ///
    private static void Initialize()
    {

        CodeDomProvider compiler = new JScriptCodeProvider();

        CompilerParameters parameters = new CompilerParameters();
        parameters.GenerateInMemory = true;
        parameters.ReferencedAssemblies.Add("system.dll");

        CompilerResults results = compiler.CompileAssemblyFromSource(parameters, _jscriptEvalClass);

        Assembly assembly = results.CompiledAssembly;
        _evaluatorType = assembly.GetType("JScriptEvaluator");
        _evaluatorInstance = Activator.CreateInstance(_evaluatorType);
    }

    #endregion

    #region Public Methods

    ///
    /// Evaluates specified expression using reflection
    /// on the assembly generated in Initialize() method.
    ///
    /// The expression.
    /// A string representing evaluated expression.
    public static string Eval(string expression)
    {
        if (_evaluatorInstance == null)
            Initialize();

        object result = _evaluatorType.InvokeMember(
        "Eval",
       BindingFlags.InvokeMethod,
        null,
       _evaluatorInstance,
        new object[] { expression }
       );

        return (result == null) ? null : result.ToString();

    }

    #endregion
}

Using this class, we can execute statements such as:

        Console.WriteLine(ExpressionEvaluator.Eval("2 + 9"));
        Console.WriteLine(ExpressionEvaluator.Eval("System.DateTime"));
        Console.WriteLine(ExpressionEvaluator.Eval("Environment.OSVersion.VersionString"));