Falafel Blog Feed

Project Houston

John Waters — Mon, 06 Sep 2010 05:07:35 GMT

I came across a neat Utility, codename Project Houston. It is a web based SQLAzure admin tool, that allows you to work with SqlAzure databases much as you would with SQL Server Management Studio (SSMS) and regular SQL Server databases.

It is a CTP right now and can be found here: https://www.sqlazurelabs.com/houston.aspx. I found it pretty handy.

Houston, we do not have a problem!

Migrating Data to SqlAzure

John Waters — Mon, 06 Sep 2010 04:34:35 GMT

In the midst of figuring out SqlAzure, I found a handy article showing how to export data from a regular SQL Server database into you SQLAzure database.

I had already created the SQLAzure DB, and the tables (I just generated scripts from my original database, and ran them from SQL Server Management Studio (SSMS) 2008 RS (note, you need R2 to work with Azure), until they passed with no errors. I had to get rid of most of the options in the WITH statement, and the [PRIMARY] designations below:

CREATE TABLE [dbo].[ConferenceInfos](
    [Id] [int] IDENTITY(1,1) NOT NULL,
    [Name] [nvarchar](max) NOT NULL,
    [StartDate] [datetime] NOT NULL,
    [EndDate] [datetime] NOT NULL,
    [Location] [nvarchar](max) NOT NULL,
    [Logo] [nvarchar](max) NOT NULL,
    [Published] [bit] NOT NULL,
    [MinViewerVersion] [nvarchar](max) NOT NULL,
    [Config] [nvarchar](max) NOT NULL,
 CONSTRAINT [PK_ConferenceInfos] PRIMARY KEY CLUSTERED 
(
    [Id] ASC
)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
) ON [PRIMARY]
GO

The actual transfer was done by right clicking my original database, Tasks, Export Data. The trick is in step 2 of the wizard, when you chose the destination, you can NOT use SQL Server Native Client 10.0. Instead, choose “.NET Framework Data Provider for SqlServer”, and fill out the following items:

UserID – a user in your SqlAzure database that has sufficient rights
Password – the password
Data Source: the name of your SQLAzure instance
Initial Catalog – the name of your database

The rest is just as normal and it works like a charm! Happy migrating

Our Journey to the Cloud Begins

John Waters — Mon, 06 Sep 2010 03:29:45 GMT

Today, we embarked on our journey into the Cloud, more specifically the Windows Azure Cloud. This journey goes hand in hand with our venture into the Mobile market. Mobile apps and Cloud services make a perfect match. The devices roam across the face of the planet, running a variety of Operating Systems, from the Apple iPhone and iPad devices in all their incarnations, to the slew of Android machines hitting the market, and now the upcoming Windows Phones.

Falafel Software is writing software for all these environments, and now we are also writing services for them as well. We will be providing a range of services to support our mobile offerings, including SQL Azure for database storage, REST WCF services, BLOB file storage in the Cloud, and Notifications.

MonoDroid Videos

Lino Tadros — Thu, 26 Aug 2010 00:00:00 GMT

Falafel Software created two videos on the pre-release version of MonoDroid in the last week with permission from the Mono Development Team at Novell in order to demonstrate the power of this upcoming tool in building Android Applications in Visual Studio 2010 using C#.
The first video was downloaded 12,000 times in the first 36 hours worldwide. The interest is very high for this tool!
What do you think of the ability to write C# code for the Android SDK?

Binding Tab Navigation to a Control’s Enabled State in Silverlight

J. Tower — Mon, 23 Aug 2010 14:31:21 GMT

I got some positive feedback on my recent post about binding a TextBlock’s tooltip to its own text property, so I decided to post this related follow-up…

Allowing your users to navigate your forms with the keyboard is a very important usability feature that is often overlooked. In Silverlight, this is accomplished by setting IsTabStop to True on any controls you want to participate in keyboard navigation. When the user hits the tab key, focus will cycle through all the controls where IsTabStop is True, one at a time. Any controls where IsTabStop is false will be skipped.

One problem I’ve often run into in Silverlight is making sure that keyboard navigation only sets the focus on active controls. For example, consider a form with a Save button that is disabled until all the required fields have been filled in. If the user forgets to fill in a required field and tabs past the last field on the form (assuming the Save button is at the bottom of the form), focus will move to the still-disabled Save button. It may be very difficult for the user to see what happened to the focus.

In lieu solving this by writing code in the code-behind that sets IsTabStop whenever there is a change to the button’s IsEnabled property, I recommend using Silverlight’s build-in binding capabilities to “set it and forget it”. From then on, any changes you make that enable or disable the Save button will also enable or disable tab navigation for the control.

Without further ado, here’s the code to accomplish this:

<Button x:Name="btnSave" Width="80" Content="Save" 

    IsTabStop="{Binding Path=IsEnabled, RelativeSource={RelativeSource Self}}" />

To take it one step further, instead of copying this binding into every button make a UserControl or global Style for your buttons that implements this binding by default and use that UserControl or Style throughout your application. Then all your buttons will have this feature without having to remember to implement it every time.

Automate Common Tasks With Batch Files

Adam Anderson — Fri, 13 Aug 2010 22:23:32 GMT

I know, you are probably thinking “Batch files? What is this, the Dark Age of DOS?” Bear with me; while you might see batch files as antiquated relics, I have come to see them as simple and elegant tools (with admittedly primitive syntax) that speed my daily development. They seem to have become a bit of a lost art in this day and age of point-and-click UIs. Let me share a few scenarios with you.

Delete log files before running an app

This one is simple. I am on a team developing a large WCF multi-tier application with plenty of logging happening. If I am really only interested in the log output from my latest run, I don’t want to have to scroll past all of the old entries. Besides, some of the WCF *.svclog files can grow pretty big.

del *log
start app.exe

This simple batch file first deletes all files ending with “log” (so, *.log and *.svclog) in the current directory, launches app.exe, and then closes the command window.

Start a web app in a non-default browser

I don’t have Internet Explorer set as my default browser, but I want to use it to run a web app.

start "" "C:\Program Files (x86)\Internet Explorer\iexplore.exe" "http://virtual_dir/start_page.aspx"

The first empty string is for the “optional” (according to the documentation) title, but if it is omitted, the start command will not work in this case.

Drop and rebuild a DB with multiple SQL scripts

In our current project, we rebuild our DBs from scratch often, and it takes multiple steps to do so. All of these manual steps have been automated by a batch file.

set SQLCMDUSER=user
@set SQLCMDPASSWORD=password
set SQLCMDDBNAME=db

sqlcmd -d master -i "DropCreate.sql"
sqlcmd -i "aspnet_objects.sql","app_objects.sql" "path\populate_data.exe" params
type "path\populate_data.log"

The three SET commands set environment variables used by sqlcmd.exe, which is MSSQL’s command-line SQL command executor. The first sqlcmd executes a script that runs in the master DB and drops and re-creates the existing DB and adds a user login. The second sqlcmd executes a script that creates objects for asp.net membership, and then a script that creates our custom objects for our app. The last pair of lines executes a custom tool that loads the fresh DB with initial data and outputs the app’s log file to the command line for review. This batch file has been a huge time-saver for the team, turning a once highly interactive process into an unattended one.

Here is the contents of the DropCreate script, since anyone could find a use for it:

if exists ( select * from sys.databases where name = 'db_name' )
begin alter database db_name set read_only with rollback immediate drop database db_name
end go create database db_name
go use db_name
go create user user_name
go exec sp_addrolemember 'db_owner', 'user_name'
go

To adapt it to your purposes, just replace db_name with your DB’s name, and user_name with a user account. The script will terminate any active connections prior to dropping the DB, since any active connections would cause the DROP DATABASE to fail.

Test a DB upgrade script against multiple DB versions

Our project has a SQL script that is designed to run against any past deployed DB version and bring that DB to the current version. This can be a complex task, and sometimes a script that works against one version will encounter errors when run against a different version. Here is a solution that I put together to test the latest upgrade script against any past DB that I have a backup of.

First of all, I keep all of the past DB versions backed up in a single .BAK file. Now, I have this SQL script that can restore any of the backups:

use master
go alter database db_name
set read_only
with rollback immediate GO RESTORE DATABASE [db_name] FROM DISK = N'path\db_name.bak' WITH REPLACE,  FILE = $(file),  NOUNLOAD,  STATS = 10
GO

That $(file) is a substitution variable that will be supplied by the batch file that runs this script. Now, here is the batch script. It loops through all of the backups in the backup file and restores them, and then runs the upgrade script against the restored backup. If the upgrade encounters an error, the script stops and displays the file number of the backup that encountered the error, so that I can start interactively debugging the upgrade script against that DB version.

@echo off
set SQLCMDUSER=sa
set SQLCMDPASSWORD=password
set SQLCMDDBNAME=db_name

for /l %%i in (1,1,8) do (
    sqlcmd -v file="%%i" -i "RestoreOld.sql"
    sqlcmd -b -i "upgrade_objects.sql" if errorlevel 1 (
        echo Error at %%i
        pause
        exit
    )
)
echo Success
pause

The first line in the FOR loop passes the loop variable’s value into the $(file) substitution variable in the SQL script above, restoring the backup files 1 through 8 in succession. The next line runs the upgrade script, and the last block tests the value of the errorlevel environment variable, which is set by sqlcmd if an error is encountered.

How to get started for yourself

I hope by now, you can see how just a few lines in a batch script can automate tasks and save a lot of time and effort. The best way to get started is simply to read the documentation. Just open a command prompt on your system and type “help” to see a list of built-in commands.

WCF RIA Services Default Load Behavior Can Be Misleading

Scott Frolich — Thu, 12 Aug 2010 21:43:52 GMT

Recently I was given a task of creating a quick example of someone making a data change to a database table then someone else being able to see the new data. Seemed simple enough. I created a WCF RIA Services application with a simple grid and submit/refresh buttons on it. I brought up two instances of the application and had one instance change the data and the other refresh it. To my amazement the second instance didn’t see the new data.

I brought up SQL Server Profiler to see what was going on. When hitting the refresh button I did see the query getting sent to MSSQL server. I then looked at the result from the load operation in the callback method and I found that for some reason the entities returned were the old copies. I found a solution to this problem to be very simple. Change the load behavior of the load operation.

Change this:

context.Load(context.GetDepartmentsQuery(),

Load_Completed, null);

context.Load(context.GetDepartmentsQuery(), _

AddressOf Load_Completed, _

Nothing)

To this:

context.Load(context.GetDepartmentsQuery(),

LoadBehavior.MergeIntoCurrent,

Load_Completed, null);

context.Load(context.GetDepartmentsQuery(), _

LoadBehavior.MergeIntoCurrent, _

AddressOf Load_Completed, Nothing)

There are three different load behaviors available:

Keep Current (default): means that the version that is cached on the client is not changed with the load operation. Entities will not be updated with new information.
Merge Into Current: if there has been no modification to a cached entity, it will be updated with the load operation entities. This seems to be the safest option if the user will be editing data because the user will not want to lose data they have been entering before a submit.
Refresh Current: all entities in the cache will be updated with information from the load operation entities. This has the possibility to overwrite a change that the user has made but not committed. Be careful with this option.

A sample solution that displays the refresh issue is attached with three projects (ones for C# and VB) that include a test Silverlight client in both languages. This sample uses the AdventureWorks2008 database and logs in with integrated security. Edit the Web.config file if necessary to change the connection string to connect to your database. Steps for using the example are in the sample itself. Load Operations and Behavior Example

BasedOn Styles in Silverlight

J. Tower — Thu, 12 Aug 2010 19:46:16 GMT

Those that have been programming in WPF for a while probably already know about defining styles based on other styles. With the release of version 3, this feature made the jump over to Silverlight as well. Even though this is old news, as Silverlight is now on version 4, I’ve found that this feature is still little-know, and it’s so useful, I thought it deserved a post. In the post, I’ll go over the basics of how to use this feature for anyone to whom the feature is new.

Why Use BasedOn

Using BasedOn to define a style allows you to significantly reduce your XAML styling code and improve maintainability. To take advantage of this, you should define base styles in a globally accessible resource dictionary and then define derived styles that only dictate the ways in which they are different from their base styles. For all of us object-oriented programmers, this type of inheritance should feel pretty comfortable!

Using BasedOn - Step By Step

To start out with, create a new SIlverlight project and add a StackPanel and four TextBlocks to the MainPage.xaml. Here’s the XAML I used:

<UserControl x:Class="BasedOnStyles.MainPage"

    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"

    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"

    mc:Ignorable="d"

    d:DesignHeight="300" d:DesignWidth="400">

    <Grid x:Name="LayoutRoot" Background="White">

        <StackPanel>

            <TextBlock Text="This text is not styled" />

            <TextBlock Text="This text is not styled" />

            <TextBlock Text="This text is not styled" />

            <TextBlock Text="This text is not styled" />

        </StackPanel>

    </Grid>
 </UserControl>

Now you can create a resource dictionary for your project that will allow you to define styles that can be used throughout your application. I like to put my resource dictionaries in a sub-directory within the project, usually called “ResourceDictionaries” or something similar. Add a new item to the directory by right-clicking and selection Add –> New Item…

Select “Silverlight Resource Dictionary” and give it a name. In the Resource dictionary, define a style that targets TextBlock tags. Here’s the style I created:

<ResourceDictionary

    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 

    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">

    <Style x:Key="GlobalTextBlockStyle" TargetType="TextBlock">

        <Setter Property="Foreground" Value="Red"/>

    </Style>
 </ResourceDictionary>

Now the dictionary needs to be merged into the application’s main dictionary so it will be available globally. Open the App.xaml and update it to look this the code below, replacing “BasedOnStyles” with the name of your Silverlight project and the file path with the path to your resource dictionary file.

<Application xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 

             x:Class="BasedOnStyles.App">

    <Application.Resources>

        <ResourceDictionary>

            <ResourceDictionary.MergedDictionaries>

                <ResourceDictionary 
 Source="/BasedOnStyles;component/ResourceDictionaries/GlobalStyles.xaml" />

            </ResourceDictionary.MergedDictionaries>

        </ResourceDictionary>

    </Application.Resources>
 </Application>

Now back in MainPage.xaml you can reference your new style as seen in my code example below:

<UserControl x:Class="BasedOnStyles.MainPage"

    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"

    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"

    mc:Ignorable="d"

    d:DesignHeight="300" d:DesignWidth="400">

    <Grid x:Name="LayoutRoot" Background="White" Margin="10">

        <StackPanel>

            <TextBlock Text="This text is not styled" />

            <TextBlock Text="This text is styled" 

                Style="{StaticResource GlobalTextBlockStyle}" />

            <TextBlock Text="This text is styled" 

                Style="{StaticResource GlobalTextBlockStyle}" />

            <TextBlock Text="This text is styled" 

                Style="{StaticResource GlobalTextBlockStyle}" />

        </StackPanel>

    </Grid>
 </UserControl>

When you run your project now, it should look something like this:

Notice that the text in the last three TextBlocks is red now, based on the Foreground color defined by the style you created. That completes the set up work necessary to define global styles. Now you can start creating new styles based on the first one you defined. In the example below, I’ve created two more styles. The second style adds a Bold FontWeight to the first one, and the third style changes the Foreground color AND adds an Italic FontStyle to the second.

<ResourceDictionary

    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 

    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">

    <Style x:Key="GlobalTextBlockStyle" TargetType="TextBlock">

        <Setter Property="Foreground" Value="Red"/>

    </Style>

    <Style x:Key="GlobalTextBlockStyle2" TargetType="TextBlock"

                 BasedOn="{StaticResource GlobalTextBlockStyle}">

        <Setter Property="FontWeight" Value="Bold" />

    </Style>

    <Style x:Key="GlobalTextBlockStyle3" TargetType="TextBlock" 

                 BasedOn="{StaticResource GlobalTextBlockStyle2}">

        <Setter Property="Foreground" Value="Orange"/>

        <Setter Property="FontStyle" Value="Italic" />

    </Style>
 </ResourceDictionary>

Before running your project again, change the style on the last two TextBlocks on MainPage.xaml to reference your new styles.

<TextBlock Text="This text is not styled" />
 <TextBlock Text="This text is styled" 

    Style="{StaticResource GlobalTextBlockStyle}" />
 <TextBlock Text="This text is styled" 

    Style="{StaticResource GlobalTextBlockStyle2}" />
 <TextBlock Text="This text is styled" 

    Style="{StaticResource GlobalTextBlockStyle3}" />

Now when you run your project , every line with have a different style, each one a slight variation to the previous one.

With a set up like this, you are ready for your designer or marketing person to come to you and say, “Can you increase the font size in all the labels throughout the application?” One simple change to your base TextBlock style will do the trick.

<Style x:Key="GlobalTextBlockStyle" TargetType="TextBlock">

    <Setter Property="Foreground" Value="Red"/>

    <Setter Property="FontSize" Value="18"/>
 </Style>

Now all the styled TextBlocks throughout your application get updated with the larger font size.

I’ve include my Silverlight 4 C# project for you to download and review.

Using Primitives with Silverlight Styles

Scott Frolich — Thu, 12 Aug 2010 17:23:44 GMT

In every Silverlight project I have worked on I have needed to set some default styles for use throughout the Silverlight controls. So I create a new Silverlight Resource Dictonary and typically add items such as SolidColorBrush:

<SolidColorBrush x:Key="DefaultForeground" Color="#FF1F4386" />

<SolidColorBrush x:Key="DefaultLabelForeground" Color="GreenYellow" />

It is great to have one place to define styles and for the case above colors of my Silverlight components but then I wanted to set a particular font family and font size. This wasn’t immediately clear to me how to do that because what I needed was a string to represent the font family and an integer to represent the size. Finally I found that adding the following in my resource dictionary allowed me to access primitives:

xmlns:system="clr-namespace:System;assembly=mscorlib"

I could then do declarations like:

<system:Int32 x:Key="DefaultFontSize">12</system:Int32>

<system:String x:Key="DefaultFontFamily">Arial</system:String>

And then create a style using those primitives:

<Style x:Key="CommonText_TextBlock" TargetType="TextBlock">

<Setter Property="FontSize" Value="{StaticResource DefaultFontSize}"/>

<Setter Property="FontFamily" Value="{StaticResource DefaultFontFamily}"/>

<Setter Property="Foreground" Value="{StaticResource DefaultForeground}" />

</Style>

Synchronously Retrieving Data with WCF RIA Services

Scott Frolich — Thu, 12 Aug 2010 16:52:37 GMT

I have written quite a few WCF RIA Services applications now and almost every time I need to pre-fetch some data before showing a Silverlight page or dialog. For instance you might need to get all the years and employees available to so you can put them in ComboBoxes for a dialog. You wouldn’t necessarily want to do this in the Loaded event of the dialog because the dialog will come up with empty information then fill in when the query has returned.

Another problem is that the code turns ugly and hard to manage if you have multiple queries to run. Let’s say you have 4 queries to run before showing a dialog. You will have this chain of methods in which the completion of the query1 then starts query2 then query2 completes starts query3 then query3 completes then query4 starts then query4 completes and opens the dialog. You can see how this becomes hard to manage.

I have come across a few example asynchronous data loaders but I have had trouble with them not working consistently. I’m not sure if it is a problem with the code itself or the fact that it starts a bunch of queries all at once and WCF RIA Services is having trouble so I decided to try a synchronous version. There might be a very slight performance difference with asynchronous queries but I believe them to be minimal in most cases that I have needed to lookup entities and found synchronous to perform just as well in my rudimentary speed tests.

The DataLoader I have created is really simple to use.

DataLoader bulkDataLoader = new DataLoader(context, DataLoader_Completed);

bulkDataLoader.AddQuery(new DataLoader.QueryOperation

{ Query = context.GetDepartmentsQuery() });

bulkDataLoader.AddQuery(new DataLoader.QueryOperation

{ Query = context.GetEmployeesQuery() });

bulkDataLoader.AddQuery(new DataLoader.QueryOperation

{ Query = context.GetEmployeePayHistoriesQuery() });

bulkDataLoader.Execute();

private void DataLoader_Completed(DataLoader dataLoader)

{

// do what you need after all the data is loaded

}

Dim bulkDataLoader As New DataLoader(context, AddressOf DataLoader_Completed)

bulkDataLoader.AddQuery(New DataLoader.QueryOperation() With { _

.Query = context.GetDepartmentsQuery()})

bulkDataLoader.AddQuery(New DataLoader.QueryOperation() With { _

.Query = context.GetEmployeesQuery()})

bulkDataLoader.AddQuery(New DataLoader.QueryOperation() With { _

.Query = context.GetEmployeePayHistoriesQuery()})

bulkDataLoader.Execute()

Private Sub DataLoader_Completed(ByVal dataLoader As DataLoader)

' do what you need after all the data is loaded

End Sub

You can see from the above examples that three queries are being run and once all three have returned, either successfully or failed, the DataLoader_Completed method will be called where you can either analyze each LoadOperation for its data or just use it in the DomainContext since successfully loaded entities will be in the supplied DomainContext automatically. In addition you can change the load behavior and pass any object you like from the DataLoader definition to the complete action by using the UserState.

I’m sure some people will have ideas for enhancements and I’d like to hear about them but I do not start a WCF RIA Services project without having this class in it.

The sample solution is attached with three projects (ones for C# and VB) that include the DataLoader in both languages. This sample uses the AdventureWorks2008 database and logs in with integrated security. Edit the Web.config file if necessary to change the connection string to connect to your database. Bulk DataLoader Example

Cloning Objects with .NET

Scott Frolich — Wed, 11 Aug 2010 16:25:19 GMT

There have been a few instances when I would like to have an identical copy of an object but want them to be different instances. There are a few brute force ways to do this by either copying the values one by one or by using reflection to iterate over variables, properties, etc. The problem is that these methods are not very generic and need to be tweaked for each situation.

I have discovered that there are a few ways to clone an object by serializing then de-serializing an object into a new deep-copy instance of that object.

Method 1 – Using BinaryFormatter

private static T BinaryClone<T>(T source)

{

MemoryStream memStream = new MemoryStream();

BinaryFormatter binFormatter = new BinaryFormatter();

binFormatter.Context = new StreamingContext(StreamingContextStates.Clone);

binFormatter.Serialize(memStream, source);

memStream.Position = 0;

return (T)binFormatter.Deserialize(memStream);

}

Private Function BinaryClone(Of T)(ByVal source As T) As T

Dim memStream As New MemoryStream()

Dim binFormatter As New BinaryFormatter()

binFormatter.Context = New StreamingContext(StreamingContextStates.Clone)

binFormatter.Serialize(memStream, source)

memStream.Position = 0

Return DirectCast(binFormatter.Deserialize(memStream), T)

End Function

The BinaryClone method will take any object marked with the SerializableAttribute and return a new instance of that object.

Method 2 – Using DataContractSerializer

public static T DataContractClone<T>(T source)

{

DataContractSerializer serializer;

serializer = new DataContractSerializer(typeof(T));

using (MemoryStream ms = new MemoryStream())

{

serializer.WriteObject(ms, source);

ms.Seek(0, SeekOrigin.Begin);

return (T)serializer.ReadObject(ms);

}

Public Function DataContractClone(Of T)(ByVal source As T) As T

Dim serializer As New DataContractSerializer(GetType(T))

Using ms As New MemoryStream

serializer.WriteObject(ms, source)

ms.Seek(0, SeekOrigin.Begin)

Return DirectCast(serializer.ReadObject(ms), T)

End Using

End Function

The DataContractClone method will also take and return a new instance of an object as long as the class has the DataContractAttribute and each public variable has the DataMemberAttribute. One advantage the DataContractClone method has over BinaryClone is that DataContractClone can also be used in Silverlight where the BinaryFormatter is unavailable.

The above methods can also be converted to extension methods for easy use throughout your projects. For example.

public static class ExtensionMethods

{

public static T DataContractClone<T>(this T source)

{

DataContractSerializer serializer;

serializer = new DataContractSerializer(typeof(T));

using (MemoryStream ms = new MemoryStream())

{

serializer.WriteObject(ms, source);

ms.Seek(0, SeekOrigin.Begin);

return (T)serializer.ReadObject(ms);

}

Module ExtensionMethods

<System.Runtime.CompilerServices.Extension()> _

Public Function DataContractClone(Of T)(ByVal source As T) As T

Dim serializer As New DataContractSerializer(GetType(T))

Using ms As New MemoryStream

serializer.WriteObject(ms, source)

ms.Seek(0, SeekOrigin.Begin)

Return DirectCast(serializer.ReadObject(ms), T)

End Using

End Function

End Module

Here’s an example of two classes that are ready for cloning with either of the above methods. If this is used in Silverlight remove the SerializableAttribute since it is unavailable.

[Serializable]

[DataContract]

class Class1

{

[DataMember]

public String Value = "Hello";

[DataMember]

public Class2 AnotherClass = new Class2();

}

[Serializable]

[DataContract]

class Class2

{

[DataMember]

public int AnotherValue = 123;

}

<Serializable()>

<DataContract()>

Class Class1

<DataMember()>

Public Value As String = "Hello"

<DataMember()>

Public AnotherClass As Class2 = New Class2()

End Class

<Serializable()>

<DataContract()>

Class Class2

<DataMember()>

Public AnotherValue As Integer = 123

End Class

Then the code to test the cloning of both methods (Again you cannot use BinaryClone/BinaryFormatter with Silverlight):

Class1 c1 = new Class1();

Class1 c1a = c1;

System.Console.WriteLine("Before DataContractClone same object? " +

object.ReferenceEquals(c1, c1a));

c1a = DataContractClone(c1);

System.Console.WriteLine("After DataContractClone same object? " +

object.ReferenceEquals(c1, c1a));

Class1 c1b = c1;

System.Console.WriteLine("Before BinaryClone same object? " +

object.ReferenceEquals(c1, c1b));

c1b = BinaryClone(c1);

System.Console.WriteLine("After BinaryClone same object? " +

object.ReferenceEquals(c1, c1b));

// using extension methods defined in ExtensionMethods.cs

Class1 bc = c1.BinaryClone();

Class1 dcc = c1.DataContractClone();

Dim c1 As Class1 = New Class1()

Dim c1a As Class1 = c1

System.Console.WriteLine("Before DataContractClone same object? " &

Object.ReferenceEquals(c1, c1a))

c1a = DataContractClone(c1)

System.Console.WriteLine("After DataContractClone same object? " &

Object.ReferenceEquals(c1, c1a))

Dim c1b As Class1 = c1

System.Console.WriteLine("Before BinaryClone same object? " &

Object.ReferenceEquals(c1, c1b))

c1b = BinaryClone(c1)

System.Console.WriteLine("After BinaryClone same object? " &

Object.ReferenceEquals(c1, c1b))

' using extension methods defined in ExtensionMethods.vb

Dim bc As Class1 = c1.BinaryClone()

Dim dcc As Class1 = c1.DataContractClone()

When you have a choice of serialization methods for cloning I believe it comes down to which one is easier to use for your case. There are several discussions around how BinaryFormatter creates a smaller representation verses DataContractSerializer XML representation but when this data is not sent over the wire these differences make little difference. When using Silverlight, you need to use the DataContractSerializer and when using WCF RIA Services the entities already have the attributes on the classes and variables and are ready to clone.

For your convenience attached to this post is a four project solution created in Visual Studio 2010 that includes two Silverlight projects (C#/VB) and two console projects (C#/VB). The console projects also include use of sample extension methods. Cloning Example

ASP.NET MasterPage metatag localization

Brad Divine — Tue, 10 Aug 2010 19:14:34 GMT

I've been working on a multilanguage web site using ASP.NET localization. I wanted to return unique meta tags for each page in the user's language. There are a handful of ways to accomplish this (MasterPage codebehind, base page codebehind, etc); here's the approach I took:

My web site was already taking advantage of Web.Sitemap, so I decided it would be best to store the meta tags there as a custom attribute. Web.Sitemap's resources can be globalized, so I actually don't need to do anything special to the sitemap besides set enableLocalization="true" and assign a unique resourceKey attribute if one does not already exist on each siteMapNode, e.g.

<?xml version="1.0" encoding="utf-8" ?>

<siteMap xmlns="http://schemas.microsoft.com/AspNet/SiteMap-File-1.0" enableLocalization="true" >

<siteMapNode url="~/Default.aspx" resourceKey="Home" />

</siteMap>
Now I am ready to add the meta tags themselves. These will be placed in the Web.sitemap.resx file(s) under App_GlobalResources. I'll add two rows for each resourceKey. For the example above, I'll create a row named Home.metaKeywords to store the keywords and a row named Home.metaDescription to store the page description. I'll need to create those rows in every Web.sitemap.*.resx file to store the language-specific tags and descriptions.
Once that's done, we're ready to start the work of inserting those tags into the page. In the MasterPage, I create two ContentPlaceHolder controls in the head section. These ContentPlaceHolders will be used to insert the appropriate meta tags when the page is rendered.

<head id="Head1" runat="server">

<asp:ContentPlaceHolder ID="METAKeywords" runat="server" />

<asp:ContentPlaceHolder ID="METADescription" runat="server" />

</head>
Normally we would populate those ContentPlaceHolders in the individual pages, but that sounds like a lot of work. I suggest we let the MasterPage's codebehind take care of it.

public partial class MyMasterPage : System.Web.UI.MasterPage

{

    protected void Page_Load(object sender, EventArgs e)

    {

        ParseMetaTags();

    }

    private void ParseMetaTags()

    {

        HtmlMeta description = new HtmlMeta();

        HtmlMeta keywords = new HtmlMeta();

        description.Name = "description";

        description.Content = SiteMap.CurrentNode["metaDesc"];

        keywords.Name = "keywords";

        keywords.Content = SiteMap.CurrentNode["metaKeywords"];

        METADescription.Controls.Add(description);

        METAKeywords.Controls.Add(keywords);

    }

}

As you can see, I've accessed the language-specific tags from the SiteMap control using our custom attributes metaDesc and metaKeywords (which automatically retrieved them from the appropriate resource file), created HtmlMeta controls and added them to the ContentPlaceHolders (METADescription and METAKeywords) before rendering the page.

Falafel Mobile is HERE!

Lino Tadros — Tue, 10 Aug 2010 13:00:00 GMT

Falafel mobile experts make developing for your mobile market easier and more efficient.

The Falafel Mobile Team is pleased to announce the launch of Falafel Mobile, the best mobile application development assistance offered.

Executives need access to key data points anytime, anywhere. Gone is the nine to five work day, your managers and users need to be able to view data, receive notifications, and take appropriate action, no matter where they are, and at what time of day, using the mobile device of their choice. Your Line of Business applications no longer have to be constrained to the confines of your office and VPN, now you can securely access your systems through mobile extensions from any location that has connectivity. Today’s powerful devices allow you to do much more than just email on the go.

Falafel Software has a proven track record of delivering world-class Windows and Web applications. Be it iPhone, iPad, Android or the upcoming Windows Phone, we are ready to mobilize your business with our exquisite Consulting, World-class Training, well-executed Software and unique Solutions.

Benefits of Falafel’s Mobile Application Development:

Faster time to market
Top quality results
Proven experts at the ready
Your customer’s mobile expectations are met
User Interface and User Experience design tailored to the various hand held formats and challenges
One stop shop for all the layers of your application, from mobile interface to communications, middle tier and back end
Business grade development, enterprise ready performance

Falafel 2 Go

Falafel created a mobile solution which allows our customers to view our upcoming training schedule, quickly view our Twitter Tweets, or read our excellent technical blogs – all very easily from their mobile devices. Falafel 2 Go is available in both the iTunes App Store and the Android Marketplace.

http://itunes.com/apps/falafelsoftwareinc

Session Viewer

Falafel is also developing an exciting mobile app for Silicon Valley Code Camp 2010 which will enable attendees to view and manage info about sessions, tracks, rooms, and speakers – enriching their conference experience.

Code Camp is a 2 day, free, developer conference covering many development technologies, with currently over 100 technical sessions and 700+ attendees.

http://www.siliconvalley-codecamp.com

Session Viewer will also be used at DevReach in Bulgaria. It will be available on the iPad, iPhone, WinPhone and Android devices.

http://www.devreach.com/

Sitefinity 4 Generic APIs vs Fluent APIs

Lino Tadros — Mon, 09 Aug 2010 16:00:00 GMT

I just released a new video demonstrating the power of the new APIs in Sitefinity 4.0 Beta that was just released last week by the Telerik team (CONGRATULATIONS! to the entire Telerik team worldwide).

The essence of the video was to demonstrate the use of the regular APIs to create a new PAGE into the system using two different approaches:

1- The Regular API way that most core developers will use that require understanding of the architecture and the fundamental knowledge of how the Object hierarchy relates to the database layer behind Sitefinity 4.0

2- The FLUENT API way that does not require the knowledge from the previous point and was made for designer and developers to be able to accomplish jobs into the Sitefinity system really quickly working on Objects in an atomic way to accomplish a task.

Both ways have their uses and make Sitefinity 4 extremely powerful in bringing the level of integration into the system very easy and powerful.

I see the resemblance to the old days when we used VBA to write macros against Word, Excel, Powerpoint, etc… A lot of people did not really care about learning about COM, Type Libraries, IUnknown, IDispatch, etc… they just want to Create an Excel document, write some cells to it and save it. VBA allowed for that very easily by hiding the complexity of the system behind the scene. For some others that was not enough, they wanted to attach to a specific instance of Excel, embed their own ActiveX Control into the spreadsheet and communicate both ways with their internal system, for those the COM layer was available and ready to program against as long as you understood the relationships between the Application, Workbook, Worksheet, Range, Cell, etc…

Same thing here in Sitefinity 4, and I believe it is a very welcome addition to that excellent platform that will bridge the gap between IT professionals and Developers to get tasks accomplished quickly in Sitefinity.

First, the code I used for the Generic API to create a new Page is here below based on a Button click event on a test page I created:

protected void Button1_Click(object sender, EventArgs e)

{

PageManager manager = PageManager.GetManager();

PageData pagedata = manager.CreatePageData();

pagedata.Template = manager.GetTemplates().First();

pagedata.HtmlTitle = "Lino testing page";

PageNode node = manager.CreatePageNode();

node.Title = "Lino Test Page";

node.ShowInNavigation = true;

node.UrlName = "LinoPage1";

var parent = manager.GetPageNode(SiteInitializer.FrontendRootNodeId);

manager.ChangeParent(node, parent);

node.Page = pagedata;

manager.SaveChanges();

SiteMapBase.Cache.Flush(); // This is needed only for the Beta

}

The main points as you will see in the video is to learn the relationship between PageManager, PageData and PageNode objects and how the system brings them all together to communicate with the OpenAccess ORM layer to place the new created page in its correct place in the database with all its corresponding data.

Finally, the code for the alternative method using FLUENT APIs is found below to accomplish the same thing:

protected void Button2_Click(object sender, EventArgs e)

{

PageManager pmanager = new PageManager();

Guid tempGuid = pmanager.GetTemplates().First().Id;

App.WorkWith()

.Page()

.CreateNewStandardPage(PageLocation.Frontend)

.Do(p =>

{

p.Name = "Lino Page 2";

p.Title = "Lino Second Page";

p.ShowInNavigation = true;

p.UrlName = "Lino2Page";

})

.SetTemplateTo(tempGuid)

.SaveChanges();

SiteMapBase.Cache.Flush(); // This is needed only for the Beta

}

Notice that the entire instruction occurred in one line using the “App” object that allows you to choose a preferred Object to “workwith” and then focus on that Object to accomplish whatever task specific to that object without worrying about what the OpenAccess ORM layer needs or the other objects in the hierarchy require to make it work.

Hope this gives you an entry into the power of using the Sitefinity 4.0 APIs and Fluent APIs and I would be interested in your opinion and recommendation for other videos and blogs to make Sitefinity 4.0 Development easier for everyone.

It's a little early for Easter but.....

Matt Kurvin — Thu, 05 Aug 2010 22:30:01 GMT

It's not unknown that we like to have fun at Falafel Software. So we've decided to add a new feature to the site.

Every month we will be adding an "Easter Egg" to www.falafel.com. Just a little fun interactive element one might happen to stumble upon while clicking through the site.

Previous misadventures have included our rippling logo at the header, and the interactive robot on the Consulting Home Page.

So be on the lookout, you never know what you may find!

Falafel Software Welcomes Drew Wells to Management Team

Lino Tadros — Mon, 02 Aug 2010 13:00:00 GMT

Falafel Software is very happy to announce Drew Wells has joined the management team at Falafel Software as Vice President of Products and Acquisitions. Wells joins the team with extensive experience building strong and successful product companies. He comes to Falafel from AutomatedQA, recently renamed Smart Bear Software, where he served for six years as the company’s Chief Technology Officer. AutomatedQA/Smart Bear and Falafel Software partner to offer state of the art consulting and training on AutomatedQA product offerings like TestComplete.

“Drew’s addition to the team signals an added focus at Falafel to complete the pyramid of consulting and training with the ‘product’ edge”, said Lino Tadros, Falafel Software’s Chairman & CEO, “Drew’s tremendous talent, ethics and hard work are an incredible addition to Falafel and fit very well with our plans and direction into the future.”

“Falafel Software is a great company.”, said Wells, “Lino leads an amazing group of smart people with world-class expertise in software technology and business needs. They also care deeply about the human side of customer experience. It’s an honor to join them and help the company continue to grow.”

Binding a TextBlock’s ToolTip to its Own Text Property in Silverlight

J. Tower — Thu, 29 Jul 2010 21:05:17 GMT

There’s not always enough room in the UI to display the entire contents of a TextBlock. Silverlight 4 includes the a new TextTrimming feature that allows you to cut a TextBlock’s content off after the last word that fits plus an ellipsis (. . .) at the end.

When I use the new text trimming feature, I like to put the un-trimmed contents of the TextBlock into its ToolTip so that the user can still see it when they mouse over the control.

The example below shows you how you can wire a TextBlock’s ToolTip to be bound to its own Text property.

<TextBlock x:Name="tbSample" Text="Too long to fit the space you have available"
 ToolTipService.ToolTip="{Binding Path=Text, RelativeSource={RelativeSource Self}}"
 TextWrapping="NoWrap" TextTrimming="WordEllipsis" HorizontalAlignment="Stretch" />

Falafel Is Ready for TestComplete 8

Lino Tadros — Thu, 29 Jul 2010 00:00:00 GMT

Congratulations to our friends and partners at SmartBear for releasing the heavily anticipated release of TestComplete 8 to the market. TestComplete 8 comes with an abundance of new features (over 150 features) to make everyday testing of Software easier and enjoyable.

Falafel Software simultaneously released today two major revisions of its award winning series of courseware material for TestComplete 8 Made Easy – Scripting Edition and the TestComplete 8 Made Easier – Keyword Edition.

You can order Testcomplete 8 Standard or Enterprise or upgrade your current version and receive 10% of the current price from the Falafel Store

Falafel software is offering TestComplete 8 training starting immediately on Scripting and Keyword testing, please check the schedule for online and onsite classes.

Last but not least, if you would like to get your hand on the courseware material for these two classes, they available for purchase on Lulu.com

Testcomplete 8 Made Easy – Scripting edition

TestComplete 8 Made Easier – Keyword Edition

With this release we also enabled PDF download from Lulu.com for these two books for a reduced price.

If you are an iPad user, check out the Keyword version of the book for the iBookStore that can be purchased here.

Falafel 2 Go now available in the Apple iTunes App Store

Lance Bullock — Tue, 27 Jul 2010 17:31:29 GMT

The Falafel Mobile Team is pleased to announce that Falafel 2 Go is now available in the App Store for the iPhone, iPad and iPod Touch. This application joins its’ Android cousin (already available in the Android Market) as a solution which allows our customers to view our upcoming training schedule, quickly view our Twitter Tweets, or read our excellent technical blogs – all very easily from their mobile devices.

http://itunes.com/apps/falafelsoftwareinc

Falafel 2 Go is a “universal application” where the same binary runs on the iPhone, iPod Touch, and the iPad in native resolution. This is a preferred way to go as you (and your users) only need to manage a single binary, while still taking advantage of the additional capabilities of something like the iPad. More technical blogs will be coming soon on this topic.

Take your data “2 Go”

Very soon, if not already, your customers and employees will be demanding to have access to various information on the go. We can tell you from experience that there is more to this than just coding for a mobile device. Of course there are all of the mobile considerations; such as the small form factor, limited battery life, reduced CPU power and memory capacities. However, in the enterprise world, it is also all about tying into existing infrastructure. Very seldom, an enterprise mobile app will be standalone, it will need to access existing information from other databases, systems, and applications.

At Falafel, we feel we are uniquely positioned for maximum success in this area, as we have extensive experience building and maintaining back-end application infrastructures, as well as a state-of-the-art mobile team. If you need help with your “2 Go” orders, please give us a call.

Silicon Valley Code Camp 2010

One exciting example of our ability to do the above, is what we will be doing for the Silicon Valley Code Camp. Code Camp is a 2 day, free, developer conference covering many development technologies, with currently over 100 technical sessions and 700+ attendees. More information can be found at:

http://www.siliconvalley-codecamp.com

In addition to being a Platinum Sponsor, and having multiple speakers delivering many sessions, Falafel will be developing a mobile app for the conference which will enable attendees to view and manage info about sessions, tracks, rooms, and speakers – enriching their conference experience. The mobile app will be making OData RESTful calls to the backend Code Camp .NET application. You may also see this running on multiple mobile platforms and examples from this solution being used in some of the Falafel talks being given at the conference.

Using a non converter to help you debug binding issues

Bary Nusz — Thu, 22 Jul 2010 02:16:44 GMT

Most of the time it’s not a big deal knowing what the binding source is. However when you have to go searching for that source with calls like RelativeSource then you’re not always sure of what you’re getting, if anything. I’ve found using a simple non converter can help a great deal. Let’s say you have a binding in xaml that looks something like this.

DataContext="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:SomeType}}}"

If you’re not getting what you’re expecting in the DataContext, you can use a simple non converter to figure out what you’re getting.

public class NonConverter : IValueConverter

{

#region IValueConverter Members

public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)

{

return value;

}

public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)

{

return value;

}

#endregion

}

Insert this into your xaml and put a break point on the “return value; “ line in your non converter.

<UserControl.Resources> 
  <local:NonConverter x:Key="nonConverter"></local:NonConverter> 
</UserControl.Resources> 
... 
DataContext="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:MyWindow}},Converter={StaticResource nonConverter}}"

Now you can run your program, and when the break point gets hit, you can query exactly what is getting passed to your binding.

Using BindingValidationError to Add Messages to a Validation Summary in Silverlight

Rachel Hagerman — Wed, 21 Jul 2010 04:08:22 GMT

If you aren’t familiar with it, the ValidationSummary control in Silverlight automatically shows validation exceptions for any controls within its same container element. That means if you add it to a grid or StackPanel that is full of bound controls, it will capture any validation exceptions from those bindings. It also gives you all kinds of useful functionality, like taking you to the invalid control when clicking on an item, and even removing the message when the input is corrected.

For example, these two textboxes are bound to FirstName and MiddleInitial properties, and MiddleInitial is required to be a string no longer than 1 character.

This works automatically, because the textboxes and the ValidationSummary are all inside the same layout grid.

But, if for some reason, we have to move the ValidationSummary outside, to another grid:

Oh no! The validation exceptions are no longer handled, and the ValidationSummary remains blank.

That’s because the ValidationSummary always hooks into a certain event of its parent container, in order to handle any ValidationExceptions from sibling controls. Luckily, we can use that same event to hook it back up again, even when it is outside the layout control.

The event is BindingValidationError, and it is triggered each time a ValidationException is thrown due to a binding setter, and also each time a setter action makes a previously invalid input valid again. So both the adding and the removal of ValidationSummaryItems can be handled in the same place. Here we are handling the event on the grdDataEntry, or the grid containing our textbox controls. You can use the Context property to set and find any messages that match a particular control.

private void grdDataEntry_BindingValidationError(object sender, ValidationErrorEventArgs e)
{
    if (e.Action == ValidationErrorEventAction.Added)
    {
        ValidationSummaryItem vsi = new ValidationSummaryItem() 
        { Message = e.Error.ErrorContent.ToString(), Context = e.OriginalSource };
        vsi.Sources.Add(
            new ValidationSummaryItemSource(String.Empty, e.OriginalSource as Control));
        valSum.Errors.Add(vsi);
    }
    else
    {
        ValidationSummaryItem valsumremove = 
            valSum.Errors.FirstOrDefault(v => v.Context == e.OriginalSource);
        if (valsumremove != null)
        {
            valSum.Errors.Remove(valsumremove);
        }
    }
}

Now the validation messages appear as the ValidationSummaryItems are added and removed. An invalid entry into the MiddleInitial field shows up in my ValidationSummary:

And when I correct the input, the message is removed!

So, the ValidationSummary can indeed be completely functional even when you are unable to place it in the same container as your bound controls.

Using a Generic Custom Attached Property Part 2

Bary Nusz — Wed, 14 Jul 2010 17:07:56 GMT

In part 1 I talked about our strongly typed GenericAttachedProperty<A> class that allows you to quickly attach any object or class to a UI element. This works great as long as you only need to store one int and/or one string and/or one TMyBigClass on the same element. To be able to attach more than one of a particular type to the same UI element we need to update our GenericAttachedProperty<A> class. The problem is that our GenericAttachedProperty<A> class uses the same dependency property name “Value” for all generic types.

public class GenericAttachedProperty<T>

 public static readonly DependencyProperty ValueProperty =

                DependencyProperty.RegisterAttached(

 "Value",

 typeof(T),

 typeof(GenericAttachedProperty<T>),

 null);

 public static T GetValue(DependencyObject d)

 return (T)d.GetValue(ValueProperty);

 public static void SetValue(DependencyObject d, T value)

            d.SetValue(ValueProperty, value);

If the types are different then you’re OK because the “Value” dependency property name is registered with the type of the parent. However, when you want to attach more than one of the same type of attached properties you can’t because you end up with the same “Value” dependency property and the same parent. Because you can’t have a static constructor, you can’t really pass in a different name for the attached property. The only option I could figure out to get around this problem was to make a new abstract type where you can pass in the owner type.

 public abstract class GenericAttachedProperty<O, A>

 public static readonly DependencyProperty ValueProperty =

                DependencyProperty.RegisterAttached(

 "Value",

 typeof(A),

 typeof(GenericAttachedProperty<O, A>),

 null);

 public static A GetValue(DependencyObject d)

 return (A)d.GetValue(ValueProperty);

 public static void SetValue(DependencyObject d, A value)

            d.SetValue(ValueProperty, value);

So now when we need to attach two ints (or any other object or class) to the same element you just need to declare new classes for each instance of the dependency property type you want to attach. Something like this:

 class LeftCountAttachedProperty : GenericAttachedProperty<LeftCountAttachedProperty, int> { };

 class RightCountAttachedProperty : GenericAttachedProperty<RightCountAttachedProperty, int> { };

This works because now when the “Value” dependency property is registered, it’s being registered to different parent types (which is defined in the third parameter in the RegisterAttached call). Now you can attach multiple unique int to any UI element by using its own class. Those calls would look something like this:

 #region Unique Int

 private void LeftCountAttachedProperty_Click(object sender, RoutedEventArgs e)

 int count = LeftCountAttachedProperty.GetValue(textBlock1);

            ++count;

            LeftCountAttachedProperty.SetValue(textBlock1, count);

            textBlock1.Text = String.Format("Left AttachedProperty: {0}", count.ToString());

 private void RightCountAttachedProperty_Click(object sender, RoutedEventArgs e)

 int count = RightCountAttachedProperty.GetValue(textBlock1);

            ++count;

            RightCountAttachedProperty.SetValue(textBlock1, count);

            textBlock1.Text = String.Format("Right AttachedProperty: {0}", count.ToString());

 #endregion

So what about the fourth parameter in the RegisterAttached call. Can we use the PropertyMetadata parameter to set and use a PropertyChangedCallback event handler for our GenericAttachedProperty? Yes, but it does require another updated abstract class.

If we just update the RegisterAttached call with the proper PropertyMetadata parameter to call a PropertyChangedCallback event handler like so:

 public static readonly DependencyProperty ValueProperty =

                DependencyProperty.RegisterAttached(

 "Value",

 typeof(A),

 typeof(GenericAttachedPropertyValueChanged<O, A>),

#if Silverlight

 new FrameworkPropertyMetadata(false, OnValueChanged));

#else

 new PropertyMetadata(new PropertyChangedCallback(OnValueChanged)));

#endif

Notice the #if to handle the differences between Silverlight and WPF.

The event handler OnValueChanged must be static and will be called upon a change to any attached property of the same type with the same parent type regardless of what UI element the attached property is attached. To handle this problem we must be able to store separate PropertyChangedCallback event handlers with the UI elements that you’re attaching properties to. First, we need to add a couple of static members to add and remove PropertyChangedCallback event handlers.

 public static void AddValueChangedHandler(DependencyObject element, PropertyChangedCallback callback)

 public static void RemoveValueChangedHandler(DependencyObject element, PropertyChangedCallback callback)

We could just attach the callback event handler to the element with a call like this:

GenericAttachedProperty<PropertyChangedCallback>.SetValue(element, callback);

But this would only allow you to ever attach one event handler to any one element regardless of the owner type. So if you tried to add a event handler to a UI element named textBox1 with the LeftCountAttachedProperty from above and then attached another event handler to the same UI element with RightCountAttachedProperty from above, you would overwrite the first event handler with the second one because the event handlers are the same type. What we need is to store the event handlers in a Dictionary that is keyed with the owner type. So we need a new class declaration to handle this.

 class GenericAttachedPropertyChangedCallbackDictionary :

        GenericAttachedProperty<GenericAttachedPropertyChangedCallbackDictionary, Dictionary<Type, PropertyChangedCallback>> { }

Now each UI element can maintain its own dictionary of event handler keyed with the owner type. Now we can fill in the Add/Remove members.

 static Type _type = typeof(O);

 public static void AddValueChangedHandler(DependencyObject element, PropertyChangedCallback callback)

            Dictionary<Type, PropertyChangedCallback> propertyChangedCallbackDictionary =

                GenericAttachedPropertyChangedCallbackDictionary.GetValue(element);

 if (propertyChangedCallbackDictionary == null)

                propertyChangedCallbackDictionary = new Dictionary<Type, PropertyChangedCallback>();

                element.SetValue(GenericAttachedPropertyChangedCallbackDictionary.ValueProperty, propertyChangedCallbackDictionary);

 if (propertyChangedCallbackDictionary.ContainsKey(_type))

                propertyChangedCallbackDictionary[_type] += callback;

 else

                propertyChangedCallbackDictionary[_type] = callback;

 public static void RemoveValueChangedHandler(DependencyObject element, PropertyChangedCallback callback)

            Dictionary<Type, PropertyChangedCallback> propertyChangedCallbackDictionary =

                GenericAttachedPropertyChangedCallbackDictionary.GetValue(element);

 if ((propertyChangedCallbackDictionary != null) &&

                (propertyChangedCallbackDictionary.ContainsKey(_type)))

                propertyChangedCallbackDictionary[_type] -= callback;

The first thing we do with either call is retrieve the dictionary from the UI element. If the dictionary comes back null when adding an event handler, then it’s the first time we’re adding an event handler, and the dictionary must be created and attached to the element. We can then add the event handler to the dictionary with the owner type as a key.

Now we just need to fill in the static OnValueChanged event handler.

 public static void OnValueChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

            Dictionary<Type, PropertyChangedCallback> propertyChangedCallbackDictionary =

                GenericAttachedPropertyChangedCallbackDictionary.GetValue(sender);

 if ((propertyChangedCallbackDictionary != null) &&

                (propertyChangedCallbackDictionary.ContainsKey(_type)))

                PropertyChangedCallback callback = propertyChangedCallbackDictionary[_type];

 if (callback != null)

                    callback(sender, e);

It’s a simple matter to retrieve the dictionary. Then the event handler keyed upon the owner type can be called.

The complete updated class is listed here.

 class GenericAttachedPropertyChangedCallbackDictionary :

        GenericAttachedProperty<GenericAttachedPropertyChangedCallbackDictionary, Dictionary<Type, PropertyChangedCallback>> { }

 /// <summary>

 /// A strongly typed generic attached property with property changed callback support

 /// </summary>

 /// <typeparam name="O">The type of the owner class</typeparam>

 /// <typeparam name="A">Type of the attached property</typeparam>

 public abstract class GenericAttachedPropertyValueChanged<O, A>

 static Type _type = typeof(O);

 public static readonly DependencyProperty ValueProperty =

                DependencyProperty.RegisterAttached(

 "Value",

 typeof(A),

 typeof(GenericAttachedPropertyValueChanged<O, A>),

#if Silverlight

 new FrameworkPropertyMetadata(false, OnValueChanged));

#else

 new PropertyMetadata(new PropertyChangedCallback(OnValueChanged)));

#endif

 public static A GetValue(DependencyObject d)

 return (A)d.GetValue(ValueProperty);

 public static void SetValue(DependencyObject d, A value)

            d.SetValue(ValueProperty, value);

 public static void AddValueChangedHandler(DependencyObject element, PropertyChangedCallback callback)

            Dictionary<Type, PropertyChangedCallback> propertyChangedCallbackDictionary =

                GenericAttachedPropertyChangedCallbackDictionary.GetValue(element);

 if (propertyChangedCallbackDictionary == null)

                propertyChangedCallbackDictionary = new Dictionary<Type, PropertyChangedCallback>();

                element.SetValue(GenericAttachedPropertyChangedCallbackDictionary.ValueProperty, propertyChangedCallbackDictionary);

 if (propertyChangedCallbackDictionary.ContainsKey(_type))

                propertyChangedCallbackDictionary[_type] += callback;

 else

                propertyChangedCallbackDictionary[_type] = callback;

 public static void RemoveValueChangedHandler(DependencyObject element, PropertyChangedCallback callback)

            Dictionary<Type, PropertyChangedCallback> propertyChangedCallbackDictionary =

                GenericAttachedPropertyChangedCallbackDictionary.GetValue(element);

 if ((propertyChangedCallbackDictionary != null) &&

                (propertyChangedCallbackDictionary.ContainsKey(_type)))

                propertyChangedCallbackDictionary[_type] -= callback;

 public static void OnValueChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

            Dictionary<Type, PropertyChangedCallback> propertyChangedCallbackDictionary =

                GenericAttachedPropertyChangedCallbackDictionary.GetValue(sender);

 if ((propertyChangedCallbackDictionary != null) &&

                (propertyChangedCallbackDictionary.ContainsKey(_type)))

                PropertyChangedCallback callback = propertyChangedCallbackDictionary[_type];

 if (callback != null)

                    callback(sender, e);

To demonstrate the various generic classes, I’ve prepared a sample Silverlight application here.

All the attached properties in this demo are attached to the same UI element – textBlock1.

The buttons labeled “Left Int” and “Right Int” have the following click event handlers.

 #region Basic Int Type

 private void LeftIntCount_Click(object sender, RoutedEventArgs e)

 int count = GenericAttachedProperty<int>.GetValue(textBlock1);

            ++count;

            GenericAttachedProperty<int>.SetValue(textBlock1, count);

            textBlock1.Text = String.Format("Left Int: {0}", count.ToString());

 private void RightIntCount_Click(object sender, RoutedEventArgs e)

 int count = GenericAttachedProperty<int>.GetValue(textBlock1);

            ++count;

            GenericAttachedProperty<int>.SetValue(textBlock1, count);

            textBlock1.Text = String.Format("Right Int: {0}", count.ToString());

 #endregion

Clicking either button will first call GetValue of the generic class. The generic type we are looking for is an int, and we are looking for it in the textBlock1 element. The int value is incremented, and the new value is attached back to the textBlock1 element. The new value is then displayed on the textBlock1 element. By clicking both buttons, it becomes obvious that the same value is being read, incremented, and reattached regardless of whether the left or right button is clicked.

For the next part of the demo, we need to declare a couple of classes to handle two unique int attached properties.

 class LeftCountAttachedProperty : GenericAttachedProperty<LeftCountAttachedProperty, int> { };

 class RightCountAttachedProperty : GenericAttachedProperty<RightCountAttachedProperty, int> { };

The buttons labeled “Left Count” and “Right Count” have the following click event handlers:

 #region Unique Int

 private void LeftCountAttachedProperty_Click(object sender, RoutedEventArgs e)

 int count = LeftCountAttachedProperty.GetValue(textBlock1);

            ++count;

            LeftCountAttachedProperty.SetValue(textBlock1, count);

            textBlock1.Text = String.Format("Left AttachedProperty: {0}", count.ToString());

 private void RightCountAttachedProperty_Click(object sender, RoutedEventArgs e)

 int count = RightCountAttachedProperty.GetValue(textBlock1);

            ++count;

            RightCountAttachedProperty.SetValue(textBlock1, count);

            textBlock1.Text = String.Format("Right AttachedProperty: {0}", count.ToString());

 #endregion

Same routine as before except that we are using our unique classes to store unique int values. Clicking either button will demonstrate that the values are indeed unique.

For the last part of the demo, we need to declare our unique callback classes.

 class LeftCountAttachedCallbackProperty : GenericAttachedPropertyValueChanged<LeftCountAttachedProperty, int> { };

 class RightCountAttachedCallbackProperty : GenericAttachedPropertyValueChanged<RightCountAttachedProperty, int> { };

The event handlers for the CheckBox, the unique PropertyChangedCallbacks, and the buttons labeled “Left Count Callback” and “Right Count Callback” are as follows.

 #region Unique Int with Callback

 private void CheckBox_Checked(object sender, RoutedEventArgs e)

            LeftCountAttachedCallbackProperty.AddValueChangedHandler(textBlock1, OnLeftValueChanged);

            RightCountAttachedCallbackProperty.AddValueChangedHandler(textBlock1, OnRightValueChanged);

 private void CheckBox_Unchecked(object sender, RoutedEventArgs e)

            LeftCountAttachedCallbackProperty.RemoveValueChangedHandler(textBlock1, OnLeftValueChanged);

            RightCountAttachedCallbackProperty.RemoveValueChangedHandler(textBlock1, OnRightValueChanged);

            leftTextBlock.Text = string.Empty;

            rightTextBlock.Text = string.Empty;

 private void LeftCountAttachedPropertyCallback_Click(object sender, RoutedEventArgs e)

 int count = LeftCountAttachedCallbackProperty.GetValue(textBlock1);

            ++count;

            LeftCountAttachedCallbackProperty.SetValue(textBlock1, count);

            textBlock1.Text = String.Format("Left Callback: {0}", count.ToString());

 private void RightCountAttachedPropertyCallback_Click(object sender, RoutedEventArgs e)

 int count = RightCountAttachedCallbackProperty.GetValue(textBlock1);

            ++count;

            RightCountAttachedCallbackProperty.SetValue(textBlock1, count);

            textBlock1.Text = String.Format("Right Callback: {0}", count.ToString());

 void OnLeftValueChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)

            leftTextBlock.Text = e.NewValue.ToString();

 void OnRightValueChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)

            rightTextBlock.Text = e.NewValue.ToString();

 #endregion

The PropertyChangedCallback event handlers are set and unset by the CheckBox. Clicking the left and right buttons demonstrates that the values are unique and the event handlers are unique.

It’s important to remember that you can attach any class or object type to any UI element. Using these generic classes you can quickly attach whatever you may need to UI elements and even use the PropertyChangedCallback to those attached properties however you need.

I’ve included the generic classes into a solution that contains a Silverlight project and WPF project that share the same source code as well as the demo solution here.

Sitefinity WebUIEditors and Selectors

Lino Tadros — Fri, 09 Jul 2010 18:38:00 GMT

Still as of Sitefinity 3.7 SP3, it is still really hard to find out all the available WebUIEditors and Selectors available for Sitefinity properties during Custom Control Development.

With some snooping around using .NET Reflector, you could see they are all over the place. Most of them are undocumented so be careful :)

