Brian Orrell

Accepting Diversity - The Mandate of Mobile

2012-05-11T08:07:00.000-05:00

I found this very interesting bit from the Wall Street Journal, CIO Edition:

Google senior vice president Vic Gundrota used the company’s social network to introduce a mobile version of Google+. The fact Google introduced it for Apple devices first, because the Android version isn’t ready, is an acknowledgement both of the urgency to get a mobile version of its social network into the market, and the primacy of the iPhone.

This is the way organizations must operate in the new world of multi-platform, multi-OS, and multi-form-factors with no dominant winner. Gone are the days of using your monopoly in one area to force your users to use your other products. If you are selling a service, you must accept the fact that you should actively pursue every avenue to sell that service, even by actively promoting it on your competitors platforms.

Even Microsoft is beginning to slowly adopt this approach. They have released Lync and OneNote applications for iOS and there are lot of well respected prognosticators who believe there will be more versions of Office applications that will run on competing devices in the future.

Pariveda continues to actively develop mobile strategies and roadmaps for our clients that embrace the diversity of platforms as a current and future reality. Enterprises must be prepared to support multiple platforms and develops applications that effectively run on these platforms.

PaaS Definition: It Depends On Whom You Ask...

2011-02-03T09:41:00.000-06:00

David Chappell wrote an interesting post on what the "real" definition of PaaS (Platform as a Service) is.

As with many emerging technologies, vendors try to cast their offering in the most favorable light by adjusting the definition to match what their product does.

He talks about the four main competitors: Microsoft (Windows Azure), Google (AppEngine), SalesForce (Force.com) and Amazon (Elastic Beanstalk) and how their systems have similar and also widely varying approaches.

The one capability that sticks out for me the most is "updating with no downtime." That seems like a entry-level requirement and one that surprisingly Amazon's Elastic Beanstalk currently doesn't support. This is a very new offering for Amazon so I have to imagine that it is on the radar for future enhancements. "Root Access to the VM" the application is running on seems like more of a selling opportunity to IT buyers concerned about giving up control-- if it works the way PaaS is supposed to, do I really need that level of access? Auto-scaling is another one that I think is a must-have across all of the stacks. If my demand spikes at 3am, please tell me a human is not required to increase the capacity-- automate please.

The PaaS space is certainly one that we at Pariveda see as the most promising and one that we look forward to discussing further with organizations. I will be speaking with Vaughan Merlyn in February and early March on the Threats and Opportunities in the Cloud in Chicago, Dallas, Houston and Seattle. If you're near the area during that time, sign up and come see us.

Microsoft to offer Chatter-like OfficeTalk

2011-01-22T12:35:00.000-06:00

This could be great for Microsoft technologies.

I have to say that when I first heard about SalesForce.com's Chatter, I wasn't intrigued. It sounded like "just another enterprise micro-blogging tool." When I caught up with a contact who had recently moved over to work for SalesForce, and I got the scoop on what Chatter really is I was incredibly impressed.

The concept of not only being able to follow people within my company but also things is very cool. So any entity that I create on the Force.com platform can participate in my Chatter stream. That is powerful. I could follow a client, an opportunity, a project, a team... hopefully if and when Microsoft gets on the micro-blogging bandwagon, they take the same approach to allowing anything to be followed.

Microsoft makes OneNote free on the iPhone. Is iPad next?

2011-01-18T15:47:00.003-06:00

Key quote from this piece:

Microsoft is a software company. The company should offer software products across platforms to maximize its addressable market. The entire Microsoft Office suit should be made available on the iPad. Otherwise, Numbers, Pages, etc. for iPad will only continue to grow.

It's great to see that they are developing more apps for iOS. As the device space heats up and more non-Windows devices make their way into our lives, Microsoft Office, their cash-cow, must try and be on as many of them as possible.

My gut tells me it won't happen, but I was surprised to see even OneNote. Baby steps.

Visual Studio STILL Calls It JScript?

2011-01-02T10:54:00.001-06:00

Just when I think Microsoft is gradually accepting some common community standards: embracing MVC, framework support of JSON, TDD...

Today I am deploying a web app to Azure, and I decide to write my current Sencha demo using Visual Studio 2010:

Javascript Intellisense - Check
Easy Packaging to Azure - Check
Familiar IDE - Check

I go to add my javascript file and I search for "Javascript" using the handy power tools when adding files. I type javascript - "No items found" Huh? Turns out Microsoft still prefers to refer to the js files as JScript files. Really? It's 2011. It is supposedly to avoid trademark issues with Sun:

As explained by JavaScript guru Douglas Crockford in his talk entitled The JavaScript Programming Language on YUI Theater, "[Microsoft] did not want to deal with Sun about the trademark issue, and so they called their implementation JScript. A lot of people think that JScript and JavaScript are different but similar languages. That's not the case. They are just different names for the same language, and the reason the names are different was to get around trademark issues."

I seriously doubt that adding javascript in the name of the file you are creating in an IDE would violate trademark issues. Every other IDE doesn't seem to have a problem it.

Chrome OS vs. Android

2010-12-15T10:39:00.002-06:00

I have to say that this post is spot-on. I can't see both Chrome-OS and Android succeeding in the long run. The benefits of Chrome-OS seem to be met and then some by Android and with the industry momentum around Android, I don't see how Chrome-OS can carve out a niche. I'm willing to be proven wrong. I still am a huge fan of Chrome and think it will take a great deal of market share (as it already has) from the other browsers, but the OS is a different story.

Microsoft Dynamics CRM and the iPad - Better Get Moving, Microsoft

