Traditionally, building the workflow for the creation, management, and distribution of media is problematic. It involves having to integrate multiple technologies and providers, some of which may be incompatible. In addition, it can require a huge investment in infrastructure, which may not always be fully utilized. These issues can result in a non-standardized workflow that is not easily scaled, and that requires coordination at different stages of the workflow.

Azure Media Services allow you to build scalable, cost effective, end-to-end media distribution solutions that can upload, encode, package, and stream media to Windows, iOS, Android, Adobe Flash, and other devices and platforms.

This guide describes how to design and build a video-on-demand application that uses Media Services. It provides an end to end walkthrough of a Windows Store application that communicates with Media Services through a web service, and explains key design and implementation choices.

How to get it?

In addition to the Windows Store application, the guide also includes client applications for Windows Phone 8, HTML5, iOS, and Android devices. You can download the Windows client applications from the Microsoft Download Center. You can download the Android and iOS applications from the community site.

You can view the documentation on MSDN or you can download it as an eBook from the Microsoft Download Center.

How to provide feedback?

If you’d like to provide feedback, please post it via the CodePlex forum.

Happy coding!

The advent of NoSQL databases has changed the way in which organizations have started to think about the way in which they structure their data. There is no standard definition of what a NoSQL database is other than they are all non-relational. They are less generalized than relational databases, but the driving force behind most NoSQL databases is focused efficiency and high scalability.

The downside of NoSQL is that no single database is likely to be able to support the complete range of business requirements mandated by your applications. How do you select the most appropriate database to use, or should you remain with the relational model? A modern business application is not restricted to using a single data store, and an increasing number of solutions are now based on a polyglot persistent architecture. The key to designing a successful application is to understand which databases best meet the needs of the various parts of the system, and how to combine these databases into a single, seamless solution.

This guide helps you understand these challenges and enables you to apply the principles of NoSQL databases and polyglot persistent solutions in your own environment.

To help illustrate how to build a polyglot persistent solution, this guide presents a case study of a fictitious company faced with building a highly scalable web application capable of supporting many thousands of concurrent users.

How to get it?

The source code for the associated reference implementation can be found on the Microsoft Download Center.

You can view the documentation on MSDN or you can download a PDF from the Microsoft Download Center.  The written guidance is also available for purchase on Amazon as a printed book or a Kindle download.

How to provide feedback?

If you’d like to provide feedback, please post it via the Codeplex forum.

Happy coding!

https://blogs.msdn.com/b/agile/archive/2013/02/07/embracing-semantic-logging.aspx

This is your opportunity to tell us what topics (SQL, ORMs, NoSQL, etc.) you feel should be covered in the guidance.

We value your opinions, so please take a moment and fill out this very short survey.

https://www.surveymonkey.com/s/dataaccess

Thanks!

The patterns & practices Symposium is the event for software developers and architects to have engaging and meaningful discussions with the people creating technologies and guidance at Microsoft.

This year’s Symposium topics span the spectrum of technology, architecture, and teamwork.  You will learn about practices, patterns, and technologies that will save you time and reduce risk when creating Cloud, Web, and Windows-based solutions. The Symposium is also an opportunity to influence p&p and other product teams face-to-face to address the scenarios most important to you.

Symposium Highlights

• This year’s theme is exploration—reflecting software development as a journey of discovery.
• Keynote Sessions by senior Microsoft executives including Scott Guthrie & Ales Holecek.
• Special keynote sessions delivered by Felicity Aston, the first woman to ski across Antarctica alone, and Adam Steltzner, NASA lead engineer for Curiosity’s Entry, Descent and Landing.
• 18 thought-provoking sessions.
• Symposium Party on Wednesday night.
• Scott Hanselman’s Coding Game show—back by popular demand!

Registration for the three day Symposium is $498.

More information about sessions, speakers, and registration is available online:

https://aka.ms/symposium

Register now!

Since the application was using WPF 4.0, a pixel shader was a natural fit for this problem.  There have a been a number of great blog posts about pixel shaders, HLSL, and WPF, so I won’t go into detail about the inner workings.  The posts below are the main ones I used to get an understanding how to solve this problem.

• A Series on GPU-based Effects for WPF
• Advanced Alpha Blending with HLSL
• Photoshop-like Alpha Blending
• Premultiplied alpha

While the above articles showed everything needed to get a working sample up and running, there was no overarching sample that brought everything together.  Building a working WPF application that shows an image with a pixel shader effect tied to it is relatively straightforward.  Adding a second image parameter to the pixel shader and an opacity factor is also very simple given the level of pixel shader support in WPF.  One thing that you need to keep in mind is the fact that WPF uses pre-multiplied alpha values for optimization purposes.  That affects the math that you need to do in the pixel shader.

