The wonderful XYNTService application is an application that allows you to turn commandline utilties into NT Services.

This is where you can get the subversion version control software. This includes svnserve which needs to be run from the command-line.

These two make an ideal pair allowing the subversion server to be run as a stand-alone service.

 

This is a superb project based upon Castle, MonoRail and Winsor.

It provides basic project issue tracking, reports and calenders. 

This is a software metric tool.

It is great for dermining the relative sizes of projects. 

This is suggested as a notepad replacement.

Recently I have been playing with Monorail the port of Ruby on Rails to C#/.NET
I needed to get Cassini to work with .NET 2

The initial version of Cassini that I have was built against  

I added the following as CassiniWebServer.exe.config 

<?xml version =”1.0″?>
<configuration>
<startup>
<requiredRuntime version=”v2.0.50727″/>
<supportedRuntime version=”v2.0.50727″/>
</startup>
</configuration>

This is all that was required. 

This may not be the most elegant paging code for sql server but it solves the problem:

create database foobar
go

use foobar
go

drop table test
go
create table test(id int not null, name varchar(10) not null, primary key(id))
go

insert into test values (1,’one’)
insert into test values (2,’two’)
insert into test values (3,’three’)
insert into test values (4,’four’)
insert into test values (5,’five’)
go

select top 2 *
from test  
where id not in (select top 2 id from test)
order by id
go

 

There are a number of useful OO Frameworks that allow us to avoid reinventing the wheel:

Castle Project

This project acts as a container for a number of other Open Source Projects

• Containers – This provides inversion of control services that allows an application to consist of distinct interfaces
• • Facilities
  • Components
  • Services
• Monorail
• Active Record
• • NHybernate
• Dynamic Proxy

CSLA.NET

Microsoft Enterprise Libraries

Genghis

This is a great introduction to CSLA 2.0

CSLA 2.0 is the 7th version of a complete OO framework.

It has a rather steep learning curve. 

The Castle Project is a collection of useful  C# tools

This is a sample application of the Castle using an App.config:

It demonstrates the use of Castle.Winsor to allow an app to specify behaviour.
This  could easily be used to switch logging handlers.

Here is the main source of the application:

 

using System;
using System.Collections.Generic;
using System.Text;

namespace CastleConsole
{
    using Castle.Windsor;                            // Castle.Winsor
    using Castle.Windsor.Configuration.Interpreters; //Castle.MicroKernel

    public interface ILogger
    {
        void Log(string msg );
    }

    public class LogToConsole : ILogger
    {
        public void Log(string msg)
        {
            System.Console.WriteLine(“The message was {0}”, msg);
        }
    }

    public class SecondLogger : ILogger
    {
        public void Log(string msg)
        {
            System.Console.WriteLine(“Second logger was {0}”, msg);
        }
    }

    public interface IExecute
    {
        void Execute();
    }

    /// <summary>
    /// This is a class that uses the logger
    /// </summary>
    public class ThreeExecutions : IExecute
    {
        /// <summary>
        /// This is used to store the logger interface
        /// </summary>
       
        ILogger _logger;

        public ThreeExecutions(ILogger logger)
        {
            _logger = logger;
        }

        public void Execute()
        {
            _logger.Log(“One”);
            _logger.Log(“Two”);
            _logger.Log(“Three”);
        }
    }

    /// <summary>
    /// Summary description for CastleConsoleTestClass
    /// </summary>
    public class CastleConsoleTestClass
    {
        static void Main(string[] args)
        {
            try
            {
                // This is the initial version
                //IWindsorContainer container = new WindsorContainer();
                //container.AddComponent(“logger 2”, typeof(ILogger), typeof(SecondLogger));
                //container.AddComponent(“logger”, typeof(ILogger), typeof(LogToConsole));           
                //container.AddComponent(“execute”, typeof(IExecute), typeof(ThreeExecutions));
               
                // This one uses app.config
                IWindsorContainer container = new WindsorContainer(new XmlInterpreter());
                IExecute service = (IExecute)container[“execute”];
                service.Execute();

            }
            catch(Exception ex)
            {
                System.Console.WriteLine(ex.Message);
            }
           

            System.Console.ReadLine();
        }
    }
}

 

Here is the app.config file:

 

<?xml version=”1.0″ encoding=”utf-8″ ?>
<configuration>
  <configSections>
    <section name=”castle”
         type=”Castle.Windsor.Configuration.AppDomain.CastleSectionHandler,
                   Castle.Windsor” />
  </configSections>

  <castle>
    <components>
      <component id=”logger” service=”CastleConsole.ILogger, CastleConsole” type=”CastleConsole.LogToConsole, CastleConsole”  />
      <component id=”execute” service=”CastleConsole.IExecute, CastleConsole” type=”CastleConsole.ThreeExecutions, CastleConsole” />
    </components>
  </castle>

</configuration>

 

If you replace the first line of the components section with:

  <component id=”logger” service=”CastleConsole.ILogger, CastleConsole” type=”CastleConsole.SecondLogger, CastleConsole”  />