PLINQO - Supercharge LINQ to SQL

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Text;
using System.Text.RegularExpressions;
using System.IO;
using System.Xml;
using System.Xml.Serialization;
using Microsoft.Build.BuildEngine;
using CodeSmith.Engine.Utility;

public class ProjectUpdater
{
    
    private string _projectDirectory;

    public ProjectUpdater(string projectFile)
    {
        _projectFile = projectFile;
        InitializeProject();
    }

    private Project _project;
    
    public Project Project
    {
        get { return _project; }
    }

    private string _projectFile;

    public string ProjectFile
    {
        get { return _projectFile; }
    }

    public void AddEmbeddedResource(string fileName)
    {
        AddItem(fileName, "EmbeddedResource", true);
    }

    public void AddCompileItem(string fileName)
    {
        AddItem(fileName, "Compile", true);
    }

    public void AddNoneItem(string fileName)
    {
        AddItem(fileName, "None", true);
    }
    
    public void AddCompileItem(string fileName, string dependentFile)
    {
        if (string.IsNullOrEmpty(this.ProjectFile) || _project == null)
            return;

        fileName = PathUtil.RelativePathTo(
            _projectDirectory, Path.GetFullPath(fileName));
        dependentFile = PathUtil.RelativePathTo(
            _projectDirectory, Path.GetFullPath(dependentFile));

        BuildItem classItem = null;
        BuildItem dependItem = null;

        BuildItemGroup group = _project.GetEvaluatedItemsByName("Compile");

        foreach (BuildItem item in group)
        {
            if (item.FinalItemSpec.Equals(fileName, StringComparison.OrdinalIgnoreCase))
                classItem = item;
            else if (item.FinalItemSpec.Equals(dependentFile, StringComparison.OrdinalIgnoreCase))
                dependItem = item;
        }

        if (classItem == null)
            classItem = _project.AddNewItem("Compile", fileName);
        if (dependItem == null)
            dependItem = _project.AddNewItem("Compile", dependentFile);

        if (!dependItem.HasMetadata("DependentUpon"))
        {
            dependItem.SetMetadata(
                "DependentUpon",
                Path.GetFileName(classItem.FinalItemSpec));
            _project.MarkProjectAsDirty();
        }

    }

    public void AddReferenceItem(string reference, bool searchProjectReferences)
    {
        if (searchProjectReferences)
        {
            BuildItemGroup group = _project.GetEvaluatedItemsByName("ProjectReference");
            foreach (BuildItem item in group)
            {
                if (item.Include.Contains(reference) ||
                    (item.HasMetadata("Name") && item.GetMetadata("Name").Contains(reference)))
                {
                    return;
                }
            }
        }
        AddItem(reference, "Reference", false);
    }

    public void AddItem(string fileName, string itemType, bool makeRelative)
    {
        if (string.IsNullOrEmpty(this.ProjectFile) || _project == null)
            return;

        if (makeRelative)
        {
            fileName = PathUtil.RelativePathTo(
                _projectDirectory, Path.GetFullPath(fileName));
        }

        BuildItem newItem = null;
        BuildItemGroup group = _project.GetEvaluatedItemsByName(itemType);

        foreach (BuildItem item in group)
        {
            if (fileName.Equals(item.FinalItemSpec,
                StringComparison.OrdinalIgnoreCase))
            {
                newItem = item;
                break;
            }
        }

        if (newItem == null)
        {
            newItem = _project.AddNewItem(itemType, fileName);
            _project.MarkProjectAsDirty();
        }
    }
    
    private void InitializeProject()
    {
        if (string.IsNullOrEmpty(this.ProjectFile)
            || !File.Exists(this.ProjectFile))
            return;

        _projectDirectory = Path.GetDirectoryName(
            Path.GetFullPath(_projectFile));

        Engine engine = new Engine(Environment.CurrentDirectory);
        _project = new Project(engine);
        _project.Load(_projectFile);
    }

    public void SaveProject()
    {
        if (string.IsNullOrEmpty(this.ProjectFile)
            || _project == null
            || !_project.IsDirty)
            return;

        _project.Save(this.ProjectFile);
    }

}