Отчет по практике, работа с "1С:Бухгалтерия 8.2"

_{read(f,b); - прочитать 1 байт} 

_{write(f,b); - записать 1 байт} 

_{seek(f,100); - поставить текущее  положение считывания/записи  на сотый байт} 

_{size(f); - прочитать количество  байт в файле.} 

_{eof(f); - узнать, не является  ли байт последним} 

_{Все эти функции не работают с файлами большими 2 gb.}

_{После работы файл надо закрыть:}

_{closefile(f);}

_{Приведенные выше механизмы будут  работать с любым  файлом, так как  любой файл можно  считать файлом байтов. Теперь, где это  можно использовать? В принципе везде, но в подавляющем большинстве случаев это будет очень неудобно, ведь скорость считывания при чтении по байтам будет на порядки более низкой, чем другими способами. Однако в некоторых случаях этот способ может быть очень полезен. Например, в программе вам надо заменить 100й байт файла на другой, или прочитать 100й байт файла, например во всяких читерских программах, при взломе и т.п. Здесь такой доступ будет весьма удобен. Гораздо более интересным представляется дальнейшее развитие технологии типизированных файлов (их еще лет 15 назад называли "Файлы прямого доступа"). Представим себе, что файл состоит не из байт, а из более сложных структур. Например, мы имеем некоторую информацию в виде:}

_type

_{myrec = record}

_{name: string[100];}

_{age: byte;}

_{membership: boolean;}

_{accounts: array[1..10] of integer;}

_end;

_{Обратите  внимание, что все  элементы записи точно  типизированы, нет  ни длинных строк, ни открытых массивов, ни объектов, другими  словами, заранее  точно известно, сколько  именно байт будет  занимать переменная этого типа. Объявим переменную этого типа:}

_var

_{myvar: myrec;}

_{и файл этого типа:}

_var

_{f: file of myrec;}

_{Теперь  мы можем читать и  писать сразу целую  структуру, абсолютно  так же как и  если бы это был  один байт:}

_{assignfile(f, 'c:myfile.rec');}

_rewrite(f);

_{myvar.name := 'vitaly';}

_{myvar.age := 33;}

_{myvar.membership := true;}

_{myvar.accounts[1] := 12345;}

_{myvar.accounts[2] := 34985;}

_{write(f, myvar);}

_{closefile(f);}

_{Все остальные функции, приведенные в  предыдущей статье будут  работать так же, только одно отличие - seek и size оперируют не с количеством байт, а с количеством записей.}

_{Нетипизированные  файлы}

_{Есть  такое понятие  как нетипизированный файл. Это такой  файл, который содержит разнородные элементы. Например, файл exe - вначале  он имеет заголовок, затем двоичный код, в конце какие-то ресурсы. Все части файла имеют разную длину и разную структуру. Тут уже обратится к произвольному элементу сложно, обычно надо вначале узнать, где этот элемент находится, подчас это записано в предыдущем куске информации. Работа с такими файлами достаточно сложна и требует вручную разработки алгоритмов его чтения, но в связи гибкостью структуры и компактностью такие файлы составляют большинство. Для работы с нетипизированными файлами используют процедуры blockread и blockwrite, которые позволяют читать/писать произвольное количество байт. Привожу пример пользования этими функциями из справки по Дельфи:}

_var

_{fromf, tof: file;}

_{numread, numwritten: integer;}

_{buf: array[1..2048] of char;}

_begin

_{if opendialog1.execute then { display open dialog box }}

_begin

_{assignfile(fromf, opendialog1.filename);}

_{reset(fromf, 1); { record size = 1 }}

_{if savedialog1.execute then { display save dialog box}}

_begin

_{assignfile(tof, savedialog1.filename); { open output file }}

_{rewrite(tof, 1); { record size = 1 }}

_{canvas.textout(10, 10, 'copying ' + inttostr(filesize(fromf)) +}

_{' bytes...');}

_repeat

_{blockread(fromf, buf, sizeof(buf), numread);}

_{blockwrite(tof, buf, numread, numwritten);}

