A developers toolbox that any mechanic or carpenter would envy – Part 1

Every time i take my car into the garage for repairs I am amazed at the size of the tool boxes and the number of tools each mechanic has. Once, I asked my mechanic, “why do you need so many different tools? Many of them are quite similar.” He said, “We never know what might tool might be needed. Each repair job is different and may require a different tool. Each tool has a different purpose.” I thought about that and remembered the carpenter who had worked on one of my homes. He had various types of hammers and screwdrivers.

In the world of tools there is no one tool that does all things or one size fits all. Each tool has a distinct purposef for which it was made. Carpentry and car mechanics are a lot like software development. As developers we are craftsmen and craftswomen just like that mechanic or carepenter. We build software. We put together lines of code. We need tools to help us in our job also.

When i first began programming back in the mid-eighties there were not a lot of tools available for software developers. I coded in a text editor. I saved my code and then went out to DOS. I compiled the code with a compiler and if no errors were found, I then linked the modules together to produce an .exe. If i wanted a tool i had to pretty much make my own. The internet wasn’t like it is now. In factU didnt use the internet. I used Bulletin Board Services (BBS). I didnt start using the internet until about 1991. As i look back now after almost 30 years in the industry if I had the tools I have today and the books and the on-line help avaiable to today’s programmers….. Well let’s just say my early programming years would have been different.

Getting back to the subject at hands. Tools. If a carepenter or a mechanic needs a good toolbox, well so do we as software developers. Over the last few years of programming in the dot net world, I have seen and tried a lot of different tools. Some were good and some were well!!!!! Enough said. I am now working on a book and a series of tutorials to show programmers how to write a line of business in WPF/Silverlight using a set of tools and controls I use on a day to day basis. The application will be in C# and use the MVVM framework. But first, I am going to produce a series of articles on the tools we will be using. Each tool will be discussed and analyzed in a different article.

In this first blog I want to list the tools we will be using. Note this is not the only list of tools available. These are the ones I have found to be the best and have helped me to be successful as a developer. Take a look at these tools and try them out. If you are not happy then try another and another until you find the ones you love and are comfortable with.

Here is my list: Now first off I must issue a disclaimer, I am an independent contractor. I do not work or make any income from any of these companies. They did not ask me or pay me to say or write these things I approached them and some gave me free copies to work with in return. They gave me access to support and advice. So this is my unbiased opinion. It is a given that we will use Visual Studio 2012 and C#. We will use the dot net 4.5 framework. I am not planning to cover smart devices or Win RT at this point. So here is my list. I will just provide a brief statement as to what the tool does in this blog and in the succeeding blogs, I will discuss the tool in more detail.

1. Intersoft WebUI Studio 2012 R2 – This software will be used for the UI controls in WPF/Silverlight and for the MVVM framework.
2. IdeaBlade DevForce 2012 – This will provide us with the Entity Framework. We will use this software for relational mapping and linq
3. TypeMock Isolator V7 / NUnit – This software will be part of the unit testing along with NUnit.
4. NDepend version 4 – This software is a little like a Swiss army knife. It has many uses. It does build compares and differences, code quality and code metrics, analysis of code and finding references down to the function level and dependencies between modules and much more.
5. Red-Gate Memory and Performance Profiler – These two tools we will discuss together. They will help us to detect memory usage and leaks, the performance of our application and the detection of bottlenecks.
6. Red-Gate SmartAssembly – This software will provide for Automated Error Reporting.
7. XAML Spy – This software will be used to debug our XAML.
8. Red-Gate .Net Reflector – Tnis software allows us to look inside any .net code.

This is not a complete list. We may add other tools as we go. In future blogs. we will take a look at each tool in much more detail. We will also discuss the application that we will be creating in more detail. Hope you are as excited about this project as I am. Well, take care and we will see you soon when in part 2, we will discuss the Intersoft Web Studio 2012 R2.

Regards
Bill

Posted in Uncategorized | Leave a comment

An essential tool for every WPF/Silverlight developer

Last year i blogged about a great product called Silverlight Spy from First Floor Software. Silverlight Spy is an run time inspection tool that allows the developer to exmaine various aspeccts of their Silverlight or Windows Phone 7 application. It provides the ability to visually debug, examine XAML, identify application bottlenecks and understand why the application is behaving as it does. My only complaint about the product was what about all the developers who were developing in WPF? Well back in the summer of 2012, First Floor Software answered that question and released XAML Spy. XAML Spy works in Silverlight, WPF, Windows Phone, and WinRT. In addition, it also works with Windows Surface. It is now the upgrade to Silverlight Spy. Think of it as Silverlight Spy promoted to new platforms. It has all the wonderful capibilities of Silverlight Spy and works on additional platforms.