2010-04-06T15:24:00.003-05:00

I assume out of the gate that SalesForce.com can run on the recently released iPad. It's a browser app. Why shouldn't it? Good for SalesForce.

Microsoft Dynamics CRM is an entirely different animal. Even though CRM is a "browser app" it requires Windows IE - can't run it on Mac IE or Firefox or Chrome or Opera or anything else. Kind of defeats the purpose of being a browser app, in my opinion.

And who is one of the largest target demographics for the iPad? Mobile Sales Professionals! While it may pain Microsoft to have to play well on non-Microsoft OS's and browsers, if they want to stay relevant in this space, they better get moving.

And yes, the iPad can terminal service in and run IE virtualized from Citrix, etc... but why should you have to? If I were SalesForce.com, I would be marketing this for all it's worth.

Weathering an economic challenge as a consultancy

2009-05-14T15:16:00.001-05:00

As we all experience one of the more challenging economic times in our history, it becomes even more critical to revisit how companies can stay resilient. At Pariveda, we have asserted that even in the most challenging of times the information technology knowledge worker pool is supply-constrained. Does this mean that over the past six months, layoffs in our industry haven't occurred? Absolutely not. They have. But what we have experienced first hand, is that our clients are having a harder time finding competent candidates.

We think the reason is straightforward. After the first and second rounds of layoffs within the IT industry, the bottom percentages of workers are typically the ones laid off first. This has resulted in a larger overall pool of candidates with the same amount of good candidates as before-- the same number of "needles" (good candidates) in a much larger haystack.

We are investing in recruiting, training and growing our people now more than ever before. We just hired a new recruiter, we continue our push for top-tier college graduates and experienced hires and our sales pipeline is strong. Our clients continue to confirm our difference in the industry- our people.

Now more than ever companies cannot afford to go with "average" firms. People's jobs are on the line and project success is critical. Does it matter what the rate of a firm is if they fail to deliver the solution?

All of us at Pariveda could work at other places if we wanted; what keeps us at Pariveda is the ability to work with some of the most intellectually curious and talented folks in the industry. Even in a down economy, we have fun and do interesting work. The best way to beat the economic blues is to surround yourself with people who enjoy what they do, are interested in continuous learning and are focused on providing the most value possible for their clients.

Dallas DevCares Presentation - REST Based Services

2009-04-25T11:12:00.001-05:00

Charles Knight did an awesome job presenting on RESTful Services in .NET. Click here to download the presentation.

Data Access with LINQ to SQL - Update

2008-06-07T11:20:00.000-05:00

As with all new technologies, you continue to learn as you work with it. Some of my thoughts have changed from my previous post on using LINQ to SQL.

After attending TechEd 2008 in Orlando this past week and speaking recently on this topic at the Austin Code Camp, I have a (what I think) is a better approach to doing data access with LINQ to SQL in an ASP.NET web project. First, it is definitely my preference to separate all data context activity to the business and/or data tiers.

Some key things that I have learned along the way. You will want to use the Attach(entity, true), which essentially tells LINQ to "trust me, the entity has changed, update the whole thing." In order for this to work with an entity that has relational entities such as the Customer with the CustomerAddress, you must do one of the following things:

Serialize and then deserialize the entity using the DataContractSerializer. This will be automatic if you are passing it over WCF, otherwise, you will need to write the code to essentially clone your entity.
Use the DataLoadOptions to get the full entity graph when you pull down the original entity.

I've started storing my code up on Google Code. Here's a link to download the latest bits. If you aren't already an SVN user, just download TortoiseSVN-- trust me, it's easy.

Technorati Tags: LINQ,ASP.NET,DataContractSerializer

Slow Typing in Word and Outlook on your ThinkPad?

2008-06-05T16:23:00.001-05:00

This was driving me absolutely crazy and hopefully it will help others (write a comment if it fixes your problem). I was getting significant delay when I would type in Microsoft Word and Outlook and when it would and I could not figure out what the problem was. I tried removing all my user settings, uninstalling/reinstalling Office. Nothing worked.

Turns out that the problem wasn't with Office at all. It was the Client Security - Password Manager program that comes pre-installed on ThinkPad laptops with fingerprint scanners. Uninstall it and everything works like it should.

Technorati Tags: Outlook,Word,Slow,Typing,Lenovo,ThinkPad,Password Manager

How to trigger a full postback from within an AJAX UpdatePanel

2008-03-01T10:17:00.001-06:00

If you've ever used an AJAX UpdatePanel and needed to have a control within the UpdatePanel cause a full postback of the page, here's how you do it.

ScriptManager scriptManager = ScriptManager.GetCurrent(Page);

if (scriptManager != null)

{

scriptManager.RegisterPostBackControl(SaveButton);

}

First you have to get access to the ScriptManager on the page. Then you register the control within the UpdatePanel that needs to trigger a full postback.

Technorati Tags: ASP.NET,AJAX,UpdatePanel,ScriptManager

Visual Studio 2008 Hotfix Available

2008-02-10T14:31:00.001-06:00

Microsoft has released a hotfix for Visual Studio 2008... thankfully. We had noticed some severe performance issues with VS 2008 since we started using it back in October. Hopefully this will speed up my team's development and will resolve some stability issues.

Here's a link to download the hotfix.

And here's a link to Scott Guthrie's post on what was resolved with the hotfix.

LINQ to SQL Updating in ASP.NET - The Right Way

2008-02-09T15:41:00.001-06:00

Update (6/7/2008): I have posted my thoughts on how this can be done in a more n-tier based way here.

Click here to download the source for these examples. This is a link to a Google Code repository. Use subversion to check it out.

