How to force browser to updated the Silverlight package from client?

Where developing an application in Silverlight you will need to create more than one version of the application. Each new version of the application will require each client to clear the cache (CTRL+F5). Normally, you don’t want the application to be downloaded each time.  Because of this, you will not configure the package to expire after a specific period of time.
But what happens when you have a new version of the application? You cannot tell to the clients to clear the cache.
A simple solution for this problem is to version your assemblies. When you deploy on IIS server a new version of the application with the assembly version updated, the new version of your application will be automatically download from the server.
If you don’t know how to version your assemblies you can visit the following link: http://vunvulearadu.blogspot.ro/2012/05/how-to-change-version-of-our-solution.html
Don’t forget to update the assembly version each time when you make a deploy.

Read More

What should I do when I receive "4.1 Your app must comply with the following privacy-related requirements"

The most of us are developer; we are technical persons, which do their stuff better than anyone. But besides this, when we are developing a Windows Client application for Windows 8 (Metro App) we don’t need to forget about the legal stuff and similar things. We don’t like them, but we need to resolve them also.
If you have an application that use internet connection, access a backend server, share data with another 3th party like Facebook, Twitter or another system than we should have a simple privacy policy in our application.
From now one this is a MUST, even if in the past was optional. If you try to submit your application without privacy policy that you will receive a big reject with the following message:
"Your app doesn't meet requirement 4.1" (Privacy)
What I recommend, is to add a privacy policy even if you don’t thing that you store, share the user data. Why? Is safest for you and you don’t need to submit the application again if you will have this problem.
What should the privacy policy should contain? Depends, internet is full with a lot of privacy policy text. You can inspire from them, but I recommend to double check the text with someone from legal department or a lawyer.
After you have the privacy policy content, all that you have to do is to publish on your website. If your application don’t have a website, that you can create a blog and publish there the privacy policy. The good part with this is that: you can make anytime an update if the privacy policy without the need to create an update for your application.
When you create your application you will need to add a link in the setting page that will open a browser with the privacy policy. This can be done in different ways. If you have a base class for your pages, that you can override the “OnNavigateTo” method. The code should look something like this:

protected override void OnNavigatedTo(NavigationEventArgs e)
{

    SettingsPane.GetForCurrentView().CommandsRequested += (SettingsPane sender, SettingsPaneCommandsRequestedEventArgs args) =>  
      {
        IList<SettingsCommand> commands = requestEventArgs.Request.ApplicationCommands;
        if (commands.FirstOrDefault(x => x.Id.ToString().Equals("privacyPolicyCommand",StringComparison.CurrentCultureIgnoreCase)) != null)
        {
          return;
        }

        SettingsCommand privacyPref = new SettingsCommand("privacyPolicyCommand", "Privacy Policy", (uiCommand) =>
          {
            Windows.System.Launcher.LaunchUriAsync("http://mywebsite.com/privacypolicy.html");
          });
        requestEventArgs.Request.ApplicationCommands.Add(privacyPref);
      });

}

Cool, now we have in our Settings page of each page of our application a link to our privacy policy.
Next step is to add the link to our privacy policy page in the moment when we want to want to submit our applicant. There is a small input with “Privacy policy” label at the end of the page.
I hope that you will not have any kind of problems with 4.1 requirements. Good luck.

Read More

WOWZAPP 2012: Worldwide Global Hackathon for Windows -- Bucharest, Romania

Everyone on Earth already knows what will happen at the end of this month. Yes, you are right, Windows 8 will be launched. Not only this, Windows Phone 8 will be lunched in this month also. With this occasion Bucharest will be the host of WOWZAPP 2012: Worldwide Global Hackathon for Windows.
Sounds good and it will be a great event. You will have 24h to develop a great Windows Client App for Windows 8.

If you know C# and XAML or JavaScript and HTML5, than you should register NOW.
If you have a great idea of an application for Windows 8, that you should register NOW.
If you have a great idea of an application for Windows Phone that you should register NOW.

In the case you need something in backend; you will receive a six month subscription for Windows Azure.
What a great event! See you there.

