Typ wyliczeniowy:

[Flags]
enum Flavour
{
    [Description("black chocolate")]
    Chocolate = 1 << 0,

    [Description("vanilla")]
    Vanilla = 1 << 2,

    [Description("cherry")]
    Cherry = 1 << 3,

    [Description("coffee")]
    Coffee = 1 << 4,
}

Użycie EnumDescriptionConverter:

var converter = new EnumDescriptionConverter(typeof(Flavour));

// Convert string to enum. 
string enumStr = "black chocolate, cherry, coffee";
Flavour flavour = (Flavour)converter.ConvertFromString(enumStr);

// Convert enum to string. 
enumStr = converter.ConvertToString(flavour);
Console.WriteLine(enumStr);

Post na blogu All-In-One Code Framework z kodem źródłowym i opisem: http://blogs.msdn.com/b/codefx/archive/2012/04/05/sample-of-apr-5th-c-vb-enum-string-converter.aspx

All-In-One Code Framework na CodePlex: http://1code.codeplex.com/

Rozszerzenie do Visual Studio: http://visualstudiogallery.msdn.microsoft.com/b3aaa8f6-1b72-4ce2-bb39-f597489d55da

W jaki sposób udostępnić UI aplikacji WPF w różnych językach:

1. Edycja .csproj (dodanie tagu UICulture):

 <PropertyGroup>
    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
	<UICulture>en-US</UICulture>

2. Edycja AssemblyInfo.cs (dodanie "neutralnych zasobów"):

[assembly: NeutralResourcesLanguage("en-US", UltimateResourceFallbackLocation.Satellite)]

3. Stworzenie "UI localization IDs" dla plików .xaml:

msbuild /t:updateuid ProjectName.csproj

...
<Label x:Uid="Label_1">Hello</Label>
...

4. Stworzenie pliku .csv z tłumaczeniami przy pomocy narzędzia LocBaml.

msbuild LocBaml_SDK.csproj

LocBaml.exe /parse en-US\AssemblyName.resources.dll /out:en-US.csv

...
WpfApplication1.g.en-US.resources:mainwindow.baml,Label_1:System.Windows.Controls.Label.$Content,Label,True,True,,Hello:
...

5. Tłumaczenie na inny język:

LocBaml.exe /generate en-US\AssemblyName.resources.dll /trans:fr-CA.csv /out:fr-CA /cul:fr-CA

public partial class App : Application
{
    public App()
    {
        CultureInfo ci = new CultureInfo("fr-CA");
        Thread.CurrentThread.CurrentCulture = ci;
        Thread.CurrentThread.CurrentUICulture = ci;
    }
}

using System;
using System.Windows.Data;
using System.Windows;
using System.Threading;
using System.Globalization;

namespace IValueConverterExample
{
    public class Person
    {
        public string Name { get; set; }
    }

    [ValueConversion(typeof(string), typeof(Person))]
    public class PersonConverter : IValueConverter
    {
        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
        {
            return new Person { Name = value.ToString() };
        }

        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
        {
            return ((Person)value).Name;
        }
    }

    class Program
    {
        static void Main()
        {
            var converter = new PersonConverter();
            var converted = (Person) converter.Convert("Jan", typeof(Person), null, Thread.CurrentThread.CurrentCulture);

            string convertedBack = (string) converter.ConvertBack(converted, typeof(string), null, Thread.CurrentThread.CurrentCulture);
        }
    }
}

<Window x:Class="WpfApplication1.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="MainWindow" Height="350" Width="525"
        xmlns:src="clr-namespace:WpfApplication1"
        >
    <Window.Resources>
        <src:Person x:Key="myDataSource" Name="Joe"/>
    </Window.Resources>
    
    <StackPanel>
        <TextBox>
            <TextBox.Text>
                <Binding Source="{StaticResource myDataSource}" 
                         Path="Name"
                    UpdateSourceTrigger="PropertyChanged"/>
            </TextBox.Text>
        </TextBox>

        <TextBlock Text="{Binding Source={StaticResource myDataSource}, Path=Name}"/>
    </StackPanel>
</Window>

namespace WpfApplication1
{
    public class Person
    {
        public string Name { get; set; }
    }
}

using System;
using System.Windows.Data;
using System.Windows;

namespace CollectionViewExample
{
    public class Person : DependencyObject
    {
        public static readonly DependencyProperty NameProperty =
            DependencyProperty.Register("Name", typeof(string), typeof(Person));

        public string Name
        {
            get { return (string) GetValue(NameProperty); }
            set { SetValue(NameProperty, value); }
        }
    }

    class Program
    {
        static void Main()
        {
            // support styling, data binding, inheritance, animations, and default values
            // callbacks, validation

            var p = new Person();
            p.Name = "A";
        }
    }
}

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel; 
using System.Collections.Specialized;
using System.ComponentModel;
using System.Windows.Data;

