The Building Coder

Grouping Schedule Headers and How to Do Something

Here is my first real Revit 2014 post, sharing some code friendlily provided by David Robison of Design Master showing how to use the ViewSchedule.GroupHeaders method.

Using the ViewSchedule GroupHeaders Method

Question: I am trying to call ViewSchedule.GroupHeaders, and it keeps throwing an unhandled argument exception saying "Headers could not be grouped. Parameter name: right".

Answer: Yes, this issue has been raised in the past and a few solutions were suggested.

First case

The ViewSchedule.GroupHeaders produces the argument exception mentioned above.

After a schedule is created, however, calling it directly with the same parameters succeeds, so the issue is not related to the arguments provided.

I investigated this issue and found 2 workarounds:

1. Activate the new schedule view and then group the header.
2. Refresh the new schedule view and then group the header when the schedule is out of data.

It seems that the second workaround is the right way to 'fix' this issue. We have to manually refresh the schedule data if the view is out of data. This behaviour is by design.

Second case

The API cannot get the updated value in Body section if the schedule view is not opened.

Close the schedule view:

1. IsCellOverridden returns True;
2. ResetCellOverride;
3. IsCellOverridden also returns True;

Open the schedule view:

1. IsCellOverridden returns True;
2. ResetCellOverride;
3. IsCellOverridden returns False (as expected);

The workaround is to call viewSchedule.GetTableData again.

The API calls will not work in the body section if the schedule view is closed.

The root cause is that the schedule data (especially the body section) will not be updated if the schedule view is closed.

This is no problem for the user interface, and improves performance because the schedule data is not regenerated. It does cause a problem in the API, though.

Response: I got this to work using the suggestion in first case #1.

I created the schedule, closed the transaction, set the schedule to the ActiveView and then grouped the headers.

I also discovered that the column indexes ignore hidden columns.

Here is a sample external command demonstrating the ViewSchedule.GroupHeaders function. Please note the comments describing some of the steps in more detail:

public Result Execute(
  ExternalCommandData commandData,
  ref string message,
  ElementSet elements )
{
  try
  {
    UIDocument uidoc = commandData.Application
      .ActiveUIDocument;
 
    Document doc = uidoc.Document;
 
    // Create the schedule
 
    Transaction tran = new Transaction( doc );
    tran.Start( "Create schedule" );
 
    ViewSchedule sampleSchedule
      = ViewSchedule.CreateSchedule( doc, new
        ElementId( BuiltInCategory.OST_Windows ) );
 
    foreach( ElementId id in
      ViewSchedule.GetAvailableParameters( doc, new
        ElementId( BuiltInCategory.OST_Windows ) ) )
    {
      try
      {
        sampleSchedule.Definition.AddField(
          new SchedulableField(
            ScheduleFieldType.Instance, id ) );
      }
      catch( Exception )
      {
      }
    }
    ScheduleDefinition sampleDefinition
      = sampleSchedule.Definition;
 
    // Hide two columns in the schedule
 
    sampleDefinition.GetField( 0 ).IsHidden = true;
    sampleDefinition.GetField( 1 ).IsHidden = true;
 
    // Commit the schedule. This is important so 
    // you can set the active view.
 
    tran.Commit();
 
    // Change the active view to the schedule. 
    // This is required before the GroupHeaders 
    // function will work.
 
    uidoc.ActiveView = sampleSchedule;
 
    // Group the last three headers.
    // Hidden fields are not counted in the left 
    // and right values, so make sure to account 
    // for that.
 
    tran.Start( "Group headers" );
 
    int iFieldCount = sampleDefinition
      .GetFieldCount();
 
    sampleSchedule.GroupHeaders( 0,
      iFieldCount - 5, 0,
      iFieldCount - 3, "Group Header" );
 
    tran.Commit();
 
    return Result.Succeeded;
  }
  catch( Exception ex )
  {
    MessageBox.Show( ex.ToString(),
      "Group Headers Sample" );
 
    return Result.Failed;
  }
}