Over this next year, I place to blog about my experience developing a line of business application in WPF using IdeaBlade Devforce and Intersoft ClientUI tools. I plan to blog also on how to use XAML Spy to reduce development and debugging time. I am a firm believer that XAML Spy is a necessary tool in every Silverlight/WPF/Windows Phone developers toolbox. I can honestly say that using XAML Spy will make the development and debugging process easier and reduce the amount of time needed to make the product ready for release. And isn’t that the goal that as developers we try strive for? First Floor Software has made a valuable but yet affordable product that no developer should be without.

While I will cover in more detail in later blogs the features of XAML Spy, let me enumerate some of my favorite ones. XAML Spy povides a much cleaner interface than Silverlight Spy. The developer can now focus on the content of their application much more easily. In addition, it is a separate windows application. This feature alone allows for some great new possibilities. The best new feature is remote debugging. I can use XAML Spy to remotely debug a Windows Phone application running on a Windows Phone. I can also specifiy which emulator I want to use. And to increase speed of debugging XAML Spy uses TCP sockets to connect to the Windows Phone as opposed to HTTP polling as was used by Silverlight Spy. Not only that I can remotely debug Silverlight applications running on MACOS and applications running on a S
urface device

One of the most important things I like about First Floor Software is their frequent updates to this product. Since the initial release in the summer of 2012, the company has come out with 7 updates. As a developer this allows me to be confident that I am using a product that is continually being improved and reported bugs are being fixed in a timely manner.

I am not an employee of First Floor Software. I am a developer who is continually looking for ways to improve productivity to reduce my development time and to allow me to get a product more quickly from my development machine to the clients machine.

Posted in Uncategorized | Leave a comment

The world is still here and my application must continue.

