#region Assembly Microsoft.Office.Interop.Excel.

dll,
v1.1.4322
// C:\Program Files (x86)\Microsoft Visual Studio
10.0\Visual Studio Tools for
Office\PIA\Office12\Microsoft.Office.Interop.Excel.dll
#endregion

using System;
using System.Collections;
using System.Reflection;
using System.Runtime.InteropServices;

namespace Microsoft.Office.Interop.Excel
{
// Summary:
// Represents a cell, a row, a column, a selection
of cells containing one or
// more contiguous blocks of cells, or a 3-D range.
[Guid("00020846-0000-0000-C000-000000000046")]
[TypeLibType(4096)]
[InterfaceType(2)]
public interface Range
{
[DispId(1063)]
dynamic AddIndent { get; set; }
[DispId(2020)]
bool AllowEdit { get; }
[DispId(148)]
Application Application { get; }
[DispId(568)]
Areas Areas { get; }
[DispId(435)]
Borders Borders { get; }
[DispId(238)]
Range Cells { get; }
[DispId(240)]
int Column { get; }
[DispId(241)]
Range Columns { get; }
 [DispId(242)]
dynamic ColumnWidth { get; set; }
[DispId(910)]
Comment Comment { get; }
[DispId(118)]
int Count { get; }
//
// Summary:
// Counts the largest value in a given Range of
values. Read-only.
//
// Returns:
// Object
[DispId(2499)]
dynamic CountLarge { get; }
[DispId(149)]
XlCreator Creator { get; }
[DispId(501)]
Range CurrentArray { get; }
[DispId(243)]
Range CurrentRegion { get; }
[DispId(543)]
Range Dependents { get; }
[DispId(545)]
Range DirectDependents { get; }
[DispId(546)]
Range DirectPrecedents { get; }
[DispId(246)]
Range EntireColumn { get; }
[DispId(247)]
Range EntireRow { get; }
[DispId(2015)]
Errors Errors { get; }
[DispId(146)]
Font Font { get; }
[DispId(1392)]
FormatConditions FormatConditions { get; }
[DispId(261)]
dynamic Formula { get; set; }
[DispId(586)]
dynamic FormulaArray { get; set; }
[DispId(262)]
dynamic FormulaHidden { get; set; }
[DispId(1380)]
XlFormulaLabel FormulaLabel { get; set; }
[DispId(263)]
dynamic FormulaLocal { get; set; }
[DispId(264)]
dynamic FormulaR1C1 { get; set; }
[DispId(265)]
dynamic FormulaR1C1Local { get; set; }
[DispId(266)]
dynamic HasArray { get; }
[DispId(267)]
dynamic HasFormula { get; }
[DispId(123)]
dynamic Height { get; }
[DispId(268)]
dynamic Hidden { get; set; }
[DispId(136)]
dynamic HorizontalAlignment { get; set; }
[DispId(1393)]
Hyperlinks Hyperlinks { get; }
[DispId(1813)]
string ID { get; set; }
[DispId(201)]
dynamic IndentLevel { get; set; }
[DispId(129)]
Interior Interior { get; }
[DispId(127)]
dynamic Left { get; }
[DispId(1187)]
int ListHeaderRows { get; }
[DispId(2257)]
ListObject ListObject { get; }
[DispId(691)]
XlLocationInTable LocationInTable { get; }
[DispId(269)]
dynamic Locked { get; set; }
[DispId(2123)]
string MDX { get; }
[DispId(1385)]
Range MergeArea { get; }
[DispId(208)]
dynamic MergeCells { get; set; }
[DispId(110)]
dynamic Name { get; set; }
[DispId(502)]
Range Next { get; }
[DispId(193)]
dynamic NumberFormat { get; set; }
[DispId(1097)]
dynamic NumberFormatLocal { get; set; }
[DispId(134)]
dynamic Orientation { get; set; }
[DispId(271)]
dynamic OutlineLevel { get; set; }
[DispId(255)]
int PageBreak { get; set; }
[DispId(150)]
dynamic Parent { get; }
[DispId(1391)]
Phonetic Phonetic { get; }
[DispId(1811)]
Phonetics Phonetics { get; }
[DispId(2013)]
PivotCell PivotCell { get; }
[DispId(731)]
PivotField PivotField { get; }
[DispId(740)]
PivotItem PivotItem { get; }
[DispId(716)]
PivotTable PivotTable { get; }
[DispId(544)]
Range Precedents { get; }
[DispId(504)]
dynamic PrefixCharacter { get; }
 [DispId(503)]
Range Previous { get; }
[DispId(1386)]
QueryTable QueryTable { get; }
[DispId(975)]
int ReadingOrder { get; set; }
[DispId(257)]
int Row { get; }
[DispId(272)]
dynamic RowHeight { get; set; }
[DispId(258)]
Range Rows { get; }
//
// Summary:
// Specifies the actions that can be performed
on the SharePoint server for
// a Microsoft.Office.Interop.Excel.Range
object.
//
// Returns:
// Microsoft.Office.Interop.Excel.Actions
[DispId(2491)]
Actions ServerActions { get; }
[DispId(585)]
dynamic ShowDetail { get; set; }
[DispId(209)]
dynamic ShrinkToFit { get; set; }
[DispId(2016)]
SmartTags SmartTags { get; }
[DispId(916)]
SoundNote SoundNote { get; }
[DispId(260)]
dynamic Style { get; set; }
[DispId(273)]
dynamic Summary { get; }
[DispId(138)]
dynamic Text { get; }
[DispId(126)]
dynamic Top { get; }
 [DispId(274)]
dynamic UseStandardHeight { get; set; }
[DispId(275)]
dynamic UseStandardWidth { get; set; }
[DispId(1387)]
Validation Validation { get; }
[DispId(1388)]
dynamic Value2 { get; set; }
//
// Summary:
// Returns or sets the vertical alignment of the
specified object.
//
// Returns:
// .
[DispId(137)]
dynamic VerticalAlignment { get; set; }
[DispId(122)]
dynamic Width { get; }
[DispId(348)]
Worksheet Worksheet { get; }
[DispId(276)]
dynamic WrapText { get; set; }
[DispId(2258)]
XPath XPath { get; }

[DispId(0)]
dynamic this[object RowIndex = Type.Missing, object
ColumnIndex = Type.Missing] { get; set; }

[TypeLibFunc(1088)]
[DispId(1027)]
dynamic _PasteSpecial(XlPasteType Paste =
XlPasteType.xlPasteAll, XlPasteSpecialOperation Operation =
XlPasteSpecialOperation.xlPasteSpecialOperationNone, object
SkipBlanks = Type.Missing, object Transpose = Type.Missing);
[DispId(905)]
[TypeLibFunc(1088)]
 dynamic _PrintOut(object From = Type.Missing, object
To = Type.Missing, object Copies = Type.Missing, object
Preview = Type.Missing, object ActivePrinter = Type.Missing,
object PrintToFile = Type.Missing, object Collate =
Type.Missing);
[DispId(304)]
dynamic Activate();
//
// Summary:
// Adds a comment to the range.
//
// Parameters:
// Text:
// Optional Object. The comment text.
[DispId(1389)]
Comment AddComment(object Text = Type.Missing);
//
// Summary:
// Filters or copies data from a list based on a
criteria range.
//
// Parameters:
// CopyToRange:
// Optional Object. The destination range for
the copied rows if Action is xlFilterCopy.
// Otherwise, this argument is ignored.
//
// Unique:
// Optional Object. True to filter unique
records only; False to filter all
// records that meet the criteria. The default
value is False.
//
// CriteriaRange:
// Optional Object. The criteria range. If this
argument is omitted, there are
// no criteria.
//
// Action:
 // Required
Microsoft.Office.Interop.Excel.XlFilterAction. Can be one of
the
// following XlFilterAction
constants:xlFilterCopyxlFilterInPlace
[DispId(876)]
dynamic AdvancedFilter(XlFilterAction Action, object
CriteriaRange = Type.Missing, object CopyToRange =
Type.Missing, object Unique = Type.Missing);
//
// Summary:
// Applies names to the cells in the specified
range.
//
// Parameters:
// IgnoreRelativeAbsolute:
// Optional Object. True to replace references
with names, regardless of the
// reference types of either the names or
references; False to replace absolute
// references only with absolute names, relative
references only with relative
// names, and mixed references only with mixed
names. The default value is True.
//
// UseRowColumnNames:
// Optional Object. True to use the names of row
and column ranges that contain
// the specified range if names for the range
cannot be found; False to ignore
// the OmitColumn and OmitRow arguments. The
default value is True.
//
// AppendLast:
// Optional Object. True to replace the
definitions of the names in Names and
// also replace the definitions of the last
names that were defined; False to
 // replace the definitions of the names in Names
only. The default value is
// False.
//
// OmitColumn:
// Optional Object. True to replace the entire
reference with the row-oriented
// name. The column-oriented name can be omitted
only if the referenced cell
// is in the same column as the formula and is
within a row-oriented named range.
// The default value is True.
//
// Names:
// Optional Object. An array of the names to be
applied. If this argument is
// omitted, all names on the sheet are applied
to the range.
//
// Order:
// Optional
Microsoft.Office.Interop.Excel.XlApplyNamesOrder. Determines
which
// range name is listed first when a cell
reference is replaced by a row-oriented
// and column-oriented range name. Can be one of
these XlApplyNamesOrder
constants:xlColumnThenRowxlRowThenColumn
// default
//
// OmitRow:
// Optional Object. True to replace the entire
reference with the column-oriented
// name. The row-oriented name can be omitted
only if the referenced cell is
// in the same row as the formula and is within
a column-oriented named range.
// The default value is True.
[DispId(441)]
 dynamic ApplyNames(object Names = Type.Missing,
object IgnoreRelativeAbsolute = Type.Missing, object
UseRowColumnNames = Type.Missing, object OmitColumn =
Type.Missing, object OmitRow = Type.Missing,
XlApplyNamesOrder Order = XlApplyNamesOrder.xlRowThenColumn,
object AppendLast = Type.Missing);
[DispId(448)]
dynamic ApplyOutlineStyles();
//
// Summary:
// Returns an AutoComplete match from the list.
//
// Parameters:
// String:
// Required String. The string to complete.
[DispId(1185)]
string AutoComplete(string String);
//
// Summary:
// Performs an autofill on the cells in the
specified range.
//
// Parameters:
// Type:
// Optional
Microsoft.Office.Interop.Excel.XlAutoFillType. Specifies the
fill
// type. Can be one of these XlAutoFillType
constants:xlFillDaysxlFillFormatsxlFillSeriesxlFillWeekdaysx
lGrowthTrendxlFillCopyxlFillDefaultdefaultxlFillMonthsxlFill
ValuesxlFillYearsxlLinearTrendIf
// this argument is xlFillDefault or omitted,
Microsoft Excel selects the most
// appropriate fill type, based on the source
range.
//
// Destination:
// Required Microsoft.Office.Interop.Excel.Range
object. The cells to be filled.
 // The destination must include the source
range.
[DispId(449)]
dynamic AutoFill(Range Destination, XlAutoFillType
Type = XlAutoFillType.xlFillDefault);
//
// Summary:
// Filters a list using the AutoFilter.
//
// Parameters:
// Operator:
// Optional
Microsoft.Office.Interop.Excel.XlAutoFilterOperator. Can be
one
// of the following XlAutoFilterOperator
constants:xlAnddefaultxlBottom10ItemsxlBottom10PercentxlOrxl
Top10ItemsxlTop10PercentUse
// xlAnd and xlOr with Criteria1 and Criteria2
to construct compound criteria.
//
// VisibleDropDown:
// Optional Object. True to display the
AutoFilter drop-down arrow for the filtered
// field; False to hide the AutoFilter drop-down
arrow for the filtered field.
// True by default.
//
// Field:
// Optional Object. The integer offset of the
field on which you want to base
// the filter (from the left of the list; the
leftmost field is field one).
//
// Criteria1:
// Optional Object. The criteria (a string; for
example, "101"). Use "=" to
// find blank fields, or use "<>" to find
nonblank fields. If this argument
 // is omitted, the criteria is All. If Operator