Here are two important pieces of information I learned:

1. You have to set the active view to the schedule before the GroupHeaders method will work.
2. The left and right indices do not include hidden columns, so you need to make sure to adjust for those.

For completeness' sake, here is GroupHeadersSampler.zip containing the complete source code, Visual Studio solution and add-in manifest for this command.

Many thanks to David for testing this and sharing the code. Hopefully you are able to make good use of this sample.

Before closing, here is are some thoughts on how to research automating something using the Revit API in general, the kind of suggestions I regularly provide orally and seldom wind up putting down clearly and separately in writing:

How to Research Automating Something

Question: I would like to create a dimension that differs from the normal linear dimension style within the template.

Here is an example of the normal dimension style and the modified variant I would like, with the dimension text sticking out on the side like this instead:

How can I realise this programmatically, please?

Answer: There is a simple standard procedure for exploring this kind of issue.

First of all, determine whether what you wish is possible manually in the user interface.

If not, then it is probably not possible programmatically either.

If yes, then the two models before and after can be compared using RevitLookup, included with the Revit SDK, to analyse the differences.

That might give a hint how to achieve it programmatically.

If no differences can be found, then it is maybe impossible.

In this case, you can apparently achieve your goal manually, so the first hurdle is already taken.

Looking at the NewDimension method and the Dimension class members, I see no obvious input arguments or properties that might affect the dimension in the desired way.

Therefore, the only remaining things to check are the parameters on the dimension object.

You can list those before and after using RevitLookup or the built-in parameter BipChecker and compare.

I hope this helps.

Response: Yes, as you say, I know that it is possible to create this manually.

And yes, the text position and leader information are not shown in the standard UI, nor visible in RevitLookup.

I guess that this specific task cannot be achieved programmatically at this moment, then.

Answer: Sorry about that.

I hope the standard exploration procedure described above will prove useful anyway.

Cloud & Mobile, Extensible Storage Data Use in Schedules

My topics for today are:

• Cloud and mobile topics I covered so far
• Cloud-based round-trip 2D Revit model editing on any mobile device using SVG
• Extensible storage data use in schedules

I am still meeting with my European DevTech colleagues here in Konk Leon, 'anse du Lèon', the cove of the lion, aka Le Conquet, Brittany.

Yesterday, one of our topics was work we have done so far for cloud and mobile applications. It was very interesting to hear about my peers' rich and varied experiences.

Cloud and Mobile Topics Covered so Far

I documented all my own experiences so far here on the blog, and was able to reuse that for my presentation quite spontaneously with no further preparation:

• Accessing a REST API web service from a Revit .NET add-in – Apollonian sphere packing and AVF.
• Thoughts on mobile indoor positioning, representing room polygons in SVG, the Azure SDK, ASP.NET MVC 4, and implementing a web service.
• An overview of the BIM 360 Glue viewer and REST API.
• BIM 360 Glue REST API authentication using Python.
• A room polygon and furniture picker in SVG.
• 2D SVG editing on mobile devices using the Raphaël JavaScript SVG library.

As I explained at the time, all of the explorations involving SVG are part of a larger master plan.

This plan has now matured to a certain extent and is forcing me to move ahead quite fast in the immediate future.

The main outcome so far is a presentation proposal that I submitted for the internal Autodesk technical summit taking place in June, and the fact that it was accepted.

My cloud and mobile roadmap is thus now clearly focused on implementing that proposal:

Cloud-based Round-trip 2D Revit Model Editing on any Mobile Device using SVG

I described the roadmap I envision in the discussion of my simple SVG editor. The main components include:

• A Revit add-in that determines room boundary and furniture and equipment family instance polygons for a simplified 2D plan view rendering.
• A cloud-based database repository managing the models, levels, rooms, furniture, equipment meta- and polygon data.
• The SVG editor running in a browser on any device, rendering the model and supporting some simple geometric modification.

Here is the actual wording of my technical summit proposal:

