Centrolutions Blog

Four Things You Should Know Before Starting a Software Project

jason@centrolutions.com (Jason Williams) — Thu, 07 Nov 2019 03:47:00 GMT

Creating custom software can add incredible value to your business by automating processes or easing pain points that keep your team from working at full capacity. Taking on a project like building a piece of software can be a daunting task, however, without doing a few things prior to starting.

Obvious things like finding a software engineer, picking a platform, picking a technology, and even more technical details will need to be decided. You will also need to put a good amount of thought into everything you want the software to do. Before all of that though, you need to think about these four things so your project can be successful. These four things are so important, you should stop now, and write them down before you put any more effort into planning your project.

Know Your Goals

A successful project will have clearly defined goals. You should not only think about what you want your custom software to do, but also think about the problem you want the software to solve. To identify your goals and bring clarity to this part of your project plan, it is often helpful to ask yourself a few questions.

What process is taking too long or what pain point are you trying to eliminate?
Is your team unable to do something fast enough because it’s not automated?
Is there a unique solution your software would bring to an industry or group of people? If so, what is it and who are they?
Why would someone use your software?

As you’re defining your goals, you should be as specific as possible. Don’t use general terms like “make importing orders into QuickBooks easier.” Instead, use details like, “increase the number of orders we can put in QuickBooks from 25 to at least 100 per day.” Using details like that will help you greatly as you define the second piece of your project plan.

Know Success

Success shouldn’t be a feeling or a subjective goal. Once you have your goals specifically defined, this step is easy. The main question to ask yourself when picking your definition of success is, “when the project is done, what goals must be met and which goals are less important?” It may be helpful to look at your list of goals and rank their importance on a number scale of some sort. For instance, put “1” next to your most important, “2” next to the goals that are less important, and “3” next to those goals that are “nice-to-haves.” Then, your success statement may be something like, “this project will be successful when all of the #1 and #2 goals have been achieved.” Alternatively, you may not have any optional goals and your success statement may be something like, “this project will be a success when all of these goals are met.”

When you define success in this way, you will have a much better sense for the last two items in your project plan.

Know Your Timeline

Now that your project plan includes your goals and a clear definition of success, you’ll need to consider what a reasonable timeline will look like. Typically, the temptation is put an ASAP stamp on your project and leave it at that. Of course, most of the time, this is unreasonable and sets your project up for failure. Failure would come – not because you can’t finish a project in a hurry, but because it puts no boundaries on your project and leaves room for the project to drag on beyond reason.

If you have never run a software project, you may not have a good feel for how long development may actually take. However, you can put things in your timeline before an engineer gets involved. If you have deadlines, appointments, or other projects that are dependent upon your software being complete, you should write those down. After you’ve cataloged your timeline restrictions, you can get a software engineer involved to see if your timeline is reasonable.

Remember, you define a timeline so your project does not drag on. If your timeline is not met or it appears that it will not be met, you can use that as a key performance indicator (KPI) and either make adjustments or re-evaluate the project as a whole. The next KPI and the final item on your project plan is your budget.

Know Your Budget

Just like defining your timeline, a budget may be difficult to get a feel for if you haven’t run a software project before. However, just like your timeline, you likely have some restrictions you can apply to your budget. It is often useful to think of the possible return on investment you may see from the software you want to create. For instance, if your software can save your team 3 hours of work per day and you pay your employees an hourly rate, it is easy to calculate how much money you may save in labor. That, of course, is a very simplistic approach to ROI, but estimating a return of some sort will often give you a feel for the top end of your budget. If you estimate a return of $5,000 annually for instance, and your software engineer estimates a cost of $10,000, you will need to decide if you can wait for 2 years before you see a financial return on your investment.

Final Thoughts

A successful project will start with goals, a definition of success, a timeline, and a budget. Once you have all four of those things, you’re ready to start a conversation with a software engineer. I should mention that while you are in the planning phase of your project, you should expect these four things to undergo slight adjustments before the project begins. For instance, you may need to re-define success by eliminating a subset of goals so you can meet your timeline and budget. Alternatively, you may need to adjust your budget to ensure success by meeting all of your goals. Small changes should be expected. However, once the project starts, you should strive to stay as close to the plan as possible.

After the project starts, for instance, it would be ill-advised to add goals to your project as that would likely cascade and cause your timeline or budget to increase. Be sure your plan is sound before you start and stick to it!

If you have any questions or comments about this, please leave them below. If you would like to start a software project, please email me using the form on this website.

Thanks for reading!

This work by Jason Williams is licensed under a Creative Commons Attribution-NonCommercial-NoDerivs 3.0 Unported License.
Based on a work at centrolutions.com.

If you liked this article, see more on Centrolutions.

New Website Launched

jason@centrolutions.com (Jason Williams) — Thu, 07 Nov 2019 00:00:00 GMT

Have a look at the new website! I'm in the process of migrating old blog articles to the new site and fixing old links. Let me know if you find something broken.

Thanks!

This work by Jason Williams is licensed under a Creative Commons Attribution-NonCommercial-NoDerivs 3.0 Unported License.
Based on a work at centrolutions.com.

If you liked this article, see more on Centrolutions.

Centrolutions Becomes a BizSpark Startup

jason@centrolutions.com (Jason Williams) — Tue, 25 Sep 2012 12:54:23 GMT

I am excited to announce that Centrolutions has become a BizSpark startup! About two months ago, I made the decision to strike out on my own and turn Centrolutions into more than just a hobby. For a developer, this can be a daunting proposition since the tools and systems used to write software can be very expensive. Not to mention, finding funding for projects, connecting with other startups for advice, and marketing a startup can be more than overwhelming. That’s where the Microsoft BizSpark program comes in.

Through BizSpark, Microsoft provides tools and connections for the startup community. The resources they provide will prove to be invaluable as I get on my feet. If you have a startup or are thinking of getting into one, I highly recommend Microsoft’s program. I am grateful for their help and I’m excited for the future.

This work by Jason Williams is licensed under a Creative Commons Attribution-NonCommercial-NoDerivs 3.0 Unported License.
Based on a work at centrolutions.com.

If you liked this article, see more on Centrolutions.

NuGet and TFS 2010 Automated Build

jason@centrolutions.com (Jason Williams) — Thu, 05 Jul 2012 19:28:00 GMT

If you don't use NuGet for your Visual Studio projects, you should. Go download it, now.

If you do use NuGet and you want to automate your builds with TFS 2010, it's super easy to enable it:

[more]

In Solution Explorer, right-click on the solution
From the context menu, choose "Enable NuGet Package Restore"

One hickup you might encounter is that when your automated build tries to build the solution, you may get the following error:

C:\Builds\1\MyProject\Main Release\Sources\MyProject\ProjectName\.nuget\nuget.targets (76): Package restore is disabled by default. To give consent, open the Visual Studio Options dialog, click on Package Manager node and check 'Allow NuGet to download missing packages during build.' You can also give consent by setting the environment variable 'EnableNuGetPackageRestore' to 'true'.

The newer versions of NuGet requires explicit permission to restore packages. Usually, on your development machine, you could enable this through Visual Studio's options (per the instructions in the error message). However, on a build server, you need to add the environment variable. To do this, log into the build server and do the following:

Click Start and right-click on "Computer"
Choose "Properties" from the context menu

Choose "Advanced System Settings" from the System window.
Choose the "Advanced" tab in the System Properties window and click the "Environment Variables" button.

In the System Variables section, click the "New..." button.
Enter "EnableNuGetPackageRestore" for the "Variable name" field
Enter "true" for the "Variable value" field and click the OK button.

Lastly, restart the TFS build service and retry your build

After all of that, your build should now be able to download the NuGet packages it needs.

Happy coding!

This work by Jason Williams is licensed under a Creative Commons Attribution-NonCommercial-NoDerivs 3.0 Unported License.
Based on a work at centrolutions.com.

If you liked this article, see more on Centrolutions.

A Developer’s Free Time

jason@centrolutions.com (Jason Williams) — Sun, 15 Apr 2012 21:00:00 GMT

Lately, I’ve been in a bit of a self-reflective mode. So, this blog post is going to be a little different than normal. Usually, I try to post about very technical / programming things. However, due to some things at work that I probably shouldn’t air in public, I’ve started to think about what I put my energy into at home and at work.

Like many software engineers, I really, really like writing software. It doesn’t matter what the software does. So long as it solves a problem, I’m happy to work on it. This also means that my hobby is (drum roll please) -- writing software. So, at work, I write software. I come home and I write software. It’s part of loving the creative process and having a bit of a one-track mind. It’s part of being compelled to learn something new and fulfill the ever-so-eternal quest to improve on existing processes.

