Cast your mind back...

If you recall (maybe you don't) there was some discussion a while
back about Codplex, TFS and the fact that it's a bit of a wash for creating an collaborative environment for an open source project... why?  Well because of the chasm between developers for the project and those users who wish to collaborate by providing small patches, or working on the bleeding edge (i.e. checking out changes since the last time they build your project from source)

Just to recap the big problems were:

• No support for patches
• No anonymous check-outs
• No easy way to diff/merge between your version and the latest version on source control (because you could only get the source as a tarball).

In particular I remember Ayendes posts on the subject, which sparked a bit of debate on the whole issue (and even got some feedback from the codeplex developers themselves...)

• Codeplex WTF
• Team Foundation Scalability ??? And why CodePlex exists?
• Adding SVN functionality to CodePlex

Codeplex's new command line client

Well it looks like one small step has been taken this week, check out this
entry on the codeplex blog ... There is now a .Net 2.0 command-line client being developed, which will include support for:

• Anonymous checkouts (hurray! dragging down a tar ball every time there were changes... what an arse that is/was)
• Merging
• Patching

I got all excited (well as excited as you can be about a command line client for TFS) and grabbed the beta... really all I cared about was anonymous checkouts... I like my open source medium rare (mmm... nothing like a fresh check-out of castle... release candidates
never have any of the fun stuff!)

But my hopes were dashed - it appears there's no way to skip the authorisation check as far as I can see, and when supplying my own credentials I didn't have access:

c:devtoolscodeplex_client>

cpc co reflectoraddins:/ c:devresourcesreflector

_addins

Username [sndanonymous_cp]: bittercoder

Password for bittercoder: ********

error: TF50309: You do not have sufficient permissions to perform
this operation

. ---> Attempted to perform an unauthorized operation.

I guess there's a little more waiting to go yet...

Still, not to get too disheartended I decided to try it on a project I coordinate for (ye olde Splicer...) and I can certainly confirm it works... considering that the command line tools are less than 200K, this is already a great improvement over the current situtation... (about 250mb to download Team Explorer's iso).

c:devtoolscodeplex_client>

cpc co splicer:/ c:devhomesplicer_copy

A    c:devhomesplicer_copy

A    c:devhomesplicer_copysrc

A    c:devhomesplicer_copysrcASL - Apache
Software Foundation License.txt

.... and so on ;o)

So as you can see ... it does work... but I have to say it's pretty damn slow (could just be because I'm in New Zealand of course).

At any rate... I'll be keeping my eye on it... there may be hope for codeplex yet ;o)

... and on one last note... the gui check-in looks a little like TortoiseSVN don't you think...  hopefully the work towards some feature parity there.

I've got a little project on at the moment which I chose to use ActiveRecord for... this is for a "legacy" database where there are existing nightly data warehousing scripts written against it... The cost of changing the database structure and tables is potentially quite high (it has run on effects to other systems, potentially effects SLA's when the nightly scripts fail.. and a small project ends up having a big impact)



At any rate, I'm just consuming the existing database as-is... which includes a single character status columns i.e. "A" for active, "P" for pending etc... after poking round with a few solutions I ended up creating an NHibernate custom type... first off, this was surprisingly easy... but it annoyed me a little that I had to create a different custom type for each set of enumerated values, and that this information was no longer declarative, compared to the rest of the ActiveRecord implementation...

So I took a few minutes to re-write it as generic solution to the problem today... which at least solves the declarative problem... first off, here's a property with the custom type applied - nothing amazing here, but notice the type is generic... with the type of status field itself qualifying the generic custom type...

[Property("dBlrStatus", "App.Model.MappedEnumerationHibernateType`1[[App.Model.Status, App.Model]], App.Model")]

public virtual Status Status  {

    get { return _status; }

    set { _status = value; }

}

We then declare the mappings on the enumeration itself...

public enum Status

{

    [MapToCharacters('A', 'a', '+')]

    Active,

    [MapToCharacters('I', 'i', '-')]

    [Default]

    InActive

}

I think this is a good fit for ActiveRecord... If anyone wants the code at some point just leave a comment and I'll package it up and post it... it's pretty elementary stuff, though it might save some time if you wanted to re-implement it yourself...

Well as the more observant reader of Alex Jame's Blogmight have noticed, I'm talking at the the Architect Camp 2007 this year... which should be...interesting - I haven't done any public speaking for a while now, but Alex James assures me I'll be fine ... be it on his head! ;o) ...

So I'm planning to talk about IoC (Inversion of Control) - one of my little pet loves... Some of the subjects I'm considering include:

• Coupling
  • How do we couple (Message, data, content etc.)
  • Metrics for the architect (Instability vs. Abstractness etc.)
  
  
  
  
• Dependency Injection
  • Constructor dependencies
  • Parameter dependencies
  • Law of Demeter
  
  
  
  
• Inversion of Control
  • Why bother?
    • Added flexibility and opportunity
    • Lowering the cost of change
    
    
    
    
  • ServiceLocators
    • Why they suck
    
    
    
    
  • Inversion of control containers
    • What's available (Castle, Spring, StructureMap etc.)
    • Autowiring
    • Services
    • Lifestyle vs Lifecycle
    • Configuration
    • AOP
    • Patterns
      • Decorators
      • Facilities
      • Arrays (simple contributor patterns etc.)
      
      
      
      
    
    
    
    
  
  
  
  

