Why are INI files deprecated in favor of the registry? There were many problems with INI files.
- INI files don’t support Unicode. Even though there are Unicode functions of the private profile functions, they end up just writing ANSI text to the INI file. (There is a wacked out way you can create a Unicode INI file, but you have to step outside the API in order to do it.) This wasn’t an issue in 16-bit Windows since 16-bit Windows didn’t support Unicode either!
- INI file security is not granular enough. Since it’s just a file, any permissions you set are at the file level, not the key level. You can’t say, “Anybody can modify this section, but that section can be modified only by administrators.” This wasn’t an issue in 16-bit Windows since 16-bit Windows didn’t do security.
- Multiple writers to an INI file can result in data loss. Consider two threads that are trying to update an INI file. If they are running simultaneously, you can get this:
Thread 1 Thread 2 Read INI file Read INI file Write INI file + X Write INI file + Y
Notice that thread 2’s update to the INI file accidentally deleted the change made by thread 1. This wasn’t a problem in 16-bit Windows since 16-bit Windows was co-operatively multi-tasked. As long as you didn’t yield the CPU between the read and the write, you were safe because nobody else could run until you yielded.
- INI files can suffer a denial of service. A program can open an INI file in exclusive mode and lock out everybody else. This is bad if the INI file was being used to hold security information, since it prevents anybody from seeing what those security settings are. This was also a problem in 16-bit Windows, but since there was no security in 16-bit Windows, a program that wanted to launch a denial of service attack on an INI file could just delete it!
- INI files contain only strings. If you wanted to store binary data, you had to encode it somehow as a string.
- Parsing an INI file is comparatively slow. Each time you read or write a value in an INI file, the file has to be loaded into memory and parsed. If you write three strings to an INI file, that INI file got loaded and parsed three times and got written out to disk three times. In 16-bit Windows, three consecutive INI file operations would result in only one parse and one write, because the operating system was co-operatively multi-tasked. When you accessed an INI file, it was parsed into memory and cached. The cache was flushed when you finally yielded CPU to another process.
- Many programs open INI files and read them directly. This means that the INI file format is locked and cannot be extended. Even if you wanted to add security to INI files, you can’t. What’s more, many programs that parsed INI files were buggy, so in practice you couldn’t store a string longer than about 70 characters in an INI file or you’d cause some other program to crash.
- INI files are limited to 32KB in size.
- The default location for INI files was the Windows directory! This definitely was bad for Windows NT since only administrators have write permission there.
- INI files contain only two levels of structure. An INI file consists of sections, and each section consists of strings. You can’t put sections inside other sections.
- [Added 9am] Central administration of INI files is difficult. Since they can be anywhere in the system, a network administrator can’t write a script that asks, “Is everybody using the latest version of Firefox?” They also can’t deploy scripts that say “Set everybody’s Firefox settings to XYZ and deny write access so they can’t change them.”
Windows, INI Files, Registry, Knowledgebase, Article, Microsoft