Question

I have a habit of creating classes that tend to pass objects around to perform operations on them rather than assigning them to a member variable and having operations refer to the member variable. It feels much more procedural to me than OO.

Is this a terrible practice? If so, what are the adverse effects (performance, memory consumption, more error-prone)? Is it simply easier and more closely aligned to OO principles like encapsulation to favour member variables?

A contrived example of what I mean is below. I tend to do the following;

public class MyObj()
{

  public MyObj() {}

  public void DoVariousThings(OtherObj oo)
  {
    if (Validate(oo))
    {
       Save(oo);
    }
  }

  private bool Validate(OtherObj oo)
  {
    // Do stuff related to validation
  }

  private bool Save(OtherObj oo)
  {
     // Do stuff related to saving
  }

}

whereas I suspect I should be doing the following;

public class MyObj()
{

  private OtherObj _oo;

  public MyObj(OtherObj oo) 
  {
    _oo = oo;
  }

  public void DoVariousThings()
  {
    if (Validate())
    {
       Save();
    }
  }

  private bool Validate()
  {
    // Do stuff related to validation with _oo
  }

  private bool Save()
  {
     // Do stuff related to saving with _oo
  }
}

Answer 1

I think you already answered your question yourself, you seem to be aware of the fact that the 2nd approach is more favorable in general and should be used (unless there are serious reasons for the first approach).

Advantages that come to my mind immediately:

• Simplified readability and maintainability, both for you and for others
• Only one entry point, therefore only needing to checking for != null etc.

• In case you want to put that class under test, it’s way easier, i.e., getting something like this (extracting interface IOtherObj from OtherObj and working with that):

  public MyObj (IOtherObj oo)  
  {
      if (oo == null) throw...
      _oo = oo;
  }