Proposal Abstract

This presentation demonstrates round-trip editing a 2D rendering of a Revit model on any mobile device with no need for installation of any additional software whatsoever beyond a browser. How can this be achieved? A Revit add-in exports polygon renderings of room boundaries and other elements such as furniture and equipment to a cloud-based repository. On the mobile device, the repository is queried and the data is rendered in a standard browser using JavaScript and SVG. The rendering supports modification, such as translation and rotation of the furniture and equipment, which is saved back to the cloud database. The Revit add-in picks up these changes and updates the Revit model.

Intended Audience and Prerequisites

Intended audience is programmers with interest in cloud-based and mobile computing, specifically interest in round-trip editing of a Revit model using a cloud-based data repository and editing a 2D model on an arbitrary mobile device with no additional software beyond a browser installed on it. 
Knowledge of .NET, JavaScript and REST programming is helpful but not required. Revit add-in experience is not a prerequisite.

Presentation Outline

• Show a Revit model.
• Export the model to a cloud-based data repository.
• Query and display the repository contents as 2D rendering on a mobile device.
• Edit the model in the browser on the mobile device, updating the data repository.
• Pick up and display the modified model in Revit.

Two of the important components whose implementation I plan to explore next are the polygon generation and data model:

Plan View Polygon Determination

The generation of the room boundary polygons is obvious, since the room has a boundary property.

For the furniture and equipment family instance, the solution is a less immediate. My current idea is to explore making use of the ExtrusionAnalyzer class. It is supplied a solid geometry, a plane, and a direction. From those, it calculates the outer boundary of the shadow cast by the solid onto the input plane along the extrusion direction. As far as I can tell, that should be exactly what I need.

Scott Conover mentioned this class in his session on the Geometry API, a continuation of his AU 2011 presentation CP4011 'Geometric Progression: Further Analysis of Geometry Using the Autodesk Revit 2012 API', enhanced for the Revit 2013 API.

As soon as I have the polygons determined, I want to implement functionality to render them easily. This will involve extent calculation, canvas definition, and coordinate system transformation. I will probably implement a simple .NET geometry viewer before moving on to the SVG rendering. I've been wanting to do that for a long time...

Cloud-based Data Repository

So far, my colleagues have been focusing on using the Amazon and Azure cloud hosting services, and many discussions on the cloud and mobile DevBlog deal with them.

I searched the Internet for other cloud-based database alternatives, and right now CouchDB looks pretty promising, so I might try a completely different approach using that instead.

There is a lot to do here as well: define the data model, set up the web service, define a format for saving the polygon data, etc. At the very least, I will need to manage:

• Model > metadata, rooms.
• Room > metadata, model, furniture, level, polygon.
• Furniture > metadata, room, polygon, transformation (initially identity).

Round tripping the information will be interesting, especially if I want the Revit model to update automatically when furniture positions are modified on the mobile device, which I certainly do, if only for the wow effect :-)

Stay tuned...

... Oh, and, yeah, wish me luck!

Extensible Storage Data Use in Schedules

Returning to the desktop again, here is a recent question from a developer on using estorage data in a schedule that leads to some general observations on that topic:

Question: I would like to display my extensible storage information in a schedule. I searched high and low, though, and was unable to find any samples or documentation on the subject. Can you help?

Answer: There is a good reason why you have not found anything: there is no such support.

The usage of extensible storage data is utterly and completely up to the add-in itself. The Revit API offers no support whatsoever for making use of estorage data in any way. The only support provided is for storage and retrieval, nothing else.

Well, one tiny little detail more: if an element id value is stored, and the element id is later modified by some worksharing operation, its value will be automatically updated.

On the other hand, there is currently no direct support for putting data into a schedule either.

I am no user interface expert, but I think that you can set up a schedule to be populated from certain parameter values via the user interface. You would have to talk with an application engineer or product support or explore this topic on the Internet to find out how that can be done.

