SoundBytes 2013.pdf

Workshop_Update.pdf

Multiple dates in 2012 | 1 day Presentation | 32 PSfD hours

We are now able to bring the Visual Studio 2012 & .NET
4.5 Tech|Briefing “on the road” to you. We will run the event at your offices
to anything from a small group of developers to your entire team. This is the
same event that received fantastic feedback when we ran it for over 150
delegates in Reading – but we’ve also spent time analysing the feedback to
perfect the sessions even further. The day covers all the major features to
about Level 200 in the following areas;

• Visual Studio 2012
• Team Foundation Server 2012
• C# and .NET 4.5 Core
• ASP.NET 4.5 and Entity Framework
• WCF, WPF and WF 4.5
• Windows 8 Application Development & Windows
  Store

See the attached data sheet for more information. To book, contact
your ADM; they will provide options from the pre-reserved dates we have
available.

Tech Briefing Datasheet.pdf

20^th – 22^nd November 2012 | Microsoft Campus, Reading | 3 day workshop | 14 PSfD hours per
delegate

This workshop is a three day deep dive into the key developer concepts of Metro style development. The workshop takes you through the most important features and architectural concepts that you will find in the next release of Windows. Examples of these are the new UI, Process Lifecycle Manager, Tiles and Notifications and the different contracts to name but a few. After this workshop, you will have written a fully functional working application. This is a hands-on workshop that exposes students to the new programming model for Windows 8.

ASP.NET MVC 4 Ramp Up

13^th &14^th November 2012 | Microsoft Campus, Reading | 2 day workshop | 8 PSfD
hours per delegate

ASP.NET MVC has matured since release and is proving to be very popular with our customers; many have deployed or are currently developing new applications with it. The ASP.NET MVC Ramp Up is a two day workshop targeted at getting your developers and architects up to speed fast, whilst retaining a strong focus on “doing it the right way”. It was created early in the life of MVC, so has become a proven format over the years and has been updated with each major revision of the framework.

SoundByte: Service Bus Server, the next generation
messaging middleware, Zulfiqar Ahmed

10:00am, 9^th November 2012 | 1 hour webcast | 1
PSfD hour for 2 connection

Azure Service Bus is the core messaging middleware for Microsoft’s next generation on-premises and cloud workloads. Service Bus Server brings the same reliable & scalable middleware to on-premises workloads that has been available in the cloud for some time now. With 100% Azure compatibility, customers can easily move their workloads between on-premises and Azure. This session will be a preview of the recent Beta release of Service Bus Server; we will discuss server architecture, its messaging capabilities and the supported programming models.

SoundByte: Programming Visual Studio with Nuget and
Powershell, Rob Garfoot

3:00pm, 9^th November 2012 | 1 hour webcast | 1
PSfD hour for 2 connection

This SoundByte will cover how to use the PowerShell console that ships with NuGet to add new cmdlets to Visual Studio to automate common tasks. By the end of the session you will be familiar with:

• How to build a NuGet package that can be
  deployed to Visual Studio to deliver a PowerShell module
• How to build a PowerShell module that exports
  commands capable of controlling Visual Studio
• Providing IntelliSense to the cmdlets for easier
  use and pipelining capabilities
• See examples of building a couple of simple
  cmdlets to demonstrate the process

Knowledge of NuGet, Visual Studio automation and PowerShell
is not a pre-requisite.

 By Aidan Caffrey - Application Development Manager

All around the world more users have a smart-phone and/or a tablet every day _1. This change has caused the application marketplace to change drastically over a short space of time. In this new world, it is now easier (and maybe faster) to connect with and generate revenue from a large audience. It’s also easy to be left behind with the high pace of change, or build an app that nobody wants…

More statistics are continually produced comparing web-traffic from mobile browsers to that from desktops, and revenue figures from apps/advertising _2. The world is full of predictions of “mobile browser traffic surpass[ing] desktop in 2014” ₃. This means discussions have moved away from whether to be considering the mobile space to we need to go mobile – but which way is best in our exact scenario.