Read More

Patterns in Windows Azure Service Bus - Dynamic Router Pattern

Last time we talked about Scatter-Gather Pattern and how we can implement it using Windows Azure Service Bus. Today, we will look over Dynamic Router Pattern and how can be integrated in Windows Azure Service Bus.
First of all, let’s see what Dynamic Router is. This is a pattern that can be used when we want to register at runtime different rules and based on this rules the messages are redirected to a specific consumers. This sounds pretty simple in the first moment, but we have 2 different situations that need to be handled.
The first one is from the consumer perspective.  In any moment we need to be able to change the rules or add new rules, without stopping the system. These rules can use properties from messages that didn’t exist when the system started.
The second situations are from the producer. At runtime we need to be able to add or remove properties that can be handled by the system when the routing is made without restarting the system or affecting the consumers.
Top on this, it would be nice to be able to extract all the properties that will be used by the routing mechanism automatically, without the need to make special configuration over the system.
Of course, this pattern can be implemented with success using Windows Azure Service Bus. This pattern can be implemented using Service Bus Queues or Service Bus Topics. The secret here to have the best implementation of this pattern in Windows Azure is to create a mechanism that can extract the properties that are needed by the dynamic routing from the message that is added to the Service Bus. This solution need to be very flexible and to give us the possibility at runtime to control this.
The solution of this problem can be the promoted properties that can be found in BizTalk. This kind of properties doesn’t exist yet in Windows Azure Service Bus, but can be implemented very easily using attributes. I describe this solution in the following blog post: http://vunvulearadu.blogspot.ro/2012/10/winduws-azure-service-bus-adding.htm
In this moment we know how we can dynamically add/remove properties from a BrokeredMessage. From now one, the rest can be implemented very easily. If we are using Windows Azure Service Bus Topic, we can create custom filters over each subscription.

TopicClient topicClient = TopicClient.CreateFromConnectionString(
CloudConfigurationManager.GetSetting(
    "ServiceBusConnectionString"),
    "myFooTopic");
SqlFilter sqlFilterReviewGroup = new SqlFilter(“Groups LIKE ‘%Review%’”);
topicClient.AddSubscription(“ReviewSubscription”, sqlFilterReviewGroup);
SqlFilter sqlFilterTestGroup = new SqlFilter(“Groups LIKE ‘%Test%’”);
topicClient.AddSubscription(“ReviewSubscription”, sqlFilterTestGroup);

This pattern can be used with success when we need a dynamic routing mechanism where rules and filters attributes can change anytime. This is a case that can appear when we offer a solution that is used by other solution providers.
Last edit: A list of all patterns that can be used with Windows Azure Service Bus, that were described by me LINK.  

Read More

Configuration settings from Windows Azure Service Configuration Schema (cscfg) is always null

Last day, one of my colleges had to move some configuration items from application configuration file to cscfg files (Windows Azure Service Configuration Schema).
He tried for some hours to move the configuration to cscfg files but without success. Even if the configuration was done 1 to 1 to the msdn example and the project was built and deployed with success, the configuration could not be accessed.
In the next part of the post I will describes the steps that were done by him:
      1. Identify the configuration that need to be moved in the configuration file:

<add key="BingKey" value="XXXXXXXXXXXXXXXXX" />

      2. Create the key definition in the csdef (Windows Azure Service Definition Schema) file:

<ServiceDefinition ..
    <WebRole ...
        <ConfigurationSettings>
            <Setting name="BingKey" />
        </ConfigurationSettings>
    </WebRole>
<ServiceDefinition>

      3. Add the value of the given configuration key to the cscfg file (cloud and also local configuration):

<ServiceConfiguration ...
    <Role ...
        <ConfigurationSettings>
            <Setting name="BingKey" value="XXXXXXXXXXXXXXXX" />
        </ConfigurationSettings>
    </Role>
</ServiceConfiguration>

      4. Access the configuration key:

string bingKey = ConfigurationManager.AppSettings[“BingKey”];