My initial attempt worked great when the images were the same size, however when the images were different sizes, the second image was resized to the size of the base image.  This again is an optimization done by WPF, but definitely doesn’t give the results we would want.  Greg Schechter's last blog post in his series on GPU-based effects in WPF explains this in detail.  To make the ViewBox technique work with absolute X, Y positioning coordinates, there is some sizing math that needs to be done.  Since I try to keep as little code behind as possible in my views, I wrote the converter below to do all of this work for me.

    public class ViewboxRectConverter : IMultiValueConverter
    {
        public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
        {
            if ((values == null) || (values.Length < 4))
            {
                throw new InvalidOperationException(
                    string.Format(
                    CultureInfo.InvariantCulture,
                    "Invalid number of parameters.  Found: {0}  Minimum Required: 4",
                    values.Length));
            }

            double baseImageWidth = values[0] == null ? 0.0d : (double)values[0];
            double baseImageHeight = values[1] == null ? 0.0d : (double)values[1];
            int blendImageWidth = (values[2] == null) ? 1 : (int)values[2];
            int blendImageHeight = (values[3] == null) ? 1 : (int)values[3];

            // Just a shortcut to save some if statements.
            double x = (values.Length > 4) ? values[4] as double? ?? 0.0d : 0.0d;
            double y = (values.Length > 5) ? values[5] as double? ?? 0.0d : 0.0d;

            double scaleX = baseImageWidth / blendImageWidth;
            double scaleY = baseImageHeight / blendImageHeight;

            return new Rect((x / blendImageWidth) * -1, (y / blendImageHeight) * -1, scaleX, scaleY);
        }

        public object[] ConvertBack(
            object value,
            Type[] targetTypes,
            object parameter,
            CultureInfo culture)
        {
            throw new NotImplementedException();
        }

The XAML usage is as follows.

<ImageBrush x:Name="imageBrush" ImageSource="{Binding ElementName=blendImageName, Path=SelectedValue}">
    <ImageBrush.Viewbox>
        <MultiBinding Converter="{StaticResource rectConverter}">
            <Binding RelativeSource="{RelativeSource Mode=FindAncestor, AncestorType=Image}" Path="ActualWidth" />
            <Binding RelativeSource="{RelativeSource Mode=FindAncestor, AncestorType=Image}" Path="ActualHeight" />
            <Binding RelativeSource="{RelativeSource Mode=Self}" Path="(ImageBrush.ImageSource).(BitmapSource.PixelWidth)" />
            <Binding RelativeSource="{RelativeSource Mode=Self}" Path="(ImageBrush.ImageSource).(BitmapSource.PixelHeight)" />
            <Binding ElementName="xSlider" Path="Value" />
            <Binding ElementName="ySlider" Path="Value" />
        </MultiBinding>
    </ImageBrush.Viewbox>
</ImageBrush>

You might notice that I am binding to the actual width and height of the Image and ImageBrush respectively.  This is to allow our converter to update appropriately when either image changes in our view.  Binding to the ImageSource property doesn’t quite work the same as other bindings, so I took the path of least resistance.

You can download the sample application here.  It contains free sample images from various sources on the web.  I have resized all of the base images to 1024 x 768 and 96 ppi.  If you want to add your own, just make sure that it is 96 ppi, or WPF will resize it automatically.

To make this sample application build, you will need to install the Microsoft DirectX SDK.  I used the June 2010 DirectX SDK which is available here, but as long as you have a version that can compile Pixel Shader 2.0 FX files, it should be fine.  Also, to make my sample easier for me to test, there are two pre-build events that compile the pixel shaders every time you build.  My install path may be different than yours, so if you get errors during a build, check the path to the fxc.exe and make sure it is pointing to your install of the DirectX SDK.

There are many cool things that can be done with pixel shaders and this basic setup should allow you to add your own to try out.  For a great set of shaders, check out the WPF Pixel Shader Effects Library on CodePlex.

While the original post referenced a non-Microsoft ORM I used in a previous company, the concept/problem still applies to many problems, including the Entity Framework and it’s associated ObjectContext.

In a nutshell, the problem with the application surfaced because I was naively using the the per-thread lifetime manager included with Unity within my WCF service.  In the course of testing, I found that the objects using this lifetime manager seemed to occasionally persist across service calls.  After spending a couple of minutes looking at stack traces and general debugging, it finally dawned on me what was happening.  WCF's threading model, which was designed to make my services speedy, was actually causing the problem.

What was happening was that the same thread that was obtained in my first service call was being used to service my second service call.  Because I was using the per-thread lifetime manager in Unity, the object was not going to be removed from the container until the associated thread went away.  Well, in WCF, the threads don't ever really go away.  Uh oh!

After talking with Scott (who luckily used to work on Unity), we came up with the idea to build a Unity lifetime manager tied to WCF's OperationContext.  That way, our container objects would live only for the lifetime of the request, rather than the actual thread.

Starting with IExtension<OperationContext> and an implementation of IDispatchMessageInspector, I soon had an implementation of a UnityOperationContextLifetimeManager.  Once we used this lifetime manager instead of the per-thread lifetime manager, the problem disappeared.

Once that was done, I figured that since I did one of the extensible objects in WCF, I might as well do the rest.  The attached zip has lifetime managers to support all of the IExtensibleObject<T> implementations within WCF.

All of the lifetime managers are fairly straightforward, except for the UnityInstanceContextLifetimeManager.  This depends on the InstanceContext of a given service on which it is enabled.  PerSession is the default instancing mode for InstanceContext, but only when the transport supports sessions.  If the transport does not support sessions, the instancing mode is essentially PerCall.

I have included the Unity assemblies in the zip file for ease of compilation, but if you plan on using any of this code, I would point the references to wherever you have your Unity assemblies.

I’m working on getting these added to Unity Contrib, but for now, just download the code..

Please note that the testing application is not necessarily a best practice for self-hosting a service, but I wanted you to see how to use the lifetime managers without having to worry about IIS (since IIS 6 doesn't have WAS and doesn't support the net.tcp binding).  Make sure if you are on Windows 7/Vista, you run this sample application as admin.

Download - UnityWcfExtensions.zip

It has been quite awhile since I have blogged about .NET, so it will take a bit of time to get some posts together.  However, hopefully you will all eventually find something useful on this blog.  My first post will be around some custom lifetime managers for Unity that allow you take advantage of the various contexts within WCF.  This will be an update of a post from my personal blog with some minor updates suggested by the community (i.e. I fixed a couple of “bugs”).

Until then, happy coding!