These are the 20 WebUIEditors and Selectors currently found in the shipping 3.7 SP3:

Telerik.Blogs.WebControls.BlogsSelector
Telerik.Cms.Engine.WebControls.Categories.CategoriesSelector
Telerik.Cms.Engine.WebControls.ContentSelector
Telerik.Cms.Engine.WebControls.HtmlContentEditor
Telerik.Cms.Engine.WebControls.RssContentSelector
Telerik.Cms.Engine.WebControls.Tags.TagSelector
Telerik.Cms.Web.UI.CmsUrlWebEditor
Telerik.Cms.Web.UI.DhlIdEditor
Telerik.FileManager.UrlWebEditor
Telerik.Libraries.WebControls.DocumentsSelector
Telerik.Libraries.WebControls.DownloadListSelector
Telerik.Libraries.WebControls.GallerySelector
Telerik.Libraries.WebControls.ImageSelector
Telerik.Libraries.WebControls.LibrarySelector
Telerik.Lists.WebControls.ListSelector
Telerik.News.WebControls.NewsSelector
Telerik.Notifications.Newsletters.WebControl.GroupSelectionList
Telerik.Polls.WebControls.PollBoxEditor
Telerik.Rss.WebControls.RssFeedSelector
Telerik.Search.WebControls.IndexingServicesPicker

