Блог

допустим, у меня есть автоматическое общедоступное свойство P в виде целого числа, и каждый раз, когда я хочу прочитать эту переменную P в функции, я буду объявлять локальную переменную как таковую: dim _p = P затем прочитайте _p вместо P.

Мне интересно, имеет ли это смысл вообще? действительно ли это замедлит работу (что, конечно, не входит в мои намерения)

Кстати, если мы изменим вопрос на общедоступное свойство P как Object, будут ли какие-либо изменения в ответе?

Если вы обращаетесь к методу Me.P (или _p ) несколько сотен тысяч раз, копирование свойства в локальную переменную ускорит процесс. Однако в большинстве случаев это не вызывает беспокойства, поэтому вы можете делать что угодно, и это не будет иметь заметного значения.

Я обычно выступаю за упрощение понимания кода, поэтому я бы предпочел доступ к свойству, если только вы не обнаружите, что вам нужна дополнительная производительность. Me.P это легче понять, чем _p есть на самом деле.

Что касается стиля кодирования, я бы очень предпочел, чтобы вы не присваивали P значение _p . При отслеживании кода, чтобы увидеть, где используется P, я бы пропустил его версию _p. Я не думаю, что разница в скорости является чем-то значительным.

Это зависит от того, выполняет ли ваш getter что-либо еще, кроме возврата значения, которое уже было вычислено. Если ваш getter действительно действует просто как общедоступная переменная, то происходит незначительное снижение производительности. С другой стороны, если ваш getter выполняет какие-либо вычисления, это будет медленнее, поскольку каждый раз, когда вы вызываете свойство, ему приходится выполнять код в нем.

Все, что вы, похоже, делаете, это запутываете свой код. Просто используйте свойство напрямую. Никаких последствий, кроме упрощения вашего кода, нет.

Это имеет смысл из-за природы свойств. Свойства позволяют пользователю вернуться к изменению и указать код для форматирования возвращаемого значения данного свойства. Вы не хотите запускать этот код каждый раз, когда ссылаетесь на него одним и тем же методом.

Вот код C #. Я уверен, что вы поймете, что это делает, даже если не знакомы с C#:

 public int MyNumber
{
    get
    {
        return GetValueFromDatabase();
    }
}

public void main()
{
    lblFirst.Text = MyNumber;
    lblSecond.Text = MyNumber;
    lblThird.Text = MyNumber;
}
  

В этом примере база данных вызывалась три раза, в отличие от следующего, в котором она вызывается только один раз:

 public void main()
{
    int _myNumber = MyNumber;
    lblFirst.Text = _myNumber;
    lblSecond.Text = _myNumber;
    lblThird.Text = _myNumber;
}
  

Имейте в виду, что только потому, что ваше свойство не выполняет никаких сложных вычислений в данный момент, не означает, что этого не произойдет в будущем. Вы же не хотите кодировать так, чтобы вам пришлось возвращаться позже и изменять несколько разных мест только из-за изменения кода в одну строку.

Я делаю это только как средство устранения дублирования кода. Если свойство используется более одного раза, то я использую рефакторинг «Ввести переменную», чтобы заменить свойство локальным, которое содержит то же значение.

В противном случае я не вижу причин делать это, и много причин не делать этого.

Автоматически реализованные свойства имеют ту же производительность, что и классические возможности, поскольку компилятор будет генерировать то же самое, что и для обычного класса, у которого нет автоматически реализованных свойств.

Не нужно беспокоиться о производительности. Воспользуйтесь преимуществами короткого формата, когда вам не нужно внедрять больше логики внутри свойства.