If that describes you, I would consider you a compulsive programmer. I say this with the most positive meaning of the word and with all due respect. Your compulsion is what probably makes you good at your job. After all, remember, I’m talking about myself, too. As a side, here’s a great example of “one of us.”

If you can’t really relate, you probably already know what I’m going to say in the rest of this post. I would consider you a less-than-compulsive programmer. You are no less of a programmer -- I’m sure you’re very good at your job, too. You are just not driven to constantly run in the same mode, all of the time.

[more]

The Unimaginable

So, let’s say your hobby is writing software. Cool! Now, let’s say you get a job writing software. In essence, you’ve turned your hobby into a career that you love. Cool! You are one of the privileged few whose passion is also their career. People all over the world long for what you have. There are millions and millions of people that go to work at a j-o-b. They do their job with diligence, but it doesn’t cause a spark to go off in their soul. Some are even stuck in a soul-killing j-o-b that they should really find a way out of, altogether. You, however, get to go to work. You get to work on cool and interesting things. You get to create!

Now, imagine someone told you: “you’re not allowed to write software at home any more.” The only time you get to commit to your passion is from 8am through 5pm. That’s it. Would you still love your job? Would you still be just as passionate about what you do during the day, as you were before?

That’s an extreme example, of course, but think about it for a minute. I found myself thinking in those terms, recently. Really, the question boiled down to: if I could do anything else during my free time, that wasn’t computer-related, what would it be? The answer I came up with was, “I don’t know.”

Right now, those less-than-compulsive programmers that are reading this should probably take a moment and pick your jaw up off of the floor. To you, that was a ludicrous answer to such a simple question. Alternatively, if you count yourself amongst the compulsive programmers, you might come to the same conclusion I did: I just don’t do much other than learn, read, use, and write software.

Of course, I play with the kids, do yard work, take care of the house, and all of the other “normal” things you might expect, but when I’ve got really free time that isn’t being used for anything else, I levitate towards the computer. It’s just so fun to sit down and create something. Imagine, though, if that was taken away.

The Void

In case you’re wondering, I have not been told that I can’t write software at home. That was just an example to get you thinking. The principle remains, though: it seems that my life is not as well rounded as it could be. My life needs to be defined by more than software development.

I was introduced to computers during my formative years. I saw them as a challenge, at first. Like many, I was intrigued by the variety of things they could do and thrilled at how I could make them do things most people couldn’t -- by programming them. I went to college to learn more about computers. I found jobs related to computers. I was and still am a computer geek. Looking back, I’ve been on a single track for quite some time.

Ultimately, the problem is this: because I have spent so much time doing this one thing -- and it’s all I do, I fear there is a strong possibility that I will get burned out on software development. Then, not only would I have lost my passion; I would be left with nothing afterwards.

Is it a Problem That Needs a Solution?

When you’re looking at starting a new programming project, one of the first things you should ask yourself is: does the problem warrant a software solution? Perhaps the problem could be solved in another way (a change of process, for example). Maybe it doesn’t require a new piece of software after all. However, if you think a new project is needed, then you can figure out what that new piece of software will look like.

I’ve come to the personal conclusion that this problem does require a solution. What does the solution look like? I’m not entirely sure. For now, I’m going to try to solve it with a new hobby. Is that the whole solution? I’m not sure, but I’m going to try it out. I’ll prototype something and see how it goes.