namespace CollectionViewExample
{
    public class Person
    {
        private string name;

        public Person(string name)
        {
            this.name = name;
        }

        public string Name
        {
            get { return name; }
            set { name = value; }
        }
    }

    class Program
    {
        static void Main()
        {
            var collView = new CollectionView(
                new List<Person>()
                {
                    new Person("A"),
                    new Person("B"),
                    new Person("C"),
                    new Person("D"),
                    new Person("E")
                });
           
            // Navigate
            Console.WriteLine("Current person is: {0}", ((Person)collView.CurrentItem).Name);
            collView.MoveCurrentToNext();
            Console.WriteLine("Current person is: {0}", ((Person)collView.CurrentItem).Name);
            
            // Result:
            //Current person is: A
            //Current person is: B

            // Filter
            collView.Filter = o => 
            { 
                if (o is Person) 
                {
                    return ((Person)o).Name == "A";
                } 
                return false; 
            };

            foreach (var item in collView)
                Console.WriteLine(((Person)item).Name);

            // Result:
            // A

            // Undo filtering
            collView.Filter = null;

            foreach (var item in collView)
                Console.WriteLine(((Person)item).Name);

            // Result:
            //A
            //B
            //C
            //D
            //E

            Console.WriteLine(collView.CanSort); // Zawsze false (override w klasach potomnych)!
            Console.WriteLine(collView.CanGroup); // Zawsze false (override w klasach potomnych)!
        }
    }
}

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel; 
using System.Collections.Specialized;

namespace ObservableCollectionExample
{
    public class Person
    {
        private string name;

        public Person(string name)
        {
            this.name = name;
        }

        public string Name
        {
            get { return name; }
            set { name = value; }
        }
    }

    class Program
    {
        static void Main()
        {
            var list = new ObservableCollection<Person>();
            list.Add(new Person("John"));
            list.CollectionChanged += new NotifyCollectionChangedEventHandler(list_CollectionChanged);
            list.Add(new Person("Sydney"));

            // Result:
            //Collection has been changed.
            //Action was Add
            //Sydney
        }

        static void list_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
        {           
            Console.WriteLine("Collection has been changed.");
            Console.WriteLine("Action was {0}", e.Action);

            foreach (object o in e.NewItems)
                Console.WriteLine(((Person)o).Name);
        }
    }
}

using System;
using System.Collections.Generic;
using System.ComponentModel; // INotifyPropertyChanged

namespace INotifyPropertyChangedExample
{
    public class Person : INotifyPropertyChanged
    {
        #region INotifyPropertyChanged members
        public event PropertyChangedEventHandler PropertyChanged;
        #endregion

        private void NotifyPropertyChanged(string info)
        {
            if (PropertyChanged != null)
            {
                PropertyChanged(this, new PropertyChangedEventArgs(info));
            }
        }

        private string name;

        public string Name
        {
            get { return this.name; }

            set
            {
                if (value != this.name)
                {
                    this.name = value;
                    NotifyPropertyChanged("Name");
                }
            }
        }
    }

    class Program
    {
        static void Main()
        {
            var p = new Person();
            p.PropertyChanged += new PropertyChangedEventHandler(p_PropertyChanged);

            p.Name = "dsdsds";

            // Result:
            // Name has been changed.
        }

        static void p_PropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            Console.WriteLine(e.PropertyName + " has been changed.");
        }
    }
}

Setup:

$ git config --global user.name "Firstname Lastname"
$ git config --global user.email "your_email@youremail.com"

git config --global core.editor 
"'C:\Program Files (x86)\Notepad++\notepad++.exe' 
-multiInst -notabbar -nosession -noPlugin"

$ git config --global core.autocrlf true

git config --get user.name

mkdir [Nazwa]
cd [Nazwa]
git init
touch README
git add README
git commit -m 'first commit'
git remote add origin git@github.com:user/Project.git
git push -u origin master

git clone git://... mydir

git status

git push [remote-name] [branch-name]
na przykład:
git push origin master

git pull [remote-name] [branch-name]

git commit -a -m 'Commit message'

git commit --amend
git commit --amend -m 'New commit message'

git tag -a v1.4 -m 'my version 1.4'

git push --tags

git rm 
git rm --cached 

git mv [from] [to]

git log
git log -p -2   - diff only 2
git log --stat
git log --pretty-oneline
git log --pretty --graph

git reset HEAD [filename]

git branch

git branch -r

git branch -a

git chechout -b branchname
=
git branch branchname
git chechout branchname

git checkout master
git merge branchname

git branch -d hotfix

git checkout 

$ git reset HEAD <file>

git remote show origin

git checkout -- <file>