Code Arsenal - .NET Tutorials and Code Samples

Singleton Design Pattern C# Example

2013-04-19T20:16:00.001+03:00

Singleton is one of the most frequently used Design Patterns in Software Engineering. You should apply Singleton pattern if you want to ensure that your class will have only one instance with a global point of access to it.

Let's look at Singleton code:

public sealed class Singleton
{
   private static readonly Singleton instance = new Singleton();
   
   private Singleton(){}

   public static Singleton GetInstance
   {
      get 
      {
         return instance; 
      }
   }
}

As you can see the code is pretty simple. Class is defined as sealed in order to prevent derivation. Also Singleton variable is marked readonly, which means that it can be assigned only during static initialization or in a constructor.

This approach has only one downside - it's not thread safe. This code must be improved if you work in multithreaded environment.

Here is a thread safe version of Singleton:

public sealed class Singleton
{
   private static volatile Singleton instance;
   private static object sync = new Object();

   private Singleton() {}

   public static Singleton GetInstance
   {
      get 
      {
         if (instance == null) 
         {
            lock (sync) 
            {
               if (instance == null) 
                  instance = new Singleton();
            }
         }

         return instance;
      }
   }
}

In this version of Singleton we resolved thread concurrency problems, so you can use it in multithreaded environment.

Factory Design Pattern C# Example

2013-04-06T16:26:00.002+03:00

Factory it's such a Design Pattern which defines an interface for creating an object, but lets the classes that implement the interface decide which class to instantiate. Factory Pattern lets a class postpone instantiation to sub-classes.

Let's see Factory Pattern in action on a simple example. Assume you have two different classes Toyota and Suzuki, they both implements abstract class Car. You need to instantiate one of these classes, but you don't know which of them, it depends on user. This is perfect scenario for the Factory Pattern.

So here are our two main classes and the interface (abstract class):

abstract class Car
{
    public abstract string Company { get; }
    public abstract string Model { get; set; }
    public abstract int Speed { get; set; }
}

class Suzuki : Car
{
    private readonly string _company;
    private string _model;
    private int _speed;

    public Suzuki(string model, int speed)
    {
        _company = "Suzuki";
        _model = model;
        _speed = speed;
    }

    public override string Company
    {
        get { return _company; }
    }

    public override string Model
    {
        get { return _model; }
        set { _model = value; }
    }

    public override int Speed
    {
        get { return _speed; }
        set { _speed = value; }
    }
}

class Toyota : Car
{
    private readonly string _company;
    private string _model;
    private int _speed;

    public Toyota(string model, int speed)
    {
        _company = "Toyota";
        _model = model;
        _speed = speed;
    }

    public override string Company
    {
        get { return _company; }
    }

    public override string Model
    {
        get { return _model; }
        set { _model = value; }
    }

    public override int Speed
    {
        get { return _speed; }
        set { _speed = value; }
    }
}

Abstract CarFactory class is an interface for our ToyotaFactory and SuzukiFactory classes that will be responsible for the instantiation of corresponding car, therefore they only have one single GetCar() method.

abstract class CarFactory
{
    public abstract Car GetCar();
}

class ToyotaFactory : CarFactory
{
    private string _model;
    private int _speed;

    public ToyotaFactory(string model, int speed)
    {
        _model = model;
        _speed = speed;
    }
    public override Car GetCar()
    {
        return new Toyota(_model, _speed);
    }
}

class SuzukiFactory: CarFactory
{
    private string _model;
    private int _speed;

    public SuzukiFactory(string model, int speed)
    {
        _model = model;
        _speed = speed;
    }

    public override Car GetCar()
    {
        return new Suzuki(_model, _speed);
    }
}

What is left is only CarAssembler class which will create needed type of car depending on the factory that it receives as parameter.

class CarAssembler
{
    public void AssembleCar(CarFactory factory)
    {
        Car car = factory.GetCar();
        Console.WriteLine("{0} {1} assembled successfully. Maximum speed is {2} mph", 
            car.Company, car.Model, car.Speed);
    }
}

That's all! Now you can instantiate corresponding car object depending on user input:

static void Main(string[] args)
{
    CarFactory factory = null;
    Console.WriteLine("Which car you would like to build?");
    string car = Console.ReadLine();
    if (car == "toyota")
        factory = new ToyotaFactory("Corolla", 130);
    else
        factory = new SuzukiFactory("Swift", 110);

    new CarAssembler().AssembleCar(factory);
}

Here is the program output:

Download the source code (Visual Studio 2012 project).

Managing Dependency Injection in C# with Autofac

2013-03-31T15:28:00.002+03:00

Dependency Injection in software engineering is a specific form of invasion of control. Conventionally, when an object needs access to a particular service, this object takes responsibility for access to this service. Commonly, an object receives a link to the service location or appeals to some "service locator" and requests a reference to the implementation of a specific type of service. When implementing Dependency Injection, object simply provides a property that is able to keep a reference to the type of service, and when the object is created, a reference to the implementation of the desired type of service is automatically inserted into the property (field). Dependency Injection is more flexible because it becomes easier to create alternative implementations of this type of service, and then specify exactly which implementation should be used, for example in the configuration file, with no changes in the objects that use this service. This is especially useful in unit testing.

Today I'll show a simple example of managing dependency injection with Autofac. Autofac is an Inversion of Control Container for .NET. It helps to manage dependencies between classes so that applications stay easy to change as they grow in size and complexity. This achieved by treating regular .NET classes as components. You can download Autofac from here.

Our example application is a console program that checks a list of employees and notifies which of them are experts (work experience more than 10 years).

Here is our Employee class:

class Employee
{
    public string Name { get; set; }
    public string Position { get; set; }
    public int Experience { get; set; }
}

EmployeeObserver class is the core of the application, its main purpose is to find employees that satisfy our condition - their work experiences is more than ten years.

class EmployeeObserver
{
    readonly IList<Employee> _employees;
    readonly IEmployeeNotifier _notifier;

    public EmployeeObserver(IList<Employee> employees, IEmployeeNotifier notifier)
    {
        _employees = employees;
        _notifier = notifier;
    }

    // find employees with more than 10 years of experience
    public void FindExperts()
    {
        var experts = _employees.Where(e => e.Experience > 10);

        foreach (var e in experts)
            _notifier.PrintExperts(e);
    }
}

Now we need to create a Printer class which will be responsible for printing out messages to a TextStream. Printer will implement IPrinter interface.

interface IPrinter
{
    void PrintExperts(Employee employee);
}

class Printer : IPrinter
{
    private readonly TextWriter _textWriter;

    public Printer(TextWriter writer)
    {
        _textWriter = writer;
    }

    public void PrintExperts(Employee employee)
    {
        _textWriter.WriteLine("Employee {0} is an expert.", employee.Name);            
    }
}

Now all set for Dependency Injection. As you can see we can make Dependency Injection by hand, without Autofac:

var di = new EmployeeObserver(employees, new Printer(Console.Out));
di.FindExperts();

In fact this code looks very simple, but in real application with many layers and all kind of components configuring dependency injection by hand will become very complex. Dependency injection containers, such as Autofac, bring order to this world of chaos. Let's see how we use it:

ContainerBuilder autofac = new ContainerBuilder();
autofac.Register(o => new EmployeeObserver(o.Resolve<IList<Employee>>(), o.Resolve<IPrinter>()));
autofac.RegisterType<Printer>().As<IPrinter>();
autofac.RegisterInstance(employees).As<IList<Employee>>();
autofac.RegisterInstance(Console.Out).As<TextWriter>();
using (var container = autofac.Build())
{
    container.Resolve<EmployeeObserver>().FindExperts();
}

May be on this particular example it's hard to see why this approach is better than configuring dependency injection by hand, but you should notice one important thing - with Autofac each component is configured independently of all the others, and this is what will make a big difference when your application become more complex.

Download the source code (Visual Studio 2012 project).

C# Object-to-Object Mapping - AutoMapper Example

2012-12-24T17:56:00.002+02:00

Imaging this scenario: We have an Employee object with many properties in it, and we want to display our Employee in a DataGrid or some other control. For this purpose we need a lighter version of Employee, let's call it EmployeeViewItem. A list of EmployeeViewItem will need to bind to our DataGrid.

public class Employee
{
    public string Name { get; set; }
    public string Email { get; set; }
    public Address Address { get; set; }
    public string Position { get; set; }
    public bool Gender { get; set; }
    public int Age { get; set; }            
    public int YearsInCompany { get; set; }
    public DateTime StartDate { get; set; }
}

public class Address
{
    public string Country { get; set; }
    public string City { get; set; }
    public string Street { get; set; }
    public int Number { get; set; }            
}

public class EmployeeViewItem
{
    public string Name { get; set; }
    public string Email { get; set; }
    public string Address { get; set; }
    public string Position { get; set; }
    public string Gender { get; set; }
    public int Age { get; set; }            
    public int YearsInCompany { get; set; }
    public string StartDate { get; set; }
}

Ok, so what we usually do? Something like this, right?

EmployeeViewItem viewItem = new EmployeeViewItem();
viewItem.Name = employee.Name;
viewItem.Email = employee.Email;
viewItem.Address = employee.Address.City + employee.Address.Street + employee.Address.Number;
viewItem.Position = employee.Position;
viewItem.Gender = employee.Gender == true ? "Man" : "Female";
viewItem.Age = employee.Age;
viewItem.YearsInCompany = employee.YearsInCompany;
viewItem.StartDate = employee.StartDate.ToShortDateString();

Quite annoying, isn't it? What if we could do this mapping automatically in some way? I hasten to please you - yes, you can map these two object automatically with AutoMapper! As written on AutoMapper webpage - "AutoMapper is a simple little library built to solve a deceptively complex problem - getting rid of code that mapped one object to another."

I'll show how to use AutoMapper on our Employee to EmployeeViewItem mapping example.
First, download AutoMapper from here. It's a standalone assembly, so you'll need to add reference to it in your project.

In order to tell to AutoMapper what exactly to map we need to write this line of code:

Mapper.CreateMap<Employee, EmployeeViewItem>();

And to actually perform the mapping we write this thing:

EmployeeViewItem employeeViewItem = Mapper.Map<Employee, Employee>(employee);

Where employee is an object of Employee class. This is it!

But, as you probably noticed, our EmployeeViewItem class has several inconsistencies with Employee class. Address is a complex object in Employee, but a simple string in EmployeeViewItem. Gender is boolean in Employee, but is a string in EmployeeViewItem. StartDate is a DateTime in Employee, but a string in EmployeeViewItem. So, we need to do some tweaks to CreateMap method in Mapper. The final code will look like this:

class Program
{
    static void Main(string[] args)
    {
        Mapper.CreateMap<Employee, EmployeeViewItem>()
           .ForMember(ev => ev.Address, 
                       m => m.MapFrom(a => a.Address.City + ", " + 
                                           a.Address.Street + " " + 
                                           a.Address.Number)
                      )
           .ForMember(ev => ev.Gender, 
                       m => m.ResolveUsing<GenderResolver>().FromMember(e => e.Gender))
           .ForMember(ev => ev.StartDate, m => m.AddFormatter<DateFormatter>());

        Employee employee = new Employee
        {
            Name = "John SMith",
            Email = "john@codearsenal.net",
            Address = new Address
            {
                Country = "USA",
                City = "New York",
                Street = "Wall Street",
                Number = 7
            },
            Position = "Manager",
            Gender = true,
            Age = 35,                
            YearsInCompany = 5,
            StartDate = new DateTime(2007, 11, 2)
        };
        
        EmployeeViewItem employeeVIewItem = Mapper.Map<Employee, EmployeeViewItem>(employee);            
    }        

    public class GenderResolver : ValueResolver<bool, string>
    {
        protected override string ResolveCore(bool source)
        {
            return source ? "Man" : "Female";
        }
    }

    public class DateFormatter : IValueFormatter
    {
        public string FormatValue(ResolutionContext context)
        {
            return ((DateTime)context.SourceValue).ToShortDateString();
        }
    }
}

Voila! Employee object successfully mapped to EmployeeViewItem:

Download the source code (Visual Studio 2012 project).

C# Reading XML Recursively (XmlDocument)

2012-12-01T16:31:00.001+02:00

I'll be honest - I hate Recursion! But, nothing you can do, there are some situations when you know - this problem should be solved with Recursion. One of such problems is XML reading.

Today I'll show a simple example of reading XmlDocument recursively.

This is our XML:

<employees>
    <employee Id="1001" Name="John" Position="Developer">    
        <projects>
            <project Code="Rocket">                
                <budget>7000</budget>
            </project>
        </projects>
    </employee>

    <employee Id="1002" Name="Tomas" Position="Helpdesk">    
        <projects>
            <project Code="Orlando">                
                <budget>1000</budget>
            </project>
            <project Code="Newman">                
                <budget>900</budget>
            </project>
        </projects>
    </employee>
    
    <employee Id="1003" Name="Susan" Position="QA">        
        <projects>            
            <project Code="Newman">                
                <budget>900</budget>
            </project>
            <project Code="Rocket">                
                <budget>7000</budget>
            </project>
            <project Code="Orlando">                
                <budget>1000</budget>
            </project>
        </projects>
    </employee>  
</employees>

And, for example, I want to print the names of employees that participated in Orlando project. Of course, this task could be done with LINQ, but this time we want to see some recursion, right? :) Here is the code:

static void Main(string[] args)
{
    XmlDocument doc = new XmlDocument();
    doc.Load("../../Employees.xml");
    XmlNode root = doc.SelectSingleNode("*"); 
    ReadXML(root);
}

