At least i’m somewhat confused that Gray (#FF808080) is darker than DarkGray (#FFA9A9A9)

they probably have some really strange monitor settings over there in redmond

<r:Ribbon cal:RegionManager.RegionName="ApplicationRibbon"> ....</r:Ribbon>

you will get a KeyNotFoundException.
Diving a little bit deeper shows you that the RegionManager cannot find a RegionAdapter mapping for Microsoft.Windows.Controls.Ribbon.Ribbon.That means that we have to write a RegionAdapter for the Ribbon Control.Implementing IRegionAdapter should suffice but as we are lazy, we could just inherit from RegionAdapterBase<T> (where our T will be Ribbon) and we will end up with something short like this:

 public class RibbonRegionAdapter : RegionAdapterBase<Ribbon>
    {
        protected override void Adapt(IRegion region, Ribbon regionTarget)
        {
            region.Views.CollectionChanged += delegate {
                foreach (var tab in region.Views.Cast<RibbonTab>())
                {
                    if (!regionTarget.Tabs.Contains(tab))
                    {
                        regionTarget.Tabs.Add(tab);
                    }
                }
            };
        }

        protected override IRegion CreateRegion()
        {
            return new SingleActiveRegion();
        }
    }

at least we have to Register this RegionAdapter in our bootstrapper. Therefore we just override the Bootstrapper’s ConfigureRegionAdapterMapping’s method:

protected override RegionAdapterMappings ConfigureRegionAdapterMappings()
        {
            var mappings = Container.TryResolve<RegionAdapterMappings>();
            if (mappings != null)
            {
                mappings.RegisterMapping(typeof(Ribbon), new RibbonRegionAdapter());
            }
            return mappings;
        }

Now we should be able to add RibbonTab’s to the ribbon from within our Modules using RegionManager (we can easily resolve this from our IoC Container).

This is no full featured quality guide for using the Wpf Ribbon control with CompositeWpf. It just shows that writing custom region adapters is actually quite an easy thing.

Our 4 candidates are :

• DateTime.Parse
• DateTime.ParseExact
• DateTime.TryParse
• DateTime.TryParseExact

I also wanted to know if there is a difference when using different IFormatProviders. To benchmark i used the InvariantCulture, a concrete CultureInfo (”de-DE” in this case as i could not see any difference between “de-DE”,”en-US”,”fr-FR”,…) and no IFormatProvider for the Parse/TryParse methods (having an IFormatProvider is mandatory for the ***Exact methods).
The following chart shows the result for 10.000.000 calls to every one of those methods.

Comments are welcome!

Edit:I was pointed out to the System.Convert.ToDateTime() Method, but as it uses DateTime.Parse() internally, performance is the same as DateTime.Parse(), so TryParseExact is still the way to go.

The Webbrowser control is just a native Win32 Hwnd that gets hosted inside some WPF content area. But it’s quite annoying that the Transparency stuff gets pass on to it.
I wonder how i could circumvent this limitation as i don’t need transparency in the webbrowser control itself. Its just to get some homegrown, fancy-looking window style.

I’m looking forward to see this fixed by Microsoft in some future release.

Disclaimer:This is not a ready to use fully-featured control for production use. It just shows in a very simple manner how to get Properties and their values from objects via reflection and show them using WPF and databinding.
It is by far not a replacement of commercial WPF PropertyGrids (e.g. MindScape WPF PropertyGrid), more a fast solution for minimal requirements.

This simple PropertyGrid will not contain special Editors for non trivial data types. For now we are confident with a simple TextBox for demonstration purposes.
We will see that because of the automatic conversion features of wpf , we’re easily able to edit not only strings, but also int’s, double’s, Color’s, SolidColorBrush’es and so on in a simple TextBox.

Our WPF PropertyGrid clone should look like this:

• TextBox for searching (filtering) properties. This is especially usefule if your classes contain lots of properties
• a panel (here StackPanel) that contains all the PropertyName/PropertyValue pairs (wrapped up in a Scrollviewer)
• TextBox for descriptions that we obtain from the System.ComponentModel.DescriptionAttribute-Attribute of the property selected

First we want to realize the simple structure shown above in XAML to get started.
After short time this may look like this:

foreach (PropertyDescriptor property in TypeDescriptor.GetProperties(value)){

	if (!property.IsBrowsable) continue; //not browsable. ignore

        PropertyItem currentProperty = new PropertyItem();
        currentProperty.PropertyName = property.Name;
        Binding b = new Binding(property.Name);
        b.Source = selectedObject;
	//OneWay Binding if readonly, twoway else
        b.Mode = property.IsReadOnly ? BindingMode.OneWay : BindingMode.TwoWay;

        currentProperty.SetBinding(PropertyItem.PropertyValueProperty, b);
	currentProperty.OnActive += new EventHandler(currentProperty_OnActive);

        foreach (Attribute attribute in property.Attributes)	//check attributes
        {
         if (attribute.GetType() == typeof(DescriptionAttribute)){ //description to show in description textbox
            currentProperty.PropertyDescription = ((DescriptionAttribute)attribute).Description;
         }
         if (attribute.GetType() == typeof(CategoryAttribute)) {  //categories known from winforms pg.not implemented
             currentProperty.PropertyCategory = ((CategoryAttribute)attribute).Category;
         }
        }      

	PropertyPanel.Children.Add(currentProperty); //add PropertyItem to panel
}

That’s it! Well, what happened here?
We iterate over all properties the object, we set as SelectedObject, contains. If it’s marked as non-Browsable (System.ComponentModel.BrowsableAttribute), we’ll just skip it, otherwise we create a PropertyItem, set its name and create a Binding to connect the PropertyItem’s PropertyValue-property with the value of the actual property from SelectedObject.

And before we add the PropertyItem to our Panel, we check the attributes of the source property (e.g. to get the description from the DescriptionAttribute or the get the corresponding category from the CategoryAttribute, which is not processed for simplicity in this demo).

When we now try to set some object to our PropertyGrid’s SelectedObject-property (in this case a dummy class containing several properties, including string, int, double, color, SolidColorBrush and a property marked with Browsable(false)) it should look like this:

In the screeshot above you can see different data types in their string representation. You don’t have to care about converting them back manually to their actual type as WPF’s Binding-Helpers do everything for you (and will throw Exceptions if the string-format for your type is wrong).

At last we add some Style to our PropertyGrid and received something like this:

…and add the PropertyGrid itself somewhere in your XAML code

at last you have to provide some object (that contains some properties) to the SelectedObject property:

//...
this.propertyGrid.SelectedObject = myCustomObject;
//...

You can download the whole solution here: PropertyGridDemo.zip

Some time later i found out what made this error appear. When you have a lot of entities and therefore a huge mapping, it can take quite a long time to process your hbm file. When you now want to access some of your entities from another thread as the main thread via NHibernate, but NHibernate still has not finished processing your mapping, then you’ll also get the error stated above.This will remain as long as you use the same session.

Maybe this can save some other guy’s time

[ServiceContract]
    public interface IStreamService
    {
        [OperationContract]
        Stream GetData(string fileName);
    }

We now want to define a service that just takes a filename as an argument and returns the data the file contains in a stream. Therefore our implementation of IStreamService is quite easy too:

  public class StreamService : IStreamService
    {
        public Stream GetData(string filename)
        {
            FileStream fs = new FileStream(filename, FileMode.Open)
            return fs;
        }
    }

That’s everything we have to do on the service side (exception configuration). When you want to use streaming, be sure to use one of the following bindings:

• BasicHttpBinding
• NetTcpBinding
• NetNamedPipeBinding

These bindings expose a Property called “TransferMode” where you can specify how you want to transmit your data. This could be either “Buffered” (default) or “Streamed” (or even StreamedResponse/StreamedRequest if you want to stream just in one direction).

Next just add a service reference to your client (within visual studio).You way also want to set the maxReceivedMessageSize property of your binding to a value high enough to contain your whole stream data, as everything transmitted via your stream is regarded as one huge message. But you can leave maxBufferSize to its default (64k bytes) as this indicates only the amout that is buffered before it gets processed.

Then we can just use the stream as we did years ago :

StreamDemo.StreamServiceClient client = new WcfStreamDemoClient.StreamDemo.StreamServiceClient();
Stream str = client.GetData(@"c:\path\to\myfile.dat");
FileStream fs = new FileStream(@"c:\wcf\transmitted\copy.dat", FileMode.Create);

int b,i=0;
do
{
      b = str.ReadByte(); //read next byte from stream
      fs.WriteByte((byte)b); //write byte to local file
      i++;
} while (b != -1);
Console.Write("\rRead {0} bytes.", i);
str.Close();
fs.Close();

That’s it!
I can imagine a lot of distributed applications where this could be really useful. Maybe this micro tutorial can be useful too

But what if you want to display some Properties of your objects in another format (i.e. something other that ToString() returns) ? You can either override ToString() or try to use another (imho more elegant) way.
Therefore WPF offers an Interface called IValueConverter

public interface IValueConverter {
   public object Convert(object value, Type targetType, object parameter, CultureInfo culture);
   public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture);
}