These are the class names with their full namespace that needs to be used in the attribute before your properties as well as the assemblies they come from. So for example, if you want to decorate a property with the ListSelector, this will be the syntax:

[WebEditor("Telerik.Lists.WebControls.ListSelector, Telerik.Lists")]

public string QuoteList

{

get { return _QuoteList; }

set { _QuoteList = value; }

}

iPad UISplitViewController bug – a workaround

Lance Bullock — Fri, 09 Jul 2010 15:59:40 GMT

The Problem

The UISplitViewController is the flagship iPad user interface element, as it allows your application to optimize the use of the large screen. This control manages 2 views, usually a master view (for navigation) and a detail view (for content). When in landscape mode, the controller shows both views side-by-side, and when the device is rotated to portrait mode, the master view is hidden and the detail view occupies the full screen. In this case, the SplitView controller places the master view in a hidden UIPopoverController, and the common MO is to add a button to a toolbar on the detail view so the user can call up the hidden master view for navigation – when in landscape this toolbar button is unnecessary (because the view is already showing) and should be hidden.

When testing the forthcoming Falafel 2 Go iPad version, I sometimes encountered a case where after the rotation back to portrait the toolbar button was missing. This is a pretty bad user experience because now the user is looking at detail view content, with no way to navigate – aside from rotating the device again. Of course I looked at my code first, and all seemed ok:

[toolbar setItems:items animated:YES];

This should correctly set the item back on the UIToolbar inside of the splitViewController:willHideViewController:withButtonBarItem:forPopoverController: delegate method.

After discovering that I could easily reproduce this problem by starting in portrait, rotating the device 45 degrees until the view started to change, and then quickly rotating back to portrait - I then tried I the simple Xcode template for a UISplitViewController project. The issue still reproduced, even with only the Apple code. I only found 1 reference to this issue anywhere on the internet (in the Apple forums), confirming my issue, and saying that a bug had been logged with Apple – but no solution. I guess I was able to discover it easily because I would launch our app from my debugger, with the device on the desk, and then pick up my iPad – which caused a couple of quick semi rotations.

It’s The Animation

You will notice from the line of code above, that we are telling the button to be added to the toolbar in an animated fashion, in this case a fade-in. In iOS you can manually animate almost anything, but many of the UIKit calls contain flags (as above) so the framework will perform the default animation for you automatically. I was already thinking that the animation was not so good in this case, the button would quickly fade in while the screen finished rotating. If Chuck Norris was using the app he would be ready to click before the button was there!

So I tried:

[toolbar setItems:items animated:NO];

This resulted in almost no visual difference to the user, and…………..no disappearing toolbar button!

Reusing list items in Android and iOS - a comparison.