But that's only a small brain dump... we will see what actually gets in there.

For anyone who's thinking of attending this event, anything in particular you would like to have covered in a little more depth... or have you had any exposure to IoC at all?

Well first off... where has this month gone??... it's been 2 weeks since I last blogged... I thought it was only a week!

At any rate, one of the things I've been working on lately is mocking out COM interfaces (using RhinoMocks of course) ... and I have to admit that my eyes start crossing after a while, at about the point where the mock repositories setup code begins dominating the test case... which happens all too often... here's a smaller example of what I'm talking about:

MockRepository repository = new MockRepository();
TaggedValue oneTaggedValue = repository.DynamicMock();

Expect.Call(oneTaggedValue.Value = "").Constraints(Is.Equal("ExpectedValue"));

Expect.Call(textAlignTaggedValue.Update()).Return(true);
TaggedValue anotherTaggedValue = repository.DynamicMock();

Expect.Call(anotherTaggedValue.Value = "").Constraints(Is.Equal("AnotherExpectedValue"));

Expect.Call(textAlignTaggedValue.Update()).Return(true);
Collection taggedValuesCollection = repository.DynamicMock();
Expect.Call(taggedValuesCollection.GetByName("")).Constraints(Is.Equal("OneTaggedValue"))

    .Return(oneTaggedValue).Repeat.Any();
Expect.Call(taggedValuesCollection.GetByName("")).Constraints(Is.Equal("AnotherTaggedValue"))

    .Return(anotherTaggedValue).Repeat.Any();
Element destinationElement = repository.DynamicMock();

Expect.Call(destinationElement.TaggedValues).Return(taggedValuesCollection).Repeat.Any();
repository.ReplayAll();

So in this case we have an "Element", which has a collection of "TaggedValues", and we have two tagged values "OneTaggedValue" and "AnotherTaggedValue", and for each we are updating their values, and then invoking "Update()" on them to flush the changes...

To help solidify that, here's an example of what we're expecting to happen to our element (Element, Collection and TaggedValue are all interfaces from a COM interop assembly, in case you were wondering):

    Element element;
    ...
    TaggedValue oneTaggedValue = (TaggedValue)element.TaggedValues.GetByName("OneTaggedValue");

    oneTaggedValue.Value = "ExpectedValue";

    oneTaggedValue.Update();

    TaggedValue anotherTaggedValue = (TaggedValue)element.TaggedValues.GetByName("AnotherTaggedValue");

    anotherTaggedValue.Value = "AnotherExpectedValue";

    anotherTaggedValue.Update();

Now normally in this case I take unit tests once I've got "green" and refactor the mocking code out a bit... so in the above case I'd probably end up with something like:

MockRepository repository = new MockRepository();
Collection taggedValuesCollection = repository.DynamicMock();

AddTaggedValueSetter(repository, taggedValuesCollection, "OneTaggedValue", "ExpectedValue");

AddTaggedValueSetter(repository, taggedValuesCollection, "AnotherTaggedValue", "AnotherExpectedValue");
Element destinationElement = repository.DynamicMock();

Expect.Call(destinationElement.TaggedValues).Return(taggedValuesCollection).Repeat.Any();
repository.ReplayAll();

Which works... generally quite well... but lately I've been moving away from that approach and instead have been refactoring the setup code into a fluent interface... which I've found to be a lot easier to maintain and extend (and tends to be a little more re-usable across multiple test fixtures...) So for example, this is what the setup code for the above mock element is now:

MockRepository repository = new MockRepository();
Element element =

    Mock

    .Element()

    .HasTaggedValue("OneTaggedValue").ExpectSetValue("ExpectedValue")

    .HasTaggedValue("AnotherTaggedValue").ExpectSetValue("AnotherExpectedValue")

    .Complete(repository);
repository.ReplayAll();

I'm just skimming the surface of what I've been doing, but it might be food for thought for anyone working on similar projects... anyone else doing similar things?

Have you ever wanted to be able to do something like this in
C#?



string propertyName = GetName(MyClass.MyProperty);



Well I have, in fact I've wanted the ability to do this since
Version 1 of the .Net Framework, and now with C# 3.0 we finally
can!



First off, check out the original blog post here -
Symbols in C# 3.0 by Jafar Husain - it's a
clever (and once I thought about, plainly obvious) use of extension
methods and expression trees.

public static class SymbolExtensions

{

    public static string GetPropertySymbol(this T obj, Expression<>> expr)

    {

        return ((System.Linq.Expressions.MemberExpression)           (((System.Linq.Expressions.LambdaExpression)(expr)).Body)).Member.Name;

    }

}

Usage requires a lambda, but that's not to painful, here's example
usage:

MyClass o;

//...

string propertyName = this.GetPropertySymbol(o => o.MyProperty)

The beauty of this is that refactoring is entirely painless, you
don't need to spend time reviewing all the optional string
replacements that resharper may have found in case you haven't
mirrored a property or method name change correctly... it also
looks like it could offer some nice usability improvements to some
unit testing scenarios (nothing worse then unit tests that don't
seamlessly refactor with your code).



I wonder what other ideas are floating around for expression trees
at the moment (outside of the obvious querying concepts) ?