Of course, there is nothing stopping you from extracting your data from extensible storage and transferring it into parameters set up to populate a schedule yourself.

I hope that answers your question and helps you get started successfully.

Retrieving Schedules on a Sheet

Guy Robinson recently explained an easy way to access all elements in a schedule.

Victor Chekalin picked up and expanded on that.

Here is his solution to retrieve all schedules in a view and elements from a schedule. In his own words:

One wonderful day I had to retrieve schedules which are presented on a sheet:

At first I looked at the Revit API Help but unfortunately there is no method such as GetSchdulesOnView in the ViewSheet class. There is no explicit way to get it. After a couple of hours trying to achieve that I need I encountered Guy's simple solution to access all elements in a schedule. The solution is use FilteredElementCollector and pass in the element id of the view in which you want to collect elements.

I created the following simple extension method GetSchedules to get schedules on view:

  public static class ViewSheetExtensions
  {
    public static IEnumerable<ViewSchedule>
      GetSchedules( this ViewSheet viewSheet )   
    {
      var doc = viewSheet.Document;
 
      FilteredElementCollector collector =
        new FilteredElementCollector(
          doc, viewSheet.Id );
 
      var scheduleSheetInstances =
        collector
          .OfClass( typeof( ScheduleSheetInstance ) )
          .ToElements()
          .OfType<ScheduleSheetInstance>();
 
      foreach( var scheduleSheetInstance in
        scheduleSheetInstances )
      {
        var scheduleId =
          scheduleSheetInstance
            .ScheduleId;
 
        if( scheduleId == ElementId.InvalidElementId )
          continue;
 
        var viewSchedule =
          doc.GetElement( scheduleId )
          as ViewSchedule;
 
        if( viewSchedule != null )
          yield return viewSchedule;
      }
    }
  }

It can be used like this:

  var schedules = viewSheet
    .GetSchedules()
    .ToList();

  foreach( var viewSchedule in schedules )
  {
    // Do something
  }

Here is the demo result:

But I decided not to stop and go deeper. The next step is to get all elements which are involved in a schedule. The approach is the same as with schedules. Using FiltereredElementCollector but instead of the ViewSheet element id we pass in the ViewSchedule id.

The extension method is similar:

  public static class ViewScheduleExtensions
  {
    public static IEnumerable<ElementId>
      GetElementIdsInSchedule(
        this ViewSchedule viewSchedule )
    {
      var doc = viewSchedule.Document;
 
      FilteredElementCollector collector =
        new FilteredElementCollector(
          doc, viewSchedule.Id );
 
      var elementIds = collector
        .WhereElementIsNotElementType()
        .ToElementIds();
 
      return elementIds;
    }
  }

But there is an additional little nuance. If I retrieve elements from a material takeoff schedule, the method will return all materials in the project together with other elements. The solution is to just skip all elements which are materials:

  foreach( var id in elementIds )
  {
    var element = doc.GetElement( id );
 
    if( element is Material )
      continue;
 
    // Do something
  }

Here is the result of my demo project:

I attached the demo Visual Studio solution and Revit project.

I hope this information will useful for developers.

Have a nice day,
Victor.

Accessing all Elements in a Schedule

Here is a quick little post, with a surprisingly short and simple answer to a short and seemingly difficult Revit API question.

Before getting to that, I will just mention that I arrived safe and sound in Paris for a developer conference here. I had a walk in the sunset on the north bank of the Seine from the Gare de Lyon along the industrial areas on Quai de Bercy and crossed the river over the new-built Pont National to reach the rue de Tolbiac by a rather roundabout route.

So, back to Revit; how can we easily retrieve all the elements listed in a schedule view?

Question: The Revit 2013 API finally enabled the creation of schedule views, which is great.

I would also need to query that schedule and retrieve all the element ids of the elements contained in it.

Currently, I am using the workaround of exporting the schedule and then comparing with elements within the project, which takes a considerable amount of time.

Is there any simpler way to achieve this?

Answer: Yes, there is.