Lance Bullock — Thu, 08 Jul 2010 18:40:00 GMT

A very common UI paradigm in mobile development is the scrolling list of items. You have all seen it: flick your finger up and down and the data scrolls by, touch an item and drill down into the details for the touched item. Here are a couple of examples from our Falafel 2 Go app:

You can probably imagine this is a critical performance area for a resource constrained mobile device: there could be many items in the list, the scrolling must happen in a fast and smooth fashion, and the process should not use excessive CPU or drain the device's battery. Fortunately, both the Android SDK and Apple's iOS provide mechanisms for optimizing the display of your list data, but it is the developers responsibility to use these correctly. This article is not meant to be a comprehensive tutorial on using Android's ListView or iOS's UITableViewController, instead we are going to look at some of the details of list item reuse in the different frameworks.

Android's ListView and ListAdapter view reuse

In the Android architecture, the scrolling list UI object (the "controller" if you will) is called a ListView and the "model" is called a ListAdapter. A ListAdapter subclass is responsible for supplying the data to a ListView for display. The simplest subclass of a ListAdapter is an ArrayAdapter (provided by the Android SDK). If you are just looking for a list of simple strings, then it is enough to use an instance of ArrayAdapter and give it an array of your String object, and you are done. In most cases however, you will want to present additional information within the cell in a more complicated view than just a simple text string. When this is the case, in Android, you will need to subclass one of the ListAdapter classes and override the getView method in order to provide the ListView with a view representation for the list item, this is where the list item reuse is going to come into play.

