Формат файла dll что это
Перейти к содержимому

Формат файла dll что это

  • автор:

Файл формата DLL — что это?

Формат DLL является динамической библиотекой, которая отвечает за получение доступа различными программными комплексами к общедоступному системному функционалу. Достаточно часто, DLL файл входит в состав неотъемлемых элементов операционной системы Windows. Такой формат файлов, как Link Library, может представлять из себя и часть прикладных программ.

Многие из динамических библиотек, способствуют реализации программных функций, отвечающих за соединение с внешними устройствами либо работу с жесткими дисками. Применение файла DLL, находят и в кроссплатформенных приложениях для Mac, однако основное распространение Dynamic Link, наблюдается в операционной системе Windows, в которой не обойтись без библиотек DLL. Подобный тип файла, может встречаться и в системе IBM OS/2.

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

What is a .dll?

Delta Force

Ever had an error due to missing .dll files? Ever wondered what those pesky little buggers are? Well, read on to find out how they work!


A .dll, or a dynamically-linked library, is a software library that’s imported into an executable when it is run. What the hell does that mean? Well, that’ll require delving into a scary piece of code called…

The C compiler

C/C++ compilers on Windows are capable of producing these dynamically-linked libraries. To truly understand how they work, how a compiled language can import code at runtime, we’ll have to have a basic understanding of a compiler.

A C compiler flow can be broken down thusly:

To understand how a dynamically-linked library works, we need to understand what a library is, which means we’ll need to understand what a linker is, which means we’ll need to understand what a compiler is…

So let’s get started.


The preprocessor is pretty simple: it copies and pastes code, and can conditionally include certain parts of code depending on the compile-time environment.

Developers can give orders to the preprocessor using pre-processor directives. In the above example, #include simply asks the preprocessor to paste the contents of the stdio.h standard library here.


Ah, the compiler… What a simultaneously glorious and terrifying piece of software.

The compiler is what converts our high-level code into executable binaries. Wait, aren’t we discussing the parts of a compiler? How does a compiler contain a compiler?

Compilers like gcc or the one packaged with Visual Studio (called MSVC) contain many components — including a bit that does the actual translation from source code to machine code. Machine code is binary, all 1s and 0s. This is what ultimately runs on your computer and what it understands.

To avoid any further confusion, we’ll refer to the bit that does the translation as a translator, and a compiler will refer to all 3 parts — preprocessor, translator and linker.

Let’s now compile a simple example:

  1. The preprocessor pastes stdio.h and hands it to the translator.
  2. The translator converts the code to machine code and produces an executable. An executable is just a .exe file.
  3. We run the executable and we see ‘9’ on the screen.

Simple stuff, right? ‘But hold on,’ I hear you say. ‘What about the linker?’. Well, the linker actually doesn’t do a whole lot here. The linker is used when we have multiple files to compile (It’s actually used to resolve references, but we’ll get to that later). So why bother with multiple files? Why can’t we just stick with this? What’s the purpose of splitting our code into multiple files?

  1. To modularize code and reason about it sanely.
  2. Some codebases are several million lines long, like Linux and gcc, and they take hours to compile from scratch. Splitting code into multiple files allows the compiler to compile only those files that were changed, or whose dependencies were changed.

Let’s return to our example. We can shift the function complex_function to its own file. Let's do that now.

We now pass both main.c and awesome_sauce.c to our compiler. The preprocessor does its work, but the translator will throw an error (or at the very least a warning). Why? Well, we've not declared complex_function anywhere in main.c ! Clearly, just separating functions like this isn't going to work. Instead, we do this:

What’s this .h file? It’s called a header file. A header file typically holds declarations. The .c files, or source files, hold the actual definitions. So what happens now?

  1. The preprocessor chugs along faithfully and pastes code in place of the #include s. We have to pass the location of awesome_sauce.h to the compiler so that the preprocessor knows where to find this non-standard header (A header that's not part of the standard library. stdio.h is a part of the standard library).
  2. The translator now processes each .c file individually and produces an object file for each .c file. That’s right, I lied earlier when I said the translator produces an executable. Each source file produces an object file. These object files are all given as input to the linker.
  3. The linker does magical things to the object files and makes an executable. More on this later. Our earlier example had only one file, but the linker still did some other stuff — linking bits of the standard library. We’ll get to what libraries are later.

Let’s go into a bit more detail. After step 1, main.c looks like this to the translator:

In step 2, while translating to object files, the translator converts variables and functions to symbols, which it stores in a symbol table. Thus, complex_function is converted to a symbol, and all occurrences of complex_function are replaced with this symbol. However, as was earlier mentioned, the translator goes through each source file individually, and thus while working on main.c , it does not know the actual location of complex_function . So, it replaces all occurrences of complex_function in main.c with a symbol, but the symbol table, which is supposed to contain a reference to the actual location of complex_function , is empty. We say complex_function is an unresolved symbol.

Step 3 is where symbols actually get resolved by the linker. How does that happen?


The linker is passed the object files with unresolved symbols (or unresolved references). Let’s call these files main.o and awesome_sauce.o . What happens now is actually pretty simple: the linker will take all the object files (so it takes main.o and awesome_sauce.o ), searches for any unresolved references and resolves them. So, this is what roughly happens:

  1. The linker notices the unresolved reference to complex_function inside main.o .
  2. It notices the definition for complex_function inside awesome_sauce.o .
  3. It makes the reference in main.o point to the address of the definition of complex_function inside awesome_sauce.o . Pretty simple, right?

If we hadn’t passed awesome_sauce.o to the linker (by not compiling awesome_sauce.c at all), we would have gotten a linker error (not a compiler error) complaining about an unresolved reference.

This is an example of static linking. Static linking means performing linkage at compile time, i.e., right after the translation (static = at compile time, dynamic = at run time). Understanding static linkage is crucial to understanding dynamic linkage and how .dll files work.


In the example we just ran through, we’d have to re-compile awesome_sauce.c every time we wanted to make changes to main.c , as the linking needs awesome_sauce.o . That seems stupid, surely we can just translate awesome_sauce.c to binary and just do the linking alone?

Apparently, compiler developers have already thought deeply about optimizations, and any superficial attempts on our part to contemplate on flaws in compilers isn’t likely to yield results. Surprising, isn’t it?

A library is exactly what we described, some binary code with a bunch of definitions for symbols. It’s already been translated and is now just waiting to be linked to an executable or another library. So, we can compile awesome_sauce.c on Windows to an awesome_sauce.lib . This can then just be passed to the compiler when compiling main.c , which gives the library directly to the linker, thus skipping the preprocessor and translator altogether ( main.c still goes through all the steps though). Keep in mind that we can't run libraries like executables, as libraries don't contain a main function, they're just a bunch of definitions for symbols.

If it hasn’t occured to you yet, all of the standard libraries are just a bunch of libraries that have already been compiled to binary code. You don’t see stdio.c compiling everytime you include it, do you? No, of course you don't. That's because it's already been compiled and is usually distributed along with whatever C compiler you've installed. Standard library functions like printf are resolved by the linker by finding the definitions for them in their respective libraries.

Magical as static linking might seem, we can go a step further. What if we don’t even want to link during compile time? We definitely need some way to resolve unresolved references, but it turns out we can defer that for until after compilation…

Da-Da-Dynamic Linking!

Static linking has several inherent issues which we shall expose through an example.

I am the maintainer of a security library called h4x0r_pwner. Everyone in the world uses this library by statically linking with it. Today, a leet hacker has pwned my library and discovered an exploit. I immediately patch the exploit and push new binaries. Now, everyone depending on h4x0r_pwner must re-compile their code and re-distribute their executables. This sounds like a horribly painful process — forcing services that depend on your library to re-compile and re-distrubute their code. There is a simpler way — using dynamic linking.

Dynamic linking is exactly what it sounds like — running the linker at run-time instead of compile time. Now, references to symbols in h4x0r_pwner are resolved at run time, so services depending on my library just need to download the latest version of my library. They don’t need to recompile their code, as their executable will simply link to my new library at run time. This is much better than requiring clients to recompile their services.

Apart from easy updating, dynamic libraries also save space. Static linking just dumps the necessary symbol definitions into the final executable. Dynamic libraries contain the definitions themselves, reducing the executable size. If multiple executables require one dynamic library, the library is only loaded once into memory, thus saving memory too.

So how do dynamic libraries actually work? On Windows, you can just ask your compiler to produce a dynamic library instead of a static one — well, not quite, but that’s the essence of it. So let’s say we want to compile awesome_sauce.c to our very own .dll. We make the compiler generate a dynamic library, and it spits out two binaries — awesome_sauce.lib and awesome_sauce.dll . Great, we have our own .dll! But what's the static library awesome_sauce.lib doing here?

Well, the .lib is a stub. It just contains hooks into the .dll file.

