Fetching Strategies for the Entity Framework - a waste of time for now?
I really want Fetching Strategies for the Entity Framework however my efforts in making this happen have been exhausted for now. Implementing Fetching Strategies (eager loading only) was possible in LINQ To SQL and I expect that abstracting the .Includes extension method on ObjectQuery<T> is just as feasible, however what’s questionable right now is whether it’s worth implementing a half baked solution that only helps in eager fetching. Building calls to .Includes() in non generic methods implemented by a Repository, would probably be the best place to do this for Repositories implemented on top of Entity Framework V 1.0.
public class EntitiesRepository<E, C> where E : EntityObject where C : ObjectContext { private readonly C _ctx; //Unit of Work Accessor public C Session { get { return _ctx; } } //Constructor public EntitiesRepository(C session) { _ctx = session; } //Common Unit of Work Methods public void Save() { _ctx.SaveChanges(); } /// <summary> /// A generic method to return ALL the entities /// of type TEntity. This overload will use the /// the parameter entitySetName in the resolution of mapping /// between the CSDL and SSDL. This method is useful /// for Models that DO have their pluralized names /// changed by the developer. For example if Customers /// table from Northwind produces an Entity that by /// default is named Customers but has it’s name changed /// to Customer this method call would fail. In Version /// 2.0 this pluralizing behaviour will change and this /// method overload should be used only if Developers /// change EntitySet names from the default name generated. /// </summary> /// <param name="entitySetName"> /// The EntitySet name of the entity in the model. /// </param> /// <typeparam name="TEntity"> /// The Entity to load from the database. /// </typeparam> /// <returns>Returns a set of TEntity.</returns> public ObjectQuery<E> All(string entitySetName) { return (ObjectQuery<E>)_ctx.CreateQuery<E>("[" + entitySetName + "]"); } /// <summary> /// A generic method to return ALL the entities /// of type TEntity. This overload will use the /// typeof(TEntity).Name in the resolution of mapping /// between the CSDL and SSDL. This method is useful /// for Models that DO NOT have their pluralized names /// changed by the developer. For example if Customers /// table from Northwind produces an Entity that by /// default is EntitySet name is NOT changed. /// </summary> /// <typeparam name="TEntity"> /// The Entity to load from the database. /// </typeparam> /// <returns>Returns a set of TEntity.</returns> public ObjectQuery<E> All() { return (ObjectQuery<E>)_ctx.CreateQuery<E>("[" + typeof(E).Name + "]"); } //…etc etc etc } public class CustomerRepository : EntitiesRepository<Customer, NorthwindEntities> { public IQueryable<Customer> GetCustomerByCountry(string country) { var custs = from c in Session.Customers where c.Country == country select c; return custs; } /// <summary> /// Uses the base constructor /// to inject the Unit of work /// session. (should new up the /// session outside of here if /// it’s being used accross /// repositories. Also change to /// add the context to the constructor /// parameters as well) /// </summary> public CustomerRepository() : base(new NorthwindEntities()) { } }
My fear is that if the changes / upgrades to the Entity Framework for Version 2.0 don’t cut deep enough many will lose faith and patience and may be forced by default into using some other ORM. Personally this is a critical feature for me however for the moment I have decided there is no satisfying solution to this problem and so I am going to leave Fetching Strategies out of my library for now. I will post the entire code soon.
Silverlight and Model View Presenter (is it a realistic option?)
I am currently working on ‘Case In Point‘, a Silverlight application which is available online and if you want to know more about it and why I chose to build it, please check out this previous post. In more recent times I have moved beyond the layout / UI Design stage (the main point in building this app) and have just now moved into preparing the ground for structuring my approach to the Business Logic and Data Access and how I was going to affect loosely coupled layers.
My first instinct was to tackle the task by using the recently devised Model-View View-Model pattern however I chose not to go down that path because this applications primary objective was to provide a learning exercise in UI skills and ultimately I thought that implementing the Model View Presenter pattern in a Silverlight application would provide me a solid foundation to compare when I do finally try out MVVM.
Over the past couple of years I have become accustomed to using a home grown MVP Framework that was fully templated in Visual Studio and offered a lot of benefit in speed of use by cutting out a lot of the repetitive file creational stuff that such an approach requires. Using this templated framework meant that creating a ‘new item’ in Visual Studio would trigger the creation of the Model, View (user control, page, form etc) and Presenter, wiring their dependencies (via injection) together in the process. One of the benefits of this homegrown MVP framework was it’s ability to deal with what effectively handled two way Databinding between the views and the model, something that we now get from Silverlight for free, which gave me a chance to really see how MVP would benefit or from this aspect.
So far my standard MVP approach for Win Forms and Web Forms seems to sit equally as well with Silverlight so I am pleased that I can move forward quickly with completing this learning exercise, which as I have pointed out was completely about getting comfortable with Silverlight in respect to gaining familiarity with the new UI paradigm.
Setting up the Model View Presenter.
public partial class CaseInPoint : UserControl { //The main UI View (control) that loads all the tabs views) public CaseInPoint() { InitializeComponent(); //new up the model for the tabbed application PointInCaseProject model = new PointInCaseProject(); //new up all the presenters CaseInPointPresenter mainPagePresenter = new CaseInPointPresenter(this, model); ProjectDetailPresenter projDetailsPresenter = new ProjectDetailPresenter(this.AppTabs.ctlProjectCalculator, model); FactorsPresenter factorPresenter = new FactorsPresenter(this.AppTabs.ctlFactorList, model); UserStoryPresenter storyPresenter = new UserStoryPresenter(this.AppTabs.ctlUserStoryView, model); ActorsPresenter actorsPresenter = new ActorsPresenter(this.AppTabs.ctlActorsView, model); } }
The Presenter.
internal class ProjectDetailPresenter : IPresenter { private ProjectDetailCalculator _view; private PointInCaseProject _model; private CaseInPoint _viewParentWindow; internal ProjectDetailCalculator View { get { return _view; } set { _view = value; } } internal PointInCaseProject Model { get { return _model; } set { _model = value; } } internal ProjectDetailPresenter(ProjectDetailCalculator view, PointInCaseProject model) { //set the view and model _view = view; _model = model; //wire up the events of the view and its parent window WireUpEventsOnInit(); //do any initial data binding InitialBindUiToEntity(); } }
And finally the Model
[XmlRoot()] internal class PointInCaseProject : INotifyPropertyChanged { private ProjectDetails _details; private List<EnvironmentalFactor> _environmentalFactors; private List<TechnicalFactor> _technicalFactors; private List<UserStory> _userStories; private List<Actor> _actors; /// <summary> /// The list of User Stories contained /// within the point case estimate project. /// </summary> [XmlElement()] internal List<UserStory> UserStories { get { return _userStories; } set { NotifyPropertyChanged(“UserStories”); _userStories = value; } } /// <summary> /// The list of Technical Factors /// within the point case estimate project. /// </summary> [XmlElement()] internal List<TechnicalFactor> TechnicalFactors { get { return _technicalFactors; } set { NotifyPropertyChanged(“TechnicalFactors”); _technicalFactors = value; } } /// <summary> /// The list of Environmental Factors /// within the point case estimate project. /// </summary> [XmlElement()] internal List<EnvironmentalFactor> EnvironmentalFactors { get { return _environmentalFactors; } set { NotifyPropertyChanged(“EnvironmentalFactors”); _environmentalFactors = value; } } /// <summary> /// The list of Actors within the /// point case estimate project. /// </summary> [XmlAnyElement()] internal List<Actor> Actors { get { return _actors; } set { NotifyPropertyChanged(“Actors”); _actors = value; } } /// <summary> /// The details of the /// point case estimate project. /// </summary> [XmlElement()] internal ProjectDetails Details { get { return _details; } set { _details = value; NotifyPropertyChanged(“Details”); } } public void NotifyPropertyChanged(string propertyName) { if (PropertyChanged != null) { PropertyChanged(this, new PropertyChangedEventArgs(propertyName)); } } public event PropertyChangedEventHandler PropertyChanged; public void Clear() { if (this._details != null) { this._details.Clear(); } if (this._actors != null) { this._actors.Clear(); } if (this._environmentalFactors != null) { this._environmentalFactors.Clear(); } if (this._technicalFactors != null) { this._technicalFactors.Clear(); } if (this._userStories != null) { this._userStories.Clear(); } } }
NOTE: This is not the entire code base and some things above have been left out or assumed, things such as the entities that are contained in generic<> lists in the model and all the subscribing handlers for view events that would be present in the presenters. At the end of the exercise I will follow up by implementing a small application using MVVM framework, putting me in a better position to discuss the differences and merits of both approaches. I have read some opinion that suggests that the Databinding abilities present in Silverlight and WPF are not equally as available to pre-exiting UI development frameworks such as MVC and MVP so I consider this is step one in putting that assertion to the test for my own sanity.
Of course a happy by-product of this exercise is getting a tool to manage my point case estimations for real world projects and in so doing I will be able to remove the dependence on the spreadsheet that currently manages this task for me. As it stands today, the project details tab has it’s data being persisted and I have decided to take a document centric approach to the persistence. Each project will save it’s estimation data in XML format locally in Isolated Storage and each file is saved as a .pce (point case estimate) file. I will post the Visual Studio solution when the project is complete.
Are Designers or even Devigner’s a requirement for XAML UI’s?
Based on some of my experimental / learning project work with Silverlight and what I have seen on line I think that there is enough in the XAML UI frameworks to offer the plain old graphically challenged business developer. Sure the designer / devigner might add huge value but I don’t see a lot of organisations simply taking that role on board because there is a new UI framework in town; no matter how powerful. Certainly my own effort to date I find a little drab but I don’t think my past Winform or ASP.Net applications were not graphical feats of brilliance either, yet I like so many others have produced many business applications that have served their user bases faithfully nonetheless. My first Silverlight application (currently underway) was indeed designed for this reason, to get as comfortable as possible with laying out a typical data driven LOB application window.
I do think that as more and more third party tools (controls) become available I will not be required to work so particularly on my graphical XAML skills and be left to concentrate on the job at hand and surely that’s what we want business developers doing.
So in essence I do think that projects where a high requirement for visual elegance or graphical complexity will benefit greatly from the inclusion of the designer / devigner role, however many projects that need classical data driven forms should be adequately handled by the simple developer who like me is stick figure bound!
Why I want Silverlight to succeed in a huge way - [A new year wish].
Ok I’m just going to come out and say it - I don’t want to know two UI frameworks equally as well or perhaps I should say one ‘less well’ than the other. It’s a fact of life that a great deal of we .NET developers (the majority I would think) work for an SME and also that the great majority of work we do is not public facing web sites. These SME’s form a significant portion of Microsoft’s Market and the main two UI frameworks used by this customer segment, have up until recent times been developing their application using Windows Forms or ASP.Net. More recently, Microsoft have invested heavily in UI frameworks grounded in the XAML which offers perhaps the first real opportunity we have seen for a unification of a single set of skills to be employed both across the web and desktop. Historically of course we have witnessed the relative failure of the Java Applet and the ActiveX control but we shouldn’t let those failures deter us from exploring success with WPF and Silverlight.
I have to say that as a Rich Client kind of guy, I have always been at odds with ASP.Net to a degree. Web Forms was a revelation of sorts when it was introduced and it continues to be a very useful and highly productive framework for web development in the SME IT environments. In pursuit of improving the quality of software the web toolkit exists in a vast nebula of expanding stars which surround ASP.Net Web Forms. Today as Web Developers it’s becoming incumbent on us to have strong skills in CSS, JavaScript, Ajax, JSON, JQuery, DHTML, MVC and the list goes on and on and on and on and…….and this is complicated by the lack of consolidation caused by browser discontinuity - don’t get me started on that. The huge mesh of variation in skill requirement with these technologies is something that never really played well with me and one that I have resisted by and large. I do still from time to time get to develop in ASP.Net, however I still resist these outlying technologies and one might argue that within the context of my business domain that’s perfectly valid (if not required) as a choice.
What I want to be able to do is focus squarely on XAML based UI skills and 
leverage this with equal impact on the desktop or the web (or to be precise over HTTP and in the browser) and not feel boxed into my limited abilities with the standard web box of tricks that I named above. Now it’s true that I don’t do a great deal of work on the public facing web however that is not synonymous with my never having to need to build highly scalable applications that exist behind the firewall and even support large user bases outside of that same firewall. If I can affect a streamlining of my team by leveraging XAML via WPF and Silverlight and work richly on the web and desktop and avoid the toolkit soup that comes with browser development, then I will be a happy man - a very happy man.
Certainly these days there is diminishing resistance to the idea of Silverlight becoming more prevalent as an alternative to the prevailing approaches and some of the noise in the blogsphere and opinion in the podcast domain is warming to idea. I would just love to get to the point where my UI technology choice can be more consistent and at best be uniform.
Post Christmas and Pre New Year Question?
As we approach the new year and many of us reflect on the one that just passed, I find myself compelled to ask the question - are we as human being’s becoming spiritually (not in a religious sense) lost in the after glow of technological advance? Certainly technology has changed my life in a most profound way. I was once a musician and recording engineer and to execute my job required some technological expertise coupled with some artistic flair (I hope). After changing careers and moving into software development, I find that my creative desires are to some extent still fulfilled however my sense of shared experience and the actual amount of time I spend developing my skills ‘with others’ is not comparable at all. No more rehearsals, recording sessions, writing groups, all of which required much human interaction and debate, a lot of which took place in social settings. These days I do most of my learning in isolation, sitting in front of the very computer screen that I see now as I type this post. It is clear that even in my constant education and expression via this blog that I am communicating, however it is still seems to lack some of the interpersonal aspects that traditional face to face interaction can bring.
The Question:
Sometimes it’s not clear whether technology is improving our general quality of life or not. Any thoughts?
Regardless, I hope that 2009 brings an abundance to .NET goodness to one and all. My aim is to be a little more socially inclined next year.