What does your solution look like? Maybe you’re already solving this problem. Either way, I would love to hear your ideas. I don’t usually request comments, but if you would leave your feedback here or tweet me (@centrolutions or #HobbiesForDevs) I would really like to hear your ideas.

If you’re a compulsive programmer and find yourself in the same boat I did, I encourage you to think about what life would look like without software development. What would you do? Do you see a burnout coming? Take a moment to examine yourself. I think you’ll be better for it.

This work by Jason Williams is licensed under a Creative Commons Attribution-NonCommercial-NoDerivs 3.0 Unported License.
Based on a work at centrolutions.com.

If you liked this article, see more on Centrolutions.

REST, WCF 4, Forms Authentication, and Custom Clients (Part 3 of 3)

jason@centrolutions.com (Jason Williams) — Fri, 10 Feb 2012 05:16:00 GMT

In the first and second parts of this post, I described what makes a REST service different from a SOAP service and how to use WCF to create one. In this post, we’ll look at what a REST client may look like and add some security around the service.

Security

In most line-of-business services, some sort of security system is usually required to prevent unauthorized access to the service’s data. One of the easiest ways to accomplish this is to use the ASP.NET Membership Provider and its associated services. In our example, I’ll be using the NuGet package called “ErikEJ.SqlCeMembership" to quickly create a database of users; without a full SQL Server instance. Once the NuGet package is installed, build the project and navigate to Project > ASP.NET Configuration to setup your users. Make sure to create at least one group and one user. I’ve called my group “Users” and my user, “user1.”

[more]

On the Customer Service, you should add the PrincipalPermission attribute to the methods you want to protect from unauthorized access and demand the user be a member of your role.

        1: [PrincipalPermission(SecurityAction.Demand, Role = "Users")]

       2: public Customer GetCustomer(int customerId)

       3: {

       4:     return _Customers.Where(c => c.CustomerId == customerId).SingleOrDefault();

       5: }

Additionally, you need to add the AspNetCompatibilityRequirements attribute to the service class and require compatibility. Along with that, you will need to assign the user from the http context, to the current thread’s current principal; in the constructor of the service.

       1: [AspNetCompatibilityRequirements(RequirementsMode = AspNetCompatibilityRequirementsMode.Required)]

       2: public class CustomerService : ICustomerService

       3: {

       4:     public CustomerService()

       5:     {

       6:         Thread.CurrentPrincipal = HttpContext.Current.User;

       7: ...

If you want to know more about the ASP Membership Provider and associated services, you should visit msdn.microsoft.com/en-us/library/ms731049.aspx to learn about the basics.

After your users are setup, you need to create a service your clients can use to authenticate with. ASP.NET has a service, specifically for this, but you have to enable it. To do this, make the following changes to the Web.config file:

Add

         1: <service name="System.Web.ApplicationServices.AuthenticationService" behaviorConfiguration="AuthenticationServiceTypeBehaviors">

         2:         <endpoint contract="System.Web.ApplicationServices.AuthenticationService"

         3:         binding="basicHttpBinding"

         4:         bindingConfiguration="userHttp"

         5:         bindingNamespace="http://asp.net/ApplicationServices/v200"/>

         6:       </service>

to system.serviceModel / services.

       1: <bindings>

       2:   <webHttpBinding>

       3:     <binding>

       4:       <security mode="TransportCredentialOnly" />

       5:     </binding>

       6:   </webHttpBinding>

       7:  

       8:   <basicHttpBinding>

       9:     <binding name="userHttp">

      10:       <security mode="None" />

      11:     </binding>

      12:   </basicHttpBinding>

      13: </bindings>

to system.serviceModel and

       1: <behavior name="AuthenticationServiceTypeBehaviors">

       2:   <serviceMetadata httpGetEnabled="true"/>

       3: </behavior>

to serviceBehaviors.

Also, add

         1: <system.web.extensions>

         2:     <scripting>

         3:       <webServices>

         4:         <authenticationService enabled="true" requireSSL="false" />

         5:       </webServices>

         6:     </scripting>

         7:   </system.web.extensions>

to the <configuration> root. Please note the the requireSSL attribute is set to false. In a production environment, I highly recommend you set this to true and use an SSL certificate to protect your users’ credentials.

Add a new item to the web project by choosing “Text File” and name it “Authentication.svc" or something similar that ends with the .svc extension. Open the new file and add the following to it:

       1: <%@ ServiceHost Language="C#" 

       2:     Service="System.Web.ApplicationServices.AuthenticationService"

       3:     Factory="System.Web.ApplicationServices.ApplicationServicesHostFactory" %>

The Client

Next, we’re going to create a consumer for our service. To start, create a new project and add a service reference to the new Authentication.svc service.

As a client, your application will need to keep track of the authentication cookie that is returned from the authentication service. Normally, this type of thing (cookie management) is taken care of by the browser, but since we’re running outside of the browser, we have to explicitly manage cookies.

The methods you need to pay attention to, on the authentication service, are:

Login(string username, string password, string customCredential, bool isPersistent)
IsLoggedIn()

The first time you call the authentication service, you need to log in and get a cookie, like this:

         1: using (new OperationContextScope(authService.InnerChannel))

         2: {

         3:     try

         4:     {

         5:         IsLoggedIn = authService.Login(username, password, customCredential, isPersistent);

         6:         Cookies = GetCookies(OperationContext.Current);

         7:     }

         8:     catch (EndpointNotFoundException enfe)

         9:     {

        10:     }

        11: }

After you have an authentication cookie, you should store it, for later use. The GetCookies method is shown below, along with the SetCookies method, which sets a cookie on a service client, so the next call to the service is seen as coming from an authenticated user.

       1: private CookieContainer GetCookies(OperationContext operationContext)

       2: {

       3:     HttpResponseMessageProperty httpResponseProperty =

       4:     (HttpResponseMessageProperty)operationContext.IncomingMessageProperties[HttpResponseMessageProperty.Name];

       5:     if (httpResponseProperty != null)

       6:     {

       7:         CookieContainer cookieContainer = new CookieContainer();

       8:         string header = httpResponseProperty.Headers[HttpResponseHeader.SetCookie];

       9:  

        if (header != null)

        {

            cookieContainer.SetCookies(new Uri(@"http://someuri.tld"), header);

        }

        return cookieContainer;

    }

    return null;

}

  

private void SetCookies(OperationContext oc, CookieContainer cookieContainer)

{

  

    HttpRequestMessageProperty httpRequestProperty = null;

    if (oc.OutgoingMessageProperties.ContainsKey(HttpRequestMessageProperty.Name))

    {

        httpRequestProperty =

            oc.OutgoingMessageProperties[HttpRequestMessageProperty.Name]

            as HttpRequestMessageProperty;

    }

  

    if (httpRequestProperty == null)

    {

        httpRequestProperty = new HttpRequestMessageProperty();

        oc.OutgoingMessageProperties.Add(HttpRequestMessageProperty.Name,

            httpRequestProperty);

    }

    httpRequestProperty.Headers.Add(HttpRequestHeader.Cookie,

        cookieContainer.GetCookieHeader(new Uri(@"http://someuri.tld")));

}

Calling the REST service

The simplest way to call a rest service is with the HttpWebRequest class. It has a very simple method to get an XML stream that can be passed into a serializer. The following code demonstrates how to retrieve an object from the XML stream returned by the HttpWebRequest.

       1: protected T ExecuteTwoWayRequest<T>(string serviceUrl, HttpMethod method, string responseDefaultNamespace = null)

       2: {

       3:     //setup the request

       4:     var request = CreateRequest(serviceUrl, method);

       5:  

       6:     //retrieve the response

       7:     var responseSerializer = new XmlSerializer(typeof(T), responseDefaultNamespace);

       8:     var response = request.GetResponse();

       9:     T result = (T)responseSerializer.Deserialize(response.GetResponseStream());

      10:  

      11:     return result;

      12: }

      13:  

      14: private HttpWebRequest CreateRequest(string serviceUrl, HttpMethod method)

      15: {

      16:     var request = (HttpWebRequest)HttpWebRequest.Create(serviceUrl);

      17:     this.SecurityManager.AddSecurity(request);

      18:     request.Method = method.ToString();

      19:     request.ContentType = "text/xml";

      20:     return request;

      21: }

To retrieve a customer from the service (with the GetCustomer method), you need to create a representation of the customer; on the client side. For our trivial example, the customer may look like this:

       1: public class Customer

       2: {

       3:     public int CustomerId { get; set; }

       4:     public string FirstName { get; set; }

       5:     public string LastName { get; set; }

       6: }

To retrieve the customer, use the following code:

       1: public Customer GetCustomer(int id)

       2: {

       3:     var result = base.ExecuteTwoWayRequest<Customer>(string.Format("{0}?id={1}", ServiceAddress, id), HttpMethod.GET, "http://schemas.datacontract.org/2004/07/RESTDatabaseService");

       4:     return result;

       5: }

Conclusion

In this part of the series, we saw how to add security to a REST service and how to create a client that authenticates and uses the secure REST service. You can download the complete code for the service and the client for a more complete example.

This work by Jason Williams is licensed under a Creative Commons Attribution-NonCommercial-NoDerivs 3.0 Unported License.
Based on a work at centrolutions.com.

If you liked this article, see more on Centrolutions.

REST, WCF 4, Forms Authentication, and Custom Clients (Part 2 of 3)

jason@centrolutions.com (Jason Williams) — Sun, 01 Jan 2012 03:31:07 GMT

In the first part of this post, I discussed REST and how it compares to SOAP-based services. In this part, we’ll figure out how to create a REST service with WCF and what it takes to start thinking in a “RESTful” way when designing a REST service.

[more]

Design and Planning

A lot of services are used for basic CRUD operations. Create, Retrieve, Update, and Delete are tasks that any line-of-business service is going to need to perform. With a SOAP service, you might layout your service methods like this:

        1: [ServiceContract]

       2:     public interface ICustomerService

       3:     {

       4:         [OperationContract]

       5:         ServiceResponse<Customer> AddCustomer(Customer cust);

       6:         [OperationContract]

       7:         IEnumerable<Customer> SearchCustomers(string searchTerm, int page, int recordsPerPage);

       8:         [OperationContract]

       9:         Customer GetCustomer(int customerId);

        [OperationContract]

        ServiceResponse<Customer> UpdateCustomer(Customer cust);

        [OperationContract]

        ServiceResponse<Customer> DeleteCustomer(int customerId);

    }

 

    [DataContract]

    public class Customer

    {

        [DataMember]

        public int CustomerId { get;set;}

        [DataMember]

        public string FirstName { get; set; }

 

        [DataMember]

        public string LastName { get; set; }

    }

 

    [DataContract]

    public class ServiceResponse<T>

    {

        [DataMember]

        public T StoredEntity { get;set; }

        [DataMember]

        public bool Success { get;set; }

        [DataMember]

        public string ErrorMessage { get;set;}

    }

If you’re familiar with WCF, the attributes on these contracts should look familiar. By default, in a Visual Studio WCF Service Application (see VS 2010 Screenshot below), this contract will define a SOAP service with 5 distinct methods. For brevity’s sake, I have excluded the actual implementation of the service.

The data contracts consist of a simple Customer Entity and a wrapper class to return some information back to the user about any errors that occurred during processing.

If you would like to learn more about WCF services, I encourage you to visit Basic WCF Programming to learn more about how this all fits together.

Getting Started With REST

To allow your WCF service to behave as if it were a REST service, you will need to add the following XML to the <system.serviceModel /> element in your web.config:

       1: <services>

       2:   <service name="RESTDatabaseService.CustomerService">

       3:     <endpoint kind="webHttpEndpoint" contract="RESTDatabaseService.ICustomerService" />

       4:   </service>

       5: </services>

Once that is done, you’ll need to alter your service contract (ICustomerService, in this case) to read:

       1: [ServiceContract]

       2: public interface ICustomerService

       3: {

       4:     [OperationContract]

       5:     [WebInvoke(Method="POST")]

       6:     ServiceResponse<Customer> AddCustomer(Customer cust);

       7:  

       8:     [OperationContract]

       9:     [WebInvoke(Method="GET", UriTemplate="/{searchTerm}?page={page}&pageSize={recordsPerPage}")]

      10:     IEnumerable<Customer> SearchCustomers(string searchTerm, int page, int recordsPerPage);

      11:     

      12:     [OperationContract]

      13:     [WebInvoke(Method="GET", UriTemplate="/?id={customerId}")]

      14:     Customer GetCustomer(int customerId);

      15:     

      16:     [OperationContract]

      17:     [WebInvoke(Method="PUT")]

      18:     ServiceResponse<Customer> UpdateCustomer(Customer cust);

      19:     

      20:     [OperationContract]

      21:     [WebInvoke(Method="DELETE", UriTemplate="/?id={customerId}")]

      22:     ServiceResponse<Customer> DeleteCustomer(int customerId);

      23: }

Once those changes are made, you can now access your data via a URL. If you take a look at the WebInvoke attribute that is applied to each of the operations, you’ll notice that some of them define a UriTemplate. That template will dictate what has to come after the “CustomerService.svc” part of the URL for the operation to be invoked.

For instance, if I wanted to perform a search for everyone named “smith”, I would call the URL:

http://<server>/CustomerService.svc/smith?page=1&pageSize=10

You’ll notice the address for the service remains similar to what you would expect (starts with server name and contains /CustomerService.svc), but it ends with a string that matches the pattern in the UriTemplate argument on the SearchCustomers(…) service operation.

This works great. However, I’m not real happy with the CustomerService.svc, in the URL. It just doesn’t smell right. So, I want to change things to make my URL prettier -- like:

http://<server>/Customers/smith?page=1&pageSize=10

To do this, you’ll need to add a Global.asax to your web site: In Solution Explorer, right-click the web-site project and choose Add –> New Item… (Ctrl + Shift + A), and choose the “Global Application Class” item. Leave its default name and click “Add.”

You will also need to add a reference to the “System.ServiceModel.Activation.dll” assembly.

On your service implementation (code in CustomerService.svc.cs), add the AspNetCompatibilityRequirements attribute to the service and require compatibility, like this:

       1: [AspNetCompatibilityRequirements(RequirementsMode = AspNetCompatibilityRequirementsMode.Required)]

       2: public class CustomerService : ICustomerService

You will also need to tell WCF to enable ASP.NET Compatibility by changing the web.config. In the <system.ServiceModel /> element, change the <serviceHostingEnvironment/ > element by adding the “aspNetCompatibilityEnabled” attribute and setting it to “true” as follows:

       1: <serviceHostingEnvironment multipleSiteBindingsEnabled="true" aspNetCompatibilityEnabled="true" />

Finally, in the new Global.asax file, add the following code:

       1: protected void Application_Start(object sender, EventArgs e)

       2: {

       3:     RegisterRoutes();

       4: }

       5:  

       6: private void RegisterRoutes()

       7: {

       8:     var factory = new System.ServiceModel.Activation.WebServiceHostFactory();

       9:     System.Web.Routing.RouteTable.Routes.Add(new System.ServiceModel.Activation.ServiceRoute("customers", factory, typeof(CustomerService)));

      10: }

After all of that, you should be able to navigate your browser to:

http://<server>/Customers/smith?page=1&pageSize=10

Striving for True RESTful-ness

REST services are not just a different protocol for delivery, they are a different way to think about your services. Roy Fielding is typically credited with coining the term “REST” in his doctoral dissertation (chapter 5); in which he lays out his vision of Representational State Transfer (REST) as a service architecture.

One of the main differences between a SOAP/RPC-style of service and a RESTful one is that the RESTful service uses its data to guide the consumer around the service; opposed to a consumer downloading a WSDL and obtaining intimate details about a service. A RESTful service will provide hints about how it should be called, next. If you’ve done any web programming, it’s similar to providing links that your user can click on, or a post-back URL in a <form /> tag.

Because of this requirement, we need to think a little more about what gets returned to our consumers. We need to modify the data contracts to include some actions that can be taken on the data that gets returned.

As an example, I want to modify the SearchCustomers(…) method to not just return data, but to also return links to the next and previous pages of data.

So far, a GET call to “http://<server>/Customers/smith?page=1&pageSize=10” will result in data similar to this:

       1: <ArrayOfCustomer xmlns="http://schemas.datacontract.org/2004/07/RESTDatabaseService" xmlns:i="http://www.w3.org/2001/XMLSchema-instance">

       2:   <Customer>

       3:     <CustomerId>1</CustomerId>

       4:     <FirstName>First1</FirstName>

       5:     <LastName>Smith1</LastName>

       6:   </Customer>

       7:   <Customer>

       8:     <CustomerId>2</CustomerId>

       9:     <FirstName>First2</FirstName>

    <LastName>Smith2</LastName>

  </Customer>

  <Customer>

    <CustomerId>3</CustomerId>

    <FirstName>First3</FirstName>

    <LastName>Smith3</LastName>

  </Customer>

  <Customer>

    <CustomerId>4</CustomerId>

    <FirstName>First4</FirstName>

    <LastName>Smith4</LastName>

  </Customer>

  <Customer>

    <CustomerId>5</CustomerId>

    <FirstName>First5</FirstName>

    <LastName>Smith5</LastName>

  </Customer>

  <Customer>

    <CustomerId>6</CustomerId>

    <FirstName>First6</FirstName>

    <LastName>Smith6</LastName>

  </Customer>

  <Customer>

    <CustomerId>7</CustomerId>

    <FirstName>First7</FirstName>

    <LastName>Smith7</LastName>

  </Customer>

  <Customer>

    <CustomerId>8</CustomerId>

    <FirstName>First8</FirstName>

    <LastName>Smith8</LastName>

  </Customer>

  <Customer>

    <CustomerId>9</CustomerId>

    <FirstName>First9</FirstName>

    <LastName>Smith9</LastName>

  </Customer>

  <Customer>

    <CustomerId>10</CustomerId>

    <FirstName>First10</FirstName>

    <LastName>Smith10</LastName>

  </Customer>

</ArrayOfCustomer>

That is because an IEnumerable, when serialized by the DataContractSerializer, becomes an ArrayOf XML element, by default. Instead of returning a straight IEnumerable, we need to create a type that contains the returned elements, and includes the links we want to provide to the consumer. That type might look like this:

       1: [DataContract(Name="PagedServiceResponse")]

       2: public class PagedServiceResponse<T>

       3: {

       4:     public PagedServiceResponse()

       5:     {

       6:         Results = new List<T>();

       7:     }

       8:  

       9:     [DataMember]

      10:     public string PreviousPage { get; set; }

      11:  

      12:     [DataMember]

      13:     public string NextPage { get; set; }

      14:  

      15:     [DataMember]

      16:     public List<T> Results { get; set; }

      17: }

If we return that type; filled with Customer objects, we’ll see output like this:

       1: <PagedServiceResponse xmlns="http://schemas.datacontract.org/2004/07/RESTDatabaseService" xmlns:i="http://www.w3.org/2001/XMLSchema-instance">

       2:   <NextPage>http://localhost:63608/customers/Smith?page=4&amp;pageSize=10</NextPage>

       3:   <PreviousPage>http://localhost:63608/customers/Smith?page=2&amp;pageSize=10</PreviousPage>

       4:   <Results>

       5:     <Customer>

       6:       <CustomerId>21</CustomerId>

       7:       <FirstName>First21</FirstName>

       8:       <LastName>Smith21</LastName>

       9:     </Customer>

    <Customer>

      <CustomerId>22</CustomerId>

      <FirstName>First22</FirstName>

      <LastName>Smith22</LastName>

    </Customer>

    <Customer>

      <CustomerId>23</CustomerId>

      <FirstName>First23</FirstName>

      <LastName>Smith23</LastName>

    </Customer>

    <Customer>

      <CustomerId>24</CustomerId>

      <FirstName>First24</FirstName>

      <LastName>Smith24</LastName>

    </Customer>

    <Customer>

      <CustomerId>25</CustomerId>

      <FirstName>First25</FirstName>

      <LastName>Smith25</LastName>

    </Customer>

    <Customer>

      <CustomerId>26</CustomerId>

      <FirstName>First26</FirstName>

      <LastName>Smith26</LastName>

    </Customer>

    <Customer>

      <CustomerId>27</CustomerId>

      <FirstName>First27</FirstName>

      <LastName>Smith27</LastName>

    </Customer>

    <Customer>

      <CustomerId>28</CustomerId>

      <FirstName>First28</FirstName>

      <LastName>Smith28</LastName>

    </Customer>

    <Customer>

      <CustomerId>29</CustomerId>

      <FirstName>First29</FirstName>

      <LastName>Smith29</LastName>

    </Customer>

    <Customer>

      <CustomerId>30</CustomerId>

      <FirstName>First30</FirstName>

      <LastName>Smith30</LastName>

    </Customer>

  </Results>

</PagedServiceResponse>

We’re almost there! The last thing we should probably do is provide a direct link to the individual customer record details. To do this, we’ll create a new domain object like this:

       1: [DataContract(Name="Customer")]

       2: public class LinkedCustomer : Customer

       3: {

       4:     public LinkedCustomer(Customer c)

       5:     {

       6:         this.FirstName = c.FirstName;

       7:         this.LastName = c.LastName;

       8:         this.CustomerId = c.CustomerId;

       9:     }

      10:     [DataMember]

      11:     public string Link { get; set; }

      12: }

Finally, we get the following result:

       1: <PagedServiceResponse xmlns="http://schemas.datacontract.org/2004/07/RESTDatabaseService" xmlns:i="http://www.w3.org/2001/XMLSchema-instance">

       2:   <NextPage>http://localhost:63608/customers/Smith?page=4&amp;pageSize=10</NextPage>

       3:   <PreviousPage>http://localhost:63608/customers/Smith?page=2&amp;pageSize=10</PreviousPage>

       4:   <Results>

       5:     <Customer>

       6:       <CustomerId>21</CustomerId>

       7:       <FirstName>First21</FirstName>

       8:       <LastName>Smith21</LastName>

       9:       <Link>http://localhost:63608/customers/?id=21</Link>

    </Customer>

    <Customer>

      <CustomerId>22</CustomerId>

      <FirstName>First22</FirstName>

      <LastName>Smith22</LastName>

      <Link>http://localhost:63608/customers/?id=22</Link>

    </Customer>

    <Customer>

      <CustomerId>23</CustomerId>

      <FirstName>First23</FirstName>

      <LastName>Smith23</LastName>

      <Link>http://localhost:63608/customers/?id=23</Link>

    </Customer>

    <Customer>

      <CustomerId>24</CustomerId>

      <FirstName>First24</FirstName>

      <LastName>Smith24</LastName>

      <Link>http://localhost:63608/customers/?id=24</Link>

    </Customer>

    <Customer>

      <CustomerId>25</CustomerId>

      <FirstName>First25</FirstName>

      <LastName>Smith25</LastName>

      <Link>http://localhost:63608/customers/?id=25</Link>

    </Customer>

    <Customer>

      <CustomerId>26</CustomerId>

      <FirstName>First26</FirstName>

      <LastName>Smith26</LastName>

      <Link>http://localhost:63608/customers/?id=26</Link>

    </Customer>

    <Customer>

      <CustomerId>27</CustomerId>

      <FirstName>First27</FirstName>

      <LastName>Smith27</LastName>

      <Link>http://localhost:63608/customers/?id=27</Link>

    </Customer>

    <Customer>

      <CustomerId>28</CustomerId>

      <FirstName>First28</FirstName>

      <LastName>Smith28</LastName>

      <Link>http://localhost:63608/customers/?id=28</Link>

    </Customer>

    <Customer>

      <CustomerId>29</CustomerId>

      <FirstName>First29</FirstName>

      <LastName>Smith29</LastName>

      <Link>http://localhost:63608/customers/?id=29</Link>

    </Customer>

    <Customer>

      <CustomerId>30</CustomerId>

      <FirstName>First30</FirstName>

      <LastName>Smith30</LastName>

      <Link>http://localhost:63608/customers/?id=30</Link>

    </Customer>

  </Results>

</PagedServiceResponse>

Of course, this type can be modified to be re-used by the GetCustomer(…) method so that it also includes the URLs for saving the item back to the service and deleting it. Providing feedback to your service consumer, in this manner, allows you to change your service layout, later; while not affecting the consumer’s ability to use the service. This is because the consumer never has to hard-code any URL information; instead they pull it from the message returned by the service.

Pick Your Formatting

So far, we have a service that will respond very well to basic HTTP calls and return very useful information – in XML. However, what if a JavaScript consumer calls the service and wants JSON messages back, instead? Fortunately, because of the way WCF is designed, you can control this with only a few lines of configuration.

In the web.config, add the following XML to the <system.serviceModel /> element:

       1: <standardEndpoints>

       2:   <webHttpEndpoint>

       3:     <standardEndpoint automaticFormatSelectionEnabled="true" helpEnabled="true" />

       4:   </webHttpEndpoint>

       5: </standardEndpoints>

The “automaticFormatSelectionEnabled” is the real magic, here. This instructs WCF to inspect the HTTP headers for Accept and Content-Type; to determine what kind of formatting the consumer is asking for. After that, WCF picks the correct serializer, for you, and you don’t have to worry about it. Cool, eh?!

Another nicety I should mention is the “helpEnabled" attribute. This enables consumers to navigate to http://<server>/Customers/help and see documentation for your service. Here’s a screenshot of what comes back in a browser:

In essence, as a consumer, you end up with an interactive document that helps you format your messages and URLs and gives you examples of what returns back from the service. This is incredibly useful and once again, it’s all done for you!

Summary

So, what have we done so far? In Part 1 of this post we saw some simple differences between SOAP and REST architectures. In this post, we saw how simple it is to convert a basic WCF service into a REST service; using a couple lines of configuration, and the addition of the WebInvoke attribute to the service contract.

We also saw how we can use ASP.NET routing to make the service URL more “pretty” and get rid of the .svc extension on the service, itself. Additionally, to stay true to the way REST services are suppose to work, we saw one example of how we might add links to other service actions in our return messages. Just because your service is accessed via a URL and an HTTP verb doesn’t make it truly RESTful. You have to think about your consumers in a different way than if they had downloaded all of the details of your service from a WSDL.

Lastly, we looked at the formatting of the data that comes out of the service. It’s very simple to enable flexible formatting; with only a few lines of configuration. Additionally, it’s just as easy to provide online help and documentation to your service consumers using the “helpEnabled” configuration attribute.

In the upcoming Part 3 of this post, we’ll add a client / consumer to the service and, just to make things more interesting, tack on some security to make this hypothetical service a little more real-world-ready.

This work by Jason Williams is licensed under a Creative Commons Attribution-NonCommercial-NoDerivs 3.0 Unported License.
Based on a work at centrolutions.com.

If you liked this article, see more on Centrolutions.

REST, WCF 4, Forms Authentication, and Custom Clients (Part 1 of 3)

jason@centrolutions.com (Jason Williams) — Thu, 29 Dec 2011 04:09:00 GMT

SOAP and REST Compared

REST services are the new “hotness.” All of the cool kids are doing them. I (not that cool of a kid) feel as though I’ve been left behind -- holding onto my SOAP messages like an old curmudgeon holding on to his last dollar. After all, SOAP-based services have served me well; all the way back to the .ASMX days. So, I’m the first to admit that traditional (SOAP-based) web services still have a place. They are extraordinarily easy to use, nowadays, because the tooling around them is so polished. On top of that, I can’t think of a platform that doesn’t support them, today.

[more]

The argument against these traditional services is that they are “heavy.” The SOAP envelope that your actual message gets wrapped in, adds weight and uses extra bandwidth. It also means that both the consumer and service need to have logic to “open the envelope” and understand it. Granted, this is hidden in most implementations, nowadays, but it still has to exist at some level. In the example above, you can see how verbose the request to a parameter-less method and it’s Boolean result can be.

Another argument against SOAP is that it is redundant. If you look at the HTTP protocol, it already has its own set of operations in the form of “Verbs” (POST, GET, PUT, DELETE, etc.). SOAP uses a header in the HTTP message (SOAPAction to be exact), to declare the operation you want the service to perform. REST simply uses a URL and an HTTP verb -- both of which would already be there for a normal HTTP request. Below, you can see a typical REST request and response. In many ways, it looks very much the same as a SOAP request/response, but as you can see, the request is much small and simpler; as is the response.

Message format is a given in the SOAP-based service world. Almost all SOAP services you will encounter “in the wild” use XML for their message format. Not every SOAP implementation has to use XML; SOAP can use other formats, but most choose XML because they have to deal with the SOAP envelope (which is XML), anyway. So, because of that, it’s almost a no-brainer to use XML since you’re in that space, already.

REST services, on the other hand, can easily switch between message formats. So, if you need XML for your .NET deserialization code, but require JSON for your JavaScript snippets, REST can easily accommodate your needs. The good services do this automatically by looking at the “Content-Type” header in the HTTP message. The not-so-well-thought-out services can still do this, but may require you pass an argument in the URL to choose your format. And, because you don’t have any message envelopes to get through before you see your data, parsing the returned data is trivial.

Below, you can see an example of a REST service method (the same one as the example above), but the request’s “Content-Type” header is set to “application/json” instead of “text/xml.” You’ll notice the response now includes a valid JSON-formatted date string instead of XML.

What is Missing from REST

Like I said before, I have used SOAP for almost all of the service work I’ve done, in the past. I like how Visual Studio and WCF creates nice, easy to understand objects for me. I like being able to point at a WSDL and have my service client generated for me. I like having the abstraction layer / SOAP implementation handle context for me. I like not having to think about the underlying HTTP protocol.

On top of all of that, my brain works in the RPC-like service domain, very well. I name my methods after the action they perform. With REST, you concentrate more on your entities and utilize the existing verbiage to perform the actions you want.

If you use WS-* with your SOAP services, there is a chance you’ll run into some roadblocks. For federated security or reliable messaging, you’re probably going to want to stick with SOAP and WS-*. Transactions are another piece of the puzzle I don’t quite have a solution for yet, but I’ve seen examples of possible solutions, so there’s hope there.

Other than those things mentioned above, you can do most anything with a REST service that you could with a SOAP service. Some might even argue that you can do it more elegantly – though beauty is in the eye of the beholder.

What’s Next

In the next part of this post, I’ll detail how you might create a REST service (with pretty URLs, no less!) using WCF 4. In the part following that, we’ll take a look at securing the service with ASP.NET’s MembershipProvider (also known as Forms Authentication) and how we can write a simple console application that consumes the service.

This work by Jason Williams is licensed under a Creative Commons Attribution-NonCommercial-NoDerivs 3.0 Unported License.
Based on a work at centrolutions.com.

If you liked this article, see more on Centrolutions.

Camera Image Control -- New Name and New Features

jason@centrolutions.com (Jason Williams) — Sun, 20 Nov 2011 00:21:00 GMT

I'm pleased to announce a new addition to the LightSwitch family: The Image Controls for LightSwitch extension.

Previously, the extension was called "Camera Image Control for LightSwitch" which was a very accurate, but too specific name. Recently, I added a control to the extension that allows you to scan documents directly from a scanner. With this new addition comes a name change.

I'm also pleased to announce that, while the name has changed, the price has not. You can still purchase the Camera Image Control; along with the Scanner Image Control, together for a low, low price. Simply click here to open the purchase page. Of course, you can download a free, limited trial from the Visual Studio Gallery to try it out before you buy it.

If you previously purchased the extension, you don't have to worry. You can get the new functionality by logging in at the product section of this website, choosing "My Account," and then "Downloadable Products." Once there, you can click on the "Download" link next to the product.

I'm excited to hear your feedback and I hope you find the new control useful. As always, if you have any trouble with it, I want to know about it. Please use the links on this website to contact me, directly.

This work by Jason Williams is licensed under a Creative Commons Attribution-NonCommercial-NoDerivs 3.0 Unported License.
Based on a work at centrolutions.com.

If you liked this article, see more on Centrolutions.

Camera Image Control 1.2

jason@centrolutions.com (Jason Williams) — Thu, 03 Nov 2011 04:17:00 GMT

Just released: Camera Image Control for Visual Studio LightSwitch version 1.2.

New in this version:

There is now a trial version available for download from the Visual Studio Gallery.
You can now optionally disable the file upload and clear photo buttons by using a couple new properties on the control.

If you purchased the control, you can log in at http://centrolutions.com/products/login and re-download the extension file from the "My Account" > "Downloadable Products" section.

This work by Jason Williams is licensed under a Creative Commons Attribution-NonCommercial-NoDerivs 3.0 Unported License.
Based on a work at centrolutions.com.

If you liked this article, see more on Centrolutions.

LightSwitch, Custom Settings Tables, and a Web Cam

jason@centrolutions.com (Jason Williams) — Thu, 13 Oct 2011 02:41:49 GMT

Visual Studio LightSwitch is a relatively new development tool from Microsoft that allows a developer to quickly create database-driven, Silverlight applications. While I won’t give you the full sales pitch in this post – since it is my first post on LightSwitch, I should at least mention that you can find more information here

We’ll take a look at setting control properties from code-behind. Specifically, we’ll see how we might store some settings in a database table, read them, and apply them to a control.

[more]

Setting up the Project

If you’re following along at home, create a new LightSwitch project (File > New > Project, choose the LightSwitch in the project template tree, and select LightSwitch Application (Visual C#)). Name it whatever you want; I named my project “SettingsAndWebCam.”

From the Designer tab, choose “Create new table.”

Call the table “Setting” and create four integer properties called “ResolutionWidth,” “ResolutionHeight,” “ViewFinderWidth,” and “ViewFinderHeight.”

While the Setting table is still visible in the designer, click on the down-arrow next to the “Write Code” button; to expand its menu. Choose “Settings_CanInsert” from the “Access Control Methods” section of the menu.

When the code-behind file opens, write the following code. This simple bit of C# only allows one record in the table and never allows the user to delete a record.

Go back to the designer tab and click the “Screen…” button to create a new screen. I’m sort of partial to the “List and Details Screen” layout, but you could also use the “Editable Grid Screen” layout. Choose “Settings” from the dropdown list under “Screen Data.” Click the OK button to create the screen.

Run your LightSwitch application (press F5) and create a new record in the Setting table. Enter the values in the screenshot below:

Click the OK button and then click “Save” on the screen.

Using the Settings

Now that the settings are ready to go, let’s use them to setup a camera control on another screen.

I’ve created a table called “Member” that has three columns: FirstName, LastName, and Picture. The first two columns are strings and the last one is an image column.

Another thing I’ve done is to include the “Camera Image Control” as an extension in the properties of my project. Shameless plug: you can buy this extension here.

Additionally, I’ve created another List and Details Screen for the Member table.

and I’ve changed the control used for the Picture column to “Camera” so that I can use my web cam to take pictures of people.

Alright, it’s finally time to write some code! If you’re a “coder” like me, here comes the fun part.

In the Solution Explorer, right click on the “SettingsAndWebCam” project and choose “View Application Code (Client)” from the context menu.

Add the following code to the code-behind file.

On the MembersListDetail screen designer, choose “MemberListDetail_Created” method from the “Write Code” drop-down list and add the following code to that method:

When you run the application, you can see the results of your hard work when you start the camera:

Usually, these properties would be set by the LightSwitch developer; through the LightSwitch designer, but that would lock the end-user into using a single resolution and view-finder window size. Because we have used our settings to initialize the camera, the end-user can change the resolution of the camera which adds more flexibility to your application.

This work by Jason Williams is licensed under a Creative Commons Attribution-NonCommercial-NoDerivs 3.0 Unported License.
Based on a work at centrolutions.com.

If you liked this article, see more on Centrolutions.

Beta Testers for the “Camera Image Control for LightSwitch” Extension

jason@centrolutions.com (Jason Williams) — Sun, 28 Aug 2011 13:36:00 GMT

I’m looking for several people to help me beta-test a LightSwitch extension. The extension allows you to capture an image from your webcam and save it directly to a screen in LightSwitch. I’m planning to sell the extension for a small fee, but if you are one of the beta testers, you will get it for free.

If you think you can help, please use the menu on this site to contact me and I’ll get you setup with access to the extension.

Thanks!

This work by Jason Williams is licensed under a Creative Commons Attribution-NonCommercial-NoDerivs 3.0 Unported License.
Based on a work at centrolutions.com.

If you liked this article, see more on Centrolutions.

Major Bug in Stripes 2.0 for Those Upgrading From Previous Versions

jason@centrolutions.com (Jason Williams) — Tue, 26 Apr 2011 20:08:00 GMT

Update 5/3/2011: The fix (version 2.1) has been published to the market place. You should be able to start downloading it whenever your country's marketplace refreshes.

Well, it had to happen, eventually. There is a major bug in Version 2.0 of Stripes that is affecting users that upgrade from a previous version. Because some internal data structures have changed, when the old application state is pulled into the new application, items are missing and the application can crash when searching for a barcode.

A fix for this problem has been submitted to the Marketplace, but it may take a few days to actually hit the device in your hand.

A short-term fix for this issue can be performed by uninstalling Stripes and re-installing it from the Marketplace. You will not be charged for the re-installation and it should fix the internal data structure. However, this will result in complete data loss of your scanning history.

I apologize for this error and please look for the fix on your device, soon.

Thank you!

This work by Jason Williams is licensed under a Creative Commons Attribution-NonCommercial-NoDerivs 3.0 Unported License.
Based on a work at centrolutions.com.

If you liked this article, see more on Centrolutions.

Stripes 2.0 for Windows Phone

jason@centrolutions.com (Jason Williams) — Mon, 25 Apr 2011 19:35:21 GMT

The latest version of Stripes (2.0) brings the following changes:

Fixed crash bug with certain ISBN numbers and QR codes
Added option to use GPS and search for local stores carrying the product scanned
Added option to use regional search services for better, localized results
Added ability to rename history items and delete individual items from history (touch and hold on an item for a context menu)
Added support for two new languages (German and Spanish)
Added error reporting to aid in diagnosing support issues
Enhanced detection of barcodes in photos where the barcode is rotated by 90 degrees

The good news is that the next version of Windows Phone (“Mango” is the code name) will allow developers to embed the camera in their application. That means, Stripes will have “live scanning” capabilities! Microsoft says we can expect this update in the fall of 2011.

This work by Jason Williams is licensed under a Creative Commons Attribution-NonCommercial-NoDerivs 3.0 Unported License.
Based on a work at centrolutions.com.

If you liked this article, see more on Centrolutions.

What Order Do Navigation Methods Get Called in Windows Phone?

jason@centrolutions.com (Jason Williams) — Mon, 11 Apr 2011 10:34:00 GMT

Recently, I was asked which gets called first: the Application_Launching, Application_Activated, Application_Deactivated, and Application_Closing events or the page-specific OnNavigatedTo and OnNavigatedFrom overrides. It turns out, the answer is – both.

When the application first runs from the start screen, Application_Launching gets called first. Then, the page-specific OnNavigatedTo gets called.

When navigating back to the start screen (by pressing the start button), the page-specific OnNavigatedFrom override gets called and then the Application_Deactivated event gets fired.

When navigating back to the app (using the back button), the Application_Activated fires first, and then the page’s OnNavigatedTo override gets hit.

So, the rule of thumb seems to be, if you are on a page, that page’s overrides will be called first. If you are entering the app from elsewhere, the Application events will fire first. Now you (and I) know!

This work by Jason Williams is licensed under a Creative Commons Attribution-NonCommercial-NoDerivs 3.0 Unported License.
Based on a work at centrolutions.com.

If you liked this article, see more on Centrolutions.

Slides and Demos from Nebraska Code Camp 2011

jason@centrolutions.com (Jason Williams) — Sun, 10 Apr 2011 08:28:00 GMT

Thanks to everyone who came to my session Building a Real App for Windows Phone 7 at the Nebraska Code Camp 2011 event. I hope you enjoyed it. If you’re looking for the slides and demos, you can download them here.

This work by Jason Williams is licensed under a Creative Commons Attribution-NonCommercial-NoDerivs 3.0 Unported License.
Based on a work at centrolutions.com.

If you liked this article, see more on Centrolutions.

Quick Tip: Find your Windows Phone Wifi MAC

jason@centrolutions.com (Jason Williams) — Fri, 08 Apr 2011 15:50:00 GMT

I recently had to find the mac address of the Windows Phone I was using for a demo. I needed to connect to Wifi and the venue filtered connections by MAC.

Here are the steps to make it happen:

Open the Phone app and dial ##634#
Hit the "Call" button and a "Diagnosis" app will open
In the "Diagnosis" app, dial *#1234# and a "Version" screen will be shown.
There's your Wi-Fi MAC address at the bottom of the screen. Cool, eh?

By the way, I should mention, this is a "Works on my phone" type of thing. I have tested it on a Samsung Focus.

This work by Jason Williams is licensed under a Creative Commons Attribution-NonCommercial-NoDerivs 3.0 Unported License.
Based on a work at centrolutions.com.

If you liked this article, see more on Centrolutions.

How the TextBox InputScope Affects the Windows Phone SIP (On-Screen Keyboard)

jason@centrolutions.com (Jason Williams) — Wed, 06 Apr 2011 09:29:06 GMT

When writing a Windows Phone 7 application in Silverlight, you will find a property on every TextBox control called “InputScope.” The primary use of this property is to alter the way the Software Input Panel (SIP or on-screen keyboard) works. Depending on what you set its value to, the SIP will include certain character sets, auto-complete features, and can auto-capitalize phrases and words for you. There’s no question you should be using this built-in feature. However, sometimes it’s hard to remember what each value of the InputScopeNameValue Enumeration actually does.

As it turns out, Microsoft lists only 10 modes the SIP can be put into. Below, you will find a screenshot of each and a list of the InputScope values associated with each.

[more]

Default

If the InputScope is not specified, this is the SIP that is used. You get a standard layout with no auto-complete help at the top.

InputScope values: Default, PhraseList, RegularExpression, Srgs, Xml, EnumString, FullFilePath, FileName, LogOnName, PersonalFullName, PersonalNamePrefix, PersonalGivenName, PersonalMiddleName, PersonalSurname, PersonalNameSuffix, AddressStateOrProvince, AddressCity, AddressCountryName, AddressCountryShortName, OneChar, Password, NumberFullWidth, AlphanumericHalfWidth, AlphaNumericFullWidth, CurrencyChinese, Bopomofo, Hiragana, KatakanaHalfWidth, KatakanaFullWidth, Hanja, Yomi, Private (causes a non-functioning auto-complete bar to show at the top of the SIP)

InputScope values starting in numeric / symbol mode: PostalAddress, PostalCode, AddressStreet, CurrencyAmountAndSymbol, CurrencyAmount, DateMonth, DateDay, DateYear, Digits, Number, Time, TimeHour, TimeMinorSec

InputScope values starting in text mode with first letter capitalization: DateMonthName, Date

Text

This SIP layout is nearly the same as the Default layout. However, it comes with an emoticon button, auto-correct bar (on top) and auto-capitalization for the first word of a sentence.

InputScope values: Text

Web

Also similar to the Default layout, a “.com” button is added along with a highlighted Enter button.

InputScope values: Url

E-mail address

Adding the “.com” and “@” buttons to the default layout, this layout is used for email address entry.

InputScope values: EmailSmtpAddress, EmailUserName

E-mail name or address

This layout is listed separately from the “E-mail address” layout, but seems to be identical in every way.

InputScope values: EmailNameOrAddress

Maps

The Maps layout is suppose to be used for entering location information (coordinates or city, state combinations). It includes a prominent comma button, auto-complete features, and a highlighted Enter key.

InputScope values: Maps, ApplicationEnd

Phone number

This layout is a standard 12-key telephone pad (0 – 9, *, and #) with the addition of Backspace, Space, Comma, and Period.

InputScope values: TelephoneNumber, TelephoneCountryCode, TelephoneAreaCode, TelephoneLocalNumber

Search

This is nearly the same as the Default layout, but also includes a highlighted Enter key.

InputScope values: Search

SMS contact

Take the Default layout, add access to the 12-key telephone pad (123 button), the “@” key, and a semicolon.

InputScope values: NameOrPhoneNumber

Chat

This layout is listed separately from the “Text” layout, but seems identical to the Text layout.

InputScope values: Chat

One thing I should bring up is that I did not try the keyboard in all language modes. (If you hit the “En” button you can switch languages) However, it does appear the above lists are consistent across languages, as well. I tested this in English (United States). If you spot an error, please let me know and I’ll update the post.

This work by Jason Williams is licensed under a Creative Commons Attribution-NonCommercial-NoDerivs 3.0 Unported License.
Based on a work at centrolutions.com.

If you liked this article, see more on Centrolutions.

Slides and Demos from Lincoln .NET User Group

jason@centrolutions.com (Jason Williams) — Thu, 27 Jan 2011 10:20:00 GMT

If you came to the Lincoln .NET User Group last night, thanks! Unfortunately, I ran out of time and didn't get to show all of the demos I had prepared, but I hope it was informative, nonetheless. I've attached the final demo project and the slides from my talk.

Thanks again for coming out and feel free to contact me with questions.

Slides and Demos

This work by Jason Williams is licensed under a Creative Commons Attribution-NonCommercial-NoDerivs 3.0 Unported License.
Based on a work at centrolutions.com.

If you liked this article, see more on Centrolutions.

Stripes 1.4 for Windows Phone

jason@centrolutions.com (Jason Williams) — Tue, 11 Jan 2011 21:30:00 GMT

Version 1.4 was just released to the Marketplace. It brings the following updates:

Improved Barcode detection from photos
Improved search results for products
Improved QR Code support (including Contacts and Map Locations)
Ability to save photos to the Picture Hub
Ability to use an existing photo from the Picture Hub
Better progress reporting during scans

As always, bug reports and image detection problem reports are welcome. Please comment here or use the "Contact" link in the menu.

This work by Jason Williams is licensed under a Creative Commons Attribution-NonCommercial-NoDerivs 3.0 Unported License.
Based on a work at centrolutions.com.

If you liked this article, see more on Centrolutions.

Stripes 1.3 for Windows Phone

jason@centrolutions.com (Jason Williams) — Tue, 30 Nov 2010 11:17:00 GMT

I uploaded the latest version of Stripes (1.3) to the Marketplace last night. This version brings a few improvements, including:

Searching will optionally (prompts the user) defer to the phone's built-in search facility if nothing can be found through Stripes
Added a "Settings" page with an option to examine images more thoroughly. This should increase the likelihood of finding a barcode in an image where the barcode doesn't fill a majority of the frame.
Fixed a potential detection bug that may have kept some barcode types from being discovered in images
Added better support for UPC-E barcodes (the shorter version found on some food products, like soda cans)
Added additional QRCode functionality and 2-D / Data Matrix support (both are still a work in progress)
Added contact information to the bottom of the "Help" page
Prices for products are now sorted in ascending order

Right now, I am constrained by the very limited camera API on all Windows Phone devices. Microsoft has promised regular updates to the platform and I am hopefull that direct camera access will become available in a future release. However, until then, a "live" barcode scanner (one in which the video from the camera is examined until a barcode is found) is impossible. Also, there is no way to modify the camera settings or save them for future use, either. Believe me when I say I am anxiously awaiting an update to this particular API. Are you listening, Microsoft?

Let me also say "thank you" to the many people that are using Stripes. I hope it is a useful tool and will continue work to make it more useful, as the Windows Phone platform evolves. Please leave a comment here or contact me on Twitter @Centrolutions with your feedback.

This work by Jason Williams is licensed under a Creative Commons Attribution-NonCommercial-NoDerivs 3.0 Unported License.
Based on a work at centrolutions.com.

If you liked this article, see more on Centrolutions.

Windows Phone 7 Launch

jason@centrolutions.com (Jason Williams) — Mon, 11 Oct 2010 15:53:00 GMT

Microsoft officially luanched its new smartphone brand "Windows Phone" today. While I usually don't re-blog / link-blog I do want to mark the occasion and I can't really add much to the following content:

http://www.tested.com/news/windows-phone-7-hardware-revealed-the-rundown/1120/

http://channel9.msdn.com/posts/First-Look-Windows-Phone-7-Hardware

As a developer, I'm super excited about the new platform and have a couple of ideas in the works. However, I am a little dishearted by the fact that, at the RTM, we (developers) have no api access to the microphone, compass, the video stream from the camera, or user data files (like music and video the user loads onto the device). This is limiting, for sure. However, those things should be coming with a software update.

I am excited to see the number of devices (10 by my count) announced today. Also, the price of most of them ($199 w/contract) seems reasonable compared to competing phones.

Anyway, enjoy the content I linked to, above and know that I hope to post some developer content about the phone... just as soon as I can get my hands on one.

Oh yea, there's also this: http://www.youtube.com/watch?v=EHlN21ebeak (Funny Commercial)

This work by Jason Williams is licensed under a Creative Commons Attribution-NonCommercial-NoDerivs 3.0 Unported License.
Based on a work at centrolutions.com.

If you liked this article, see more on Centrolutions.

Slides and Demos from Lincoln Users Group Super Laptop Meeting

jason@centrolutions.com (Jason Williams) — Thu, 26 Aug 2010 14:36:00 GMT

I had a great time speaking at the “Super Laptop Meeting” last night. My 20-minute talk was “Best Practices for Custom WF Activities.” I even won the grand prize, so thanks to all of you that voted for me!

If you are interested in the slides and the demo I showed, you can download them by clicking here. If you want to know more about the Lincoln .NET Users Group, you can do so at http://www.lincolndev.net

This work by Jason Williams is licensed under a Creative Commons Attribution-NonCommercial-NoDerivs 3.0 Unported License.
Based on a work at centrolutions.com.

If you liked this article, see more on Centrolutions.

Dynamic Control Layout With WPF

jason@centrolutions.com (Jason Williams) — Fri, 11 Jun 2010 03:27:00 GMT

If you are even a little bit familiar with the Model-View-View Model pattern and its implementation in WPF, you have probably run into the ItemsControl control. Actually, even if you haven’t used MVVM, you may have used it. Somewhat like the Repeater control in ASP.NET, this control allows you to bind to a data source and do something in XAML for each of the items in that data source. In any case, let’s play around with the ItemsControl element in WPF a little bit.

[more]

Imagine we have the need to display a Tic-Tac-Toe board in an application. Our model might look like this:

    public class MoveBase
    {
        public int Row { get; set; }
        public int Column { get; set; }
    }
    public class XMove : MoveBase
    {
    }
    public class OMove : MoveBase
    {
    }

You’ll notice there is a base class and two descendent classes. Each of the inheriting classes represents a move by either the X-player or the O-player.

Our View Model looks something like this:

    public class MainViewModel : ViewModelBase
    {
        public MainViewModel()
        {
            Moves = new ObservableCollection<MoveBase>()
            {
                new XMove() { Row = 0, Column = 0 },
                new OMove() { Row = 1, Column = 0 },
                new XMove() { Row = 1, Column = 1 },
                new OMove() { Row = 0, Column = 2 },
                new XMove() { Row = 2, Column = 2}
            };
        }
        public ObservableCollection<MoveBase> Moves
        {
            get;
            set;
        }
    }

For the sake of our example, the constructor creates some sample moves, but those could be loaded from a data store in a “real world” application. The key is the property called “Moves” that will be bound to in the View (XAML) portion of the app.

The View part of the app might look like this:

    <Window.Resources>
        <DataTemplate DataType="{x:Type m:XMove}">
            <Image Source="XMove.png" Stretch="None" />
        </DataTemplate>
        <DataTemplate DataType="{x:Type m:OMove}">
            <Image Source="OMove.png" Stretch="None" />
        </DataTemplate>
    </Window.Resources>
    <Grid>
        <ItemsControl ItemsSource="{Binding Path=Moves}">
            <ItemsControl.ItemContainerStyle>
                <Style>
                    <Setter Property="Grid.Row" Value="{Binding Path=Row}" />
                    <Setter Property="Grid.Column" Value="{Binding Path=Column}" />
                </Style>
            </ItemsControl.ItemContainerStyle>
            <ItemsControl.ItemsPanel>
                <ItemsPanelTemplate>
                    <Grid ShowGridLines="True">
                        <Grid.RowDefinitions>
                            <RowDefinition />
                            <RowDefinition />
                            <RowDefinition />
                        </Grid.RowDefinitions>
                        <Grid.ColumnDefinitions>
                            <ColumnDefinition />
                            <ColumnDefinition />
                            <ColumnDefinition />
                        </Grid.ColumnDefinitions>
                    </Grid>
                </ItemsPanelTemplate>
            </ItemsControl.ItemsPanel>
        </ItemsControl>
    </Grid>

You will notice there is a data template for each of the MoveBase types that will display the appropriate image for the type of move.

Now, to the ItemsControl: Notice that it is bound directly to the Moves property in the ViewModel. Also, the <ItemsPanelTemplate> defines a 3x3 grid for the items in the Moves collection. Every item (an XMove or an OMove) will be placed inside of the grid defined here.

The last thing to take note of is the <ItemsControl.ItemContainerStyle> element. When the ItemsControl control is rendered, it actually wraps each of the items it is bound to in a container. That means each of our images won’t be directly contained in the 3x3 grid; thus we need to assign the row and column to each item’s container. We do that with some styling. Two property setters take care of this detail.

The resulting form should look like this:

Because of the ItemsControl control, the placement of the images can be controlled from the View Model. Of course, this solution just displays a Tic-Tac-Toe board, but it should be a relatively small change to add a few commands and create a playable Tic-Tac-Toe board.

This work by Jason Williams is licensed under a Creative Commons Attribution-NonCommercial-NoDerivs 3.0 Unported License.
Based on a work at centrolutions.com.

If you liked this article, see more on Centrolutions.

Selecting Multiple Rows as a Single Column in SQL

jason@centrolutions.com (Jason Williams) — Mon, 29 Mar 2010 22:14:00 GMT

Recently, I was writing a report that selected some data out of a normalized SQL Server database. For one of the queries, I needed a “flattened” form of the rows in one of the tables. In essence, what I needed to do was turn several rows of data into a single column.

[more]

Here’s an example of what I was looking at:

The Data Tables

ParentId	FirstName	LastName	Age
1	John	Smith	26
2	Jane	Johnson	32
3	Jacob	Doe	29

ChildId	ParentId	FullName
1	1	Johnny Smith
2	2	Billy Johnson
3	2	Samantha Johnson
4	3	Megan Doe
5	3	Willy Doe
6	3	Bobby Doe

I’ll setup this example like this:

DECLARE @Parents AS TABLE (
	ParentId INT PRIMARY KEY,
	FirstName VARCHAR(50),
	LastName VARCHAR(50), Age INT)
DECLARE @Children AS TABLE (
	ChildId INT PRIMARY KEY,
	ParentId INT, FullName VARCHAR(50))

INSERT INTO @Parents VALUES (1, 'John', 'Smith', 26)
INSERT INTO @Parents VALUES (2, 'Jane', 'Johnson', 32)
INSERT INTO @Parents VALUES (3, 'Jacob', 'Doe', 29)

INSERT INTO @Children VALUES (1, 1, 'Jonny Smith')
INSERT INTO @Children VALUES (2, 2, 'Billy Johnson')
INSERT INTO @Children VALUES (3, 2, 'Samantha Johnson')
INSERT INTO @Children VALUES (4, 3, 'Megan Doe')
INSERT INTO @Children VALUES (5, 3, 'Willy Doe')
INSERT INTO @Children VALUES (6, 3, 'Bobby Doe')

The Desired Output

What I needed was a table of the parents along with a column that contained a comma-delimited list of each parent’s children. Something like this:

ParentId	FirstName	LastName	Age	Children
1	John	Smith	26	Jonny Smith
2	Jane	Johnson	32	Billy Johnson, Samantha Johnson
3	Jacob	Doe	29	Megan Doe, Willy Doe, Bobby Doe

The Solution

The “secret sauce” for the solution involves the STUFF Function and the FOR XML PATH statement. You’ll notice that if we select from the child table using FOR XML PATH(‘’):

SELECT ', ' + c.FullName
FROM @Children c
WHERE c.ParentId=1
FOR XML PATH('')

The output looks like:

XML_F52E2B61-18A1-11d1-B105-00805F49916B
--------------------------------------------------------
, Billy Johnson, Samantha Johnson

Finally, if we wrap our FOR XML PATH select statement in the STUFF function, we can obtain our desired output with the following query:

SELECT p.ParentId
            , p.FirstName
            , p.LastName
            , p.Age
            , STUFF(
                  (SELECT ', ' + c.FullName
                        FROM @Children c
                        WHERE c.ParentId=p.ParentId
                        FOR XML PATH('')
                  ), 1, 2, '') AS Children
FROM @Parents p

Once again, we see that almost anything is possible with enough SELECT statements.

This work by Jason Williams is licensed under a Creative Commons Attribution-NonCommercial-NoDerivs 3.0 Unported License.
Based on a work at centrolutions.com.

If you liked this article, see more on Centrolutions.