CODEWITHSUNDEEP
c#
Lea Cohen
Lea Cohen

Reputation: 8200

Global member vs. passing parameters

I have a ASP.NET project, in which I have a method with 10 local variables. This method calls about 10 other methods. 3 of the called methods need all the variables. Is it considered good practice to turn all those variables into global members, and then they don't have to passed as parameters?

Upvotes: 3

Views: 2192

Answers (7)

Bryan Watts
Bryan Watts

Reputation: 45465

For a purely mechanical refactoring, packaging the values together (as suggested) is probably the best solution.

However, you have a large series of dependent methods, each of which acts on common state (at least 10 values). It sounds like you should design a class to handle this operation.

The class would encapsulate the behavior and relevant state, rather than be a simple property bag (see Anemic Domain Model).

Upvotes: 1

Brian Rudolph
Brian Rudolph

Reputation: 6318

Just be sure to be conscious about boxing. If you are passing 10 ref types around, it comes down to personal preference.

However, if you are passing 10 value types, if you were to declare them as member variables within a class, they will be boxed, then they will have to be unboxed by the recipient.

If you leave them confined as local variables within the method stack(passing as parameters), they will remain purely on the stack, rather than being boxed to the heap.

Upvotes: 1

Marc Gravell
Marc Gravell

Reputation: 1063338

If you want to pass complex state around, package it in an object - i.e.

public class Foo {
     public string Key {get;set;}
     public decimal Quantity {get;set;}
     // etc
}

And have the methods accept this object as an argument. Then you just create an instance of this and pass it along.

Global is a big no-no; ASP.NET is highly threaded - this would be a nightmare. Per-request state is possible, but a bit messy.

Upvotes: 8

Samiksha
Samiksha

Reputation: 6182

create a structure instead and pass the structure instead of passing those 10 parameters

Eg : 

public struct user 
{ 
    public string FirstName; 
    public string LastName; 
    public string zilionotherproperties; 
    public bool SearchByLastNameOnly; 
    public datetime date1;
}

Upvotes: 3

Joseph Ferris
Joseph Ferris

Reputation: 12705

If you have methods that truly do act upon a large number of variables, such as you mention, you can also consider designing a class that has the purpose of acting as a data container. Once populated, you can then pass the class to the functions that require the data instead of ten parameters.

I can not remember the exact example offhand, but in Microsoft's "Framework Design Guidelines" book, they explicitly describe a scenario like your as well as how they have followed the same approach in the .NET Framework.

Also, if you have the need to pass that many parameters, take a step back and make sure that the code in question does not need to be refactored. There are legitimate cases where a lot of data is needed by a method, but I use long method signatures as a sign that I need to look inside the method to make sure it is doing only what it needs to.

Upvotes: 2

Jon Skeet
Jon Skeet

Reputation: 1502036

Do these variables relate to each other, either all of them or perhaps into a few groups? If so, encapsulate them into a type. So you might have half of your variables relating to a user, and half relating to a requested operation - and suddenly your method taking 10 variables only takes 2.

Making things global is almost always the wrong way to go.

Upvotes: 4

Lasse V. Karlsen
Lasse V. Karlsen

Reputation: 391456

Well, it depends entirely on what you mean by "global members".

If, considering you're writing an ASP.NET application, you mean session/application-based cache values, then it depends. There's performance implications so you should measure to see if it has any impact on your app.

If you mean static variables, then no. Static is per application, and will thus be for all users of your web application, not just one person. Thread static is not a good idea either as a single user may float between threads during his lifetime in the application.

Upvotes: 2

Related Questions