When implementing this interface in your own class, you can probably do everything you can imagine with the values you try to format. You can e.g. display the birthdate instead of its (normal) DateTime representation as Base64-string (this has no real use, it’s just an example of how far you can go). Therefore we create the following converter:

public class Base64Converter : IValueConverter
{
  #region IValueConverter Members

  public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
  {
      return System.Convert.ToBase64String(Encoding.ASCII.GetBytes(value.ToString()));
  }

  public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
  {
      return Encoding.ASCII.GetString(System.Convert.FromBase64String(value.ToString()));
  }

  #endregion
}

Next we have to add our Namespace to the Window:

<Window x:Class="CustomValueConverter:Window1"
. . .
xmlns:converters="clr-namespace:CustomValueConverter.Converter">

In the next step we create our Converter in our Window’s Resources:

. . .
<Window.Resources>
    <converter:Base64Converter x:Key="base64"/>
</Window.Resources>
. . .

And from now on we can use our Converter everywhere we use DataBinding. For example:

. . .
<TextBlock Text="{Binding Path=Birthday,Converter={StaticResource base64}}"/>
. . .

would give the following result:

You can also pass parameters directly from XAML to a class implementing IValueConverter. This could be useful if you want to e.g. display some DateTime values in your own format.
Therefore we change our Convert()-method in the following way:

public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
     return ((DateTime)value).ToString((string)parameter);
}

Now the DateTime value will be formatted corresponding to our format string we supply as a parameter from XAML. We can declare our parameters like this :

<TextBlock Text="{Binding Path=Birthday,
                  Converter={StaticResource parameterized},
                  ConverterParameter='dd@MM@yyyy'}"/>

what gives us the following result

With ValueConverters you can transform your objects to any representation you want. You’re only limited by your imagination.
The ConvertBack() method of IValueConverter is needed to convert the values from Convert() back to its original representation.
This is necessary especially if you bind some values to TextBoxes (or other value-changing controls) and don’t want your user to use the original representation of your object’s values.