In the Java code below we are subclassing the ArrayAdapter class and overriding the getView method to return a view for the list item that contains an ImageView and 2 TextViews, note that our array adapter is also now holding more than just a simple String object, but an object which represents various items we would like to populate in our list.

01.public class BlogAdapter extends ArrayAdapter<BlogListData>

02.{

03.

04. BlogListData[] items;

05.

06. public BlogAdapter(Context context, int resource, int textViewResourceId,

07. BlogListData[] objects)

08. {

09. super(context, resource, textViewResourceId, objects);

10. this.items = objects;

11.

12. }

13.

14. @Override

15. public View getView(int position, View convertView, ViewGroup parent)

16. {

17. View currentRowView = convertView;

18. if (currentRowView == null)

19. {

20. LayoutInflater li = (LayoutInflater)getContext().getSystemService(Context.LAYOUT_INFLATER_SERVICE);

21. currentRowView = li.inflate(R.layout.blogentry, null);

22.

23. }

24. ImageView ivBlogger = (ImageView)currentRowView.findViewById(R.id.tvBloggerPic);

25. TextView tvBlogTitle = (TextView)currentRowView.findViewById(R.id.tvBlogTitle);

26. TextView tvBlogSubtitle = (TextView)currentRowView.findViewById(R.id.tvBlogSubtitle);

27.

28. // Setup cell data that changes based on row

29. ivBlogger.setImageResource(items[position].bloggerDrawable);

30. tvBlogSubtitle.setText(items[position].author + " on " + items[position].date);

31. tvBlogTitle.setText(items[position].title);

32. return currentRowView;

33. }

34.

35.}

