1. Develop without opening the designer or mapping in XML files.
2. Define model objects by simply writing POCO(Plain old CLR object) with no base classes required
3. Use a “convention over configuration” approach that enables database persistence without explicitly configuring anything

You can download the latest version of code first from this url : ADO.NET Entity Framework 4.1 – Update 1.

You can also install via NuGet.

install-package entityframework

Quick CRUD example with EF Code first.

First we will create the model classes.

public class Task
{
    public int TaskId { get; set; }
    public string TaskDescription { get; set; }
    public DateTime TaskDate { get; set; }
    public short TaskPriority { get; set; }
    public bool TaskIsDone { get; set; }
}

Now we need to create a Context for this. Context is required to use the POCO classes for DataAccess. It can be implemented by deriving it from DbContext class. The DbContext class is available under System.Data.Entity namespace.

public class TaskContext : DbContext
{
    public DbSet Tasks { get; set; }
}

We are done. Now we can use this class for communicating to Database.

Inserting records to Database.

using (TaskContext taskContext = new TaskContext())
{
    taskContext.Tasks.Add(new Task()
    {
        TaskDate = DateTime.Today,
        TaskDescription = "Create a blog post",
        TaskIsDone = false,
        TaskPriority = 1
    });
    if (taskContext.SaveChanges() != 0)
    {
        Console.WriteLine("Task added.");
    }
}

Updating records, updating the first task from Tasks, if the Task date is today.

using (TaskContext taskContext = new TaskContext())
{
    var currentTask = taskContext.Tasks.Where
		(task => task.TaskDate == DateTime.Today).FirstOrDefault();
	currentTask.TaskIsDone = true;
    if (taskContext.SaveChanges() != 0)
    {
        Console.WriteLine("Task updated.");
    }
}

Removing records, removing first task from Tasks, if the Task is completed.

using (TaskContext taskContext = new TaskContext())
{
    var completedTask = taskContext.Tasks.Where
        (task => task.TaskIsDone == true).FirstOrDefault();
    taskContext.Tasks.Attach(completedTask);
    taskContext.Tasks.Remove(completedTask);
    if (taskContext.SaveChanges() != 0)
    {
        Console.WriteLine("Task Deleted.");
    }
}

And retriving records, retriving all the tasks.

using (TaskContext taskContext = new TaskContext())
{
	var tasks = taskContext.Tasks.Where
		(task => task.TaskDate == DateTime.Today);
	tasks.ToList().ForEach(task =>
        Console.WriteLine("Task : {0} IsCompleted : {1}",
        task.TaskDescription, task.TaskIsDone));
}

It is very easy right? Another interesting question is where this data is getting stored? Because we didn’t specified any Database, or Connection string. By default the database will be created on local instance of SQLEXPRESS (localhost\SqlExpress). The database is named after the fully qualified name of your derived context, in our case that it will be “EFCodeFirst.TaskContext”. You can control this by providing connection string or by setting DefaultConnectionFactory.

You can provide connectionstring either in App.Config / Web.Config file or in code.

If you are providing the connection string in config, file the name of the connection string element should be same as Context class name. Like this

<connectionStrings>
  <add name="TaskContext"
  connectionString="Server=.\SqlExpress; Integrated Security=SSPI; Database=TaskDb;"
  providerName="System.Data.SqlClient"/>
</connectionStrings>

And if you want to use your own connection string name, you can do this using CreateConnection() method of the DefaultConnectionFactory class. You can also specify the connection string. You need to provide this information before creating the instance of task context.

Database.DefaultConnectionFactory.CreateConnection("TaskDbConnection");
using (TaskContext taskContext = new TaskContext())
{
	//Code.
}

Entity Framework also supports various databases also, like SQL CE, MySql etc. This can be achive either using the provider name is the config settings or by using DefaultConnectionFactory propery of Database class. Following statement helps to use SqlCe database instead of Sql Server

Database.DefaultConnectionFactory =
	new SqlCeConnectionFactory("System.Data.SqlServerCe.4.0");
using (TaskContext taskContext = new TaskContext())
{
	//Code.
}

Model validations also supported by entity framework. I may cover them in another post.

Happy 2012

Here is the API declarations.