The schedule is a view, and its view id can be passed in to the filtered element collector just like any other.

That will return the relevant elements.

Sorry you had to go to all that unnecessary trouble :-)

Many thanks to Guy Robinson for pointing this out!

Geometry Object Subcategory

I received and have started installing and learning to use my new laptop, which is a Mac, I'm finishing up my preparations for Autodesk University, and I'm working on preparations for upcoming developer conferences, so you can imagine there is rather a lot to do and 24 hours per day seem very limiting. I love the Unix shell! Goodbye, DOS box.

Thank goodness my colleague Joe Ye answered a case that I found interesting and would like to share with you, since Joe is busy preparing his own Chinese developer meetings and conferences:

Question: I am trying to determine the subcategory of each solid element in a family.

Can this be done using the API?

My family that has two different solids and they have different subcategories.

I want to know which solid I am looking at and figured that subcategories would be a good way to go, since they can be applied to solids in a family.

Please note that the family with the subcategories must be nested as a non-shared family and I have to find out what element geometry is what in the supercomponent family.

I know that I can find out what subcategory each solid element belongs to when I open the family, but can I do so when its loaded as well?

Is there any other way of identifying different geometry objects once a family instance has been placed in the project? Besides looking at the geometrical aspects such as volume, areas etc.

Answer: Yes, you can retrieve the solid category from the family instance in the model.

The category information is stored in the Solid object's GraphicStyle property.

The following code retrieves all the solid category names from a selected family instance:

[Transaction( TransactionMode.ReadOnly )]
public class Command : IExternalCommand
{
  public Result Execute(
    ExternalCommandData commandData,
    ref string message,
    ElementSet elements )
  {
    UIApplication uiapp = commandData.Application;
    UIDocument uidoc = uiapp.ActiveUIDocument;
    Application app = uiapp.Application;
    Document doc = uidoc.Document;
 
    Selection sel = uidoc.Selection;
 
    Reference r = sel.PickObject( ObjectType.Element,
      "Please pick a family instance" );
 
    Element e = doc.GetElement( r );
 
    GeometryElement geoElem = e.get_Geometry(
      new Options() );
 
    int n = 0;
    string s = string.Empty;
 
    foreach( GeometryObject obj in geoElem )
    {
      if( obj is GeometryInstance )
      {
        GeometryInstance geoInst
          = obj as GeometryInstance;
 
        GeometryElement geoElem2
          = geoInst.GetSymbolGeometry();
 
        foreach( GeometryObject geoObj2 in geoElem2 )
        {
          if( geoObj2 is Solid )
          {
            Solid solid = geoObj2 as Solid;
 
            ElementId id = solid.GraphicsStyleId;
 
            GraphicsStyle gStyle = doc.GetElement(
              id ) as GraphicsStyle;
 
            if( gStyle != null )
            {
              ++n;
              s += gStyle.GraphicsStyleCategory.Name
                + "\r\n";
            }
          }
        }
      }
    }
 
    TaskDialog.Show( n.ToString() + " Graphics Styles",
      s );
 
    return Result.Succeeded;
  }
}

Here is an example of running this and selecting one of the doors in the basic sample project:

The following materials are listed for this instance:

Many thanks to Joe for this answer!

Listing all Schedules Placed on a Sheet

Meanwhile, Saikat discusses yet another use of the temporary transaction and deletion trick to determine all schedules placed on a given sheet.

In this case, the trick is to temporarily delete the sheet and watch which schedules are wiped out by that operation.

Note that in a comment on that post, Phillip Miller points out a way to achieve the same result using a filtered element collector taking a view id argument.

Who is going to create a benchmark comparing the relative speed of these two approaches?

The Schedule API and Access to Schedule Data

Somehow I seem to be spending the vast majority of my time just shovelling information back and forth, preparing for conferences and trainings and answering questions. It is always a great pleasure for me to actually get in a teeny weenie bit of programming in between, so I am happy that I managed to find time to create the new little sample application described below.

