在保持良好的面向对象设计的同时，重用代码以获得性能的最佳方法是什么？

Question

I am developing a scientific program where there are several time consuming functions that are called from different other functions. I want to optimize these calls by avoid calling the same function with the same parameters more than once without breaking OO concepts such as encapsulation.

I tried to formulate a basic example of what I have. Class A has an object of class B from where I calculate intermediate results needed by class A functions. For example, in order for the functionA and functionB to calculate its results, each function needs to call the time_consuming_function on the object from B. Usually this functions are called from within a loop so the parameters (1 and 2) are the same among calls to functionA and functionB.

class ClassA {
  ClassB obj // member object

  return_type functionA(parameter1, parameter2) {
    value1 = obj.time_consuming_function(parameter1)
    value2 = obj.time_consuming_function(parameter2)

    return some_operation_with(value1, value2)
  }

  return_type functionB(parameter1, parameter2) {
    value1 = obj.time_consuming_function(parameter1)
    value2 = obj.time_consuming_function(parameter2)

    return some_operation_with(value1, value2)
  }
}

One solution would be create a structure to hold the calculated values among calls to ClassA functions, such as this example:

class ClassA {
  ClassB obj // member object

  return_type functionA(data) { // data is a structure to hold the values
    if (data.is_empty()) {
      data.value1 = obj.time_consuming_function(parameter1)
      data.value2 = obj.time_consuming_function(parameter2)
    }

    return some_operation_with(data.value1, data.value2)
  }

  return_type functionB(data) { // same data obj as before

    // this time data is not empty, so no calculation needed
    if (data.is_empty()) {
      data.value1 = obj.time_consuming_function(parameter1)
      data.value2 = obj.time_consuming_function(parameter2)
    }

    return some_operation_with(data.value1, data.value2)
  }
}

Another solution would be create a class Data to hold the data beforehand. In this case, having the parameters 1 and 2, I would update all properties that change with this parameter on class Data and when executing my functions from class AI would only need to use the values calculated previously. The class A would provide an interface to the Data class.

class Data {
  ClassA class_a_obj

  void update_values_that_depend_on_parameter1(class_a_obj, parameter1) {
    value1 = class_a_obj.time_consuming_function(parameter1)
  }

  void update_values_that_depend_on_parameter2(parameter2) {
    value2 = class_a_obj.time_consuming_function(parameter2)
  }
}

class ClassA {
  ClassB obj // member object

  return_type functionA(data) {
    return some_operation_with(data.value1, data.value2)
  }

  return_type functionB(data) { // same data obj as before

    return some_operation_with(data.value1, data.value2)
  }

  return_type time_consuming_function(parameter) {
    return obj.time_consuming_function(parameter)
  }
}

I wanted to know what you think of this problem and the proposed solutions. Are there other suitable and efficient solutions?

TL;DR:

I have a program that makes several calculations and each of this calculations calls functions to get intermediate values. These values are the same when called from functions that receive the same parameters, I am looking for a way to optimize these calls reusing those intermediate values.

What is the best way to reuse those values while still keeping a good Object Oriented design??

Answer 1

通过代理缓存对这些方法/对象的访问，缓存最近的结果并返回缓存的结果。