[DllImport("comctl32.dll", CharSet = CharSet.Unicode, EntryPoint = "TaskDialog")]
static extern int TaskDialog(IntPtr hWndParent, IntPtr hInstance, String pszWindowTitle,
String pszMainInstruction, String pszContent, int dwCommonButtons,
IntPtr pszIcon, out TaskDialogResult pnButton);

//Dialog buttons
[Flags]
public enum TaskDialogButtons : int
{
    Ok = 0x0001,
    Cancel = 0x0008,
    Yes = 0x0002,
    No = 0x0004,
    Retry = 0x0010,
    Close = 0x0020
}

//Dialog Results
[Flags]
public enum TaskDialogResult : int
{
    IDOK = 1,
    IDCANCEL = 2,
    IDRETRY = 4,
    IDYES = 6,
    IDNO = 7,
    IDCLOSE = 8,
    NONE = 0
}

//Dialog Icons
[Flags]
public enum TaskDialogIcon
{
    Information = UInt16.MaxValue - 2,
    Warning = UInt16.MaxValue,
    Stop = UInt16.MaxValue - 1,
    Question = 0,
    SecurityWarning = UInt16.MaxValue - 5,
    SecurityError = UInt16.MaxValue - 6,
    SecuritySuccess = UInt16.MaxValue - 7,
    SecurityShield = UInt16.MaxValue - 3,
    SecurityShieldBlue = UInt16.MaxValue - 4,
    SecurityShieldGray = UInt16.MaxValue - 8
}

And here is my TaskDialog wrapper function.

public static TaskDialogResult Show(IntPtr handle, string messageTitle, string mainTitle,
    string mainContent, TaskDialogButtons taskDialogButtons, TaskDialogIcon taskDialogIcon)
{
    TaskDialogResult buttonClicked = TaskDialogResult.IDCANCEL;
    TaskDialog(handle, IntPtr.Zero, messageTitle, mainTitle, mainContent,
        (int)taskDialogButtons, (IntPtr)(int)taskDialogIcon, out buttonClicked);
    return buttonClicked;
}

And here is the screen shot of Task Dialog running in my Windows 7 machine.

Task Dialog - On Windows 7 machine

Here is a sample implementation, which displaying RSS feeds in a WPF application.

private void cmdRead_Click(object sender, RoutedEventArgs e)
{
    WebClient client = new WebClient();
    client.DownloadStringCompleted += new DownloadStringCompletedEventHandler(client_DownloadStringCompleted);
    client.DownloadStringAsync(new Uri(this.txtUrl.Text));
}

private void client_DownloadStringCompleted(object sender, DownloadStringCompletedEventArgs e)
{
    XmlReader reader = XmlReader.Create(new StringReader(e.Result));
    SyndicationFeed feed = SyndicationFeed.Load(reader);
    this.lstBox.ItemsSource = feed.Items;
}

private void linkUrl_Click(object sender, RoutedEventArgs e)
{
    string url = (e.Source as Hyperlink).NavigateUri.AbsoluteUri;
    Process.Start(url);
}

And here is the WPF – XAML

<Window x:Class="RssReader.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">
    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto" />
            <RowDefinition Height="*" />
            <RowDefinition Height="Auto" />
        </Grid.RowDefinitions>
        <Grid Grid.Row="0">
            <Grid.ColumnDefinitions>
                <ColumnDefinition Width="Auto" />
                <ColumnDefinition Width="*" />
                <ColumnDefinition Width="Auto" />
            </Grid.ColumnDefinitions>
            <TextBlock Grid.Column="0">URL</TextBlock>
            <TextBox Name="txtUrl" Grid.Column="1" />
            <Button Content="Read" Name="cmdRead" Click="cmdRead_Click" Grid.Column="2" />
        </Grid>
        <ListBox Name="lstBox" Grid.Row="1">
            <ListBox.ItemTemplate>
                <DataTemplate>
                    <StackPanel>
                        <TextBlock Text="{Binding Path=Title.Text}" />
                        <TextBlock TextAlignment="Justify" Text="{Binding Path=Summary.Text}" />

                        <TextBlock>
                            <Hyperlink Name="linkUrl" Click="linkUrl_Click" NavigateUri="{Binding Path=Id}">
                                <Label Content="{Binding Path=Title.Text}" ></Label>
                            </Hyperlink>
                        </TextBlock>
                    </StackPanel>
                </DataTemplate>
            </ListBox.ItemTemplate>
        </ListBox>
        <StatusBar Grid.Row="2">
            <StatusBarItem Content="Welcome to RSS Reader" />
        </StatusBar>
    </Grid>
