Infragistics XamGantt Control - Using Entity Framework Code First to Persist Projects in a Database

[Infragistics] Mihail Mateev / Sunday, October 21, 2012

Infragistics Gantt Control helps to create own project planning applications, that can contain most of the Microsoft Project features. One of the most common scenario is to store project data in a database (Microsoft SQL Server or other).

Developers are always looking for the easiest way for the implementation of the solution. In this case, it is reasonable to use an ORM framework. This article will demonstrate how to use Entity Framework with Code First approach.

Entity Framework 4.x and 5.x contains both the Code First approach and the DbContext API. This API provides a more productive surface for working with the Entity Framework and can be used with the Code First, Database First, and Model First approaches.

Entity Framework Code First allows you to create data model classes prior to creating a database. When you run the application for the first time, a database is created for you on the fly based on the classes you created. Database initializers allow you to decide a strategy of database creation and seed data generation. Code First provides its own set of database initializer classes and also allows you to create your own. This approach is a very convenient when you need to distribute your application. Customers need only to have a SQL Server installed.

Let’s create a simple WPF application and add XamGantt control instance inside it. You can start with the samples from my previous post: “How to Start Using Infragistics XamGantt Control” , "Data Exchange with Infragistics XamGantt Control - Using XML (Part 1)" or “Data Exchange with Infragistics XamGantt Control - Import/Export to Microsoft Project (Part 2)”. Add buttons to call import from and export to project. If you want to create a Silverlight simple you can use the same snippets, mentioned for WPF application.

What you need in advance:

To have some experience in the use of Entity Framework 4.x or 5.x
To install NetAdvantage for WPF vol. 12.2 or NetAdvantage for Silverlight Vol. 12.2 (these products are also included in NetAdvantage for .NET and NetAdvantage Ultimate)
To install EntityFramework, run the following command in the Package Manager Console PM> Install-Package EntityFramework

Create the Model

Let’s define a very simple model using classes. You can start with the models samples from my previous post “Data Exchange with Infragistics XamGantt Control - Import/Export to Microsoft Project (Part 2)”.

Create a Context

The simplest way to start using the classes for data access is to define a context that derives from System.Data.Entity.DbContext and exposes a typed DbSet<TEntity> for each class in my model.

You need to add a reference to the EF assembly

Project -> Add Reference…
Select the “.NET” tab
Select “EntityFramework” from the list
Click “OK”

You’ll also need a reference to the System.Data.Entity assembly:

Project -> Add Reference…
Select the “.NET” tab
Select “System.Data.Entity” from the list
Click “OK”

Let’s create a derived context:

Add a derived context below the existing classes that we’ve defined. You need to inherit System.Data.Entity.DbContext. By default when you run the application your database should be created if it doesn’t exist.

public class DbProjectViewModel : DbContext, INotifyPropertyChanged

 {

  

     #region SelectedTask

     private TaskModel _selectedTask;

     public TaskModel SelectedTask

     {

         get

         {

             return _selectedTask;

         }

         set

         {

             if (value != null)

             {

                 _selectedTask = value;

             }

  

             NotifyPropertyChanged("SelectedTask");

         }

     }

     #endregion SelectedTask

  

     #region Tasks

     private DbSet<TaskModel> _tasks;

     public DbSet<TaskModel> Tasks {get; set;}

     

     #endregion //Tasks

  

     #region NotifyPropertyChanged

     public event PropertyChangedEventHandler PropertyChanged;

     protected void NotifyPropertyChanged(String info)

     {

         if (PropertyChanged != null)

         {

             PropertyChanged(this, new PropertyChangedEventArgs(info));

         }

     }

     #endregion NotifyPropertyChanged

  

 }

If you do not want to generate a database at all, as you already have a database, you can add the following to the DbProjectViewModel constructor:

#region Constructor

public DbProjectViewModel()

   : base()

{

   Database.SetInitializer<DbProjectViewModel>(null);

}

  

public DbProjectViewModel(String connection)

   : base(connection)

{

   Database.SetInitializer<DbProjectViewModel>(null);

}

#endregion Constructor

Your task model will be the same as in previous posts.

