Niezgod's Weblog

C++ : Convertion operators

niezgod — Fri, 24 Sep 2010 09:36:45 +0000

  1: #include 

  2:

  3: class Test

  4: {

  5: public:

  6: 	// convertion from char const *

  7: 	Test( const char * _rhs )

  8: 		: _string( _rhs )

  9: 	{}

 10:

 11: 	// convertion to char const *

 12: 	operator char const * ()

 13: 	{

 14: 		return _string;

 15: 	}

 16:

 17: private:

 18: 	char const * _string;

 19: };

 20:

 21: int main()

 22: {

 23: 	Test instance("ala ma kota");

 24:

 25: 	std::cout << instance << std::endl;

 26:

 27: 	return 0;

 28: }

Test Live Writera Bety

niezgod — Fri, 25 Jun 2010 07:51:26 +0000

Jakiś tam tekst.

Chapter 5. Serialization.

niezgod — Tue, 20 Oct 2009 13:46:26 +0000

1. How to serialize an object.

In order to be able to serialize type it needs to be marked with [Serialized] attribute.

[Serializable]
class ObjectToBeSerialized
{
}

We can serialize such object like this:

  1: using System;

  2: using System.IO;

  3: using System.Runtime.Serialization.Formatters.Binary;

  4:

  5: [Serializable]

  6: class ObjectToBeSerialized

  7: {

  8: }

  9:

 10: class Program

 11: {

 12:     void Serialize()

 13:     {

 14:         ObjectToBeSerialized instance = new ObjectToBeSerialized();

 15:

 16:         using (FileStream stream = File.Create( @"c:/output.bin"))

 17:         {

 18:             BinaryFormatter formatter = new BinaryFormatter();

 19:             formatter.Serialize(stream, instance);

 20:         }

 21:     }

 22: }

2. How to deserialize object.

  1:

  2: using (FileStream stream = File.Open(@"c:/output.bin", FileMode.Open))

  3: {

  4:     BinaryFormatter formatter = new BinaryFormatter();

  5:     ObjectToBeSerialized instance = (ObjectToBeSerialized )formatter.Deserialize(stream);

  6: }

  7:

3. How to handle values that are calculated / do not have to be serialized.

  1: using System.Runtime.Serialization;

  2: using System;

  3:

  4: [Serializable]

  5: class ObjectToBeSerialized : IDeserializationCallback

  6: {

  7:     private int m_value1;

  8:

  9:     [NonSerialized]

 10:     private int m_value2;

 11:

 12:     public ObjectToBeSerialized( int _value1)

 13:     {

 14:         m_value1 = _value1;

 15:         m_value2 = 10; // calculated value

 16:     }

 17:

 18:     public void OnDeserialization(object sender)

 19:     {

 20:         m_value2 = 10;

 21:     }

 22: }

 23:

If we don’t want some fields to be serialized we mark them with [NonSerialized].

If we have some values that are not serialized but have to be initialized we can use IDeserializationCallback interface to handle that.

4. Serialization and version compatibility.

Styles in WPF.

niezgod — Sun, 10 May 2009 11:34:16 +0000

Note on article’s inspiration: Article is based almost entirely on Windows Presentation Foundation Unleashed book which I recommend for all WPF learners.

Content:

1. What is style. Why do I need it?
2. Basic styling scenario.
3. How are elements connected with styles? – Named and typed styles.
4. I have typed style for Control type but it doesn’t work. Not a single subclass of Control has been changed. If I change it to named style everything is ok. What’s wrong? – Differences between named and typed style in target element’s type matching.

1. What is style. Why do I need it?

Style is not something you couldn’t live without. It’s yet another mechanism provided to make your life easier. If in your window you have several buttons and you want them all to have their text displayed in red we could set in each one it’s Foreground property’s value to red. However, since we all know the value of gathering such commonalities in one place we will use styles as a very handy tool in such cases. It’s more less like CSS. If you know CSS you get the idea.

2. Basic styling scenario.

We have a window layout containing several buttons.

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

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

  4:     Vertical">

  5:         
  6:         
  7:     

  8:

We want all buttons to have their text displayed in red so we define style that will do that for us.

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

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

  4:

  5:     

  6:         

  9:     

 10:

 11:     ...

 12:

 13:

And here it is, our first style changing Foreground of all Buttons to red. Generally that’s it. You can add more setters to our style to customize more properties of all Button elements.

3. How are elements connected with styles? – Named and typed styles.

This one is important and at first a bit tricky. There are several ways to tell Button’s element instance that it should use our style.

define so called named style and assign it to each Button’s instance explicitly

First button has it’s style set. Second one will stay unchanged by our style.

  1:     

  2:         

  5:     

  6:

  7:     Vertical">

  8:         
  9:         
 10:     

 11:

define typed style for specific type

In this case all elements of type Button in window’s scope will have our style set implicitly.
You might wonder why our style defined in resources dictionary does not have it’s x:Key set. Well actually it has. It is set implicitly to the value of TargetType attribute.

  1:     

  2:         

  5:     

  6:

  7:     Vertical">

  8:         
  9:         
 10:     

 11:

You can choose the one that suits your needs best. Both have their advantages.

4. I have typed style for Control type but it doesn’t work. Not a single subclass of Control has been changed. If I change it to named style everything is ok. What’s wrong? – Differences between named and typed style in target element’s type matching.

There is one very important, because hard to be figured out, difference between named and typed style. It is about what type they do match and what they don’t.
Let’s look at named style example:

  1:     

  2:         

  5:     

  6:

  7:     Vertical">

  8:         
  9:         Second" Style="{StaticResource controlTemplate}"/>

 10:

In this style we set a Foreground property of Control element. It means that we can set this style to any element that is a subclass of Control and it will still work. This is a very convenient mechanism and it seems to be so natural that when we define typed style like the following we might wonder what’s wrong.

  1:     

  2:         

  5:     

  6:

  7:     Vertical">

  8:         
  9:         Second" />

 10:     

 11:

It seems to have the same meaning as previous named style but there is a fundamental difference in type matching. Typed style matches only elements of exactly the same types. In our case it would be a Control type. WPF Unleashed explains that it was done to avoid surprises. For example, they say, you can create style for ToggleButton but you don’t want it to be applied to CheckBoxes which is an subclass of a ToggleButton. For named style there is no such problem because you apply style explicitly.

How to display list of items – MVVM way.

niezgod — Sun, 03 May 2009 09:02:38 +0000

What is that MVVM anyway?

The preferred way of connecting data with view in WPF applications seems to be MVVM pattern. MVVM stands for ModelViewViewModel. The whole idea behind it is to create a kind of a bridge between your data and logic at one side and view at the other. By using such bridge/buffer we avoid hardwiring our logic with view. It allows us to write application data and logic the way it should be written without taking shortcuts and making compromises just to be able to connect such code with a view. If written properly ViewModel can be unit tested which helps a lot in a world of GUI applications which are usually hard to test.

A little bit of practice.

Let’s start with a view model. What is a view model? For now let’s just think about view model as an object that provides view with whatever it requires in the form that is convenient for a view. Since view works with a few simple elements like properties containing data it can bind to and commands it can invoke these are two basic elements we will expose in out view model instance.

  1:     class MainWindowViewModel

  2:     {

  3:         public MainWindowViewModel()

  4:         {

  5:             People =

  6:                 new List()

  7:                     {

  8:                         new Person("Arek", 31),

  9:                         new Person("Magda", 26)

 10:                     };

 11:         }

 12:

 13:         public IList People { get; set; }

 14:     }

Above we have our view model for main window. It provides view with a list of elements that we will bind to ListView’s control ItemsSource property.

For the sake of completeness of our view model example I have to say a few things about bindings here. Binding, according to MSDN, looks like this:

How our example works? Our binding target is ListView, binding source is MainWindowViewModel. Dependency property ItemsSource is bound in XAML to People property in view model. Our binding is in OneWay mode which means that data updates go only from People property to ItemsSource. Actually then don’t. They would if we implemented INotifyPropertyChanged interface in MainWindowViewModel. After that modification on view model looks like that:

(TODO: insert view model with updated implementation)

Now that we have our data we can move to a view implementation.

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

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

  4:     xmlns:local="clr-namespace:SimpleList">

  5:

  6:     

  7:         viewModel" />

  8:     

  9:

 10:     
 11:         DataContext="{StaticResource viewModel}"

 12:         ItemsSource="{Binding Path=People}" />

 13: 

As you can see we create an instance of our view model in Windows.Resources section and than use it for setting DataContext of ListView control. First effect of our struggles looks like this. 
 

It’s not exactly what we had in mind so what’s wrong? By default list view displays for each item text returned by it’s ToString() method. 
One way to improve it would be like this.
  1:     
  2:         DataContext="{StaticResource viewModel}"

  3:         ItemsSource="{Binding Path=People}">

  4:         

  5:             

  6:                 Name" DisplayMemberBinding="{Binding Name}"/>

  7:                 Age" DisplayMemberBinding="{Binding Age}"/>

  8:             

  9:         

 10:     

And the result:
 
Better, or maybe like this:
  1:     
  2:         DataContext="{StaticResource viewModel}"

  3:         ItemsSource="{Binding Path=People}">

  4:         

  5:             

  6:                 Horizontal">

  7:                     Name:" Margin="10,0,5,0"/>

  8:                     Bold" Text="{Binding Name}"/>

  9:                     Age:" Margin="10,0,5,0"/>

 10:                     Bold" Text="{Binding Age}"/>

 11:                 

 12:             

 13:         

 14:     


As you can see there is a lot of choices. Actually taking into consideration styles, templates, and ExpressionBlend we’ve got countless choices of how to show our data within a control.
Full source code for the article.

How to create WPF application from scratch.

niezgod — Sun, 03 May 2009 07:06:37 +0000

Our goal.

Our goal is to create most basic application in WPF. It is an application so we’ll create an Application instance. It is a WPF so we’ll add some UI element, let it be an empty Window instance.

Project and it’s basic “must have” settings.

First create new empty project. I like to start with an empty one in order to have everything under control. Later on it’s easy to create template out of our simple application and use it instead of doing everything again and again. When you’re done go to project properties and change application type to Windows Application.

Application definition.

Create Application.xaml file with following content.

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

  3:     StartupUri="MainWindow.xaml"

  4:     />

After compiling that project compiler will complain, among other things, about lack of Main method. Visual Studio is able to generate Main method based on that file. In order to do that you have to change in Application.xaml’s properties it’s build action to ApplicationDefinition.
Line two works like a bunch of using statements. It imports a few core namespaces so that we can use core WPF types.
Line two instructs Application object to open resource defined in XAML. We can open resources of type Window of NavigationWindow. 
Window definition.
In our case MainWindow.xaml contains a definition of new Window class which looks like this:
  1: http://schemas.microsoft.com/winfx/2006/xaml/presentation"/>

What we have here is like above: import of core WPF namespaces and definition of new object of class Window.
And that’s it. We’ve got our first GUI application written using WPF library:) I won’t add anything to that example since the core idea was to show the most basic and simple application in WPF. 
Why not even shorter?
It would be even more compact if we could treat Application as something similar to a ContentControl
  1: http://schemas.microsoft.com/winfx/2006/xaml/presentation">

  2:     

  3: 

but Application cannot have any content so we must stick with this two file solution.

How to display list of items.

niezgod — Sun, 03 May 2009 06:42:31 +0000

In order to display a list of items we obviously need two things:

a list of items
some UI control prepared for the task of displaying lists

WPF is quite liberal about what can be our list of items. It can be a Collection or even IEnumerable. Of course it can work with more sophisticated types but more about it some other time.
When choosing a control we should know something about WPF Content Model idea. For our task best one will be a control implementing ItemsControl content model. When we’ve got our data and control the rest is easy. We just need to bind data to control and we do it like this:

Application instance like usually :

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

  3:     StartupUri="View/MainWindow.xaml"

  4:     />