One of the many exciting enhancements in the Revit 2013 API is the new Schedule API. Here is the description from the Revit API help file RevitAPI.chm What's New section:

Schedule API

Several new classes have been added to allow schedule views to be created, modified, and added to drawing sheets. Major new classes include:

• The ViewSchedule class that represents the schedule view. Its create methods are used to create new schedules.
• The ScheduleField class for the individual fields in a schedule.
• The ScheduleSheetInstance class represents schedules placed on sheets. The create method creates an instance of a schedule on a sheet.
• The ScheduleDefinition class defines the contents of a schedule view, including:
  1. Basic properties that determine the kind of schedule, such as the schedule's category.
  2. A set of fields that become the columns of the schedule.
  3. Filters that restrict the set of elements visible in the schedule.
  4. Sorting and grouping criteria.

Running API commands in Schedule Views

API commands may now be active when a Schedule is active in the current document.

Schedule export

The ViewSchedule class has been added to the API and the method ViewSchedule.Export method exports an existing schedule to a text file.

As I already mentioned, the ability to create a schedule is demonstrated by the ScheduleCreation SDK sample.

Before even dreaming of creating new schedules, however, many people are interested in simply accessing the data in existing ones.

Accessing Schedule Data

Fitting in nicely with this, a couple of queries recently came in on accessing schedule data.

The Revit API currently does not provide a method to access and cycle through the schedule data directly.

The new Revit 2013 schedule export functionality described above provides for a very simple workaround, however: you can use the ViewSchedule.Export method to export the schedule data to a text file, and then parse the resulting file to access the data.

The ViewSchedule.Export method takes a ViewScheduleExportOptions argument which provides the following properties to enable specification of various text file output settings:

• ColumnHeaders: how to export column headers. Default is MultipleRows.
• FieldDelimiter: how to delimit fields. Default is Tab.
• HeadersFootersBlanks: whether to export group headers, footers, and blank lines. Default is true.
• TextQualifier: how to qualify text fields. Default is DoubleQuote.

ScheduleData Sample Add-in

I created a sample application to demonstrate accessing the schedule data, and not just that. It also implements the following interesting additional features:

• Access and read back the schedule data from the exported text file into your application.
• Separately determine the schedule name, the column header names, and the schedule row data.
• Populate a DataTable instance with the retrieved schedule data.
• Create a new Windows form with a docked DataGridView in it programmatically, avoiding the need to define a hard-coded form in your add-in.
• Attach the form to the Revit main window, so that it is minimised and restored together with Revit.
• Populate the DataGridView from the DataTable and display the results.

I use the undocumented AdWindows assembly to determine the Revit parent window.

It returns the main window Revit handle in the static property ApplicationWindow of the ComponentManager class in the Autodesk.Windows namespace.

Here is the JtWindowHandle class that I use to convert the IntPtr returned by that property to the IWin32Window required by the Form.Show method:

  /// <summary>
  /// Wrapper class for converting 
  /// IntPtr to IWin32Window.
  /// </summary>
  public class JtWindowHandle : IWin32Window
  {
    IntPtr _hwnd;
 
    public JtWindowHandle( IntPtr h )
    {
      Debug.Assert( IntPtr.Zero != h,
        "expected non-null window handle" );
 
      _hwnd = h;
    }
 
    public IntPtr Handle
    {
      get
      {
        return _hwnd;
      }
    }
  }

Exporting the schedule data from Revit is really simple. Here is the implementation to export all schedule data in the entire model to separate text files with the filename extension TXT, defined by _ext, in a hard-coded folder, defined by _export_folder_name:

  FilteredElementCollector col
    = new FilteredElementCollector( doc )
      .OfClass( typeof( ViewSchedule ) );
 
  ViewScheduleExportOptions opt 
    = new ViewScheduleExportOptions();
 
  foreach( ViewSchedule vs in col )
  {
    Directory.CreateDirectory( 
      _export_folder_name );
 
    vs.Export( _export_folder_name, 
      vs.Name + _ext, opt );
  }

