Question

Let’s say I have some classes defined as follows:

class Security
{
    Boolean AuthenticateUser(String username, String password);
    Boolean AddUser(String username, String password);
    // many more methods
}

class NetworkedDevice
{
    void Stop();
    void Start();
    // many more methods
}

Then I have another class that contains instances of the above classes. How can I avoid code like the following? I want all the methods of class1 and class2 exposed via this class.

class MyWindowsService
{
     Security _security = new Security();
     NetworkDevice _netDevice = new NetworkDevice();

     Boolean AuthenticateUser(String username, String password)
     {
          return _security.AuthenticateUser(username, password);
     }
     // all the rest of "Security" methods implemented here

     void StopNetworkDevice()
     {
          _netDevice.Stop();
     }

     void StartNetorkDevice()
     {
          _netDevice.Start();
     }
     // all the rest of "NetDevice" methods implemented here
}

Edit
I’ve updated the code to be more real to what I am doing. I am hosting a WCF service within a windows service. The windows service does several things including user authentication and communication to networked devices to name a few. The implementation of my WCF interface calls methods of the “MyWindowsService” class. Exposing the underlying objects as properties is the answer I was looking for. The above class then looks something like:

class MyWindowsService
{
     SecurityClass _security = new SecurityClass();
     NetworkDevice _netDevice = new NetworkDevice();

     Public NetworkDevice NetDevice
     {
          get { return _netDevice; }
     }

     Public SecurityClass Security
     {
          get { return _security; }
     } 
}

Answer 1

Well, if you’re using composition (as you are) there is no "easier way"; you just have to wrap the methods you want to expose. If you want to expose all of the methods of the composed type, then why are you using composition in the first place? You may as well just expose SecurityClass and NetworkDevice via public properties as it is functionally no different than wrapping every method and property/public field.

If it makes sense that they belong in the inheritance chain then SuperClass (oddly named as it would be a sub class…) should inherit from one of those classes. Of course you can’t inherit from both in C#, but this design makes me suspect that there may be a better overall approach. It is impossible to tell from your code sample though as you don’t tell us what you are actually trying to accomplish with these types.