Like many folks who have been creating web applications on the ASP.NET platform for a while, the glitz and glamour surrounding Language Integrated Query (LINQ) intrigued and frightened me at the same time. All the demos seemed to imply that life was easier and clearer in the new world. Don't believe the hype.

Don't get me wrong, LINQ is great if you understand the right way to use it and our teams at Pariveda are really getting some great traction out of LINQ to SQL, but you definitely have to approach it differently than most of the demos seem to imply. The QUERY part of LINQ to SQL is straightforward and extremely powerful; the create, update and delete support in the language is what takes some getting used to.

First off, it's good to understand the model that is used for LINQ to SQL Updates. The entities that are passed around with LINQ to SQL are lightweight and do not store changed state information. The only things the entities do is store data and raise events when their properties change to other watching objects such as the DataContext-- and that is where folks get confused when working with LINQ in ASP.NET.

Almost ALL applications these days work in a disconnected state. Meaning there are process/memory differences between when and where data is initially RETRIEVED and when and where it is eventually UPDATED. Herein lies the problem with most of the demos that show LINQ in action.

ASP.NET web applications are and should remain stateless from an architectural implementation. We have ways of "fooling" developers into believing that their pages are somehow living in memory using things like ViewState, but anyone who has worked in the tool long enough knows that ViewState is serialization/deserialization trickery to lull the developer into a stateful sense of well being. I love me some ViewState, but you have to understand it to use it wisely.

So, what's the problem with ASP.NET and LINQ. When you perform an update with LINQ, the entity you are updating must be watched when the properties are updated to their new values.

Say, I have a page that displays a customer record:

On the SelectedIndexChanged of the ListBox, I would simply write some code that filled in the values in the TextBoxes like so:

protected void CustomerListBox_SelectedIndexChanged(object sender, EventArgs e)