_{until (numread = 0) or (numwritten <> numread);}

_{closefile(fromf);}

_{closefile(tof);}

_end;

_end;

_end;

_{Этот  код копирует из одного файла в другой. Замечания по поводу этого метода работы с файлами - плюсы - очень высокая  скорость, особенно если размер буфера увеличить до 64kb-512kb, что позволит считывать  файл достаточно большими кусками, чтобы обеспечить отсутствие простоев винчестера, к тому же обеспечивается очень высокая гибкость в работе. Минусы - сложность разработки, необходимость вручную писать все детали механизма чтения/записи и интерпретации данных.}

_{Пожалуй, на этом можно было бы, и завершить описание работы с файлами средствами Паскаля и файловых переменных, но заглянув в help Дельфей я обнаружил, еще несколько функций достойных упоминания.}

_{erase(f) - удаляет файл} 

_{filepos(f) - возвращает текущую  позицию чтения/записи  в файл} 

_{flush(f) - сбрасывает кэшированные файловые операции на диск}

_{rename(f, 'mynewfilename.txt') - переименование файлов} 

_{truncate(f) - файл обрезается  до текущей позиции  чтения/записи} 

_{Файловые  потоки}

_{Теперь  разберем возможности  работы потомка tstream - tfilestream - файловый поток. Этот класс был специально введен для работы с файлами. Для работы с файловым потоком Вам надо записать в uses модули classes, sysutils (classes - включает в себя собственно определение класса, sysutils - некоторые константы необходимые для работы).}

_{Вот пример записи/перезаписи файла:}

_{procedure writefileusingstream(s, filename: string);}

_begin

_{with tfilestream.create(filename, fmcreate or fmopenwrite) do}

_try

_{write(pointer(s)^, length(s));}

_finally

_free;

_end;

_end;

_{Теперь  небольшой разбор:}

_{tfilestream.create - конструктор класса, его вызов требует указания имени файла и опций его открытия, следующие опции определены:}

_{fmcreate = $ffff;}

_{fmopenread = $0000;}

_{fmopenwrite = $0001;}

_{fmopenreadwrite = $0002;}

_{fmsharecompat = $0000;}

_{fmshareexclusive = $0010;}

_{fmsharedenywrite = $0020;}

_{fmsharedenyread = $0030;}

_{fmsharedenynone = $0040;}

_{Теперь  метод write - этим методом  в файл пишется  любая информация из буфера любого типа, Вам надо указать  только буфер и  количество записываемых байтов. В данном случае используется переменная типа string в качестве буфера, но так как для длинных строк она представляет собой лишь указатель, то конструкция "pointer(s)^" заставляет обращаться именно к ее содержимому.}

_{А вот  этот код демонстрирует  чтение файла с  использованием файлового потока:}

_var

_{p: pchar;}

_begin

_{getmem(p, 255);}

_{with tfilestream.create('c:mytext.txt', fmopenreadwrite) do}

_try

_{seek(10, sofrombeginning);}

_{read(p^, 254);}

_finally

_free;

_end;

_{showmessage(p);}

_freemem(p);

_end;

_{И пояснения  к коду:}

_{Никаких проверок длину файла и его наличие здесь не делается - это демонстрационный код, а не готовая процедура чтения.}

_{Файл  мы считываем в  буфер типа pchar (с  тем же успехом  можно использовать массив или любой  другой контейнер). Для  тех кто не помнит - процедуры getmem(p, 255) и freemem(p) - распределение памяти для строки и освобождение памяти.}

_{Метод потока seek позволяет  установить текущую  позицию считывания/записи файла. Первый параметр - номер байта, второй - это от чего считать  этот байт (у нас  считать от начала файла), возможны варианты:}

_{sofrombeginning - от начала файла} 

_{sofromcurrent - от текущей позиции  считывания} 

_{sofromend - от конца файла  (в этом случае  номер байта должен  быть отрицательным  или равным нулю)}

_{Собственно  считывание из потока осуществляется методом read, в котором указывается в качестве параметров буфер, в который мы читаем и желаемое количество байт для чтения. Метод read является функцией, которая возвращает количество байт реально прочитанных из потока.}

