# Bind Class
The central piece of the BindingSystem is the `Bind` class. This class wraps the `T` type with the binding mechanism and provides the necessary functionality for serializing binding information. Additionally, it includes the `BindData` structure for storing the binding information. The `Bind` class allows for binding paths with different depths. For example, a float field can be bound to the path `"position.x"` of a Transform so that at runtime, it will have the value of x component of transform's position.
The `Bind` has an internal data pipeline when reading the data from the bound source or writing it to the source:
Default Bind Pipeline
There are several variations of the `Bind` class available:
* `ReadOnlyBind`: Allows read-only access to the bound value.
* `WriteOnlyBind`: Allows write-only access to the bound value.
* `BindDataFor`: Doesn't have a direct value field, must only bind to other sources.
These classes can be implicitly converted to the inner `T` type when needed.
To define a new `Bind` simply add a field or property as follows:
```csharp
class MyMonoBehaviour : MonoBehaviour
{
public Bind myBoundFloat;
public Bind myBoundAndInitializedFloat = 3.14f.Bind();
}
```
The above code will let users bind the properties directly in Unity's Inspector.
{% tabs %}
{% tab title="Minimal UI" %}
Inspector View of MyMonoBehaviour
{% endtab %}
{% tab title="Verbose UI" %}
Inspector View of MyMonoBehaviour
{% endtab %}
{% endtabs %}
The power of `Bind` type is in its drawer, which allows for a quick and easy binding process with an intuitive UI.
#### Binding with code
To create a new bound value in code simply call the constructor with specified target and path:
```csharp
void Start()
{
Object target = GameObject.Find("Sphere").transform;
myBoundFloat = new Bind(target, "position.x");
}
```
When accessing `Bind`'s value, simply use the `.Value` property or, in case of reading the value, ommit it altogether:
```csharp
void Update()
{
float value = myBoundFloat; // Here the implicit conversion is applied
value *= 2;
myBoundAndInitializedFloat.Value = value;
}
```
The `Bind` class and its variations (except `WriteOnlyBind`) can notify users when its value changes through its `ValueChanged` event:
```csharp
void Start()
{
myBoundFloat.ValueChanged += (oldValue, newValue) => Debug.Log("New Value is: " + newValue);
}
```
*Please Note*: `ValueChanged` is not called immediately when the underlying value is changed, due to security limitations (*an immediate version is available in experimental versions, to be released on demand*). All these events are processed at multiple points within the same frame.
For more expert users, the inner `BindData` structure can be used to create custom `Bind` classes. `BindData` stores all required information to access a bound value, as well as parameters for converters and modifiers.
---
# 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://postica.gitbook.io/binding-system/product/bind-class.md?ask=
```
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.