public class TaskModel : ObservableModel

 {

     public TaskModel():base()

     {

     }

  

     public TaskModel(TaskModel oldTask)

         : base()

     {

         ConstraintType = oldTask.ConstraintType;

         ConstraintDate = oldTask.ConstraintDate;

         Id = oldTask.Id;

         DeadlineDate = oldTask.DeadlineDate;

         TaskName = oldTask.TaskName;

         Index = oldTask.Index;

         Id = oldTask.Id;

         DurationTicks = oldTask.DurationTicks;

         Start = oldTask.Start;

         IsMilestone = oldTask.IsMilestone;

         IsInProgress = oldTask.IsInProgress;            

     }

  

  

     #region ConstraintType

     private ProjectTaskConstraintType _constraintType;

     public ProjectTaskConstraintType ConstraintType

     {

         get

         {

             return _constraintType;

         }

         set

         {

             if (_constraintType != value)

             {

                 _constraintType = value;

                 this.NotifyPropertyChanged("ConstraintType");

             }

         }

     }

     #endregion ConstraintType

  

     #region ConstraintDate

     private DateTime? _constraintDate;

     public DateTime? ConstraintDate

     {

         get

         {

             return _constraintDate;

         }

         set

         {

             if (_constraintDate != value)

             {

                 _constraintDate = value;

                 this.NotifyPropertyChanged("ConstraintDate");

             }

         }

     }

     #endregion ConstraintDate

  

     #region DeadlineDate

     private DateTime? _deadlineDate;

     public DateTime? DeadlineDate

     {

         get

         {

             return _deadlineDate;

         }

         set

         {

             if (_deadlineDate != value)

             {

                 _deadlineDate = value;

                 this.NotifyPropertyChanged("DeadlineDate");

             }

         }

     }

     #endregion //DeadlineDate

  

     #region DurationFormat

     private ProjectDurationFormat _durationFormat;

     public ProjectDurationFormat DurationFormat

     {

         get

         {

             return _durationFormat;

         }

         set

         {

             if (_durationFormat != value)

             {

                 _durationFormat = value;

                 this.NotifyPropertyChanged("DurationFormat");

             }

         }

     }

     #endregion DurationFormat

  

     #region Duration

     private TimeSpan _duration;

  

     //[XmlIgnore]

     [NotMapped]

     public TimeSpan Duration

     {

         get

         {

             return _duration;

         }

         set

         {

             if (_duration != value)

             {

                 _duration = value;

                 this.NotifyPropertyChanged("Duration");

             }

         }

     }

     #endregion Duration

  

     #region DurationTicks

  

     // Pretend property for serialization

     [XmlElement("Duration")]

     public long DurationTicks

     {

         get { return _duration.Ticks; }

         set { _duration = new TimeSpan(value); }

     }

  

     #endregion DurationTicks

  

     #region Id

     private Int32 _id;

  

  

     public Int32 Id

     {

         get

         {

             return _id;

         }

         set

         {

             if (_id != value)

             {

                 _id = value;

                 this.NotifyPropertyChanged("Id");

             }

         }

     }

     #endregion Id

  

     #region Index

     private TimeSpan _index;

  

  

     public TimeSpan Index

     {

         get

         {

             return _index;

         }

         set

         {

             if (_index != value)

             {

                 _index = value;

                 this.NotifyPropertyChanged("Index");

             }

         }

     }

     #endregion Index

  

     #region IsMilestone

     private bool _isMilestone = false;

     public bool IsMilestone

     {

         get

         {

             return _isMilestone;

         }

         set

         {

             if (_isMilestone != value)

             {

                 _isMilestone = value;

                 this.NotifyPropertyChanged("IsMilestone");

             }

         }

     }

     #endregion IsMilestone

  

     #region IsInProgress

     private bool _isInProgress = true;

     public bool IsInProgress

     {

         get

         {

             return _isInProgress;

         }

         set

         {

             if (_isInProgress != value)

             {

                 _isInProgress = value;

                 this.NotifyPropertyChanged("IsInProgress");

             }

         }

     }

     #endregion IsInProgress

  

     #region IsUndetermined

     private bool _isUndetermined = false;

     public bool IsUndetermined

     {

         get

         {

             return _isUndetermined;

         }

         set

         {

             if (_isUndetermined != value)

             {

                 _isUndetermined = value;

                 this.NotifyPropertyChanged("IsUndetermined");

             }

         }

     }

     #endregion //IsUndetermined

  

     #region Predecessors

     private string _predecesors;

     public string Predecessors

     {

         get { return _predecesors; }

         set

         {

             if (value != _predecesors)

             {

                 _predecesors = value;

                 this.NotifyPropertyChanged("Predecessors");

             }

         }

     }

     #endregion //Predecessors

  

     #region PredecessorsIdText

     private string _predecessorsIdText;

     public string PredecessorsIdText

     {

         get { return _predecessorsIdText; }

         set

         {

             if (value != _predecessorsIdText)

             {

                 _predecessorsIdText = value;

                 this.NotifyPropertyChanged("PredecessorsIdText");

             }

         }

     }

     #endregion //PredecessorsIdText

  

     #region Successors

     private string _successors;

     public string Successors

     {

         get { return _successors; }

         set

         {

             if (value != _successors)

             {

                 _successors = value;

                 this.NotifyPropertyChanged("Successors");

             }

         }

     }

     #endregion //Successors

  

     #region Start

     private DateTime? _start;

     public DateTime? Start

     {

         get

         {

             return _start;

         }

         set

         {

             if (_start != value)

             {

                 _start = value;

                 this.NotifyPropertyChanged("Start");

             }

         }

     }

     #endregion Start

  

     #region Finish

     private DateTime? _finish;

     public DateTime? Finish

     {

         get

         {

             return _finish;

         }

         set

         {

             if (_finish != value)

             {

                 _finish = value;

                 this.NotifyPropertyChanged("Finish");

             }

         }

     }

     #endregion Finish

  

  

     #region TaskID

     private string _taskId;

     public string TaskID

     {

         get

         {

             return _taskId;

         }

         set

         {

             if (_taskId != value)

             {

                 _taskId = value;

                 this.NotifyPropertyChanged("TaskID");

             }

         }

     }

     #endregion TaskID

  

     #region Tasks

     private string _tasks;

     public string Tasks

     {

         get

         {

             return _tasks;

         }

         set

         {

             if (_tasks != value)

             {

                 _tasks = value;

                 this.NotifyPropertyChanged("Tasks");

             }

         }

     }

     #endregion Tasks

  

     #region TaskName

     private string _name;

     [Key]

     public string TaskName

     {

         get

         {

             return _name;

         }

         set

         {

             if (_name != value)

             {

                 _name = value;

                 this.NotifyPropertyChanged("TaskName");

             }

         }

     }

     #endregion TaskName

  

     #region ResourceName

     private string _resourceName;

     public string ResourceName

     {

         get

         {

             return _resourceName;

         }

         set

         {

             if (_resourceName != value)

             {

                 _resourceName = value;

                 this.NotifyPropertyChanged("ResourceName");

             }

         }

     }

     #endregion ResourceName

  

 }

}

