An Assembly is a collection of compiled or executable components which versioned and deployed as single implimentation unit or An assembly is a collection of types and resources that forms a logical unit of functionality. All types in the .NET Framework must exist in assemblies; the common language runtime does not support types outside of assemblies. Each time you create a Microsoft Windows® Application, Windows Service, Class Library, or other application with Visual Basic .NET, you're building a single assembly. Each assembly is stored as an .exe or .dll file.
Note: Although it's technically possible to create assemblies that span multiple files, you're not likely to use this technology in most situations.
The .NET Framework uses assemblies as the fundamental unit for several purposes:
- Type Identity
- Reference Scope
An assembly is the unit at which security permissions are requested and granted. Assemblies are also the level at which you establish identity and trust.
The .NET Framework provides two mechanisms for this level of assembly security: strong names and signcode.exe. You can also manage security by specifying the level of trust for code from a particular site or zone.
Signing an assembly with a strong name adds public key encryption to the assembly. This ensures name uniqueness and prevents substituting another assembly with the same name for the assembly that you provided.
The signcode.exe tool embeds a digital certificate in the assembly. This allows users of the assembly to verify the identity of the assembly's developer by using a public or private trust hierarchy.
You can choose to use either strong names, signcode.exe, or both, to strengthen the identity of your assembly.
The common language runtime also uses internal hashing information, in conjunction with strong names and signcode, to verify that the assembly being loaded has not been altered after it was built.
The identity of a type depends on the assembly where that type is defined. That is, if you define a type named DataStore in one assembly, and a type named DataStore in another assembly, the .NET Framework can tell them apart because they are in two different assemblies. Of course you can't define two different types with the same name in the same assembly.
The assembly is also the location of reference information in general. Each assembly contains information on references in two directions:
The assembly contains metadata that specifies the types and resources within the assembly that are exposed to code outside of the assembly. For example, a particular assembly could expose a public type named Customer with a public property named AccountBalance
The assembly contains metadata specifying the other assemblies on which it depends. For example, a particular assembly might specify that it depends on the System.Windows.Forms.dll assembly.
Each assembly has a 128-bit version number that is presented as a set of four decimal pieces:
For example, an assembly might have the version number 184.108.40.206.
By default, an assembly will only use types from the exact same assembly (name and version number) that it was built and tested with. That is, if you have an assembly that uses a type from version 220.127.116.11 of another assembly, it will (by default) not use the same type from version 18.104.22.168 of the other assembly. This use of both name and version to identify referenced assemblies helps avoid the "DLL Hell" problem of upgrades to one application breaking other applications.
Assemblies are the natural unit of deployment. The Windows Installer Service 2.0 can install individual assemblies as part of a larger setup program. You can also deploy assemblies in other ways, including by a simple xcopy to the target system or via code download from a web site. When you start an application, it loads other assemblies as a unit as types and resources from those assemblies are needed.
The Assembly Manifest
Every assembly contains an assembly manifest, a set of metadata with information about the assembly. The assembly manifest contains these items:
- The assembly name and version
- The culture or language the assembly supports (not required in all assemblies)
- The public key for any strong name assigned to the assembly (not required in all assemblies)
- A list of files in the assembly with hash information
- Information on exported types
- Information on referenced assemblies
In addition, you can add other information to the manifest by using assembly attributes. Assembly attributes are declared inside of a file in an assembly, and are text strings that describe the assembly. For example, you can set a friendly name for an assembly with the AssemblyTitle attribute
Types of Assemblies:
- Private Assemblies
- Shared Assemblies
Private and Shared Assemblies: A private assembly is used only by a single application, and is stored in that application's install directory (or a subdirectory therein). A shared assembly is one that can be referenced by more than one application. In order to share an assembly, the assembly must be explicitly built for this purpose by giving it a cryptographically strong name (referred to as a strong name). By contrast, a private assembly name need only be unique within the application that uses it.
There are several reasons you may elect to build and use shared assemblies, such as the ability to express version policy. The fact that shared assemblies have a cryptographically strong name means that only the author of the assembly has the key to produce a new version of that assembly. Thus, if you make a policy statement that says you want to accept a new version of an assembly, you can have some confidence that version updates will be controlled and verified by the author. Otherwise, you don't have to accept them.
For locally installed applications, a shared assembly is typically explicitly installed into the global assembly cache (a local cache of assemblies maintained by the .NET Framework).
Global Assembly Cache:
GAC is a place where .NET DLLs are placed so that they may be shared across multiple applications. This provides developers a way to place their DLL once on a machine and have multiple applications using it without the fear of name conflicts or problems with different versions of the DLL. The Global Assembly Cache (GAC) enables you to share assemblies across numerous applications. The GAC is automatically installed with the .NET runtime.
Xcopy deployment describes deployment in ASP.NET where you use the drag-and-drop feature in Microsoft Windows Explorer, File Transfer Protocol (FTP), or the DOS Xcopy command to copy files from one location to another. The ASP.NET application requires no modifications to the registry and has no special installation requirements for the host company on hosted sites.
Advantages of XCopy deployment
An Xcopy-style file transfer simplifies the deployment and the maintenance of ASP.NET sites because you make no registry entries and because you register no components. The Microsoft .NET applications are self-describing, typically with no dependencies. With assembly versioning, you can even copy a new copy of a DLL that the application uses without stopping the Web server.
MSBuild.exe builds the specified project or solution file, with the specified options.
MSBuild.exe [Switches] [ProjectFile]
Example: How to make build using DOS:
C:\Windows\Microsoft.NET\Framework\cd v3.5> msbuild C:\YourProject\yourproject.sln