is xlTop10Items, Criteria1 specifies
// the number of items (for example, "10").
//
// Criteria2:
// Optional Object. The second criteria (a
string). Used with Criteria1 and
// Operator to construct compound criteria.
[DispId(793)]
dynamic AutoFilter(object Field = Type.Missing,
object Criteria1 = Type.Missing, XlAutoFilterOperator
Operator = XlAutoFilterOperator.xlAnd, object Criteria2 =
Type.Missing, object VisibleDropDown = Type.Missing);
[DispId(237)]
dynamic AutoFit();
//
// Summary:
// Automatically formats the specified range,
using a predefined format.
//
// Parameters:
// Number:
// Optional Object. True to include number
formats in the AutoFormat. The default
// value is True.
//
// Format:
// Optional
Microsoft.Office.Interop.Excel.XlRangeAutoFormat. The
specified
// AutoFormat.Some of the XlRangeAutoFormat
constants may not be available to
// you, depending on the language support (U.S.
English, for example) that you’ve
// selected or installed.
//
// Font:
// Optional Object. True to include font formats
in the AutoFormat. The default
 // value is True.
//
// Pattern:
// Optional Object. True to include pattern
formats in the AutoFormat. The default
// value is True.
//
// Width:
// Optional Object. True to include column width
and row height in the AutoFormat.
// The default value is True.
//
// Border:
// Optional Object. True to include border
formats in the AutoFormat. The default
// value is True.
//
// Alignment:
// Optional Object. True to include alignment in
the AutoFormat. The default
// value is True.
[DispId(114)]
[TypeLibFunc(64)]
dynamic AutoFormat(XlRangeAutoFormat Format =
XlRangeAutoFormat.xlRangeAutoFormatClassic1, object Number =
Type.Missing, object Font = Type.Missing, object Alignment =
Type.Missing, object Border = Type.Missing, object Pattern =
Type.Missing, object Width = Type.Missing);
[DispId(1036)]
dynamic AutoOutline();
//
// Summary:
// Adds a border to a range and sets the
Microsoft.Office.Interop.Excel.Border.Color,
//
Microsoft.Office.Interop.Excel.Border.LineStyle, and
Microsoft.Office.Interop.Excel.Border.Weight
// properties for the new border.
//
 // Parameters:
// Weight:
// Optional
Microsoft.Office.Interop.Excel.XlBorderWeight. The border
weight.
// Can be one of the following XlBorderWeight
constants:xlHairlinexlMediumxlThickxlThindefault
//
// LineStyle:
// Optional
Microsoft.Office.Interop.Excel.XlLineStyle. The line style
for the
// border. Can be one of the following
XlLineStyle
constants:xlContinuousdefaultxlDashxlDashDotxlDashDotDotxlDo
txlDoublexlLineStlyeNonexlSlantDashDotxlLineStlyeNone
//
// ColorIndex:
// Optional
Microsoft.Office.Interop.Excel.XlColorIndex. The border
color, as
// an index into the current color palette or as
an XlColorIndex constant. Can
// be one of the following XlColorIndex
constants:xlColorIndexAutomaticdefaultxlColorIndexNone
//
// Color:
// Optional Object. The border color, as an RGB
value.
[DispId(1067)]
dynamic BorderAround(object LineStyle =
Type.Missing, XlBorderWeight Weight = XlBorderWeight.xlThin,
XlColorIndex ColorIndex =
XlColorIndex.xlColorIndexAutomatic, object Color =
Type.Missing);
[DispId(279)]
dynamic Calculate();
//
// Summary:
 // Calculates a specfied range of cells.
//
// Returns:
// Object
[DispId(2364)]
dynamic CalculateRowMajorOrder();
//
// Summary:
// Checks the spelling of an object.
//
// Parameters:
// IgnoreUppercase:
// Optional Object. True to have Microsoft Excel
ignore words that are all uppercase;
// False to have Microsoft Excel check words
that are all uppercase. If this
// argument is omitted, the current setting will
be used.
//
// CustomDictionary:
// Optional Object. A string that indicates the
file name of the custom dictionary
// to be examined if the word isn't found in the
main dictionary. If this argument
// is omitted, the currently specified
dictionary is used.
//
// SpellLang:
// Optional Object. The language of the
dictionary being used. Can be one of
// the MsoLanguageID values used by the
Microsoft.Office.Core.LanguageSettings.this[Microsoft.Office
.Core.MsoAppLanguageID]
// property.
//
// AlwaysSuggest:
// Optional Object. True to have Microsoft Excel
display a list of suggested
 // alternate spellings when an incorrect