</Window>

This is a basic implementation, you can add more features like multiple urls, settings etc. You can developing a RSS client in silverlight with the same code, but the problem with silverlight is we require a crossdomainpolicy.xml file in the server. If the file is not found it will throw security exception.

Happy Programming.

If you are using VB.Net, Visual Studio will give an option to do this in the Application Settings in Project properties.

VB NET Project Settings

But this option is not available in C#. This following small snippet will help you to avoid multiple instances running on the machine using C#.

using System;
using System.Diagnostics;
using System.Windows.Forms;

namespace SampleApp
{
    static class Program
    {
        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        [STAThread]
        static void Main()
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Process currentProcess = Process.GetCurrentProcess();
            Process[] processItems = Process.GetProcessesByName(currentProcess.ProcessName);
            foreach (Process item in processItems)
            {
                if (item.Id != currentProcess.Id)
                {
                    MessageBox.Show("Another instance running");
                    return;
                }
            }
            Application.Run(new Form1());
        }
    }
}

<Window x:Class="dotnetthoughts.net.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=System"
Title="WPF SpellCheck Demo" Height="350" Width="525" Loaded="Window_Loaded">
<DockPanel>
<TextBox Name="txtEdit" SpellCheck.IsEnabled="True"
                AcceptsReturn="True"
ContextMenuOpening="txtEdit_ContextMenuOpening"
                VerticalScrollBarVisibility="Visible">
<TextBox.ContextMenu>
<ContextMenu Name="ctxMenu" />
</TextBox.ContextMenu>
</TextBox>
</DockPanel>
</Window>

And here is the code behind

