CODEWITHSUNDEEP
c#javamethodsinstance-variables
Pranav Shah
Pranav Shah

Reputation: 3323

Usage of Instance Variable within the class for Java/C#

Assume that 2 different methods - one static and one non-static - need an instance variable.

The variable is used 3-5 different times within the methods for comparison purposes.

The variable is NOT changed in any manner.

Also would the type of variable - String, Colection, Collection, etc. make any difference on how it should be coded.

What is the best/right way of using Instance Variable within a private method (static and non-static)?

  1. Pass as method argument
  2. Store locally by using the method to get the value - this.getClaimPropertyVertices();
  3. Store locally by getting the value - this.claimPropertyVertices;
  4. Use the instance variable directly in the method

When creating a local variable to store the value will the "final" keyword provide any advantages, if the variable will not be changed.

Edit 1: Based on a comment, I am adding additional information The value cannot be created locally in the method. It has to come from the class or some other method accessed by the class.

My Solution Based on the Answers:
Based on the answer by @EricJ. and @Jodrell. I went with option 1 and also created it as a private static method. I also found some details here to support this.

Upvotes: 0

Views: 671

Answers (2)

Jodrell
Jodrell

Reputation: 35696

If you write your functions with the static keyword whenever you can, there are several obvious benefits.

  1. Its obvious what inputs effect the function from the signature.

  2. You know that the function will have no side effects (unless you are passing by reference). This overlooks non-functional side effects, like changes to the GUI.

  3. The function is not programtically tied to the class, if you decide that logically its behaviour has a better association with another entity, you can just move it. Then adjust any namespace references.

These benefits make the function easy to understand and simpler to reuse. They will also make it simpler to use the function in a Multi Threaded context, you don't have to worry about contention on ever spreading side effects.

I will cavet this answer. You should write potentially resuable functions with the static keyword. Simple or obviously non-resulable functionality should just access the private member or getter, if implemented.

Upvotes: 2

Eric J.
Eric J.

Reputation: 150108

When creating a local variable to store the value will the "final" keyword provide any advantages, if the variable will not be changed

In Java, final provides an optimization opportunity to the compiler. It states that the contents of the variable will not be changed. The keyword readonly provides a similar role in C#.

Whether or not that additional opportunity for optimization is meaningful depends on the specific problem. In many cases, the cost of other portions of the algorithm will be vastly larger than optimizations that the compiler is able to make due to final or readonly.

Use of those keywords has another benefit. They create a contract that the value will not change, which helps future maintainers of the code understand that they should not change the value (indeed, the compiler will not let them).

What is the best/right way of using Instance Variable within a private method (static and non-static)?

Pass as method argument

The value is already stored in the instance. Why pass it? Best case is this is not better than using the instance property/field. Worst case the JITer not inline the call, and will create a larger stack frame costing a few CPU cycles. Note: if you are calling a static method, then you must pass the variable as the static method cannot access the object instance.

Store locally by using the method to get the value - this.getClaimPropertyVertices();

This is what I do in general. Getters/setters are there to provide a meaningful wrapper around fields. In some cases, the getter will initialize the backing field (common pattern in C# when using serializers that do not call the object constructor. Don't get me started on that topic...).

Store locally by getting the value - this.claimPropertyVertices;

No, see above.

Use the instance variable directly in the method

Exactly the same as above. Using this or not using this should generate the exact same code.

UPDATE (based on your edit)

If the value is external to the object instance, and should not meaningfully be stored along with the instance, pass it in as a value to the method call.

Upvotes: 4

Related Questions