Imports System
Imports System.Collections
Imports System.Text
Imports System.Windows.Forms
Imports MSProject = Microsoft.Office.Interop.MSProject
Imports Office = Microsoft.Office.Core

using System;
using System.Collections;
using System.Text;
using System.Windows.Forms;
using MSProject = Microsoft.Office.Interop.MSProject;
using Office = Microsoft.Office.Core;

Public Class ThisAddIn
    Private commandBar As Office.CommandBar
    Private importButton As Office.CommandBarButton

    Private Sub ThisAddIn_Startup(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Startup
        AddImportToolbar()
    End Sub

    . . .

    Private Sub AddImportToolbar()

    End Sub

End Class

namespace ImportProject
{
    public partial class ThisAddIn
    {
        private Office.CommandBar commandBar;
        private Office.CommandBarButton importButton;

        private void ThisAddIn_Startup(object sender, System.EventArgs e)
        {
            AddImportToolbar();
        }
        . . .

        private void AddImportToolbar()
        {

        }
    }
}

Try
   commandBar = Application.CommandBars("ImportBar")
Catch ex As ArgumentException
   ' The toolbar named ImportBar does not exist, so create it.
End Try

If (commandBar Is Nothing) Then
   ' Check the list of command bars.
   'Dim numBars As Integer
   'Dim msg As String
   'numBars = Application.CommandBars.Count
   'msg = String.Format("There are currently {0} command bars: " + vbCrLf, numBars)

   'For i As Integer = 1 To numBars
   '    msg += String.Format("{0}: {1}" + vbCrLf, i, Application.CommandBars(i).Name)
   'Next i
   'MessageBox.Show(msg, "Command Bars in Project", _
   '                MessageBoxButtons.OK, MessageBoxIcon.Information)

   ' Add a command bar named ImportBar to the toolbar area.
   Dim barPosition As Integer = 1
   Dim isTemporary As Boolean = True
   commandBar = Application.CommandBars.Add("ImportBar", barPosition, , isTemporary)
End If

try
{
    commandBar = Application.CommandBars["ImportBar"];
}
catch (ArgumentException e)
{
    // The toolbar named ImportBar does not exist, so create it.
}
if (commandBar == null)
{
    // Add a commandbar named ImportBar.
    /*   //Check the list of command bars.
    int numBars = Application.CommandBars.Count;
    string msg = string.Format("There are currently {0} command bars: \r\n",
        numBars);
    for (int i = 1; i <= numBars; i++)
    {
        msg += string.Format("\t{0}: {1}\r\n", i, Application.CommandBars[i].Name);
    }
    MessageBox.Show(msg, "Command Bars in Project", MessageBoxButtons.OK, 
       MessageBoxIcon.Information);
    */

    //int barPosition = (int)Office.MsoBarPosition.msoBarLeft;
    // Add the toolbar to the toolbar area.
    int barPosition = 1;
    bool isMenuBar = false;
    bool isTemporary = true;
    commandBar = Application.CommandBars.Add("ImportBar", barPosition, 
                                             isMenuBar, isTemporary);
}

Try
   importButton = _
       commandBar.Controls.Add(Type:=Office.MsoControlType.msoControlButton)
   importButton.Style = Office.MsoButtonStyle.msoButtonCaption
   importButton.Caption = "Import Project VB"
   importButton.Tag = "importProjectVB"
   importButton.TooltipText = "Import a project from Excel, by using the Visual Basic add-in."
   AddHandler importButton.Click, AddressOf ImportButtonClick

   commandBar.Visible = True

Catch ex As Exception
   MessageBox.Show(ex.Message, "Error adding toolbar button", _
                   MessageBoxButtons.OK, MessageBoxIcon.Error)
End Try

try
{
    importButton = (Office.CommandBarButton)commandBar.Controls.Add(
        Office.MsoControlType.msoControlButton, missing, missing, missing, missing);
    importButton.Style = Office.MsoButtonStyle.msoButtonCaption;
    importButton.Caption = "Import Project";
    importButton.Tag = "importProject";
    importButton.TooltipText = "Import a project from Excel.";
    importButton.Click += 
        new Office._CommandBarButtonEvents_ClickEventHandler(ImportButtonClick);

    commandBar.Visible = true;
}
catch (ArgumentException e)
{
    MessageBox.Show(e.Message, "Error adding toolbar button", 
        MessageBoxButtons.OK, MessageBoxIcon.Error);
}

Private Sub ImportButtonClick(ByVal ctrl As Office.CommandBarButton, _
                           ByRef cancel As Boolean)
    Dim importDialog As ImportDialogBox = New ImportDialogBox()
    importDialog.Show()
End Sub

private void ImportButtonClick(Office.CommandBarButton ctrl, ref bool cancel)
{
   ImportDialogBox importDialog = new ImportDialogBox();
   importDialog.Show();
}

Imports System
Imports System.Collections
Imports System.Deployment.Application     ' For ClickOnce properties.
Imports System.Text
Imports System.Windows.Forms
Imports Office = Microsoft.Office.Core
Imports Excel = Microsoft.Office.Interop.Excel

using System;
using System.Collections;
using System.Deployment.Application;    // For ClickOnce properties.
using System.Text;
using System.Windows.Forms;
using Office = Microsoft.Office.Core;
using Excel = Microsoft.Office.Interop.Excel;

Private Const DOT_SEPARATOR As Char = "."c
Private Const COMMA_SEPARATOR As Char = ","c

Dim xlDirectory As String
Dim xlFile As String
Dim xlApp As Excel.Application
Dim xlWorkbook As Excel.Workbook
Dim xlWorksheet As Excel.Worksheet
Dim headerRange As Excel.Range
Dim projectRange As Excel.Range

Dim taskRows As ArrayList = New ArrayList()
Dim excelColumns As ArrayList = New ArrayList()
Dim columnLetters As Hashtable = New Hashtable()

private const char DOT_SEPARATOR = '.';
private const char COMMA_SEPARATOR = ',';

private System.Object xx = System.Type.Missing;
private string xlDirectory;
private string xlFile;

private Excel.Application xlApp;
private Excel.Workbook xlWorkbook;
private Excel.Worksheet xlWorksheet;
private Excel.Range headerRange;
private Excel.Range projectRange;

private ArrayList taskRows = new ArrayList();
private ArrayList excelColumns = new ArrayList();
private Hashtable columnLetters = new Hashtable();

Enum Column
   TaskId = 1
   WBS = 2
   TaskName = 3
   TaskCF = 4
   Duration = 5
   Start = 6
   Finish = 7
   Predecessors = 8
   Notes = 9
End Enum

enum Column
{
   TaskId = 1,
   WBS = 2,
   TaskName = 3,
   TaskCF = 4,
   Duration = 5,
   Start = 6,
   Finish = 7,
   Predecessors = 8,
   Notes = 9
}

Imports System

Public Class ColumnInfo

    Private _name As String
    Private _letter As String
    Private _number As Integer

    Public Sub New(ByVal colName As String, _
                   ByVal colLetter As String, _
                   ByVal nextColNumber As Integer)
        Name = colName
        Letter = colLetter
        Number = nextColNumber
    End Sub

    Public Property Name() As String
        Get
            Return _name
        End Get
        Set(ByVal value As String)
            _name = value
        End Set
    End Property

    Public Property Letter() As String
        Get
            Return _letter
        End Get
        Private Set(ByVal value As String)
            _letter = value
        End Set
    End Property

    Public Property Number() As Integer
        Get
            Return _number
        End Get
        Set(ByVal value As Integer)
            _number = value
        End Set
    End Property

End Class

using System;

namespace ImportProject
{
    class ColumnInfo
    {
        public ColumnInfo(string colName, string colLetter, int nextColNumber)
        {
            Name = colName;
            Letter = colLetter;
            Number = nextColNumber;
        }

        // Autoimplemented properties are new in Visual C# 2008.
        // Read-only properties have private set.
        public string Name { get; set; }
        public string Letter { get; private set; }
        public int Number { get; private set; }
    }
}

Private Function GetExcelColumnInfo(ByVal file As String) As Array
    Dim startCell As String
    Dim endCell As String
    startCell = columnLetters(DirectCast(Column.TaskId, Integer)) _
                + mtxtRowHeader.Text.Trim()
    endCell = columnLetters(DirectCast(Column.Predecessors, Integer)) _
                + mtxtRowHeader.Text.Trim()
    headerRange = xlWorksheet.Range(startCell, endCell)

    Dim headerCells As Array = Nothing
    headerCells = TryCast(headerRange.Cells.Value2, Array)
    Return headerCells
End Function

private Array GetExcelColumnInfo(string file)
{
   string startCell = columnLetters[(int)Column.TaskId] 
                      + mtxtRowHeader.Text.Trim();
   string endCell = columnLetters[(int)Column.Predecessors] 
                    + mtxtRowHeader.Text.Trim();
   headerRange = xlWorksheet.get_Range(startCell, endCell);

   Array headerCells = (Array)headerRange.Cells.Value2;
   return headerCells;
}

Private Sub StoreColumnInfo(ByVal headerCells As Array)
    Dim colName As String
    Dim colLetter As String
    Dim numColumns As Integer = headerCells.GetLength(1)
    Dim i As Integer

    For i = 1 To numColumns
        colName = headerCells.GetValue(1, i).ToString()
        colLetter = columnLetters(i).ToString()
     Dim thisColumn As ColumnInfo
     
     thisColumn = New ColumnInfo(colName, colLetter, i)
     excelColumns.Add(thisColumn)
    Next i
End Sub

private void StoreColumnInfo(Array headerCells)
{
   string colName, colLetter;
   int numColumns = headerCells.GetLength(1);

   for (int i = 1; i <= numColumns; i++)
   {
       colName = headerCells.GetValue(1, i).ToString();
       colLetter = columnLetters[i].ToString();
       
       var column = new ColumnInfo(colName, colLetter, i);
       excelColumns.Add(column);
   }
}

using System;

namespace ImportProject
{
    class TaskRow
    {
        // Private member variables needed only for storing start and finish dates in
        // Coordinated Universal Time (UTC).  
        private DateTime startDateUTC;
        private DateTime finishDateUTC;

        public TaskRow(double taskId,
                       string wbs,
                       int level,
                       string taskName,
                       string taskCf,
                       string duration,
                       double startDate,
                       double finishDate,
                       string predecessors,
                       string notes)
        {
            TaskId = Convert.ToInt32(taskId);
            Wbs = wbs;
            Level = level;
            TaskName = taskName;
            TaskCustomField = taskCf;
            Duration = duration;
            Predecessors = predecessors;
            Notes = notes;

            // Automation imports dates from Excel as type double. Convert to DateTime. 
            // Store both the local time and the UTC for dates.
            StartDate = DateTime.FromOADate(startDate);
            FinishDate = DateTime.FromOADate(finishDate);

            StartDateUTC = startDateUTC;
            FinishDateUTC = finishDateUTC;
        }
        // Autoimplemented properties. Read-only properties have private set.
        public int TaskId { get; private set; }
        public string Wbs { get; set; }
        public int Level { get; set; }
        public string TaskName { get; set; }
        public string TaskCustomField { get; set; }
        public string Duration { get; set; }
        public string Predecessors { get; private set; }
        public string Notes { get; set; }

        // Store all start and finish times as UTC. Add the DateTimeKind value 
        // so consumer knows whether the date is local or UTC.
        public DateTime StartDate 
        {
            get
            {
                // Convert UTC to local time for a property get.
                return DateTime.SpecifyKind(startDateUTC.ToLocalTime(), 
                    DateTimeKind.Local);
            } 
            set
            {
                startDateUTC = value.ToUniversalTime();
            }
        }

        public DateTime FinishDate 
        {
            get
            {
                // Convert UTC to local time for a property get.
                return DateTime.SpecifyKind(finishDateUTC.ToLocalTime(), 
                    DateTimeKind.Local);
            }
            set
            {
                finishDateUTC = value.ToUniversalTime();
            }
        }
        public DateTime StartDateUTC
        {
            get
            {
                // No conversion needed for a property get of UTC time.
                return DateTime.SpecifyKind(startDateUTC, DateTimeKind.Utc);
            }
            set
            {
                startDateUTC = value;
            }
        }

        public DateTime FinishDateUTC
        {
            get
            {
                // No conversion needed for a property get of UTC time.
                return DateTime.SpecifyKind(finishDateUTC, DateTimeKind.Utc);
            }
            set
            {
                finishDateUTC = value;
            }
        }
    }
}

Private Function ImportTasksFromExcel(ByVal file As String) As Array
    Dim startCell As String
    Dim endCell As String
    startCell = columnLetters(DirectCast(Column.TaskId, Integer)) _
                + mtxtRowBegin.Text.ToString()
    endCell = columnLetters(DirectCast(Column.Notes, Integer)) _
              + mtxtRowEnd.Text.ToString()

    projectRange = xlWorksheet.Range(startCell, endCell)

    Dim projectCells As Array = Nothing
    projectCells = TryCast(projectRange.Cells.Value2, Array)
    Return projectCells
End Function

private Array ImportTasksFromExcel(string file)
{
   string startCell = columnLetters[(int)Column.TaskId] 
       + mtxtRowBegin.Text.ToString();

   string endCell = columnLetters[(int)Column.Notes] 
       + mtxtRowEnd.Text.ToString();

   projectRange = xlWorksheet.get_Range(startCell, endCell);

   Array projectCells = (Array)projectRange.Cells.Value2;
   return projectCells;
}