Add an instance of your derived context in the sample application. You can use it in the same way like you will bind XamGantt control to a model with custom tasks, demonstrated in the blog "How to Start Using Infragistics XamGantt Control".

<Grid.Resources>

    <models:DbProjectViewModel x:Key="viewmodel" />

</Grid.Resources>

You need to cerate a ListBackedProject and a Gantt control instances. ListBackedProject.TaskItemsSource is bound to Tasks.Local that returns ObservableCollection<TaskModel>.

<ig:ListBackedProject x:Name="dataProvider" TaskItemsSource="{Binding Tasks.Local}">

     <ig:ListBackedProject.TaskPropertyMappings>

         <ig:ProjectTaskPropertyMappingCollection UseDefaultMappings="True">

  

             <!--Mandatory mappings -->

             <ig:ProjectTaskPropertyMapping TaskProperty="DataItemId" 

                                DataObjectProperty="TaskID" />

             <ig:ProjectTaskPropertyMapping TaskProperty="ConstraintType" 

                                DataObjectProperty="ConstraintType" />

             <ig:ProjectTaskPropertyMapping TaskProperty="ConstraintDate" 

                                DataObjectProperty="ConstraintDate" />

             <ig:ProjectTaskPropertyMapping TaskProperty="DurationFormat" 

                                DataObjectProperty="DurationFormat" />

             <ig:ProjectTaskPropertyMapping TaskProperty="Tasks" 

                                DataObjectProperty="Tasks" />

             <!--End of mandatory mappings -->

  

             <!--Manual tasks mapping -->

  

             <ig:ProjectTaskPropertyMapping TaskProperty="IsManual" 

                                DataObjectProperty="IsUndetermined" />

  

             <!--End of maual tasks mapping -->

  

             <!--Task link mapping -->

  

             <ig:ProjectTaskPropertyMapping TaskProperty="Predecessors" DataObjectProperty="Predecessors" />

  

             <!--End of task link mapping -->

  

             <!--Other tasks mapping -->

  

             <ig:ProjectTaskPropertyMapping TaskProperty="IsActive" 

                                DataObjectProperty="IsInProgress" />

  

             <ig:ProjectTaskPropertyMapping TaskProperty="Finish" 

                                        DataObjectProperty="Finish" />

  

             <ig:ProjectTaskPropertyMapping TaskProperty="DurationFormat" 

                                        DataObjectProperty="DurationFormat" />                               

  

  

             <ig:ProjectTaskPropertyMapping TaskProperty="TaskName" 

                                DataObjectProperty="TaskName" />

  

             <ig:ProjectTaskPropertyMapping TaskProperty="Start" 

                                DataObjectProperty="Start" />

  

  

             <ig:ProjectTaskPropertyMapping TaskProperty="Duration" 

                                DataObjectProperty="Duration" />

  

  

             <ig:ProjectTaskPropertyMapping TaskProperty="IsMilestone" 

                                DataObjectProperty="IsMilestone" />

  

             <ig:ProjectTaskPropertyMapping TaskProperty="Deadline" 

                                DataObjectProperty="DeadlineDate" />

  

             <!--End of other tasks mapping -->

  

  

         </ig:ProjectTaskPropertyMappingCollection>

     </ig:ListBackedProject.TaskPropertyMappings>

     <ig:ListBackedProject.TaskSettings>

         <ig:ProjectTaskSettings AllowChangeIndentation="True" 

                     AllowDelete="True"

                     AllowDragDeadline="True"

                     AllowDragMilestone="True"

                     AllowDragPercentComplete="True"

                     AllowDragSummary="Always"

                     AllowDragTask="True"                              

                     AllowInsert="True" 

                     AllowResizeSummary="Always"                                        

                     AllowResizeTask="True"/>

     </ig:ListBackedProject.TaskSettings>

  

 </ig:ListBackedProject>

