Advanced Registry Cleaner PC Diagnosis and Repair

Regserve Registry Cleaner

The RegServe registry scan searches your computer for invalid, corrupt, orphaned registry entries, and registry errors. Using the comprehensive registry scan, RegServe will search fifteen (15) areas of your computers registry and detect items that may be impacting your computers performance. Registry DefragRegistry Defrag The registry defrag process is designed to increase your computer speed and free resources by managing the overall size of your registry and how requests are made. Registry ScansAuto-Scheduled Scans After establishing a desired setting and frequency, auto-scheduled scans allow you to automate future registry scans. When enabling this feature, RegServe will automatically start the date you specify and scan your computer for registry items. Registry ReportDetailed Scan Results Following any registry scan, RegServe provides you with a detail report for the areas of your registry selected for repair. At this point, you may also select which registry items (if any) you would like RegServe to overlook during the repair process. Ignore ListBuilt-In Ignore List The built-in ignore list ensures maximum compatibility with third-party applications. If you have deselected items from the registry scan results, they will be added to the ignore list automatically. Keywords may also be entered into the ignore list to prevent any possible conflict from arising. Registry BackupRegistry Backup & Restore Prior to each registry repair, RegServe creates a log file that contains backup information with your previous registry settings. Using the Restore feature you can revert your computers registry to a previous setting if desired. Windows RegistryWindows Startup Manager View and manage applications that launch during startup. The Startup Manager allows you to improve slow computer load times by freeing up computer resources and disabling applications you do not wish to load automatically. Read more here...

Regserve Registry Cleaner Overview


4.7 stars out of 13 votes

Format: Ebook
Official Website:
Price: $41.00

Access Now

My Regserve Registry Cleaner Review

Highly Recommended

This is one of the best e-books I have read on this field. The writing style was simple and engaging. Content included was worth reading spending my precious time.

This ebook does what it says, and you can read all the claims at his official website. I highly recommend getting this book.

Accessing the Windows Registry

Although you didn't have direct access to the Windows Registry using server-side script in classic ASP, several aftermarket controls provided that capability. You could also use some other language such as classic VB, which provided an easy way to read, write, and delete values from the Windows Registry using the SaveSetting, GetSetting, GetAllSettings, and DeleteSetting statements but all the values resided in a specific key. In other words, there was no built-in way to read or write values from any other location in the Registry. But the need was there, so people used the Windows API calls from VB, which was awkward. C and C++ had fewer problems, but reading and writing to the Registry via API calls was not simple. Fortunately, the .NET framework solves that problem. In the Microsoft Win32 namespace, you'll find a Registry class that (as you might expect) wraps and simplifies access to the Registry. It's now child's play to read and write Registry values. Tip I recommend that you...

Adding and removing a Registry key

To add a Registry key to the deployment project, follow these steps 1. Open the Registry Editor by clicking the Registry Editor button in Solution Explorer of the deployment project, as shown in Figure 21-5. Figure 21-5 Registry Editor button in Solution Explorer You can remove a Registry key from the Registry Editor of the deployment project simply

Writing Registry keys

Creating and writing Registry keys is also accomplished using the RegistryKey object. Several methods in the RegistryKey class are useful when writing keys. Table 24-4 describes the purpose of some of the more prevalent members. With the new key in place, use the SetValue() method to specify the name of the value and the actual value. This example, stores text in the Success value and a DWord in the AttemptNumber value. After the values are set, it's best to close the key in case of a power outage or similar failure. At this point, the changes have been committed to the Registry. If you open RegEdit and navigate to the proper key, you should see the values shown in Figure 24-9. Figure 24-9 RegEdit reveals that your values have been saved. Figure 24-9 RegEdit reveals that your values have been saved.

Using the Windows Registry

