1. public class XMLResult<T> : ActionResult
2.   {
3.     private IEnumerable<T> _items;
4.     private string _rootName;
5.     private string _typeName;
7.     public XMLResult(IEnumerable<T> items, string rootName, string typeName)
8.     {
9.       _items = items;
10.       _rootName = rootName;
11.       _typeName = typeName;
12.     }
13.     public override void ExecuteResult(ControllerContext context)
14.     {
15.       if (_items == null)
16.       {
17.         throw new NullReferenceException();
18.       }
19.       XmlWriterSettings settings = new XmlWriterSettings() { Indent = true, NewLineHandling = NewLineHandling.Entitize };
20.       context.HttpContext.Response.ContentType = “text/xml”;
22.       using (XmlWriter writer = XmlWriter.Create(context.HttpContext.Response.OutputStream, settings))
23.       {
25.         writer.WriteStartElement(_rootName);
26.         foreach (T item in _items)
27.         {
28.           if (string.IsNullOrEmpty(_typeName))
29.           {
30.             writer.WriteStartElement(item.GetType().Name);
31.           }
32.           else
33.           {
34.             writer.WriteStartElement(_typeName);
35.           }
36.           foreach (PropertyInfo pi in item.GetType().GetProperties())
37.           {
38.             if (pi.PropertyType.IsValueType || pi.PropertyType == typeof(string))
39.             {
40.               if (pi.GetValue(item, null) != null)
41.               {
42.                 writer.WriteElementString(pi.Name, pi.GetValue(item, null).ToString());
43.               }
44.             }
45.           }
46.           writer.WriteEndElement();
47.         }
48.         writer.WriteEndElement();
49.       }
51.     }
52.   }

* This source code was highlighted with Source Code Highlighter.

I think it speaks for itself. The only thing needs a little explanation is the narrowing of the types in the PropertyInfo loop. I needed only value types and string, nothing else. Since my entities contained BLOB data and navigation properties, I got rid of the rest.
This little class is used as follows:

1. public XMLResult<Beer> Beers()
2.     {
3.       return new XMLResult<Beer>(context.Beers.Where(x=>x.IsApproved.Value).OrderBy(x=>x.Name), “Beers”, “Beer”);
4.     }

* This source code was highlighted with Source Code Highlighter.

And it works with basically anything, thanks to the generic type parameter. From this startpoint, you can easily implement your own POX (Plain Old XML) services with ASP.NET MVC. In the next post we consider how to extract the entities from the generated XML on the iPhone.

First you need a timer. To avoid some nasty threading issues, we use the DispatcherTimer – it runs on the same thread as the Dispatcher. I created it as a private field of my UserControl, so I assume you did this too.

I also created an event for the double click, but it’s fairly convenient. The main interest is the MouseLeftButtonUp event, which looks like this:

private void Control_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
    {
      if (_doubleClickTimer.IsEnabled)
      {
        _doubleClickTimer.Stop();
        if (this.DoubleClick != null)
        {
          this.DoubleClick(this, null);
        }
      }
      else
      {
        _doubleClickTimer.Interval = new TimeSpan(0, 0, 0, 0, 400);
        _doubleClickTimer.Tick += (o, e2) => _doubleClickTimer.Stop();
        _doubleClickTimer.Start();
      }
    }

* This source code was highlighted with Source Code Highlighter.

The source code is pretty simple. First we check if our DispatcherTimer has an enabled state. If it does, it means that it’s already started. If it’s started, then it means that the user must have clicked once on the control. That’s because if the DispatcherTimer isn’t started, then the else branch will run, which does nothing more than start a timer with a reasonable 400 milliseconds double-click experience, sets that it should run only once, then starts it.

So if our timer was started that means we are no longer than 400 milliseconds after the first click, so we have a double click! And we fire the double click event. That’s all, use it, extend it as you wish.

This problem can be solved easily. The following code snippet does it for you:

1. if (Current.IsRunningOutOfBrowser)
2.       {
3.         Current.CheckAndDownloadUpdateCompleted += (s, e2) =>
4.         {
5.           if (e2.UpdateAvailable)
6.           {
7.             MessageBox.Show(“A new version was found, please restart the Application!”);
9.             if (e2.Error != null)
10.             {
11.               MessageBox.Show(“There was an error updating the application!”);
12.             }
13.           }
15.         };
16.         Current.CheckAndDownloadUpdateAsync();
17.       }

 

* This source code was highlighted with Source Code Highlighter.

However, there are some quirks. You shouldn’t check the “Require elevated trust when running outside the browser”, because if you do so, auto update fails to start.