The application then asks the user to select any one of the resulting text output files at a time to display its data in the data grid view. When the user cancels the file selection, the command is terminated:

  string filename;
 
  while( FileSelect( _export_folder_name, 
    out filename ) )
  {
    DisplayScheduleData( filename, 
      revit_window );
  }

Here is the DisplayScheduleData method that programmatically sets up a new Windows form, populates it with a docked DataGridView instance, and populates that with the schedule data retrieved from the output text files by the ScheduleDataParser class:

  void DisplayScheduleData( 
    string filename, 
    IWin32Window owner )
  {
    ScheduleDataParser parser 
      = new ScheduleDataParser( filename );
 
    System.Windows.Forms.Form form 
      = new System.Windows.Forms.Form();
    form.Size = new Size( 400, 400 );
    form.Text = _caption_prefix + parser.Name;
 
    DataGridView dg = new DataGridView();
    dg.AllowUserToAddRows = false;
    dg.AllowUserToDeleteRows = false;
    dg.AllowUserToOrderColumns = true;
    dg.Dock = System.Windows.Forms.DockStyle.Fill;
    dg.Location = new System.Drawing.Point( 0, 0 );
    dg.ReadOnly = true;
    dg.TabIndex = 0;
    dg.DataSource = parser.Table;
    dg.Parent = form;
 
    form.ShowDialog( owner );
  }

You could obviously make the form modeless instead of modal by calling Show instead of ShowDialog here. Since we are not accessing the Revit API from the form, there is no danger in leaving it open after the external command terminates. That would enable navigation and exploration of the schedule data in a modeless form in parallel with continued work in the Revit model.

Finally, here is the main point, the ScheduleDataParser class that I implemented to extract the schedule name, column headers, and schedule data from the text file and populate a DataTable instance with it:

class ScheduleDataParser
{
  /// <summary>
  /// Default schedule data file field delimiter.
  /// </summary>
  static char[] _tabs = new char[] { '\t' };
 
  /// <summary>
  /// Strip the quotes around text strings 
  /// in the schedule data file.
  /// </summary>
  static char[] _quotes = new char[] { '"' };
 
  string _name = null;
  DataTable _table = null;
 
  /// <summary>
  /// Schedule name
  /// </summary>
  public string Name 
  { 
    get { return _name; } 
  }
 
  /// <summary>
  /// Schedule columns and row data
  /// </summary>
  public DataTable Table 
  { 
    get { return _table; } 
  }
 
  public ScheduleDataParser( string filename )
  {
    StreamReader stream = File.OpenText( filename );
 
    string line;
    string[] a;
 
    while( null != ( line = stream.ReadLine() ) )
    {
      a = line
        .Split( _tabs )
        .Select<string, string>( s => s.Trim( _quotes ) )
        .ToArray();
 
      // First line of text file contains 
      // schedule name
 
      if( null == _name )
      {
        _name = a[0];
        continue;
      }
 
      // Second line of text file contains 
      // schedule column names
 
      if( null == _table )
      {
        _table = new DataTable();
 
        foreach( string column_name in a )
        {
          DataColumn column = new DataColumn();
          column.DataType = typeof( string );
          column.ColumnName = column_name;
          _table.Columns.Add( column );
        }
 
        _table.BeginLoadData();
 
        continue;
      }
 
      // Remaining lines define schedula data
 
      DataRow dr = _table.LoadDataRow( a, true );
    }
    _table.EndLoadData();
  }
}

Here is a sample schedule in Revit to test this on:

This is the resulting data grid view representation:

Here is ScheduleData.zip containing the complete source code, Visual Studio solution and add-in manifest for this add-in.

On a closely related note, here is another question that just came in:

Question: Can calculated values in schedules be transferred to a shared parameter with some API code?

Answer: Sure. Just access the schedule data as demonstrated above, and then write the relevant value to the shared parameter.