---
title: "A: Dynamic and DynamicProxy"
description: "Dynamic Properties and the DynamicProxy Class. Dino Scripts™ are ideal for reporting. However, just returning a set of built-in objects is rarely enough to generate a report that will make sense to t…"
url: "https://support.wheelhousemfg.com/article/hc4el00kaa-a-dynamic-and-dynamic-proxy"
category: "Appendix A: Trestle®/Dino Script® Integration"
updated_at: "2020-12-22T20:53:30Z"
---

# A: Dynamic and DynamicProxy

### Dynamic Properties and the DynamicProxy Class

Dino Scripts™ are ideal for reporting. However, just returning a set of built-in objects is rarely enough to generate a report that will make sense to the end user. Database objects are by nature "normalized". Running a sales report with only **Sale** objects may show things like who the customer is, when the order was placed, etc., but will lack all the information about what items were purchased. In a normalized data structure, the items in a sale are stored in a separate table (thus in a separate object).

The .NET framework can be used for dynamic programming. While the .NET framework is a statically typed system, there are "syntactic sugar" allowances that give a very convincing impression of a dynamic, loosely typed system like Dino. For example, the following code will build (and run!) in C#:

```
namespace MyTests
{
    public class MyClass
    {
	public MyClass()
	{
	    dynamic d = new Trestle.DynamicProxy();
	    d.Name = "Jane Witherspoon";
	    d.Age = 34;
	    d.ThisIsCool = true;
	}
    }
}
```

The **DynamicProxy** class (in the **Trestle®** assembly and namespace) is an implementation of the .NET dynamic meta object system. In the code above, by declaring the variable as **dynamic**, the C# parser and validator know that they should not try to check for the existence of properties at compile time.

### How Dino Script™ uses DynamicProxy

The Dino language has a **dynamic()** function. The language has a provision for making this function pluggable, that is systems that integrate the Dino language can provide their own dynamic object, provided it meets the interface requirements for a dynamic class in the .NET framework. In the **ExpressionEvaluator** class in **Dino.Core**, there is this code to enable this behavior:

```
/// <summary>
/// Set this to return a certain type of dynamic.
/// </summary>
public Func<IDynamicMetaObjectProvider> DynamicFactory
{
    get;
    set;
}

/// <summary>
/// Do NOT return ExpandoObject for this! It will break
/// public indexing. By default this method creates a
/// <see cref="Dynamitey.DynamicObjects.Dictionary"/>.
/// </summary>
/// <returns></returns>
public virtual IDynamicMetaObjectProvider CreateDynamicInstance()
{
    return DynamicFactory?.Invoke() ??
	new Dynamitey.DynamicObjects.Dictionary();
}
```

As you can see from the return value, the default implementation of this is 1) first check to see if the **DynamicFactory** property returns anything, and if not then 2) return a dynamic object which is defined in one of the dependencies that Dino already uses. By doing this, we prevent Dino from needing to take another dependency simply to return a dynamic object implementation.

When Dino is used with Trestle, we inject the creation function into **ExpressionEvaluator** like this:

```
//...
ExpressionEvaluator.Current.DynamicFactory = () => new DynamicProxy();
//...
```