private static void ReadXML(XmlNode root)
{
    if (root is XmlElement)
    {
        DoWork(root);

        if (root.HasChildNodes)
            ReadXML(root.FirstChild);
        if (root.NextSibling != null)
            ReadXML(root.NextSibling);
    }
    else if (root is XmlText)
    {}
    else if (root is XmlComment)
    {}
}

private static void DoWork(XmlNode node)
{
    if (node.Attributes["Code"] != null)
        if(node.Name == "project" && node.Attributes["Code"].Value == "Orlando")
            Console.WriteLine(node.ParentNode.ParentNode.Attributes["Name"].Value);
}

So, I go over each XmlNode by calling XMLRead method. Of course, we need some logic, which is in DoWork method. Inside the XMLRead method I specified that I'm interesting only in XmlElement. As you can see from the source code, you can specify not only XmlElement, but also XmlComment or other XmlNode type, if you need. All this stuff looks very simple until you starting to remove XML elements. Don't forget that once you removed an XML node, the whole XML structure is changed.

Download the source code (Visual Studio 2012 project).

WPF Start New Background Process using Task

2012-11-24T15:20:00.000+02:00

In GUI programming there is exist some very common problem - if some operation takes too much time the GUI will become unresponsive. For example, if you want establish connection with a server, or fetch some data from database or a large file, this probably will take some time and if you perform this operation in the main thread your GUI will stuck. In order to keep your GUI responsive you need to run long-running operations on a separate thread. So far, in order to open a new thread we used Thread class or BackgroundWorker. Starting from .NET Framework 4.0 we have a Task class for this purpose.

If you already switched to Visual Studio 2012 with Framework 4.5 then read my previous post - C# Async Programming Example in WPF (Async, Await).
If you still working with Visual Studio 2010 Framework 4.0 then this post is for you.
Today I'll show how to build WPF application with background thread using Task Framework 4.0.

Ok, let's say we have a WPF application with a button which triggers some long-running method.

Here is the XAML:

<Window x:Class="WpfTask.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="CodeArsenal.net" Height="200" Width="300">
    
    <DockPanel Margin="4">
        <Button Name="buttonNewTask" Height="50" 
                Content="New Task" DockPanel.Dock="Top" 
                Click="buttonNewTask_Click"/>

        <TextBox Name="textBoxResults" DockPanel.Dock="Bottom" Margin="0,10,0,0"
                 TextWrapping="Wrap"
                 FontFamily="Lucida Console" 
                 FontSize="10"
                 AcceptsReturn="True"/>
    </DockPanel>
</Window>

So, by pressing on buttonNewTask we call for buttonNewTask_Click method. Now we want run this method in separate thread and after the method is completed we want to show the result. This is how to do it in .NET Framework 4.0 using Task:

private void buttonNewTask_Click(object sender, RoutedEventArgs e)
{
    textBoxResults.Text = "Working...";
    buttonNewTask.IsEnabled = false;

    TaskScheduler scheduler = TaskScheduler.FromCurrentSynchronizationContext();
    CancellationToken cancelationToken = new CancellationToken();

    string result = "";
    Task.Factory.StartNew(() => GetResultFromServer(out result)).
        ContinueWith(w =>
        {
            textBoxResults.Text = result;
            buttonNewTask.IsEnabled = true;
        },
        cancelationToken,
        TaskContinuationOptions.None, scheduler);
}

private void GetResultFromServer(out string result)
{
   Thread.Sleep(2500);
   result = "Data received.";
}

Task.Factory.StartNew actually starts a mew thread. I specified GetResultFromServer as the one which will run in new thread. Inside ContnueWith block we put everything that should run after the GetResultFromServer is complete - printing the result and enabling the button. We don't use CancelationToken in this particular example, but its mandatory to specify it. We also must declare the TaskScheduler which tells to Task Framework what our GUI thread is, so it know when to run the the final update.

Download the source code (Visual Studio 2010 project).

C# Async Programming Example in WPF (Async, Await)

2012-11-18T16:40:00.000+02:00

C# 5.0 and .NET Framework 4.5 bring to developer a very nice feature called Asynchronous Programming. Asynchronous Programming is based on Task Parallel Library (TPL). As you probably know traditional techniques for writing asynchronous programs are very complicated in many aspects, so Async Programming comes to make our life easier when we write Multithreading applications.

Today we'll see a very simple example of Async Programming using Async, Await and Task keywords in WPF application. Let's build a simple WPF application with a button and a textbox. By pressing the button we call for some slow method (I named it SlowDude :). I don't want GUI will be locked until the method will finish his job. In other words I want to call that method asynchronously.

Ok here is our simple XAML:

<Window x:Class="WpfAsync.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="CodeArsenal.net" Height="180" Width="360">

    <DockPanel>
        <Button Name="buttonAsync" Height="50" Content="Async Example" 
                DockPanel.Dock="Top" Click="buttonAsync_Click"/>
        
        <TextBox Name="textBoxResults" DockPanel.Dock="Bottom" Margin="0,20,0,0"
                 TextWrapping="Wrap"
                 FontFamily="Lucida Console" 
                 FontSize="10"
                 AcceptsReturn="True"/>
    </DockPanel>
</Window>

So, as you can see, by clicking on the button we will fire buttonAsync_Click method.
Let's see now the code behind:

private async void buttonAsync_Click(object sender, RoutedEventArgs e)
{
    buttonAsync.IsEnabled = false;
    
    var slowTask = Task<string>.Factory.StartNew(() => SlowDude());
    
    textBoxResults.Text += "Doing other things while waiting for that slow dude...\r\n";
    
    await slowTask;
    
    textBoxResults.Text += slowTask.Result.ToString();
    
    buttonAsync.IsEnabled = true;
}

private string SlowDude()
{
    Thread.Sleep(2000);
    return "Ta-dam! Here I am!\r\n";
}

Did you notice the async modifier in buttonAsync_Click method signature? This is crucial, because async modifier tells to compiler that this method contains code that will run asynchronously using await keyword.

Following code line actually calls for SlowDude method in asynchronous manner:

var slowTask = Task<string>.Factory.StartNew(() => SlowDude());

Ok now let's look on following line:

await slowTask;

This command means - do other stuff that are between these two lines of code, without locking the main thread, and once SlowDude is finished proceed further.

Well, I think, Async Programming is a great thing, and will make our life a lot easier when it comes to Multithreading problems. Well done, Microsoft!
Download the source code (Visual Studio 2012 project).

If you still working with Visual Studio 2010 Framework 4.0 then take a look at this post - WPF Start New Background Process using Task

C# Application Performance Wizard in Visual Studio

2012-11-16T18:29:00.000+02:00

If you want to know how much resources your C# application consumes there is a very nice tool in Visual Studio for this purpose. It allows you to see how much CPU your program uses, amount of memory allocated for it, how much time your program running and many other useful things. Today I'll show how to build a performance test for your C# program in Visual Studio.

