Design class chaining

I have a third party C# library for ldap operations. It does all operations on connection object as below:

LdapConnection connection = new LdapConnetion(Settings settings);
connection.Search(searchOU, filter,...);

which I feel is not readable. I want to write a wrapper around it so that I should be able to write code like below:

As I would like to have different Ldap classes like

public class AD: LdapServer { }
public class OpenLdap: LdapServer { }

and then

AD myldap = new AD(Settings settings);
myldap.Users.Search(searchOU, filter,...)
myldap.Users.Add(sear开发者_StackOverflow中文版chOU, filter,...)
myldap.Users.Delete(searchOU, filter,...)

I am thinking about Proxy design pattern, but things are not getting into my head about hot to go about it. What classes should I have etc.

Any help?

The solution posted above inherits from the LdapConnection. This is good if you want to maintain the inheritance chain, but I dont think that is necessary in your case. You simply want to customize and simplify the interface.

The proxy design pattern inherits from the underlying object so that the proxy object can be used anywhere that the underlying object is required, this is good if you want to "inject" extra functionality into the class without the clients of that class realising. I dont think this is your intention here?

The big problem with the solution posted above is that (because it inherits directly from LdapConnection) you can call search in two ways like so:

Settings settings = new Settings();
AD myAD = new AD(settings);

object results = myAD.Users.Search();
// OR
object results2 = myAD.Search();

As I'm sure you can see from the code, both of these call the exact same underlying method. But in my opinion, this is even more confusing to developers than just using the vanilla LdapConnection object. I would always be thinking "whats the difference between these seemingly identical methods??" Even worse, if you add some custom code inside the UsersWrapper Search method, you cannot always guarentee that it will be called. The possibility will always exist for a developer to call Search directly without going through the UsersWrapper.

Fowler in his book PoEAA defines a pattern called Gateway. This is a way to simplify and customize the interface to an external system or library.

public class AD
{
    private LdapConnection ldapConn;
    private UsersWrapper users;

    public AD()
    {
        this.ldapConn = new LdapConnection(new Settings(/* configure settings here*/));
        this.users = new UsersWrapper(this.ldapConn);
    }

    public UsersWrapper Users
    {
        get
        {
            return this.users;
        }
    }

    public class UsersWrapper
    {
        private LdapConnection ldapConn;

        public UsersWrapper(LdapConnection ldapConn)
        {
            this.ldapConn = ldapConn;
        }

        public object Search()
        {
            return this.ldapConn.Search();
        }

        public void Add(object something)
        {
            this.ldapConn.Add(something);
        }

        public void Delete(object something)
        {
            this.ldapConn.Delete(something);
        }
    }
}

This can then be used like so:

AD myAD = new AD();
object results = myAD.Users.Search();

Here you can see that the LdapConnection object is completly encapsulated inside the class and there is only one way to call each method. Even better, the setting up of the LdapConnection is also completely encapsulated. The code using this class doesn't have to worry about how to set it up. The settings are only defined in one place (in this class, instead of spread throughout your application).

The only disadvantage is that you loose the inheritance chain back to LdapConnection, but I dont think this is necessary in your case.

Ok, if you simply want to split the methods up into they objects that they act on (i.e. in your example add the .Users. before the method call) you can do something similar to this.. You'll need to get the method parameters and return types correct for your library, I've just used object here.

Is this the sort of thing you're looking for?

public class AD : LdapConnection
{
    private UsersWrapper users;

    public AD(Settings settings) : base(settings)
    {
        this.users = new UsersWrapper(this);
    }

    public UsersWrapper Users
    {
        get
        {
            return this.users;
        }
    }

    public class UsersWrapper
    {
        private AD parent;

        public UsersWrapper(AD parent)
        {
            this.parent = parent;
        }

        public object Search()
        {
            return this.parent.Search();
        }

        public void Add(object something)
        {
            this.parent.Add(something);
        }

        public void Delete(object something)
        {
            this.parent.Delete(something);
        }
    }
}

This can then be be used as follows:

Settings settings = new Settings();
AD myAD = new AD(settings);

object results = myAD.Users.Search();

Remember that this isn't strictly a "wrapper" because it actually inherits from the underlying class.