MainWindow that way:
  1: 
  2:     xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

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

  4:     x:Class="SimpleList.MainWindow"

  5:     >

  6:     {Binding Path=Numbers}"/>

  7: 

  1: using System.Collections.Generic;

  2: using System.Windows;

  3:

  4: namespace SimpleList

  5: {

  6:     public partial class MainWindow : Window

  7:     {

  8:         public MainWindow()

  9:         {

 10:             InitializeComponent();

 11:

 12:             Numbers = new List<int>();

 13:

 14:             Numbers.Add(1);

 15:             Numbers.Add(2);

 16:             Numbers.Add(3);

 17:

 18:             this.DataContext = this;

 19:         }

 20:

 21:         public IList<int> Numbers { get; set; }

 22:     }

 23: }

Important things we should remember are:

Content Model idea
DataContext dependency property provided by FrameworkContentElement
the whole data binding mechanism
the fact that we can define part of a class as partial class and e.g. set DataContext property that way

How to create class partially in XAML and partially in code?

niezgod — Sat, 02 May 2009 17:55:49 +0000

C# supplies us with a nice feature allowing to create such splitted class definition. It’s called partial class. Partial classes were added to allow for an easy integration with generated code. For example managed C++ does not support it (some say it is a good thing) which makes it much harder to use WPF with this language.

In our case it would look like this.

  1: 
  2:     xmlns="http://schemas.microsoft.com/netfx/2007/xaml/presentation"

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

  4:     x:Class="DatabaseGui.MainWindow"

  5:     >

  6:

  7: 

  8: 

  1: namespace Database

  2: {

  3:     public partial class MainWindow : Window

  4:     {

  5:         public MainWindow()

  6:         {

  7:             InitializeComponent();

  8:         }

  9:     }

 10: }

From code’s perspective what is important is this partial keyword telling compiler that it is only a partial definition of MainWindow class. Compiler will look for all parts of that class and join them together.
For XAML’s perspective we can omit x:Class attribute. It has more less the same meaning as partial keyword used in code.
If we use x:Class in our XAML than, during XAML compilation new file MainWindow.g.cs is created. It contains automatically generated partial class for our MainWindow that does a lot of useful magic behind the scene. It contains a private field for any named element defined in XAML (that’s why you can use such elements so easy in your code-behind). It also contains InitializeComponent method that loads BAML resource, assigns fields to appropriate instances originally declared in XAML, and hook up events if any were specified in XAML. That is why it is so important to call InitializeComponent in MainWindow’s constructor.

O yeah!

niezgod — Sun, 08 Mar 2009 17:28:40 +0000

No, to teraz zobaczymy. Zainstalowałem właśnie plugin Insert Code do Live Writera. Ciekawe jak to się będzie sprawować.

   1:  using System.Windows;

   2:  using System;

3:

   4:  namespace ListBoxApp

   5:  {

   6:      class Program : Application

   7:      {

   8:          [STAThread]

   9:          static void Main()

  10:          {

  11:              Program program = new Program();

  12:              program.Run( new MainWindow() );

  13:          }

  14:      }

  15:  }

.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, “Courier New”, courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }

Hmm, jakiejś rewelacji nie widzę, ale bez przesady. W końcu chodzi o to żeby coś w końcu napisać na tym blogu, a nie w nieskończoność szukać idealnego syntax higlightera.

No to git. Sprawę uznajemy za załatwioną.

Test post.

niezgod — Sat, 07 Mar 2009 21:27:09 +0000

This is just an example post to check how wordpress.com is able to handle c# source code. I’ve been trying to get it working for some time now but it looks like there is no way to do it easly. It’s a pity wordpress.com doesn’t have SyntaxHighlighter script from Alex Gorbatchev installed. It’d be so nice and easy. Anyway it’s not installed so we need to do it some other way.
Let’s find out what the output of http://dotnetslackers.com/articles/csharpformat.aspx looks like.

using System.Windows;
using System;

namespace ListBoxApp
{
    class Program : Application
    {
        [STAThread]
        static void Main()
        {
            Program program = new Program();
            program.Run( new MainWindow() );
        }
    }
}