<ig:XamGantt Margin="10" x:Name="xamGantt" VerticalAlignment="Top" ActiveCellChanged="xamGantt_ActiveCellChanged"  Project="{Binding ElementName=dataProvider}">

                       <ig:XamGantt.DefaultColumnSettings>

                           <ig:ProjectColumnSettings AllowHide="True"

                                         AllowMove="True"

                                         AllowResize="True"

                                         AllowShow="True"  />

                       </ig:XamGantt.DefaultColumnSettings>

                   </ig:XamGantt>

Save project to database

Let’s first try to save Gantt project to Microsoft SQL Server database. Create a project with tasks in your XamGantt appellation.

To be possible to save tasks with correct data about links you need to add an additional code – here it is implemented in UpdatePredecessorsIdText method.

#region btnSave_Click

private void btnSave_Click(object sender, RoutedEventArgs e)

{

        var model = this.Root.Resources["viewmodel"] as DbProjectViewModel;

        if (model != null)

        {

            UpdatePredecessorsIdText(xamGantt);

            SaveGanttProject(model);

        }

}

#endregion btnSave_Click

Unlike previous blogs here should keep not only information about PredecessorsIdText property but also information about the task sequence number is stored in a property named id. Add this property in your custom task model.

When you save and read the model tasks could not be saved/read in the proper number. This property will keep the original task sequence in the Infragistics Gantt project.

#region Id

private Int32 _id;

  

public Int32 Id

{

    get

    {

        return _id;

    }

    set

    {

        if (_id != value)

        {

            _id = value;

            this.NotifyPropertyChanged("Id");

        }

    }

}

#endregion Id

Add in the UpdatePredecessorsIdText method code that copy the value from the readonly property ProjectTask.Id to your custom tasks before to save the model.

#region UpdatePredecessorsIdText

private void UpdatePredecessorsIdText(XamGantt gantt)

{

    foreach (ProjectTask task in gantt.Project.RootTask.Tasks)

    {

        var customTask = task.DataItem as TaskModel;

        customTask.PredecessorsIdText = task.PredecessorsIdText;

        customTask.Id = task.Id;

    }

}

#endregion UpdatePredecessorsIdText

The real save to your database is a very simple just call SaveChanges() method of your derived context.

#region SaveGanttProject

private void SaveGanttProject(DbProjectViewModel model)

{

    model.SaveChanges();

}

#endregion SaveGanttProject

Database settings

Connection strings

You can tell DbContext to use this connection by passing the connection string name to the DbContext constructor. For example:

public class DbProjectViewModel : DbContext, INotifyPropertyChanged

{

        #region Constructor

        public DbProjectViewModel()

