How to determine if passing in an object is better than several parameters (int, string, etc) [closed]

Question

I have a class/object called "User" that has about a dozen properties (eg: UserGUID, UserName, etc.). It has a constructor, static methods, couple other helpers/support methods, etc.

The website has hundreds of functions/methods where 2+ parameters come from the User object. For example:

public string HelloWorld(Guid userGUID, Guid accountGUID, bool somethingElse)
{
    //Do something
}

I really want to pass in the User object itself to make the call cleaner and not have to keep adding parameters everytime I need a new value from the User object. Like this:

public string HelloWorld(User user)
{
    //Do something
    Guid userGUID = user.UserGUID;
}

So my question is, at what point is passing in the object good/bad vs passing in several parameters? Does it depend on the size of the object? How would I determine what's "too big" vs "OK"? Is it the number of parameters? How many params is too many?

Answer 1

You should think about what the method is supposed to do . Why does the method exist?

The semantic of the method will determine its arguments. So, for example, if HelloWord is supposed to print some stuff out, like a userId, and something else, then the signature should contain userId and something else as arguments.

On the other hand, if HelloWord is supposed to print out some information about a User, then the method signature should have the object User as a parameter.

It all depends on the method semantic.

Answer 2

In Clean Code, Robert Martin says to prefer 0 arguments, 1 or 2 arguments are acceptable and 3 is too many.

In my opinion as long as you're in the same process I think passing the object is preferable to passing arguments. You wouldn't want to send (or receive) more than is needed to another process (say a web service).

I highly recommend Clean Code, it's a good read and has a lot to say about structure.