spelling is found; False to have Microsoft
// Excel pause while you input the correct
spelling. If this argument is omitted,
// the current setting will be used.
[DispId(505)]
dynamic CheckSpelling(object CustomDictionary =
Type.Missing, object IgnoreUppercase = Type.Missing, object
AlwaysSuggest = Type.Missing, object SpellLang =
Type.Missing);
[DispId(111)]
dynamic Clear();
[DispId(1390)]
void ClearComments();
[DispId(113)]
dynamic ClearContents();
[DispId(112)]
dynamic ClearFormats();
[DispId(239)]
dynamic ClearNotes();
[DispId(1037)]
dynamic ClearOutline();
//
// Summary:
// Returns a
Microsoft.Office.Interop.Excel.Range object that represents
all
// the cells whose contents are different from
the comparison cell in each column.
//
// Parameters:
// Comparison:
// Required Object. A single cell to compare to
the specified range.
[DispId(510)]
Range ColumnDifferences(object Comparison);
//
// Summary:
 // Consolidates data from multiple ranges on
multiple worksheets into a single
// range on a single worksheet.
//
// Parameters:
// CreateLinks:
// Optional Object. True to have the
consolidation use worksheet links; False
// to have the consolidation copy the data. The
default value is False.
//
// TopRow:
// Optional Object. True to consolidate data
based on column titles in the top
// row of the consolidation ranges; False to
consolidate data by position. The
// default value is False.
//
// Sources:
// Optional Object. The sources of the
consolidation as an array of text reference
// strings in R1C1-style notation. The
references must include the full path
// of sheets to be consolidated.
//
// LeftColumn:
// Optional Object. True to consolidate data
based on row titles in the left
// column of the consolidation ranges; False to
consolidate data by position.
// The default value is False.
//
// Function:
// Optional
Microsoft.Office.Interop.Excel.XlConsolidationFunction. Can
be one
// of the following XlConsilidationFunction
constants:xlAveragedefaultxlCountxlCountNumsxlMaxxlMinxlProd
uctxlStDevxlStDevPxlSumxlVarxlVarP
 [DispId(482)]
dynamic Consolidate(object Sources = Type.Missing,
object Function = Type.Missing, object TopRow =
Type.Missing, object LeftColumn = Type.Missing, object
CreateLinks = Type.Missing);
//
// Summary:
// Copies the range to the specified range or to
the Clipboard.
//
// Parameters:
// Destination:
// Optional Object. Specifies the new range to
which the specified range will
// be copied. If this argument is omitted,
Microsoft Excel copies the range
// to the Clipboard.
[DispId(551)]
dynamic Copy(object Destination = Type.Missing);
//
// Summary:
// Copies the contents of an ADO or DAO
Recordset object onto a worksheet, beginning
// at the upper-left corner of the specified
range.
//
// Parameters:
// MaxColumns:
// Optional Object. The maximum number of fields
to copy onto the worksheet.
// If this argument is omitted, all the fields
in the Recordset object are copied.
//
// MaxRows:
// Optional Object. The maximum number of
records to copy onto the worksheet.
// If this argument is omitted, all the records
in the Recordset object are
// copied.
 //
// Data:
// Required Object. The Recordset object to copy
into the range.
[DispId(1152)]
int CopyFromRecordset(object Data, object MaxRows =
Type.Missing, object MaxColumns = Type.Missing);
//
// Summary:
// Copies the selected object to the Clipboard
as a picture.
//
// Parameters:
// Format:
// Optional
Microsoft.Office.Interop.Excel.XlCopyPictureFormat. The
format of
// the picture. Can be one of the following
XlPictureAppearance constants:xlPrinter.
// The picture is copied as it will look when
it's printed.xlScreendefault.
// The picture is copied to resemble its display
on the screen as closely as
// possible.
//
// Appearance:
// Optional
Microsoft.Office.Interop.Excel.XlPictureAppearance.
Specifies how
// the picture should be copied. Can be one of
the following XlCopyPictureFormat
// constants:xlBitmapxlPicturedefault
[DispId(213)]
dynamic CopyPicture(XlPictureAppearance Appearance =
XlPictureAppearance.xlScreen, XlCopyPictureFormat Format =
XlCopyPictureFormat.xlPicture);
//
// Summary:
 // Creates names in the specified range, based
on text labels in the sheet.
//
// Parameters:
// Bottom:
// Optional Object. True to create names by
using labels in the bottom row.
// The default value is False.
//
// Right:
// Optional Object. True to create names by
using labels in the right column.
// The default value is False.
//
// Left:
// Optional Object. True to create names by
using labels in the left column.
// The default value is False.
//
// Top:
// Optional Object. True to create names by
using labels in the top row. The
// default value is False.
[DispId(457)]
dynamic CreateNames(object Top = Type.Missing,
object Left = Type.Missing, object Bottom = Type.Missing,
object Right = Type.Missing);
[DispId(458)]
[TypeLibFunc(64)]
dynamic CreatePublisher(object Edition =
Type.Missing, XlPictureAppearance Appearance =
XlPictureAppearance.xlScreen, object ContainsPICT =
Type.Missing, object ContainsBIFF = Type.Missing, object
ContainsRTF = Type.Missing, object ContainsVALU =
Type.Missing);
//
// Summary:
// Cuts the object to the Clipboard or pastes it
into a specified destination.
 //
// Parameters:
// Destination:
// Optional Object. The range where the object
should be pasted. If this argument
// is omitted, the object is cut to the
Clipboard.
[DispId(565)]
dynamic Cut(object Destination = Type.Missing);
//
// Summary:
// Creates a data series in the specified range.
//
// Parameters:
// Stop:
// Optional Object. The stop value for the
series. If this argument is omitted,
// Microsoft Excel fills to the end of the
range.
//
// Rowcol:
// Optional Object. Can be the xlRows or
xlColumns constant to have the data
// series entered in rows or columns,
respectively. If this argument is omitted,
// the size and shape of the range is used.
//
// Date:
// Optional
Microsoft.Office.Interop.Excel.XlDataSeriesDate. If the Type
argument
// is xlChronological, the Date argument
indicates the step date unit. Can be
// one of the following XlDataSeriesDate
constants:xlDaydefaultxlWeekdayxlMonthxlYear
//
// Trend:
// Optional Object. True to create a linear
trend or growth trend; False to
 // create a standard data series. The default
value is False.
//
// Type:
// Optional
Microsoft.Office.Interop.Excel.XlDataSeriesType. Can be one
of the
// following XlDataSeriesType
constants:xlAutoFillxlDataSeriesLineardefaultxlChronological
xlGrowth
//
// Step:
// Optional Object. The step value for the
series. The default value is 1.
[DispId(464)]
dynamic DataSeries(object Rowcol = Type.Missing,
XlDataSeriesType Type = XlDataSeriesType.xlDataSeriesLinear,
XlDataSeriesDate Date = XlDataSeriesDate.xlDay, object Step
= Type.Missing, object Stop = Type.Missing, object Trend =
Type.Missing);
//
// Summary:
// Deletes the object.
//
// Parameters:
// Shift:
// Optional Object. Specifies how to shift cells
to replace deleted cells. Can
// be one of the following
Microsoft.Office.Interop.Excel.XlDeleteShiftDirection
// constants: xlShiftToLeft or xlShiftUp. If
this argument is omitted, Microsoft
// Excel decides based on the shape of the
range.
[DispId(117)]
dynamic Delete(object Shift = Type.Missing);
[DispId(245)]
dynamic DialogBox();
//
 // Summary:
// Designates a range to be recalculated when
the next recalculation occurs.
[DispId(2014)]
void Dirty();
[DispId(1131)]
dynamic EditionOptions(XlEditionType Type,
XlEditionOptionsOption Option, object Name = Type.Missing,
object Reference = Type.Missing, XlPictureAppearance
Appearance = XlPictureAppearance.xlScreen,
XlPictureAppearance ChartSize =
XlPictureAppearance.xlScreen, object Format = Type.Missing);
//
// Summary:
// Exports to a file of the specified format.
//
// Parameters:
// IgnorePrintAreas:
// Optional Object set to True to ignore any
print areas set when publishing;
// otherwise False.
//
// IncludeDocProperties:
// Optional Object set to True to include the
document properties; otherwise
// False.
//
// To:
// Optional Object The number of the last page
to publish. If this argument
// is omitted, publishing ends with the last
page.
//
// Filename:
// Optional Object The file name of the file to
be saved. You can include a
// full path, or short_Excel2007 saves the file
in the current folder.
//
 // FixedFormatExtClassPtr:
// Optional Object Pointer to the FixedFormatExt
class.
//
// Type:
// Required
Microsoft.Office.Interop.Excel.XlFixedFormatType The type of
file
// format to export to.
//
// OpenAfterPublish:
// Optional Object set to True to display the
file in the viewer after it is
// published; otherwise False.
//
// Quality:
// Optional Object Typically formatted as a
Microsoft.Office.Interop.Excel.XlFixedFormatQuality.
// Specifies the quality of the published file.
//
// From:
// Optional Object The number of the page at
which to start publishing. If this
// argument is omitted, publishing starts at the
beginning.
[DispId(2493)]
void ExportAsFixedFormat(XlFixedFormatType Type,
object Filename = Type.Missing, object Quality =
Type.Missing, object IncludeDocProperties = Type.Missing,
object IgnorePrintAreas = Type.Missing, object From =
Type.Missing, object To = Type.Missing, object
OpenAfterPublish = Type.Missing, object
FixedFormatExtClassPtr = Type.Missing);
[DispId(248)]
dynamic FillDown();
[DispId(249)]
dynamic FillLeft();
[DispId(250)]
dynamic FillRight();
 [DispId(251)]
dynamic FillUp();
//
// Summary:
// Finds specific information in a range and
returns a Microsoft.Office.Interop.Excel.Range
// object that represents the first cell where
that information is found.
//
// Parameters:
// SearchOrder:
// Optional Object. Can be one of the following
Microsoft.Office.Interop.Excel.XlSearchOrder
// constants: xlByRows or xlByColumns.
//
// What:
// Required Object. The data to search for. Can
be a string or any Microsoft
// Excel data type.
//
// LookIn:
// Optional Object. The type of information.
//
// MatchByte:
// Optional Object. Used only if you’ve selected
or installed double-byte language
// support. True to have double-byte characters
match only double-byte characters;
// False to have double-byte characters match
their single-byte equivalents.
//
// LookAt:
// Optional Object. Can be one of the following
Microsoft.Office.Interop.Excel.XlLookAt
// constants: xlWhole or xlPart.
//
// SearchFormat:
// Optional Object. The search format.
//
 // SearchDirection:
// Optional
Microsoft.Office.Interop.Excel.XlSearchDirection. The search
direction.
// Can be one of these XlSearchDirection
constants:xlNextdefaultxlPrevious
//
// MatchCase:
// Optional Object. True to make the search case
sensitive. The default value
// is False.
//
// After:
// Optional Object. The cell after which you
want the search to begin. This
// corresponds to the position of the active
cell when a search is done from
// the user interface. Note that After must be a
single cell in the range. Remember
// that the search begins after this cell; the
specified cell isn’t searched
// until the method wraps back around to this
cell. If you don’t specify this
// argument, the search starts after the cell in
the upper-left corner of the
// range.
[DispId(398)]
Range Find(object What, object After = Type.Missing,
object LookIn = Type.Missing, object LookAt = Type.Missing,
object SearchOrder = Type.Missing, XlSearchDirection
SearchDirection = XlSearchDirection.xlNext, object MatchCase
= Type.Missing, object MatchByte = Type.Missing, object
SearchFormat = Type.Missing);
//
// Summary:
// Continues a search that was begun with the
Microsoft.Office.Interop.Excel.Range.Find(System.Object,Syst
em.Object,System.Object,System.Object,System.Object,Microsof
t.Office.Interop.Excel.XlSearchDirection,System.Object,Syste
m.Object,System.Object)
// method.
//
// Parameters:
// After:
// Optional Object. The cell after which you
want to search. This corresponds
// to the position of the active cell when a
search is done from the user interface.
// Note that After must be a single cell in the
range. Remember that the search
// begins after this cell; the specified cell
isn’t searched until the method
// wraps back around to this cell. If this
argument isn’t specified, the search
// starts after the cell in the upper-left
corner of the range.
[DispId(399)]
Range FindNext(object After = Type.Missing);
//
// Summary:
// Continues a search that was begun with the
Microsoft.Office.Interop.Excel.Range.Find(System.Object,Syst
em.Object,System.Object,System.Object,System.Object,Microsof
t.Office.Interop.Excel.XlSearchDirection,System.Object,Syste
m.Object,System.Object)
// method.
//
// Parameters:
// After:
// Optional Object. The cell before which you
want to search. This corresponds
// to the position of the active cell when a
search is done from the user interface.
// Note that After must be a single cell in the
range. Remember that the search
// begins before this cell; the specified cell
isn’t searched until the method
 // wraps back around to this cell. If this
argument isn’t specified, the search
// starts before the upper-left cell in the
range.
[DispId(400)]
Range FindPrevious(object After = Type.Missing);
[DispId(571)]
dynamic FunctionWizard();
[DispId(236)]
string get_Address(object RowAbsolute =
Type.Missing, object ColumnAbsolute = Type.Missing,
XlReferenceStyle ReferenceStyle = XlReferenceStyle.xlA1,
object External = Type.Missing, object RelativeTo =
Type.Missing);
[DispId(437)]
string get_AddressLocal(object RowAbsolute =
Type.Missing, object ColumnAbsolute = Type.Missing,
XlReferenceStyle ReferenceStyle = XlReferenceStyle.xlA1,
object External = Type.Missing, object RelativeTo =
Type.Missing);
[DispId(603)]
Characters get_Characters(object Start =
Type.Missing, object Length = Type.Missing);
[DispId(500)]
Range get_End(XlDirection Direction);
[DispId(170)]
dynamic get_Item(object RowIndex, object ColumnIndex
= Type.Missing);
[DispId(254)]
Range get_Offset(object RowOffset = Type.Missing,
object ColumnOffset = Type.Missing);
[DispId(197)]
Range get_Range(object Cell1, object Cell2 =
Type.Missing);
[DispId(256)]
Range get_Resize(object RowSize = Type.Missing,
object ColumnSize = Type.Missing);
[DispId(6)]
 dynamic get_Value(object RangeValueDataType =
Type.Missing);
[DispId(-4)]
[TypeLibFunc(1024)]
IEnumerator GetEnumerator();
//
// Summary:
// Calculates the values necessary to achieve a
specific goal.
//
// Parameters:
// ChangingCell:
// Required
Microsoft.Office.Interop.Excel.Range. Specifies which cell
should
// be changed to achieve the target value.
//
// Goal:
// Required Object. The value you want returned
in this cell.
[DispId(472)]
[TypeLibFunc(64)]
bool GoalSeek(object Goal, Range ChangingCell);
//
// Summary:
// When the Microsoft.Office.Interop.Excel.Range
object represents a single
// cell in a PivotTable field’s data range, the
Group method performs numeric
// or date-based grouping in that field.
//
// Parameters:
// End:
// Optional Object. The last value to be
grouped. If this argument is omitted
// or True, the last value in the field is used.
//
// Periods:
 // Optional Object. An array of Boolean values
that specify the period for the
// group, as shown in the following table.If an
element in the array is True,
// a group is created for the corresponding
time; if the element is False, no
// group is created. If the field isn’t a date
field, this argument is ignored.
//
// Start:
// Optional Object. The first value to be
grouped. If this argument is omitted
// or True, the first value in the field is
used.
//
// By:
// Optional Object. If the field is numeric,
this argument specifies the size
// of each group. If the field is a date, this
argument specifies the number
// of days in each group if element 4 in the
Periods array is True and all the
// other elements are False. Otherwise, this
argument is ignored. If this argument
// is omitted, Microsoft Excel automatically
chooses a default group size.
[DispId(46)]
dynamic Group(object Start = Type.Missing, object
End = Type.Missing, object By = Type.Missing, object Periods
= Type.Missing);
//
// Summary:
// Inserts a cell or a range of cells into the
worksheet or macro sheet and
// shifts other cells away to make space.
//
// Parameters:
// Shift:
 // Optional Object. Specifies which way to shift
