Silverlight Developers are worried

It kind of feels like another episode of a dramatic television soap.  If you’ve been in a coma for the previous 5 months let me refresh your memory:

In episode 1 of ‘bye bye silvy’ Microsoft announced that they’ll beusing HTML 5 as a core technology for Windows 8.

Then in episode 2 we then saw that HTML and Javascript will be technologies that you can use in Windows 8 but you can still write your everyday XAML and use the WinRT API’s for your metro apps.  You can even still use .NET for your 'legacy' applications.

In episode 3 Microsoft announced that they’ll be ditching browser plugins in the metro version of IE and will only make them available in legacy desktop mode.  Another sad episode indeed, the part that made allot of people cry was quote:

For what these sites do, the power of HTML5 makes more sense, especially in Windows 8 apps.

Now for the cliffhanger of this seasons ‘bye bye silvy’ rumors are going that Silverlight 5 will be the last Silverlight version released.  Will this turn out to be true?

Since the release of this rumor my blog visitors have spiked and one post in particular received allot of views.  Based on this and the ranting that’s going on several forums I think it’s safe to say that allot of Silverlight developers are worried for their future.

But should you be worried?  After all the technology isn’t likely to go away the next couple of years, Silverlight 5 still has to be released.  But what company is going to invest in a project that makes use of a technology that is already deprived of its future?  Wouldn’t it make more sense to switch to HTML 5 instead?