So let’s consider and evaluate the different options:

Do Nothing 

It’s entirely your prerogative to ignore the mobile
space. In some rare domains mobile doesn’t make sense. It might actually cost
you more to solve this problem that you’d generate in revenue.

Make your app look good on a mobile browser

 You need to answer this key question – are
you updating your app purely to look good on mobile browsers, or are you
building different functionality for the mobile version of your app?

If your vision goes beyond look and feel, you
are actually building a different app. At this point your thoughts should turn
to code re-use, maintenance of the dual code bases, and how they evolve in the
future.

If it is just a User Experience issue, there
are two major options; – firstly, can you manage the differences purely with styling
changes? If so, CSS3 Media Queries could be the answer – provided your target browsers
support HTML5! If you cannot the alternative is for the server to respond with different
HTML based on the browser. In ASP.NET MVC 4 this is implemented with “Display
Modes”.

Port your app to a native app for a particular OS.

What platforms are you going to target? Windows
Phone, obviously… but how about iOS and Android? Once you’ve decided, do you
have the skills and tooling in your team to do this? You may need training,
physical devices, emulators, IDEs, and more. How do you build it in a CI
environment, and what is the impact on your testers?

Native apps have a very different lifecycle; they
are in an “often disconnected” world, and the platforms will evolve
independently of your app; updates might change the way the app can run, its permissions, or the device
capabilities. Planning for the maintenance involved and determining the
economic and servicing model are fundamental to your success.

Hybrid₄

Hybrids are built using HTML5 and JavaScript,
with a thin native wrapper around it. This reduces the amount of native code to
write, maintain, run, port and test, but can increase the skillset required.
Alternatively you could use tooling to do this part for you, but it is likely
to be limited to the “lowest common denominator” rather than fully utilizing
the device capabilities.₅

Which approach you select depends on your priorities and what you are trying to achieve. If you don’t need to support mobile, do nothing; although this is rare today. If you do, using Media Queries or Display Modes can be a cost effective way to prevent a loss of business through a site not compatible with mobile devices, or to start providing great mobile experiences for like-for-like feature scenarios. When your gear shifts to investment, seeing mobile as a true growth area and a distinct part of your offering, start thinking about native or hybrid approaches. This brings the ability to target your feature set and User Experience directly at mobile users in return for additional effort in development, maintenance, and related disciplines such as
marketing.

Whichever way sounds right to you, speak to your Application Development Manager about how we can help; we have ADMs that have specialist skills in ASP.NET WebForms, MVC, JavaScript, HTML 5, and in native device development on Windows Phone or Windows 8. We can teach you the technologies, run Architecture & Design sessions to help you choose the right mix for your scenario, partner with you to build a Proof of Concept, or conduct reviews of your progress at regular intervals to help you stay on the right path.

References:

1. http://blog.flurry.com/
2. http://mobithinking.com/guide-mobile-web-uk
3. http://www.smartinsights.com/mobile-marketing/mobile-marketing-analytics/mobile-marketing-statistics/
4. http://www.readwriteweb.com/mobile/2012/01/hybrid-html5-apps-are-more-les.php
5. http://www.phonegap.com/

Once you added the package to your project you can use the PromotedProperty attribute to mark your properties as promoted. The package supports promotion from both complex & primitive arguments. In addition to PromotedPropertyAttribute you also need to stick PropertyPromotionBehavior on each method of your service contract.

Following service contract captures the sample usage.

Enjoy…

