Dressing up our classes – Date with a model tonight!
Classes are in a sense behavior libraries. To initialize or configure them, we can use their properties. Serialization is a technic that helps distribute the state of our classes. In this post we will discuss how to serialize any class in the multi-layer XAF model! Then we finish with the model synchronizers which will control the class. Having a class or a part of a class serialized in the model makes it possible to continue development there without writing more code (declarative/runtime approach).
Runtime classes
In .NET is super easy to create runtime classes or interfaces. The following snippet will create a assembly with a Dynamic class.
var provider = CodeDomProvider.CreateProvider("c#");
var results = provider.CompileAssemblyFromSource(new CompilerParameters(), new[] { @"public class DynamicClass{}" });
Assembly compiledAssembly = results.CompiledAssembly;
Modeling
XAF’s super advanced and simple model technology is using interfaces for design and further extension. This is well documented How to: Extend Application Model. To serialize any class on the XAF model we simply need to use reflection, extract an interface from the class and extend any part of the model we want with it.
Let’s see a few examples using XAF build-in components.
1) GridListEditor
XAF’s GridListEditor is based on the GridView class which is a very sophisticated component with a lot of properties. Serializing it into the model allow us to control it from there. Using the model it is possible to work at runtime and since we have a lot of properties it is wise to serialize their help as well (see red arrow).
2) ChartListEditor
This is a very useful editor that also needs better control from our model. Note that this model serialization is reusable from all our projects!
This technic can boost our runtime experience and make it possible to work side by side with our customer building really fast. Furthermore it is applicable to any class or component. Let’s a few more interesting examples.
3) Repository Items
XAF’s DX PropertyEditors render DX controls which store their configuration in RepositoryItem classes. We can serialize all ReporitoryItem descendants and extend the IModelColumn. As a result by simply changing a model attribute we can do things at runtime that with a code approach would be very time consuming.
4) The SchedulerListEditor
5) The PivotListEditor
This one uses the same serialization approach however since this is a very useful editor we modeled a few extra behaviors – the pivot rules!. We would probably create a separate post about them.
Furthermore here we need to notice that we can model business meanings such as NetIncome, so for the following model modifications,
XAF will render the View bellow without any coding or dependency to any object!
Another example, when we talk about the TopObject meaning, we can model it like
and XAF will give us the following View again without writing not even one line of code (no code==no bugs)
Model synchronization
ModelSynchronizers can be used to:
a) set up an entity according to the configuration stored in the Application Model
b) Persists the configuration of an entity into the Application Model
Model’s nature makes it very abstract so since the attributes of the model are automatically generated from the properties of a class, its rather easy to do the opposite. Therefore we can write an abstract class that will implement IModelSynchronizable interface. The method SynchronizeValues is reading from any class and updates the model. The method ApplyValues is reading the values of the model and synchronize any class that properties match model’s attribute Ids.
protected void SynchronizeValues(ModelNode modelNode, object component, PropertyDescriptorCollection properties) {
foreach (var valueInfo in GetModelValueInfos(modelNode)) {
var propertyDescriptor = properties.Find(valueInfo.Name, false);
if (propertyDescriptor != null) {
var propertyValue = GetPropertyValue(component, propertyDescriptor, valueInfo, modelNode);
var modelValue = GetSynchronizeValuesNodeValue(modelNode, valueInfo, propertyDescriptor, valueInfo.PropertyType.IsNullableType(), component);
if (modelValue != null && !modelValue.Equals(propertyValue)) {
modelNode.SetValue(valueInfo.Name, propertyValue);
}
}
}
}
protected void ApplyValues(ModelNode node, object component, PropertyDescriptorCollection properties) { foreach (var valueInfo in GetModelValueInfos(node)) {
var propertyDescriptor = properties.Find(valueInfo.Name, false);
if (propertyDescriptor != null) {
var nodeValue = GetApplyModelNodeValue(node, valueInfo);
if (nodeValue != null) {
var propertyType = propertyDescriptor.PropertyType;
var propertyValue = propertyDescriptor.GetValue(component);
if ((!IsDefaultCoreValue(nodeValue, propertyType) || (!nodeValue.Equals(propertyValue))) && propertyType.IsValidEnum(nodeValue)) {
if (!nodeValue.Equals(propertyValue))
propertyDescriptor.SetValue(component, nodeValue);
}
}
}
}
}
Finally for each component we want to synchronize we create a descendant of the above implementation. For example,
AdvBandedListEditor
public class AdvBandedViewOptionsSynchronizer : ComponentSynchronizer<DevExpress.XtraGrid.Views.BandedGrid.AdvBandedGridView, IModelOptionsAdvBandedView> {
public AdvBandedViewOptionsSynchronizer(AdvBandedListEditor control)
: base(control.GridView, control.Model.OptionsAdvBandedView, ((IColumnViewEditor)control).OverrideViewDesignMode) {
}
}
ChartControlListEditor
public class ChartControlSynchronizer : ComponentSynchronizer<DevExpress.XtraCharts.ChartControl, IModelOptionsChart> {
readonly XafApplication _application;
We have discussed ways to model components into a distributable layer that describes a XAF. Even more we show how simple would be a model representation of business meanings (eg. NetIncome). It is clear that these tools are reusable from any project. We only need to feed XAF with a business domain and a few model modifications even in runtime to be able to have a working solution! A solution so rich in features that it is impossible to implement using the traditional approach.
The code and screen shots are taken from the XVideoRental application. This demo that can be found along with the other XAF demos in v12.2. Next posts will be about this new demo that really proves how XAF can save our time by lifting the development to the runtime!
P.S. If you are a facebook fun you can support us with a like for our new XAF page.
We are happy to read your feedback about this!. Remember that your questions are the best candidates for future posts.
Happy XAFing!