Every time when the key is retrieved, the return value is null. If we check the settings, we will notify that we cannot find the “BingKey” through the list of available setting. 
Did you spot the problem?
The configuration was made perfectly; the problem was with at step 4. When we want to access configurations from cscfg file we need to use the RoleEnvironmnet and not the ConfigurationManager. The configurations from cscgf files will not be available through AppSetings collection.
The code should be changed to something like this:

string bingKey = RoleEnvironment.GetConfigurationSettingValue("BingKey");

After this fix everything works perfectly. For more informations about RoleEnvironment please check the following link.

Read More

New Unit Tests features of Visual Studio 2012

Visual Studio 2012 was already lunched some time ago. A lot of new feature were introduce with this new version. Some changes from Visual Studio 2012 are big and from some point of view, the difference between the old version of Visual Studio and the new one are like the difference between Windows 8 and Windows 7.

 I think that a lot of developers already played a little with this new version of Visual Studio. The first thing that you notify after installing it is the time that is necessary to load the new Visual Studio – that is very low. The second thing is the new UI, that is Metro like.

One zone where Visual Studio 2012 made a big step forward was Unit Testing. A lot of new feature were introduce in this area that not only increase the productivity of the developer, but also increase the quality of the code. In the next part of the post we will discover what are the main new features that were introduce from the unit testing perspective.

Run tests after each build

In the old version of Visual Studio, we didn’t have a build in mechanism to run unit tests after each build. Because of this we had to click on “Run All Tests” each time when we build the solution. This could be annoying after a while. Visual Studio 2012 already has this feature build in and with only one click we can activate or deactivate this feature.

All the tests run in background, without bothering us.

Debug/Run tests from direct from code

How many time you had to go to the Test Explorer window to be able to run your current test. From now one, Visual Studio 2012 have a shourcut in the menu that will run the test that are selected in the code.

Group and run unit test based on the category

From now one we can add one or more categories to our unit test. This attribute can be added not only to each test in part but also to the unit test class. Using this feature we can run unit tests only from a specific category. This is a great feature when not only on the developers’ machine, but also on the build machines.

To be able to run the unit tests that have a specific category from command line we need to specify the TestCaseFilter option:

Vstest.console.exe myFooProject.dll 
   /TestCaseFilter:”TestCategory="Atomic"

Assert.ThrowsException

Until now, if we had a unit test that would check if a method throws an expected exception; we would have to decorate our method with an attribute. But this is not the best solution, because there were cases when we could not determine precisely the source of the exception.

In this moment this feature is available only for Windows Store Application. We hope that this new feature will be also available for other type of projects also.

Smart unit test discovery

The algorithm that is used to discover new unit test was improved. In this moment the new unit tests are discover extremely fast. We don’t need to rebuild the solution and wait until the new unit tests are discovered by Visual Studio.

Integration with JavaScript

Using a plugin like Chutzpah Test Adapter, we are able to run unit test written in JavaScript and run them in Test Explorer. Not only this, but we can run test written in C# and JavaScript in the same time. In this way we can run the entire test as one thing. The only thing that is necessary to be done is to install Chutzpah Test Adapter and use a unit test package for JavaScript like qunit.

Unit testing is a lot easier with this new version of Visual Studio. These are only a part of the new features that Visual Studio 2012 brought to us. You can try it and discover by yourself these new great features.

Read More

Windows Azure Service Bus - Adding properties to the BrokeredMessage automatic

Some days ago I started to look over a big system and trying to identify places where Windows Azure can be used. Trying to imagine a PoC I realized that I need a mechanism that is able to add properties to a BrokeredMessage automatically.
For example we can have a serializable item that is added to the BrokeredMessage. This message can have one, two or n properties that we want to add them to the BrokeredMessage. These properties will be used by the topics and subscription to filter and redirect each message.
This target can be accomplished in different ways:

1. Our object can contain a method that returns the list of properties as KeyValuePair. This can be used to populate the Properties of the BrokeredMesssage.
2. Another option is to create a separate class that store the list of properties for each class and to call an external method that will populate our BrokeredMessage with our custom properties.
3. Create a custom attribute that will be used to mark properties that will be added to the BrokeredMessage. After adding our object to the BrokeredMessage, we will need to call another method that will processed our object and add the marked properties to the BrokeredMessage.

