syncfusion/wpf-ui-components-skills / skills/syncfusion-wpf-gantt
syncfusion-wpf-gantt
VerifiedImplement Syncfusion WPF Gantt control for project management and task scheduling in Windows Presentation Foundation applications. Use this when building project planning tools, task timeline visualizations, or resource management systems. This skill covers Gantt chart configuration, task dependencies, drag-drop interactions, resource allocation, baseline tracking, and customization options.
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 16.5 KB |
| references/customization.md | markdown | 9.6 KB |
| references/data-binding.md | markdown | 18.0 KB |
| references/data-operations.md | markdown | 10.9 KB |
| references/drag-drop-interaction.md | markdown | 7.6 KB |
| references/getting-started.md | markdown | 9.4 KB |
| references/localization.md | markdown | 9.4 KB |
| references/resource-management.md | markdown | 11.6 KB |
| references/task-relationships.md | markdown | 12.2 KB |
| references/task-scheduling.md | markdown | 14.6 KB |
references/data-operations.md
View on GitHub# Data Operations
Comprehensive guide for filtering, sorting, virtualization, and import/export operations in the WPF Gantt control.
## Table of Contents
- [Filtering Tasks](#filtering-tasks)
- [Sorting Tasks](#sorting-tasks)
- [Data Virtualization](#data-virtualization)
- [XML Import and Export](#xml-import-and-export)
- [Bulk Operations](#bulk-operations)
## Filtering Tasks
Filter tasks based on various criteria.
### Predicate-Based Filtering
```csharp
// Filter to show only incomplete tasks
ganttControl.FilterPredicate = task =>
{
var taskDetails = task as TaskDetails;
return taskDetails.Progress < 100;
};
// Refresh view
ganttControl.RefreshGantt();
```
### Date Range Filtering
```csharp
private void FilterByDateRange(DateTime startDate, DateTime endDate)
{
ganttControl.FilterPredicate = task =>
{
var taskDetails = task as TaskDetails;
return taskDetails.StartDate >= startDate &&
taskDetails.FinishDate <= endDate;
};
ganttControl.RefreshGantt();
}
```
### Multi-Criteria Filtering
```csharp
public class TaskFilter
{
public bool ShowCompleted { get; set; }
public bool ShowOverdue { get; set; }
public string ResourceFilter { get; set; }
public string PriorityFilter { get; set; }
}
private void ApplyFilter(TaskFilter filter)
{
ganttControl.FilterPredicate = task =>
{
var taskDetails = task as TaskDetails;
// Completed filter
if (!filter.ShowCompleted && taskDetails.Progress == 100)
return false;
// Overdue filter
if (filter.ShowOverdue &&
(taskDetails.FinishDate >= DateTime.Today || taskDetails.Progress == 100))
return false;
// Resource filter
if (!string.IsNullOrEmpty(filter.ResourceFilter))
{
if (taskDetails.Resources == null ||
!taskDetails.Resources.Any(r => r.Name.Contains(filter.ResourceFilter)))
return false;
}
// Priority filter
if (!string.IsNullOrEmpty(filter.PriorityFilter) &&
taskDetails.Priority != filter.PriorityFilter)
return false;
return true;
};
ganttControl.RefreshGantt();
}
```
### Clear Filtering
```csharp
private void ClearFilter()
{
ganttControl.FilterPredicate = null;
ganttControl.RefreshGantt();
}
```
## Sorting Tasks
Sort tasks by various properties.
### Sort by Property
```csharp
// Sort by start date
var sortedTasks = new ObservableCollection<TaskDetails>(
TaskCollection.OrderBy(t => t.StartDate)
);
ganttControl.ItemsSource = sortedTasks;
```
### Multi-Level Sorting
```csharp
// Sort by priority, then by start date
var sortedTasks = new ObservableCollection<TaskDetails>(
TaskCollection
.OrderBy(t => t.Priority)
.ThenBy(t => t.StartDate)
);
ganttControl.ItemsSource = sortedTasks;
```
### Custom Sorting with IComparer
```csharp
public class TaskComparer : IComparer<TaskDetails>
{
public int Compare(TaskDetails x, TaskDetails y)
{
// Sort by progress (incomplete first), then by start date
if (x.Progress == 100 && y.Progress < 100)
return 1;
if (x.Progress < 100 && y.Progress == 100)
return -1;
return x.StartDate.CompareTo(y.StartDate);
}
}
// Apply custom sorting
var sortedTasks = new ObservableCollection<TaskDetails>(
TaskCollection.OrderBy(t => t, new TaskComparer())
);
ganttControl.ItemsSource = sortedTasks;
```
## Data Virtualization
Improve performance with large datasets using virtualization.
### Enable Virtualization
```csharp
// Enable row virtualization for better performance
ganttControl.EnableVirtualization = true;
```
### Virtual Mode Example
```csharp
public class LargeProjectViewModel
{
private ObservableCollection<TaskDetails> _allTasks;
public LargeProjectViewModel()
{
// Load large dataset (e.g., 10,000+ tasks)
_allTasks = LoadTasksFromDatabase();
// Enable virtualization
GanttControl.EnableVirtualization = true;
GanttControl.ItemsSource = _allTasks;
}
private ObservableCollection<TaskDetails> LoadTasksFromDatabase()
{
// Load tasks efficiently
var tasks = new ObservableCollection<TaskDetails>();
using (var context = new ProjectContext())
{
// Use deferred execution
var dbTasks = context.Tasks
.Include(t => t.Resources)
.Include(t => t.Dependencies)
.AsNoTracking()
.ToList();
foreach (var task in dbTasks)
{
tasks.Add(new TaskDetails(task));
}
}
return tasks;
}
}
```
### Performance Best Practices
```csharp
// 1. Disable auto-expand for large hierarchies
ganttControl.AutoExpandMode = AutoExpandMode.None;
// 2. Use lightweight data structures
public class LightweightTaskDetails
{
// Only essential properties
public int TaskId { get; set; }
public string TaskName { get; set; }
public DateTime StartDate { get; set; }
public DateTime FinishDate { get; set; }
public double Progress { get; set; }
}
// 3. Load on demand
private void LoadChildrenOnExpand(object sender, ExpandEventArgs e)
{
var task = e.Node.Content as TaskDetails;
if (!task.ChildrenLoaded)
{
task.Child = LoadChildTasks(task.TaskId);
task.ChildrenLoaded = true;
}
}
```
## XML Import and Export
Import and export Gantt data to/from XML format.
### Export to XML
```csharp
using System.Xml.Serialization;
private void ExportToXml(string filePath)
{
var serializer = new XmlSerializer(typeof(ObservableCollection<TaskDetails>));
using (var writer = new StreamWriter(filePath))
{
serializer.Serialize(writer, TaskCollection);
}
MessageBox.Show($"Project exported to {filePath}");
}
```
### Import from XML
```csharp
private void ImportFromXml(string filePath)
{
var serializer = new XmlSerializer(typeof(ObservableCollection<TaskDetails>));
using (var reader = new StreamReader(filePath))
{
var importedTasks = (ObservableCollection<TaskDetails>)serializer.Deserialize(reader);
// Validate and load
if (ValidateImportedData(importedTasks))
{
TaskCollection = importedTasks;
ganttControl.ItemsSource = TaskCollection;
MessageBox.Show("Project imported successfully.");
}
}
}
private bool ValidateImportedData(ObservableCollection<TaskDetails> tasks)
{
// Validate task IDs are unique
var uniqueIds = new HashSet<int>();
foreach (var task in tasks)
{
if (uniqueIds.Contains(task.TaskId))
return false;
uniqueIds.Add(task.TaskId);
// Validate date ranges
if (task.StartDate > task.FinishDate)
return false;
}
return true;
}
```
### Export to Microsoft Project XML
```csharp
private void ExportToMSProjectXml(string filePath)
{
// Create MS Project compatible XML
var xmlDoc = new XmlDocument();
var projectNode = xmlDoc.CreateElement("Project");
foreach (var task in TaskCollection)
{
var taskNode = xmlDoc.CreateElement("Task");
var idNode = xmlDoc.CreateElement("UID");
idNode.InnerText = task.TaskId.ToString();
taskNode.AppendChild(idNode);
var nameNode = xmlDoc.CreateElement("Name");
nameNode.InnerText = task.TaskName;
taskNode.AppendChild(nameNode);
var startNode = xmlDoc.CreateElement("Start");
startNode.InnerText = task.StartDate.ToString("yyyy-MM-ddTHH:mm:ss");
taskNode.AppendChild(startNode);
var finishNode = xmlDoc.CreateElement("Finish");
finishNode.InnerText = task.FinishDate.ToString("yyyy-MM-ddTHH:mm:ss");
taskNode.AppendChild(finishNode);
var percentCompleteNode = xmlDoc.CreateElement("PercentComplete");
percentCompleteNode.InnerText = task.Progress.ToString();
taskNode.AppendChild(percentCompleteNode);
projectNode.AppendChild(taskNode);
}
xmlDoc.AppendChild(projectNode);
xmlDoc.Save(filePath);
}
```
## Bulk Operations
Perform operations on multiple tasks efficiently.
### Bulk Update
```csharp
private void BulkUpdateProgress(IEnumerable<TaskDetails> tasks, double newProgress)
{
// Suspend notifications for performance
var collection = TaskCollection as INotifyCollectionChanged;
foreach (var task in tasks)
{
task.Progress = newProgress;
}
// Refresh once
ganttControl.RefreshGantt();
}
```
### Bulk Delete
```csharp
private void DeleteTasks(IEnumerable<TaskDetails> tasksToDelete)
{
var taskList = tasksToDelete.ToList();
foreach (var task in taskList)
{
// Remove dependencies first
RemoveTaskDependencies(task);
// Remove from parent
if (task.ParentTask != null)
{
task.ParentTask.Child.Remove(task);
}
else
{
TaskCollection.Remove(task);
}
}
ganttControl.RefreshGantt();
}
private void RemoveTaskDependencies(TaskDetails task)
{
// Remove all dependencies involving this task
foreach (var t in TaskCollection)
{
if (t.Predecessor != null)
{
var deps = t.Predecessor.Where(p => p.GanttTaskIndex != task.TaskId).ToList();
t.Predecessor = new ObservableCollection<Predecessor>(deps);
}
}
}
```
### Search Tasks
```csharp
private IEnumerable<TaskDetails> SearchTasks(string searchText)
{
return TaskCollection.Where(task =>
task.TaskName.Contains(searchText, StringComparison.OrdinalIgnoreCase) ||
(task.Notes != null && task.Notes.Contains(searchText, StringComparison.OrdinalIgnoreCase))
);
}
private void HighlightSearchResults(string searchText)
{
var results = SearchTasks(searchText);
foreach (var task in results)
{
// Apply highlight style
task.NodeStyle = new Style(typeof(GanttNode))
{
Setters =
{
new Setter(GanttNode.BackgroundProperty, Brushes.Yellow)
}
};
}
ganttControl.RefreshGantt();
}
```
## Best Practices
1. **Enable Virtualization:** Always use virtualization for projects with 100+ tasks.
2. **Filter Before Sort:** Apply filters first to reduce the dataset before sorting.
3. **Batch Updates:** Use bulk operations for updating multiple tasks to improve performance.
4. **Validate Imports:** Always validate XML data before importing to avoid corrupt project states.
5. **Deferred Loading:** Load child tasks on-demand for large hierarchical structures.
6. **Refresh Once:** After bulk operations, call `RefreshGantt()` only once at the end.
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis. | Stars: 471k | Updated | Claude CodeCodex | Verified | Install |
| diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness. | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is available | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |