development

Using XPath to select nodes with a missing attribute

kellyb — Fri, 15 Jan 2010 01:05:58 GMT

The only thing worse than my XPath skills are my RegEx skills. I don’t use XPath all that much these days, but today I needed to. It took me a while to find a code sample that does this. After a playing a bit with SnippetCompiler, I found the solution:

StringBuilder builder = new StringBuilder();
builder.AppendLine("<foo>");
builder.AppendLine("<bar baz=\"a\">1</bar>");
builder.AppendLine("<bar>2</bar>");
builder.AppendLine("<bar baz=\"b\">3</bar>");
builder.AppendLine("<bar>4</bar>");
builder.AppendLine("<bar baz=\"c\">5</bar>");
builder.AppendLine("</foo>");

XmlDocument doc = new XmlDocument();
doc.LoadXml(builder.ToString());

XmlNodeList nodes = doc.SelectNodes("//foo/bar[not(@baz)]");

if ( nodes == null )
{
    WL("nodes was null");
}
else
{
    foreach ( XmlNode node in nodes )
    {
        WL("Node: " + node.InnerText);
    }
}

Hand-Shaping the XML Schema of your data contract using IXmlSerializable

kellyb — Fri, 10 Apr 2009 15:14:55 GMT

I’ve been getting into some pretty advanced scenarios with WCF where we need to precisely shape the XML on the wire and the schema’s that are produced by svcutil.exe. Trust me, the moment you start using WCF for exposing services to Java clients, those Java clients are really going to care how the XML looks. WCF makes .NET-to-.NET very easy, and .NET-to-Java doable, but I wouldn’t call it easy. For vanilla scenarios (simple contracts with simple types and basic complex types), it’s pretty easy. The hooks exposed by WCF for shaping the XML are pretty poor in my opinion.

IXmlSerializable is your friend when it comes to shaping the xml on the wire. It will work with the Data Contract Serializer in WCF, but if you google around trying to find info on people using IXmlSerializable, you’ll quickly get confused. I wanted to hand-roll how my entity serializes, and this interface is very straightforward for that. For shaping the schema, it’s not straight forward in the slightest. Below are several lessons I learned over a number of days while working with IXmlSerialiable:

GetSchema is not what you use to shape the schema!

I don’t know what this method is for, but it’s not what it sounds like. Everything you’ll find on google is people returning null. If you programmatically construct an XmlSchema instance, and return it from GetSchema(), it won’t be used. As far as I can tell, the Data Contract Serializer never calls this method. Instead, you have to decorate your class with the XmlSchemaProvider attribute and specify the static method that should be called for shaping the schema. This method should accept an argument of type XmlSchemaSet and in that method is where you should construct your schema, and add it to the XmlSchemaSet. It appears the method you implement must return either an instance of XmlQualifiedName or any derivative of XmlSchemaObject (i.e. XmlSchemaComplexType or XmlSchemaSimpleType). Here’s an example:

    [XmlSchemaProvider("ConstructSchema")]
    public class Product : IXmlSerializable
    {
        private bool _deserializing;
        protected object _data;

        public virtual object Data
        {
            get { return _data; }
            set { _data = value; }
        }

        public static XmlQualifiedName ConstructSchema(XmlSchemaSet schemaSet)
        {
            const string theNamespace = "http://webservices.kellybrownsberger.com/1.0";

            XmlSchema schema = new XmlSchema
            {
                TargetNamespace = theNamespace,
                ElementFormDefault = XmlSchemaForm.Qualified
            };

            schemaSet.Add(schema);

            return new XmlQualifiedName("Product", theNamespace);
        }

        public XmlSchema GetSchema()
        {
            throw new NotImplementedException("Not implemented - the XMmlSchemaProvider attribute specifies calling the static GetSchema method instead");
        }

        public void ReadXml(XmlReader reader)
        {
        }

        public void WriteXml(XmlWriter writer)
        {
        }
    }

Shaping Schema using a read-in xml string