_{Заканчивая  о файловых потоках, хочу упомянуть о методе copyfrom, который позволяет перекачивать информацию из одного потока в другой и о свойствах:}

_{size - размер файла} 

_{position - текущая позиция  чтения/записи потока} 

_{Работа  с файловыми потоками весьма быстра, этот класс, являясь классом vcl, в то же время базируется на низкоуровневых функциях windows, что обеспечивает очень высокую скорость работы и стабильность операций. К тому же многие компоненты и классы vcl поддерживаю прямое чтение и запись с файловыми потоками, что значительно упрощает работу - например, tstringlist, tblobfield, tmemofield и другие.}

_{Файловые  потоки могут быть рекомендованы к  использованию в  большинстве случаев  для чтения и записи файлов (за исключением  специфических ситуаций, требующих каких-то других подходов), другими  словами, если вам надо просто записать или считать файл, используйте файловые потоки.}

_{Работа  через handle}

_{Еще один способ работы с файлами - это  открытие handle на файл и работу через  него. Тут есть 2 варианта - можно использовать функции Дельфи или  использовать winapi напрямую.}

_{При использовании функций  Дельфи можно применять  следующие функции:}

_{fileopen(filename, fmopenwrite or fmsharedenynone) - функция открывает  файл и возвращает  целое число - handle на файл. Параметры  функции - имя файла  и тип доступа (все типы доступа я перечислил ранее). Если файл успешно открыт, то handle должен, быть положительным числом, отрицательное число - это код ошибки.}

_{Во  всех остальных функциях используется именно значение handle, возвращаемое этой функцией.}

_{fileclose(handle: integer) - закрывает файл}

_{fileread(handle: integer; var buffer; count: integer): integer;}

_{filewrite(handle: integer; const buffer; count: integer): integer;}

 

_{Эти функции для чтения/записи файла, где buffer любая  переменная достаточного размера для  чтения/записи куска информации (обычно типа pchar или массив), count-количество байт, которое Вы желаете записать/прочитать. Функции возвращают количество байт, которые реально были прочитаны или записаны.}

_{Этот  тип доступа к  файлам применяется  весьма редко. Дело в том, что он практически дублирует соответствующие функции winapi и к тому же обычно работает несколько медленнее, чем например потоки. И все же использование функций fileopen и fileclose не лишено привлекательности. Наряду с тем, что эти функции намного легче в использовании соответствующих функций winapi (можете сравнить - fileopen имеет 2 параметра, соответствующая функция winapi - createfile имеет 7 параметров, большая часть из которых реально требуется лишь в ограниченном числе случаев) этот путь доступа открывает возможность прямого использования всех функций winapi про работе с файлами, которые требуют handle на открытый файл.}

_{Файловые  операции}

_{Дельфи  предоставляет довольно широкие возможности  по файловым операциям  без использования  механизмов открытия/закрытия файлов.}

_{Вот список наиболее употребляемых  функций, большинство  из которых в фачкстве параметров нуждаются  только в имени  файла:}

_{chdir(newcurrentpath: string); - изменяет текущий  каталог (в среде  windows сие конечно  не так актуально  как в ДОС, но все же), прочитать, же текущий каталог можно функцией getcurrentdir, а текущий каталог для определенного драйва - getdir.}

_{createdir(const dir: string): boolean; - создает каталог. При этом предыдущий уровень должен присутствовать. Если вы хотите сразу создать всю вложенность каталогов, используйте функцию forcedirectories(dir: string): boolean; Обе функции возвращают true, если каталог создан.}

_{diskfree(drive: byte): int64; - дает свободное  место на диске.  Параметр - номер  диска 0 = текущий,  1 = a, 2 = b, и так далее}

_{disksize(drive: byte): int64; - размер винта. Обратите внимание на то что для результата этой и предыдущей функций абсолютно необходимо использовать переменную типа int64, иначе максимум того что вы сможете прочитать правильно будет ограничен 2gb}

_{fileexists(const filename: string) - применяется для  проверки наличия  файла}