-
This post will be on how to use the approach described in Fast prototyping requires an initial data import mechanism with Excel as input source. The technic is based on System.Data.DataSet class and can be applied to any type of input source!
Thanks to your reports and of course Slava’s help (XPO guru), XVideoRental importing mechanism has been improved a lot and now is faster, has notification events and is decoupled from XAF’s TypesInfo system. This makes it possible to simply copy the ImportData.cs file found in Common.Win project and use it in non XAF solutions!
In previous version this importing mechanism worked only when matching in types of input and output members. This means that if my output Oid property was a System.Guid then input should be of the same type. Now we have workaround this minor issue. If conversion is possible it will be done automatically without the need of any configuration or extra coding!
To better design, support, extend and describe the importing mechanism I used Mspec a functional testing framework and I open source the specifications in our community project eXpandFramework. These follow bellow,
MemberMapper, When Class Has a flag that includes all members
» should collect all members that belong to the class
» should not collect any base class member
» should create new members for each one of them
MemberMapper, When class does not have a flag that includes all ownmembers
» should not create members for those not marked with the attribute
» should create members and name them according to the attribute data
» should create a key property if not included in the conficuration
MemberMapper, When class attribute has data for base members
» should create and name them according to the attribute data
» should map their attributes
MemberMapper, When class is marked to include all member but member is marked seperately
» should use the member marking
MemberMapper, When mapping a referenced member
» should create a member with a dynamic type ownwer
MemberMapper, When reference type is not includedIN the configuration
» should create non reference member
ClassMapper, When creating dynamic classes
» should Create Classes only for the ones that have a marking attribute
» should name the classes taking data from marking attribute
ClassMapper, When class has many to many collection marked for importing
» should create intermediate classes
» should create an auto genareted key for this class
» should create 2 columns with names taken from the marked attribute
DictionaryMapper, When is mapping a dictionary
» should map all marked objects
InitDataImporter, When importing an object
» should create a new output object
» should assign all mapped properties
InitDataImporter, When input membertype is different than output
» should convert the value when simple type
» should convert the value when reference type
21 passed, 0 failed, 0 skipped, took 1.61 seconds (Machine.Specifications 0.5.2-98b543c).
The above specifications are evaluated with every eXpand build and you can see them in eXpand’s build server. Take a quick look at their code located in github to see how easy it is to write them (http://goo.gl/TNv4d).
Now lets see how to use our magic XPO ORM to import into the real world business domain like the one of our XVideoRental demo,
For the sake of complexity the input source will be a list of excel files and not just a simple Excel file with many sheets.
XPO supports a DataStore provider which is based on DataSet. So, first we fill a DataSet with the excel files and for this I will use some DataSet extension methods I contributed to eXpand (see http://goo.gl/TF26g)
static DataSet DataSet() {
var dataSet = new DataSet();
dataSet.ImportExcelXLS(new[]{
"Customer", "Receipt", "Company", "CompanyType", "Country", "Employee", "Language", "Movie", "MovieArtist",
"MovieArtistLine", "MovieCategory", "MovieCategoryPrice", "MovieCompany", "MovieItem",
"MovieMovies_CountryCountries", "MoviePicture","Person","Artist","ArtistPicture","Rent"
});
return dataSet;
}
Now we are ready to create a UnitOfWork with this DataSet as DataStore like,
var inputUnitOfWork = new UnitOfWork(new SimpleDataLayer(new DataSetDataStore(DataSet(), AutoCreateOption.None)));
and finally call the Import method of the InitDataImporter class as shown bellow
var initDataImporter = new InitDataImporter();
var unitOfWork = OutputUnitOfWork();
var inputUnitOfWork = new UnitOfWork(new SimpleDataLayer(new DataSetDataStore(DataSet(), AutoCreateOption.None)));
initDataImporter.Import(() => new UnitOfWork(unitOfWork.ObjectLayer), () => new UnitOfWork(inputUnitOfWork.ObjectLayer));
This simple, however powerful technic can be applied to any type of input source as long as you are able to fill a DataSet!
You can download a sample project was created with v12.2.5 of our Suite from Importer.Console.
Happy New Year to everybody!
-
XAF knowledge base is really rich and in our Support Center you can find solutions for all common business problems. Moreover our community project www.expandframework.com has tones of reusable solutions, we collected a few of them and applied them to the video rent business. The demo is available with 12.2.4 version of our Suite and can be found in the same folder with the other amazing XAF demos!
XAF is a framework that provides the tools that a developer needs for building business solutions.
- A state of the art multi layered configuration system – The Application Model.
- A robust and flexible Security System that can be used to protect our data and control the auto generation of the UI based on Role permissions
- Its own reflection system (TypesInfo)– with amazingly simple ways to do what .NET does not offer eg. Runtime members, dynamic attributes etc.
- A well designed architecture to guide you where you should put your code. Moreover a very flexible modularization for structuring and further supporting any solution.
- WinForms/ASP.NET integration for a large number of our components
- Rich documentation and a click and run SDK!
XVideoRental is a real world application (RWA). It is designed as a clone of our WinForms VideoRent application and demos only a small part of XAF capabilities. XAF provides the tools/architecture to do extraordinary things so we have followed a (no code)/(design at runtime) approach!. We recommend you to open the legacy Winforms demo and XVideoRental side by side and compare how much faster and richer is XAF development versus the traditional one. Moreover take a look at this help document that extensively compares traditional vs XAF development.
- XVideoRental uses a mechanism to serialize classes into Application Model and control them further from there! Therefore minimizes the learning curve since it is based on your existing component knowledge. (see this blog)
- It is a modeling rather than development technic. In addition allows further modeling at runtime since XAF already provides a runtime model editor.
- Implementations are collected from our usual places (Support Center / Code Central) / www.expandframework.com.
The XVideoRental demo has three projects:
Common.Win
This is a library (not XAF module) and contains 95% of the code needed to model the VideoRental business! As a library can be reused from all domains and not only for video rental business. By extending the model as discussed in Dressing up our classes – Date with a model tonight! it is possible to create an abstract mechanism and control any class/component from there. Since all business operations can be modeled, the library contains controllers like NetIncomeController, TopObjectController that map to the real world meanings and can be applied to any domain. The XAF Application Model serves as an abstraction from technology and business specifics. This module is assembled by collecting the classes/implementations from our Support Center and from our community project www.expandframework.com.
XVideoRental.Module.Win
References Common.Win library and simple initializes the required classes/controllers by deriving from the abstract implementation of Common.Win library. However even if it is possible to “model” any behavior sometimes technical depth must be considered. Therefore in the project you will find a small number of video rental specific classes. In this project you can also find the model differences for this business domain.
XVideoRental.Win
This is the application project and contains no code. Only a few default configurations like module and security registrations.
In the next post we are going to discuss the steps involved in building this application. I remind you again that all code functionality is borrowed from our community, this means that code / ideas really belong to you! We welcome more of your contributions and ideas to build even more wonderful applications. Please explore this demo and we are waiting for your feedback in order to blog more about features that interest you.
A similar version can found in our community project www.expandframework.com. This version has exactly the same functionality as the original demo. However it references directly the eXpand framework so the Common.Win project does not exist nor the initialization of the controllers in the XVideoRental.Module.Win.
We are looking forward for your feedback and contributions in order to make this demo even more powerful! In its current state, a developer can replace before lunch all the business objects with objects of a different business domain then package the application and go to customer and continue development there, at runtime! The final goal as developers is to build such configurable applications that business users can use and modify and shift this weight of our backs. XAF provides all the tools for this and this demo is a proof for this!
Bellow is a short video that shows this demo. You can find about two more dozen of images of this demo in our FB group
PS: A thanks to everybody that already provided feedback and reported issues with this demo. We already provided a newer version with improved performance and you can find it here. For posts related to the XVideoRental demo please subscribe to to the XVideoRental tag
Happy XAFing!
-
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!