And another one: if you place the code above in the app constructor, it won’t work. The earliest stage I manage to get it work was the Application_Startup method.

First rule: you can only enter full screen as a result of a user initiated action. This is a security feature, and I don’t know the reason of it, but smarter guys will tell you if you ask them. So no full screen enters in Window_Loaded event handlers, but you can add a MouseLeftButtonUp handler to the same window, and add the following code to the event handler:

Application.Current.Host.Content.IsFullScreen = true;

Security bypassed, the user initiated the action (although totally unaware of it). You might think that you’re good to go from now on, your application running full screen, everybody is happy. Sadly, there’s a little quirk here: you won’t get full keyboard support running full screen.

I was a little unspecific about what is full keyboard support. Well, you can rest assured that you can’t type in anything, but you can move around with arrows. Nice, isn’t it? Before you ask, no there’s no way to code this around.

From version 4, we have a solution to your problem. Setting the Application.Current.MainWindow.WindowState property to Maximized, you can have a maximized window on startup. You don’t even need the user to initiate an action for you, it just works. The code for the lazy ones:

Application.Current.MainWindow.WindowState = WindowState.Maximized;

It’s not full screen, just a plain old maximized window, but it did the trick for me.

So we’re arriving to version 5.0 in a matter of days, and we’re also having (or at least I’m having) nightmares about the future. After watching the BUILD conference, scanning through the news, blogs, forums, whatever I had the feeling that Silverlight won’t last that long. (Of course, Silverlight is a first-class citizen of the new Windows 8 platform, but we didn’t even mention it in the keynote). After the first suspicious thoughts came the campaign of Silverlight’s importance, which further strengthened my feelings that something is wrong here. But enough of this.

I came to the decision that there’s no point arguing about wasted development efforts (I learn something new every day – and not about Silverlight, but about Software development in general) and the rest. No effort wasted as long as you think. The only one has to worry about this is my boss, who took the decision of rewriting the company’s flagship product in Silverlight. But he has his points, so let’s take a look around.

You want to take your business application to the browser and you want to provide rich user experience – generally, you want a rich internet application. What do you chose? I’ve fiddled enough with Javascript frameworks like ExtJs, and they are simply not enough (for me, the .NET guy). Also, you can start writing something in HTML5, but that’s not a lot better, in my opinion. Add existing .NET developers to the scene, along with a strong Microsoft partnership: it leads to Silverlight.

As I said, I’m writing my biggest application (healthcare system) and I feel that Silverlight is not the best tool for the job – I stumble into some immaturity, inconsistent function, etc. daily, not to mention the horror of adding yet another toolkit. I pretty much enjoyed subclassing existing controls (an effect of Cocoa development), but you get fed up with that too, just to make a dumb Combobox work.

Anyway, Silverlight is bad, but it’s not that bad. My troubles stem from the fact that I worked with WPF before I take a chance with Silverlight, and from the fact that I know what I’m missing. And because of this, I plan to publish some painfully earned gems on this blog, like how you can make a full screen app that you can type into, or how to make a crappy data binding to a Combobox. Just to help you guys out there googling the same crap I do daily.

Happy coding!

Why Silverlight? The answer is simple: I hold no Silverlight certification – and moreover I’m working on a big project which is based on Silverlight and it strikes me every day  ow much I don’t know about it.

So from now on, except some Silverlight posts based on Microsoft Learning’s skills being measured section.

Hopefully I’ll have the time to write some posts about my first (successful) iOs application, it became the number one in Hungary for a week or so.

I’m currently building an iPhone/iPad app which is connected to PHP sites running MySql in the background and result in content users reading printed magazines on their devices, thus saving quite a lot of trees (and me getting bald). This app is so economical that there are two in one, further reducing the carbon footprint (In fact, reducing it better than Microsoft with not sending certifications out, only if you pay for it.). But enough of this, you want code, not complaints.

And code is what you’ll get. I’ve made some patches to the LeavesView project on GitHub, so that now you zoom into it without nice system crashes. I’ll create a fork on the project after the thing is tested and proved well.

The MS certification track is suspended now, because I think I have had enough for now. I collected ten certs in a year, and I don’t feel like I need another ten. Also, I’m a little bit upset, because MS certification prices will be raised (OK, I can live with it), but you can’t find out the rate, because the cert price calculator is just plain wrong (maybe a Silverlight MCTS would be able to help).

I’ll post soon, because I read a lot about data structures, algorithms, coding practices and I’m eager to create a book list. Until then, happy coding to everyone, and check out my iPhone app when it gets into the store. I’ll make a post for it, too.

