The only sensible way to do what you're wanting to do is to create a proxy type which sites between both Document and Node. This is what we do with Snapshot, we've got an interface which is a proxy to either Umbraco content or Snapshot content.

We've also got a class which is a proxy to those interfaces which can be used in your system (confusing yes I know).

But essentially you create an interface which represents the data you want, then have it implemented for the different underlying data structures (either Node or Document).

Then you need to have a factory which is what you go through to get the objects you require. The factory should also be an interface (or an abstract class) so you can swap it out either at run time or on application start.

You then end up with stuff like this:

public interface IContentFactory {
    IEnumerable<IContent> GetContent();
}

public interface IContent {
    int Id { get; set; }
    string NodeName { get; set; }
    //and so on
}

internal class NodeContent : IContent {
    public NodeContent(nodeFactory.Node source) {
      // set data
    }
}

internal class DocumentContent : IContent {
    public DocumentContent(Document source) {
      //set data
    }
}

public IEnumerable<IContent> SomeMethod(IContentFactory factory) {
  return factory.GetContent();
}

What you're trying to do is not exactly something for the faint hearted, you're going to have to use either a DI framework or have some other way of handling factories within your application scope.

Ahh sounds like I may try avoid the whole thing for the moment. :-) But If the performace becaomes an issue I may be comming back to this.

Thanks for your input.

is working on a reply...