namespace dotnetthoughts.net
{
    using System;
    using System.IO;
using System.Linq;
    using System.Windows;
    using System.Windows.Controls;
    using System.Windows.Documents;
    using System.Windows.Input;

public partial class MainWindow : Window
    {
public MainWindow()
        {
InitializeComponent();
        }

private void txtEdit_ContextMenuOpening(object sender, ContextMenuEventArgs e)
        {
            int index = 0;
this.txtEdit.ContextMenu.Items.Clear(); //Clearing the existing items
            //Getting the spellcheck suggestions.
SpellingError spellingError = this.txtEdit.GetSpellingError(this.txtEdit.CaretIndex);
if (spellingError != null && spellingError.Suggestions.Count() >= 1)
            {
                //Creating the suggestions menu items.
foreach (string suggestion in spellingError.Suggestions)
                {
MenuItem menuItem = new MenuItem();
                    menuItem.Header = suggestion;
menuItem.FontWeight = FontWeights.Bold;
menuItem.Command = EditingCommands.CorrectSpellingError;
                    menuItem.CommandParameter = suggestion;
menuItem.CommandTarget = this.txtEdit;
this.txtEdit.ContextMenu.Items.Insert(index, menuItem);
                    index++;
                }
Separator seperator = new Separator();
this.txtEdit.ContextMenu.Items.Insert(index, seperator);
                index++;
//Adding the IgnoreAll menu item
MenuItem IgnoreAllMenuItem = new MenuItem();
                IgnoreAllMenuItem.Header = "Ignore All";
IgnoreAllMenuItem.Command = EditingCommands.IgnoreSpellingError;
IgnoreAllMenuItem.CommandTarget = this.txtEdit;
                this.txtEdit.ContextMenu.Items.Insert(index, IgnoreAllMenuItem);
                index++;
            }
            else
            {
//No Suggestions found, add a disabled NoSuggestions menuitem.
                MenuItem menuItem = new MenuItem();
menuItem.Header = "No Suggestions";
                menuItem.IsEnabled = false;
this.txtEdit.ContextMenu.Items.Insert(index, menuItem);
                index++;
            }
//.Net 4.0 Supports CustomDictionaries, Option for Adding to dictionary.
int selectionStart = this.txtEdit.GetSpellingErrorStart(this.txtEdit.CaretIndex);
            if (selectionStart >= 0)
            {
                Separator seperator1 = new Separator();
this.txtEdit.ContextMenu.Items.Insert(index, seperator1);
                index++;
MenuItem AddToDictionary = new MenuItem();
                AddToDictionary.Header = "Add to Dictionary";
                //Getting the word to add
this.txtEdit.SelectionStart = selectionStart;
this.txtEdit.SelectionLength = this.txtEdit.GetSpellingErrorLength(this.txtEdit.CaretIndex);
                //Ignoring the added word.
AddToDictionary.Command = EditingCommands.IgnoreSpellingError;
AddToDictionary.CommandTarget = this.txtEdit;
AddToDictionary.Click += (object o, RoutedEventArgs rea) =>
                {
this.AddToDictionary(this.txtEdit.SelectedText);
                };
this.txtEdit.ContextMenu.Items.Insert(index, AddToDictionary);
                index++;
            }

//Common Edit MenuItems.
            Separator seperator2 = new Separator();
this.txtEdit.ContextMenu.Items.Insert(index, seperator2);
            index++;
            //Cut
MenuItem cutMenuItem = new MenuItem();
cutMenuItem.Command = ApplicationCommands.Cut;
this.txtEdit.ContextMenu.Items.Insert(index, cutMenuItem);
            index++;
            //Copy
MenuItem copyMenuItem = new MenuItem();
copyMenuItem.Command = ApplicationCommands.Copy;
this.txtEdit.ContextMenu.Items.Insert(index, copyMenuItem);
            index++;
            //Paste
MenuItem pasteMenuItem = new MenuItem();
pasteMenuItem.Command = ApplicationCommands.Paste;
this.txtEdit.ContextMenu.Items.Insert(index, pasteMenuItem);
            index++;
            Separator seperator3 = new Separator();
this.txtEdit.ContextMenu.Items.Insert(index, seperator3);
            index++;
            //Delete
MenuItem deleteMenuItem = new MenuItem();
deleteMenuItem.Command = ApplicationCommands.Delete;
            this.txtEdit.ContextMenu.Items.Insert(index, deleteMenuItem);
            index++;
            Separator seperator4 = new Separator();
this.txtEdit.ContextMenu.Items.Insert(index, seperator4);
            index++;
            //Select All
MenuItem selectAllMenuItem = new MenuItem();
selectAllMenuItem.Command = ApplicationCommands.SelectAll;
            this.txtEdit.ContextMenu.Items.Insert(index, selectAllMenuItem);
            index++;
        }
        //Method to Add text to Dictionary
private void AddToDictionary(string entry)
        {
using (StreamWriter streamWriter = new StreamWriter(@"D:\WPF\MyCustomDictionary.lex", true))
            {
streamWriter.WriteLine(entry);
            }
        }

private void Window_Loaded(object sender, RoutedEventArgs e)
        {
//Assigning custom Dictionary to TextBox
this.txtEdit.SpellCheck.CustomDictionaries.Add(new Uri(@"D:\WPF\MyCustomDictionary.lex"));
        }
    }
}

The .Net Framework 4.0 supports CustomDictionaries, which helps to create your own Dictionary.

//.Net 4.0 Supports CustomDictionaries, Option for Adding to dictionary.
int selectionStart = this.txtEdit.GetSpellingErrorStart(this.txtEdit.CaretIndex);
if (selectionStart >= 0)
{
    Separator seperator1 = new Separator();
this.txtEdit.ContextMenu.Items.Insert(index, seperator1);
    index++;
MenuItem AddToDictionary = new MenuItem();
    AddToDictionary.Header = "Add to Dictionary";
    //Getting the word to add
this.txtEdit.SelectionStart = selectionStart;
this.txtEdit.SelectionLength = this.txtEdit.GetSpellingErrorLength(this.txtEdit.CaretIndex);
    //Ignoring the added word.
AddToDictionary.Command = EditingCommands.IgnoreSpellingError;
AddToDictionary.CommandTarget = this.txtEdit;
AddToDictionary.Click += (object o, RoutedEventArgs rea) =>
    {
this.AddToDictionary(this.txtEdit.SelectedText);
    };
this.txtEdit.ContextMenu.Items.Insert(index, AddToDictionary);
    index++;
}

Here is the screenshot of Demo Application.

WPF Spell Check Demo - Screenshot