The .lib file just calls stuff inside the .dll. Why do we even need it? Well, let’s say we want to compile main.c now, and wish to link with awesome_sauce.dll . We first link main.c with awesome_sauce.lib while compiling. and that's it! The function in the .dll file is searched for and found at run-time. This means we can change the definition of complex_function without recompiling main.c ! Let's take an example: say we run main.exe now. We get an output of 9, as 4 + 5 is 9. Now, I change awesome_sauce.c to this:

Now, I compile this and I get awesome_sauce.dll and awesome_sauce.lib . I replace the old awesome_sauce.dll packaged with main.exe with the new one. Now, I just run main.exe and the output is now -1! We changed the definition of complex_function , but didn't trigger a recompilation of main.exe .

It’s not all rosy, though. Dynamic libraries come with their own set of disadvantages, one of which is something called binary compatibility.

Let’s say we want complex_function to take in 3 arguments now. Nope, that's not possible without recompiling main.c . Why though? Notice awesome_sauce.lib . It's already hard-coded to call complex_function with 2 arguments. We've already statically linked main.c with this library. If we want to add an argument, the .lib file will change. Thus, any change to the declaration of a function will result in something called a binary incompatibility. This is something library developers will have to take care of, otherwise they might inadvertently force a recompilation on services that depend on them.

Well, that’s about it. This was a pretty basic overview of how a .dll works on Windows. Dynamic libraries are present on other platforms too, though they work somewhat differently, e.g. Linux has ‘shared objects’ or .so files.

True understanding comes with doing. Compiling a dynamic library yourself with Visual Studio (or gcc on Linux) will make you feel like a true hacker. Here are some awesome_sauce resources for doing that:

Расширение файла DLL

DLL значок файла

Файл DLL представляет собой файл формата Dynamic Link Library, разработанный Microsoft. Он относится к категориям Системные файлы, Исполняемые файлы и Опасные файлы, в которых 425 расширений файлов.

Файлы DLL можно открыть в операционных системах Windows, Mac OS и Linux. Наиболее популярными программами для этого формата являются Microsoft Visual Studio, IconsExtract и Icon Extractor.

Добавьте в закладки и поделитесь этой страницей с другими:

  • Закрепите его на Pinterest
  • Поделиться через Facebook
  • Поделиться в Twitter
  • Share on WhatsApp
  • Отправить Email
  • Копировать ссылку

Как открыть файл DLL?

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

Программы, которыми можно открыть файлы DLL


  • Microsoft Visual StudioMicrosoft Visual Studio
  • IconsExtractIconsExtract
  • Icon ExtractorIcon Extractor
  • ResEditResEdit
  • BeCyIconGrabberBeCyIconGrabber
  • IcoFXIcoFX
  • Microsoft WindowsMicrosoft Windows
  • Microsoft Windows NT 4.0Microsoft Windows NT 4.0
  • Microsoft Windows 8Microsoft Windows 8
  • Microsoft Windows XP ProfessionalMicrosoft Windows XP Professional
  • Microsoft Windows MeMicrosoft Windows Me
  • Microsoft Windows 7Microsoft Windows 7
  • Microsoft Windows 2000Microsoft Windows 2000
  • Microsoft Windows 3.xMicrosoft Windows 3.x
  • Microsoft Windows 10Microsoft Windows 10
  • Microsoft Windows VistaMicrosoft Windows Vista

Mac OS

Mac OS
  • Microsoft Visual StudioMicrosoft Visual Studio


  • Microsoft Visual StudioMicrosoft Visual Studio

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

Для настольных компьютеров доступно 16 программ, в том числе 16 для Windows, 1 для Mac OS и 1 для Linux.

Как редактировать файл DLL?

Если вам нужно изменить файл dll, вам нужно использовать специальные программы для работы с такими файлами. Самым популярным DLL редактором является Microsoft Visual Studio. Он позволяет создавать и редактировать файлы с заданным расширением.

Как решить проблемы с файлами DLL?

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

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


  • Щелкните правой кнопкой мыши файл DLL, для которого вы хотите изменить программу для открытия по умолчанию;
  • В контекстном меню «Открыть с помощью» выберите «Выбрать другое приложение»;
  • Выберите программу Microsoft Visual Studio из списка и установите флажок «Всегда использовать это приложение для открытия .dll файлов».

Mac OS

  • Щелкните правой кнопкой мыши имя файла DLL или щелкните, удерживая клавишу «Control»;
  • Выберите в меню «Открыть в программе»;
  • В окне выбора программы найдите программу Microsoft Visual Studio и поставьте галочку напротив «Всегда открывать в программе».


  • Выберите файл Dynamic Link Library, приложение для которого по умолчанию вы хотите установить;
  • Щелкните файл правой кнопкой мыши и выберите «Свойства», затем вкладку «Открыть с помощью»;
  • Выберите приложение Microsoft Visual Studio и нажмите «Установить по умолчанию».

