На главную Наши проекты:
Журнал   ·   Discuz!ML   ·   Wiki   ·   DRKB   ·   Помощь проекту
ПРАВИЛА FAQ Помощь Участники Календарь Избранное RSS
msm.ru
Модераторы: Rouse_, jack128, Krid
  
    > Работа с файлами , для начинающих
      © Vit ;)

      Текстовый файл отличается тем что он разбит на разные по длине строки, отделенные символами #13#10.

      Сперва, Вам придётся освоить (вспомнить) древний паскалевский способ:

      Для доступа к текстовым файлам используется переменная типа TextFile. До сих пор не совсем понимаю что это такое физически - что-то типа "внутреннего" паскалевского Handle на файл.
      Итак чтобы ассоциировать файл на диске с переменной надо проделать следующие опрерации:

      1) Определяем файловую переменную:
      ExpandedWrap disabled
        Var F:TextFile;


      2) Ассоциируем ее:
      ExpandedWrap disabled
        AssignFile(F, 'c:\MyFile.txt');


      3) Теперь надо этот файл открыть, есть 3 варианта:
        - файла нет или он должен быть перезаписан, открытие для записи:
      ExpandedWrap disabled
        ReWrite(f)


        - файл есть и его надо сбросить на чтение (с начала файла)
      ExpandedWrap disabled
        Reset(f)


        - файл есть и его надо открыть для дозаписи строк в конец
      ExpandedWrap disabled
        Append(f)


      Как видите не хватает очень полезных функций таких как открытия файла для чтения с произвольной строки и для записи в файл произвольной строки. Но надо учесть, что так как длины строк разные, не существует никакого способа узнать физическое место начала например 1000 строки, не прочитав всю тысячу строк. Для записи ситуация еще сложнее - вставить строку означает перезаписать всю информацию после этой строки заново. Таким образом варианты только следующие:
      - Перезаписать весть файл
      - Читать с первой строки
      - Дописать что-то в конец
      - Читать и писать файл целиком (см. ниже работу через TStrings)
      4) В конце работы открытый файл нужно закрыть:
      ExpandedWrap disabled
        CloseFile(f);


      Очень часто работу этих процедур объединяют для придания допоолнительного полезного эффекта. Ну, например, процедура Reset() сбрасывает файл на чтение. А, если файла нет? Правильно, тогда его надо открыть для записи. Для определения существует файл или нет в Паскале существует переменная IOresult, которая возвращает резльтат от выполнения последней операции ввода/вывода. В случае успеха операции она возвращает 0 или код ошибки в случае ошибки. Например, рассмотрим пример программы, которая будет открывать файл для дополнения и создавать, если он отстутствует:

      ExpandedWrap disabled
        ...
         AssignFile(F,'my_file.txt');
        {$I-}
         Append(f);
         IF IOresult<>0 then ReWrite(f);
        {$I+}
         try
          WriteLn(f,'Дополняем текстовый файл my_file.txt');
         finally
          CloseFile(F);
         end;
        ...


      Здесь строка собственно записывается в WriteLn().

      Запись целой строки:
      ExpandedWrap disabled
        WriteLn(f,s);


      WriteLn - это сокращение от "Write Line". Т.е. записать строку. Строка будет заканчиваться в файле байтами #13#10. А теперь как записать без этих байт:

      Запись кусочка строки(те следующая операция записи будет произведена в ту же строку):
      ExpandedWrap disabled
        Write(f,s);


      Если переменная s содержит больше 255 символов (т.е. является длинной строкой), то таким способом ни фига не запишится, в файл вместо строки попадут 4 байта указателя на нее. Надо делать так:
      ExpandedWrap disabled
        WriteLn(f,Pointer(s)^);


      Также в данном примере Вы видите возможно неизвестные для Вас {$I-} и {$I+}. Это директивы компилятора. {$I-} - означает что компилятор должен вместо этой директивы включить в объектный код программы, код, который будет подавлять сообщение об ошибке, которое неизбежно возникнет при выполнении процедуры Append() в случает отсутствия файла. {$I+} - выключение этого режима.

      Вверху мы рассмотрели пример записи строки S (WriteLn), а теперь прочитаем её.
      Пусть у нас есть строковая переменная S для чтения строки из файла
      Чтение предварительно открытого файла:
      ExpandedWrap disabled
        ReadLn(f, s)
      - будет прочитанна текущая строка и позиция чтения переведена на следующую позицию.

      А как прочитать весь файл?
      ExpandedWrap disabled
         
         ... // Откроем файл для чтения
        While not Eof(f) Do
         Begin
           ReadLn(f, s);
           {здесь делаем ?то-то с про?итанной строкой}
         End;
        ... // Закроем файл


      Хорошо, а если файл несколько метров есть ли способ поставить какой-нибудь ProgressBar или Gauge чтобы показывал сколько считанно? Есть, но не совсем прямой - не забыли, сколько строк в файле заранее мы не знаем, узнать можно только прочитав его весь, но показательный пример мы все-таки сделаем:

      ExpandedWrap disabled
        Var  Canceled:Boolean;
         
        Function GetFileSize(FIleName: String): Integer;
         Var f: File of Byte;
        Begin
         try
           AssignFile(f, FileName);
           Reset(f);
           Result:=FileSize(F);
           CloseFile(f);
         except
           Result:=-1;
         end;
        End;
         
        Procedure ReadMyFile;
        Var i, j: Integer;
        Begin
          ProgressBar1.Max:=GetFileSize('c:\MyFile.txt');
          ProgressBar1.position:=0;
          AssignFile(f,'c:\MyFile.txt');
          Canceled:=False;
          Reset(f);
          try
           i:=0;j:=0;
           While not Eof(f) do
             Begin
              Inc(j);
              ReadLn(f,s);
              i:=i+Length(s)+2;
              IF (j mod 1000)=0 then
               Begin
                ProgressBar1.Position:=i;
                Application.ProcessMessages;
                IF Canceled then Break;
               End;
                 {здесь мы ?то-то делаем с прочитанной строкой}
             End;
          finally
           CloseFile(f);
          end;
        End;


      Теперь комментарии к коду.
      1) Функию GetFileSize я рсссмотрю после, она немного по другому подходит к чтению файла (кстати я знаю еще по крайней мере 3 способа ее реализации, поэтому не нужно указывать что это можно сделать легче, быстрее или просто по другому - просто давайте разберем это позже)
      2) Переменная i - все время указывает на количество байт которое мы считали - мы определяем длину каждой строки и прибавляем 2 (символы конца строки). Зная длину файла в байтах и сколько байт прочитано можно оценить и прогресс, но
      3) Если ставить изменение прогресса после каждой строки, то это очень сильно тормознет процесс. Поэтому вводим переменную j и обновляем прогресс например 1 раз на 1000 прочитанных строк
      4) Переменная Canceled - глобальная переменная. Поставьте на форму кнопку, в обработчике нажатия поставьте Canceled:=True; и нажатие кнопки прервет чтение файла.


      Добавлено в
      Появление Object Pascal дало нам программирование на основе классов, которым намного облегчают жизнь рядовому программисту.
      Рассмотрим класс TStrings. Этот класс представляет из себя список. Т.е. попросту говоря, массив строк. TStrings широко используется в различных компонентах для организации списков. Например, наверняка известный Вам компонент TMemo использует в качестве контейнера для строка именно класс TStrings, который организуется в свойстве TMemo.Lines. Тоже самое и для других компонент: TListBox.Items, TComboBox.Items и многих других.
      Однако, это абстрактный класс, т.е. он используется только для наследования. Напрямую его создавать нельзя. Потомком от этого класса являются TStringList. С ним-то нам и надо работать.
      Сейчас рассмотрим как мы можем использовать TStringList для нашей темы, т.е. для чтения файлов.
      У TStrings есть методы записи и чтения в файл - SaveToFile, LoadFromFile. Преимущество - простота использования и довольно высокая скорость, недостаток - читать и писать файл можно только целиком.
      Примеры.
      1) Загрузка текста из файла в Memo:
      ExpandedWrap disabled
        Memo1.Lines.LoadFromFile('c:\MyFile.txt');


      2) Сохранение в файл:
      ExpandedWrap disabled
        Memo1.Lines.SaveToFile('c:\MyFile.txt');


      3) А вот так можно прочитать весь файл в строку:

      ExpandedWrap disabled
        Function ReadFromFile(FileName:string):string;
        begin
         With TStringList.create do
           try
            LoadFromFile(FileName);
            Result:=text;
           finally
            Free;
           end;
        end;


      В данном примере у нас создаётся экземпляр потомка TStrings и в него загружается файл, указанный в параметре процедуры.
      У TStrings есть много других дополнительных методов и свойств: (здесь приведены только некоторые из них)

      Свойство Strings[индекс] - возвращает строку списка с индексом, указанным в скобках. Например,
      ExpandedWrap disabled
         ShowMessage(Strings[0]);
      - выведет нам 0-ю строку списка (конечно, если она есть)

      Метод Add(строка) - добавляет в список строку в начало списка.

      Метод Insert(индекс,строка) - вставляет строку после строки, с указанным индексом.

      Метод Append(строка) - добавляет строку в конец списка.

      А сейчас пример программы для добавления строки в существующий (или несуществующий файл) для сравнения, сделанный на "паскалевском" способе и с использованием класса TStrings:

      Паскалевский способ:

      ExpandedWrap disabled
        Var ff: TextFile;
        ...
        AssignFile(ff,'my_file.txt');
        {$I-}
        Append(ff);
        {$I+}
        IF IOresult<>0 then ReWrite(ff);
        try
         WriteLn(ff,'строка для добавления');
        finally
         CloseFile(ff);
        end;


      Способ с использованием класса TStrings:

      ExpandedWrap disabled
         
         With TStringList.Create Do
          try
           IF FileExists('my_file.txt') then LoadFromFile('my_file.txt');
           Append('строка для добавления');
           SaveToFile('my_file.txt');
          finally
           Free;
          end;


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


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

      Объявляем файл байтов:
      ExpandedWrap disabled
        Var f:file of byte;
            b:Byte;


      Ассоциируем файловую переменную с физическим файлом:
      ExpandedWrap disabled
        AssignFile(f,'c:\myfile.bin');


      Теперь мы можем либо перезаписать/создать файл:
      ExpandedWrap disabled
        ReWrite(f);

      Либо открыть существующий для чтения и записи:
      ExpandedWrap disabled
        Reset(f);

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

      Теперь функции работы с файлом:

      ExpandedWrap disabled
        Read(f,b); - прочитать 1 байт;
        Write(f,b); - записать 1 байт;
        Eof(f); - узнать не является ли байт последним;
        FileSize(f); - возвращает размер файла (или количество структур, если файл структурированный, см. ниже);
        FilePos(f); - возвращает текущую позицию чтения/записи внутри файла.
        Seek(f,100); - устанавливает текущее положение считывания/записи на сотый байт.


      Все эти функции не работают с файлами большими 2 Gb.
      После работы файл надо закрыть:
      ExpandedWrap disabled
        CloseFile(f);



      Добавлено в
      Структурированные файлы.
      Приведенные выше механизмы будут работать с любым файлом, так как любой файл можно считать файлом байтов. Теперь где это можно использовать? В принципе везде, но в подавляющем большинстве случаев это будет очень неудобно, ведь скорость считывания при чтении по байтам будет на порядки более низкой чем другими способами. Однако в некоторых случаях этот способ может быть очень полезен. Например в программе вам надо заменить 100й байт файла на другой, или прочитать 100й байт файла, например во всяких читерских программах, при взломе и т.п. Здесь такой доступ будет весьма удобен. Гораздо более интересным представляется дальнейшее развитие технологии типизированных файлов (их еще лет 15 назад называли "Файлы прямого доступа"). Представим себе, что файл состоит не из байт а из более сложных структур. Например мы имеем некоторую информацию в виде:
      ExpandedWrap disabled
        Type MyRec=Record
                  Name:string[100];
                  Age:byte;
                  Membership:Boolean;
                  Accounts:array[1..10] of integer;
               End;

      Обратите внимание, что все элементы записи точно типизированны, нет ни длинных строк, ни открытых массивов, ни объектов, другими словами, заранее точно известно сколько именно байт будет занимать переменная этого типа. Объявим переменную этого типа:
      ExpandedWrap disabled
        Var MyVar:MyRec;

      и файл этого типа:
      ExpandedWrap disabled
        Var f:File of MyRec;

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

      ExpandedWrap disabled
        AssignFile(f,'c:\MyFile.rec');
        ReWrite(f);
        try
         With MyVar Do
           Begin
            Name:='Vitaly';
            Age:=33;
            Membership:=True;
            Accounts[1]:=12345;
            Accounts[2]:=34985;
           End;
         Write(f,MyVar);
        finally
         Closefile(f);
        end;


      Все остальные функции приведенные в предыдущей статье будут работать так же, только одно отличие - Seek и FileSize оперируют не с количеством байт, а с количеством записей (структур).


      Добавлено в
      Идем дальше. Есть такое понятие как нетипизированный файл. Это такой файл который содержит разнородные элементы. Например файл EXE - вначале он имеет заголовок, затем двоичный код, в конце какие-то ресурсы. Все части файла имеют разную длину и разную структуру. Тут уже обратится к произвольному элементу сложно, обычно надо вначале узнать где этот элемент находится, подчас это записано в предыдущем куске информации. Работа с такими файлами достаточно сложна и требует вручную разработки алгоритмов его чтения, но в связи гибкостью структуры и компактностью такие файлы составляют большинство. Для работы с нетипизированными файлами используют процедуры BlockRead и BlockWrite, которые позволяют читать/писать произвольное количество байт. Привожу пример пользования этими функциями из справки по Дельфи:
      ExpandedWrap disabled
         
        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 Дельфей я обнаружил еще несколько функций достойных упоминания.

      ExpandedWrap disabled
        Erase(f) - удаляет файл;
        FilePos(f) - возвращает текущую позицию чтения/записи в файл;
        Flush(f) - сбрасывает кэшированные файловые операции на диск;
        Rename(f, 'MyNewFileName.txt') - переименование файлов;
        Truncate(f) - файл обрезается до текущей позиции чтения/записи.



      Добавлено в
      Теперь венёмся к работе с файлами чере программирование классов. Но на сей раз более сложный класс - TStream. Он также как и TStrings является абстрактным и для практической с ним работы мы должны использовать его потомков - TFileStream и/или TMemoryStream.
      Для работы с файловым потоком Вам надо записать в Uses модули classes, Sysutils (classes - включает в себя собственно определение класса, Sysutils - некоторые константы необходимые для работы).
      Вот пример записи/перезаписи файла:

      ExpandedWrap disabled
        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)^" заставляет обращаться именно к ее содержимому.
      А вот этот код демонстрирует чтение файла с использованием файлового потока:
      ExpandedWrap disabled
         
        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;


      И пояснения к коду:
      1) Никаких проверок длину файла и его наличие здесь не делается - это демонстрационный код, а не готовая процедура чтения.
      2) Файл мы считываем в буффер типа PChar (с тем же успехом можно использовать массив или любой другой контейнер). Для тех кто не помнит - процедуры   GetMem(p, 255) и FreeMem(p) - распределение памяти для строки и освобождение памяти.
      3) Метод потока  Seek позволяет установить текущую позицию считывания/записи файла. Первый параметер - номер байта, второй - это от чего считать этот байт (у нас считать от начала файла), возможны варианты:
      Цитата
       soFromBeginning - от начала файла
       soFromCurrent - от текущей позиции считывания
       soFromEnd - от конца файла (в этом случае номер байта должен быть отрицательным или равным нулю)

      4) Собственно считывание из потока осуществляется методом read, в котором указывается в качестве параметров буфер в который мы читаем и желаемое количество  байт для чтения. Метод read является функцией, которая возвращает количество байт реально прочитанных из потока.
      Заканчивая о файловых потоках хочу упомянуть о методе
      CopyFrom который позволяет перекачивать информацию из одного потока в другой и о свойствах:
      Size - размер файла
      Position - текущая позиция чтения/записи потока
      Работа с файловыми потоками весьма быстра, этот класс, являсь классом VCL, в то же время базируется на низкоуровневых функциях Windows, что обеспечивает очень высокую скорость работы и стабильность операций. К тому же многие компоненты и классы VCL поддерживаю прямое чтение и запись с файловыми потоками, что занчительно упрощает работу - например TStringList, TBlobField, TMemoField и другие.
      Файловые потоки могут быть рекомендованы к использованию в большинстве  случаев для чтения и записи файлов (за исключением специфических ситуаций, требующих каких-то других подходов), другими словами если вам надо просто записать или считать файл, используйте файловые потоки.


      Добавлено в
      Еще один способ работы с файлами - это открытие Handle на файл и работу через него. Тут есть 2 варианта - можно использовать функции Дельфи или использовать WinAPI напрямую.
      При использовании функций Дельфи можно применять следующие функции:
      ExpandedWrap disabled
        FileOpen(FileName, fmOpenWrite or fmShareDenyNone)
      - функция открывает файл и возвращает целое цисло - Handle на файл. Параметры функции - имя файла и тип доступа (все типы доступа я перечислил ранее). Если файл успешно открыт то Handle должен быть положительным цислом, отрицательное число - это код ошибки.
      Во всех остальных функциях используется именно значение Handle, возвращаемое этой функцией.
      ExpandedWrap disabled
         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 параметра, cooтветствующая функция 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) - применяется для проверки наличия файла
      DirectoryExists(Const FileName: String) - соответственно наличие каталога
      FileGetAttr(const FileName: string): Integer; и
      FileSetAttr(const FileName: string; Attr: Integer): Integer;
      - функции для работы с атрибутами файлов. Вот список возможных атрибутов:
      Цитата
      faReadOnly $00000001 Read-only files
      faHidden $00000002 Hidden files
      faSysFile $00000004 System files
      faVolumeID $00000008 Volume ID files
      faDirectory $00000010 Directory files
      faArchive $00000020 Archive files
      faAnyFile $0000003F Any file

      (Естественно не все атрибуты применимы во всех случаях)
      RemoveDir(const Dir: string): Boolean; - удаляет папку(пустую)
      DeleteFile(const FileName: string): Boolean; - удаляет файл
      RenameFile(const OldName, NewName: string) и
      ChangeFileName(старое_имя, новое_имя)
      - переименовывает файл
      ChangeFileExt(старое_расширение, новое_расширение) - переименовывает расширение файла.


      Добавлено в
      И в заключение пример кода, который собирает информацию о файле:

      ExpandedWrap disabled
         
        Type TFileInfo=record
                        Exists:boolean;//true если файл найден
                        Name:String; //имя файла с расширением
                        ShortName:String;//DOS 8.3 имя файла
                        NameNoExt:String;//имя файла без расширения
                        Extension:string;//расширение файла
                        AssociatedFile:string;//программа с которой ассоциирован файл
                        Path:string;// путь к файлу
                        ShortPath:string;// DOS 8.3 путь файла
                        Drive:string;// дисковод на котором находится файл
                        CreateDate:TDateTime; //время когда файл создан
                        Size:Int64;// размер файла (работает для файлов и больше 2Gb)
                        Attributes:record //нали?ие/отсутствие системных атрибутов
                                     ReadOnly:boolean;
                                     Hidden:boolean;
                                     System:boolean;
                                     Archive:boolean;
                                   end;
                        ModifyDate:TDateTime; // время последнего изменения файла
                        LastAccessDate:TDateTime; // дата последнего открытия файла
                      end;
        Function ReadFileInfo(FileName:string):TFileInfo;
        var ts:TSearchRec;
          Function FileTime2DateTime(FT:_FileTime):TDateTime;
          var FileTime:_SystemTime;
          begin
             FileTimeToLocalFileTime(FT, FT);
             FileTimeToSystemTime(FT,FileTime);
             Result:=EncodeDate(FileTime.wYear, FileTime.wMonth, FileTime.wDay)+
                     EncodeTime(FileTime.wHour, FileTime.wMinute, FileTime.wSecond, FileTime.wMilliseconds);
          end;
          Function AssociatedFile(FileExt:string):string;
            var key:string;
          begin
            With TRegistry.create do
              try
                RootKey:=HKEY_CLASSES_ROOT;
                OpenKey(FileExt, false);
                Key:=ReadString('');
                CloseKey;
                OpenKey(key+'\Shell\open\command', false);
                result:=ReadString('');
                Closekey;
              finally
                free;
              end
          end;
        begin
         Result.Name:=ExtractFileName(FileName);
         Result.Extension:=ExtractFileExt(FileName);
         Result.NameNoExt:=Copy(Result.Name,1,length(Result.Name)-length(Result.Extension));
         Result.Path:=ExtractFilePath(FileName);
         Result.Drive:=ExtractFileDrive(FileName);
         Result.ShortPath:=ExtractShortPathName(ExtractFilePath(FileName));
         if lowercase(Result.Extension)<>'.exe' then Result.AssociatedFile:=AssociatedFile(Result.Extension);
         if FindFirst(FileName, faAnyFile, ts)=0 then
           begin
             Result.Exists:=true;
             Result.CreateDate:=FileDateToDateTime(ts.Time);
             Result.Size:=ts.FindData.nFileSizeHigh*4294967296+ts.FindData.nFileSizeLow;
             Result.Attributes.ReadOnly:=(faReadOnly and ts.Attr)>0;
             Result.Attributes.Hidden:=(faHidden and ts.Attr)>0;
             Result.Attributes.System:=(faSysFile and ts.Attr)>0;
             Result.Attributes.Archive:=(faArchive and ts.Attr)>0;
             Result.ModifyDate:=FileTime2DateTime(ts.FindData.ftLastWriteTime);
             Result.LastAccessDate:=FileTime2DateTime(ts.FindData.ftLastAccessTime);
             Result.ShortName:=ts.FindData.cAlternateFileName;
             Findclose(ts);
           end
         else Result.Exists:=false;
        end;
      0 пользователей читают эту тему (0 гостей и 0 скрытых пользователей)
      0 пользователей:


      Рейтинг@Mail.ru
      [ Script execution time: 0,0645 ]   [ 17 queries used ]   [ Generated: 28.03.24, 13:56 GMT ]