Then again Silverlight will still be used in Windows Phone 7 and Xbox…. not really useful if you’re a corporate developer (unless you work at a company that uses Xbox's for their business apps).  Okay granted that there will certainly be a future for Silverlight in Windows Phone 7, but how long will it take for Microsoft to merge their desktop OS with their Phone OS, seeing that we already have quad core mobile CPU’s.

I don’t think Silverlight developers should worry just yet, the transition will go smoothly and there are still a ton of Silverlight applications that need to be maintained (or rewritten).  Though it won’t hurt you to start refreshing that good old HTML and Javascript as it looks that you’ll be needing it in the near future…

Remote Control your PC with Windows Phone 7

I just wanted to share a cool app with you.  It’s called cool remote and it allows you to remote control the desktop of your PC from iPhone or Windows Phone 7.  I’ve installed it this weekend and been trying it out since then and it just works great.  Even on 3G, the connection is stable and good enough to use. 

Default the application tries to use port 80 or 81 but I had to switch it to a custom port (in my case 1222) that I’ve had to open on my router.  Once that was done it was just a matter of connecting to the PC.

Another great thing about this app is that it’s free!

Here are the download links:

MarketPlace

Server side

Have fun!

Wordprocessing Serialization: move content between wordprocessing files

At the moment I’m working on a couple of side projects (which explains why I forgot to close last month off with a funny post). I’ll be blogging about them a bit more in the couple of weeks or months ahead.  A small one-man’s project I’m working on has to do with OpenXml.  For those that have been following my blog, it won’t sound much of a surprise that I’m pretty fond of doing document generation with OpenXml.  I wanted to make it a bit easier though.

A recurring requirement I’ve been confronted with is the copying of content from one document to another.  It can even go so far that you must be able to store this content and be able to inject it into multiple documents at a later moment.  One might think that this is an easy think to do but think again.  If you’re document is crammed with custom style, numbering and tables you’ll soon notice that a simple copy of the paragraphs won’t do the trick.  

So what I’ve done is create a library that allows you to transfer content between 2 wordprocessing documents and keep the format of the table and styles.  Not only can you transfer the content between documents, you can also save the content as a blob to your database or any other file.  The way that you can mark the content that you want to serialize is by bookmarks.  You place two bookmarks in the source document to determin the start and end of the content, and one bookmark in the target document to indicate where to insert the copied content.

So how does it work? There are basically 3 main objects to the library that you need to know about.

• ContentSerializer
• ContentDeserializer
• ContentInserter

ContentSerializer

The content serializer will serialize OpenXmlElements between the two bookmarks that you specify.  Here is a small example:

var memoryStream = new MemoryStream();

IContentSerializer serializer = new ContentSerializer("c:\\temp\\Test.docx");

serializer.SerializeElementsFullBetweenBookmarks(memoryStream,

                                                "profielstart",

                                                "profieleind");

As you can see the ContentSerializer accepts a string that points to the location of where the document resides.  You can then call the SerializeElementsFullBetweenBookmarks.  This method accepts 3 parameters:

• The stream to which it will serialize to
• The bookmark indicating the start of the text
• The bookmark indicating the end of the text

The ContentSerializer will then serialize all OpenXmlElements between the two bookmarks together with their styles and numbering definition.  You can use the data in the stream to save the objects to a database or a binary file.

There is also a SerializeElementsBetweenBookmark function available which will only serialize the paragraphs between two bookmarks.  Yet for this example I want to be able to serialize everything.

ContentDeserializer

The ContentDeserializer will simply deserialize the serialized content into a format usable to inject into a document.  Depending on whether you serialized only the paragraphs or the full content with styles and numbering you can call one of the two following methods:

• DeserializeContent: This will deserialize only paragraphs
• DeserializeContentWithNumberingAndStyles: This method will deserialize the paragraphs together with the numbering and styles.

A small demonstration:

IContentDeserializer deserializer = new ContentDeserializer();

var contentWithNumbering = deserializer.DeserializeContentWithNumberingAndStyles(memoryStream);

This method will return an object that contains an IEnumerable of paragraphs, an IEnumerable of styles and a numbering definition. 

ContentInserter

When you have the content deserialized you might want to insert it into another docx file.  The ContentInserter will do just this for you.  All you need to do is provide it with the location of the wordprocessing document and then call the InsertElementsWithNumberingInDocument method to insert the deserialized content at the provided bookmark.

IContentInserter contentInserter = new ContentInserter("c:\\temp\\InsertInDocument.docx");

                contentInserter.InsertElementsWithNumberingInDocument(contentWithNumbering, "Paste");

So the InsertElementsWithNumberingInDocument method accepts the following parameters:

• An ElementsFull element which contains the deserialized content
• The name of the bookmark in which it will insert after.

There are a few things that you should take note to:

• When the document is under revision control, all revisions will be accepted prior to serializing or inserting content!
• The bookmarks are case sensitive
• This projects uses the OpenXml Power tools, it’s a cool open source project so be sure to take a look at: http://powertools.codeplex.com/
• The content that will be serialized between the two bookmarks currently only consists of Parargraphs and all their children (run, text, runproperties, etc.) and tables and all their children (tablecell, etc.).

Some things that I might improve in the future are:

• Include the serialization of Images
• Include the serialization of more elements like drawings and graphs
• Optimize the serialization of the styles and numbering part, at the moment there is no filter

The code can be found at GitHub: https://github.com/LucBos/WordprocessingSerialization

 

Make any adjustments as you like, until next time ;)

Editable Views in Entity Framework

Last time I explained how you could create an association between a view and a table inentity framework.  Now let’s take it a step further.  

The inherent ‘problem’ with working with a view as opposed to working with a table is that a view is read only.  Yet out of the box, Entity Framework can work with this view like it would with a table and update and delete rows out of this view.

      I will be explaining two ways for updating your view in this post:  

1. For simple views we can just remove the defining query
2. For more advanced views we can map stored procedures

A cautious word: only do this with the simplest of views, or even better, write stored procedures that will do this for you.  I’m just explaining the possibility that exists in Entity Framework to do this and not really encouraging the use of updating views.

So that being said, let’s get down to business.

Removing the defining query