Each solution has good parts and bad parts. Also, based on the developer preference and the project characteristics, each team can prefer a different solution.
Using the first option has the downside that we create a coupling between our class and Windows Azure. Even if is not directly, the method will be relevant only for Windows Azure. If we want to reuse these classes, maybe we don’t want to load the class with a lot of methods.
The second option creates a clear decoupling between the item that is sent using BrokeredMessage and the system. The downside of is on the configuration part. We need to manage a separate configuration for items that will be added on the BrokeredMessage. Also we will need to create a mechanism that will read the configuration and extract from each item the properties that need to be exposed in the BrokeredMessage.
The last option creates a small coupling between our item and the mechanism that sends the message on the wire. In comparison with the first and the second option, this option in somehow in the middle. It will not add to much complexity to our project. The only problem that I see here is the reflection mechanism that needs to be used to retrieve the properties that need to be exposed in the BrokeredMessage.
I will take the last option that I will try to cover. To be able to develop a mechanism that automatically add the properties of BrokeredMessage the properties of an items that are marked with a custom properties we will need to create two things

1. A custom attribute that will be used to mark the properties of our item
2. Decorate our item properties with our custom attribute.
3. A function that will extract the properties that are marked with our custom attribute and add them to the properties list of the BrokeredMessage

We need to create our attribute. This attribute will be used only on the properties that need to be exposed in the BrokeredMessage. Using the AttributeUsage attribute we will limit the places where our attribute can be used – only on properties.

[AttributeUsage(AttributeTargets.Property)]
public class ExposedProperty : System.Attribute
{
    private string name;

    public ExposedProperty(string name)
    {
        this.name = name;
    }
}

In this moment we have our attribute that can be used on the properties of our item that we want to expose.

public class Item
{
        [ExposedProperty( “name”, PropertyDirection.ReadAndWrite))]
        public string Name { get; set; }

        public int Age { get; set; }

        [ExposedProperty( “job” , PropertyDirection.ReadAndWrite))]
        public string Job { get; set; }

        public double Salary { get; set; }

}

As you can see we can have different properties names (one in our Item class and another one that is used in the BrokeredMessage). This can be very useful when we exposed different object that are coming from different sources. The PropertyDirection specify the direction of data. This is not mandatory, but can be useful and also tell us the direction of data.
The last step that we need to do is to write a method that will extract all the properties that are decorated with our custom attribute and add them to our BrokeredMessage.

public void AddCustomProperties(BrokeredMessage message, object item)
{
    Type exposedPropertyType = typeof(ExposedProperty);
    PropertyInfo[] itemProperties = serializableObject.GetType().GetProperties();
    foreach (PropertyInfo property in itemProperties)       
    {
        foreach (ExposedProperty exposedProperty in property.GetCustomAttributes(exposedPropertyType, true))
        {
            var propertyValue = property.GetValue(item, null);
            message.Properties.Add(exposedProperty.Name, propertyValue);
        }
    }
}

In this moment we have all that we need to add our item and all the custom properties to the BrokeredMessage. In the following example we are adding the item to the BrokeredMessage.

Item item = new Item();
...

SubscriptionClient subscriptionClient = SubscriptionClient.CreateFromConnectionString(
    CloudConfigurationManager.GetSetting("ServiceBusConnectionString"),
    "myFooTopic",
    "Property1Equal10");
BrokeredMessage message = subscriptionClient.Receive();
Sending the message to our subscribers:
BrokeredMessage message = new BrokeredMessage(item);
AddCustomProperties(message,item);
topicClient.Send(message);

In this way we will be able to define filters over the subscription using our custom properties. The downside of this solution is the way we het the list of properties that are decorated with our custom attribute – using reflection. Reflection is a very expensive mechanism. Because our machines and servers are very fast, based on the case, this may or not may be a problem.

Read More