Ok, let's suppose we've created some C# application in Visual Studio. In order to run Performance Wizard go to main menu and click on Analyze and Launch Performance Wizard.

You'll see Performance Wizard first page where you can choose desired profiling method. Usually we want to know CPU consuming or Memory allocation. Choose your profiling method and click Next.

On the second page you can choose specific target project for profiling or even some external executable if you need it. Click Next.

On the third page, Performance Wizard asks you if you wish to launch profiling process after pressing Finish button. Check the check-box and press Finish.

Here what you'll see if you choose CPU Sampling:

If you choose .NET Memory Allocation this is what you'll see:

If click on Show Hot Lines you'll see detailed information about each method of your program:

Another useful feature is Trimmed Call Tree:

7 Regular Expressions a C# Developer Must Know

2012-11-09T21:05:00.002+02:00

Regular expressions, aka Regex, are very commonly used by any developer no matter what language he's writing his program. Today I'll show the most useful Regex that sooner or later you will need them.

1. URL Regex:

^(https?:\/\/)?([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w \.-]*)*\/?$

Match:
http://www.codearsenal.net/

Not Match:
http://www.codearsenal.net?/

2. IP Address Regex:

^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$

Match:
73.180.213.135

Not Match:
255.255.255.256

3. Email Address Regex:

^([a-z0-9_\.-]+)@([\da-z\.-]+)\.([a-z\.]{2,6})$

Match:
john@codearsenal.net

Not Match:
john@gmail?com

4. Username Regex:

^[a-z0-9_-]{3,16}$

Match:
john_detroit-13

Not Match:
this-username-is-too-long

5. Password Regex:

^.*(?=.{8,})(?=.*\d)(?=.*[a-z])(?=.*[A-Z])(?=.*[_!@#$%^&+=]).*$

Description:

Password length must be at least 8 characters.
Password must contain at least one lower case letter, at least one upper case letter and at least one special character.
Allowed aspecial characters: _!@#$%^&+=

Match:
paSS_123

Not Match:
weak_pass

6. Between Two Characters Regex:

(?<=\[)(.*?)(?=\])

Description:
Gets a string that is between two specific characters without including them, in our case these are two brackets.

Match:
[anything between these brackets]

Not Match:
no brackets here

7. File Extension Regex:

([^\s]+(\.(?i)(jpg|png|gif|bmp))$)

Description:

Any file name with specific extension, in our case these are image files.
Allowed extensions: jpg, png, gif or bmp
You can change the allowed extensions in the regex on those what you need.

Match:
MyPicture.bmp

Not Match:
app.xaml

When you want to test your Regex I suggest to use Rubular online tool. It has user friendly interface and what I like the most in it is that it's showing the matching result on the fly.

And this is an example of how to use Regex in C#:

IsMatch Method:

string regexPattern = @"([^\s]+(\.(?i)(jpg|png|gif|bmp))$)";

if (Regex.IsMatch(testString, regexPattern))
    Console.WriteLine("This is an image file name.");
else
    Console.WriteLine("This is not an image file name.");

Match Method:

Regex regex = new Regex(@"([^\s]+(\.(?i)(jpg|png|gif|bmp))$)");
Match match = regex.Match(testString);

if (match.Success)
    Console.WriteLine(match.Groups[1].Value);

WPF ObjectDataProvider - Binding Enum to ComboBox

2012-11-03T22:21:00.000+02:00

Let's say we created some Enum data type. Now we want to show our Enum values on WPF ComboBox or ListBox. How do we do that?

In order to achieve this, in WPF we have an ObjectDataProvider class which provides mechanism for creation a XAML object available as a binding source.
Here is our Enum:

public enum TimePeriods
{
    Year,
    Month,
    Day,
    Hour,
    Minute
}

Now let's see how we bind it to a ComboBox in XAML:

<Window x:Class="WPFObjectDataProvider.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:sys="clr-namespace:System;assembly=mscorlib"
        xmlns:local="clr-namespace:WPFObjectDataProvider"
        Title="CodeArsenal.Net" Height="59" Width="266">
    <Window.Resources>

        <ObjectDataProvider x:Key="timePeriodsFromEnum"
                            MethodName="GetValues" 
                            ObjectType="{x:Type sys:Enum}">
            <ObjectDataProvider.MethodParameters>
                <x:Type TypeName="local:TimePeriods"/>
            </ObjectDataProvider.MethodParameters>
        </ObjectDataProvider>

    </Window.Resources>
    
    <Grid>
        <ComboBox ItemsSource="{Binding Source={StaticResource timePeriodsFromEnum}}">
        </ComboBox>
    </Grid>
</Window>

As you can see in the code above I added ObjectDataProvider to WIndow.Resources. The GetValues() method gets an array of the values in an Enum. Since Enum is part of mscorlib assembly we must add a reference to it in our XAML. Finally we bind our static Enum resource to ItemSource of the ComboBox. This is what we have when we run the application:

Download the source code (Visual Studio 2010 Project).

C# Writing Custom Configuration Settings Section

2012-10-20T17:29:00.003+02:00

Almost every C# application has its own Configuration Settings file also known as App.Config. If you look on your App.Config file you probably will see a list of key value pairs:

<add key="key0" value="value0" />
<add key="key1" value="value1" /> 
<add key="key2" value="value2" />
...

But what if you need some more complex configurations? Something like this:

<MySection>
    <MySettings MyKey="John" MyValue1="Developer" MyValue2="Expert"/>
    <MySettings MyKey="Tomas" MyValue1="Developer" MyValue2="Junior"/>    
    <MySettings MyKey="Robert" MyValue1="Developer" MyValue2="Senior"/>
    <MySettings MyKey="Kurt" MyValue1="IT" MyValue2="Expert"/>
    <MySettings MyKey="Anna" MyValue1="HR" MyValue2="Senior"/>    
</MySection>

Today I'll show how to build this kind of Custom Configuration Settings in C#.

First of all, we have to define our class that will represent the whole configuration section. This class must be inherited from ConfigurationSection class. By the way, don't forget to include System.Configuration namespace. Also we need an Element class. This class will represent a single row in the section and it must be inherited from ConfigurationElement class. Third and the last class will represent the collection of our elements. Let's call it ElementCollection. This class must be inherited from ConfigurationElementCollection. Let's see the source code:

Element.cs:

public class Element : ConfigurationElement
{
    private const string ATTRIBUTE_MYKEY = "MyKey";
    private const string ATTRIBUTE_MYVALUE1 = "MyValue1";
    private const string ATTRIBUTE_MYVALUE2 = "MyValue2";
    
    [ConfigurationProperty(ATTRIBUTE_MYKEY, IsRequired = true, IsKey = true)]        
    public string MyKey
    {
        get { return (string)this[ATTRIBUTE_MYKEY]; }
        set { this[ATTRIBUTE_MYKEY] = value; }
    }

    [ConfigurationProperty(ATTRIBUTE_MYVALUE1, IsRequired = true, IsKey = false)]        
    public string MyValue1
    {
        get { return (string)this[ATTRIBUTE_MYVALUE1]; }
        set { this[ATTRIBUTE_MYVALUE1] = value; }
    }

    [ConfigurationProperty(ATTRIBUTE_MYVALUE2, IsRequired = true, IsKey = false)]        
    public string MyValue2
    {
        get { return (string)this[ATTRIBUTE_MYVALUE2]; }
        set { this[ATTRIBUTE_MYVALUE2] = value; }
    }    
}

Notice that above each property there is ConfigurationProperty attribute. Also MyKey property has IsKey attribute set to true. Let's see now ElementCollection class which represents the collection of elements:

ElementCollection.cs:

public class ElementCollection : ConfigurationElementCollection
{
    public ElementCollection()
    {
        this.AddElementName = "MySettings";
    }

    protected override object GetElementKey(ConfigurationElement element)
    {
        return (element as Element).MyKey;
    }

    protected override ConfigurationElement CreateNewElement()
    {
        return new Element();
    }

    public new Element this[string key]
    {
        get { return base.BaseGet(key) as Element; }
    }

    public Element this[int ind]
    {
        get { return base.BaseGet(ind) as Element; }
    }
}

I override GetElementKey method in order to determine the key attribute in the element. In our case MyKey attribute is our key in configuration element. And finally here is the code of Section class:

Section.cs:

public class Section : ConfigurationSection
{
    public const string sectionName = "MySection";

    [ConfigurationProperty("", IsDefaultCollection = true)]
    public ElementCollection MySettings
    {
        get
        {
            return this[""] as ElementCollection;
        }
    }

    public static Section GetSection()
    {
        return (Section)ConfigurationManager.GetSection(sectionName);
    }
}

We almost done. Before we can use our configuration section we must specify the name of our custom configuration section, configuration section class namespace and the assembly name where the configuration section classes are located:

<configuration>

  <configSections>
    <section name="MySection" type="CustomConfigurationSection.CustomConfig.Section, CustomConfigurationSection" />
  </configSections>
  
  <MySection>
    <MySettings MyKey="John" MyValue1="Developer" MyValue2="Expert"/>
    <MySettings MyKey="Tomas" MyValue1="Developer" MyValue2="Junior"/>
    <MySettings MyKey="Robert" MyValue1="Developer" MyValue2="Senior"/>
    <MySettings MyKey="Kurt" MyValue1="IT" MyValue2="Expert"/>
    <MySettings MyKey="Anna" MyValue1="HR" MyValue2="Senior"/>
  </MySection>

</configuration>

Here is how we access our configurations:

Console.Write(section.MySettings["John"].MyValue1);
Console.Write(section.MySettings["Anna"].MyValue2);

Download the source code (Visual Studio 2010 project).

Speech Synthesizer in WPF

2012-10-13T17:18:00.002+02:00

I recently came across with some very interesting feature in C# - Speech Synthesizer! Speech Synthesizer is Microsoft API which allows to build speech enabled applications. Just one row of code and your WPF application will spell any textual data!

All you need is just add a reference to System.Speech.Synthesis and a couple rows of code. I built a simple application just to show how to use Speech Synthesizer in WPF.

Here is the XAML code of the GUI:

<TextBox Grid.Column="0" Grid.Row="0"
         HorizontalAlignment="Left"
         TextWrapping="Wrap"
         AcceptsReturn="True"
         VerticalScrollBarVisibility="Visible"
         FontSize="14"
         Height="100"
         Width="270"
         Name="TextBox_Read">Talk to me!</TextBox>

<Button Grid.Column="1" Grid.Row="1"                
        Name="Button_Say"
        Content="Say" Click="Button_Say_Click"></Button>

<Button Grid.Column="1" Grid.Row="2"                
        Name="Button_Who"
        Content="Who's talking?" Click="Button_Who_Click"></Button>

<Slider Grid.Column="0" Grid.Row="1" 
        Name="Slider_Volume"
        Value="50" Minimum="0" Maximum="100"
        TickFrequency="5" ValueChanged="VolumeChanged"
        ToolTip="Volume"/>

<Slider Grid.Column="0" Grid.Row="2" 
        Name="Slider_Rate"
        Value="0" Minimum="-5" Maximum="7" 
        TickFrequency="1" ValueChanged="RateChanged"
        ToolTip="Speech Rate"/>

So, when user clicks on "Say" button, the Speech Synthesizer will spell what is currently written in the textbox. The upper slider is volume level and by the second slider we can change the speak rate. Let's see now the code behind:

public partial class MainWindow : Window
{
    private SpeechSynthesizer _speechSynthesizer = new SpeechSynthesizer();

    public MainWindow()
    {
        InitializeComponent();            
    }

    private void Button_Say_Click(object sender, RoutedEventArgs e)
    {
        _speechSynthesizer.SpeakAsync(TextBox_Read.Text);
    }

    private void VolumeChanged(object sender, RoutedPropertyChangedEventArgs<double> e)
    {
        _speechSynthesizer.Volume = (int)((Slider)e.OriginalSource).Value;
    }

    private void RateChanged(object sender, RoutedPropertyChangedEventArgs<double> e)
    {
        _speechSynthesizer.Rate = (int)((Slider)e.OriginalSource).Value;
    }

    private void Button_Who_Click(object sender, RoutedEventArgs e)
    {
        _speechSynthesizer.SpeakAsync("This is " + _speechSynthesizer.Voice.Name);
    }
}

As you can see it is very easy to use speech synthesizer in WPF application. Just pass the text to SpeakAsync method and this is it!

Download the source code (Visual Studio 2010 project).

WCF Service Returns List of Objects to WPF DataGrid

2012-09-26T16:24:00.003+02:00

Today we will build WCF service that returns a list of objects, an Employee objects, in our case. And we will build a WPF client application which will show the result in DataGrid.

First, let's create WCF service. Choose WCF Service Application from the list:

Visual Studio will automatically create template project with IService.cs and Service.svc files, where actually all the service logic will be written. I added the Employee class and edited Service.cs and IService.cs in order to service be able to return a list of employees. Let's see:

Employee.cs:

[DataContract]
public class Employee
{
    public Employee(string name, string email, string position, int age)
    {
        Name = name;
        Email = email;
        Position = position;
        Age = age;            
    }
    [DataMember]
    public string Name { get; set; }
    [DataMember]
    public string Email { get; set; }
    [DataMember]
    public string Position { get; set; }
    [DataMember]
    public int Age { get; set; }
}

We must state DataContract attribute on our Employee class because we are going to send employee objects to the client.

IService.cs:

[ServiceContract]
public interface IService
{     
    [OperationContract]
    List<Employee> GetEmployees();     
}

Service.svc.cs:

public class Service : IService
{
    public List<Employee> GetEmployees()
    {
        List<Employee> employees = new List<Employee>();
        employees.Add(new Employee("John", "john@codearsenal.net", "Developer", 32));
        employees.Add(new Employee("Smith", "smith@codearsenal.net", "Service", 45));
        employees.Add(new Employee("Lucas", "lucas@codearsenal.net", "Manager", 25));
        employees.Add(new Employee("Richard", "richard@codearsenal.net", "IT", 31));
        employees.Add(new Employee("Anna", "anna@codearsenal.net", "HR", 28));
        return employees;
    }
}

Ok, the service is ready to send employee list to the client. Now let's create our WPF client that will connect to the service and retrieve the data. Add new WPF project to the solution:

Now we need to add reference to our WCF service:

The last is to add some code that will retrieve the data from the service and bind that data to the DataGrid.

ViewModel.cs:

public class ViewModel
{
    WCFServiceReference.ServiceClient _serviceClient = new ServiceClient();        

    public List<Employee> Employees
    {
        get 
        {
            return _serviceClient.GetEmployees().ToList(); 
        }            
    }
}

MainWindow.xaml:

<Grid>
    <DataGrid Name="dataGrid1" ItemsSource="{Binding Employees}" AutoGenerateColumns="False">
        <DataGrid.Columns>
            <DataGridTextColumn Header="Name" Binding="{Binding Name}" />
            <DataGridTextColumn Header="Email" Binding="{Binding Email}" />
            <DataGridTextColumn Header="Position" Binding="{Binding Position}" />
            <DataGridTextColumn Header="Age" Binding="{Binding Age}" />
        </DataGrid.Columns>
    </DataGrid>
</Grid>

This is what we'll see once we build and run the project:

Download the source code (Visual Studio 2010 project).

C# Custom Event Handling

2012-09-22T12:13:00.001+03:00

There are a lot of examples on Event Handling and delegates in C# on the net, but most of them are just too complicated and confusing for a beginner. Today I'd like to share with you simple and clear example of event handling with custom event arguments.

Imaging that we have a simple Employee class. There are two properties - Name and Salary. We want a mechanism that will indicate that employee's salary has changed.Obviously we need create an event inside our Employee class and fire it each time when salary has changed.

Let's see Employee class source code:

public class Employee
{
    public delegate void PropertyChangedHandler(object sender, PropertyChangeEventArgs args);

    public event PropertyChangedHandler PropertyChange;

    public void OnPropertyChange(object sender, PropertyChangeEventArgs args)
    {
        // If there exist any subscribers call the event
        if (PropertyChange != null)
        {                
            PropertyChange(this, args);
        }
    }

    public string Name { get; set; }

    private int _salary = 5000;
    public int Salary
    {
        get { return _salary; }
        set
        {
            int oldValue = _salary;
            _salary = value;
            OnPropertyChange(this, new PropertyChangeEventArgs("Salary", value - oldValue));
        }
    }
}

PropertyChange is actually our event. PropertyChangeHandler delegate will allow us to subscribe to the event from other classes. We also want to pass custom arguments to subscriber, namely the difference between old amount of salary and the new one. That's why second parameter of the delegate is not EventArgs, as usual, but our custom class PropertyChangeEventArgs.

Let's see PropertyChangeEventArgs class source code:

public class PropertyChangeEventArgs : EventArgs
{
    public string PropertyName { get; internal set; }        
    public int Difference { get; internal set; }

    public PropertyChangeEventArgs(string propertyName, int difference)
    {
        PropertyName = propertyName;            
        Difference = difference;
    }
}

Now let's see how to subscribe to our event from other class:

class Program
{
    static void Main(string[] args)
    {
        Employee employee = new Employee();
        employee.PropertyChange += new Employee.PropertyChangedHandler(PropertyChanged);
        employee.Salary = 8000;            
        Console.ReadLine();
    }
    
    public static void PropertyChanged(object sender, PropertyChangeEventArgs args)
    {
        if (args.PropertyName == "Salary")
        {
            Console.WriteLine("Salary amount has changed! Salary difference is : " 
                               + args.Difference.ToString());
        }
    }
}

Here is the output:

Download the source code (Visual Studio 2010 project).

C# Get Assembly Location Path

2012-09-18T11:53:00.001+03:00

Often when developing different applications or services you need to know where is actually your exe or a dll located. For example, you developing a service which will create some files and directories in the same place where the service is running, so you need to know somehow in the run time the path to your service dll. Fortunately for these purposes we have Reflection mechanism in C#.
First, include reflection library in your code:

using System.Reflection;

Now, to get the path to the assembly in the run time - use this command:

string assemblyPath = Assembly.GetAssembly(typeof(ClassName)).Location;

Or if you need the path to the assembly directory then you can apply this code:

string directoryPath = Path.GetDirectoryName(Assembly.GetAssembly(typeof(ClassName)).Location);

C# DataTable Order By Column

2012-08-28T14:38:00.001+03:00

Sometimes when you work with DataSet or DataTable you need to order the data by specific column. The quickest way to sort DataTable by specific column is to convert it to DataView, apply the Sort method and then save back the results to your DataTable. Here is the code sample:

//   Create DataTable and fill out with data
DataTable table = new DataTable();  
table.Columns.Add("EmployeeFirstName", typeof(string));  
table.Columns.Add("EmployeeFamilyName", typeof(string));  
table.Columns.Add("Age", typeof(int));
DataRow row = table.NewRow();
  
row["EmployeeFirstName"] = "Bill";  
row["EmployeeFamilyName"] = "Gates";  
row["Age"] = 56;  
table.Rows.Add(row);  

row = table.NewRow();  
row["EmployeeFirstName"] = "Steve";  
row["EmployeeFamilyName"] = "Ballmer";  
row["Age"] = 57;  
table.Rows.Add(row); 

row = table.NewRow();  
row["EmployeeFirstName"] = "Paul";  
row["EmployeeFamilyName"] = "Allen";  
row["Age"] = 59;  
table.Rows.Add(row); 

//  In real life applications, it is critical 
//  to check if your DataTable is not empty!
if (table.Rows.Count > 0)  
{
    //  Convert DataTable to DataView
   DataView dv = table.DefaultView;
   //   Sort data
   dv.Sort = "Age";
   //   Convert back your sorted DataView to DataTable
   table = dv.ToTable();  
}

WPF ScrollViewer Control Example

2012-08-22T15:23:00.000+03:00

There are two controls that enables scrolling in WPF: ScrollBar and ScrollViewer. The ScrollViewer encapsulates both vertical and horizontal ScrollBar and a container that contains all the visible elements inside scrollable area. I'll show a ScrollBar example based on code described in my previous post.

Let's see the XAML:

<ScrollViewer HorizontalScrollBarVisibility="Auto" 
                VerticalScrollBarVisibility="Auto">               
    <Expander Name="MyExpander" Margin="10,10" >
        <Expander.Content>
            <DataGrid Name="dataGrid1"
                Cursor="Hand"
                ItemsSource="{Binding Employees}" />
        </Expander.Content>
        <Expander.Style>
            <Style TargetType="Expander">
                <Setter Property="IsExpanded" Value="False" />
                <Setter Property="Header" Value="Click to See More" />
                <Style.Triggers>
                    <DataTrigger Binding="{Binding IsExpanded,RelativeSource={RelativeSource Self}}"                                 Value="True">
                        <Setter Property="Header" Value="Click to See Less" />
                    </DataTrigger>
                </Style.Triggers>
            </Style>
        </Expander.Style>
    </Expander>                
</ScrollViewer>

By specifying HorizontalScrollBarVisibility and VerticalScrollBarVisibility as "Auto" we achieve that ScrollBar becomes visible only when content becomes larger than window frame.

Download the source code (Visual Studio 2010 project).

WPF Expander with DataGrid

2012-08-21T13:34:00.000+03:00

WPF has a very useful control called Expander. Expander allows you to hide or show any content that is inside of it. Today I'll show you how to use Expander with DataGrid and how to apply a Style to Expander's Header.

Collapsed state

Expanded state

In this particular example I put a DataGrid inside of Expander. I also applied a Style to Expander Header. The Style actually changes Header's text from "Click to See More" to "Click to See Less" when clicking on collapsed Expander and vice versa. Let's see the XAML:

<StackPanel>       
    <Expander Name="MyExpander" Margin="10,10" >
        <Expander.Content>
            <DataGrid Name="dataGrid1" Cursor="Hand" ItemsSource="{Binding Employees}" />
        </Expander.Content>
        <Expander.Style>
            <Style TargetType="Expander">
                <Setter Property="IsExpanded" Value="False" />
                <Setter Property="Header" Value="Click to See More" />
                <Style.Triggers>
                    <DataTrigger Binding="{Binding IsExpanded,RelativeSource={RelativeSource Self}}"                                 Value="True">
                        <Setter Property="Header" Value="Click to See Less" />
                    </DataTrigger>
                </Style.Triggers>
            </Style>
        </Expander.Style>
    </Expander>
</StackPanel>

Download the source code (Visual Studio 2010 project).

C# Write to Windows Event Log

2012-08-11T22:07:00.001+03:00

As you probably know Windows has its own Event Logging System. You can see the logs in it if you'll run Event Viewer from Administrative Tools. Today I'll show how to write messages into Windows Event Log from your application using C#.

In order to write to Event Log you have to include System and System.Diagnostics namespaces in your code.

   using System;
   using System.Diagnostics;

The log message that will be inserted to event log consists of three things - the message itself, the name of the log to which you want to write your message (if such log does not exist it will be created) and a string that represents the source of your event. If you need to write messages to more than one log you must define multiple sources.

   string _source = "My Application";
   string _log = "Application";
   string _event = "My Application Event";

You have to check if the source that you specified really exists, if it doesn't then create it. If the log name that you specified does not exist, then it will be created automatically when you write your first message.

   if (!EventLog.SourceExists(_source))
       EventLog.CreateEventSource(_source, _log);

In order to write a message use EventLog.WriteEntry static method. WriteEntry has several overloaded versions, here is the simplest one:

   EventLog.WriteEntry(_source, _event);

Run the following code, then go to the Event Viewer and check your logs.

using System;
using System.Diagnostics;

namespace WriteToAnEventLog_csharp
{    
    class MyEvent
    {
        static void Main(string[] args)
        {
            string _source = "My Application";
            string _log = "Application";
            string _event = "My Application Event";

            if (!EventLog.SourceExists(_source))
                EventLog.CreateEventSource(_source, _log);

            EventLog.WriteEntry(_source, _event);
            EventLog.WriteEntry(_source, _event, EventLogEntryType.Warning, 234);
        }
    }
}

Good luck!

C# LINQ - OrderBy clause

2012-08-11T11:51:00.002+03:00

This post is part of a series called LINQ Examples that brings practical examples of using LINQ in C#.

Today we'll see practical examples of using OrderBy, ThenBy clauses in LINQ. This kind of operators in LINQ are called LINQ Ordering Operators.

List<Employee> employees = GetEmployeeList();

var sortedEmployees =
    from e in employees
    orderby e.EmployeeName
    select e;
Console.WriteLine("Employees list ordered by name:");
foreach(var e in sortedEmployees)
    Console.Write(e.EmployeeName + ", ");    /*    Output:    John, Lucas, Marina, Susan, Tomas   */

We can also order our objects in opposite way simply by adding descending keyword:

var sortedEmployees =
                from e in employees
                orderby e.EmployeeName descending
                select e;

If we need to sort the employees by name and then by country they living in, we do it this way:

List<Employee> employees = GetEmployeeList();

var sortedEmployees =
        from e in employees
        orderby e.EmployeeName, e.EmployeeCountry
        select e;            
foreach(var e in sortedEmployees)
    Console.WriteLine(e.EmployeeName + " (" + e.EmployeeCountry + ")");

/*  Output:
 * 
 *  John (USA)                
 *  Lucas (England)                
 *  Marina (Russia)                
 *  Susan (England)
 *  Tomas (USA)   
 */

C# Entity Framework in Visual Studio 2010

2012-08-04T11:02:00.000+03:00

Some time ago I published an article about LINQ to SQL Classes Generation in Visual Studio 2010. Today I'll show how to use a newer version of Microsoft ADO.NET technology called Entity Framework.

ADO.NET Entity Framework enables developers to work directly with object model of a database instead of writing SQL queries. Developers which already worked with LINQ to SQL will easily switch to Entity Framework, because the overall using of it is pretty similar.

Ok, let's move on to the example. I created a WPF project with a datagrid in the main window and a simple local database with one single table Employees. Now I want to use ADO.NET Entity Framework to fetch data from the database and show it in my datagrid. Final result will look like this:

In order to add Entity Framework to your application mouse right click on the project then "Add New Item", choose ADO.NET Entity Data Model:

Then Entity Data Model Wizard will appear, choose "Generate from database":

Click "Next", then choose your data connection. In my case this is my local DB.sdf:

Click "Next", then choose desired tables or/and stored procedures. In my case I choose my Employee table, click "Finish":

That's all! You now have Entity Framework Model. Here how you use it in the code:

public List<Employee> GetData
{
    get
    {
        using (DBEntities context = new DBEntities())
        {
            var query = from e in context.Employees
                        select e;
            return query.ToList<Employee>();
        }                
    }
}

Download the source code of this example (Visual Studio 2010 project).

C# LINQ - Take, Skip, TakeWhile, SkipWhile clauses

2012-07-30T14:46:00.003+03:00

This post is part of a series called LINQ Examples that brings practical examples of using LINQ in C#.

Today we'll see practical examples of using Take, TakeWhile, Skip and SkipWhile clauses in LINQ. This kind of operators are called LINQ Partitioning Operators.

int[] numbers = { 1, 3, 9, 8, 6, 7, 2, 0, 5, 10 };

var firstFive = numbers.Take(5);
Console.WriteLine("First five numbers:");
foreach (var x in firstFive)
    Console.Write(x + ", ");    /*    Output:    1, 3, 9, 8, 6    */

var skipFive = numbers.Skip(5);
Console.WriteLine("All but first five numbers:"); 
foreach (var x in skipFive)
    Console.Write(x + ", ");    /*    Output:    7, 2, 0, 5, 10    */

var firstLessThanFive = numbers.TakeWhile(n => n < 5);
Console.WriteLine("First numbers less than five:"); 
foreach (var x in firstLessThanFive)
    Console.Write(x + ", ");    /*    Output:    1, 3    */

var fromFirstEven = numbers.SkipWhile(n => n % 2 != 0);
Console.WriteLine("All elements starting from first even element:");
foreach (var x in fromFirstEven)
    Console.Write(x + ", ");    /*    Output:    8, 6, 7, 2, 0, 5, 10    */

WPF DataGrid ColumnHeaderStyle (LinearGradientBrush)

2012-07-28T18:06:00.000+03:00

This post is part of series called WPF Styles where you can find many different styles for your WPF application.

Due to several requests to share XAML code of the DataGrid style that been used in my examples, today I'm sharing with you a ColumnHeaderStyle. Just to remind, this is how the DataGrid looks like:

So the ColumnHeaderStyle for this DataGrid is following:

<Style x:Key="HeaderStyle" TargetType="DataGridColumnHeader">
    <Setter Property="Background" Value="{StaticResource HeaderBrush}" />
    <Setter Property="Foreground" Value="White" />
    <Setter Property="BorderBrush" Value="{StaticResource HeaderBorderBrush}" />
    <Setter Property="BorderThickness" Value="1" />
    <Setter Property="SnapsToDevicePixels" Value="True" />
    <Setter Property="HorizontalContentAlignment" Value="Center" />
    <Setter Property="MinWidth" Value="0" />
    <Setter Property="MinHeight" Value="30" />
    <Setter Property="Cursor" Value="Hand" />
</Style>

<LinearGradientBrush x:Key="HeaderBrush" StartPoint="0.5,0" EndPoint="0.5,1">
    <GradientStop Color="#FF6B8E95" Offset="0"/>
    <GradientStop Color="#FF14A7C1" Offset="1"/>
    <GradientStop Color="#FF1E424E" Offset="0.509"/>
    <GradientStop Color="#FF1D4855" Offset="0.542"/>
    <GradientStop Color="#FF1D4855" Offset="0.542"/>
    <GradientStop Color="#FF193A44" Offset="0.526"/>
</LinearGradientBrush>

<LinearGradientBrush x:Key="HeaderBorderBrush" StartPoint="0.5,0" EndPoint="0.5,1">
    <GradientStop Color="#FF1D1D1D" Offset="0.614"/>
    <GradientStop Color="#FF007F96" Offset="0.853"/>
    <GradientStop Color="#FF0AEAFA" Offset="1"/>
</LinearGradientBrush>

LinearGradientBrush adds some fancy look to the column headers. To apply the style for your DataGrid just write following:

<DataGrid Name="dataGrid1" ColumnHeaderStyle="{StaticResource HeaderStyle}"/>

WPF DataGrid RowStyle (AlternationIndex)

2012-07-28T16:41:00.000+03:00

This post is part of series called WPF Styles where you can find many different styles for your WPF application.

Today I will share with you a WPF DataGrid RowStyle that I used recently for my DataGrid. At some point of development I noticed that data inside my DataGrid was really hard to read because of each row had the same color, so I decided to apply a style that will alternate the color for the rows, just like we usually see in excel reports. After applying this style your DataGrid will look like this:

To achieve this we need to add a trigger to our style with AlternationIndex set to 1. Here is the XAML of the style:

<Style x:Key="RowStyleWithAlternation" TargetType="DataGridRow">
    <Setter Property="SnapsToDevicePixels" Value="True" />
    <Setter Property="Background" Value="GhostWhite"/>
    <Setter Property="FontWeight" Value="Normal"/>
    <Setter Property="ContextMenu" Value="{x:Null}"/>
    <Style.Triggers>
        <Trigger Property="AlternationIndex" Value="1">
            <Setter Property="Background" Value="#FFD0D0E0"/>
        </Trigger>        
        <Trigger Property="IsMouseOver" Value="True">
            <Setter Property="Background" Value="#F9F99F"/>
        </Trigger>
        <Trigger Property="IsSelected" Value="True">
            <Setter Property="Background" Value="#F9F99F" />
        </Trigger>
        <Trigger Property="Validation.HasError" Value="True" >
            <Setter Property="Effect">
                <Setter.Value>
                    <DropShadowEffect Color="Red" ShadowDepth="0" BlurRadius="20" />
                </Setter.Value>
            </Setter>
            <Setter Property="BorderThickness" Value="2" />
            <Setter Property="BorderBrush" Value="Red" />
            <Setter Property="Foreground" Value="Blue" />
            <Setter Property="FontSize" Value="12" />
        </Trigger>
    </Style.Triggers>
</Style>

This RowStyle will make your DataGrid look clearly and easier to read. Just don't forget to apply the style in the DataGrid definition:

<DataGrid Name="dataGrid1" RowStyle="{StaticResource RowStyleWithAlternation}" />

WPF DataGrid CellStyle (CenterCellStyle)

2012-07-24T17:31:00.000+03:00

This post is part of series called WPF Styles where you can find many different styles for your WPF application.

When your DataGrid contains many different controls, the height of a cell in DataGrid increases accordingly. This make your text to look ugly inside the cell.

As you can see "Imaging" and "Devices" are not aligned to the center of the cell and overall look of DataGrid is ugly. To fix this problem you can apply a simple style that will put the cell content at the middle of the cell.

Here is DataGrid CellStyle code:

<Style x:Key="CenterCellStyle" TargetType="{x:Type DataGridCell}">
    <Setter Property="Template">
        <Setter.Value>
            <ControlTemplate TargetType="{x:Type DataGridCell}">
                <Grid Background="{TemplateBinding Background}">
                    <ContentPresenter HorizontalAlignment="Center" 
                                      VerticalAlignment="Center"/>
                </Grid>
            </ControlTemplate>
        </Setter.Value>
    </Setter>
    <Style.Triggers>
        <Trigger Property="IsSelected" Value="True">
            <Setter Property="Background" Value="Transparent" />
            <Setter Property="BorderBrush" Value="Transparent" />
            <Setter Property="Foreground" Value="Black" />
        </Trigger>
    </Style.Triggers>
</Style>

All you need now to apply this style to specific column or the CellStyle of the DataGrid.

    CellStyle="{StaticResource CenterCellStyle}"