{

using (AdventureWorksDataContext db = new AdventureWorksDataContext())

{

Customer customer = db.Customers.Single(c => c.CustomerID ==

int.Parse(CustomerListBox.SelectedValue));

NameTextBox.Text = customer.CompanyName;

EmailTextBox.Text = customer.EmailAddress;

FirstNameTextBox.Text = customer.FirstName;

LastNameTextBox.Text = customer.LastName;

IsActiveCheckBox.Checked = customer.IsActive;

}

We think all is well with the world. Then we proceed to Update the Customer object by hooking into the Save Button's click event like so:

protected void SaveButton_Click(object sender, EventArgs e)

{

using (AdventureWorksDataContext db = new AdventureWorksDataContext())

{

Customer customer = new Customer

{

CustomerID = int.Parse(CustomerListBox.SelectedValue)

};

db.Customers.Attach(customer);

customer.CompanyName = NameTextBox.Text;

customer.EmailAddress = EmailTextBox.Text;

customer.FirstName = FirstNameTextBox.Text;

customer.LastName = LastNameTextBox.Text;

customer.IsActive = IsActiveCheckBox.Checked;

db.SubmitChanges();

}

And we get a "row not found or changed" error? Why is this? Because the datacontext uses concurrency checking to ensure that the data we originally retrieved has not changed between the time we retrieved it and the time we are attempting to update it. Let's take a look at the SQL that was generated by the DataContext that caused the error:

UPDATE [SalesLT].[Customer]
SET [FirstName] = @p0, [LastName] = @p1, [CompanyName] = @p2, [EmailAddress] = @p3WHERE 0 = 1
-- @p0: Input NVarChar (Size = 7; Prec = 0; Scale = 0) [Orlando]
-- @p1: Input NVarChar (Size = 3; Prec = 0; Scale = 0) [Gee]
-- @p2: Input NVarChar (Size = 13; Prec = 0; Scale = 0) [A Bike StoreX]
-- @p3: Input NVarChar (Size = 28; Prec = 0; Scale = 0) [orlando0@adventure-works.com]
-- Context: SqlProvider(Sql2005) Model: AttributedMetaModel Build: 3.5.21022.8

Notice, the WHERE 0=1 part? What's up with that?

The best way to start off solving this is to create a timestamp column in your table and hold on to this value in ViewState so that when you perform your Attach and Update, you can vouch for the fact that the data hasn't changed since the last time you retrieved it. We'll call it the column "Version".

Next, we'll create a ViewState-backed property that will hold onto the value of the currently selected version:

Binary SelectedCustomerVersion

{

get { return (Binary)ViewState["SelectedCustomerVersion"]; }

set { ViewState["SelectedCustomerVersion"] = value; }

}

We'll set the Version property in our SelectedIndexChanged event of our ListBox like so:

protected void CustomerListBox_SelectedIndexChanged(object sender, EventArgs e)

{

using (AdventureWorksDataContext db = new AdventureWorksDataContext())

{

Customer customer = db.Customers.Single(c => c.CustomerID ==

int.Parse(CustomerListBox.SelectedValue));

NameTextBox.Text = customer.CompanyName;

EmailTextBox.Text = customer.EmailAddress;

FirstNameTextBox.Text = customer.FirstName;

LastNameTextBox.Text = customer.LastName;

IsActiveCheckBox.Checked = customer.IsActive;

SelectedCustomerVersion = customer.Version;

}

Finally, in our update code, we will be sure and set the Version value of our Customer entity before we attach to the data context.

protected void SaveButton_Click(object sender, EventArgs e)

{

using (AdventureWorksDataContext db = new AdventureWorksDataContext())

{

Customer customer = new Customer

{

CustomerID = int.Parse(CustomerListBox.SelectedValue),

Version = SelectedCustomerVersion

};

db.Customers.Attach(customer);

customer.CompanyName = NameTextBox.Text;

customer.EmailAddress = EmailTextBox.Text;

customer.FirstName = FirstNameTextBox.Text;

customer.LastName = LastNameTextBox.Text;

customer.IsActive = IsActiveCheckBox.Checked;

db.SubmitChanges();

}

And this works... MOST of the time. You can be deceived into thinking you have things working until you understand what is actually occurring. When you attach your customer entity to your datacontext, you are basically promising that the values you plan to change in your entity while your data context watches are ALREADY SET to the original values they were in the database. The reason why this is important for LINQ is that your Customer entity will only alert the data context that something has changed if the value the property is changing FROM is different. So how would you see this problem manifest itself? It will occur when you are setting a property back to the default value that it would already have when a new entity is created-- boolean values are the easiest ways to see the issue.

If we we set the IsActive property from true to false, our current code won't work because the default value of a boolean is already false. Let's look at what the SQL would look like if the ONLY thing we changed in the entity was the IsActive checkbox going from checked to unchecked (true to false).

UPDATE [SalesLT].[Customer]
SET [FirstName] = @p2, [LastName] = @p3, [CompanyName] = @p4, [EmailAddress] = @p5
WHERE ([CustomerID] = @p0) AND ([Version] = @p1)

SELECT [t1].[Version]
FROM [SalesLT].[Customer] AS [t1]
WHERE ((@@ROWCOUNT) > 0) AND ([t1].[CustomerID] = @p6)
-- @p0: Input Int (Size = 0; Prec = 0; Scale = 0) [1]
-- @p1: Input Timestamp (Size = 8; Prec = 0; Scale = 0) [SqlBinary(8)]
-- @p2: Input NVarChar (Size = 5; Prec = 0; Scale = 0) [Brian]
-- @p3: Input NVarChar (Size = 3; Prec = 0; Scale = 0) [Gee]
-- @p4: Input NVarChar (Size = 12; Prec = 0; Scale = 0) [A Bike Store]
-- @p5: Input NVarChar (Size = 28; Prec = 0; Scale = 0) [orlando0@adventure-works.com]
-- @p6: Input Int (Size = 0; Prec = 0; Scale = 0) [1]
-- Context: SqlProvider(Sql2005) Model: AttributedMetaModel Build: 3.5.21022.8

Notice, that even though the ONLY column we changed is the IsActive value from true to false, it was the only column that wasn't attempted to be updated by the database. Let's examine why.

When you attach an entity to the datacontext, it is basically hooking up to be alerted everytime a property changes. Since we just created an empty customer from scratch and only set the CustomerID and Version properties on the entity, all of the other property values are null. When we set CompanyName, it alerts that there was a change because we changed the property from null to a value, and the same for the other columns... except for IsActive. The CURRENT value of IsActive is false and then we attempt to set the value of the property to false. No change event is raised because the property isn't being changed and therefore the database is not updated during the SubmitChanges call.

So, the last piece of the puzzle is coming up with a way to hold on to the original values of the customer entity so that before we attach the customer entity we set all the properties to their new values, the old values are already set. This is the part that had my head spinning for a while. At first, I tried putting the Customer entity directly into ViewState but it complained about a host of serialization problems-- you can try making it happen and see for yourself the problems that occur.

The way I finally was able to get serialization of a LINQ entity to work was to set the dbml file to the Serialization Mode of Unidirectional. You can do this by clicking in a blank area of the designer and then opening up the properties window.

Next, I created an OriginalCustomer property to store the object.

Customer OriginalCustomer { get; set; }

Finally, I overrode the LoadViewState and SaveViewState methods of the page so that I could persist the deserialized string of the OriginalCustomer property to ViewState.

protected override void LoadViewState(object savedState)

{

object[] allStates = (object[])savedState;

base.LoadViewState(allStates[0]);

OriginalCustomer = LinqEntityUtil.Deserialize<Customer>((string)allStates[1]);

}

protected override object SaveViewState()

{

object baseState = base.SaveViewState();

object[] allStates = new object[2];

allStates[0] = baseState;

allStates[1] = LinqEntityUtil.Serialize<Customer>(OriginalCustomer);

return allStates;

}

Here's the utility class that handles the deserialization of LINQ Entities:

public static class LinqEntityUtil

{

/// <summary>

/// Serializes a LINQ to SQL Entity to a WCF-Serialized

/// string using the DataContractSerializer

/// </summary>

/// <typeparam name="T">Type of the LINQ Entity to be serialized</typeparam>

/// <param name="linqEntity">LINQ Entity object to be serialized</param>

/// <returns>Serialized string</returns>

public static string Serialize<T>(T linqEntity)

{

DataContractSerializer serializer = new DataContractSerializer(typeof(T));

StringWriter writer = new StringWriter();

XmlTextWriter xmlWriter = new XmlTextWriter(writer);

serializer.WriteObject(xmlWriter, linqEntity);

writer.Flush();

return writer.ToString();

}

/// <summary>

/// Deserializes from a string back to a LINQ to SQL Entity

/// object using the DataContractSerializer

/// </summary>

/// <typeparam name="T">Type of the LINQ Entity to be serialized</typeparam>

/// <param name="xml">Serialized string to deserialize</param>

/// <returns>LINQ Entity object</returns>

public static T Deserialize<T>(string xml)

{

DataContractSerializer serializer = new DataContractSerializer(typeof(T));

StringReader reader = new StringReader(xml);

XmlTextReader xmlReader = new XmlTextReader(reader);

T linqEntity = (T)serializer.ReadObject(xmlReader);

return linqEntity;

}

Now, with my OriginalCustomer serialization in place, I could hold on to the original customer entity and attach it back to the datacontext when I was ready to save.

protected void SaveButton_Click(object sender, EventArgs e)

{

using (AdventureWorksDataContext db = new AdventureWorksDataContext())

{

db.Customers.Attach(OriginalCustomer);

OriginalCustomer.CompanyName = NameTextBox.Text;

OriginalCustomer.EmailAddress = EmailTextBox.Text;

OriginalCustomer.FirstName = FirstNameTextBox.Text;

OriginalCustomer.LastName = LastNameTextBox.Text;

OriginalCustomer.IsActive = IsActiveCheckBox.Checked;

db.SubmitChanges();

}

With this in place, I can make changes to IsActive where I set it from true to false and the data context "sees" the changes appropriately. Here is the much more optimized SQL that occurs, when I change just the IsActive field.

UPDATE [SalesLT].[Customer]
SET [IsActive] = @p2
WHERE ([CustomerID] = @p0) AND ([Version] = @p1)

SELECT [t1].[Version]
FROM [SalesLT].[Customer] AS [t1]
WHERE ((@@ROWCOUNT) > 0) AND ([t1].[CustomerID] = @p3)
-- @p0: Input Int (Size = 0; Prec = 0; Scale = 0) [1]
-- @p1: Input Timestamp (Size = 8; Prec = 0; Scale = 0) [SqlBinary(8)]
-- @p2: Input Bit (Size = 0; Prec = 0; Scale = 0) [False]
-- @p3: Input Int (Size = 0; Prec = 0; Scale = 0) [1]
-- Context: SqlProvider(Sql2005) Model: AttributedMetaModel Build: 3.5.21022.8

Hopefully this helps some of you struggling with similar issues. The key thing when using attach is that you want all of the properties that you plan to change to be set to their original values before you attach it to the datacontext and ViewState serialization is the easiest way to do that in ASP.NET.

Click here to download the source for these examples.

Technorati Tags: LINQ,ASP.NET,Serialization,WCF

Bill Gates' Last Day

2008-02-01T08:52:00.001-06:00

Too funny not to post

We Are Microsoft - Great Event

2008-01-28T11:19:00.001-06:00

It's been a week now since our two teams from Pariveda volunteered at the We Are Microsoft event. Toi Wright and Chris Koenig did a great job organizing the event.

My team which had Jeff Townes, Justin Finch and Kyle Stock from Pariveda and Amy Stewart from Stewart Design was assigned to Texas CARES, a cat rescue group here in North Texas. Beyond some initial phone discussions where we worked through logistics and timing for the weekend, we started out with a clean slate on Friday evening.

Over the course of two and half days, we developed a revamped website with a searchable and maintainable database for managing rescued cats and helping pair them up with adoptive owners.

To see the improvement, here's a link to their current site. Here's a link to the new site (in beta as we work through transferring domain registration). Here's a link to the interview that Geeks with Blogs did with Carol Benassi, the president of Texas CARES and me, and here's another link to the interview they did with the Texas Response Unit Search and Rescue (the second Pariveda team).

One of the things that makes Pariveda unique is that we have an expectation that all of our folks participate in community service. Depending upon the person's level (it increases the higher up you go), there are a certain number of hours that are expected you commit to community service. We Are Microsoft was a great way to be able to help our community by doing the things that we do best- develop great software.

We each spent around 40 hours between Friday night until late Sunday afternoon. It took us a while to recover, but I was extremely proud of both teams. By the way, our two teams from Pariveda came in First and Third in the competition-- Woo Hoo!

ObjectDataSource / LINQ / Paging / Sorting Example

2008-01-01T17:17:00.001-06:00

[Edit: Updated link to download code]
Click here to download the source for these examples. This is out on GoogleCode. I recommend TortoiseSVN to download the code.

One of the first issues you encounter when doing .NET development the “Right Way”/”Pariveda Way” is finding an example of how to support paging and sorting in a GridView. Many of the examples out on the web assume you are using a SqlDataSource to get at your data. If you are developing against an N-Tier architecture, you know you will need to use the ObjectDataSource, but there are few examples that show how to support paging and sorting when using this model.

This example will hopefully point you in the right direction for how to support paging and sorting using an ObjectDataSource. In addition, it will show you a method for supporting multiple search criteria where a user may or may not choose to filter on all the criteria available—LINQ has a great story around this topic.

Here’s the scenario, we need a Grid to display a list of products (Product Name, Category Name, and Supplier Name) from the Northwind database. The grid can be filtered on the Category, the Supplier or both. In addition, the grid can be sorted by any of the three columns by clicking on the columns. Sorting on the Category or Supplier should also use a secondary sort by Product since there will be multiple records for each Category and/or Supplier when sorted.

The grid should look like this:

One of the primary reasons we advocate using a business tier and the ObjectDataSource is to support writing tests against your code (it’s difficult and not all that useful to write web testing code, so we choose to have as much code as possible isolated to our business and data tiers). In true Test Driven Development fashion, let’s start by creating the tests that we will use to test out our Business layer code before we write anything else. We are using NUnit, but you can use whatever testing framework you want).

Let’s create a project and solution called Pariveda.ObjectDataSource.Test inside a solution called Pariveda.ObjectDataSource.

After creating our first project in the new solution, let’s also add two new projects to the solution: Pariveda.ObjectDataSource.Business (Windows Class Library) and Pariveda.ObjectDataSource.Web (ASP.NET Web Application).

Next, we need to add our references. Both Test and Web need to point to the Business Project as a reference so they can use the business layer code.

Also, let’s add a reference to the nunit.framework.dll in our Test project.

So let’s work on adding at least the stub for our Business library method for retrieving a list of Products.

First let’s add a “LINQ to SQL Classes” file:

Next we’ll drag the Category, Product and Supplier tables from the Server Explorer (the Northwind database is included with the zipped up solution I have a link to).

First, let’s create an entity class in our Business Library that will store our grid results. We will call it ProductGetListResult. This will enable us to have a more optimized call that only returns the key information we need to display for our grid.

public class ProductGetListResult
{
    public string ProductName { get; set; }
    public string CategoryName { get; set; }
    public string SupplierName { get; set; }
}

Next, we’ll create a class called ProductController in the Business Library. Our main method will be called GetList.

We know the parameters will need to be the following:

· An optional categoryId parameter to filter by category

· An optional supplierId parameter to filter by supplier

· A sortType indicating the sort order

· A startRowIndex parameter for use with paging to support starting at a specified row

· A maximumRows parameter for indicating how many total rows to retrieve

public List<ProductGetListResult> GetList(int? categoryId, int? supplierId, string sortType, int startRowIndex, int maximumRows)
{
    using (NorthwindDataContext db = new NorthwindDataContext())
    {
        //First we start with the base query
        var productQuery = from p in db.Products
                           select p;
 
        //Next we filter if category or supplier has been specified
        productQuery = GetListQuery(productQuery, categoryId, supplierId);
 
        //Sort the query
        productQuery = GetListSort(productQuery, sortType);
 
        //Use the Skip and Take methods to limit the results to the page requested
        productQuery = productQuery.Skip(startRowIndex).Take(maximumRows);
 
        //Project results into a ligher weight class and actually execute the query by
        //calling the ToList method
        return productQuery.Select(p => new ProductGetListResult
                       {
                           ProductName = p.ProductName,
                           SupplierName = p.Supplier.CompanyName,
                           CategoryName = p.Category.CategoryName
                       }).ToList();
    }
}

We are creating an instance of our DataContext (being sure to use a disposing “use” statement on the object to ensure the data context and subsequent data connections are closed).

We do four things in this method:

· We dynamically filter based on our criteria (category and supplier ids)

· We dynamically sort based on our sortType parameter

· We return a subset of the information based on the startRowIndex and maximumRows parameters

· We then project the results into our lightweight list of ProductGetListResults

Let’s look at the GetListQuery method.

private IQueryable<Product> GetListQuery(IQueryable<Product> productQuery, int? categoryId, int? supplierId)
{
    //Only filter by category id if specified (query not executed here either)
    if (categoryId.HasValue && categoryId.Value > 0)
    {
        productQuery = productQuery.Where(p => p.CategoryID == categoryId.Value);
    }
 
    //Only filter by supplier id if specified (query not executed here either)
    if (supplierId.HasValue && supplierId.Value > 0)
    {
        productQuery = productQuery.Where(p => p.SupplierID == supplierId.Value);
    }
 
    //Return the query (Query isn't even executed when we return it)
    return productQuery;
}
 

What we are doing in this method is very similar to things we have done in the past prior to LINQ where we would build dynamic SQL except we get strong-typing and intellisense. In addition, we get all the benefits for prevention of SQL injection attacks etc.

Now let’s look at the sorting.

private IQueryable<Product> GetListSort(IQueryable<Product> productQuery, string sortType)
{
    //Determining whether to sort ascending or descending 
    //(GridView appends DESC if the column is clicked on twice to indicate a descending sort)
    bool sortDescending = false;
    if (!String.IsNullOrEmpty(sortType))
    {
        string[] values = sortType.Split(' ');
        sortType = values[0];
        if (values.Length > 1)
        {
            sortDescending = values[1] == "DESC";
        }
    }
 
    switch (sortType)
    {
        case "CategoryName":
            if (sortDescending)
            {
                productQuery = productQuery.OrderByDescending(p => p.Category.CategoryName)
                    .ThenBy(p => p.ProductName); ;
            }
            else
            {
                productQuery = productQuery.OrderBy(p => p.Category.CategoryName)
                    .ThenBy(p => p.ProductName); ;
            }
            break;
        case "SupplierName":
            if (sortDescending)
            {
                productQuery = productQuery.OrderByDescending(p => p.Supplier.CompanyName)
                    .ThenBy(p => p.ProductName);
            }
            else
            {
                productQuery = productQuery.OrderBy(p => p.Supplier.CompanyName)
                    .ThenBy(p => p.ProductName);
            }
            break;
        default:
            if (sortDescending)
            {
                productQuery = productQuery.OrderByDescending(p => p.ProductName);
            }
            else
            {
                productQuery = productQuery.OrderBy(p => p.ProductName);
            }
            break;
    }
 
    //The query has not executed during this method, it is only setting up the query for execution
    return productQuery;
}

We are basically doing two things, first we are seeing if a direction specifier is attached to our sortType parameter. The GridView automatically appends DESC to the end of the sortType parameter when a user clicks on a column twice (once for ascending, twice for descending). Next we are switching on the SortType which is a string and we are then using strong typing to sort on the column. Notice that for CategoryName and SupplierName we also do a secondary sort on ProductName since only sorting on Category or Supplier isn’t specific enough.

Big point about the benefits of LINQ: Please note that throughout all of this code, nothing is being executed on the database. That is one of the main benefits of LINQ: delayed execution. The only time SQL Server is contacted and the query is executed is when we first access the collection neither by enumerating through it or in this case, when we call the ToList method.

Now here’s where many folks get hung up. In order for the ObjectDataSource to correctly support paging, you need one more method, GetListCount. If you think about it, it becomes obvious why this is required. We are only returning a subset of records back to the ObjectDataSource (a page’s worth). The GridView has to know how many total rows are available so that it can correctly show the right number of links to the different page numbers. Since we separated the call for filtering from the rest of the code, we can easily use the same method in our GetListCount method.

public int GetListCount(int? categoryId, int? supplierId)
{
    using (NorthwindDataContext db = new NorthwindDataContext())
    {
        var productQuery = from p in db.Products
                           select p;
 
        productQuery = GetListQuery(productQuery, categoryId, supplierId);
 
        return productQuery.Count();
    }
}

Here we simply call the Count() method on our query. You may be thinking to yourself, “Hey, isn’t that two calls to the database?” and you would be correct. While this is true, this is the most optimized query you can do if you need both a SUBSET of the data for paging and yet you also need the total row count.

In addition to our ProductController, I created two additional controller classes: CategoryController and SupplierController.

public int GetListCount(int? categoryId, int? supplierId)
{
    using (NorthwindDataContext db = new NorthwindDataContext())
    {
        var productQuery = from p in db.Products
                           select p;
 
        productQuery = GetListQuery(productQuery, categoryId, supplierId);
 
        return productQuery.Count();
    }
}

Now to use it!

In order to create our web page, we don’t need to use any code-behind logic. It can all be accomplished declaratively using the ObjectDataSource. In order to clean up the aspx code and to follow best practices, we are using a MasterPage for css styling and AJAX support. In addition, we are using App_Themes for our GridView so we don’t see any messy formatting within the aspx page.

First, let’s add our two drop down lists to the page. We’ll add a CategoryDropDownList and a SupplierDropDownList.

Notice we select “Value” as the data field to display and “Key” as the data field for the value. These two properties map to the Id and the Name that we return from the business controller classes.

First thing, we’ll add a GridView to the page, and click on the chevron arrow to set our Data Source. We’ll select “New data source.”

We will select “Object” as our Data Source Type and call it ProductObjectDataSource.

We’ll pick our ProductController in the next screen…

We’ll select our GetList method from the drop down.

Now we hook up our two parameters in the GetList method to the SelectedValue properties of the DropDownList controls

Next, we will modify the DropDownList controls to support an “-All-“ property and ensure the GridView refreshes when we change the filters. I find it easier to change these properties in the “Source” view of the aspx editor. Note the AppendDataBoundItems ensures that even though we are binding to an ObjectDataSource, the existing ListItem (the “-All-“ option) still remains.

<asp:DropDownList ID="SupplierDropDownList" runat="server" AutoPostBack="true" 
    DataSourceID="SupplierObjectDataSource"
    DataTextField="Value" AppendDataBoundItems="true" DataValueField="Key">
    <asp:ListItem Value="-1" Text="- All Suppliers -" />
</< span>asp:DropDownList>
 
Now, we need to tell the GridView that we will be using Paging (check the Enable Paging checkbox): 
<asp:GridView ID="GridView1" runat="server" AllowPaging="True" EnableSortingAndPagingCallbacks="True"
    AllowSorting="true" Width="600px" AutoGenerateColumns="False" DataSourceID="ProductObjectSource">
    <Columns>
        <asp:BoundField DataField="ProductName" HeaderText="<%$ Resources:ObjectDataSource, ProductLabel %>" SortExpression="ProductName"
            ItemStyle-Width="250px" HeaderStyle-HorizontalAlign="Left" />
        <asp:BoundField DataField="CategoryName" HeaderText="<%$ Resources:ObjectDataSource, CategoryLabel %>" SortExpression="CategoryName"
            ItemStyle-Width="100px" HeaderStyle-HorizontalAlign="Left" />
        <asp:BoundField DataField="SupplierName" HeaderText="<%$ Resources:ObjectDataSource, SupplierLabel %>" SortExpression="SupplierName"
            ItemStyle-Width="250px" HeaderStyle-HorizontalAlign="Left" />
    </< span>Columns>        
    <EmptyDataTemplate>
        <asp:Localize runat="server" meta:resourcekey="EmptyData" />
    </< span>EmptyDataTemplate>          
</< span>asp:GridView>
 
 
We’ll use the “Edit Columns” option on the GridView to set the headers appropriately. 
Here’s where the “wizards” breakdown and it gets “hokey.”  You must add the SelectCountMethod and set it to the name of our GetListCount method, you must add the EnablePaging and the SortParameterName properties as well.  And then you have to delete the sort and paging parameters that were automatically added to the ObjectDataSource when we set it up (sortType, startRowIndex, maximumRows). 
<asp:ObjectDataSource ID="ProductObjectSource" runat="server" EnablePaging="True"
    OldValuesParameterFormatString="original_{0}" SelectCountMethod="GetListCount"
    SelectMethod="GetList" SortParameterName="sortType" TypeName="Pariveda.ObjectDataSource.Business.ProductController">
    <SelectParameters>
        <asp:ControlParameter ControlID="CategoryDropDownList" DefaultValue="null" Name="categoryId"
            PropertyName="SelectedValue" Type="Int32" />
        <asp:ControlParameter ControlID="SupplierDropDownList" DefaultValue="null" Name="supplierId"
            PropertyName="SelectedValue" Type="Int32" />
    </< span>SelectParameters>              
</< span>asp:ObjectDataSource>
 
Whew!  Now run it and confirm that it works as expected. 
To add to the look and feel, use ASP.NET theming to set the styles of both the GridView and the general layout of the page. 
Next we can easily add AJAX functionality so we don’t get those pesky postbacks.  First we can use the built-in GridView functionality to switch pages and sorts without postbacks.  Then we put the GridView inside and AJAX UpdatePanel and set the triggers to be based on the DropDownLists. 
<asp:ObjectDataSource ID="ProductObjectSource" runat="server" EnablePaging="True"
    OldValuesParameterFormatString="original_{0}" SelectCountMethod="GetListCount"
    SelectMethod="GetList" SortParameterName="sortType" TypeName="Pariveda.ObjectDataSource.Business.ProductController">
    <SelectParameters>
        <asp:ControlParameter ControlID="CategoryDropDownList" DefaultValue="null" Name="categoryId"
            PropertyName="SelectedValue" Type="Int32" />
        <asp:ControlParameter ControlID="SupplierDropDownList" DefaultValue="null" Name="supplierId"
            PropertyName="SelectedValue" Type="Int32" />
    </< span>SelectParameters>                  
</< span>asp:ObjectDataSource>
 
Hopefully, this was easy enough to follow.  Once you get the hang of it and get over some of the initial hurdles, it is easy to maintain and apply to different applications.  
Click here to download the source for these examples.

MSBuild: Copy Files to Multiple Folders With One Copy Task

2007-05-19T07:48:00.000-05:00

At Pariveda, we typically use a standard Config project in Visual Studio to keep track of all our configuration files and accessor classes. We then write MSBuild scripts to deploy them to the appropriate web, service, winform, wpf, wcf directories as appropriate. This provides the ability to maintain a single set of config files even if they are being deployed to multiple application source environments.

This is especially appropriate with testing frameworks such as nUnit and Team Test. In order to test effectively, many files need to be copied to the running test directory as well as the main application directory. Instead of having to write duplicate msbuild tasks for copying to these directories, it would be nice if we could iterate through a list of directories that the files needed to be copied to.

You see this question being asked all the time: How do I recursively copy a series of files to another folder? That question has been answered multiple times on multiple sites. But what about needing to copy that same series of files to multiple different deployment folders? The scenario is like the one I described above or if you were wanting to automate deployment of files to a web farm. The answer is using the ItemGroup appropriately. If you can create an ItemGroup that contains the list of deployment directories that need to receive the files, you can write the script once that will iterate over this list of deployment directories and copy them to all of them.

MSBuild is certainly not as intuitive to me as NAnt. NAnt seems to be more understandable proceduraly (foreach tasks, etc) while MSBuild is more geared towards XSL type transformations. Once I got the hang of how to use ItemGroups, however, I can see how powerful MSBuild as a scripting language can be.

<ConfigFolder>c:\msbuild\config</ConfigFolder>

</PropertyGroup>

<Path>c:\msbuild\Service</Path>

</ConfigDeploy>

<Path>c:\msbuild\Test</Path>

</ConfigDeploy>

</ItemGroup>

<!-- Get all Files within the config directory and create multiple sets of the files

with metadata that describes where the files are to be deployed to -->

<CreateItem Include="$(ConfigFolder)\**\*.*"

AdditionalMetadata="ToDir=%(ConfigDeploy.Path)">

</CreateItem>

<Copy SourceFiles="@(ConfigFilesToDeploy)"

DestinationFolder="%(ToDir)\%(RecursiveDir)" />

</Target>

</Project>

Technorati Tags: MSBuild,Copy

Regex.Replace()

2004-10-19T07:55:00.000-05:00

Many times, we have a need for creating templates with key areas that are tagged for replacement. An example would be a mail-merge type form letter.

Dear [NAME],

We have reviewed your account: [ACCOUNTNUMBER]. The issue you identified has been resolved. [COMMENTS]

Sincerely,
[COMPANYNAME]

Most of the time, this is done with some brute force string.Replace command for every possible field that may have been tagged in the document.

        public string MergeFields(string text)
        {
            text = text.Replace("[NAME]", _name);
            text = text.Replace("[ACCOUNTNUMBER"], _accountNumber);
            text = text.Replace("[COMMENTS]", _comments);
            text = text.Replace("[COMPANYNAME]", _companyName);
        }

This will work, but as the number of possible fields increases, your MergeFields method gets incredibly unwieldy. Enter Regex.Replace.

        public string MergeFields(string text)
        {
            string fieldPattern = @"\[(?<Field>[A-Z]+)\]";
            return Regex.Replace(text, fieldPattern, new MatchEvaluator(GetFieldValue));
        }

        private static Hashtable _fieldProps = new Hashtable();
        private string GetFieldValue(Match m)
        {
            string fieldName = m.Groups["Field"].Value;
            PropertyInfo propInfo = (PropertyInfo)_fieldProps[fieldName];
            if (propInfo == null)
            {
                Type type = typeof(RequestMailer);
                propInfo = type.GetProperty(fieldName, typeof(string));
                if (propInfo == null)
                    throw new ArgumentException(m.Value + " is not a valid property.");
                _fieldProps.Add(fieldName, propInfo);
            }
            return (string)propInfo.GetValue(this, new object[0]);
        }

So what's happening? The Regex Replace method takes a regular expression pattern. In this case it finds all occurences of [ALLCAPS]. When it finds a match, it passes the matched value to our GetFieldValue method. The GetFieldValue method uses reflection to find the property and get the value from the property.

How does this help? As we have the need to add more and more new custom properties, all we have to do is add the property itself. The replacing methods do not need to be updated for the new properties to be used.

Technorati Tags: Regex,MailMerge