the cells. Can be one of the
// following
Microsoft.Office.Interop.Excel.XlInsertShiftDirection
constants:
// xlShiftToRight or xlShiftDown. If this
argument is omitted, Microsoft Excel
// decides based on the shape of the range.
//
// CopyOrigin:
// Optional Object. The copy origin.
[DispId(252)]
dynamic Insert(object Shift = Type.Missing, object
CopyOrigin = Type.Missing);
//
// Summary:
// Adds an indent to the specified range.
//
// Parameters:
// InsertAmount:
// Required Integer. The amount to be added to
the current indent.
[DispId(1381)]
void InsertIndent(int InsertAmount);
[DispId(495)]
dynamic Justify();
[DispId(253)]
dynamic ListNames();
//
// Summary:
// Creates a merged cell from the specified
Microsoft.Office.Interop.Excel.Range
// object.
//
// Parameters:
// Across:
// Optional Object. True to merge cells in each
row of the specified range as
 // separate merged cells. The default value is
False.
[DispId(564)]
void Merge(object Across = Type.Missing);
//
// Summary:
// Navigates a tracer arrow for the specified
range to the precedent, dependent,
// or error-causing cell or cells.
//
// Parameters:
// ArrowNumber:
// Optional Object. Specifies the arrow number
to navigate; corresponds to the
// numbered reference in the cell's formula.
//
// LinkNumber:
// Optional Object. If the arrow is an external
reference arrow, this argument
// indicates which external reference to follow.
If this argument is omitted,
// the first external reference is followed.
//
// TowardPrecedent:
// Optional Object. Specifies the direction to
navigate: True to navigate toward
// precedents; False to navigate toward
dependent.
[DispId(1032)]
dynamic NavigateArrow(object TowardPrecedent =
Type.Missing, object ArrowNumber = Type.Missing, object
LinkNumber = Type.Missing);
//
// Summary:
// Returns or sets the cell note associated with
the cell in the upper-left
// corner of the range.
//
// Parameters:
 // Length:
// Optional Object. The number of characters to
be set or returned. If this
// argument is omitted, Microsoft Excel sets or
returns characters from the
// starting position to the end of the note (up
to 255 characters). If there
// are more than 255 characters from Start to
the end of the note, this method
// returns only 255 characters.
//
// Text:
// Optional Object. The text to add to the note
(up to 255 characters). The
// text is inserted starting at position Start,
replacing Length characters
// of the existing note. If this argument is
omitted, this method returns the
// current text of the note starting at position
Start, for Length characters.
//
// Start:
// Optional Object. The starting position for
the text that’s set or returned.
// If this argument is omitted, this method
starts at the first character. To
// append text to the note, specify a number
larger than the number of characters
// in the existing note.
[DispId(1127)]
string NoteText(object Text = Type.Missing, object
Start = Type.Missing, object Length = Type.Missing);
//
// Summary:
// Parses a range of data and breaks it into
multiple cells.
//
// Parameters:
// ParseLine:
 // Optional Object. A string that contains left
and right brackets to indicate
// where the cells should be split.For example,
"[xxx][xxx]" would insert the
// first three characters into the first column
of the destination range, and
// it would insert the next three characters
into the second column.If this
// argument is omitted, Microsoft Excel guesses
where to split the columns based
// on the spacing of the top left cell in the
range. If you want to use a different
// range to guess the parse line, use a Range
object as the ParseLine argument.
// That range must be one of the cells that's
being parsed. The ParseLine argument
// cannot be longer than 255 characters,
including the brackets and spaces.
//
// Destination:
// Optional Object. A
Microsoft.Office.Interop.Excel.Range object that represents
// the upper-left corner of the destination
range for the parsed data. If this
// argument is omitted, Microsoft Excel parses
in place.
[DispId(477)]
dynamic Parse(object ParseLine = Type.Missing,
object Destination = Type.Missing);
//
// Summary:
// Pastes a Microsoft.Office.Interop.Excel.Range
from the Clipboard into the
// specified range.
//
// Parameters:
// Transpose:
// Optional Object. True to transpose rows and
columns when the range is pasted.
 // The default value is False.
//
// Paste:
// Optional
Microsoft.Office.Interop.Excel.XlPasteType. The part of the
range
// to be pasted. Can be one of the following
XlPasteType constants:xlPasteAll
//
defaultxlPasteAllExceptBordersxlPasteColumnWidthsxlPasteComm
entsxlPasteFormatsxlPasteFormulasxlPasteFormulasAndNumberFor
matsxlPasteValidationxlPasteValuesxlPasteValuesAndNumberForm
ats
//
// SkipBlanks:
// Optional Object. True to not have blank cells
in the range on the Clipboard
// pasted into the destination range. The
default value is False.
//
// Operation:
// Optional
Microsoft.Office.Interop.Excel.XlPasteSpecialOperation. The
paste
// operation. Can be one of the following
XlPasteSpecialOperation
constants:xlPasteSpecialOperationAddxlPasteSpecialOperationD
ividexlPasteSpecialOperationMultiplyxlPasteSpecialOperationN
onedefaultxlPasteSpecialOperationSubtract
[DispId(1928)]
dynamic PasteSpecial(XlPasteType Paste =
XlPasteType.xlPasteAll, XlPasteSpecialOperation Operation =
XlPasteSpecialOperation.xlPasteSpecialOperationNone, object
SkipBlanks = Type.Missing, object Transpose = Type.Missing);
//
// Summary:
// Prints the object.
//
// Parameters:
 // Preview:
// Optional Object. True to have Microsoft Excel
invoke print preview before
// printing the object; False (or omitted) to
print the object immediately.
//
// Collate:
// Optional Object. True to collate multiple
copies.
//
// PrToFileName:
// Optional Object. If PrintToFile is set to
True, this argument specifies the
// name of the file you want to print to.
//
// To:
// Optional Object. The number of the last page
to print. If this argument is
// omitted, printing ends with the last page.
//
// PrintToFile:
// Optional Object. True to print to a file. If
PrToFileName is not specified,
// Microsoft Excel prompts the user to enter the
name of the output file.
//
// Copies:
// Optional Object. The number of copies to
print. If this argument is omitted,
// one copy is printed.
//
// ActivePrinter:
// Optional Object. Sets the name of the active
printer.
//
// From:
// Optional Object. The number of the page at
which to start printing. If this
 // argument is omitted, printing starts at the
beginning.
[DispId(1772)]
[TypeLibFunc(1088)]
dynamic PrintOut(object From = Type.Missing, object
To = Type.Missing, object Copies = Type.Missing, object
Preview = Type.Missing, object ActivePrinter = Type.Missing,
object PrintToFile = Type.Missing, object Collate =
Type.Missing, object PrToFileName = Type.Missing);
[DispId(2361)]
dynamic PrintOutEx(object From = Type.Missing,
object To = Type.Missing, object Copies = Type.Missing,
object Preview = Type.Missing, object ActivePrinter =
Type.Missing, object PrintToFile = Type.Missing, object
Collate = Type.Missing, object PrToFileName = Type.Missing);
//
// Summary:
// Shows a preview of the object as it would
look when printed.
//
// Parameters:
// EnableChanges:
// True to enable changes.
[DispId(281)]
dynamic PrintPreview(object EnableChanges =
Type.Missing);
//
// Summary:
// Removes duplicate values from a range of
values.
//
// Parameters:
// Header:
// Optional
Microsoft.Office.Interop.Excel.XlYesNoGuess Specifies
whether the
// first row contains header information.
Microsoft.Office.Interop.Excel.XlYesNoGuess.xlNo
 // is the default value; specify
Microsoft.Office.Interop.Excel.XlYesNoGuess.xlGuess
// if you want Excel to attempt to determine the
header.
//
// Columns:
// Optional Object Array of indexes of the
columns that contain the duplicate
// information. If nothing is passed then it
assumes all columns contain duplicate
// information.
[DispId(2492)]
void RemoveDuplicates(object Columns = Type.Missing,
XlYesNoGuess Header = XlYesNoGuess.xlNo);
[DispId(883)]
dynamic RemoveSubtotal();
//
// Summary:
// Returns a Boolean indicating characters in
cells within the specified range.
//
// Parameters:
// Replacement:
// Required Object. The replacement string.
//
// SearchOrder:
// Optional Object. Can be one of the following
Microsoft.Office.Interop.Excel.XlSearchOrder
// constants: xlByRows or xlByColumns.
//
// What:
// Required Object. The string you want
Microsoft Excel to search for.
//
// MatchCase:
// Optional Object. True to make the search case
sensitive.
//
// MatchByte:
 // Optional Object. You can use this argument