Open you edmx in your xml editor and then search for the line that describes your View:

          <EntitySet store:Name="vw_Person" EntityType="Model.Store.vw_Person" store:Type="Views" store:Schema="dbo" store:Name="vw_Person">

            <DefiningQuery>

               store:Name="vw_Person"

              SELECT

              [vw_Person].[UserId] AS [UserId],

              [vw_Person].[PersonId] AS [PersonId],

              [vw_Person].[FirstName] AS [FirstName],

              [vw_Person].[LastName] AS [LastName],

              [vw_Person].[Sex] AS [Sex],

              [vw_Person].[Titel] AS [Titel],

              [vw_Person].[Email] AS [Email],

              [vw_Person].[Street] AS [Street],

              [vw_Person].[Street2] AS [Street2],

              [vw_Person].[Zipcode] AS [Zipcode],

              [vw_Person].[City] AS [City],

              [vw_Person].[Country] AS [Country],

              [vw_Person].[CountryCode] AS [CountryCode],

              [vw_Person].[OrganisatieNaam] AS [OrganisatieNaam],

              [vw_Person].[Rrn] AS [Rrn],

              [vw_Person].[OnlineModified] AS [OnlineModified],

              [vw_Person].[DatePasswordSent] AS [DatePasswordSent],

              [vw_Person].[CreateDate] AS [CreateDate],

              [vw_Person].[CountryId] AS [CountryId],

              [vw_Person].[ModifyDate] AS [ModifyDate],

              [vw_Person].[Image] AS [Image]

              FROM [dbo].[vw_Person] AS [vw_Person]

            </DefiningQuery>

          </EntitySet>

In order to make it updatable you have to remove the defining query.  When that is done also remove the store:Name attribute and  then remove the store prefix from the store:Schema attribute. When this is done the EntitySet element should look something like this:

          <EntitySet Name="vw_Person" EntityType="Model.Store.vw_Person" store:Type="Views" Schema="dbo" />

Now save the edmx and try to update your view like you would with any other entity.

This method will only work when your view is updatable.  When your view contains a calculated value or something similar then this method will fall short.  In this case we’ll have to manually assign the stored procedures that are responsible for updating the entity.

Using stored procedures

So in my example I have made a simple stored procedure that will update the values of the Person view.  I then import the stored procedure by clicking ‘Update Model from Database’ and then selecting the appropriate stored procedure to add.

Once the stored procedure is added, click on your view and go to the ‘Mapping Details’ toolwindow.  On the left side of this toolwindow you can select ‘Map Entity to Functions’.  In here is where you can define your Update, Insert and Delete functions that Entity Framework should use when doing these operations.

Voila that was it, see you next time ;-)

How to map a relation between a View and a Table in Entity Framework

Imagine creating a view in your database with some data you need aggregated from different tables.  This data could be associated to another table in your database.  While you might not want to make any changes in your database you may want the conceptual diagram in your application to link up these entities so it makes it easier for you to develop with them.

The first thing you need to do is create you edmx and add the wanted tables and views.  Make sure that you have a primary key defined for your view, entity framework will by default take all non nullable columns (… go figure).  Then when you have the desired view and table on your entity diagram you create a new association.

In the ‘add association ‘ window you can then select the two entities you want to have a relation between.  Deselect the ‘Add foreign key properties to the ‘xxxx’ Entity’, as it will add a new property to the associated table that will act as a foreign key.  In this case it won’t be necessary because I already have my foreign keys mapped.

Once you’ve done this you should receive the following error:

No mapping specified for the following EntitySet/AssociationSet – PersonFunctie

So this is where the entity designer falls short.  We defined the association between the two entities but entity framework cannot find the association in the storage model so it cannot figure out which properties have to be used.  To fix this open the edmx in an xml editor.  Then browse to the line that the error indicated and you’ll find this:

<Association Name="PersonFunctie">

  <End Type="eOpvolgingModel.Person" Role="Person" Multiplicity="1" />

  <End Type="eOpvolgingModel.Functie" Role="Functie" Multiplicity="*" />

</Association>

Now you just need to say to the conceptual model which properties define this association:

<Association Name="PersonFunctie">

  <End Type="eOpvolgingModel.Person" Role="Person" Multiplicity="1" />

  <End Type="eOpvolgingModel.Functie" Role="Functie" Multiplicity="*" />

  <ReferentialConstraint>

    <Principal Role="Person">

      <PropertyRef Name="PersonId" />

    </Principal>

    <Dependent Role="Functie">

      <PropertyRef Name="Persoon_Id" />

    </Dependent>

  </ReferentialConstraint>