This is handy for two things in my mind – readability and code-gen. People tend to like looking at a schema in an xml representation. It’s more error prone, and not refactor-tool-friendly, but it’s more readable to the masses I think. Secondly, I like to code-gen my contracts in batch (using T4). Typically, I’ll define some XML grammar (DSL if you will), that describes my entities. I can then gen them all and make sure all of the correct attributes are applied. This might seem silly, but in large systems with interoperability being a top-priority, keeping all of your DataContract and DataMember attributes correct (one forgotten or botched namespace declaration can hose our consumers) is a bit daunting. When you get into the more complex things like contract versioning, and types implementing IXmlSerialable, it’s very daunting. Being able to code-gen this stuff has a lot of advantages. Reading in XML Schema as text is code-gen friendly as it can easily be captured as part of the DSL/grammar I mentioned, and the necessary code can be generating quickly and easilyand because your generating it, it’s less error prone.

Example:

        public static XmlQualifiedName ConstructSchema(XmlSchemaSet schemaSet)
        {
            const string theNamespace = "http://webservices.kellybrownsberger.com/1.0";

            StringBuilder builder = new StringBuilder();
            builder.AppendLine(string.Format("<xs:schema xmlns:tns=\"{0}\" elementFormDefault=\"qualified\" targetNamespace=\"{0}\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">", theNamespace));
            builder.AppendLine("<xs:complexType name=\"Product\">");
            builder.AppendLine("<xs:sequence minOccurs=\"1\" maxOccurs=\"1\">");
            builder.AppendLine("<xs:any />");
            builder.AppendLine("</xs:sequence>");
            builder.AppendLine("</xs:complexType>");
            builder.AppendLine("</xs:schema>");

            XmlSchema schema = XmlSchema.Read(new StringReader(builder.ToString()), null);

            schemaSet.Add(schema);

            return new XmlQualifiedName("Product", theNamespace);
        }

Shaping Schema programmatically

It took me longer than I care to admit to figure out how to do this correctly (it took me forever to figure out that I needed to sequence to the XmlSchemaComplexType’s Particle property). Here’s an example:

        public static XmlSchemaComplexType ConstructSchema(XmlSchemaSet schemaSet)
        {
            const string theNamespace = "http://webservices.kellybrownsberger.com/1.0";

            XmlSchema schema = new XmlSchema
            {
                TargetNamespace = theNamespace,
                ElementFormDefault = XmlSchemaForm.Qualified
            };

            XmlSchemaComplexType type = new XmlSchemaComplexType { Name = "Product" };
            schema.Items.Add(type);
            
            XmlSchemaSequence sequence = new XmlSchemaSequence {MinOccurs = 1, MaxOccurs = 1};
            sequence.Items.Add(new XmlSchemaAny());
            type.Particle = sequence;

            schemaSet.Add(schema);

            return type;
        }

Testable WCF ServiceHost

kellyb — Wed, 18 Mar 2009 03:50:00 GMT

I’m finally getting a chance to sink my teeth into Windows Communication Foundation (WCF). I’m finding quite a few gaps on the interoperability side of things, and I think it’s overly complex in it’s configuration schemes and extensibility points, but it’s light years beyond what we had previously in ASMX. From what I can tell, the WCF adoption was just much slower than everyone anticipated. I’m not sure why that is – perhaps it’s the vastness of it that’s intimidated people. Perhaps it was the quality of the the .NET version 2.0 release that resulted in a slow adoption of all of version 3.0+. For whatever reason, this seems to have caused a number of rough edges in the product to sit dormant for a couple of years now.

At any rate, WCF is now part of my every day day-job, and I’m trying to find ways to make it more testable. We have a suite of what I’d call System Tests. Unit Tests by my definition, test at the object (or component) boundary while System Tests test at a collection of objects (or components). Our system is highly configurable, and behaviors vary dramatically from one configuration to the next. We’d like to have the ability to have a repeatable suite of automated test that can test all of our out-of-the-box configurations.

To date we’ve been executing our tests by .bat file (shelling to MbUnit.Cons.exe) after copying copies of our config files to our hosting IIS project. This is less than awesome for a few reasons:

It’s Slow and Flakey – Running test out of process (which is what IIS is) is always slower than in-process. Keep our test suite blazing fast is highly desirable. Also, when you’re doing this kind of thing, it’s not uncommon to need to restart IIS between tests (IIS caching certain types of config data, etc.), which can really slow down the party.
It’s Heavy and Hard to Setup – IIS is required to be installed on any machine that wants to run the tests.
It’s Awkward – We must have .bat files that copy around our Web.config files that contain our test configuration before executing our tests. The natural experience of running our tests directly from the IDE is lost.

Luckily, WCF is highly extensible and customizable in it’s hosting infrastructure. In the System.ServiceModel of the .NET Framework, they expose everything you need to easily create your own host for your WCF services. We’ve all seen the MSN samples that hosts your hello-world service with a Console app. To make our automated tests more awesome, I created a TestableServer service host implementation.

The Service

Lets say we have a service like this…

    /// <summary>
    /// Here's my service implementation
    /// </summary>
    public class SomeService : ISomeService
    {
        public DateTime GetCurrentDate()
        {
            return DateTime.Now.Date;
        }
    }

    /// <summary>
    /// Here's my service contract for my implementation
    /// </summary>
    [ServiceContract]
    public interface ISomeService
    {
        [OperationContract]
        DateTime GetCurrentDate();
    }

The Test

With the TestableServer, I can write a tidy little test like so…

    [TestFixture]
    public class SomeServiceFixture
    {
        [Test]
        public void Can_We_Invoke_GetCurrentDate()
        {
            using (TestableServer<SomeService, ISomeService> server = new TestableServer<SomeService, ISomeService>(new BasicHttpBinding()))
            {
                ISomeService proxy = server.CreateProxy();

                DateTime actual = proxy.GetCurrentDate();

                Assert.AreEqual(DateTime.Now.Date, actual.Date);
            }
        }
    }

By passing a few generics, it has all the information it needs to host my service in-memory and I can execute tests against it directly. Notice in the TestableServer constructor, I’m passing in the binding I’d like to use. Here I can specify netTcpBinding, msmqBinding, or any of they other support bindings. Here I’m using vanilla HTTP.

The Code

There’s not much to it at all, but here’s the code behind TestableServer…

    public class TestableServer<TServiceImp, TServiceInt> : IDisposable where TServiceImp : class
    {
        private ServiceHost _host;
        private readonly Type _serviceImplType = typeof(TServiceImp);
        private readonly Type _serviceIntType = typeof(TServiceInt);
        private readonly string _url;
        private readonly Binding _binding;
        private ChannelFactory<TServiceInt> _factory;
        private TServiceInt _channel;

        public TestableServer() : this(new NetTcpBinding()) { }

        public TestableServer(Binding binding)
        {
            _host = new ServiceHost(_serviceImplType);
            _binding = binding;

            _url = string.Format("{0}://localhost/{1}", _binding.Scheme, Guid.NewGuid());
            _host.AddServiceEndpoint(_serviceIntType, _binding,  _url);

            try
            {
                _host.Open();
                
            }
            catch (TimeoutException timeoutEx)
            {
                Console.WriteLine("Failed to close the service host - Exception: " + timeoutEx.Message);
                throw;
            }
            catch (CommunicationException communicationEx)
            {
                Console.WriteLine("Failed to close the service host - Exception: " + communicationEx.Message);
                throw;
            }
        }

        public TServiceInt CreateProxy()
        {
            _factory = new ChannelFactory<TServiceInt>(_binding);
            _channel = _factory.CreateChannel(new EndpointAddress(_url));
            
            return _channel;
        }

        public void Dispose()
        {
            if ( _factory != null )
            {
                _factory.Close();
                _factory = null;
            }

            TearDown();
        }

        private void TearDown()
        {
            if (_host != null)
            {
                try
                {
                    if ( _host.State == CommunicationState.Opened || _host.State ==CommunicationState.Opening)
                    {
                        _host.Close();
                    }
                }
                catch (TimeoutException timeoutEx)
                {
                    Console.WriteLine("Failed to close the service host - Exception: " + timeoutEx.Message);
                }
                catch (CommunicationException communicationEx)
                {
                    Console.WriteLine("Failed to close the service host - Exception: " + communicationEx.Message);
                }
                finally
                {
                    _host = null;
                }
            }
        }
    }

The Ultimate Goal

So, I haven’t actually achieved my ultimate goal yet, which is to be able to programmatically configure the server/service for each of our supported configurations and execute our test suites against those configurations. That’s what I’m going to work on next, and without IIS between my test fixture and my service implementation, achieving that goal should be relatively simple.

2009 – Base Personal Image

kellyb — Tue, 13 Jan 2009 02:07:07 GMT

Some time ago I wrote a post called Base Personal Image. I wanted to write an update to that, but decided it would be nice to have it in it’s original date for historical purposes. So, I’m writing a new post and stamping it with the year.

Here’s the topology of my setup

The staple of my setup are Windows Live Mesh (this replaced Folder Share for me – now called Windows Live Synch). This is what ties everything together for me.

Core

Windows Vista SP1 with IIS
.NET Framework 1.1, 2.0, 3.5
AVG Free Anti-Virus
7-Zip – the fastest there is
FireFox 3.0
Foxit Reader - stay away from Acrobat... it's a dog
Windows Search 4.0
Google Talk
Office 2007 Ultimate
- Save as PDF add-in for Office
Windows Live Messenger
TeraCopy – RoboCopy-like features from the Windows Shell
Windows Home Server Console – available for download from your Windows Home Server

Power Using

Cropper
Paint.NET
Launchy - this replaced SlickRun for me when Launchy released a plugin model along with a "Runner" plugin (which does just about everything SlickRun does).
Windows 2003 Resource Kit Tools (Robocopy)
TextPad
Notepad2
Sysinternals SuiteDisk
ClipPath
Daemon Tools
Password Agent
WordWeb
Texter - I need to post on this one. This is a niche utility that I don't use all that often, but very nice in certain common situations. It has its quirks though.

Backup and Recovery

Mozy – I use to have Mozy running on all of my machines, but since investing in a Windows Home Server – I only use Mozy at my office
Keep Vault – I use this to backup my entire Windows Home Server
Windows Live Mesh – Mesh runs on all of my machines. I use it to synch a few other things, but I primarily use it to keep my Password Agent password file in synch across all of my machines. This also backs up all of my files to the cloud and makes them web accessible.
Backup Magic – For simple Backup operations

Media and Entertainment

Development

Visual Studio 2005 Team Suite
Visual Studio 2008 Team Suite
ReSharper – Invaluable refactoring tool for Visual Studio
MbUnit
TestDriven.NET
CodeSmith - I barely use this one anymore, but it still makes the list
SQL Server 2008 Developer Edition
.NET Reflector
SnippetCompiler
TortoiseSVN
Subversion
VisualSVN
.NET Memory Profiler – It does everything you could ever want in the world of .NET memory profiling, for a small price tag… and the documentation kicks the shit out of Ants and dotTrace

Family Tech Support

When my family calls with a PC problem, I use CrossLoop (free and usually works) or Copilot (for the rare occasions when CrossLoop won’t connect)

Universal Drivers, Codecs, etc.

TechSmith Screen Capture Codec - commonly used on web screencasts

DOS and VBS Syntax Reminders

kellyb — Fri, 22 Aug 2008 04:00:00 GMT

From time to time I have to break out skills from my past. I needed to solve a few problems today that required a VBS script and a couple of batch scripts. It took me longer than I care to admit to remember how to do this.

So, this post is a reminder for my future self.

Here's how to set a local variable in DOS and use them, as well as how to use a system environment variable (WinDir):

   1: SET INTERNAL_ROOT_PATH=D:\foo\trunk

2:

   3: svn.exe update %INTERNAL_ROOT_PATH%

   4: %WinDir%\Microsoft.NET\Framework\v2.0.50727\msbuild.exe %INTERNAL_ROOT_PATH%\Internal.sln /Property:Config=Release

Here is how to load an XML file into XML DOM and parse it using MSXML2 and VBScript. This is also an example of how to Echo messages to the shell and process arguments

1:

   2:     path = WScript.Arguments(0)

   3:     root = WScript.Arguments(1)

4:

   5:     gacpath = "D:\Program Files\Microsoft Visual Studio 8\SDK\v2.0\Bin\gacutil.exe"

6:

   7:     If WScript.Arguments.Count = 3 Then

   8:         gacpath = WScript.Arguments(2)

   9:     End If

10:

  11:     WScript.Echo WScript.Arguments.Count

  12:     WScript.Echo "Parsing LibraryManifest: " & path

13:

  14:     Set xml = CreateObject("MSXML2.DOMDocument")

  15:     With xml

  16:         .async = False

  17:         .validateOnParse = False

  18:         .preserveWhiteSpace = True

  19:         .resolveExternals = False

  20:     End With

  21:     result = xml.load(path)

22:

  23:     Set moduleNodes = xml.selectNodes("//LibraryManifest/Module")

24:

  25:     If Not moduleNodes Is Nothing Then

26:

  27:         For Each moduleNode in moduleNodes

28:

  29:             Set assemblyNodes = moduleNode.selectNodes("Assembly")

30:

  31:             For Each assemblyNode in assemblyNodes

32:

  33:                 For Each attribute in assemblyNode.Attributes

34:

  35:                     If attribute.Name = "Name" Then

36:

  37:                         file = root & "\" & attribute.Text

38:

  39:                         'WScript.Echo "file: " & file

40:

  41:                         Set shell = CreateObject("WScript.Shell")

  42:                         gacutil = gacpath & " -uf " & attribute.Text

  43:                         Set out = shell.Exec(gacutil)

44:

  45:                         Do While Not out.StdOut.AtEndOfStream

  46:                             WScript.Echo out.StdOut.ReadLine()

  47:                         Loop

48:

  49:                         Set shell = CreateObject("WScript.Shell")

  50:                         gacutil = gacpath & " -if " & file

51:

  52:                         Set out = shell.Exec(gacutil)

53:

  54:                         Do While Not out.StdOut.AtEndOfStream

  55:                             WScript.Echo out.StdOut.ReadLine()

  56:                         Loop

57:

  58:                         Set shell = Nothing

  59:                         Set out = Nothing

60:

  61:                     End If

  62:                 Next

  63:             Next

  64:         Next

  65:     End If

66:

The Entity Framework team should talk to the MVC team

kellyb — Wed, 21 May 2008 04:00:00 GMT

Two product efforts at Microsoft have spun up this year and both are new implementations of very old ideas:

ASP.NET MVC Framework - Microsoft's upcoming implementation of a Model View Controller architecture for their web application platform. MVC has been around for a long time on other development platforms, but only recently has there been a push in the .NET community demanding for this.
ADO.NET Entity Framework - Microsoft's next rev of data access technology (ADO.NET) contains a lot of new ways to work with data. EF is their implementation of an Object-Relational Mapping framework. Again, OR Mapping has been around for a very long time on other development platforms such as Java, but only recently has there been a push in the .NET community asking for this.

My personal opinion is the recent increase in the popularity of Agile development methods has had a large part in driving out these products from Microsoft. Agile development tends to accentuates everything in a development ecosystem - the good and the bad. Agile teams using the .NET platform have been feeling a lot of pain in certain areas - namely, data access and web app development. Writing automated-test-friendly code using these parts of the framework has been a nightmare for me personally, and I know there's scores of people that feel the same way.

To be fair, there's a large part of the .NET community that just doesn't care about any of this. By and large, they don't care about Agile and they don't care about automated test friendliness and they think the current implementations of ASP.NET and ADO.NET are just fine. I'm not going to argue with any of that because those people are in the best position to know what's best for them. However, there are people out there that loudly crying for change, and I'm one of them (though most of my crying is done in my own head).

What's really interesting I think is to watch how the MVC team has went about this charge in comparison to the EF team. I pay a lot more attention to the MVC stuff just because I've been a long time reader of Scott Hanselman, Phil Haack, and Rob Conery (the 3 main guys Microsoft hired to make lead the MVC effort). If you read through these guy's blog's and the content they're producing to support this product, their "this is for a certain set of people with a certain set of concerns that doesn't apply to everyone and we want this product to delight those people" attitude is obvious, which is very refreshing. Scott posted some very cool video's of his talks on MVC at Mix this year. This refreshing attitude shines thoroughly repeatedly in these talks.

Dan Simmons from the Entity Framework team posted a break down of the data access technologies in ADO.NET and compares and contrasts them for different types of jobs. As expected, the Agile/TDD zealots are pounding on him (i.e. Jeremy Miller and the CodeBetter crew). The zealots don't like the EF team's model and they take every opportunity to remind them of that. The EF team seems view these folks and their viewpoints as a small subset of the community. They seem to be applying the 80/20 rule, and they seem to think that if only 20% of the community is pissed, then that's pretty good.

What I think Dan is missing here, unlike the MVC team, this 20% of people that are displeased with their model, is the majority of people that care about this stuff. The other 80% are the people that don't care about Agile and don't care about automated-test-friendliness. They are the people that are more than happy cranking out dataset based app after dataset based app. I would argue, they are the definitely NOT the people that are creating conceptual data models for reuse across their domain (the EF's big selling point). I think the EF team needs to watch the MVC team and start listening to the zealots. Those zealots are your customer.

My prediction:

ASP.NET MVC Framework: Huge Success
ADO.NET Entity Framework: Huge Failure

I would love to be wrong about #2. #1 seems to already be in the bag :)

Solving Real Problems with Access Modifiers 101

kellyb — Wed, 16 Apr 2008 04:00:00 GMT

Its refreshing when you solve what appears to be a nasty problem with a simple and clean solution. It's an even better feeling when you solve it with Computer Science fundamentals. I solved something this morning by releaning how acces modifiers work (access modifiers in C# in my case).

We have a basic data transfer object that has some private state that handles change tracking. Something such as:

public class ProductDTO
{
    private bool _isDirty = false;
    private string _name;
    
    public string Name
    {
        get { return _name; }
        set
        {
            if ( value != _name )
            {
                _name = value;
                _isDirty = true;
            }
        }
    }
}

This of course is a contrived example, but it illustrates the crux of my problem.

The _isDirty flag is managed internally and marked private as you'd expect. What I need to do is transfer state from one instance of ProductDTO to another. I need the public state as well as the private/internal state. Over the years I've been lulled into thinking of private members as things that cannot be accessed outside of an instance. This isn't true. Private members cannot be accessed outside of the class. In other words, two instances of the same class can happily access each other's private/internal members.

With this lesson relearned, I'm able to create a Copy() method such as:

public void Copy(ProductDTO copy)
{
    _name = copy.Name;
    _isDirty = copy._isDirty;
}

Note the get of the _isDirty from the copy instance.

I'd forgotten this how Access Modifiers work and from the majority of code I've seen in recent years, most developers out there have as well. You typically see numerous forms of encapsulation violation or leaky public contracts to accomplish something like this.

Microsoft IoC and Dependency Injection

kellyb — Thu, 10 Apr 2008 04:00:00 GMT

Microsoft's developer division has been making a lot interesting moves lately. They're starting to finally listen to the strong thoughts and opinions coming out of the Java converts in the .NET community and realizing they know what they're talking about. As usual, they're not really innovating, but they're taking existing ideas and building some great tooling around those ideas and delivering them to the masses.

In the March release of MSDN Magazine they published Loosen Up which is a general overview of the benefits of IoC and DI. Just last week Microsoft Pattern's and Practices group released Unity - their entry into the IoC and DI space. Inversion of Control Containers and the Dependency Injection pattern are not new ideas and with Castle Windsor, Spring.NET and StructureMap there are many seasoned IoC offerings out there already.

I've been a big fan for StructureMap for it's simplicity. From my initial experience with Unity, it has that same thinness and simplicity. Now that it's from Microsoft, hopefully the Morts will start to pay attention to some of these important design concepts.

David Hayden has a pretty great overview of Unity in screencast form here. Download it and play it in Windows Media Player at double the speed (a handy trick I picked up from Scott Hanselman)

Current Reading

kellyb — Sun, 03 Feb 2008 05:00:00 GMT

I haven't blogged in a long, long time. I'm not sure what got me off the horse exactly, but it's time to get back on.

Recently a past coworker from my Avanade days joined our team at CSG. It's great to have him aboard, but it was a blast from the past for me being around him in a workplace setting. I brought back a lot of memories of the consulting days. Comparing and constrasting current myself with my 18-months-ago self was a little shocking. I'm definitely much less of a Microsoft koolaide drinker and I'm certainly much less interested in the bleeding edge. I'm getting to the point in my career where I'm seeing the cyclical trends in technology and I'm catching myself choosing to sit out a wave or two here and there.

My focus for the last year has been building software in an Agile fashion. Said a different way, I'm 100% engrossed in how to build software that's easy to change. I've spent my entire career with my feet firmly planted in the Microsoft camp and I definitely am committed to my platform of choice, but I'm frequently disappointed with in the fundamental skills on our community. We're starting to see that most of the important thinking in the Microsoft space is being done by Java converts. I'm currently reading Agile Principles, Patterns, and Practices in C# by Robert Martin. It is a wonderful introduction to the art of building software that's easy to change. Sadly, much of the Microsoft .NET development community, as Martin points out in the foreword, is lacking in many of the core Object Oriented design fundamentals. Apparently he specifically wrote this C# specific revision to his classic Agile Principles, Patterns, and Practices book just to get the attention of the Microsoft camp.

Check it out - great stuff here for all ages

Introduction to Subversion

kellyb — Sun, 13 May 2007 04:00:00 GMT

Long ago I married myself to the Microsoft technology stack. For a long long, that meant you were a Visual Source Safe user. VSS's suckiness is well known and well documented. I've been happily using the free license for SourceGear Vault at home for the last 3 years and professionally I've been using whatever my clients had in place (VSS, Vault, or Team Foundation usually). When I came to CSG in late 2006, I was introduced to Subversion (SVN). I'd certainly read about SVN and knew it was a very popular open source source control system. While the adjustment period was a little rocky (mainly getting used to a merge based check-in approach around the team instead of exclusive checkouts).

Like almost everyone that's used it for any significant period of time, I'm a SVN lover. I've been using it at work for 6 months, but knew nothing about setting it up. This weekend I gutted out Vault, and stood up a SVN Server on my home network. For someone used to Microsoft products, you don't like installations filled with editing text files and commandlines. While it's not as polished as a MS install, the whole thing was relatively painless. Because my target host was a windows box, I was a bit worried about dipping my toes into Apache and all that comes with it. Well, let me say - all that *might* come with it. I'm used to IIS based servers and MS does a good job of hiding all of that from me on install. Thankfully, I didn't have to think about Apache once. Below are some posts that detail the installation process if you're interested in going down this path, but at a high level, this is what you need to do.

Download and run the SVN installer
Download and run the SVNService installer - handy Windows Service that wraps up SVN nicely in the Windows world.
Download and run TortoiseSVN install - this is the server client (one of many available)
- If you've never used anything but VSS before, this will be new to you. SVN is a file system based source control system. Each use has a copy of the source on their local file system. The source is freely change locally and at the time you check you, you merge the source into the "trunk"
- SVN has a commandline based interface for performing checkin's, but TortoiseSVN is Windows shell extension that gives you a GUI for performining checkins. It's bound to the windows shell and has icon overlays to notifying you when something's been changed (since the last GET from the server - called an SVN Update).
Created a default respository in SVN (see links below)
Configured SVNService
- TIP: By default SVNService tries to configure itself to listen as LOCALHOST. This will cause problem if you plan to access the server remotely from another machine. Make sure to configure SVNService as listening as the machine name hosting the SVN server.
- You'll see posts all over the net complaining about "No connection could be made because the target machine actively refused it" errors. I never found a good reply on any of the sites. Knowing a little bit about Windows Services and Windows TCP/IP, I knew what the problem was. Run the SVNService admin tool and make sure you're not listening as LOCALHOST.
Setup SVN security
- This is all text file based in the repository directory. Just be patient and read the comments at the top of the config files and you'll figure it out pretty quickly.
Install all TortoiseSVN on all the client you want to access your server with and checkout the repository using TortoiseSVN's repo browser - svn://your-server/your_repos
Setup remote access
- I wanted remote access outside of my network. SVN supports HTTP natively, but I've decided to use the SVN native protocol first and if it doesn't prove sufficient for my remote needs, I"ll get HTTP working, but for now, I seem good without HTTP
- I setup routing record on my main router to route all traffic on port 3690 to my SVN server.
- Now I can access my SVN server from TortoiseSVN from my office using svn://svn.kellybrownsberger.com/main/dev_repos. Very cool

Checkout these links for more detail - as usual with open source, get used to a lot of dead links and ugly hacker forum sites.

Setting up a Subversion Server under Windows

Installing SVN