Grouping conceptual algorithms into one class or associate with their object models

Question

If I have a number of classes, lets say a variety of buildings of some sort. Each of these buildings have various properties and do some stuff etc

Now there is a set of operations I need to do on these buildings that are all conceptually the same. Lets call this conceptual group of operations Move building effluent. This functionality is essentially responsible for performing methods based on the information of each Building and then setting properties in other areas of the code as well as setting information on the building itself (can't help the need to set properties in other areas at the moment due to current system design limitations).

It's important to note that although these methods are conceptually the same and they set many of the same properties in various classes the way they calculate and get to these values are different (they do share some code however).

My question is should I put the code to do this into one class called say EffluentBuildingDistribution or should I put it into each buildings own class with appropriate methods to perform essentially the same code.

So either something like:

public class EffluentBuildingDistribution 
{
    public void DistributeEffluent()
    {
       // parameters example only
       DistributeBuildingHouse(var param1, var param2);
       DistributeBuildingDogHouse(var param1, var param2);
       DistributeBuildingSecondHouse(var param1, var param2);
    }

    // and various private methods to help work with the 3 methods some shared
    // others not    
}

or

public class HouseBuilding    {
   public void DistributeEffluent(var param1, var param2)
   {
      // do stuff
   }
}

public class DogHouseBuilding    {
   public void DistributeEffluent(var param1, var param2)
   {
      // do stuff
   }
}

Or perhaps neither of these options!.

I'm not sure if putting the code on the objects they are working on is the way to go, or putting it in a class that represents conceptually what we are trying to do. This is an example of my current dilemma however it's also a general responsibility question on where to proportion methods and actions etc

If it's not specific enough or needs more explanation etc let me know and I'll try to explain more of my issue.

EDIT: Due to some understandable confusion with my usage of the term Structure in my example, I since changed it to Building. Some of the answers below refer to Structure but they are still valid as I have not changed the core of the question.

Answer 1

What about trying to make a generic version of it?

public class DistributeEffluent<T>
{
      public void DistributeEffluent()
      {
          // a generic algo working on T=HouseStructure as well as on T=DogHouseStructure... 
      }
}

How this has to look exactly depends on the programming language you are using (which you forgot to mention, I guess C# or Java?). You can realize this also by using template method pattern, which is essentially the same approach without generics. The thing you have to add here is a common interface or a common base class for your structure classes, so DistributeEffluent can work with this interface. In this in interface, there should be elementary methods implementing the individual behaviour of each structure, but nothing more.

Answer 2

I don't think I've ever said this before, but this looks like a prime candidate for the Visitor pattern.

the visitor design pattern is a way of separating an algorithm from an object structure on which it operates

In essence, the visitor pattern allows you to define the structure of the objects within the objects themselves (in an accept method), while allowing you to put all of your algorithms in the Visitor class (in a set of visit methods, which can then share code through private methods).

public class StructureVisitor
{
    public void visit (StructureHouse structure)
    {
        // do stuff to house here
    }

    public void visit (StructureDogHouse structure)
    {
        // do stuff to dog house here
    }

    public void visit (StructureSecondHouse structure)
    {
         // do stuff to second house here
    }
}

And then you have some parent class that has an accept method a bit like this:

public void accept (StructureVisitor visitor)
{
    this.House.accept(visitor);
    this.DogHouse.accept(visitor);
    this.SecondHouse.accept(visitor);
}

Each of the above accept methods would simply pass themselves on to the visitor class (unless there was more depth to the structure, obviously).

public void accept (StructureVisitor visitor)
{
    visitor.visit(this);
}

Answer 3

I would probably create a DistributeEffluent interface and one or more implementations of it. Then, I would create a member of the interface in the structure classes to be able to use the operations.

Take a look at the Wikipedia article on Strategy Patterns.