Microsoft have made it extremely easy, almost trivial to deploy your web applications to the Azure cloud from Visual Studio. Cloud capability is incredibly powerful for scalability, particularly in enterprise level applications and affords Developers with the option to make their infrastructure as Agile as their Software.
By the end of this tutorial, we’ll have deployed our Web Application directly into a Web Site in Azure using their Platform as a Service offering (PaaS), meaning we don’t need to worry about a Virtual Machine, updates, and a myriad of other concerns. Continue reading “Web API Tutorials Part 5 : Azure Deployment from Visual Studio”
Web API offers some powerful routing behaviour. Let’s look at how we can use this in our app to avoid needing a new Controller for every Translation we wish to offer (again, ignore the fact our sample is likely only ever to require two way!).
We currently have a single AlphabetToMorseController with our old ITranslator implementation. In the previous tutorial we abstracted our service into an extensible dictionary, this should allow us to take our Translator Key as a routing parameter and our string to translate as a parameter in the URI on our API.
By the end of the post we’ll have refactored the existing AlphabetToMorseController to a generic TranslatorController, with our ITranslatorService being injected. The Key will be provided through a Web API Route, and the Get Requested to the Controller will return a collection of available Translators. Continue reading “Web API Tutorials Part 4 : Controller Attribute Based Routing”
There’s a famous quote in the world of Software Development:
“We can solve any problem by introducing an extra level of indirection.”
In my experience, this is almost certainly correct, this post will see us adding in an additional layer of Abstraction to allow us to simplify our Controller(s) and manage our Dependencies in a more straightforward manner.
Last post saw us implement our Translation PCL into our Web API using Dependency Injection. The problem is that our ITranslator Interface only handles a single Translator Implementation, such that when we inject from our Container we can’t currently translate more than one direction. We’ll look into the why’s shortly, but by the end of the post we will have created :
- ITranslatorService Interface;
- TranslatorService Implementation and Unit Tests.
Continue reading “Web API Tutorials Part 3 : Translation Abstraction”
Portable Class Libraries afford great benefit when it comes to sharing code across platforms/usages. We can share a single library across our UWP App where it’ll run locally and on our Web API where it’ll execute behind our endpoint. Dependency Injection has been made very accessible with the latest ASP.NET MVC Web API.
The current MorseCoder.PCL targets only Windows 8.1 as it’s point of API Reference. We’ll need to change that to extend it to the wider .NET Framework (we’re not doing anything prohibitive, so this isn’t a problem). By the end of the post we’ll have updated our PCL to target what we require, and integrated it into the Web API Project using Dependency Injection to pull in an instance of our Translator from the IServiceCollection container.
Continue reading “Web API Tutorials Part 2 : Translation PCL with Dependency Injection”
ASP.Net MVC Web API provides a straight forward controller based approach to creating RESTful HTTP based web services. It should be quite familiar to anyone with an ASP.NET MVC background. This tutorial won’t be focussing on what is and what is not RESTful, (there’s plenty of that already, and can get a little religious!).
By the end of this post we’ll have created an ASP.Net MVC 5 Web API Project, and a new Controller ready for implementation.
Continue reading “Web API Tutorials Part 1 : Web API”
UWP apps, like the Windows Phone 7 and 8 platforms before them can have Background Tasks, while a background task for the Morse Coder app might not be enormously useful at this stage, let’s take a look at how to create one. In a further post we will look at updating the Live Tile from our Background Task.
By the end of this post we’ll have a Background Task running on a schedule. It won’t do anything, but we will have set up the permission in the manifest, created the project, and our task class and registered it with the application. We will then be ready to implement the task.
Continue reading “Universal App Tutorials Part 17 : Background Tasks”
Dependency registration in SimpleIoc, by default uses Lazy Instantiation, meaning the object won’t be created until it is requested, in this case, via the property on the ViewModelLocator class.
Due to configuring subscription of a message type in the Constructors of my ViewModels in MVVM Light I recently came across a situation whereby messages were being published prior to them having been subscribed to, meaning that the messages disappeared into the void unhandled. The ViewModels relating to the pages I had navigated to were available in the ServiceLocator, but the pages that I hadn’t navigated to were not being instantiated.
Continue reading “Eager Instantiation of ViewModels with MVVM Light Messaging”
Using Styles to create a consistent User Interface is generally considered to be a best practice. In much the same way as CSS is used on the Web, Styles in XAML provide a similar development experience.
By the end of this post we will have implemented a Style to target our About and Settings Buttons on the Home Page. removing some of the duplication in the XAML definitions.
Continue reading “Universal App Tutorials Part 16 : Styles”
It’s often necessary to “inform” other areas of an application of changes that have occurred. This can be achieved through Messaging. In the previous tutorial we created a Settings page and made the TranslationDirection Configurable. It would be nice if the Main View Model knew about our new Translation Direction setting, let’s look at how we can achieve this.
By the end of this tutorial we should have implemented a SettingsChangedMessage, subscribed to it from our MainViewModel and Published it from our SettingsViewModel. Continue reading “Universal App Tutorials Part 15 : MVVM Light Messaging”
Applications generally have a settings page, or similar allowing the user to configure the application. We laid the groundwork for making the Translation Direction setting configurable in the previous post, let’s look at putting that in to practice.
By the end of this tutorial we’ll have a really basic Settings Page, 2 Buttons allowing the user to pick between Morse to Alphabet and Alphabet to Morse, and a TextBlock displaying the current Translation Direction. Continue reading “Universal App Tutorials Part 14 : Settings Page”