I did an MCTS exam a while ago, and I was a bit shocked how easy it was – I “overprepared” myself.. I thought that you can pass this one with a deep understanding of the .NET Framework and a little WPF knowledge – but this way, you’d need to use your common sense.

There were some questions on WPF and Windows Forms integration, but you could figure them out with a little thinking. Also there were some on UI aligning, UAC, ClickOnce abd parallelism. The questions were that MCTS type, so they focused on how to do something instead of why, but that was expected.

My next goal is the .NET 4 Windows MCPD exam – which is filled with cool architectural decisions, as I looked briefly on the skills measured section.

WPF adds a new concept to the classic .NET property world, namely dependency properties. They introduce some nice new features such as property value inheritance and change notification. You can imagine that most of the WPF properties are dependency properties.

Like almost anything else, dependency properties are coming in multiple variations. The first is a “simple” dependency property, and the second is an attached dependency property. More info about the latter is in the end of this post.

What do we need to define a classic dependency property (that is not an attached one)? Three things:

• defining the property
• registering it
• wrapping it within a normal .NET property

Well, that doesn’t sound like a big issue, so let’s define one!

First we need to define the property – in the class we’ll use it in. To do so, we need to add a static field of type DependencyProperty (this field might be shared with other elements, so it’s a good point to define it as static). Also, you need to define the field with the readonly keyword, so it can only be set in a static constructor. The whole code might look as follows:

public static readonly DependencyProperty ColorProperty;

Now you need to register it with the class you’d like to use. We created a static readonly field, so the best way to set it is a static constructor. To register a dependency property, you can define five things:

• Property name
• Data type used
• Owner type
• A FramewokrPropertyMetadata object – optional
• A validation callback – optional

So working with the previous example, you could do something like this in the static constructor:

ColorProperty = DependencyProperty.Register(“Color”, typeof(Color), typeof(FrameworkElement));

The last two things are FrameworkPropertyMetadata and the validation callback – they deserve some explanation. The FrameworkPropertyMetadata class has some Boolean flags you can set, and they can indicate a bunch of things, like if the property affects the rendering of the item, is it inheritable by child properties, a default value, etc. An interesting feature is that it lets you define two callback methods – CoerceValueCallback and PropertyChangedCallback. More info on them later.

A validation callback is a bit limited callback method you can define in the DependencyProperty.Register method. Because it knows of only the value to be validated, and not the context, you can do some basic validation by it (like for example the value isn’t negative). But you can’t check if the value is bigger than another value in the same object. That’s what Coercion callbacks are for.

OK, the last thing to do when you work with a normal dependency property is to wrap it within a normal .NET property. You should use the GetValue and SetValue methods, and never place any validation logic inside your property getters and setters, because they can be bypassed by WPF. So to stick with our color example, here’s what you’d do:

public Color Color
{
get { return (Color) GetValue(ColorProperty);}
set { SetValue(ColorProperty, value); }
}

And you’re done. I told you in the very beginning that there are two types of dependency properties. That was the first one, now let’s see the second. It’s called an attached dependency property, and the main difference is that it’s an attached property.

There isn’t much difference between defining an attached and a normal dependency property. You define it as a static readonly field, but you use the RegisterAttached method of the DependencyProperty class. You define static getter and setter methods, with the name GetPropertyName and SetPropertyName, as follows:

public static Color GetColor(UIElement element)
{
return (Color) element.GetValue(UIElement.Color);
}
public static void SetColor(UIElement element, Color value)
{
element.SetValue(UIElement.Color, value);
}

Let’s see a fairly basic example: drag something and drop it to another control. First we need to handle the MouseDown event on the source control (you must hold down the mouse, move it to another place, and release it there). We need a method there:

private void source_MouseDown(….)
{
Label lab = (Label) sender;
DragDrop.DoDragDrop(lab, lab.Content, DragDropEffects.Copy);
}

Then you need to handle the target’s drop event, like this:

private void target_Drop(object sender, DragEventArgs e)
{
 ((Label)sender).Content = e.Data.GetData(DataFormats.Text);
}

These code samples were from the book Pro WPF 4 in C# 2010.

Of course you could improve this drag and drop experience to check whether or not data is present before “dropping” it on the target. There’s an event just for that, and it’s called DragEnter. A perfect candidate to check things like the format and the availability of the data to be dropped.

If you’d like to drag and drop across applications, then I have a nice link for you. It’s a little code written by Scott Garland who seemed to be a little upset when he tried to do the thing. Anyway, don’t give up the hope – you need a class implementing ISerializable or IDataObject to begin with, and the rest will be simple…