Подробная информация о расширении файла DLL

MIME-типы, используемые для dll файлов

  • application/x-msdos-program
  • application/x-msdownload

Сигнатура файла

Как конвертировать файл DLL?

Вы можете конвертировать файлы DLL в 2 других формата, самые популярные из которых:

Похожие расширения файлов

Расширение Описание
CTFSYS OS X Mach Kernel System
CUB Analysis Services Cube Format
DBL DAZ Brick Light Format
DS_STORE Mac OS X Folder Settings Format
DUMP Google BreakPad Crash Log Format
EFI Extensible Firmware Interface Format
EFIRES EFI Image Format

Перетащите сюда или загрузите файл, чтобы просмотреть сведения о файле. До 50 МБ.

Открытие DLL-файлов для редактирования

Чем открыть DLL для редактирования

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

Открываем DLL-файлы для редактирования

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

Способ 1: Resource Hacker

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

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

Как видите, Resource Hacker — достаточно удобный инструмент, позволяющий быстро редактировать различные объекты. С взаимодействием разберется каждый пользователь, останется лишь понять, какие правки стоит вносить, чтобы обеспечить желаемую работу DLL.

Способ 2: Hex Workshop

Еще один популярный редактор DLL-файлов имеет название Hex Workshop, однако реализован он с определенными отличиями от предыдущего софта. Связаны эти особенности и с процедурой редактирования, которая выполняется немного сложнее из-за отображения кода только в бинарном виде, но с разными кодировками.

  1. После инсталляции запустите Hex Workshop и приступайте к открытию файла. Переход к открытию файла в программе Hex Workshop
  2. Точно так же, как и в предыдущем методе, выберите подходящий DLL. Открытие файла для редактирования в программе Hex Workshop
  3. Теперь перед вами отобразится содержимое, разделенное на строки и столбцы для удобства. Просмотр содержимого файла в программе Hex Workshop
  4. Нажмите на одно из выражений, чтобы справа посмотреть сведения в доступных интерпретациях. Просмотр сведений отдельного блока исходного кода в программе Hex Workshop
  5. Переключение кодировок, изменение содержимого и выполнение других действий происходит с помощью панели инструментов и дополнительных окон навигации. Панель инструментов для редактирования файлов в программе Hex Workshop

Способ 3: Доступная среда разработки

Сейчас практически все программисты создают и редактируют код в специальной среде разработки. Ею выступает программное обеспечение, заточенное под выполнение работ с кодом. Обычно там присутствуют вспомогательные инструменты, упрощающие работу с проектами. Некоторые из них справляются с открытием элементов формата DLL и позволяют их редактировать. Сейчас мы хотим взять за пример Embarcadero RAD Studio последней версии.

  1. Запустите Embarcadero RAD Studio или любую другую подобную среду разработки и переходите к запуску файла. Переход к открытию файла для редактирования в программе Embarcadero RAD Studio
  2. Выберите его, дважды кликнув ЛКМ. Выбор файла для редактирования в программе Embarcadero RAD Studio
  3. Теперь в рабочей области появится иерархия всех составляющих. Справа отобразятся различные атрибуты, например, название элемента, место его хранения, вспомогательное описание и, конечно, сам исходный код. Все это доступно для изменения. Изменение сведений о файле и его вида в программе Embarcadero RAD Studio
  4. Иногда файлы открываются только в бинарном виде, что уже зависит от его структуры и первоначального создания. Отображение файла в бинарном виде в программе Embarcadero RAD Studio

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

Способ 4: Sublime Text

Как известно, Sublime Text является не совсем обычным текстовым редактором. Его основная функциональность нацелена на работу с исходным кодом и его компиляцией. В этом софте подсвечивается синтаксис и происходит автоматическое определение языка. Что касается открытия DLL, то сделает он это немного лучше, чем привычные текстовые редакторы.

  1. Раскройте всплывающее меню «File» и выберите «Open File». Открытие файла для редактирования в программе Sublime Text
  2. Исходный код DLL отобразится в непонятном для обычного пользователя виде, однако его содержимое точно отображается полностью корректно. Просмотр содержимого DLL-файла в программе Sublime Text
  3. При попытке скомпилировать имеющийся исполняемый файл на языке C++, вы, скорее всего, не получите уведомление об ошибке, но результат останется неизвестен. Попытка компиляции DLL-файла в программе Sublime Text

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

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

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *