Alex Yakhnin's Blog : MVC

Update to MobileMVC with Container

priozersk — Thu, 23 Apr 2009 03:56:00 GMT

I've recently made a substantial update to the MobileMVC framework. I've added the ability to utilize a (D)epenendcy (I)njection container by adding IControllerProvider interface into the framework which looks like this:

public interface IControllerProvider

{

Controller GetController(string name);

Controller GetController(Type type);

Controller GetController<T>();

Controller GetController<T>(IView view);

void RegisterController(Controller controller);

}

This interface gets used in the new class Navigator which could be used instead of NavigationService to navigate between the controllers since it implements the same methods such as Navigate, GoBack, GoForward etc... The Navigator class is exposed as a singleton via the property in the Controller class:

/// <summary>

/// Gets an instance of the Navigator.

/// </summary>

public Navigator Navigator

{

get

{

return Navigator.Current;

}

The Navigator class also includes the following static method:

/// <summary>

/// Sets the IControllerProvider to use.

/// </summary>

/// <param name="controllerProvider"></param>

public static void SetControllerProvider(IControllerProvider controllerProvider)

{

if (navigator == null)

{

navigator = new Navigator(controllerProvider);

}

As you can see the SetControllerProvider method accepts as a parameter an instance of the IControllerProvider which you will need call when your application is initialized.

Before diving into the full usage sample let's talk about the DI container. As we know, there's not much of the DI and IoC containers exist for .NET CF right now, however Paterns & Practices team has been quetly working on the update of the Mobile Application Blocks that where released a few years back. P&P has recently posted a Community Drop of the code refresh for the Mobility Block on the Codeplex and it includes the new block which is called ContainerModel. P&P has decided to utilize the Funq container that was developed by Daniel Cazzulino. So, I've taken this container and updated the sample for the MobileMVC to make a use of it.

Let's continue on the sample of how you can utilize the new features in the MobileMVC framework. I have modified the existing sample MVCDemoClient (a part of the download of the framework), so let's see how we'd initialize container with the views and controllers:

private static void Initialize()

{

container = new Container();

// Register Login view and controller

container.Register<LoginForm>(c => new LoginForm());

container.Register<LoginController>(c =>

new LoginController(c.Resolve<LoginForm>()))

.InitializedBy((c, v) => v.Container = c);

// Register Search view and controller

container.Register<SearchForm>(c => new SearchForm());

container.Register<SearchController>(c =>

new SearchController(c.Resolve<SearchForm>()))

.InitializedBy((c, v) => v.Container = c);

// Register Search view and controller

container.Register<DetailForm>(c => new DetailForm());

container.Register<DetailController>(c =>

new DetailController(c.Resolve<DetailForm>()))

.InitializedBy((c, v) => v.Container = c);

// Register data model

container.Register<Products>(c => new Products());

// Set ControllerProvider

Navigator.SetControllerProvider(new ControllerProvider(container));

}

In the code above when we register a controller, you can see that we call: .InitializedBy((c, v) => v.Container = c). This means that when an instance of the controller will be created we want to assign the same instance of the container to the Container property which I've added to the controller. We also make a call to the SetControllerProvider method and passing and instance of the ControllerProvider class which as you can guess implements IControllerProvider interface and makes use of the Container:

public class ControllerProvider : IControllerProvider

{

private Container container;

public ControllerProvider(Container container)

{

this.container = container;

}

#region IControllerProvider Members

public Controller GetController<T>()

{

return this.container.Resolve<T>() as Controller;

}

public Controller GetController<T>(IView view)

{

Controller controller = this.container.Resolve<Controller>();

controller.View = view;

return controller;

}

// … Other methods ommitted for brevity

#endregion

}

After this short preparation we can now modifiy our code to use the Navigator class. This is how we can show the SearchForm from the LoginController:

private void ShowSearchView()

{

//SearchController controller = new SearchController(new SearchForm());

//NavigationService.Navigate(controller);

this.Navigator.Navigate<SearchController>();

}

Ability to access the Container from the controller is also giving us much more separation from the Data Model or other services that you may use in the application. For example this is how we can get access to the Products data model in the SearchController:

// ViewLoaded event from the view

private void OnViewLoaded(object sender, EventArgs e)

{

// Show busy cursor

Cursor.Current = Cursors.WaitCursor;

// Get an instance from the container

Products products = this.Container.Resolve<Products>();

// Populate data

products.PopulateList();

// Assign the Model

this.view.ViewData.Model = products;

// Notify the view of the changes

this.NotifyView();

// Restore the cursor

Cursor.Current = Cursors.Default;

}

Overall, I think the usage of the container with the MVC pattern gives you much more flexibility when designing your applications. It allows you to decouple the access to the application services giving you more room during the unit testing as well as making changes to the application without breaking too many dependencies.

You can find the updated version of the MobileMVC framework and the sample in the downloads section of the codeplex project:

http://mobilemvc.codeplex.com/Release/ProjectReleases.aspx?ReleaseId=26507

Mobile MVC on codeplex

priozersk — Tue, 11 Nov 2008 04:46:00 GMT

I've published the Mobile MVC framework on CodePlex:

http://www.codeplex.com/MobileMVC

Feel free to post your comments, bugs, suggestions in the project's discussions.

Mobile MVC framework (part 4) - passing data between controllers

priozersk — Wed, 05 Nov 2008 02:07:00 GMT

This is the part 4 of the series of the posts related to the Mobile MVC framework that I have described for you in my previous posts. I've updated the framework to handle the scenario of passing data between different controllers: the Controller class now implements two new methods:

public void Initialize(params object[] parameters)

and:

protected virtual void OnInitialize(params object[] parameters)

The NavigationService class has also been updated to support passing the parameters to its NavigateMethod:

public static void Navigate(string name, params object[] parameters)

public static void Navigate(Controller controller, params object[] parameters)

So in order to illustrate the usage scenario I've modified the MVCDemoClient sample by adding a new DetailForm (and its DetailController). This form displays the details of the Product selected on the SearchForm which looks like this:

The code for the SearchForm:

public partial class DetailForm : ViewForm,

IView<NorthwindDataSet.ProductsRow>

{

[PublishEvent("OnBack")]

public event EventHandler OnBackEvent;

public DetailForm()

{

InitializeComponent();

}

// Callback from the Controller

private void OnProductLoaded(object sender, EventArgs e)

{

// Load the product details into controls

this.txtProductID.DataBindings.Add("Text",

this.ViewData.Model, "ProductID");

this.txtProductName.DataBindings.Add("Text",

this.ViewData.Model, "ProductName");

this.txtUnitPrice.DataBindings.Add("Text",

this.ViewData.Model, "UnitPrice");

this.txtCategoryID.DataBindings.Add("Text",

this.ViewData.Model, "CategoryID");

}

#region IView<NorthwindDataSet.ProductsRow> Members

public new ViewDataDictionary<NorthwindDataSet.ProductsRow> ViewData

{

get;

set;

}

#endregion

#region event handlers

private void menuItemBack_Click(object sender, EventArgs e)

{

if (OnBackEvent != null)

{

OnBackEvent(this, EventArgs.Empty);

}

#endregion

}

And now the DetailController:

public class DetailController : Controller<NorthwindDataSet.ProductsRow>

{

[PublishEvent("OnProductLoaded")]

public event EventHandler ProductLoaded;

public DetailController(IView<NorthwindDataSet.ProductsRow> view)

: base(view)

{

}

// Selected event from the view

private void OnBack(object sender, EventArgs e)

{

// Move back to the search form

NavigationService.GoBack();

}

protected override void OnInitialize(params object[] parameters)

{

this.view.ViewData.Model = parameters[0]

as NorthwindDataSet.ProductsRow;

// Notify the view

if (this.ProductLoaded != null)

{

this.ProductLoaded(this, EventArgs.Empty);

}

In the code above, we override the OnInitialize method into which the parameters from the SearchForm will passed via NagivationService class like so:

private void ShowDetailView(NorthwindDataSet.ProductsRow product)

{

DetailController controller = new DetailController(new DetailForm());

NavigationService.Navigate(controller, product);

}

This ShowDetailView method is a part of the SearchConroller which is called when a user indicates that a Product has been selected in the ListBox on the SearchForm:

// Selected event from the view

private void OnSelected(object sender,

DataEventArgs<NorthwindDataSet.ProductsRow> e)

{

this.ShowDetailView(e.Value);

}

I have also added the Northwind.sdf database as well as the generated strongly typed dataset to the modified sample. This is why you should probably notice the NorthwindDataSet.ProductRow data type which is used to pass the Product data between the controllers. As usual, you can download the sample code with the updated MVC framework.

Mobile MVC framework (part 3) - communicating with events

priozersk — Thu, 16 Oct 2008 23:17:00 GMT

Just for people who are not comfortable with passing strings when notifiying the view or the controller, I've added the functionality to use events instead. You would not need to hook into the events explicitly because the controller will take care of this behind the scenes.

In order to demonstrate how to use this functionality I am going to modify the exising code for the SearchForm and the SearchController I created last time.

Let's start from adding the OnSearchEvent to the SearchForm class:

[PublishEvent("OnSearch")]

public event EventHandler<DataEventArgs<string>> OnSearchEvent;

As you can see the event declaration has a few peculiar things: I've applied the PublishEvent attribute which specifies the name of the event handler in the Controller. As a parameter I've used the DataEventArgs<T> class which is a part of the System.Mobile.Mvc assembly.

Since we are going to use the OnSearchEvent to notify the SearchController that the Search button has been clicked on the form, let’s modify the code on the button’s event handler to:

private void cmdSearch_Click(object sender, EventArgs e)

{

if (OnSearchEvent != null)

{

// Raise the event and notify the controller

OnSearchEvent(this, new DataEventArgs<string>(txtSearch.Text));

}

Now, we can move to the SearchController and add the event handler for the OnSearchEvent:

private void OnSearch(object sender, DataEventArgs<string> e)

{

this.view.ViewData.Model.FilterData(e.Value);

// Notify the view

this.NotifyView();

}

The obvious positive outcome of this change is the ability to pass a strongly typed parameter between the view and the controller.

In order to communicate back to the view from the controller we can use exactly the same technique - declare the event with the PublishEvent attribute in the controller:

[PublishEvent("OnProductsUpdated")]

public event EventHandler ProductsUpdated;

private void NotifyView()

{

// Raise the event for view

if (this.ProductsUpdated != null)

{

this.ProductsUpdated(this, EventArgs.Empty);

}

Here are the final versions of the SearchView and SearchController after modifications:

public partial class SearchForm : ViewForm, IView<Products>

{

[PublishEvent("OnSearch")]

public event EventHandler<DataEventArgs<string>> OnSearchEvent;

public SearchForm()

{

InitializeComponent();

}

private void OnProductsUpdated(object sender, EventArgs e)

{

this.lstProducts.DataSource = this.ViewData.Model.ProductList;

}

#region IView<Products> Members

public new ViewDataDictionary<Products> ViewData

{

get;

set;

}

#endregion

private void cmdSearch_Click(object sender, EventArgs e)

{

if (OnSearchEvent != null)

{

// Raise the event and notify the controller

OnSearchEvent(this, new

DataEventArgs<string>(txtSearch.Text));

}

private void menuItemBack_Click(object sender, EventArgs e)

{

NavigationService.GoBack();

}

And the controller:

public class SearchController : Controller<Products>

{

[PublishEvent("OnProductsUpdated")]

public event EventHandler ProductsUpdated;

public SearchController(IView<Products> view) : base(view)

{

// Create an intance of the Products

Products products = new Products();

// Populate the list

products.PopulateList();

// Assign the Model

this.view.ViewData.Model = products;

// Notify the view of the changes

this.NotifyView();

}

private void OnSearch(object sender, DataEventArgs<string> e)

{

this.view.ViewData.Model.FilterData(e.Value);

// Notify the view

this.NotifyView();

}

private void NotifyView()

{

// Raise the event for view

if (this.ProductsUpdated != null)

{

this.ProductsUpdated(this, EventArgs.Empty);

}

You should probably notice the usage of the new class - NavigationService - the class I've just added to the framework and which takes care of caching of the controllers as well as showing them and navigating back and forth in the view stack. It implements a few helpful methods:

public static void Navigate(Controller controller)

public static void GoBack()

public static void GoForward()

Download the project from here.

Mobile MVC framework (part 2)

priozersk — Mon, 13 Oct 2008 18:05:00 GMT

Last time I showed you how to create a simple Login Form and pass the data between the View and Controller using ViewData dictionary. In this post I am going to show you how to pass a strongly typed data.

We will continue working with code sample we created last time. We are going to add a new form to the project that will display a list of items in the ListBox as well as to allow filtering the data in this ListBox by entering the filtering criteria in the TextBox. Let's add the new form to the project with the name SearchForm wich should look like that:

The Model

Let's add the Products class to the project which is goind to contain the List of products and implement a few simple methods to populate the list as well as a method to filter the list by the certain criteria:

/// <summary>

/// Model class

/// </summary>

public class Products

{

private List<string> productList;

public List<string> ProductList

{

get

{

return productList;

}

set

{

productList = value;

}

public string ProductType { get; set; }

public void PopulateList()

{

productList = new List<string>();

productList.Add("Chicken");

productList.Add("Bread");

productList.Add("Tomato");

productList.Add("Cucumbers");

productList.Add("Butter");

productList.Add("Cheese");

ProductType = "Food";

}

public void FilterData(string filter)

{

if (filter != "")

{

IEnumerable<string> result = productList.Where<string>(s => s.ToString() == filter);

this.productList = result.ToList<string>();

}

else

{

PopulateList();

}

The next let's modify the SearchForm code file to inherit from ViewForm and implement the IView<TModel> interface. Initially I have implemented the ViewForm<TModel> class and thought that I would be able to inherit from it, but I hit the old bug in the Visual Studio form's designer that doesn't like the generics if you want to visual inheritance, so I had to resort to a few workarounds such as implement the IView<TModel> interface by the form:

public partial class SearchForm : ViewForm, IView<Products>

{

public SearchForm()

{

InitializeComponent();

}

#region IView<Products> Members

public new ViewDataDictionary<Products> ViewData

{

get;

set;

}

#endregion

}

Let's add the override for OnUpdateView to the form that will be called from the controller:

protected override void OnUpdateView(string key)

{

if (key == "Category")

{

this.lblProductType.Text = this.ViewData.Model.ProductType;

}

if (key == "Products")

{

// Bind the product list to the listbox

this.lstProducts.DataSource = this.ViewData.Model.ProductList;

}

and add the implementation for button event handler:

private void cmdSearch_Click(object sender, EventArgs e)

{

// Place the filter data into the ViewData

this.ViewData["Filter"] = txtSearch.Text;

// Notify the controller

this.OnViewStateChanged("Search");

}

Search Controller

When creating the SearchController we will derive it from the Controller<TModel> and make an appropriate calls to the Products class:

public class SearchController : Controller<Products>

{

public SearchController(IView<Products> view) : base(view)

{

// Create an intance of the Products

Products products = new Products();

// Populate the list

products.PopulateList();

// Assign the Model

this.view.ViewData.Model = products;

// Notify the view of the changes

this.view.UpdateView("Products");

}

protected override void OnViewStateChanged(string key)

{

switch (key)

{

case "Search":

string filter = this.view.ViewData["Filter"].ToString();

this.view.ViewData.Model.FilterData(filter);

// Notify the view of the updates

this.view.UpdateView("Products");

break;

}

Download the project from here.

Mobile MVC framework (part 1)

priozersk — Fri, 10 Oct 2008 18:02:00 GMT

In order to show you the Mobile MVC framework I came up with, let me walk you through the same excersise we did when I showed you the MVC pattern. Let's create a simple application with the same login form. Let's create a Smart Devices project and rename the Form1.cs to LoginForm.cs and add a few controls to the form:

We will add the reference to the System.Mobile.Mvc assembly and start with the Controller.

Login Controller

Let's add the LoginController class and derive it from the Controller which is defined in the System.Mobile.Mvc. We will also define the constructor that excepts IView as a parameter and overrige OnViewStateChange method:

public class LoginController : Controller

{

public LoginController(IView view)

: base(view)

{

}

/// <summary>

/// This method indicates that something has been changed in the view.

/// </summary>

/// <param name="key">The string key to identify what has been changed.</param>

protected override void OnViewStateChanged(string key)

{

base.OnViewStateChanged(key);

}

Next, let's modify the OnViewStateChanged to handle the Login event from the view:

protected override void OnViewStateChanged(string key)

{

// Check what's changed

if (key == "Login")

{

// The values are in the ViewData. Let's validate them and return the status to the view

if (view.ViewData["UserId"].ToString() == "Alex" && view.ViewData["Password"].ToString() == "password")

{

// Pass the status to the view

this.view.ViewData["Status"] = "Login succedded.";

}

else

{

// Pass the status to the view

this.view.ViewData["Status"] = "Login failed.";

}

// Notify the view of the changes to the status

this.view.UpdateView("Status");

}

if (key == "Exit")

{

Application.Exit();

}

LoginView

Switch to the code view of your LoginView form and change it to derive from ViewForm. Let's also implement some logic for the menuLogin_Click and menuExit_Click event handlers:

public partial class LoginForm : ViewForm

{

public LoginForm()

{

InitializeComponent();

}

private void menuLogin_Click(object sender, EventArgs e)

{

// Assign the values

this.ViewData["UserId"] = txtUser.Text;

this.ViewData["Password"] = txtPassword.Text;

// Notify the Controller

this.OnViewStateChanged("Login");

}

private void menuExit_Click(object sender, EventArgs e)

{

// Notify the Controller

this.OnViewStateChanged("Exit");

}

In the code for menuLogin_Click method we assign the values from the text boxes to the ViewData and make a call to the OnViewStateChanged to notify the controller of the event. Don't forget to pass the key which is used to recoginize what kind of event has happenned in the view.

All what is left here is to add an override for the OnUpdateView method to the LoginView which will be called when controller wants us to update the view:

protected override void OnUpdateView(string key)

{

// Controller requested to update the view

if (key == "Status")

{

// Update status label

this.lblStatus.Text = this.ViewData["Status"].ToString();

}

The last step is to wire up the controller and view together. You can do it by modifying the Main in the Program.cs:

[MTAThread]

static void Main()

{

LoginForm form = new LoginForm();

LoginController controller = new LoginController(form);

Application.Run(form);

}

That is all to the code sample for now. I think the adavantages over the previous implementation are obvious - a lot less of the code to write. Plus we get a certain structure in the way the data is being passed between the view and controller. You can download the demo project from here. I am looking forward to any feedback on the approach I've taken.

In the next posts I am going to show you how to pass strongly typed data between the layers (although, you should be able to guess it by looking at the MVC for ASP.NET).

Implementing MVC pattern in .NET CF applications (Part 2).

priozersk — Tue, 07 Aug 2007 04:44:00 GMT

Let's continue on the way how-to implement the model-viewer-controller pattern in .NET Compact Framework applications that I started in my previous post. We stopped at the point where we needed to figure out on how to connect the LoginController with the concrete instance of the LoginForm. Of course we can create an instance of the LoginController class when loading the LoginForm, but in this case we would break the decoupling by doing this. The better solution would be to create another class ApplicationManager that will be responsible for instantiation of the LoginForm (or any other forms that you will have in your application), keeping a memory cache of the loaded forms and displaying/hiding them. So here we go:

5. Create ApplicationManager class

public class ApplicationManager

{

#region fields

private static ApplicationManager appManager;

private Dictionary<string, IController> controllersCache;

#endregion

#region constructors

static ApplicationManager()

{

// Create an instance of itself for a singleton

appManager = new ApplicationManager();

}

public ApplicationManager()

{

controllersCache = new Dictionary<string, IController>();

}

#endregion

public static ApplicationManager Instance

{

get

{

return appManager;

}

public LoginForm GetLoginForm()

{

// Check if we already have the form in the cache

if (!controllersCache.ContainsKey("Login"))

{

controllersCache.Add("Login",

new LoginController(new LoginForm()));

}

return controllersCache["Login"].View

as LoginForm;

}

public void ShowLoginForm()

{

if (!controllersCache.ContainsKey("Login"))

{

controllersCache.Add("Login",

new LoginController(new LoginForm()));

}

controllersCache["Login"].View.Show();

}

I've implemented the ApplicationManager as a singleton. It creates an instance of its own in the static constructor and also implements the static property Instance to expose the singleton for consuming parts. It also includes the controllersCache dictionary that stores instances of the controllers with associated viewer in it.

OK, we are almost done here. Just one thing is left - to make a call to the ApplicationManager to get an instance of the LoginForm. For example, we can do it in the entry point of our application:

[MTAThread]

static void Main()

{

LoginForm form = ApplicationManager.Instance.GetLoginForm();

Application.Run(form);

}

So that is all to it. You should be able to take it from here: add more forms to the project and implement the view and controller for them. You can download the project from here, so you should be able to step through the code and see how it works.

Implementing MVC pattern in .NET CF applications (Part 1).

priozersk — Mon, 06 Aug 2007 04:09:00 GMT

I would like to start a series of posts devoted to best practices when designing mobile applications. So in this first post I will describe the MVC pattern that I have been using when creating CF applications for the customers.

I realize that a lot has been written on the subject, explaning what the MVC pattern is. If you don't know what it is, you can start from the Wikipedia. The main purpose of the MVC pattern is to decouple data access and business logic from data presentation and user interaction. While Mobile Client Software Factory developed by the P&P group implements it (actually it's a combination of MVP and MVC patterns), I think that their implementation is too heavy and slow for mobile devices. That's why I came up with my own implementation which I think is much more lightweight and simpler than the P&P one. So let's start, shell we?

For simplicity, I am going to create a very straightforward application that contains just a Login form.

1. Interfaces

First we need a few simple interfaces: IView and IController:

public interface IView

{

void Show();

void Hide();

void Close();

string Text { get;set;}

}

public interface IController

{

IView View

{

get;

set;

}

As you can see, IView interface essentially declares methods that exist in any Form, it means that we wouldn't even need to implement them.

2. Add a new form: LoginForm

Let's add a new form, drop a few textboxes and labels (txtUser and txtPassword), add menu items (Exit and OK). It should look like this:

Since it's a login form, the requirements should be obvious : when the OK menu is selected take the values from the text boxes and either compare them to some existing values from the local database or via a web service etc... and return the result to the same form and show it in the status label. If we would not use the MVC pattern, we'd just end up with the code that makes appropriate calls to let's say a web service directly in the OK menu event handler, making future modifications for the business logic or UI more difficult.

3. Add ILoginView interface

public interface ILoginView : IView

{

void UpdateStatus(string status);

event EventHandler Exit;

event EventHandler Login;

string User { get;}

string Password { get; }

}

This new interface inherits from our base IView interface.

4. Implement LoginController class

This class is going to hold the logic that will be using the ILoginView interface to communicate with the LoginForm. We add the LoginController class and make sure that it implements the IController interface we've declared earlier:

public class LoginController: IController

{

private ILoginView view;

public LoginController(ILoginView view)

{

this.view = view;

this.AttachView(this.view);

}

private void AttachView(ILoginView view)

{

// Hook up into the view's events

view.Login += new EventHandler(view_Login);

view.Exit += new EventHandler(view_Exit);

}

void view_Exit(object sender, EventArgs e)

{

Application.Exit();

}

void view_Login(object sender, EventArgs e)

{

// The login event is been raised from the form.

// Ideally we should pass the user and password to a Business layer to validate against database or a web service

// For now we'll just compare to some hardcoded values

if (view.User == "Alex" && view.Password == "test")

{

// Update the status on the LoginForm

view.UpdateStatus("Login successfull.");

}

else

{

// Update the status on the LoginForm

view.UpdateStatus("Login failed.");

}

#region IController Members

public IView View

{

get

{

return view;

}

set

{

view = (ILoginView)value;

AttachView(view);

}

#endregion

}

5. Implement the ILoginView interface in the LoginForm:

public partial class LoginForm : Form, ILoginView

{

private string user;

private string password;

public LoginForm()

{

InitializeComponent();

}

#region ILoginView Members

public void UpdateStatus(string status)

{

lblStatusValue.Text = status;

}

public event EventHandler Exit;

public event EventHandler Login;

public string User

{

get

{

return user;

}

public string Password

{

get

{

return password;

}

#endregion

private void menuOK_Click(object sender, EventArgs e)

{

this.user = txtUser.Text;

this.password = txtPassword.Text;

// Notify the controller

if (this.Login != null)

{

this.Login(this, null);

}

private void menuExit_Click(object sender, EventArgs e)

{

// Notify the controller

if (this.Exit != null)

{

this.Exit(this, null);

}

As you should notice from this code, we don't directly talk to the controller. All what the LoginForm knows about is the ILoginView interface, which it faithfully implements and it just raises the appropriate events for whoever is listening to them. That's all for now. You can be wondering how would you connect the LoginController and ILoginView together without destroying the decoupling that we are trying to achieve. And where do we create an instance of the controller for the view? I will explain it to you in my next post. Meanwhile I welcome your comments or suggestions on how you think we should proceed.