Private assemblies are usually backwards compatible, in that they must support all the functionality available in the previous version. When copying a new version of a private assembly to the client directory, if the application has a previous copy of the assembly, the new copy overrides the old copy, because a file directory cannot have multiple files with the same name. This, in turn, allows for different life cycles for the client and server, and allows both to evolve separately. Although during installation, client applications will typically deploy all their required private assemblies, nothing prevents copying over a new private assembly later on, as long as the version number is compatible with what the client application expects. Deploying a private assembly is as simple as copying it to the directory of the application using it. NET platform was to simplify component deployment and version control.NET supports two assembly deployment models: private and shared.Ī private assembly implies just that: each client application maintains its own private local copy of the assembly. Not surprisingly, one of the major goals set for the. In the past, the sharing solution of placing DLLs in global locations such as the System directory proved to be fatal in the end, resulting in the devil's alternative of either stifling innovation or suffering DLL Hell. Nonetheless, a mature component technology is required to allow multiple applications to share server components.Ī mature component technology should also allow different client applications to use different versions of the server components. Shared components are stored in some globally known location and are used by multiple applications. Shared components, on the other hand, can cause a lot of versioning headaches. Private components (components that reside in a location private to the application using them) are far less exposed to versioning issues, because each application comes bundled with its own private set of compatible components, and you have to explicitly intervene to cause incompatibility. Component versioning challenges are closely related to the component-sharing mode.NET supports two assembly deployment models: private and shared. NET must enforce version control, allowing for separate evolution paths and for side-by-side deployment of different versions of the same component.NET should also detect incompatibility as soon as possible and alert the client.Ī component technology must provide some sort of version control support, ensuring client applications have a deterministic way of always interacting with a compatible version of a server component. Client developers should be able to deploy new versions of the client application and expect it to work with older component versions. ![]() Component-oriented programming must allow for clients and components to evolve separately.Ĭomponent developers should be able to deploy new versions (or just defect fixes) of existing components without affecting existing client applications.
0 Comments
Leave a Reply. |
Details
AuthorWrite something about yourself. No need to be fancy, just an overview. ArchivesCategories |