Well 12/21/2012 has come and gone. The world is still here and my application still needs to be completed. Fortunately companies like Inersoft (http://www.intersoftpt.com) and IdeaBlade (http://www.ideaBlade were not sitting around awaiting the end of the world but instead were continuing to improve already great products and release versions of their award winning software designed to make my job as a developer easier.

I am currently working on creating a database application in .net using SQL Server as the backend. After talking to my users and studying the various options, i decided that a desktop application was to be the main development focus at his time. Since the future might take me down a different path and my application would probably be run over the internet and over other devices such as smart phones and tablets, I wanted to ensure that my application could be easily converted to work on those platforms with the least amount of conversion work. Based on careful consideration of price, ease of use, support, documentation and examples, and releases of updates and fixes, I decided to use Intersoft Client UI for the creation of my user interface and IdeaBlade’s Devforce for the development of the entity framework. I had looked at other UI controls from various companies including ComponentOne, Syncfusion, and Infragistcs. One of the major reasons i chose Intersoft over these other companies was that Intersoft uses the same controls for both WPF and Silverlight. Later as i moved my application from a desktop app to a web based or device based app, it would mean a smoother and faster conversion. In addtion, i found the documentation very helpful and full of examples and tutorials. The Intersoft staff is very helpful and friendly and is always willing to provide assistance to questions posed. I should add that I am not an Intersoft employee but a loyal user of the product. A major decision in developing my application was what framework to use. I decided to use Model View ViewModel (MVVM) as it ties in nicely with the WPF/Silverlight philosophy. The next decision was what MVVM framwork to use. There are a variety out there to choose from including the option to create my own. Using an existing framework while certainly very viable and giving me the benefit of saving me hours of my work. While there are many free ones to choose from it meant one more thing to learn and I felt that many of the existing ones were overkill for what I needed. I know that many developers have strong feelings for their particular favorite MVVM framework. I dont’ want to get into a religious war over which one is the best.

A part of choosing the Intersoft controls was the built in support for MVVM. This feature is not an addon to the controls but is built into the very core of the controls. So I decided to roll my own MVVM framework using the Intersoft UI controls. In the next blog, we will explore the MVVM framework more closely. Now that i had the UI figured out, I needed to work on the interface to the SQL Server database. Again my choices were many. Due again to support, documentation and tutorials, frequent updates, and an ease of usage, I decided to use Devforce 2010 from IdeaBlade. I should also add here that I am not an employee of IdeaBlade.  Devforce would shield my application from the data. The built in object mapper would map my classes to the tables in the database and provide easy to learn and use ways to access the data.

One of the major restrictions on the application was that it had to be in .net 4. Many of my clients were still using older operating systems both on the server and work stations and that limited the .net framework to version 4. Over time i will get my clients moved newer operating systerms and  over to .net 4.5 and then update my application accordingly.

Well thats enough introduction. In the next blog we wil begin to discuss design philisophy and how the MVVM framework that i rolled. Over the next few months will take the application from the design phase to the development phase.

Have a happy and safe holidays.

Posted in Uncategorized | Leave a comment

Asynchronous Queries and Coroutines

Have you ever had one of “eureka” days when the light bulb goes on above the head and the code just seems to fall into place. Well I have and it happened when I finally understood coroutines and how to use them with asynchronous queries.

One of the most difficult parts of learning Silverlight is getting used to asynchronous programming. Over they years, I have been accustomed to programming in C#, Visual Basic, c++ etc. I would issue a query to the database for some data, wait for the data to return, and then display the data on the screen for the user. With asynchronous programming, I now issue a query to the database for some data, the program continues execution and displays the screen without waiting for the return of the data. After a period of time, the data is returned and is displayed on the screen. The UI is no longer held up waiting for the data to return.

Now asynchronous programming can present some interesting challenges for the programmer. There may be a slight pause as the data populates the fields on the form. Depending on the amount of data being returned and the speed of the connection, the data may even seen to flow down the form as the fields are being filled in. Most of the problems can be avoided by retrieving the minimum amount of data needed to fill the form or if using a grid, filing the first page.

As I said before, I found asynchronous programming the most difficult part of learning Silverlight. So much so that for the longest time, I created WPF apps just so that I could use synchronous programming. It wasn’t that it was difficult to create asynchronous queries. It is quite easy to do so. Let’s look at an example of how to create an asynchronous query to retrieve inventory items.

In my repository class, I have a method called GetInventoryItems() which takes 3 parameters. The first parameter is a QueryDescriptor object, which contains the filter and sort criteria. We will examine this object in more detail in later code. The second parameter is what to do upon the successful completion of the query, and finally the last parameter indicates what to do for an unsuccessful query.


 public void GetInventoryItems(QueryDescriptor queryDescriptor, Action<IEnumerable<Inventory>> onSuccess, Action<Exception> onFail)
      {

          Manager.Inventories.Parse(queryDescriptor)
            .ExecuteAsync(
                op =>
                {
                    if (op.CompletedSuccessfully)
                    {
                        if (onSuccess != null)
                            onSuccess(op.Results);
                    }
                    else
                    {
                        if (onFail != null)
                        {
                            op.MarkErrorAsHandled();
                            onFail(op.Error);
                        }
                    }
                }
             );
      }

In my View Model class, I have a FetchInventoryItems() method that calls the repository method and passes the appropriate arguments.

      
        private void FetchInventoryItems()
        {
            this.IsBusy = true;

            _queryDescriptor = new QueryDescriptor();
            _queryDescriptor.FilterDescriptors.Add(new FilterDescriptor("Status", FilterOperator.IsEqualTo, "A"));
            _queryDescriptor.SortDescriptors.Add(new SortDescriptor("Description", ListSortDirection.Ascending));

            Repository.GetInventoryItems(_queryDescriptor,

              (items) => // query success
              {
                  this.IsBusy = false;
                  ResetInventoryItemsList(items);
              },
              (error) => // failed
              {
                  this.IsBusy = false;
                  DisplayMessage(error.Message);
              });
        }

        private void ResetInventoryItemsList(IEnumerable<Inventory> inventory)
        {
            this.InventoryItems.Clear();
            inventory.ForEach(c => InventoryItems.Add(c));
            OnPropertyChanged("InventoryItems");
        }

In the above method, I instantiate a new queryDescriptor object. I add a new FilterDescription object that filters the retrieved data to items that have an Active status and a SortDescriptor that will retrieve the data in Description order. This queryDescriptor object is passed as the first parameter to the GetInventoryItems() methods, the second argument tells the method to take the returned rows and pass them to a method called ResetInventoryItemsList which populates an ObservableCollection called InventoryItems which is bound to a UXGridView on the UXPage. If there is an error in the data retrieval process, an error message is displayed to the user.

So it was not the process of creating and using asynchronous queries that bothered me. That was easy. What bothered me was that my applications were made up of more than just simple queries. There were complicated processes that required multiple steps to be complicated with multiple queries to complete the process. Unfortunately with asynchronously processing, control returned after the query was submitted and there was no guarantee that the next process would be completed in the order or time needed.

As an example, I have an entity name Batch. It represents a deposit, a batch of payments. Its identity is a BatchNo which it obtains from a table called LocalInfo which has a field names NextBatchNo. When a batch object is created, the creation process must get the next batch number from the table, increment it by 1, write the next batch number back to the table and create the batch object. This is quite a lot to do under asynchronous processing and pretty much impossible, one would think. But thanks to IdeaBlade and Coroutines, it is quite easy to do. Coroutines allow for the batching of multiple asynchronous queries. All of the queries are batched together as a group. I am going to show a practical example of using Coroutines in a line of business application.

From the Batch ListView form, the user clicks on the “Add New Batch” button. The button is bound to a AddCommand in the View Model class. Here is the AddBatch() method.


      private void AddBatch(object parameter)
        {
            this.IsInEditing = true;

            BatchEditor.AddNewBatch(
              AddedBatchSaved, // Saved callback
              EditorClosed); // Cancelled callback
        }

All data entry is done in a sandbox editor. The job of the sand box editor is to create the dialog box for data entry, associate it with a view model and reports back to the calling view model whether the Save/OK button or cancel button was clicked.

In the BatchEditSandboxEditor class, I have an AddNewBatch() method which will call the create method of the batch and then show the dialog box for data entry.


       public override void AddNewBatch(Action<Batch> onOk, Action onCancel)
        {
            Repository.ClearAllBatches();

            var coop = Coroutine.Start(Repository.CreateBatch);
            coop.Completed += (sender, args) =>
                {
                    if (args.CompletedSuccessfully)
                    {
                        var batch = coop.Result as Batch;
                        ShowBatchDialogBox(batch, onOk, onCancel);

                    }
                };
        }

In the AddNewBatch() method, I first clear the cache of any existing batches in memory. I then start a new Coroutine method which will wrap the CreateBatch() method in the repository class. After the batch is completely finished with all of its batch processing, the AddNewBatch() method instantiates a batch object from the returned results and then displays the dialog box.

In the repository class is the coroutine method CreateBatch().


        public IEnumerable<INotifyCompleted> CreateBatch()
        {

            var NextBatchOperation = Manager.LocalInfos
                .ExecuteAsync();

            yield return NextBatchOperation;

            LocalInfo li = NextBatchOperation.Results.First();

            var batchNo = li.NextBatchNo;

            Int32? nextBatchNo = batchNo + 1;

            li.NextBatchNo = nextBatchNo;

            var SaveNextBatchOperation = Manager.SaveChangesAsync(new[] {li});
            SaveNextBatchOperation.Completed += (sender, args) =>
                {
                    var savedEntities = args.Entities;
                    var sr = args.SaveResult;
                    var error = args.Exception;
                };

            yield return SaveNextBatchOperation;
            
            var batch = new Batch()
                {
                    BatchNo = Int32.Parse(batchNo.ToString()),
                    BatchDate = DateTime.Now,
                    UserCd = CommonUser.CurrentUser.UserCd,
                    Office = CommonUser.CurrentUser.Office,
                    Status = "O"
                };
                Manager.AddEntity(batch);

            yield return Coroutine.Return(batch);
        }

A Coroutine method returns a IEnumerable result. A Coroutine method wraps up multiple asynchronus statements. After each asynchronous statement a yield return statement is inserted into the code. The yield return statements returns the query operation from the asynchronous statement. At the end of the method, yield return Coroutine.Return statements returns the results of the method back to the method holding the Coroutine.Start() method. The statements within the Coroutine method are executed as a batch and the method returns only after all the statements are executed.

Here is the dialog box after the batch is created and the sand box instantiates and displays it.

The batch number, has been retrieved from the LocalInfo table, the next batch number is incremented by 1, and and been saved back the LocalInfo table, ready for the next batch to be created.

I hope that this blog about using Coroutines to batch asynchronous queries together has been helpful and will serve as an example for your own applications.

Posted in Uncategorized | Leave a comment

A Sales Invoice application using Intersoft ClientUI and IdeaBlade DevForce – Part 1

Beginning with today’s blog and over the next couple of blogs, we will explore the building of a sales invoice tracking system using Intersoft ClientUI, IdeaBlade DevForce and nested dialog boxes.

I have been a Windows programmer since the early 1990s using both Visual Basic and Visual C++ MFC. I prefer building Windows apps that have a main page with a navigation bar on the left hand side of the main form and a content page on the right hand side that holds a grid of data.

The above screen shot is a typical application that I recently did for a client who wanted to maintain an inventory for entertainment tickets and the tracking of their purchases, sales, and transfers. From the navigation bar on the left, the user can move to any module of the program. The content panel on the right displays the list view of the module. Using the above list view the user can find existing sales invoice by filling in one or more of the criteria fields and clicking on the Find button. The user can then edit or void a sales invoice or the user can add a new sales invoice.

If the user chooses to add a new sales invoice or edit an existing sales invoice, a UXDialogBox is displayed to collect the information. When the user is finished entering data, the dialog box is closed and the user is returned to the list view. Here is a screen shot showing the dialog box for adding and editing data.

A member has the ability to buy multiple sets of tickets from various vendors on the same sales invoice. Therefore, a UXGridView is used to track the various tickets purchased. Rather than using inline editing in the grid for the purchase of the ticket, I display another dialog box on top of this dialog box for the entering of the detail information. After the detail dialog box is closed, the new row is added to the grid and the user can add another item or finish the sale. Here is a screen shot using the nested dialog boxes.

In the next blog, we will discuss the database structure and the classes used to create the application. In future blogs, we will create the project, the views, the view models, and the repository class. By the time we are done, we will a line of business application that has modules for Customers or Members, Inventory, Sales Invoices, and Purchases. This application will be fully functional and Model View View-Model (MVVM) compliant.

Posted in Uncategorized | 2 Comments

Smart Decision, Smart Investment, SmartAssembly

As a software developer, I try to develop software that is user-friendly, cutting edge, and error/bug free. While all three are attainable goals, usually the first two are the easiest to achieve. No many how much time I spend testing my software, it usually ends up in the clients hands in a less than perfect state. I guess I can console myself with the fact that large corpoations with many more testers and dollars spent in the testing phase then I have available deliver sotfware that is still full of bugs. But somehow that reasoning does not go over well with my frustrated clients.

Over the years, I have come to the following conclusions. As softare becomes more complicated and pushes the edges of technology, bugs and errors are an inevitable part of programming. Even if I could, would it be economcially feasible to produce software that has zero bugs and errors? Probably not. Does that mean that I should be satisfied with releasing software that is imperfect? Of course not. It just means that I need to realize that my staff is the first line of testers and the customer in the form of alpha and beta testers is the second line of defense.

Unfortunately, my customers, while a necessary part of the testing process, are also often times more of a hindrance in the testing process instead of a help. While internal testers are diligent in tracking errors and noting the circumstances in which they occur, external testers often forget to write down errors until later. They forget or scramble up the error message received, or forget the circumstance in which the error occured. would it not be not very helpful for debugging purposes to know exactly where the bug or error occured in the code, the state of variables at the time, and then have the user make a detailed record of this infromation. While that may seem like wishful thinking, it can be a reality thanks to a product from Redgate called SmartAssembly and its Automated Error Reporting feature.

This product which works with the latest version of .net actually provdes three very valuable features, code obfuscation, feature usage reporting and automated error reporting (AER). Of the three, my personal favorite is automated error reporting, but hey I also like the feature usage reporting. With the help of AER, my clients now have the ability to become better testers. And the reporting of bugs and errors is now accurate and filled with detailed information that makes it easy to quickly find and fix the errors. And all the client has to do is click a button. If while executing your application, the user receives an exception, they press a button to send error reporting information. In turn, an error report arrives a web service which is then stored in SQL Server. The developer uses SmartAssembly to read the reports, they fix the bug and release a new version. On the part of the client, AER is as easy to use as 1-2-3.

Setting up AER by the developer is also as easy as 1-2-3. The developer creates a new project in Smart Assembly and adds the main assembly of their application to the project. SmartAssembly is great for the client to use not only during beta testing but for a couple of months after the final release of the application. The overhead of SmartAssembly is minimal and will not have adverse affects on the application.

The latest version of SmartAssembly is 6.1. The AER works well with Silverlight 4 apps, Windows Phone 7 apps, and WPF assemblies. If you have ever released software to clients and then have been bombarded by those same clients with phone calls and emails, you will appreciate the error reporting features of SmartAssembly. It will very quickly pay for itself in hours saved trying to find bugs with the little information usually provided by clients.

I will be blogging more about AER as I prepare my latest project for alpha testing over the next couple of months.

I am not an employee of Redgate nor do I benefit financially in any way from blogging about their product. I am a developer who is constantly looking for new ways to more effectively and efficiently spend my time developing software for clients.

Check out SmartAssembly at http://www.redgate.com.

Posted in Uncategorized | Leave a comment

Much Ado about Nothing

While the above heading might refer to the comedy by William Shakespeare about two pairs of lovers in 16th century Sicily, it also describes my feelings about Model View View-Model (MVVM) frameworks. Now before I get accused of blasphemy in the high court of WPF and Silverlight programmers, let me explain myself. For those of you who know me and have read my previous blogs, you know that I am a strong supporter of MVVM. In fact, I believe that no serious WPF or Silverlight application should be written without using the MVVM pattern.

There is a different between the MVVM pattern and MVVM frameworks. The pattern is there to descibe the concepts of how the application should be built and how the various pieces of the application should communicate back and forth. A framework is just a set of software modules that attempt to make using the pattern easier. it is like building a house from scratch or using a pre-fab. Both methods produce a house. Supposedly the pre-fab is easier to build because the pieces are all there in a package and precut with instructions on how to assemble them together. But you pay a price for using the pre-fab, the building process becomes a cookie cutter technique and all the pre-fab houses of the same model look the same. In addition, you are limited to how the house is designed because the pieces are already pre-cut and you receive just what you need and no more.

Now having said all that, last weekend, I began a new Silverlight/WPF project. I thought that I would try using one of the MVVM frameworks to make the programming process easier. Hmmm which one to use? There are many good ones out there and some not so good ones. I looked at three or four of the more popular ones. I noticed several things about each of them. They are all free. Now I have no problem with free. I will gladly take free over spending money any day. But free also means that you get what you pay for. These frameworks are being developed by individuals in their spare time while they have other jobs which pay their salaries and allow them to survive. I could find no evidence of companies developing any of the more popular frameworks. In the past, Microsoft had attempted to develop several frameworks and they swiftly died out leaving developers out on a limb. All of the frameworks are in various stages of development. None are fully functional yet. They are in various stages of being built. None have fully published documentation or full blown real-life examples.

Now don’t get me wrong. I am not putting down any of the frameworks nor the developers working on them. They might work very well for them and their needs. But last weekend showed me that the existing frameworks as is are not for me at this time. Maybe in the furture, if the frameworks become fully functional, the documentation is complete and real life examples are available, I might change my mind and use one. As I tried learning to use the one that I selected, I quickly became frustrated because of the lack of documentation and good examples. I realized that in addition to learning the ins and outs of programming the application design, learning the intricacies of the control set and the entity framework, there would also be a steep learning curve for the framework and my application fits into the framwork. The question that struck me, was it worth it? I decided no. I would build my own “framework”.

Building my own framework did not mean that I was going to develop a framework kit like the ones that I was rejecting. It meant that i would figure out how to use the MVVM pattern without using a framework software kit. Fortunately I had chosen two 3rd party control packages that would make my work easier. For the entity framework and backend services, I am using DevForce Universal from IdeaBlade. For the UI controls, I am using ClientUI from Intersoft. I discovered this toolset last fall and it remains my favorite among WPF/Silverlight controls. In fact, it is the only set of controls in my toolbox for Visual Studio 2010. In the past I have used Infragistics, Syncfusion, ComponentOne, and Telerik. But the Intersoft has all the controls I need. Well, there is one I wish they would create and that is a schedule/Calendar control. But that is beside the point. As for DevForce Universal, there is no way that I would consider creating a database applcation with using it. While there is the Entity Framework from microsoft and various other ORMs like EntitySpaces and Telerik’s ORM, they pale in comparison to DevForce. Using DevForce makes developing the entity model a relatively easy task and makes commmunication with the database server so much easier than having to use WCF-RIA services.

So now I have the UI controls and I have software for developing the entity framework and the backend services. With ClientUI, I am able to build the view classes. With DevForce, I am able to build the data model, the repository class(es), and communicate with the back end through a piece of software called the Business Object Server. Using C# code, I am able to build the view model classes that provide the application state and access the repository for data requests. Now I needed a way to communicate commands from the view class to the view model class. As an example, on the view. I have a Save button.

In the past, when the user had finished entering data on the view and clicked on the Save button, I had a clicked event that was triggered and code in the code behind module that would receive the clicked event, do some initial processing and call a controller method to complete the save process. But that meant that I had code in the view module, even if it was the code behind portion, and the view was tightly bound to the view model. What if I wanted to use the same view model in say a Windows Phone 7 application. My view would have to change to fit the size and controls of the phone, but i would want the code in my view model and calls to the repository to stay the same. But if the view nad view model were tightly bound togehter that might be difficult to do.

Thanks to the foresight of the developers at Intersoft, the answer was right in front of me. All the Intersoft controls are built from the ground up with the MVVM pattern. For example, the UXButton has a commmond property. So in my xaml, my definition of the button includes this syntax

<Intersoft:UXButton Content="Save" Width="80" IsDefault="True" DialogResult="None" Command="{Binding SaveCommand}"/>

In the view model for this view, I have the following code.

public DelegateCommand SaveCommand {get; set;}

In my constructor I instantiate the SaveCommand object.

SaveCommand = new DelegateCommand(Save, CanSave);

Now I create two methods, CanSave() which takes as an argument object parameter and returns a bool and determines if the button is available to the user or disabled. My second method is Save() which returns a void and takes an object parameter as a parameter. This is the method that actually will do the save.

Here is an example from the current project for the CanSave() and Save() methods for the Member class.

       private bool CanSaveMember(object parameter)
        {
            if (_isNewMember && !_isDirty)
                return false;

            if (_requireValidate)
            {
                _lastValidateResult = this.Validate();
                return _lastValidateResult;
            }

            return _lastValidateResult;
        }

        private void SaveMember(object parameter)
        {
            DetachEventHandlers();
            this.IsBusy = true; // make page busy during save
            Repository.Save(SaveSucceeded, SaveFailed);
        }

        private void SaveSucceeded(IEnumerable entities)
        {
            this.IsBusy = false;
            DetachEventHandlers();
            this.MemberEditDialogResult = DialogResult.OK;
            CloseEditView();
        }

        private void SaveFailed(Exception error)
        {
            this.IsBusy = false;

            string message = error == null
                                 ? "Save Cancelled!"
                                 : "Error: " + error.Message;

            DisplayMessage(message);
        }

All of the Intersoft controls have a mechanism for sending a notification to the view model that something has taken place on the view. The View Model listens for the notification, acts upon it and then using the INotifyPropertyChanged interface, the view is alerted that the state has changed in the view model and the view needs to refreshed. Having this pattern built into the controls, I have no code in the code behind class. My view knows nothing about the view model and my view model knows relatively little or nothing about the view. And with the recently added Event Aggregator class from Intersoft, I have pretty much everything that the MVVM frameworks have without the learning curve.

Instead of spending this week learning how to use a framework, I spent this week producing code. In fact, coding the new application along with all the other things that I have to do for the business, I was able to produce about 7,000 lines of code according to the metrics count of the solution. Rather than spending time learning the framework which doesn’t really help me reach my goal of deploying the application, I am 7,000 lines closer to deployment. As I said, maybe in the future, my views about MVVM frameworks will change and I might learn how to use one. In the meantime, I feel they are “much ado about nothing”.

I am not an employee of IdeaBlade or Intersoft. I am the president of a company that develops software for labor unions. I am constanly on the lookout for tools that make my job more productive and efficient. Both IdeaBlade and Intersoft fulfill that purpose. I cannot say enough good things about them. I am proably one of their biggest cheerleaders.

Posted in Uncategorized | 6 Comments

Data Retrieval made easy with Query Descriptor from Intersoft ClientUI toolkit.

A few releases ago, Intersoft introduced developers to their new UXGridView. While the grid is powerful and wonderful by itself, they made it even better by introducing two classes along with it, QueryDescriptor and SortDescriptor. And thanks to the ongoing partnership between Intersoft and IdeaBlade, QueryDescriptor plays well with the Entity Framework. In previous applications using IdeaBlade, when it was necessary to have the capability for multiple search fields especially when it was unknown at compile time what they were required the use of PredicateBuilder. PredicateBuilder was a bear to use and to understand and was not as flexible as what QueryDescriptor is.

The purpose of these two classes is to build query filters and sort filets for retrieving data into the grids. I love these two classes. They have made my development work so much easier. They have reduced the number of repository methods that I need to ceate. As an example, I have an app that fills a grid with members that the user has selected in a query screen. Prior to the introduction of the QueryDescriptor, I would have had a method called GetMembers() and passed a Query Object as the first parameter The Query Object would be populated the search criteria from the user. I have an Employers screen that shows all the members that work for the employer. I would have needed a method called GetMembersForEmployer() and passed the employer number as the first parameter. I have a screen that show the job sites for each employer and the user can view a grid of members working at that job site. I would have had a method called GetMembersForJobSite() eand pasds over the job site number as the first parameter.

Now I have one method called GetMembers() and pass over the QueryDescriptor object created in that particular view model which also includes the SortDescriptor. I have just reduced the number of methods needed.

Here is an example of how I do this. I want to get fill a grid with a list of all the job sites that belong to a particular employer. In my EmployerEditViewModel class I declare a QueryDescriptor object as follows:

private QueryDescriptor _queryDescriptor;

I then create a public property QueryDescriptor that returns the _queryDescriptor:

        public QueryDescriptor QueryDescriptor
        {
            get
            {
                if (this._queryDescriptor == null)
                {
                    this.QueryDescriptor = new QueryDescriptor();
                }
                return this._queryDescriptor;
            }
            set
            {
                if (this._queryDescriptor != value)
                {
                    if (this._queryDescriptor != null)
                        this._queryDescriptor.QueryChanged -= new System.EventHandler(OnQueryChanged);

                    this._queryDescriptor = value;
                    this._queryDescriptor.QueryChanged += new System.EventHandler(OnQueryChanged);

                    this.OnPropertyChanged("QueryDescriptor");
                }
            }
        }

        private void OnQueryChanged(object sender, System.EventArgs e)
        {
       }

I then build my filter and my sort order. In this sample of code, I am going to find all the job sites that belong to the current employer on the screen and display them in a grid and sort them by the name of the job.

       public void BuildFilter()
        {

            if (this.QueryDescriptor.FilterDescriptors.Count >= 1)
                this.QueryDescriptor.FilterDescriptors.Clear();

            CompositeFilterDescriptorCollection groupFilter = new CompositeFilterDescriptorCollection();

            groupFilter.LogicalOperator = FilterCompositionLogicalOperator.And;

            groupFilter.Add(
                new FilterDescriptor()
                {
                    PropertyName = "EmployerNo",
                    Operator = FilterOperator.StartsWith,
                    Value = Employer.EmployerNo
                }
                );
            if (groupFilter.Count >= 1)
                _queryDescriptor.FilterDescriptors.Add(groupFilter);

        }

        public void BuildSortOrder()
        {
           QueryDescriptor.SortDescriptors.Add(
               new SortDescriptor()
               {
                   PropertyName = "JobName",
                   Direction = System.ComponentModel.ListSortDirection.Ascending
               }
           );
        }

Here is my fetch method in my View Model class that calls the repository method GetJobSies() and passes the QueryDescriptor object that was populated in the BuildFilter() and BuildSortOrder() methods:

      public void FetchJobSites()
        {
            IsBusy = true;

            BuildFilter();
            BuildSortOrder();

            Repository.GetJobSites(QueryDescriptor,
              (jobs) => // query success
              {
                  this.IsBusy = false;
                  ResetJobsList(jobs);
              },
              (error) => // failed
              {
                  this.IsBusy = false;
                  DisplayMessage(error.Message);
              });
        }

        private void ResetJobsList(IEnumerable<JobSite> jobs)
        {
            this.JobSites.Clear();
            jobs.ForEach(c => JobSites.Add(new JobSiteViewModel(c)));
        }

Finally here is my GetJobSites() method in my repository.

       public void GetJobSites(QueryDescriptor queryDescriptor, Action<IEnumerable<JobSite>> onSuccess = null, Action<Exception> onFail = null)
        {
            Manager.JobSites.Parse(queryDescriptor)
               .ExecuteAsync(
                   op =>
                   {
                       if (op.CompletedSuccessfully)
                       {
                           if (onSuccess != null)
                               onSuccess(op.Results);
                       }
                       else
                       {
                           if (onFail != null)
                           {
                               op.MarkErrorAsHandled();
                               onFail(op.Error);
                           }
                       }
                   }
               );

        }

Because this GetJobSites method is so generic it can be used in multiple places where I need to get job sites as long as I build the filter and sort order ahead of time in the View Model before the call to the repository.

I hope that this simple example of how to use the QueryDescriptor and SortDescriptor in a real life situation will help you to be more productive and reduce the amount of code needed.

Posted in Uncategorized | 2 Comments

Applied Silverlight 5 in Context

Well Apress has given me the go ahead to start working on a book that will take the reader from start to finish in developing a line of business application using Silverlight 5. The first of most chapters building the application using the standard controls provided by Microsoft, while the second half of the chapter will show how to use 3rd party tools to get the job done faster and more efficiently. For example, for the chapter on Entity Framework, I will first show to use WCF-RIA Services for creating the entity framework and accessing the data with CRUD methods and then I will show how to do it using IdeaBlade DevForce for Silverlight. In the chapter on building the views and placing controls on the views, I will use the standard controls found in Visual Studio. Then I will show how easy it is using a 3rd party tool set like Intersoft ClientUI 5.

Here is the initial chapter outline. This may change a little.

  1. Introduction to Silverlight and XAML
  2. Silverlight 5 New Features
  3. Introduction to Design of Sample Application
  4. Silverlight Application Architecture
  5. Design Patterns in Silverlight
  6. Microsoft Expression Blend
  7. Creating Views
  8. Adding Controls to the Views
  9. Styling Your Application
  10. The Entity Framework and WCF-RIA Services
  11. Data Binding
  12. Command Handling and Event Routing
  13. Printing and Reporting
  14. Interfacing with WCF and WF
  15. Testing and Debugging your Application
  16. Browser versus Out of Browser Deployment
  17. Silverlight Applications on Mobile Devices

 

 

Posted in Uncategorized | 2 Comments

The Best Happy Birthday Ever.

This week I turn 56 years old. I have been in the IT field since 1985. I have run the gambit from programming to database administration to training. I have worked with many different languages, technologies, operating systems, data access methods, frameworks, and third party controls.

I have a confession to make. This last year of programming has been the most fun that I have ever had. I am enjoying every day of work. Why? Because I am programming WPF and Silverlight applications using the two best software components on the market today, IdeaBlade’s DevForce Universal and Intersoft’s clientUI 5.

The satisfaction that I get from programming today is far more than any I have ever received over the last 26 years. I remember programming in Visual Basic and having to work with ODBC, DAO, RDO, and ADO. It was not pretty. It was not simple, and it was not efficient. Now using DevForce, I create my entity framework which maps my classes to my database tables. Using simple methods, I create an entity manager that allows my repository class methods to easily retrieve, create, update, and delete rows from my database tables. My application does not have to know anything about my database or what type of database it is. Data Access in VB and other languages took a lot of time that I could have spent working on the application itself. With IdeaBlade DevForce, I have a fully functioning back end in a very short period of time. Then I just have to write my repository class methods to access the various classes.

Using the controls from Intersoft ClientUI, I can quickly create Views in both Silverlight and WPF that works exactly the same in either technology. The Silverlight apps, both in browser and out of browser, look as impressive and alive as the WPF desktop applications. I have clients who want both Web apps and desktop apps and the fact that I can create one set of views and view models and share them between the technologies makes my life a whole lot easier. The other feature that I really like about Intersoft controls is that they are all built from the ground up with the Model View View Model (MVVM) framework. My apps can easily pass information back and forth between the views and the view models without the need of having them integrated tightly together. My code has never looked cleaner, easier to maintain, and truly structured. I have only one UI tool set on my computer and that is Intersoft ClientUI.

So what, if this week, I get another year older. I am enjoying what I do and look forward to each new day of programming. Hopefully both IdeaBlade and Intersoft will continue to impress me with their software and continue to be the leaders in providing Silverlight and WPF developers with the best controls on the market. Hey, at 56 years old, I have become more productive, work is becoming easier, and more fun. What more could a software developer ask for?

Posted in Uncategorized | 1 Comment