The key piece of logic in the above code is at Line 18. When the ListView calls the getView method of your Adapter, it will pass a previously used view in the convertView parameter, if there is one available. You should check for this and reuse this view if possible, resetting the data for the row to be displayed. If there is no reusable view available then you go ahead and instantiate (inflate) the new object from the XML layout. We then continue on and set the image and text to be shown in our list item in the same manner - whether or not it is new or reused.

Another important point is that If you have conditional logic which is setting the values of your views, it is important that it is complete. Consider the following logic:

if (someValue > 5) backgroundColor = RED;

This would typically be perfectly fine if you were always creating new views for the list items, however when reusing views the backgroundColor may have been previously been set to RED and you need to set it back to the default in the else condition. I have seen many "bugs" discussed on the various forums due to this issue.

The ListView/ListAdapter architecture also allows for different layouts for different items in the list. In order to have this work with cell reuse, the ListView needs to know which rows are using which type of views, so that it can cache reuse pools separately. We will not go into detail here, but this is accomplished by overriding the getItemViewType and getViewTypeCount in your ListAdapter subclass.

Note: Lines 27-29 can also be optimized. You will notice that each time we render a list item we are traversing the layout hierarchy of the view in order to find the view objects we are interested in setting. A solution to this is to place a "holder" object in the tag property of the main view which references the views we are looking for.

