0

Let's say I have 10000 WPF controls that are quite heavily styled, and that their styles are about 90% identical.

I'm wondering: what would be the best way to do, performance-wise?

  1. have 10000 unique styles
  2. have 1 style that contains the common 90% + 10000 styles inheriting this style and adding the remaining 10%

I had gone for the second option without second thoughts (on readability considerations), but I made some basic tests that tended to show this was a very bad idea in terms of performance. So are my tests buggy, or does Style-inheritance really lower perfs?

edit: okay, I was almost certain that this was not explained well enough. I'll try to detail a bit:

basically, My concern lays with the DataGrid. My cells are heavily customisable (basically, you can change every style property in a cell), and as the datagrid does not allow this to be done easily (thanks to the datagridcell's datacontext being the rowView instead of the CellView), I have done something really ugly to achieve what I add to do (see there if you want the detail). It basically consists in setting the CellStyle in code-behind for each cell.

as those styles have a lot in common, I tried setting up a common style, put in my app's static resources and base all my cell styles on this common style. (this style hosted event listeners, amongst other things, while the cellStyles added the bindings to properties such as the foreground Color, FontSize, etc...)

I noticed a big drop in the datagrid's perf when I tried that. Now, as I was not really testing this side of the app at the time, it might just have been that some part of the code was simply badly written and the drop in the perf had nothing to do with me using "basedon" styles. Anyway, I rolledBack and finished the testing I had going on.

Now, I'm tidying my code and I though about this again. Before going to te trouble of changing all my style-structure again, if anly just for test-purposes, I thought I'd ask here first if it was worth the trouble... nothing more going on...

thanks for your help!

Community
  • 1
  • 1
David
  • 6,014
  • 4
  • 39
  • 55

1 Answers1

2

I would say definitely the latter. Boiling commonality down to "inheritable" styles would probably be the best. At the very least loading those styles at runtime would be faster in regards to disk time. Even if each sub style had a bunch of setters, with so many it would take less reading time that 10,000 fully specified styles that amount to the same control. Although with the other 10% of differentiation, is there a way you can boil those differences into sets of styles also?

You can have a style that is based on a style that is based on a style...

Additionally, are there some things that you can push off to Triggers on these items? Lets say you have 10000 possible combinations of all of your style settings. If you could move off a few of those to several triggers, seems like it would lower the number of style choices that you would need.

CodeWarrior
  • 7,388
  • 7
  • 51
  • 78