After discussing with Matias Bonaventura what the best way to get this done was, we decided to use an extension method for the RegionManager class.

RegisterViewWithRegionInIndex method

1. Create a new public static class named RegionManagerCustomExtensions in any place accessible to where you want to be able to use it.
2. Add a reference to the Assembly Microsoft.Practices.ServiceLocation(located in the ~DecompressionPath\LIB\Desktop\CommonServiceLocation folder)
3. Add the following using statements to the  RegionManagerCustomExtensions class:
   

   using System;
   using System.Collections.Generic;
   using System.Linq;
   using System.Text;
   using Microsoft.Practices.Composite.Regions;
   using Microsoft.Practices.ServiceLocation;

4. Add a method named RegisterViewWithRegionInIndex with that has the following code:

public static IRegionManager RegisterViewWithRegionInIndex(this IRegionManager regionManager, string regionName, Type viewType, int index)
       {
           IRegion mainRegion = regionManager.Regions[regionName];
           int viewsAmount = mainRegion.Views.Count();
           if (index > viewsAmount)
           {
               throw new IndexOutOfRangeException("Tried to add a view to a region that does not have enough views.");
           }

           if (index < 0)
           {
               throw new IndexOutOfRangeException("Tried to add a view in a negative index.");
           }

           object activeView = null;

           if (mainRegion.ActiveViews.Count() == 1)
           {
               activeView = mainRegion.ActiveViews.First();
           }

           var regionViewRegistry = ServiceLocator.Current.GetInstance<IRegionViewRegistry>();

           // Save reference to each view existing in the RegionManager after the index to insert.
           List<object> views = mainRegion.Views.SkipWhile((view, removeFrom) => removeFrom < index).ToList();

           //Remove elements from region that are after index to insert.
           for (int i = 0; i < views.Count; i++)
           {
               mainRegion.Remove(mainRegion.Views.ElementAt(index));
           }

           //Register view in index to insert.
           regionViewRegistry.RegisterViewWithRegion(regionName, viewType);

           // Adding previously removed views
           views.ForEach(view => mainRegion.Add(view));

           if (activeView != null)
           {
               mainRegion.Activate(activeView);
           }

           return regionManager;
       }

Putting the method to use

You should be able to use the method now. To test it, I created a couple of extra views in the HelloWorld Quickstart and wrote the following code in the HelloWorldModule class:

manager.RegisterViewWithRegionInIndex("MainRegion", typeof(Views.HelloWorldView), 0);
manager.RegisterViewWithRegionInIndex("MainRegion", typeof(Views.View1), 1);
manager.RegisterViewWithRegionInIndex("MainRegion", typeof(Views.View2), 1);

The outcome was the following. As you can see, View2 was placed where View1 was located:

The method could also be customized to add views to the latest index possible if the index to insert the view into was higher than the amount of views previously existing in the region.

Let me know if you find a good use to this method.

Therefore, I started doing some digging and found out that UI Virtualization could do the trick. This basically means that the process of showing a specific item in an ItemsControl is postponed until the item is within visibility range.

The ListView and ListBox controls have UI Virtualization enabled by default when their items are bound to data. In other ItemsControls, like TreeViews, it can be enabled using the VirtualizingStackPanel.IsVirtualizing attached property.

In the .NET Framework 3.5 SP1 an addition was made to improve UI Virtualization which is Container Recycling. You can read more about UI Virtualization and Container Recycling in this article:

• Optimizing Performance: Controls

Applying Theory to Practice

I opened the ViewDiscoveryComposition Quickstart from the latest Prism-v2 Drop and modified the Employee Service class’ (located in the Employees Module) implementation for the following one and ran the application:

public class EmployeeService : IEmployeeService
    {
        public ObservableCollection<BusinessEntities.Employee> RetrieveEmployees()
        {
            ObservableCollection<BusinessEntities.Employee> employees =
                new ObservableCollection<BusinessEntities.Employee>();
            for (int i = 1; i < 40001; i++)
            {
                employees.Add(new BusinessEntities.Employee(i)
                { FirstName = "John" + i,
                    LastName = "Smith", Phone = "+1 (425) 555-0101",
                    Email = "john.smith@example.com", Address = "One Microsoft Way",
                    City = "Redmond", State = "WA" });
            }

            return employees;
        }
    }

In fact, the list of employees took ages to load. I got a little deeper and found in the article mentioned above that even if the ListView performs UI Virtualization by default there are some possible reasons why UI Virtualization could be accidentally disabled. One of them was that the list was unable to scroll through its content.

Once I checked the EmployeeListView.xaml file,  I realized that it had no specified height nor implicitly showed a vertical scroll bar. The following modification in the ListView declaration was the one that made the trick:

<ListView x:Name="EmployeesList" ItemsSource="{Binding}"
SelectionChanged="EmployeesListView_SelectionChanged"
Height="250" ScrollViewer.VerticalScrollBarVisibility="Visible">

I run the application again and it took no more than one second to load the list view.

I hope you can find some good use for this. Let me know if you do.

Other posts in this series

• Event Broker QS
• Module Loader QS
• Smartpart QS
• Command QS

BankTeller QS

This is a list of the procedures in this post

• Startup
• BankTellerModuleInit
• BankTellerWorkItem Show
• Accept Customer
• Customer List SelectedIndexChanged
  • Customer WorkItem Show
  • CustomerSummaryView
    • Customer Header View
    • CustomerDetailView
    • CustomerAccountsView
• Customer Map
• Customer Summary Controller
• CustomerWorkItem
• BankShellForm
• ShowCommentButton Click
• SaveButton Click

Startup

1. The shell defines the root WorkItem as the default WorkItem provided by CAB, and the starting view as BankShellForm.
2. The shell executes the Run() method. This method calls the LoadModules() method in the CabApplication class.
3. The LoadModules() method obtains the modules (.dll) by using the FileCatalogModuleEnumerator.EnumerateModules() method. What it does is search for Assembly file names in the ProfileCatalog.xml.
4. The shell then overrides the AfterShellCreated() method registering ExtensionSites by using the hardcoded strings in the UIExtensionConstants class.
   1. mainMenuStrip
   2. mainStatusStrip
   3. file menu item
   4. file menu drop-down section

UIExtensionSiteCollection Class

5. Then the LoadFromConfig() method from the UIElementBuilder class is called.

1. 1. Gets the “shellitems” section from App.config file.
   2. Exeutes a foreach (statement) MenuItemElement in the section, convert it to a ToolStripMenuItem (uiMenuItem).
   3. Adds the ToolStripMenuItem to the ExtensionSite collection in the WorkItem.
   4. If the menuItem has a CommandName, add a Command to the WorkItem registering the click event.

6. The BankTellerModuleInit (ModuleInitializer) is executed.

BankTellerModuleInit

1. Uses the [Injection Constructor] which makes it the constructor to be used for Dependency Injection. It gets the WorkItem by using [Service Dependency].
2. The Load() method adds the “Customer” ToolStripMenuItem by adding it to the UIExtensionSites Collection in the WorkItem.
3. Then retrieves the Content and Sidebar WorkSpaces (with names harcoded in WorkSpacesConstants class).
4. Adds a CHILD WorkItem named BankTellerWorkItem and calls its Show() method.

BankTellerWorkItem Show

1. Creates a new object UserInfoView and adds it to the WorkItem.Items collection, giving it an ID (“UserInfo”) because it will be used in a place holder. (Remember that: The SmartPartPlaceHolder placeholder control has the SmartPartName property that automatically displays a SmartPart with that name if it is found within the current WorkItem.)
2. The Constructor gets the CurrentPrincipal property of the current Thread and displays the name of the user.
3. Creates a SideBarView and adds it to the WorkItem.Items collection. Then assigns it to a SideBarView instance named sideBarView.
4. Then calls the AddMenuItems() method.
   1. Creates a new ToolStripMenuItem (“Queue”)==> queueItem
   2. Adds the queueItem to the WorkItem.ExtensionSites[“File”] collection.
   3. Then registers a new site [“Queue”] in the queueItem.DropDownItems collection.
   4. Creates a new ToolStripMenuItem (“AcceptCustomer”) ==> acceptCustomer.
   5. Sets shortcut keys for acceptCustomer.
   6. Adds the acceptCustomer ToolStripMenuItem to the [“Queue”] extension site.
   7. Adds a new CommandInvoker to the Command[“QueueAcceptCustomer”] using acceptCustomer as the Invoker and “Click” as the EventName. Father WorkItem
5. Calls sideBar(IWorkSpace).Show method, passing sideBarView as a SmartPart parameter.
6. Activates the WorkItem (this.Activate()).
7. The BankTellerWorkItem overrides the OnActivated method, setting the bool ShowQueueMenu = true; which uses set{} to make the ToolStripMenuItem queueItem.Visible = true;
8. The SideBarView DESIGNER has a design time (redundant) addition of the CustomerQueueView SmartPart.
9. The CustomerQueueView uses dependency injection [CreateNew] to initialize the CustomerQueueController.
10. Also registers the CommandHandler for the [“QueueAcceptCustomer”] command.

Accept Customer

(Event Handler)

1. Registers the (“QueueAcceptCustomer”) [CommandHandler], which is referenced by acceptCustomer ToolStripMenuItem. The Event Handler is also subscribed to by the btnNextCustomer Click Event.
2. Calls the GetNextCustomerInQueue() method from the CustomerQueueController.
3. The GetNextCustomerInQueue() method calls the CustomerQueueService(which was initiated with [ServiceDependency] attribute) GetNext() method.
4. The GetNext() method returns a new Customer.
5. The view adds the Customer to the ListItem.Item Collection.

Customer List SelectedIndexChanged

1. Retrieves the selected Customer from the list.
2. Calls the CustomerQueueController.WorkWithCustomer(customer) method.
3. This method calls the BankTellerWorkItem.WorkWithCustomer (customer) method.
4. Creates a string keyè “Customer#” & {customer.ID}
5. If the CustomerWorkItem for that customer has been created it gets it. Else it adds a new one.
   1. Assigns the CustomerWorkItem with the KEY to workItem object and adds it to father WorkItems collection.
   2. Sets the CustomerWorkItem ID, and .State[“Customer2”] = customer.
   3. If the BankTeller PersistanceService ! null & contains the WorkItem.ID, load() the workItem.
   4. This method uses the Services<Collection>.Get() method, to get the FileStatePersistance service, in order to be able to get a previously saved customer state.
6. Calls the CustomerWorkItem.Show() method.

Customer WorkItem Show

1. Assigns to CustomerSummaryView object the previously existing one if !null (?? operator), or adds a new view to the CustomerWorkItem.Items (Collection).
2. The calls the WorkSpace(father).Show() method using CustomerSummaryView object as a parameter.
3. Calls the AddMenuItems() method.
   1. Creates a new instance ToolStripMenuItem named editCustomerMenuItem.
   2. Adds the ToolStripMenuItem to the CustomerWorkItem UIExtenstionSites[“BankTellerModule.CustomerMenu”] Collection.
   3. In the WorkItem’s Commands[“EditCustomer”] adds an invoker from the editCustomerMenuItem Click Event handler.
   4. In the WorkItem’s Commands[“CustomerMouseOver”] adds an invoker from the customerSummaryView (CustomerSummaryView instance) MouseHover Event handler.
4. Gets the customer from the WorkItem’s state.
5. Calls OnStatusTextUpdate() method, passing as parameter the first and last name of the customer in a string.
   1. Raises the UpdateStatusTextEvent which is published [EventPublication] in the begginnig of the WorkItem.
   2. The BankShellForm has an EventSubscription, OnStatusUpdate().
   3. Changes the label.Text to (“Editing {FirstName} {LastName}”)
6. Calls the UpdateUserAddressLabel() method.
   1. Instances a new ToolStripStatusLabel named addressLabel.
   2. Adds to the UIExtensionSites (collection)[“MainStatus”] the addressLabel.
   3. Sets the text property of the label to the customer.Address1.
7. Activates the WorkItem.
8. Calls the SmartPart CustomerSummaryView.FocusFirstTab(), which sets the SelectedTab to [0].

CustomerSummaryView

1. The CustomerSummaryView has a TabWorkSpace which inside has:

• CustomerHeaderView
• CustomerDetailView
• CustomerAccountsView

CustomerSummaryView.Designer.Cs

Customer Header View

1. The CustomerHeaderView uses the [State] attribute to get the current customer from the Parent WorkItem.
2. The load event binds the customer to the CustomerHeaderView.BindingSource.

CustomerDetailView

1. The CustomerDetailView uses [ServiceDependency] to get a reference to the parent WorkItem.
2. It also uses the [State] attribute to get the current customer from the Parent WorkItem.
3. Then uses the [CreateNew] attribute to instantiate the CustomerDetailController.
4. The overridden OnLoad() method sets the customer to the CustomerDetailView.BindingSource.

CustomerAccountsView

1. The CustomerAccountsView uses the [State] attribute to get the current customer from the Parent WorkItem.
2. Uses [ServiceDependency] to get a reference to CustomerAccountService.
3. Overrides the OnLoad() method to call the accountService.GetByCustomerID (Customer.ID), which gets a ListDictionary<> of accounts and sets it as the datasource for the DataGrid.

Customer Map

1. The Customer Map (third tab) is loaded from the CustomerMapExtensionModule.dll when the application starts because it is in the ProfileCatalog.xml. It contains a [SmartPart] (CustomerMap) and a CustomerWorkItemExtension.
2. The CustomerWorkItemExtension overrides the OnActivated() method.
   1. Adds a CustomerMap smartpart to the WorkItemExtension.Items collection, and assigns the smartpart to mapView (CustomerMap instance).
   2. Creates a TabSmartPartInfo (A SmartPartInfo that shows how a specific SmartPart will be shown in a tab Workspace) named info.
   3. Assigns valus to title and description properties:
   4. Calls the WorkItem.WorkSpaces[“tabbedWorkSpace1”].Show() method, passing as parameters the CustomerMap Smartpart and the SmartPartInfo.
3. The CustomerMap SmartPart gets a Customer instance using [State(“Customer 2”)]

Customer Summary Controller

The OnCustomerEdit event handler is declared as a [CommandHandler(“EditCustomer”)]

1. Assigns to a tabWorkSpace tabWS the WorkItem.WorkSpaces[“tabbedWorkSpace1”] using as cast (if it is not able to do it return null)
2. Sets the tabWorkSpace.SelectedIndex to 0, allowing customer Editing.

CustomerWorkItem

1. The OnCustomerEdit event handler is declared as a [CommandHandler(“CustomerMouseOver”)] and executes when the user moves the mouse over the CustomerSummaryView SmartPart.
2. If the WorkItem.Status is active, displays a ToolTipText indicating the ID of the customer being edited.

BankShellForm

1. Registers the OnStatusUpdate event handler [EventSubscription] using the topic (“topic://BankShell/statusupdate”). This event is published in the CustomerWorkItem.
2. Updates the toolStripStatusLabel1.Text with the data from the customer.

ShowCommentButton Click

1. Calls the OnShowCustomers event handler.
2. Calls the Controller.ShowCustomerComments() method.
3. The Controller.ShowCustomerComments() method calls the WorkItem.ShowCustomerComments() method.
4. Calls the CreateCommentsView() method.
   1. Assigns to commentsView (CustomerCommentsView instance) the previously existing one if !null (?? operator), or adds a new view to the CustomerWorkItem.Items collection.
   2. Declares info as a new tabSmartPartInfo. Assigns info.Title = “Comments”.
   3. Calls the WorkItem.RegisterSmartPartInfo() method passing as parameters (commentsView, info)
5. Assigns to ws (which implements IWorkSpace Interface) WorkItem.WorkSpaces[“tabbedWorkSpace1”].
6. ws.Show(commentsView);

SaveButton Click

1. Calls the Controller.Save() method
2. The Controller.Save() method calls WorkItem.Save() method.
3. Declares an IStatePersistanceService service and gets the Services.Get <IStatePersistanceService>
4. Saves the changes using the service and calls the state.AcceptChanges() method to reset the HasChanges “flag”.

Technorati Profile

Other posts in this series

• Event Broker QS
• Module Loader QS
• Smartpart QS
• BankTeller QS

For more information about CAB see:

• http://msdn.microsoft.com/en-us/library/aa480450.aspx
• CAB introduction posts (Spanish) by Mariano
• Composite UI Application Block(Spanish) by Jonathan

Commands QS

This is a list of the procedures in this post

• Startup
• Menu Item Clicking

Startup

1. The shell defines the MainWorkItem as the root WorkItem and the ShellForm as the first view.
2. The overridden AfterShellCreated() method assigns to fileitem = ToolStripMenuItem [“File”].
3. An ExtensionSite is registered in the MainWorkItem, named “File” and is a DropDownItem.
4. The MainWorkItem overridden OnRunStarted() creates a new instace of the MainController and adds it to the Workitem’s Item Collection.
5. The ProcessCommandMap() method is called, which:
   • Loads Command Configuration File.
   • Executes a foreach statement in the CommandMap.Mapping [array]
     • Creates a ToolStripMenuItem (MenuItem.Text = mapping.Label)
     • Adds to the [“File”] Extension Site (using mapping.Site as the parameter) the ToolStripMenuItem.
     • Adds to the Commands (Collection) the invoker for the “Click” event using the AddInvoker() method.
6. Activates the WorkItem.

Menu Item Clicking

1. The CommandHandler related to the click event raised by the item is called.
2. There are two kind of CommandHandlers now.
   1. The ShowCustomerHandler that MessageBox.Show(“”);
   2. The status kind. These 3 change the CommandStatus according to the ToolStripMenuItem pressed. (Enabled|Disabled|Unavailable(not visible in this case))
   3. The ToolStripItemCommandAdapter “listens” to the CommandChanged event, and based on it changes the Enabled/Visible property of the ShowCustomerHandler ToolStripMenuItem.

The next and final post in the series will cover the BankTeller QS.

Other posts in this series

• Event Broker QS
• Module Loader QS
• Commands QS
• BankTeller QS

For more information about CAB see:

• http://msdn.microsoft.com/en-us/library/aa480450.aspx
• CAB introduction posts (Spanish) by Mariano
• Composite UI Application Block(Spanish) by Jonathan

SmartPart QS

This is a list of the procedures in this post:

• Startup
• SelectedIndexChanged Event (ListView)
• Comments Button

Startup

1. The shell defines BrowseCustomerWorkItem as the default WorkItem and MainForm as the starting view.
2. The List is set in the OVERLOADED BeforeShellCreated() method.
3. The Run() method is called in the root WorkItem (BrowseCustomerWorkItem).
4. The OnRunStarted() method at BrowseCustomerWorkItem starts the CustomerView SmartPart in the MainForm’s Workspace.
5. The customer view is split (SplitContainer) between a CustomerListView SmartPart and a DeckWorkspace.
6. Using Dependency Injection [CreateNew] initializes a new instance of CustomerControllers.
7. The CustomerControllers gets the list of Customers ([State("Customers")])
8. The OnLoad() event handler fills the customers at the Controller and by using the State updates List<Customers> in the view to fill the ListBox.
9. Then it registers the SelectedIndexChanged event from the ListBox.

SelectedIndexChanged Event (ListView)

1. The SelectedIndexChanged event fires and calls the controller’s ShowCustomerDetails() Method, passing the customer as a parameter.
2. The controller then calls the ShowCustomerDetails() method of the BrowseCustomersWorkItem.
3. The ShowCustomerDetails() method injects the “Customer” State into Child Workitems.
4. It then adds a new ViewCustomerWorkItem (as a child WorkItem) and assigns the customerWorkItem.Customer property to the current “Customer” State.
5. The customerWorkItem.Run() Method is called passing the CustomersDeckedWorkspace as a parameter.
6. The Run method creates the views to be used by the WorkItem (CustomerTabView, which has the DetailsView in the CustomerTabView designer (this.customerDetailView1 = new SmartPartQuickStart.ViewCustomerWorkItem.CustomerDetailView();), and the CustomerSummaryView)
7. Then calls the workspace.Show() method, with the CustomerTabView as a parameter, to show the view in the workspace.
8. The CustomerDetailView uses dependency injection to [CreateNew]CustomerController (no “s”).
9. The OnLoadMethod adds the customer to the controls.

Comments Button

1. Gets the [State (“Customer”)] from the ViewCustomerWorkItem.
2. The OnLoad() event handler adds the Customer (provided by the State) to the BindingSource.
3. Fires the Click event handler.
4. Calls the CutomerController ShowCustomerComments() method.
5. By using [Service Dependency], the Controller gets a reference to ViewCustomerWorkItem.
6. Then the ShowCustomerComments() method calls the ViewCustomerWorkItemShowCustomerComments() method.
7. Creates a Workspace called tabbedspace.
8. Adds a CustomerCommentsView SmartPart to the ViewCustomerWorkItem.
9. The CustomerCommentsView:
   1. Creates a new SmartPartInfo and assigns (“Comments”) to the SmartPartInfo title.
   2. Registers the SmartPartInfo to the CustomerCommentsView.
   3. Shows the tabbedspace (WorkSpace).

The next post will be about the Commands QS, be sure to read it.

Other posts in this series

• Event Broker QS
• SmartPart QS
• Commands QS
• BankTeller QS

For more information about CAB see:

• http://msdn.microsoft.com/en-us/library/aa480450.aspx
• CAB introduction posts (Spanish) by Mariano
• Composite UI Application Block (Spanish) by Jonathan

Module Loader QS

This is a list of the procedures in this post:

• Run
• Get Latitude Button
• Get Distance Button

Run

1. The shell loads the GPSModule.dll MODULE specified in ProfileCatalog.xml, and gets there by using default implementations from the CAB.
2. Gets the ROOTWORKITEM by using ServiceDependency (is a dependency in a service and will be dependency injected when added to a work item)
3. The Load Method, adds a SampleWorkItem from the GPS module (DOES NOT EXIST IN CAB STRUCTURE).
4. The SampleWorkItem overloads the OnRunStarted Method.
5. The OnRunStarted Method:
   1. Calls base.OnRunStarted.
   2. References to the Deck Workspace ["MainWorkSpace"] on the MainForm.
   3. Shows the workspace by previously adding GPSview as a SmartPart.
6. The GPSview gets the values from GPSService, because it has a Service Dependency.
7. The GPSService has a service attribute (means that it is automatically loaded into the WorkItem).
8. The reason a message box appears the first time the GetDistance Event is triggered is because the DistanceCalculatorService has a service attribute containing the property (AddOnDemand = true) ([Service(typeof(IDistanceCalculatorService), AddOnDemand = true)]).

Get Latitude Button

1. The button event is fired.
2. The event handler calls the IGPSService.GetLatitude() Method.

GPSService has the [Service(typeof(IGPSService))] meaning that when the methods described in the service are executed the ones called are in GPSService NOT IGPSService (the class, not the interface).

Get Distance Button

1. The IDistanceCalculatorService.ComputeDistance() Method is called by the event handler passing as values the Latitude and Longitud from the GPSService.
2. The results return because the DistanceCalculatorService has the [Service(typeof( IDistanceCalculatorService))] meaning that when the methods described in the service are executed the ones called are in DistanceCalculatorService has NOT IDistanceCalculatorService (the class, not the interface).

The next post will be about SmartPart QS, so don’t go anywhere.

Other posts in this series

• Module Loader QS
• SmartPart QS
• Commands QS
• BankTeller QS

For more information about CAB see:

• http://msdn.microsoft.com/en-us/library/aa480450.aspx
• CAB introduction posts (Spanish) by Mariano
• Composite UI Application Block(Spanish) by Jonathan

Event Broker QS

This is a list of the procedures in this post:

• Add Customer Button
• Show List Button
• Add Local Button
• Add Local Button
• Add Global Button
• Process Local Button (Makes Local be Global)

Add Customer Button

1. View uses button event to communicate with controller.
2. Controller adds customer in controller logic, and raises State Changed Event.
3. The view which is suscribed to this event updates the list data source.

Show List Button

1. View uses button Event to call method.
2. Calls Controller method: ShowCustomerList.
3. Creates a new workitem and adds it as a child for the one being used.
4. Passes the current workitem’s State to the child workitem (Using a List, Empty)
5. Adds a form as a View (to the Item Collection) to the child workitem.
6. The view’s constructor creates a new list [Create New] & gets the state using the State attribute.
7. The OnLoad Event Handler suscribes to both the State change event in the workitem, as well as a event raised by a change of State in the parent workitem.
8. Displays the new View.

Add Local Button

1. Calls Event for the button.
2. If there’s something in the text box it calls the controller’s add local customer method passing id.
3. Adds customer to list
4. Raises event StateChanged.
5. The event handler referred to the State Changed in the view is executed.
6. The data source for the list is re-assigned.

Add Global Button

1. Calls event for the button.
2. If there is text calls Controller’s addGlobal Method passing id.
3. Raises the GlobalCustomerAdded Event, passing customer ID as event args.
4. The [EventPublication("topic://EventBrokerQuickStart/CustomerAdded")] in the controller “publicates” the event
5. This calls the method OnCustomerAdded in the LaunchPadController, because it is suscribed to the topic.
6. The OnCustomerAdded calls the AddCustomer Method from the LaunchPadController.
7. The method adds the customer to the customer List
8. The State Changed Event is raised.
9. Both Views (CustomerListView & LaunchPadForm) update their list’s datasources because they are suscribed to the event.

Proccess Local Button (Makes Local customers be Global)

1. Calls the event for the button.
2. Calls CustomerListController ProcessLocalCustomer Method.
3. If nothing is being processed assign the local customer list to DictionaryEventArgs.
4. Fire the “topic://EventBrokerQuickStart/StartProcess” topic.
5. CustomerListController has an EventSubscription to that topic, calling the StartProcessHandler (Thread = Background, runs on a separate thread).
6. Gets the list of customers to process from the dictionary.
7. Calls the OnProgressChanged Method that raises the ProgressChanged event.
8. The “topic://EventBrokerQuickStart/ProgressChanged” topic is suscribed to by the ProgressChangeHandler. The ProgressView updates its value by suscribing to this event.
9. Calls the AddGlobalCustomer Method that fires the GlobalCustomerAdded event.
10. The LaunchPadController suscribes to the GlobalCustomerAdded event, calling the add customer method, thus adding a customer to the customer list.
11. Raising the StateChangedEvent so the list updates its data source (The CustomerListController Clears the customers list, then raises the State Changed and Creates a progress view ).
12. The on process completed method is called in the StartProcessHandler, firing the ProcessCompleted event.
13. The ProcessCompleted eventhandler updates the processing status to false.

The next post will be about the Module Loader Quickstart, stay tuned.

To my understanding the delegate was a way of grouping methods with similar characteristics. i.e.:

void createdata(); & void destroydata(); void methodname (no parameters);


int add (int a, int b); & int substract(int a, int b); int methodname (int, int);

Once grouped into a single delegate they could be called at once. This was really similar to what the event did. It could group either methods or delegates (who at the same time group methods, otherwise they would be pointless to have).

The only difference I could find was that while the delegate is declared i.e.:

delegate void Accelerate();

the event containing the TakeOff() delegate would be declared some sort of:

event Accelerate PushLever;

being event only a modifier.

Some research (http://blog.monstuff.com/archives/000040.html is the web page where I got the information to help me understand some of this) showed me the some differences between the two of them:

• Events can be included in an interface, delegates cannot.
• Events’ scope for invocation only includes the class that declares it, delegates depend on their modifier (public | private| protected)
• Events come with their own custom “get and set” accessors for getting or removing other methods (add, remove)
• The signature of any delegate that is used as an event should be: “The signature should be foo(object source, EventArgs e), where source is the object that fired the event and e contains any additional information about the event.”(http://blog.monstuff.com/archives/000040.html)

From my point of view without thinking about programming semantics, an event, as the word states is easier to imagine representing something that happens in real life as a result of an action. This thing that happens triggers a set of actions (the delegate). Each small action of this set would be the methods assigned to this delegate.

Back to the plane example, the event is pushing the lever. The objective of doing this is getting the plane to take off. In order to do this, the plane must accelerate thus making the engines work harder (method) and set the wings straight(method). (Maybe the plane wasn’t the best example since I clearly don’t know how it works, but I hope you can get the point).

Here’s a summary of what I read:

Variables:

A variable is a memory location that holds a value. You name it, so its name makes reference to what it holds.

Naming conventions:

·         You must not use underscores.

·         Don’t difference them by case only. (Variable, variable).

·         Use camelCase notation (multiword only, first word start with lower case in the first letter, then for other words use upper case for first letter and continue in lower).

Declaration of variables is done by writing the type of it and its name. i.e.: int number;

Methods:

Methods are “sequences of statements“(Microsoft Visual C# 2005 Step by Step, John Sharp). They have a name (refers to what the method does) and the body (step by step of what the method will do).

Declaring a method:

returntype methodName (parameterList)

{

                body statements

}

The return type represents the type of information the method will return (or void if it returns nothing). The parameter list are the different things the method needs to do what it’s supposed to (i.e.: numbers, words, lists, etc.). When you want your method to return information you use the return keyword. The return statement must return the same type specified by the functions return type.

Method calling is done as following: methodName (parameterList);.

Scopes: The scope is the location of the program where a variable can be used. A method’s scope is defined by “{}”. Everything inside them is within the method’s scope, meaning that variables in the scope can be used by the method.

Overloads: Overloaded methods are those that have the same name inside the same scope. The difference between them is their parameterList.

i.e.:        CalculateArea (int base, int height){}

                CalculateArea (int base, int height,  string type){}

When the CalculateArea method is called, the compiler will define which one it is depending on its parameterList. The same method can’t have an overload with the same types and amounts. i.e.:                 WriteText(string title){}

                WriteText(string body){}

Decision Statements:

Boolean operators are those that return true/false. The most common are:

ü  == equal to

ü  != not equal to

ü  < less than

ü  <= less or equal than

ü  > more than

ü  >= more or equal than

ü  && (AND). The outcome of it is true only if BOTH expressions are true.

ü  || (OR). The outcome of it is true if either one of the expressions is true.

If Statements:

If you want to choose between executing different block of codes, depending on the result of a Boolean expression, you can use an if statement.

Syntax:

 if (Boolean expression){

block 1

}else{

block 2

}.

If statements can also be used in a cascade manner:

if (i==1){

block 1

}else if (i==2){

block 2

}

else if (i==3){

block 3

}

Else{nothing}.

By doing this you say: if the first statement isn’t true, then do the second one. If that one isn’t true do the third one. The last one is in case none of the statements are true.

Switch Statements:

An easier way of cascading if the statements are similar is a switch statement. You’re simply telling, if the expression is this one come here, if it’s this other one go there. i.e.:

Switch (intDay)

{case 1: do this

 break;

case 2: do this

 break;

case 3: do this

 break;

default: do this

                break;

}

 This way you only go to one of the blocks. If none of them are equal then the default block is executed. The break keyword finishes the switch statement.

Rules for switch:

Ø  You can only use them on primitive data types (such as int, string).

Ø  “The case labels must be constant expressions”(Microsoft Visual C# 2005 Step by Step, John Sharp) (1, “1”). If they’re not use an IF statement.

Ø  “Two case labels cannot have the same value.”(Microsoft Visual C# 2005 Step by Step, John Sharp)

Ø  You can use the same statements for more than one label. But you can’t use different statements for the same label.

(i.e.:        case Monday:

                case Tuesday: do this (this is correct)

Break;                                  

case thursday:

do this

            case friday: do this (this is NOT correct, )

Break;                                                                   )

You need to stop the cascading, this is generally done by using BREAK.