The last post ended with us just getting started on stumbling into text template file customization, a task that required a Visual Studio extension (Tangible T4 Editor)
to even have a chance at completing. Despite the benefits of the Tangible T4 Editor, I still had a hard time putting together a solid text template that would be easy
to explain. This is mostly due
to the way the files allow you
to mix code (encapsulated
in <# #>) with straight-up text
to generate. It is effective
to be sure, but not very readable. Nevertheless, I will try and explain what was accomplished
in my custom tt file, though the details of which are not really the point of this article (my way of saying dont criticize my crappy code, and certainly dont use it
in any somewhat real application. You may become dumber just by looking at this code. You have been warned really the footnote I should put at the end of all of my blog posts).
To begin with, there were two basic requirements that I needed the code generator
to satisfy: Reading one
to many entity framework files, and using the entities that were found
to write one
to many class files. Thankfully, using the Entity Object Generator as a starting point gave us an example on
how to do exactly that by using the MetadataLoader and EntityFrameworkTemplateFileManager you include references
to these items and use them like so: // Instantiate an entity framework file reader and file writer MetadataLoader loader = new MetadataLoader(this); EntityFrameworkTemplateFileManager fileManager = EntityFrameworkTemplateFileManager.Create(this); // Load the entity model metadata workspace MetadataWorkspace metadataWorkspace = null; bool allMetadataLoaded =loader.TryLoadAllMetadata("MFL.tt", out metadataWorkspace); EdmItemCollection ItemCollection = (EdmItemCollection)metadataWorkspace.GetItemCollection(DataSpace.CSpace); // Create an IO class
to contain the 'get' methods for all entities
in the model fileManager.StartNewFile("MFL.IO.gen.cs"); Next, we want
to be able
to loop through all of the entities found
in the model, and then each property for each entity so we can generate classes and methods for each. The code for that is blissfully simple: // Iterate through each entity
in the model foreach (EntityType entity
in ItemCollection.GetItems<EntityType>().OrderBy(e => e.Name)) { // Iterate through each primitive property of the entity foreach (EdmProperty edmProperty
in entity.Properties.Where(p => p.TypeUsage.EdmType is PrimitiveType && p.DeclaringType == entity)) { // TODO: Create properties } // Iterate through each relationship of the entity foreach (NavigationProperty navProperty
in entity.NavigationProperties.Where(np => np.DeclaringType == entity)) { // TODO: Create associations } } There really isnt anything more advanced than that going on
in the text template the only thing I had
to blunder through was realizing that if you want the generator
to interpret a line of code (such as our iterations above), you need
to enclose the code
in <# and #> while if you want the generator
to interpret the VALUE of code, such as putting the entity name into the class name, you need
to enclose the code
in <#= and #> like so: public partial class <#=entity.Name#>
To make a long story short, I did a lot of repetition of the above
to come up with a text template that generates a class for each entity based on its properties, and a set of IO methods for each entity based on its relationships. The two work together
to provide lazy-loading for hierarchical data (such getting Team.Players) so it should be pretty intuitive
to use on a front-end. This text template is available here you can tweak the inputFiles array
to load one or many different edmx models and generate the basic xml IO and class files, though it will probably only work correctly
in the simplest of cases, like our MFL model described
in the previous post. Additionally, there is no validation, logging or error handling which is something I want
to handle later by stumbling through the enterprise library 5.0. The code that gets generated isnt anything special, though using the LINQ
to XML feature was something very new and exciting for me I had only worked with XML
in the past using the DOM or XML Reader objects along with XPath, and the LINQ
to XML model is just so much more elegant and supposedly efficient (something
to test later). For example, the following code was generated
to create a Player object for each Player node
in the XML: return from element
in GetXmlData(_PlayerDataFile).Descendants("Player") select new Player { Id = int.Parse(element.Attribute("Id").Value) ,ParentName = element.Parent.Name.LocalName ,ParentId = long.Parse(element.Parent.Attribute("Id").Value) ,Name = element.Attribute("Name").Value ,PositionId = int.Parse(element.Attribute("PositionId").Value) }; It is all done
in one line of code, no looping needed. Even though GetXmlData loads the entire xml file just like the old XML DOM approach would have, it is supposed
to be much less resource intensive. I will definitely put that
to the test after we develop a user interface for getting at this data. Speaking of the data where IS the data? Weve put together a pretty model and a bunch of code around it, but we dont have any data
to speak of. We can certainly drop
to our favorite XML editor and crank out some data, but if it doesnt totally match our model, it will not load correctly.
To help with this, Ive built
in a method
to generate xml at any given layer
in the hierarchy. So for us
to get the closest possible thing
to real data, wed need
to invoke MFL.IO.GenerateTeamXML and save the results
to file. Doing so should get us something that looks like this: <Team Id="0" Name="0"> <Player Id="0" Name="0" PositionId="0"> <Statistic Id="0" PassYards="0" RushYards="0" Year="0" /> </Player> </Team> Sadly, it is missing the Positions node (havent thought of a way
to generate lookup xml yet) and the data itself isnt quite realistic (well, as realistic as MFL data can be anyway). Lets manually remedy that for now
to give us a decent starter set of data. Note that this is TWO xml files Lookups.xml and Teams.xml: <Lookups Id=0> <Position Id="0" Name="Quarterback"/> <Position Id="1" Name="Runningback"/> </Lookups> <Teams Id=0> <Team Id="0" Name="Chicago"> <Player Id="0" Name="QB Bears" PositionId="0"> <Statistic Id="0" PassYards="4000" RushYards="120" Year="2008" /> <Statistic Id="1" PassYards="4200" RushYards="180" Year="2009" /> </Player> <Player Id="1" Name="RB Bears" PositionId="1"> <Statistic Id="2" PassYards="0" RushYards="800" Year="2007" /> <Statistic Id="3" PassYards="0" RushYards="1200" Year="2008" /> <Statistic Id="4" PassYards="3" RushYards="1450" Year="2009" /> </Player> </Team> </Teams> Ok, so we have some data, we have a way
to read/write that data and we have a friendly way of representing that data. Now, what remains is the part that I have been looking forward
to the most: present the data
to the user and give them the ability
to add/update/delete, and doing so
in a way that is very intuitive (easy) from a development standpoint.Did you know that DotNetSlackers also publishes .
net articles written by top known .
net Authors? We already have over 80 articles
in several categories including Silverlight. Take a look: here.