</Association>

Save it, build it, run it, and voila.  Everything should work now.

Until next post!

Unit tests and static methods: a big no no

Yesterday I looked over some code and what appeared to be some nice tested code, was a big fail on dependency injection which resulted in his ‘apear to be’ unit tests being completely rubbish.

Most of the code in itself was decent and the author did seem to grasp a lot of the agile principles and patterns.  He used dependency injection with unity and the code was written clean and expressive.  The average length of his method was no more than 6 lines of code with a clear purpose in mind.  

However…

Then I noticed a folder called ‘Utility’.  I opened the folder and what I saw was more than a dozen of static classes filled with static ‘Utility’ methods.  I scratched my head a bit and then after some hesitation I did alt + f7 (resharper for find all usages) on the utility classes.  What I then found was 22 references to these static ‘Utility’ classes throughout his code base. 

I then took another look at the test covering the methods that used this Utility method… Then it became clear to me, the unit tests … well … they weren’t unit tests.

How can we unit test a method that uses a static utility method?  We can’t.  

A "unit" (as defined in the software testing literature) is the  smallest piece of code software that can be tested in isolation.

When you are trying to test the method that uses a static method, you can’t mock the behavior of that static method.  When you can’t mock calls of the method that needs to be tested then you can’t unit test this method.  Why not?  Well the calls that this method makes has the potential of changing the behavior of your method under test.  Your test won’t be isolated any more to that unit of work, thus it isn’t a unit test.

Consider a static utility method called Util that is used by 4 other methods (respectively A,B,C,D).  Imagine now that you’ve written unit tests for all of these methods.  Now when the implementation of the utility method changes and there is an error in the behavior of this method, this could trigger a fail on all your unit tests.  Should your other methods fail?  No A,B,C and D should remain green.  Their behavior is just fine under the prerequisite that the method Util behaves fine, but because you couldn’t mock the behavior of the static method you’re stuck with the faulted implementation also being tested in methods A,B,C and D.  

So basically you’re not testing 1 unit in your code but you’re testing 2.   So you’re depending on the behavior of another method in your tests, which obviously you shouldn’t do.  

In conclusion: if you’re doing dependency injection and unit testing don’t use static methods.  When you use static method you are in most cases (unless with dirty hacks) bound to the implementation code of that method.  In my opinion static methods in general are dangerous and contradictory to object oriented principles. 

Until next time ;-)

A code brainteaser: the solution

Yesterday I posted a small brainteaser, now I'll reveal what's wrong with the VB.NET code.

As you could see the code wouldn't execute because the boolean did not get set.  This is strange because when you debug the code it clearly jumps into the statement when the Action is invoked:

Now what is the subtle difference between the VB.NET code and the C# code is that C# uses the lambda syntax and VB.NET requires you to use the Sub or Function syntax. The VB.NET syntax requires you to specify whether you want the statement to provide a return value (Function) or whether it should just be a subroutine (Sub).  In this case I made a “mistake” by saying that it should be Function instead of a subroutine and since the assignment operator and the equality operator are the same symbol you hardly notice the difference.

So the fix would be the following:

Module Module1

    Sub Main()

        Dim thisShouldBeSet = False

        DoSomething(Sub() thisShouldBeSet = True)

        If Not thisShouldBeSet Then

            Throw New Exception()

        End If

        Console.WriteLine("yaay")

    End Sub

    Sub DoSomething(action As Action)

        action.Invoke()

    End Sub

End Module

So this is where the difference is in the Action class between VB.NET and C#.  From the definition of msdn:

In C#, the method must return void. In Visual Basic, it must be defined by the Sub…End Sub construct. It can also be a method that returns a value that is ignored.

In my opinion this is a flawed implementation and just allows developers to make more mistakes.  I can also see no valid reason why anyone would use a method with a return value in an Action.  If you do this because the method already exists then split it up because you’re doing too much.

Enough VB-ranting for today, till next time.