Posted by Zulfiqar Ahmed on July 18th (http://zamd.net/2012/07/18/service-bus-property-promotion-nuget-package/)

In case anyone else is looking to do the same, here’s the steps I
followed:

• Backed up all the files from my blog at my existing hosting provider (in
  this case copied everything locally via FTP)
• Exported the MySql database at my existing hosting provider to a local SQL
  file using MySql Workbench (yes, I know I could do
  this with a command line, but I like GUIs!)
• Logged into the Windows Azure Management Portal and created a new Windows
  Azure Web Site from the gallery, and selected WordPress as the template
• I didn’t bother setting up WordPress as I was going to copy over everything
• Connected to the new Windows Azure Web Site via FTP, and copied over all the
  files I backed up from my existing provider
• At this point the site mostly worked as it was connecting back to my
  existing MySql database
• Logged into the WordPress Dashboard to reconfigure the site URL to the
  Windows Azure Web Site URL
• Connected to the new MySql database created by the Windows Azure Web Site
  WordPress template with MySql Workbench, and imported the export I took earlier
• Opened up the wp-config.php file in the root of the web site, and
  reconfigured the MySql database connection information
• All done!

Well, when I say all done, I mean that WordPress, with all my content and
options, is running in Windows Azure. However, I also had to move all the DNS
for phazed.com over too, and that’s where I tripped over a little. You can
certainly do this with Windows Azure Web Sites, you just need to use a reserved
instance, add a CNAME in your domain for the Windows Azure Web Site hostname,
and then add a custom domain to your Windows Azure Web Site. This is all
explained quite well here:

http://social.msdn.microsoft.com/Forums/en-US/windowsazurewebsitespreview/thread/2a22b012-dc80-4f7a-9500-2a5ff628b5c4

There’s a caveat however. At the moment you can only add custom domains using
CNAMEs, which is practice means I can add www.phazed.com for
phazed.azurewebsites.net, but not phazed.com (without the www). Apparently it’s
coming, but this was a problem for this blog as all the permalinks used
phazed.com, not www.phazed.com. I won’t bore you with the details of how, but I
got around it by adding some redirection at my DNS hoster for phazed.com to
www.phazed.com, and bulk editing the contents of the database export before
importing back into the new MySql database.

Anyway, it’s all done, and I’m quite pleased that’s the blog is finally on
Windows Azure. It’s even a little faster I think!

Original post by Rupert Benbrook on July 12th 2012.

The posts from the EF team show how to control the caching by setting context.ContextOptions.DefaultQueryPlanCachingSetting = false. In the Release Candidate for EF5 this property is no longer there. Instead, you need to set the EnablePlanCaching property on the ObjectSets. As an example, consider the following simple query:

In this query, context.Customers is the ObjectSet. To disable caching we need to set the EnablePlanCaching property as shown below:

Personally, this feels like quite a lot of noise that gets in the way of the query. To solve this I created a little extension method that means we can now write the query as

The extension methods to achieve this are really pretty simple:

Enjoy!

Original Post by Stuart Leeks on June 12th, 2012

Here: http://blogs.msdn.com/b/stuartleeks/archive/2012/06/12/entity-framework-5-controlling-automatic-query-compilation.aspx

The problem was something that I’d encountered in a number of blog posts that used modified editor templates (jQuery UI datepicker, aria-required and autocomplete). In each of these posts I ended up adding a custom template, and then updating it to output an attribute in the rendered HTML. The thing that bothered me about all of these posts is that they didn’t compose well. For example, if you wanted to combine autocomplete and aria-required then you’d have to merge the changes to the templates. In the blog post, Simon and I walk through a fairly simple way to solve this problem with the introduction of HtmlAttributeProvider.

aria-required

In the remainder of this post I thought I’d show how the previous solutions would look with the new HtmlAttributeProvider. In the joint post we show how the aria-required scenario can be handled simply by adding the following line of code to global.asax:

HtmlAttributeProvider.Register(metadata =>metadata.IsRequired, "aria-required", true);

This simply says that when the model metadata has the IsRequired field set (e.g. if the property on the model has the Required attribute applied) then output an attribute with name “aria-required” and value “true”.

jQuery UI datepicker

In the case of the jQuery UI datepicker the approach is also simplified. In fact, we no longer need to create the Date.cshtml editor template. Instead we can simply add the following line of code to global.asax:

HtmlAttributeProvider.Register(metadata => metadata.DataTypeName == "Date", "class", "date");

This code says that if the DataTypeName is Date (e.g. if you’ve added the DataType(DataType.Date) attribute to the model property) then it should add the “date” class to the element. Note that the attribute provider handles merging attribute values, so this will add the “date” class to the other class values (i.e. it plays nicely with the classes that are added by default)

jQuery UI autocomplete

The autocomplete change requires a little bit more effort, but only a little! To trigger the autocomplete behaviour, we added a “data-autocomplete-url” attribute with the value of the URL that returns the autocomplete data. The generation of the URL uses HtmlHelper, so we need to use the overload of HtmlAttributeProvider.Register that allows us to pass a delegate that takes the HtmlHelper as a parameter:

HtmlAttributeProvider.Register((html, metadata) =>
{
    string autocompleteUrl = html.GetAutoCompleteUrl(metadata);
    if (!string.IsNullOrEmpty(autocompleteUrl))
    {
        return new[] { new KeyValuePair<string, object>(
                    "data-autocomplete-url", autocompleteUrl) };
    }
    return null;
});

The Register overload here expects a collection of attributes (KeyValuePairs) to be returned. The previous examples could have been written using this overload, but we opted to add a Register overload to simplify that common scenario.

Summary

Whilst it is nice that the previous scenarios have been simplified by the introduction of HtmlAttributeProvider, the real benefit is the composability as you can simply add multiple registrations!

Original Post by Stuart Leeks on May 24th, 2012

Here: http://blogs.msdn.com/b/stuartleeks/archive/2012/05/24/asp-net-mvc-supplying-html-attributes-with-editorfor.aspx

Our latest coinciding of ideas was a way to automatically inject HTML attributes for fields rendered as part of your model with Html.EditorFor. We’ve just blogged about it on our team blog – Adding Html Attributes in Templated Helpers, published the code on the MSDN Code Gallery under UkadcHtmlAttributeProvider, and pushed a working version to NuGet under UkadcHtmlAttributeProvider.

Have a read of the blog post to learn more. To try our solution just use the NuGet command;

Install-Package UkadcHtmlAttributeProvider

A few examples of attribute provider delegate registrations are below. Do let us know if you like the approach!

Output the aria-required attribute for required fields;

HtmlAttributeProvider.Register(

   metadata => metadata.IsRequired,

   "aria-required",

   "true");

This results in the following HTML for a string field;

<input aria-required="true" class="text-box single-line" … snip … />

Output an HTML 5 Custom Data Attribute (CDA) when the field contains a URL;

HtmlAttributeProvider.Register(

   metadata => metadata.DataTypeName == "Url",

   "data-url",

   "true");

 This results in the following HTML for a string field;

<input class="text-box single-line" data-url="true" … snip … />

Output the Square Root of a value of a number field as an HTML 5 CDA;

HtmlAttributeProvider.Register((html, metadata) =>

    {

        if (metadata.ModelType == typeof(Int32))

            return new[]

            {

               new KeyValuePair<string, object>(

                  "data-sqroot-value",

                       Math.Sqrt(

                          Convert.ToDouble(metadata.Model)))

            };

        return Enumerable.Empty<KeyValuePair<string, object>>();

    });

 This results in the following HTML for an Integer field;

<input class="text-box single-line" data-sqroot-value="4.58257569495584" … snip… />

OK so that last one is a bit arbitrary – but there’s a huge amount you can do here. Think of tab indexes, URLs for Ajax callbacks, CSS classes… the list goes on.

Head over to the blog post to read about how it works. And check out Stu’s follow-up post on some good real examples.

Original Post by Simon Ince on May 24th, 2012

Here: http://blogs.msdn.com/b/simonince/archive/2012/05/24/injecting-custom-html-attributes-in-asp-net-mvc.aspx