            : base("name=Northwind_Entities")

        {

            Database.SetInitializer<DbProjectViewModel>(null);

        }

        //implementation...

}

Code First Default Connection Factory

Connection strings go in the standard connectionStrings element and do not require the new entityFramework section.

This configuration section allows you to specify a default connection factory that Code First should use to locate a database to use for a context. The default connection factory is only used when no connection string has been added to the configuration file for a context.

In the sample application is used the approach when you have no connection string and use default connection factory settings.

When you use default connection factory without changes you will use a .\SQLEXPRESS instance.

Where’s My Data?

DbContext by convention created a database for you on localhost\SQLEXPRESS. The database is named after the fully qualified name of your derived context, in our case that is “WPfIgGantImportExport.Models.DbProjectViewModel”. We’ll look at ways to change this later in the walkthrough.

<entityFramework>

  <defaultConnectionFactory 

        type="System.Data.Entity.Infrastructure.SqlConnectionFactory, EntityFramework" />

</entityFramework>

If you don’t set a default connection factory, Code First uses the SqlConnectionFactory, pointing to .\SQLEXPRESS.SqlConnectionFactory also has a constructor that allows you to override parts of the connection string. If you want to use a SQL Server instance other than .\SQLEXPRESS you can use this constructor to set the server.

<entityFramework>

  <defaultConnectionFactory type="System.Data.Entity.Infrastructure.SqlConnectionFactory, EntityFramework">

    <parameters>

      <parameter value="Data Source=(local);integrated security=True;multipleactiveresultsets=True"/>

    </parameters>

  </defaultConnectionFactory>

</entityFramework>

Entity Framework Code First now uses local Microsoft SQL Server 2012 instance.

Read project from database

Write a LINQ expression that gets your tasks from data base. place this code in a separate method, named in this sample “ReadGanttProject”.

#region btnRead_Click

 private void btnRead_Click(object sender, RoutedEventArgs e)

 {

         var model = this.Root.Resources["viewmodel"] as DbProjectViewModel;

         if (model != null)

         {

             ReadGanttProject(ref model);

         }

 }

 #endregion btnRead_Click

Get all tasks in a separate list, ordered by Id. Clear the tasks from your model and add tasks from your list one by one from the smallest Id to the largest.

#region ReadGanttProject

private void ReadGanttProject(ref DbProjectViewModel model)

{

  

    var mm = model.Tasks.Where(a => a.TaskName != "").OrderBy(a=>a.Id).ToList();

    

    foreach (var entity in model.Tasks)

    {

        model.Tasks.Remove(entity);

    }

  

    //Clear the read tasks

    model.SaveChanges();

  

    xamGantt.Project.RootTask.Tasks.Clear();

  

    for (int i = 0; i < mm.Count(); i++)

    {

        model.Tasks.Add(mm[i]);

    }

  

    foreach (ProjectTask prTask in xamGantt.Project.RootTask.Tasks)

    {

        var taskModel = prTask.DataItem as TaskModel;

        prTask.PredecessorsIdText = taskModel.PredecessorsIdText;

    }

  

    //Update database again 

    model.SaveChanges();

  

}

#endregion ReadGanttProject

Now you have all tasks from database in your XamGantt application.

Try to delete a specified task, add a new task and save the project. Database is updated without any issues.

The ListBackedProject.TaskItemsSource is not bound Tasks (Tasks is from DbSet type and doesn’t support property changed notifications) . It is bound to Tasks.Local that returns ObservableCollection<TaskModel>.

<ig:ListBackedProject x:Name="dataProvider" TaskItemsSource="{Binding Tasks.Local}">

In this case all property changed notifications updates the tasks inside the XamGantt control.

Conclusions

It is very easy to a database (Microsoft SQL Server or other to persist your project data from an application with an Infragistics XamGantt control. This scenario could be used for multi-user systems for project management and planning. The sample application could be modified with a few small changes to support many different projects as a real life application.

Using Infragistics NetAdvantage for XAML (WPF and Silverlight) Vol. 12.2 you can create software for project-management teams providing the benefit from the next NetAdvantage updates of and features .

Follow news from Infragistics for more information about new Infragistics products.

Source code is available here. Sample project is created with Visual Studio 2012, but you can use NetAdvantage 12.2 controls with both: Visual Studio 2012 and Visual Studio 2012. As always, you can follow us on Twitter @mihailmateev and @Infragistics and stay in touch on Facebook, Google+ and LinkedIn!