iOS UITableViewController, UITableView and UITableViewCell reuse

Now we will move to iOS (iPhone, iPad) and take a look at reusing list items, which we will call table cells. Aside from the obvious difference that we are now coding in Objective-C instead of Java, there are a couple of other differences, but also some similarity - and the concept is exactly the same. First off, like Android, we will need to implement a method that the UITableView will call when it needs to populate its' rows. In order to do this however, we will not need to subclass this time. The Cocoa Touch framework in iOS commonly uses a delegation pattern, where some other object is specified to perform operations on behalf of another, which makes subclassing unnecessary. In this case, the UITableView will delegate row population to some other object which has been assigned to the UITableView's dataSource property. Typically that will be the UITableViewController, in fact when creating a UITableViewController class, XCode will generate template code for cell reuse.

The UITableView will call the tableView:cellForRowAtIndexPath: method of its' dataSource for each row it wishes to populate in the list. Our implementation of this looks as follows:

01.- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath {

02.

03. static NSString *CellIdentifier = @"Cell";

04.

05. UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:CellIdentifier];

06. if (cell == nil)

07. {

08.

cell = [[[UITableViewCell alloc] initWithStyle:UITableViewCellStyleSubtitle reuseIdentifier:CellIdentifier] autorelease];

09.

10. // Setup cell for new cell instances

11. cell.contentView.backgroundColor = [UIColor clearColor];

12. cell.backgroundColor = [UIColor clearColor];

13.

14. cell.textLabel.textColor= [UIColor whiteColor];

15. cell.textLabel.font = [cell.textLabel.font fontWithSize:14];

16. cell.textLabel.numberOfLines=2;

17.

18. }

19.

20. // Setup cell data that changes based on row

21. cell.imageView.image = [bloggerImageLookup imageForBlogger:((FeedInfo*)[feedItems objectAtIndex:indexPath.row]).author];

22. cell.textLabel.text = ((FeedInfo*)[feedItems objectAtIndex:indexPath.row]).title;

23. cell.detailTextLabel.text= ((FeedInfo*)[feedItems objectAtIndex:indexPath.row]).author;

24.

25. return cell;

26.}

The key code here occurs in lines 5 and 6. In line 5 you see us using the selector dequeueReusableCellWithIdentifier:, to invoke this method of the UITableView which will return us a reusable UITableViewCell if one is available, very similar to the Android model, except in this case we need to make a call instead of being directly passed a reusable cell. After that, the pattern is the same, we only allocate and init a new UITableViewCell if necessary, and then we reset or set properties to set up our table cell - once again it is important to ensure your logic is complete when reusing cells.

As with Android, you may have different UITableViewCells for each row of data. In this case, implementing additional methods is not necessary, you simply supply a NSString as a "CellIdentifier" both when create the new cell, and you retrieve the cell from the queue, that code is also seen above.

Wrap-Up

The key point I would like to make here is that while both mobile platforms provide simple and nice mechanisms for efficiently reusing list items, it is not automatic in either case. There is nothing that enforces the reuse of these objects, and you can tell from examining the above code that it is entirely possible to allocate/create brand new views or cells for each item that needs to be displayed - in which case your user is likely a few "flicks" away from being saddled with a very ill-behaving mobile device.