FileInfo[] f = new FileInfo[files.Count];
files.Values.CopyTo(f,0);
return f;

return files.Values.ToArray();

      FileInfoData[] remoteFileData = new FileInfoData[]
      {
        new FileInfoData(),
        new FileInfoData(),
        new FileInfoData()
      };
      remoteFileData[0].name = "test1.mpg";
      remoteFileData[1].name = "test2.mpg";
      remoteFileData[2].name = "test10.mpg";
      FileInfo[] remoteFiles = new FileInfo[]
      {
        new FileInfo(remoteFileData[0]),
        new FileInfo(remoteFileData[1]),
        new FileInfo(remoteFileData[2]),
      };

      FileInfo[] remoteFiles = new FileInfo[]
      {
        new FileInfo(new FileInfoData()
        {
          Name = "test1.mpg"
        }),
        new FileInfo(new FileInfoData()
        {
          Name = "test2.mpg"
        }),
        new FileInfo(new FileInfoData()
        {
          Name = "test10.mpg"
        }),
      };

  public delegate ILocalFileSystemManager LocalCreateDelegate(string localPath, string extension);

  public class FileSystemManagerFactory
  {
    public FileSystemManagerFactory( LocalCreateDelegate localFactory )
    {
      this.localFactory = localFactory;
    }
  }

FileSystemManagerFactory factory = new FileSystemManagerFactory(
  delegate(string localPath, string extension)
  {
    return new MockLocalFileSystemManager(localPath, extension);
  });

  public FileSystemManagerFactory( Func<string,string,ILocalFileSystemManager> localFactory )
  {
    this.localFactory = localFactory;
  }

FileSystemManagerFactory factory = new FileSystemManagerFactory(
  (localPath, extension)
  =>
  return new MockLocalFileSystemManager(localPath, extension);
  );

string readwriteMember;
string readonlyMember;

public string ReadWrite
{
  get { return readwriteMember; }
  set { readwriteMember = value; }
}

public string ReadOnly { get { return readonlyMember; }

public string ReadWrite { get; set; }

public string ReadOnly { get; private set; }

// Instead of this:
private void Find(INode node, List<INode> resultSet, FindDelegate findDelegate);
// called like this for a Name search:
Find(this, resultSet, delegate(INode node) { return node.Name == name; });

// I can use this:
private void Find(INode node, List<INode> resultSet, Func<INode, bool> f)
// called like this:
Find(this, resultSet, node => node.Name == name);

Thus giving me the following implementation for ISearchableNode:

public INode FindByName(string name)
{
  List<INode> resultSet = new List<INode>();
  Find(this, resultSet, x => x.Name == name);
  return resultSet.FirstOrDefault();
}

public IEnumerable<INode> FindByType(string type)
{
  List<INode> resultSet = new List<INode>();
  Find(this, resultSet, x => x.Type == type);
  return (IEnumerable<INode>)resultSet;
}

private void Find(INode node, List<INode> resultSet, Func<INode, bool> f)
{
  if (f(node))
  {
    resultSet.Add(node);
  }
  foreach (INode child in node.Children)
  {
    Find(child, resultSet, f);
  }
}

Problem solved, move on… Well, except there is significant room for improvement. Here are the two main issues that ought to be resolved:

1. Syntax is limited to two types of searches and exposing the generic find makes for an ugly syntax. It would be much nicer if queries to the tree could be expressed in LINQ syntax.
2. It’s also inefficient for the Name search, since I’m walking the entire tree, even if the first node matched the criteria.

LINQ to Hierarchical Data

In order to use LINQ to objects, I need to either create a custom query provider or implement IEnumerable. The latter is significantly simpler and could be expressed using the following interface:

public interface IQueryableNode : IEnumerable<INode> { }

Ok, ok, I don’t even need an interface, I could just implement IEnumerable<INode>… But what does that actually mean? In the simplest sense, I’m iterating over the node’s children, however, I also with do descend into the children’s children and so on. So a simple foreach won’t do. I could just do the same tree walking with a resultset as I did above and return the Enumerator of the resulting list to implement the interface, but C# 2.0 introduced a much more useful way to implement non-linear Iterators, i.e. the yield keyword. Instead of building a list to be interated over, yield let’s the iterating code return values as they are found, which means it can be used for recursive iteration. Thus the GetEnumerator is implemented simply as follows

#region IEnumerable<Node> Members
public IEnumerator<INode> GetEnumerator()
{
  yield return this;
  foreach (Node child in Children)
  {
    foreach (Node subchild in child)
    {
      yield return subchild;
    }
  }
}
#endregion

#region IEnumerable Members
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
{
  return this.GetEnumerator();
}
#endregion

Nice and simple and ready for LINQ.

Searching for all Nodes of a type becomes

var allBar = from n in x
                where n.Type == "bar"
                select n;
foreach (Node n in allBar)
{
  // do something with that node
}

and the search for a specifically named node becomes

INode node = (from n in x
              where n.Name == "i"
              select n).FirstOrDefault();

But the real benefit of this approach is that I don’t have hard-coded search methods, but can express much more complex queries in a very natural syntax without any extra code on the Node.

Deferred execution

As it turns out, using yield for the recursive iteration also solved the second issue. As yield returns values as it encounters them during iteration, the search doesn’t happen until the query is executed. And one of the side effects of LINQ syntax is that creating a query does not execute it until the result set is iterated over. Therefore, FirstOrDefault() actually short-circuits the query as soon as the first match (and in case of Name, it’s going to be the only match) is hit.