# Bundle Library

The Bundle library contains all the model needed for an application to be compiled and executed properly, these models are used to replace the existing components within desktop components and controls into web versions of them.

The Bundle library is the one that provides the **Control Models**, **GUI Life cycle** mechanism, **Application State** mechanism, among others that are vital to keep the original application behavior in the **back-end** of the converted code.

## **Models**

A model is a CSharp class used to represent the data of a component or control, for each original control there is an equivalent model in WebMAP. An example of this is a in Windows Forms application a **System.Windows.Form** class gets replaced with **Mobilize.Web.Form** class, which is defined as part of the Windows Form’s DCP and acts as the new applications counterpart of the original component.

### **Application state**

The application state is known as the representation of the totality of everything needed for an application to be able to run, it is usually referring to the memory used specifically to allocated for a given program.

For a desktop environment the state of an application is commonly handled directly by a memory storage system (Windows Memory system, .NET Framework, Java Virtual Machine, etc.) which keeps allocated all its data during its whole execution in RAM memory, which means that for a given application all its data (class instances, static fields, objects, etc.) is been stored all at once while the application is been executed, however, for web application developed from scratch this is not the case, since they are commonly implemented as stateless, which means that between one a request/response and another no state is stored in memory.

![](/files/sCDq6qoUTTJA4EpJCiGU)

In order to bring a stateful application into a stateless architecture Mobilize has developed different mechanism:

* **Desktop Compatibility Platform (DCP):** is a set of libraries created to bring into a web application a compatible and equivalent behavior found in a legacy application developed in a desktop framework.
* **WebMAP.CoreServices**: a mechanism created to track down object references and map them into the application’s session in order to ensure that they are available between different request/response process.

The state of each model in a WebMap application needs to implement a tracking mechanism which is provided by the **WebMAP.CoreServices** library so it can adequately handle its reference count to ensure the object gets persisted in the application's current session. In order to do so the **Observable** and **Intercepted** attributes are used to mark model's classes and properties respectively.

* **Observable** attribute: used to mark a model class as Observable; this means that this class contains properties that need to be tracked down by the WebMap.CoreServices mechanism. Any object marked with an Observable attribute is called **Observable object**.
* **Intercepted** attribute: is used to mark a property as observable, this means that the WebMap.CoreServices will keep reference tracking of this object so it won't get removed by .NET framework during the garbage collection process. The interception mechanism is used by the **Mapper** mechanism as well, to ensure the property deltas are sent to the front-end only when they were modified, if a non-intercepted property is used in a mapper it will send its value to the front-end in every single request made. The use of intercepted properties has the following restrictions.
  * The attribute needs to be applied individually to each auto-property in an observable class. Properties that are not auto-properties (the get or set have any kind of implementation in them) cannot be marked as intercepted.
  * In order to work correctly the **Intercepted** attribute needs to be used in a class that is also has the **Observable** attribute, otherwise it won't work.
  * The type of the property needs to be a value type (int, long, string, bool, etc), another observable class or an object that has registered an **Observable Wrapper** or the WebMAP.CoreServices won't be able to keep track of it.

![](/files/PshtO7qLl26AmHLc1X3q)

The observable and intercepted attributes need to be applied to every class and property that needs to be persisted between two or more requests, this not only include DCP model but the actual application source code.

Original code:

```
public class SampleClass
{
    public bool SampleProperty { get; set; }
}
```

Converted code:

```
[Mobilize.WebMap.Common.Attributes.Observable]
public class SampleClass
{
    [Mobilize.WebMap.Common.Attributes.Intercepted]
    public bool SampleProperty { get; set; }
}
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.gapvelocity.ai/webmap/general/backend/dcp-desktop-compatibly-platform/library-bundles/bundle-library.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.