only if you’ve selected or installed
// double-byte language support in Microsoft
Excel. True to have double-byte
// characters match only double-byte characters;
False to have double-byte characters
// match their single-byte equivalents.
//
// LookAt:
// Optional Object. Can be one of the following
Microsoft.Office.Interop.Excel.XlLookAt
// constants: xlWhole or xlPart.
//
// SearchFormat:
// Optional Object. The search format for the
method.
//
// ReplaceFormat:
// Optional Object. The replace format for the
method.
[DispId(226)]
bool Replace(object What, object Replacement, object
LookAt = Type.Missing, object SearchOrder = Type.Missing,
object MatchCase = Type.Missing, object MatchByte =
Type.Missing, object SearchFormat = Type.Missing, object
ReplaceFormat = Type.Missing);
//
// Summary:
// Returns a
Microsoft.Office.Interop.Excel.Range object that represents
all
// the cells whose contents are different from
those of the comparison cell
// in each row.
//
// Parameters:
// Comparison:
// Required Object. A single cell to compare
with the specified range.
 [DispId(511)]
Range RowDifferences(object Comparison);
//
// Summary:
// Runs the Microsoft Excel macro at this
location.
//
// Parameters:
// Arg28:
// Optional Object. The arguments that should be
passed to the function.
//
// Arg29:
// Optional Object. The arguments that should be
passed to the function.
//
// Arg24:
// Optional Object. The arguments that should be
passed to the function.
//
// Arg25:
// Optional Object. The arguments that should be
passed to the function.
//
// Arg26:
// Optional Object. The arguments that should be
passed to the function.
//
// Arg27:
// Optional Object. The arguments that should be
passed to the function.
//
// Arg20:
// Optional Object. The arguments that should be
passed to the function.
//
// Arg21:
// Optional Object. The arguments that should be
passed to the function.
 //
// Arg22:
// Optional Object. The arguments that should be
passed to the function.
//
// Arg23:
// Optional Object. The arguments that should be
passed to the function.
//
// Arg30:
// Optional Object. The arguments that should be
passed to the function.
//
// Arg8:
// Optional Object. The arguments that should be
passed to the function.
//
// Arg9:
// Optional Object. The arguments that should be
passed to the function.
//
// Arg6:
// Optional Object. The arguments that should be
passed to the function.
//
// Arg7:
// Optional Object. The arguments that should be
passed to the function.
//
// Arg4:
// Optional Object. The arguments that should be
passed to the function.
//
// Arg5:
// Optional Object. The arguments that should be
passed to the function.
//
// Arg2:
 // Optional Object. The arguments that should be
passed to the function.
//
// Arg3:
// Optional Object. The arguments that should be
passed to the function.
//
// Arg14:
// Optional Object. The arguments that should be
passed to the function.
//
// Arg1:
// Optional Object. The arguments that should be
passed to the function.
//
// Arg12:
// Optional Object. The arguments that should be
passed to the function.
//
// Arg11:
// Optional Object. The arguments that should be
passed to the function.
//
// Arg10:
// Optional Object. The arguments that should be
passed to the function.
//
// Arg16:
// Optional Object. The arguments that should be
passed to the function.
//
// Arg15:
// Optional Object. The arguments that should be
passed to the function.
//
// Arg13:
// Optional Object. The arguments that should be
passed to the function.
//
 // Arg19:
// Optional Object. The arguments that should be
passed to the function.
//
// Arg18:
// Optional Object. The arguments that should be
passed to the function.
//
// Arg17:
// Optional Object. The arguments that should be
passed to the function.
[DispId(259)]
dynamic Run(object Arg1 = Type.Missing, object Arg2
= Type.Missing, object Arg3 = Type.Missing, object Arg4 =
Type.Missing, object Arg5 = Type.Missing, object Arg6 =
Type.Missing, object Arg7 = Type.Missing, object Arg8 =
Type.Missing, object Arg9 = Type.Missing, object Arg10 =
Type.Missing, object Arg11 = Type.Missing, object Arg12 =
Type.Missing, object Arg13 = Type.Missing, object Arg14 =
Type.Missing, object Arg15 = Type.Missing, object Arg16 =
Type.Missing, object Arg17 = Type.Missing, object Arg18 =
Type.Missing, object Arg19 = Type.Missing, object Arg20 =
Type.Missing, object Arg21 = Type.Missing, object Arg22 =
Type.Missing, object Arg23 = Type.Missing, object Arg24 =
Type.Missing, object Arg25 = Type.Missing, object Arg26 =
Type.Missing, object Arg27 = Type.Missing, object Arg28 =
Type.Missing, object Arg29 = Type.Missing, object Arg30 =
Type.Missing);
[DispId(235)]
dynamic Select();
[DispId(170)]
void set_Item(object RowIndex, object ColumnIndex =
Type.Missing, object value = Type.Missing);
[DispId(6)]
void set_Value(object RangeValueDataType =
Type.Missing, object value = Type.Missing);
[DispId(1812)]
void SetPhonetic();
[DispId(496)]
 dynamic Show();
//
// Summary:
// Draws tracer arrows to the direct dependents
of the range.
//
// Parameters:
// Remove:
// Optional Object. True to remove one level of
tracer arrows to direct dependents;
// False to expand one level of tracer arrows.
The default value is False.
[DispId(877)]
dynamic ShowDependents(object Remove =
Type.Missing);
[DispId(878)]
dynamic ShowErrors();
//
// Summary:
// Draws tracer arrows to the direct precedents
of the range.
//
// Parameters:
// Remove:
// Optional Object. True to remove one level of
tracer arrows to direct precedents;
// False to expand one level of tracer arrows.
The default value is False.
[DispId(879)]
dynamic ShowPrecedents(object Remove =
Type.Missing);
//
// Summary:
// Sorts a PivotTable report, a range, or the
active region if the specified
// range contains only one cell.
//
// Parameters:
// Key3:
 // Optional Object. The third sort field, as
either text (a range name) or a
// Range object. If you omit this argument,
there’s no third sort field. Cannot
// be used when sorting PivotTable reports.
//
// MatchCase:
// Optional Object. True to do a case-sensitive
sort; False to do a sort that’s
// not case sensitive. Cannot be used when
sorting PivotTable reports.
//
// DataOption1:
// Optional
Microsoft.Office.Interop.Excel.XlSortDataOption. Specifies
how to
// sort text in Key 1. Cannot be used when
sorting PivotTable reports. Can be
// one of the following XlSortDataOption
constants:xlSortTextAsNumbers. Treat
// text as numeric data for the
sort.xlSortNormaldefault. Sorts numeric and
// text data separately.
//
// DataOption3:
// Optional
Microsoft.Office.Interop.Excel.XlSortDataOption. Specifies
how to
// sort text in key 3. Cannot be used when
sorting PivotTable reports. Can be
// one of the following XlSortDataOption
constants:xlSortTextAsNumbers. Treats
// text as numeric data for the
sort.xlSortNormaldefault. Sorts numeric and
// text data separately.
//
// DataOption2:
 // Optional
Microsoft.Office.Interop.Excel.XlSortDataOption. Specifies
how to
// sort text in Key 2. Cannot be used when
sorting PivotTable reports. Can be
// one of the following XlSortDataOption
constants:xlSortTextAsNumbers. Treats
// text as numeric data for the
sort.xlSortNormaldefault. Sorts numeric and
// text data separately.
//
// Header:
// Optional
Microsoft.Office.Interop.Excel.XlYesNoGuess. Specifies
whether or
// not the first row contains headers. Cannot be
used when sorting PivotTable
// reports. Can be one of the following
XlYesNoGuess constants:xlGuess. Let
// Microsoft Excel determine whether there’s a
header, and determine where it
// is if there is one.xlNodefault. (The entire
range should be sorted).xlYes.
// (The entire range should not be sorted).
//
// SortMethod:
// Optional
Microsoft.Office.Interop.Excel.XlSortMethod. The type of
sort. Some
// of these constants may not be available to
you, depending on the language
// support (U.S. English, for example) that
you’ve selected or installed. Can
// be one of the following XlSortMethod
constants:xlStroke Sorting by the quantity
// of strokes in each character.xlPinYindefault.
Phonetic Chinese sort order
// for characters.
//
 // Order1:
// Optional
Microsoft.Office.Interop.Excel.XlSortOrder. The sort order
for the
// field or range specified in Key1. Can be one
of the following XlSortOrder
// constants:xlDescending. Sorts Key1 in
descending order.xlAscendingdefault.
// Sorts Key1 in ascending order.
//
// Order2:
// Optional
Microsoft.Office.Interop.Excel.XlSortOrder. The sort order
for the
// field or range specified in Key2. Cannot be
used when sorting PivotTable
// reports. Can be one of the following
XlSortOrder constants:xlDescending.
// Sorts Key2 in descending
order.xlAscendingdefault. Sorts Key2 in ascending
// order.
//
// Order3:
// Optional
Microsoft.Office.Interop.Excel.XlSortOrder. The sort order
for the
// field or range specified in Key3. Cannot be
used when sorting PivotTable
// reports. Can be one of the following
XlSortOrder constants:xlDescending.
// Sorts Key3 in descending
order.xlAscendingdefault. Sorts Key3 in ascending
// order.
//
// Orientation:
// Optional
Microsoft.Office.Interop.Excel.XlSortOrientation. The sort
orientation.
 // Can be one of the following XlSortOrientation
constants:xlSortRowsdefault.
// Sorts by row.xlSortColumns. Sorts by column.
//
// Key1:
// Optional Object. The first sort field, as
either text (a PivotTable field
// or range name) or a
Microsoft.Office.Interop.Excel.Range object ("Dept" or
// Cells(1, 1), for example).
//
// Type:
// Optional Object. Specifies which elements are
to be sorted. Use this argument
// only when sorting PivotTable reports. Can be
one of the following XlSortType
// constants:xlSortLabels. Sorts the PivotTable
report by labels.xlSortValues.
// Sorts the PivotTable report by values.
//
// Key2:
// Optional Object. The second sort field, as
either text (a PivotTable field
// or range name) or a Range object. If you omit
this argument, there’s no second
// sort field. Cannot be used when sorting Pivot
Table reports.
//
// OrderCustom:
// Optional Object. This argument is a one-based
integer offset to the list
// of custom sort orders. If you omit
OrderCustom, a normal sort is used.
[DispId(880)]
dynamic Sort(object Key1 = Type.Missing, XlSortOrder
Order1 = XlSortOrder.xlAscending, object Key2 =
Type.Missing, object Type = Type.Missing, XlSortOrder Order2
= XlSortOrder.xlAscending, object Key3 = Type.Missing,
XlSortOrder Order3 = XlSortOrder.xlAscending, XlYesNoGuess
Header = XlYesNoGuess.xlNo, object OrderCustom =
Type.Missing, object MatchCase = Type.Missing,
XlSortOrientation Orientation =
XlSortOrientation.xlSortRows, XlSortMethod SortMethod =
XlSortMethod.xlPinYin, XlSortDataOption DataOption1 =
XlSortDataOption.xlSortNormal, XlSortDataOption DataOption2
= XlSortDataOption.xlSortNormal, XlSortDataOption
DataOption3 = XlSortDataOption.xlSortNormal);
//
// Summary:
// Uses East Asian sorting methods to sort the
range or a PivotTable report,
// or uses the method for the active region if
the range contains only one cell.
// For example, Japanese sorts in the order of
the Kana syllabary.
//
// Parameters:
// Key3:
// Optional object. The third sort field, as
either text (a range name) or a
// Range object. If you omit this argument,
there’s no third sort field. Cannot
// be used when sorting PivotTable reports.
//
// MatchCase:
// Optional Object. True to do a case-sensitive
sort; False to do a sort that’s
// not case sensitive. Cannot be used when
sorting PivotTable reports.
//
// DataOption1:
// Optional
Microsoft.Office.Interop.Excel.XlSortDataOption. Specifies
how to
// sort text in Key1. Cannot be used when
sorting PivotTable reports. Can be
// one of the following XlSortDataOption
constants:xlSortTextAsNumbers. Treats
 // text as numeric data for the
sort.xlSortNormaldefault. Sorts numeric and
// text data separately.
//
// DataOption3:
// Optional
Microsoft.Office.Interop.Excel.XlSortDataOption. Specifies
how to
// sort text in Key 3. Cannot be used when
sorting PivotTable reports. Can be
// one of the following XlSortDataOption
constants:xlSortTextAsNumbers. Treats
// text numeric data for the
sort.xlSortNormaldefault. Sorts numeric and text
// data separately.
//
// DataOption2:
// Optional
Microsoft.Office.Interop.Excel.XlSortDataOption. Specifies
how to
// sort text in Key 2. Cannot be used when
sorting PivotTable reports. Can be
// one of the following XlSortDataOption
constants:xlSortTextAsNumbers. Treats
// text as numeric data for the
sort.xlSortNormaldefault. Sorts numeric and
// text data separately.
//
// Header:
// Optional
Microsoft.Office.Interop.Excel.XlYesNoGuess. Specifies
whether or
// not the first row contains headers. Cannot be
used when sorting PivotTable
// reports. Can be one of the following
XlYesNoGuess constants:xlGuess. Lets
// Microsoft Excel determine whether there’s a
header, and determine where it
 // is if there is one.xlNodefault. The entire
range should be sorted.xlYes.
// The entire range should not be sorted.
//
// SortMethod:
// Optional
Microsoft.Office.Interop.Excel.XlSortMethod. The type of
sort. Some
// of these constants may not be available to
you, depending on the language
// support (U.S. English, for example) that
you’ve selected or installed. Can
// be one of the following XlSortMethod
constants:xlStroke. Sorting by the quantity
// of strokes in each character.xlPinYindefault.
Phonetic Chinese sort order
// for characters.
//
// Order1:
// Optional
Microsoft.Office.Interop.Excel.XlSortOrder. The sort order
for the
// field or range specified in the Key1
argument. Can be one of the following
// XlSortOrder constants:xlDescending. Sorts
Key1 in descending order.xlAscendingdefault.
// Sorts Key1 in ascending order.
//
// Order2:
// Optional
Microsoft.Office.Interop.Excel.XlSortOrder. The sort order
for the
// field or range specified in the Key2
argument. Cannot be used when sorting
// PivotTable reports. Can be one of the
following XlSortOrder constants:xlDescending.
// Sorts Key2 in descending order xlAscending
default. Sorts Key2 in ascending
// order.
 //
// Order3:
// Optional
Microsoft.Office.Interop.Excel.XlSortOrder. The sort order
for the
// field or range specified in the Key3
argument. Cannot be used when sorting
// PivotTable reports. Can be one of the
following XlSortOrder constants: xlDescending.
// Sorts Key3 in descending
order.xlAscendingdefault. Sorts Key3 in ascending
// order.
//
// Orientation:
// Optional
Microsoft.Office.Interop.Excel.XlSortOrientation. The sort
orientation.
// Can be one of the following XlSortOrientation
constants:xlSortRowsdefault.
// The sort is done by row.xlSortColumns. The
sort is done by column.
//
// Key1:
// Optional Object. The first sort field, as
either text (a PivotTable field
// or range name) or a Range object ("Dept" or
Cells(1, 1), for example).
//
// Type:
// Optional Object. Specifies which elements are
to be sorted. Use this argument
// only when sorting PivotTable reports.
//
// Key2:
// Optional Object. The second sort field, as
either text (a PivotTable field
// or range name) or a Range object. If you omit
this argument, there’s no second
 // sort field. Cannot be used when sorting
PivotTable reports. Can be one of
// the following XlSortType
constants:xlSortLabels. Sorts the PivotTable report
// by labels.xlSortValues. Sorts the PivotTable
report by values.
//
// OrderCustom:
// Optional Object. This argument is a one-based
integer offset to the list
// of custom sort orders. If you omit
OrderCustom, (normal sort order) is used.
[DispId(881)]
dynamic SortSpecial(XlSortMethod SortMethod =
XlSortMethod.xlPinYin, object Key1 = Type.Missing,
XlSortOrder Order1 = XlSortOrder.xlAscending, object Type =
Type.Missing, object Key2 = Type.Missing, XlSortOrder Order2
= XlSortOrder.xlAscending, object Key3 = Type.Missing,
XlSortOrder Order3 = XlSortOrder.xlAscending, XlYesNoGuess
Header = XlYesNoGuess.xlNo, object OrderCustom =
Type.Missing, object MatchCase = Type.Missing,
XlSortOrientation Orientation =
XlSortOrientation.xlSortRows, XlSortDataOption DataOption1 =
XlSortDataOption.xlSortNormal, XlSortDataOption DataOption2
= XlSortDataOption.xlSortNormal, XlSortDataOption
DataOption3 = XlSortDataOption.xlSortNormal);
//
// Summary:
// Causes the cells of the range to be spoken in
row order or column order.
//
// Parameters:
// SpeakDirection:
// Optional Object. The speak direction, by rows
or columns.
//
// SpeakFormulas:
// Optional Object. True will cause formulas to
be sent to the Text-To-Speech
 // (TTS) engine for cells that have formulas.
The value is sent if the cells
// do not have formulas; False (default) will
cause values to always be sent
// to the TTS engine.
[DispId(2017)]
void Speak(object SpeakDirection = Type.Missing,
object SpeakFormulas = Type.Missing);
//
// Summary:
// Returns a
Microsoft.Office.Interop.Excel.Range object that represents
all
// the cells that match the specified type and
value.
//
// Parameters:
// Value:
// Optional Object. If Type is either
xlCellTypeConstants or xlCellTypeFormulas,
// this argument is used to determine which
types of cells to include in the
// result. These values can be added together to
return more than one type.
// The default is to select all constants or
formulas, no matter what the type.
// Can be one of the following
Microsoft.Office.Interop.Excel.XlSpecialCellsValue
//
constants:xlErrorsxlLogicalxlNumbersxlTextValues
//
// Type:
// Required
Microsoft.Office.Interop.Excel.XlCellType. The cells to
include.
// Can be one of the following XlCellType
constants:xlCellTypeAllFormatConditions.
// Cells of any format.xlCellTypeAllValidation.
Cells having validation criteria.xlCellTypeBlanks.
 // Empty cells.xlCellTypeComments. Cells
containing notes.xlCellTypeConstants.
// Cells containing
constants.xlCellTypeFormulas. Cells containing
formulas.xlCellTypeLastCell.
// The last cell in the used
range.xlCellTypeSameFormatConditions. Cells having
// the same format.xlCellTypeSameValidation.
Cells having the same validation
// criteria.xlCellTypeVisible. All visible
cells.
[DispId(410)]
Range SpecialCells(XlCellType Type, object Value =
Type.Missing);
[DispId(481)]
dynamic SubscribeTo(string Edition,
XlSubscribeToFormat Format =
XlSubscribeToFormat.xlSubscribeToText);
//
// Summary:
// Creates subtotals for the range (or the
current region, if the range is a
// single cell).
//
// Parameters:
// PageBreaks:
// Optional Object. True to add page breaks
after each group. The default value
// is False.
//
// TotalList:
// Required Object. An array of 1-based field
offsets, indicating the fields
// to which the subtotals are added. For more
information, see the example.
//
// SummaryBelowData:
 // Optional
Microsoft.Office.Interop.Excel.XlSummaryRow. Places the
summary
// data relative to the subtotal. Can be one of
the following XlSummaryRow
constants:xlSummaryAbovexlSummaryBelowdefault
//
// GroupBy:
// Required Integer. The field to group by, as a
one-based integer offset. For
// more information, see the example.
//
// Replace:
// Optional Object. True to replace existing
subtotals. The default value is
// False.
//
// Function:
// Required
Microsoft.Office.Interop.Excel.XlConsolidationFunction. The
subtotal
// function. Can be one of the following
XlConsolidationFunction
constants:xlAveragexlCountxlCountNumsxlMaxxlMinxlProductxlSt
DevxlStDevPxlSumxlUnknownxlVarxlVarP
[DispId(882)]
dynamic Subtotal(int GroupBy,
XlConsolidationFunction Function, object TotalList, object
Replace = Type.Missing, object PageBreaks = Type.Missing,
XlSummaryRow SummaryBelowData =
XlSummaryRow.xlSummaryBelow);
//
// Summary:
// Creates a data table based on input values
and formulas that you define on
// a worksheet.
//
// Parameters:
// RowInput:
 // Optional Object. A single cell to use as the
row input for your table.
//
// ColumnInput:
// Optional Object. A single cell to use as the
column input for your table.
[DispId(497)]
dynamic Table(object RowInput = Type.Missing, object
ColumnInput = Type.Missing);
//
// Summary:
// Parses a column of cells that contain text
into several columns.
//
// Parameters:
// OtherChar:
// Optional Object (required if Other is True).
The delimiter character when
// Other is True. If more than one character is
specified, only the first character
// of the string is used; the remaining
characters are ignored.
//
// DataType:
// Optional
Microsoft.Office.Interop.Excel.XlTextParsingType. The format
of
// the text to be split into columns. Can be one
of the following XlTextParsingType
// constants:xlDelimited defaultxlFixedWidth
//
// Tab:
// Optional Object. True to have DataType be
xlDelimited and to have the tab
// character be a delimiter. The default value
is False.
//
// DecimalSeparator:
 // Optional String. The decimal separator that
Microsoft Excel uses when recognizing
// numbers. The default setting is the system
setting.
//
// Semicolon:
// Optional Object. True to have DataType be
xlDelimited and to have the semicolon
// be a delimiter. The default value is False.
//
// Comma:
// Optional Object. True to have DataType be
xlDelimited and to have the comma
// be a delimiter. The default value is False.
//
// TrailingMinusNumbers:
// Optional Object. Numbers that begin with a
minus character.
//
// Space:
// Optional Object. True to have DataType be
xlDelimited and to have the space
// character be a delimiter. The default value
is False.
//
// ConsecutiveDelimiter:
// Optional Object. True to have Microsoft Excel
consider consecutive delimiters
// as one delimiter. The default value is False.
//
// Other:
// Optional Object. True to have DataType be
xlDelimited and to have the character
// specified by the OtherChar argument be a
delimiter. The default value is
// False.
//
// TextQualifier:
 // Optional
Microsoft.Office.Interop.Excel.XlTextQualifier. Can be one
of the
// following XlTextQualifier
constants:xlTextQualifierDoubleQuotedefaultxlTextQualifierNo
nexlTextQualifierSingleQuote
//
// ThousandsSeparator:
// Optional String. The thousands separator that
Excel uses when recognizing
// numbers. The default setting is the system
setting.
//
// Destination:
// Optional Object. A
Microsoft.Office.Interop.Excel.Range object that specifies
// where Microsoft Excel will place the results.
If the range is larger than
// a single cell, the top left cell is used.
//
// FieldInfo:
// Optional Object. An array containing parse
information for the individual
// columns of data. The interpretation depends
on the value of DataType. When
// the data is delimited, this argument is an
array of two-element arrays, with
// each two-element array specifying the
conversion options for a particular
// column. The first element is the column
number (1-based), and the second
// element is one of the
Microsoft.Office.Interop.Excel.XlColumnDataType constants
// specifying how the column is parsed. Can be
one of the following XlColumnDataType
// constants:xlGeneralFormat. Genera.
xlTextFormat. Text.xlMDYFormat. MDY Date.xlDMYFormat.
// DMY Date.xlYMDFormat. YMD Date.xlMYDFormat.
MYD Date.xlDYMFormat. DYM Date.xlYDMFormat.
 // YDM Date.xlEMDFormat. EMD Date.xlSkipColumn.
Skip Column.You can use xlEMDFormat
// only if Taiwanese language support is
installed and selected. The xlEMDFormat
// constant specifies that Taiwanese era dates
are being used.The column specifiers
// can be in any order. If a given column
specifier is not present for a particular
// column in the input data, the column is
parsed with the General setting.If
// the source data has fixed-width columns, the
first element of each two-element
// array specifies the starting character
position in the column (as an integer;
// 0 (zero) is the first character). The second
element of the two-element array
// specifies the parse option for the column as
a number from 1 through 9, as
// listed above.
[DispId(1040)]
dynamic TextToColumns(object Destination =
Type.Missing, XlTextParsingType DataType =
XlTextParsingType.xlDelimited, XlTextQualifier TextQualifier
= XlTextQualifier.xlTextQualifierDoubleQuote, object
ConsecutiveDelimiter = Type.Missing, object Tab =
Type.Missing, object Semicolon = Type.Missing, object Comma
= Type.Missing, object Space = Type.Missing, object Other =
Type.Missing, object OtherChar = Type.Missing, object
FieldInfo = Type.Missing, object DecimalSeparator =
Type.Missing, object ThousandsSeparator = Type.Missing,
object TrailingMinusNumbers = Type.Missing);
[DispId(244)]
dynamic Ungroup();
[DispId(1384)]
void UnMerge();
}
}