I'm trying to mock up a data access library for Neo4J in .NET 4.5. I am using interfaces to define each command to the database.

Given:

```
    public interface IBaseRequest 
    {
        HttpMethod HttpMethod { get; }    
        string QueryUriSegment { get; }    
    }

    public interface ICreateNode  : IBaseRequest
    {
        void CreateNode();

    }

    public interface IBaseNodeActions  : ICreateNode,ICreateNodeWProperties //...And many others, all inherit from IBaseRequest
    {
    }

    internal class TestImplClass : IBaseNodeActions {

        public TestImplClass() {

        }
        void ICreateNode.CreateNode() {
            throw new NotImplementedException();
        }
        //Only one copy of the HttpMethod and QueryUriSegment are able to be implemented
        DataCommands.HttpHelper.HttpMethod IBaseRequest.HttpMethod {
            get {
                throw new NotImplementedException();
            }
        }

        string IBaseRequest.QueryUriSegment {
            get {
                throw new NotImplementedException();
            }
        }

```

Problem is for each interface that inherits from IBaseRequest, I need a property implemented for each property that it's parent owns (HttpMethod, QueryUriSegment). 

Is this possible? I know that using explicit implementation will be necessary but not sure how to push those into the implementing class.

Here is what I'd like to see in my implementing class:

```
public class TestImplClass : IBaseNodeActions{
public TestImplClass() {

        }
        void ICreateNode.CreateNode() {
            throw new NotImplementedException();
        }

        HttpMethod ICreateNode.HttpMethod {
            get {
                throw new NotImplementedException();
            }
        }

        string ICreateNode.QueryUriSegment {
            get {
                throw new NotImplementedException();
            }
        }
        HttpMethod ICreateNodeWProperties.HttpMethod {
            get {
                throw new NotImplementedException();
            }
        }

        string ICreateNodeWProperties.QueryUriSegment {
            get {
                throw new NotImplementedException();
            }
        }
}

```

Notice the ICreateNode and ICreateNodeWProperties instead of the IBaseRequest. I'm open to doing it differently but it seems like a modular, testable approach.

I hope that makes sense!