The Windows registry is a general-purpose mechanism that applications (and Windows itself) use to store program information that must be retained when an application terminates. The information is stored in a hierarchical format. You can use the Registry Editor program (Regedit.exe) that comes with Windows to examine (and, if you're very brave, even modify) the contents of the registry on your machine. The information in the registry is organized by keys, which are often written in the syntax of directory paths. For example, in the Registry Editor, you can find the key The Windows registry is supported with two classes in the Microsoft.Win32 namespace. The Registry class consists solely of seven static read-only fields for the seven possible root keys in the registry. The Description column shows how these root keys are defined in the Win32 header files and displayed in the Registry Editor You then obtain another RegistryKey object by combining that registry key with a subkey argument...

Enumerating Registry keys

Enumerating Registry keys is a lot like the Find Files feature in Windows. It enables you to scan from any point in the Registry and retrieve all subkeys and values below that starting point. No methods are currently incorporated into .NET to enumerate Registry keys it is up to you to build functions to support your needs. Knowing the structure of the keys you want to enumerate makes things much easier, as you can simply use a loop. If the structure of the Registry entries is unknown, you have to create a function that can call itself and pass the starting key in each time it is called. Listing 24-14 is an example of enumerating Registry keys. In this example, you scan the Registry for a list of all software installed on the computer. This program lists any application that shows up in the Add Remove section of the Control Panel. Listing 24-14 Enumerating Registry Keys When you iterate through each key, you search for a value called DisplayName. This DisplayName value is the name that...

Reading Registry keys

To read a Registry key, you must use the RegistryKey object. To begin exploring this object, examine Listing 24-12, an application that retrieves two pieces of information from the Registry. ClassesRoot defines the types of documents and the properties associated with those types. This field starts in the Windows Registry from the key HKEY_CLASSES_ROOT. CurrentConfig contains information pertaining to your computer's hardware. This field starts in the Windows Registry from the key HKEY_CURRENT_CONFIG. All preferences for the current user are stored here. This field starts in the Windows Registry from the key HKEY_CURRENT_USER. LocalMachine contains configuration information for the computer. This field starts in the Windows Registry from the key HKEY_LOCAL_MACHINE. The base key stores performance-related information about the different software components. This field starts in the Windows Registry from the key HKEY_PERFORMANCE_DATA. This base key contains information that will be...

The Windows Registry

Change the registry key under which our settings are stored. Change the registry key name to something more meaningful to you. Say your program is called Howdy . exe make it read The Howdy Company. Compile and run the program. A registry key gets created for The Howdy Company, and a subkey for the program Howdy gets added below it. Follow these steps to check the entries 1. Run regedit.exe. You won't find regedit in any of your Start Menu programs. Wisely, Microsoft keeps it out of public view. To run regedit, select Run from the Start Menu. Type regedit in the dialog box, and click the OK button. Opens a registry key using default security values. Fails if the key does not exist. Opens a registry key using security mask provided by the calling function.

Registry Editor

You may want to access the Registry and set values of existing Registry keys or add new Registry keys to the target computer. The Registry Editor enables you to add your own Registry keys and their values to a deployment project. When you execute the deployment project, the Registry keys are added to the Registry of the target computer. When you open the Registry Editor, it displays a standard set of keys, which correspond to the keys in the Windows Registry of the target computer. Figure 21 -4 depicts the Registry Editor. Figure 21-4 Registry Editor

Versioning Hell DLL Hell

If any of these application dependencies are broken, the application won't function correctly, or, worse still, your application can break at run-time halfway through some important operation due to missing dependencies. Many components are also dependent upon system-wide DLLs shared by many applications, and the system registry. It is very easy today to break applications by simply installing another application, or accidentally changing the registry using a tool like Regedit. Tracking these problems down can be a very difficult task, if not impossible.

Microsoft Intermediate Language and Metadata

Metadata provides a means for all of an application's information to be stored in a central location. Developers who write COM+ applications with an earlier version of Visual Studio store an application's information in a variety of locations. A component's type library stores information about the components, their methods, and interfaces. The Windows registry and the COM+ Catalog store information about where the dll is located and how the COM+ runtime must load and activate the component. In addition, other files may be used to store information that the component needs at runtime. This dislocation of information results in confusion for developers and administrators. Visual Studio .NET attempts to resolve this problem by using metadata to describe all of an application's dependencies.

Registering Your COM Servers

So much for your tour of the Windows registry. As mentioned, you will write your own registry scripts (*.reg files) that can be used to merge your server information into the registry automatically, bypassing the need to code DllRegisterServer() by hand. Thus, insert a new *.txt file and save it under the name RawComServer.reg. REGEDIT

You need to implement security in the assembly What should you do

Implement declarative security and execute the permission demand to allow access to the file system and Windows registry. B. Implement declarative security and execute the minimum permission request to allow access to the file system and Windows registry. C. Implement imperative security and execute the permission demand to allow access to the file system and Windows registry. D. Implement imperative security and execute the minimum permission request to allow access to the file system and Windows registry.

Global Assembly Cache

Assemblies that are installed in the Global Assembly Cache are similar to COM components the components cannot be accessed except through a single controlling force. In the case of assemblies, this is the Global Assembly Cache, whereas in COM it was the Windows registry.

Interface Tool for Java constraints with regard to NET

.NET assemblies do not normally implement IDispatch interfaces, but their interfaces can be represented by IDispatch interfaces. Fortunately, the .NET SDK provides a utility called tlbexp.exe which, with the correct directives, can be used to generate type information which can include an IDL definition of IDispatch interfaces. When this type of information is correctly registered in the Windows registry, the .NET runtime will automatically provide a fa ade to the .NET assembly for IDispatch clients (in this case, the Interface Tool for Java runtime is the IDispatch client). This is illustrated in Figure 6-8.

Delete Settingappname section[ key

This function deletes a section or key setting from an application's entry in the Windows Registry. Its arguments are the same as the ones by the same name of the SaveSetting function except for the last one (the key's setting). If the last argument is omitted, then all the keys in the specified section are deleted. To remove the two keys added with the sample statements in the previous entry, use the following statements

Retrieving Connection Strings Programmatically

If you are creating a desktop application, or you are moving your web application from the development server to the production server, you can't define a connection string directly in your code pointing to a specific path or to a specific server. The Windows operating system offers a centralized way to store and to retrieve general information on your application the Registry. You can use the Registry during the application installation process to store the correct path and filename of your database or the correct server name where your database is running. The examples in this chapter, before connecting to the database, have to retrieve the connection string from the Windows Registry, which they do simply by using the methods offered by the .NET framework. The Microsoft.Win32 namespace contains every method and property needed to manage registry entries effectively. Let's imagine that our installation program has added the following entry to the Windows Registry The RegistryKey...

Consuming Classic COM with NET

Note When you select the COM tab, it may take several seconds to query the Windows Registry to build a collection of available COM components. All components within a .NET project are found within the same directory, thus eliminating the need to register its location with the operating system. Classic COM, on the other hand, depends solely on the operating system to expose both its location and interface. When a classic COM component searches for another component, it does so through the Windows Registry.

Global Assembly Cache GAC

By default, assemblies are not shared. When one assembly is dependent on another, the two assemblies are typically deployed into a single application directory. This makes it easy to install and remove an application. To install an application, simply create the application directory and copy the files into it. To delete the application, just delete the application directory. The Windows Registry is not used at all.

Registering Assemblies with COM

When the Assembly Registration Tool registers an assembly with COM, it makes all the necessary entries for classes and the type library into the Windows registry. The regfile switch of the Assembly Registration Tool is used to save the resulting registry entries to a file. This file can be copied to other machines that need the assembly registered with COM. Using the CDog class defined in the preceding code, the Assembly Registration Tool yields the following registry file. Note that when this switch is used the registry entries are not made to the Windows registry. REGEDIT4 Finally, notice a brand new registry entry for the assembly. The Assembly registry key tells MSCorEE.dll which assembly is implementing the class the ProgID identifies. The assembly's version and locale is also present in the registry. This information is passed to the .NET assembly resolver at runtime to ensure that the proper assembly is located.

For Visual Basic 2005

The RegistryKey class methods provide the means by which to add, delete, or change subkey values within the registry. There are equivalent .NET registry method calls for the most common operations performed using the Windows registry API functions. For example, if you used the RegCreateKey, RegOpenKeyEx, or RegDeleteKey API calls, you can now use the RegistryKey class methods CreateSubKey, OpenSubKey, or DeleteSubKey respectively. These .NET methods offer the same functionality as their API counterparts and are easier to use.

Early and Late Binding

Early binding, often referred to as strong typing, refers to explicitly declaring the class used to define a variable. Early binding has several benefits. For example, when programming, Visual Studio .NET can give access to the class's interface with Intellisense which greatly reduces potential for typos and promotes rapid development. Also, when early binding a class, the Visual Basic compiler can enforce the proper use of a class's interface by providing warnings and refusing to complete the compile until the error is resolved. But performance gains are probably the most important reason to bind early Early binding allows your program to access your class's interface directly, rather than through the Windows Registry or at runtime. If the compiler knows ahead of time which classes you will be using in your application, it can make the appropriate compilation optimizations.

CPuttingthe Application Together

The .NET Framework dramatically improves this situation. Because .NET assemblies can run independent of the Windows Registry thanks to metadata and versioning, a much simpler installation mechanism is possible. A single Windows Installer package can contain all the files required for a particular application machine.

Problems With Traditional

ASP runtime may keep objects loaded in memory, updating a COM component can require shutting down the web server (IIS) and possibly re-registering the component with the Windows Registry. This scenario is unacceptable for large, high-traffic web applications where reliable service is paramount.

Creating And Deploying Distributed Applications

The .NET platform addresses the DLL Hell issue with assemblies. Assemblies enable you to register more than one version of the same component on the same machine. Note that the word register does not mean using the Windows Registry. When you register a version, the version resides in the machine's Global Assembly Cache, or GAC. Items in the GAC are shared assemblies that multiple clients can use. Assemblies that exist in the GAC have a version number assigned to them. When a client calls for a component, the GAC assists in matching the client component request with the correct version of the component, not just the last installed version. With the capability of Global

Introducing Windows Forms

In current Windows application development, if you use COM, DCOM, or ActiveX components, deployment of your application requires extensive configuration. You would probably at least use the regsvr32 utility to register and unregister components from the Windows Registry on the client machine. All these setup-related deployment tasks are eliminated by Microsoft .NET by Windows Forms in particular. Now, all you have to do to install an application is copy the executable onto the client machine.

Registering the COM Server

The registry is a local system database, which specifies (among other things) all the COM-centric information for a given computer. You may access the Registry Editor by running regedit.exe from the Run command. The registry is broken into a series of topmost nodes called hives. The most important hive for COM developers is HKEY_CLASSES_ROOT (abbreviate to HKCR). Figure 2-15 illustrates the hives found on a Windows XP Professional installation. Figure 2-15 The core COM hive (HKCR) Entries under a hive are called keys, which may contain subkeys. A given key or subkey may contain string or numerical values. Entire books have been written about the layout and programming of the Windows registry luckily COM developers only need to understand a small subset of its overall functionality, beginning with the ProgID.

Save Settingappname section key setting

These values should be saved to the Registry when the application ends, and they should be read when it starts, to place the form on the desktop. You can start the Registry Editor utility (select Start Run and type regedit) and search for the string MyApp. When the corresponding branch in the Registry is found, you will see how the keys Top and Left were stored there.

Common Debugging Question My boss is sending me so much email that I cant get anything done Is there any way I can slow

If your boss is currently in the office, explain that you need to run a utility on his machine so that he can access the XML Web services you're building. (It doesn't really matter whether you're creating XML Web services the buzzwords alone will cause your boss to readily let you mess with his machine.) 5. Close REGEDIT.EXE.

Common Debugging Question Are there easier ways of debugging addins since they can load into the IDE that youre using

Debugging an add-in can be a huge pain because you have to remove the add-in's registry key, open the add-in project in the target IDE, and restore the add-in keys so that spawned instances of the IDE you want to debug will have everything set up. Though not too onerous a task, you can easily mess these steps up. Additionally, if you need to compile the add-in because you fixed a bug, and the add-in gets loaded by the IDE, your build will never work Fortunately, there's an undocumented command-line switch, rootsuffix, that comes to the rescue. What rootsuffix does is tell Visual Studio .NET to append a suffix to the normal registry key and load all packages, add-ins, and settings from that registry key instead of from the default. It's almost like having two separate installs of Visual Studio .NET on your machine. The first thing you need to do is start up REGEDIT.EXE and scoot to the key After selecting the key, select Export from the File menu and save the registry keys to a file....

Exporting Type Information

Library should use this specific assembly whenever possible. If you choose, you can also export a regedit file with information about the components in an assembly using the regfile switch on regasm. However, be aware that this file will not generate registry information about interfaces (because if interfaces need registry entries, they are type library marshaled) or about type libraries (because it cannot guarantee that a type library has been generated).

Importing an existing Registry

The Registry Editor also enables you to import a complete Registry, thereby saving the time and effort required to create the same keys and values in a deployment project. You can import an existing Registry by following these steps 1. Select the Registry On Target Machine node in the Registry Editor.

Manage the Registry Settings Required by Your Application

For your application and components to function correctly, they might rely on certain registry keys and values being present on the target computer. You can deploy these keys and values as part of your installer. Registry keys can be added to a deployment project using the Registry Editor. To open the Registry Editor If a key doesn't exist in the registry of a target computer, it will be added during installation. Keys can be added beneath any top-level key in the Registry Editor. For instructions on how to add registry keys to your projects, see Adding and Deleting Registry Keys in the Registry Editor on MSDN (http library The Registry Editor can be used to specify values for new or existing registry keys in the registry of a target computer. You can add string, binary, and DWORD values. The values are written to the registry during installation. The values you specify overwrite any existing values. You can also use the Registry Editor to specify a default value...

Case Scenario 2 Installing the Document Core

By creating a setup project to install the document core, you can create a setup environment that accomplishes all of these goals. Directory structures can be defined in the File System Editor, and registry keys can be created through the Registry Editor. You can check for prerequisites in a custom action and, if they are not found, use the custom action to either install the prerequisites, if possible, or throw an InstallException to abort installation if it is not possible to install them.

Adding and removing Registry values

You can add values to the existing or newly added keys by using the Registry Editor. When you install the application, the Registry key value will be written to the Registry of the target computer. You can assign a string, binary value, or DWORD value to a Registry key. To assign a value to a Registry key, follow these steps 2. Select Action New. Click the String Value, Binary Value, or DWORD value option based on the type of value that you want to assign to the Registry key. 3. Press F4 to switch to the Properties window and type the value for the Registry key in the Value property. You can delete a Registry key value by selecting the value from the Values pane of the Registry Editor and selecting Edit Delete.

Manage Your Setup Routines

Microsoft Windows Installer is an installation and configuration service that ships as part of Windows 2000, Windows Millennium Edition (Me), and Windows XP. It is also available for Windows 95, Windows 98, and Windows NT 4.0. Windows Installer is based on a data-driven model that provides all installation data and instructions in a single package. With Windows Installer, each computer maintains a database of information about every application that it installs, including files, registry keys, and components. When an application is uninstalled, the database is checked to make sure that no other applications rely on a file, registry key, or component before removing it. This prevents the removal of one application from breaking another.

Using the Launch Conditions Editor

The Launch Conditions Editor allows you to set conditions to be evaluated when the installation begins on the target machine. If the conditions are not met, the installation stops. For example, let's say you would like to install your Visual C .NET application only if the .NET Framework exists on the target machine. This condition is added by default by Visual Studio .NET. You might also need to perform other checks such as whether a particular file exists on the target machine or verify a particular Registry key value on the target machine. The Launch Conditions Editor allows you to perform searches on target machine for a file, Registry key, or Windows Installer components. For example, you can determine whether Microsoft Data Access Components (MDAC) is installed on the target machine by making a search in the Registry for the particular Registry key value (refer to Figure 13.20). You can add conditions to be evaluated for the search performed on the target machine. If the...

Rules at a Glance

Section can contain a relative path (similar to that used to describe the folders on a hard drive) to navigate from the application key to the subkey to be deleted. For example, to delete the value entry named TestKey in the registry key HKEY_cuRRENT_USER Software VB and VBA Program Settings RegTester BranchOne BranchTwo, you would use DeleteSetting RegTester, BranchOne BranchTwo, TestKey You cannot use DeleteSetting to delete entries from registry keys that are not subkeys of HKEY_CURRENT_USER Software VB and VBA Program Settings.

Design Your Application Carefully if You will Implement Sideby Side Shared Assemblies

You need to ensure that your installs (and uninstalls) work as expected. For example, if you create a registry key during the install of an assembly, and then design a second version of that assembly that also requires the registry key, you need to determine how install and uninstall routines should behave with respect to the registry key. For this example, you want to ensure that the registry key is not removed if either assembly version is uninstalled, because this will break the remaining version. You will also want to ensure that side-by-side execution works properly. For example, if multiple versions of an assembly rely on a registry key or any shared resource (such as a file, directory, and so on) and both versions are executing side-by-side, you will need to determine how the assemblies affect each other. Put simply, you will need to ensure that changes to shared resources by one version of the assembly will not adversely affect the other version(s).

Accessory Files Required DLL Files

The hit count data file contains the current hit count for every page for which the Page Counter object is being used. Microsoft suggests that you do not modify this file by hand. However, doing so does not adversely affect the page counter's functionality unless the format of the entries is changed. The name and location of this file is specified by the File Location value entry in the registry key HKEY_CLASSES_ROOT MSWC.PageCounter. The default name for this page count file is hitcnt.cnt. Note that the Page Counter object will save the current hit count for a page if the count rises above a certain number. This number is located in the Save_Count value (under the same registry key as the File_Location value). The default number for this setting is 25.

Uninstallation Instructions

To uninstall BizTalk Server 2000, simply click Remove within Control Panel Add Remove Programs.This uninstallation does not require input and removes almost everything that it installed. However, it will leave some remnants. For example, the installation uses the XML parser version 3.0 after the uninstall, this parser remains. In addition to OS upgrades that are within the system directory, it also leaves some files in its installation directory and miscellaneous Registry keys.These leftovers are documented here for your convenience. After doing several installations and uninstallations while using the Sysdiff tool to trace down what is left over, we have found that literally thousands of lines in the Registry remained, all referring to the components that are added to the system root or program files common files directories. If you want to attempt to remove BizTalk Server 2000 from a system, leave most of those lines alone only a small number of items specific to BizTalk Server will...

Setting Up SQL Server 2000 Fail Over Clustering

The name you provide for the virtual SQL Server instance must be unique and must not be the same as any instance names used on the member servers. This is because SQL Server 2000 depends on distinct registry keys and service names within the cluster to smoothly continue after a fail-over.

Demanding Permissions

Using the declarative syntax when making a permission demand is preferable to using the imperative syntax, because the latter might result in more stack walks.There are, of course, cases that are better suited for imperative permission demands. For example, if a Registry key has to be set under specific conditions, you will perform an imperative RegistryPermission demand just before the code is actually called.This also implies that the caller can lack this permission, which will result in an exception that the code needs to handle accordingly. Another reason why you want to use imperative demands is when information is not known at compile time. A simple example is FilelOPermission on a set of files whose names are only known during runtime because they are user related.

Loading the Common Language Runtime

You can tell if the .NET Framework has been installed by looking for the MSCorEE.dll file in the windir system32 directory. The existence of this file tells you that the .NET Framework is installed. However, several versions of the .NET Framework can be installed on a single machine simultaneously. If you want to determine exactly which versions of the .NET Framework are installed, examine the subkeys under the following registry key

Fixing the AddIn Wizard Generated Code

The very first task you need to do after clicking the Finish button in the Add-In wizard is open the Registry Editor. The Add-In wizard creates some registry entries you need to export to a .REG file. The registry key starts at either hkey_local_machine or hkey_current_user depending on whether you wanted the add-in available to all users. Two registry keys that are not in the default Add-In wizard-generated code, but which you'll be adding if you want to have your own command bar bitmaps or other Win32 resources, are SatelliteDllName and SatelliteDllPath. Although having your managed bitmaps and resources work in managed add-ins would be quite convenient, Visual Studio .NET speaks only COM, so you'll have to put your resources in Microsoft Win32 resource DLLs. As you can guess from its name, SatelliteDllName is only the filename of the DLL. The other value, SatelliteDllPath, indicates where the satellite DLL resides. The documentation for SatelliteDllPath indicates that the IDE will...

Client Globalization Support in Oracle Data Provider for NET

Oracle Data Provider for .NET enables applications to manipulate culture-sensitive data, such as ensuring proper string format, date, time, monetary, numeric, sort order, and calendar support using culture conventions defined in the Oracle Database XE. The default globalization settings are determined by the client's NLS_LANG parameter, which is defined in the Windows Registry of the local computer. When the OracleConnection call Open() establishes a connection, it implicitly opens a session with globalization parameters specified by the value of the NLS_LANG parameter. Client globalization settings derive from the Oracle globalization setting, NLS_LANG, in the Windows Registry of the local computer. The client globalization parameter settings are read-only and remain constant throughout the lifetime of the application.

The Global Assembly Cache

Important Globally deploying assembly files into the GAC is a form of registering the assembly, although the actual Windows registry isn't affected in any way. Installing assemblies into the GAC breaks the goal of simple application installation, backup, restore, moving, and uninstall. So really, you get only the simple story when you avoid global deployment and use private deployment exclusively.

You develop a Windowsbased order entry application Test KingEntry by using Visual Studio NET Test KingEntry includes a

You use Visual Studio .NET to create an application TestKingTestEngine that will be deployed to several client computers. You plan to create a setup package to distribute TestKingTestEngine. Because of licensing restrictions, you must ensure that the setup package can be installed only on computers that have a particular registry key. What should you do A. Add a registry key to the setup project. Set the Transitive property of your key to True. B. From the Properties window, set the private key file option to the registry key. C. From the Launch Conditions window, add a search for the registry key. Add a launch condition to evaluate the search results. D. Open the setup project source code in Visual Studio .NET. Add code to search for the registry key and to abort the setup of the registry key does not exist on the client computer. Recompile setup1.exe and include it with your setup package. A The Transitive property cannot be used to stop the installation process if a registry key is...

Demonstration Wrapping a Legacy COM Server

You can now see the registration entries using the Registry Editor (regedit.exe) or the OLE COM Object Viewer (oleview.exe). The latter program is provided on the Tools menu of Visual Studio.NET. It groups related registry entries together, providing a convenient display. You can also perform other operations, such as instantiating objects. Figure 14-3 shows the entries for the Account2 class that is implemented by this server. We have clicked the little + in the left-hand pane, which instantiates an object and queries for the standard interfaces. You can release the object by right-clicking over the class and choosing Release Instance from the context menu.

Application Compatibility Toolkit

After you've installed ACT, open a command prompt and navigate to the < ACT installation directory> Applications directory. You'll need to register the AppVerifier add-in DLL with regsvr32 vsappverif.dll so that the COM components are in the registry. The next step is to tell Visual Studio .NET 2003 about the add-in. In the AppVerifierAddln directory with this book's sample files is a .REG file named AppVerifierAddlnReg.reg.REG. You can either double-click the .REG file from Windows Explorer or execute it with regedit This test monitors the application's use of the system registry for any inappropriate or dangerous calls. Any problems detected will be logged. This test helps to ensure future compatibility for applications because it checks for the usage of specific registry keys that might be dropped or changed in future versions of the Windows operating system.

The Important Extension Commands

Registry key In the preceding discussion I mentioned using lhandle to view event states so that you can deduce why your application is deadlocking. Another wonderful use of lhandle is to keep an eye on a potential resource leak. Since lhandle shows you the complete count of all current handles in your process, you can easily compare before and after lhandle snapshots. If you see the total handle counts change, you'll be able to tell exactly which type of handle was leaked. Because much of the detailed handle information is displayed, such as registry keys and the name of the handle, you can easily see exactly which handle you're leaking.

You need to add code to your application to set up the parameter for use with the stored procedure Which three lines of

You use Visual Studio .NET to create an application that will be deployed to several client computers. You plan to create a setup package to distribute your application. Because of licensing restrictions, you must ensure that the setup package can be installed only on computers that have a particular registry key. A. Add a registry key to the setup project. Set the Transitive property of your key to True. B. From the Properties window, set the private key file option to the registry key. C. From the Launch Conditions window, add a search for the registry key. Add a launch condition to evaluate the search results. D. Open the setup project source code in Visual Studio .NET. Add code to search for the registry key and to abort the setup of the registry key does not exist on the client computer. Recompile setup1.exe and include it with your setup package. A The Transitive property cannot be used to stop the installation process if a registry key is missing. It determines whether the...

Automatically Starting in a Debugger Image File Execution Options

The best way to set up automatic debugging is to manually set the option with the registry editor. In the NT CurrentVersion lmage File Execution Options key, create a key that is the same as your application's filename. For example, if your application is FOO.EXE, your registry key is foo.exe. In your application's registry key, create a new string value named Debugger. In the Debugger value, type the complete path and filename to your debugger of choice.

Verbatim String Literal

Verbatim String Literals are very useful for situations in which you want to specify a path, either to a registry key or file, and when you are parsing data that may contain characters that normally would require an escape character to specify for example, parsing XML, or HTML documents.

Launch Conditions Editor

Your application may be dependent on several factors, such as availability of files, the version of the operating system on the target machine, and Registry keys. Therefore, you might want to ensure that the version of the operating system on the target computer is appropriate for running your application or search the target computer for the existence of a particular file or a key in the Registry. You can perform these tasks by using the Launch Conditions Editor. Figure 21-14 depicts the Launch Conditions Editor in a deployment project. To search for the existence of a specific Registry key or value, you can add a Registry search in the Launch Conditions Editor by using the following procedure 3. Select the Properties window. If you want to search for a Registry key on the target computer, set the Root and RegKey property values to the key that you want to search. If you want to search for a particular value in the Registry of the target computer, specify the value to be searched in...

Licensing Custom Controls

Licensing in the .NET world is far more customizable and far less painful than it is with older component technologies like COM. The .NET Framework provides several licensing classes in the System.ComponentModel namespace. By using and extending these classes, you can grant or allow access to your control, using ordinary .NET code to check external resources like the Windows registry, an XML file, or even a remote Web service for registration information. The license. This is an object that contains the licensing information. You might create it based on the information in a license file, a registry key, a piece of hardware, or something entirely different. However, this is the programming abstraction that your licensing code will evaluate. You can create a custom license class by deriving from System.ComponentModel.License.

DDeploying NET Applications on Application Center 2000 Clusters

Application Center 2000 applications are still very useful for propagating any registry keys utilized by the application, or any DSNs needed by each machine that exist on the cluster controller. In our case, we have compiled the proper database connection strings into our application files, so we will not need to use the local resource propagation features of Application Center 2000. If we were using these features, items such as registry keys and DSNs would be bundled with an Application Center application as local resources, and would also be propagated to other cluster members. Data Sources File System Paths Registry Keys

Converting Assemblies to COM Type Libraries

The .NET SDK comes with two tools that can be used to generate type libraries from assemblies the Type Library Exporter (tlbexp.exe) and the Assembly Registration Tool (regasm.exe). The Type Library Exporter takes an assembly as input and produces the corresponding type library as output. The Assembly Registration Tool also produces a type library from a .NET assembly and registers the type library and its COM classes in the Windows Registry. Because we are concerned with more than just creating type libraries, let's focus on the Assembly Registration Tool. Prevents the normal COM registry entries from being entered into the registry. The RegFileName.reg contains the entries that would have gone into the Windows Registry.

The Solution Explorer

Figure 1-4 also shows that the project does not contain an app.config file by default. Most experienced ASP .NET developers are familiar with using web.config files. app.config files work on the same principle in that they contain XML, which is used to store project-specific settings such as database connection strings and other application-specific settings. Using a .config file instead of having your settings in the Windows registry enables your applications to run side-by-side with another version of the application without the settings from either version affecting the other. Because each version of your application resides in its own directory, its

Declarative and Imperative Security

The second method is imperative security, which becomes a part of your code and can make permission demands and overrides. It is not possible to request permissions using imperative security, because that makes it unclear at what point a specific permission is needed and at what point it is no longer needed.That is why permission requests are related to identifiable units of code.You might want to use imperative security to check if the caller has a permission that is specific for a part of the code. For example, just before a conditional part of the code (this might even be triggered by the role-based security) wants to access a file or a Registry key, you want to check if the caller has this FileIOPermission or RegistryPermission. The VB.NET syntax of the imperative security in code looks like this

Common AppData Registry

The RegistryKey class is a part of the .NET Framework and is available in a namespace called Microsoft.Win32. It represents a specific key in the Registry and contains methods that enable you to create subkeys, read values, and perform other work related to Registry keys.

Robust Windows

Applications no longer rely on storing extensive configuration data in the fragile Windows Registry. .NET applications are self-describing, containing metadata within the program executable files themselves. Different versions of an application or component can be deployed side-by-side. Applications can share components through the Global Assembly Cache. Versioning is built into the deployment model. A straightforward security model is part of .NET. Windows Forms technology is a new paradigm for building Windows GUI applications.

Figure 1314

You can add Registry keys and values on the target Web server by specifying them in the Registry Editor of the Web Setup project. extra careful when working with the Windows Registry. Take special care with the DeleteAtUninstall property of the Registry Settings Properties. If you end up setting DeleteAtUninstall to true for a wrong key (such as HKEY_LOCAL_MACHINE SOFTWARE), it might have very bad consequences on the target computer.

What Is COM

All the information about COM objects and their interfaces is stored in the Windows Registry using these GUIDs to identify them. If you are interested and know how to use the Registry, you can see all the COM object information by using RegEdit or RegEdt32 to browse the HKEY_CLASSES_ROOT Registry hive.

Know Your User

Different audiences require different degrees of assistance. The user browsing quickly and effortlessly through the intricacies of the Windows registry with regedit.exe is not the same user who turns to Microsoft Agent for help creating a graph. If you are designing a professional application for a specific audience, it may help you to begin by creating a profile that clearly identifies the abilities, expectations, and computer comfort level of the end user.

Object Instantiation

Classic COM relied on the Windows Registry to store its exposed properties, methods, events, and enumerations a client application could only access these exposed interfaces through the Registry. As a result, the way you instantiate classes when using classic COM components in COM+ is very important. Visual Basic .NET accepts a number of instantiation methods without performance impacts, although all variables must first be diminished and then instantiated before they can be used. The two methods for instantiating classic COM are the CreateObject and New keywords. CreateObject uses the Windows Registry to obtain the interface of the class being instantiated. Because CreateObject depends on windows for access to the register, COM+ can apply a context for use by the COM+ services. The New keyword in classic COM also depends on Windows for access to the Windows Registry. The catch is that it doesn't always have to access the Windows Registry to discover a class's interface if the class...


Note that we have not included any registry entries for the gasTIX setup application. We are able to do this by saving the relevant arguments entered by the user at installation time to an XML file called gasTIXInstall.InstallState, located in the Setup folder. This is standard practice for .NET installations, as dependence on the Windows Registry for custom applications is being phased out.


Applications have settings that need to be stored someplace. These are settings that rarely change but are not appropriate to be compiled into an application. For .NET programming, developers are accustomed to app.config and web.config files as well as the Windows Registry. The iPhone operating system allows for the storage of settings in a special file. The file is the root.plist file. The steps to create the file and have it work in the iPhone are

Private Assemblies

In the past, DLLs were installed on a machine and an entry was made in the Windows Registry. It was difficult to avoid corrupting the Registry, and reinstalling the program on another machine was nontrivial. With assemblies, all of that goes away. With private assemblies, installing is as simple as copying the files to the appropriate directory. Period.

The Manifest

Part of the assembly includes a manifest which holds information about the assembly. This self-describing method of the assembly allows for easy deployment through the use of the XCOPY command from the command line prompt. Historically, this type of metadata was stored in the Windows Registry and required the registration of every COM (Common Object Model) component. This is no longer necessary because the information is stored exclusively in the assembly manifest. Providing the ability to store all metadata within the assembly has an additional benefit. Because .NET assemblies no longer require a special installation to record metadata about the assembly in the Windows Registry, you can simply copy all .NET assemblies to a given location and run them. As a result, .NET assemblies can be run directly from a CD-ROM that, by its very nature, is readonly. This also means that complex installation programs are no longer needed. You can simply write a program that installs your .NET...

Threading Issues

To write efficient .NET applications that use COM objects, it is important to understand the threading differences between COM and .NET. The COM threading model uses the concept of apartments. In the COM world, processes are logically broken down into one or more apartments. Apartments can have a single thread running inside them or they can have multiple threads. An apartment with a single thread is called a Single Threaded Apartment (STA) an apartment running multiple threads is called a Multi-Threaded Apartment (MTA). When a COM client calls into the COM runtime to create a new instance of a component, the COM runtime reads the component's thread value from the Windows registry. The registry value tells the COM runtime which apartment model the component supports. Most components, including those Visual Basic 6 creates, are STA. Clients that run in different apartment models from their components must go through a proxy-stub pair to make method calls. The proxy-stub architecture...

CLR Hosting

When developing the CLR, Microsoft implemented it as a COM server contained inside a DLL that is, Microsoft defined a standard COM interface for the CLR and assigned GUIDs to this interface and the COM server. When you install the .NET Framework, the COM server representing the CLR is registered in the Windows registry just like any other COM server. If you want more information about this topic, refer to the MSCorEE.h C++ header file that ships with the .NET Framework SDK. This header file defines the GUIDs and the unmanaged ICorRuntimeHost interface definition.


Metadata makes the executables self-describing which opens up many possibilities for dynamic loading of objects and method calls at runtime.The metadata contains information for every element managed by the runtime along with the MSIL. This makes an assembly a complete deployable unit. Therefore, you have no need for the Windows registry.


In ASP, configuration settings for an application (such as session state) are stored in the IIS metabase. There are two major disadvantages with this scheme. First, settings are not stored in a human-readable manner but in a proprietary, binary format. Second, the settings are not easily ported from one host machine to another. (It is difficult to transfer information from an IIS's metabase or Windows Registry to another machine, even if it has the same version of Windows.)

Dialog Based Example

Close the registry keys. oSub.Close() The InRegistry() uses the simple technique of opening the application's registry entry. If oSub is null, then the registry key doesn't exist and the application isn't configured for use. On the other hand, if the registry key does exist, InRegistry() reads the contents of the TimeSet value and places them in TimeLeft. RegistryKey oReg Hive Registry Key RegistryKey oSub Company storage key. Close the registry key. oReg.Close() Close the registry keys. oSub.Close() The next task is to determine if the registry already contains settings for the control. If the registry doesn't contain the required entries, the application makes them, and then closes the registry key. The final step is to write the new timer value into the registry so that it's ready for the next time the user starts the application.


When a native application throws an exception, the system will start the default registered debugger (registered in the AeDebug registry key, as explained earlier) and allow the debugger to attach to the faulted application. When you install VS.NET, this debugger will be vs7Jit.exe, but most machines the machines that will be running your code will have Dr Watson (drwtsn32.exe) registered as the default debugger. Dr Watson will generate a crash dump by saving a copy of the memory used by the process at the point when the crash occurred. It will also generate a user-readable log file containing information about the threads that were running at the point of the crash, the contents of the stack, and the location of the fault. Dr Watson crash dumps can be loaded by the winDbg utility,171 which will load the crash dump and treat it as if it were the current state of the memory. The crash dump has full information about the modules that are loaded, and if the symbols are available you will...

Using the Registry

Registry Key Equivalent In the example shown in Listing 10.3, an instance of the RegistryKey class is created by using the Registry.CurrentUser field (giving the Registry key a starting value of HKEY_CURRENT_USER) To verify that this has all worked as planned, open the Registry Editor (by selecting Run from the Windows Start menu, and opening regedit in the Run dialog). Find the HKEY_ CURRENT_USER node, locate SybexCSharp, and make sure that the key and value have been written to the Registry (Figure 10.4). igure 10.4 Open the Registry Editor to verify that the key value pair has been written to the Registry.

Denying permissions

The code in Listing 37-4 uses a modified version of the preceding example to first deny a Registry permission. After the permission is denied, it attempts to read the Registry key, which results in a SecurityException. If you want to undo a Deny operation within code, simply use the RevertDeny() method to remove the permission denial and any further attempt to read the requested Registry key completes successfully.


If you have a specific COM registration requirement for the types in your assembly, you can provide a registration method. This is a static method that takes either a single Type or a string parameter, returns void, and is marked with ComRegisterFunction . If your version takes a string, then the runtime will pass a string giving the registry key path where the object is being registered it is in this format

Field Attributes

In the last example of querying members as to their attached attributes, we'll look at how to query a class's fields. Let's say you have a class that contains some fields the values of which you want to save in the Registry. To do that, you could define an attribute with a constructor that takes as its parameters an enum representing the correct Registry hive and a string representing the Registry value name. You could then query the field at run time as to its Registry key

Tweaking settings

The MTU is the maximum size of any packet sent over the wire. If it is set too high, lost packets will take longer to retransmit and may get fragmented. If the MTU is set too low, data becomes swamped with overhead and takes longer to send. Ethernet connections use a default of 1,500 bytes per packet ADSL uses 1,492 bytes per packet and FDDI uses 8,000 bytes per packet. The MTU value can be left as the default or can be negotiated at startup. The registry key in question is

Adding References

Creating a similar dialog requires a few steps. You need to iterate through the directories specified in two registry keys The version number of the second directory should pertain to the version of Visual Studio you're using. A sample of the contents of these registry keys is shown in Figure 3-6. ' Registry Editor Figure 3-6. Reference registry keys

Create Object

This value is found in the registry and represents how the component's DLL is registered there. Although it sometimes contains the DLL name, it often does not. For example, the DLL from which you instantiate the Ad Rotator object is adrot.dll. However, its ProgID is MSWC.AdRotator.1, as defined by the default value of the following registry key As you will note, this is the ProgID for the registered DLL and contains version information in addition to its registered name. Sometimes, however, you may have several different versions of the same DLL registered on your machine. In this case, you can use the default value of the VersionIndependentProgID registry key to instantiate the most recent version of the DLL. In our example (the ad rotator), the version-independent ProgID is MSWC.AdRotator.

Comparing Strings

When comparing strings or converting strings to uppercase or lowercase, you should usually use InvariantCulture. For example, use InvariantCulture when comparing and converting pathnames and filenames, registry keys and values, reflection strings, XML tags and XML attribute names, and any other programmatic strings. In fact, you should use a noninvariant culture only when you're comparing and converting strings that are to be displayed to the user in a linguistically correct manner. And, of course, the culture you use should match the user's chosen language and optionally the user's country.

Download Regserve Registry Cleaner Now

If you can not wait, then get Regserve Registry Cleaner now. Your Download will be instantly available for you right after your purchase.

Download Now