Как программисты практикуют повторное использование кода

В зависимости от размера проекта ответ может меняться.

Для меньшего проекта я бы порекомендовал создать класс DatabaseHelper, который будет выполнять весь доступ к вашей БД. Это была бы просто оболочка для открытия / закрытия соединений и выполнения кода БД. Затем на более высоком уровне вы можете просто написать DBCommands, которые будут выполняться.

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

Вы также можете попробовать изучить ORM, DAAB или Шаблоны и Группа практик

Насколько можно предотвратить старый C&P? - Ну, когда вы пишете свой код, вам необходимо периодически его просматривать, если у вас есть похожие блоки кода, которые различаются только одним или двумя параметрами, это всегда хороший кандидат для рефакторинга в собственный метод.

Теперь для моего примера псевдокода:

Function GetCustomer(ID) as Customer
   Dim CMD as New DBCmd("SQL or Stored Proc")
   CMD.Paramaters.Add("CustID",DBType,Length).Value = ID
   Dim DHelper as New DatabaseHelper
   DR = DHelper.GetReader(CMD)
   Dim RtnCust as New Customer(Dx)
   Return RtnCust
End Function

Class DataHelper
  Public Function GetDataTable(cmd) as DataTable
    Write the DB access code stuff here.
    GetConnectionString
    OpenConnection
    Do DB Operation
    Close Connection
  End Function
  Public Function GetDataReader(cmd) as DataReader
  Public Function GetDataSet(cmd) as DataSet
  ... And So on ...
End Class

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

Возьмем, к примеру, скромного printf. Представьте, что у вас не было printf, а было только write или что-то подобное:

//convert theInt to a string and write it out.
char c[24];
itoa(theInt, c, 10);
puts(c);

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

printf("%d", theInt);

Вам не нужно быть таким навороченным, как printf, с его вариативными аргументами и строкой формата. Даже простая рутина, такая как:

void print_int(int theInt)
{
    char c[24];
    itoa(theInt, c, 10);
    puts(c);
}

добьется цели никудышно. Таким образом, если вы хотите изменить print_int, чтобы он всегда печатал на stderr, вы можете обновить его следующим образом:

void print_int(int theInt)
{
    fprintf(stderr, "%d", theInt);
}

и все ваши целые числа теперь волшебным образом будут распечатаны до стандартной ошибки.

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

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

Библиотеки не появляются волшебным образом. Они созданы программистами, чтобы облегчить им жизнь и позволить им работать быстрее.

Поместите код в процедуру и вызывайте ее всякий раз, когда вы хотите, чтобы этот код был выполнен.

Посмотрите книгу Мартина Фаулера на refactoring или некоторые из многочисленных интернет-ресурсов, связанных с рефакторингом (также на stackoverflow), чтобы узнать, как можно улучшить код, который пахнет дублированием.

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

Также убедитесь, что библиотека протестирована и задокументирована. Таким образом, очень легко найти правильный класс / функцию / переменную / константу.

Хорошее практическое правило - если вы используете один и тот же фрагмент трижды, и, очевидно, можно обобщить его, чем сделать из него процедуру / функцию / библиотеку.

Однако по мере того, как я становлюсь старше и становлюсь более опытным в качестве профессионального разработчика, я все больше склоняюсь к мнению, что повторное использование кода не всегда является лучшей идеей по двум причинам:

1. Трудно предвидеть будущие потребности, поэтому очень сложно определить API, чтобы вы действительно использовали их в следующий раз. Это может стоить вам вдвое больше времени - как только вы сделаете его более общим, чтобы во второй раз вы все равно его переписали. Мне кажется, что в последнее время к этому склонны особенно Java-проекты, они, кажется, всегда переписываются в рамках сегодняшнего дня, просто для того, чтобы их было «легче интегрировать» или что-то еще в будущем.

2. В более крупной организации (я являюсь ее членом), если вам приходится полагаться на какую-то внешнюю команду (внутреннюю или стороннюю), у вас могут возникнуть проблемы. Тогда ваше будущее зависит от их финансирования и ресурсов. Так что использование чужого кода или библиотеки может стать большим бременем. Аналогичным образом, если вы поделитесь фрагментом кода с какой-либо другой командой, они могут ожидать, что вы будете его поддерживать.

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

чтобы получить повторное использование кода, вам нужно стать мастером ...

1. Присваивать вещам имена, отражающие их суть. Это действительно очень важно
2. Убедившись, что он делает только одно. Это действительно возвращается к первому пункту, если вы не можете назвать его по сути, то часто он делает слишком много.
3. Размещение вещи где-нибудь логично. Опять же, это возвращается к умению хорошо называть вещи и улавливать их суть ...
4. Сгруппируйте это с вещами, основанными на центральной концепции. То же, что и выше, но по-другому :-)

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

Есть две основные области, о которых вы должны знать, когда думаете о повторном использовании кода. Во-первых, повторное использование кода внутри проекта и, во-вторых, повторное использование кода между проектами.

Тот факт, что у вас есть фрагмент кода, который вы можете скопировать и вставить в проект, должен указывать на то, что фрагмент кода, на который вы смотрите, может быть полезен в другом месте. Пришло время превратить его в функцию и сделать доступным в рамках проекта. В идеале вы должны заменить все появления этого кода своей новой функцией, чтобы (а) уменьшить избыточный код и (б) гарантировать, что любые ошибки в этом фрагменте кода нужно исправлять только в одной функции, а не во многих.

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

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

Это может означать создание служебных файлов, содержащих функции, которые, как вы знаете, будут полезны в вашей среде. например. Общие функции базы данных, если вы часто разрабатываете проекты, зависящие от баз данных.

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

ExportToExcel (Дата списка, строка имени файла)

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

Для приведенного вами примера подходящим решением будет написать функцию, которая принимает в качестве параметров все, что вы редактируете при вставке блока, а затем вызовите эту функцию с соответствующими данными в качестве параметров.

Постарайтесь выработать привычку использовать чужие функции и библиотеки.

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

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

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

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

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

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

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

1. Напишите функцию, параметризуйте ее, чтобы разрешить вариации
2. Напишите объект функции с членами для хранения различных данных
3. Разработайте иерархию (функциональный объект?) Классов, которые реализуют еще более сложные варианты
4. В C ++ вы также можете разрабатывать шаблоны для генерации различных функций или классов во время компиляции.

Легко: всякий раз, когда вы ловите себя на копировании кода, вынимайте его немедленно (т.е. не делайте этого после того, как вы уже произвели код CP несколько раз) в новую функцию.