-
Notifications
You must be signed in to change notification settings - Fork 38
Documentation
The AirtableBase type exposes the following members.
| Name | Description |
|---|---|
| public AirtableBase(string, string?) | initializes a new instance of AirtableBase with a specific API key or an access token, and an optional Base ID |
| public AirtableBase(string, string?, DelegatingHandler?) | initializes a new instance of AirtableBase with a specific API key or an access token, an optional Base ID, and an optional customized HTTP delegating handler |
| public AirtableBase(HttpClient?, string?, string, DelegatingHandler?) | initializes a new instance of AirtableBase with a HttpClient, a specific API key or an access token, an optional Base ID, an optional DelegatingHandler |
| Name | Description |
|---|---|
| ShouldNotRetryIfRateLimited | Gets or sets a value which indicates whether retries should not be allowed if the user has sent too many requests in a given amount of time. This value is set to 'false' by default meaning retries are allowed. |
| RetryDelayMillisecondsIfRateLimited | Gets or sets the initial number of milliseconds to wait before sending the same request again if the previous request resulted in a HttpStatusCode 429 for Too Many Requests. The default value is 2000 milliseconds. The maximum number of retries is 3 and the delay increase exponentially with an exponent of 2 for each subsequent retry. |
| Name | Description |
|---|---|
| SetBaseId(string) | Since the base ID is optional in the AirtableBase ctors so that the users can call base related APIs after AirtableBase is constructed. In this case, if the users want to call the rest of API requiring a specific base ID, the users must call this method once before proceeding. |
| GetUserIdAndScopes(CancellationToken) | Get the user ID of the access token and the scopes granted to this user ID. |
| ListBases(string?, CancellationToken) | Returns the list of bases the token can access as an asynchronous operation, 1000 bases at a time. If there is another page to request, pass the offset in your next call to this method. |
| GetBaseSchema(string?, BaseSchemaInclude[]?, CancellationToken) | Returns the schema of the tables in the specified base as an asynchronous operation. If no base ID is passed in, the base ID already set in AirtableBase will be used. |
| CreateBase(string, string, TableConfig[], CancellationToken) | Creates a new base with the provided tables and returns the schema for the newly created base as an asynchronous operation. |
| ListRecords(string, string, IEnumerable, string int?, int?, IEnumerable, string, string, string, string, bool, bool?, CancellationToken) | Get a list of records in a specific table as an asynchronous operation. |
ListRecords<T>(string, string, IEnumerable, string int?, int?, IEnumerable, string, string, string, string, bool, bool?, CancellationToken) |
Get a list of record<T> in a specific table as an asynchronous operation. The fields of each record are deserialized to type <T>. |
| RetrieveRecord(string, string, string, string, bool), CancellationToken | Retrieve a record with a specific id from a specific table as an asynchronous operation. |
RetrieveRecord<T>(string, string, string, string, bool, CancellationToken) |
Retrieve a record<T> with a specific id from a specific table as an asynchronous operation. The fields of the retrieved record are deserialized to type <T>. |
| CreateRecord(string, Fields, bool, CancellationToken) | Create a record in a specific table using information provided by caller as an asynchronous operation. |
CreateRecordGeneric<T>(string, T, bool, CancellationToken) |
Create a record of type T in a specific table as an asynchronous operation. |
| UpdateRecord(string, Fields, string, bool, CancellationToken) | Update a record with a specific ID in a specific table as an asynchronous operation. |
| ReplaceRecord(string, Fields, string, bool, CancellationToken) | Replace a record with a specific ID in a specific table as an asynchronous operation. |
ReplaceRecordGeneric<T>(string, T, string, bool, CancellationToken) |
Replace a record with a specific ID and of type T in a specific table as an asynchronous operation. |
| DeleteRecord(string, string, CancellationToken) | Delete a record with a specific ID in a specific table as an asynchronous operation. |
| CreateMultipleRecords(string, Fields[], bool, CancellationToken) | Create multiple records in a specific table using information stored in Fields[] provided by caller in a single asynchronous operation. |
| CreateMultipleRecords(string, AirtableRecord[], bool, CancellationToken) | Create multiple records in a specific table using information stored in AirtableRecord[] provided by caller in a single asynchronous operation. |
CreateMultipleRecordsGeneric<T>(string, T[], bool, CancellationToken) |
Create multiple records in a specific table using information stored in T[] provided by caller in a single asynchronous operation. |
| UpdateMultipleRecords(string, IdFields[], bool, bool, PerformUpsert, CancellationToken) | Update multiple records in a specific table using information stored in IdFields[] provided by caller in a single asynchronous operations. |
| UpdateMultipleRecords(string, AirtableRecord[], bool, bool, PerformUpsert, CancellationToken) | Update multiple records in a specific table using information stored in AirtableRecord[] provided by caller in a single asynchronous operations. |
| ReplaceMultipleRecords(string, IdFields[], bool, bool, PerformUpsert, CancellationToken) | Replace multiple records in a specific table using information stored in IdFields[] provided by caller in a single asynchronous operation. |
| ReplaceMultipleRecords(string, AirtableRecord[], bool, bool, PerformUpsert, CancellationToken) | Replace multiple records in a specific table using information stored in AirtableRecord[] provided by caller in a single asynchronous operation. |
ReplaceMultipleRecordsGeneric<T>(string, T[], string[], bool, bool, CancellationToken) |
Replace multiple records in a specific table using information stored in T[] provided by caller in a single asynchronous operation. |
| ListComments(string, string, string, int?, CancellationToken) | Get the comment list for the record specified by caller in a single asynchronous operation. |
| CreateComment(string, string, string, CancellationToken) | Create a comment for the record specified by caller in a single asynchronous operation. |
| UpdateComment(string, string, string, CancellationToken) | Update a comment row for the record specified by caller in a single asynchronous operation. |
| DeleteComment(string, string, string, CancellationToken) | Delete a comment row for the record specified by caller in a single asynchronous operation. |
| CreateWebhook(WebhooksSpecification, string, CancellationToken) | Create a Webhook in the base specified in the specification. Payloads may be generated and the notification URL (if given) will get a ping shortly after this completes. |
| ListWebhooks(CancellationToken) | Lists all webhooks that are registered for a base, along with their statuses. |
| ListPayloads(string, int, int?, CancellationToken) | Enumerate the update messages for a client to consume. Clients should call this after they receive a ping. |
| EnableWebhookNotifications(string, bool, CancellationToken) | Enables or disables notification pings for a webhook. |
| RefreshWebhook(string, CancellationToken) | Extend the life of a webhook. The new expiration time will be 7 days after the refresh time. |
| DeleteWebhook(string, CancellationToken) | Deletes a webhook. |
| Dispose() | Releases the unmanaged resources and disposes of the managed resources used by the class |
AirtableBase.SetBaseId (string)
Since the base ID is optional in the AirtableBase ctors so that the users can call base related APIs after AirtableBase is constructed. In this case, if the users want to call any of the APIs requiring a specific base ID, the users must call this method once to set the base ID before proceeding.
Namespace: AirtableApiClient
Assembly: AirtableApiClient.dll
public void SetBaseId(string baseId)Type: string
The base ID to be use from now on.
void
AirtableBase.GetUserIdAndScopes (CancellationToken)
Get the user ID of the access token and the scopes granted to this access token as an asynchronous operation.
Namespace: AirtableApiClient
Assembly: AirtableApiClient.dll
public async Task<AirtableGetUserIdAndScopesResponse> GetUserIdAndScopes(Cancellation token = default(CancellationToken))Type: CancellationToken
An optional field for providing a means to cancel the operation.
The task object representing the asynchronous operation.
This operation will not block. The returned task object will complete once the entire response including content is read.
using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Linq;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Text.Json;
using System.Text.Json.Serialization;
using AirtableApiClient;
readonly string baseId = YOUR_BASE_ID;
readonly string appKeyOrAccessToken = YOUR_APP_KEY_OR_ACCESS_TOKEN; using (AirtableBase airtableBase = new AirtableBase(appKeyOrAccessToken, baseId))
{
Task<AirtableGetUserIdAndScopesResponse> task = airtableBase.GetUserIdAndScopes();
var response = await task;
if (!response.Success)
{
string errorMessage = null;
if (response.AirtableApiError is AirtableApiException)
{
errorMessage = response.AirtableApiError.ErrorMessage;
if (response.AirtableApiError is AirtableInvalidRequestException)
{
errorMessage += "\nDetailed error message: ";
errorMessage += response.AirtableApiError.DetailedErrorMessage;
}
else
{
errorMessage = "Unknown error";
}
}
// Report errorMessage
}
else
{
Assert.IsFalse(string.IsNullOrEmpty(response.UserId));
Console.WriteLine($"UserId is {response.UserId}");
if ((response.Scopes != null) && (response.Scopes.ToList<string>()).Count > 0)
{
foreach (var scope in response.Scopes)
{
Console.WriteLine("Scope is {0}", scope);
}
}
else
{
Console.WriteLine("Scopes are empty");
}
}
}Airtable.ListBases(string?, CancellationToken)
Returns the list of bases the token can access, 1000 bases at a time. If there is another page to request, pass the offset into subsequence calls. This method is an asynchronous operation.
Namespace: AirtableApiClient
Assembly: AirtableApiClient.dll
public async Task<AirtableListBasesResponse> ListBases(
string? offset = null,
CancellationToken token = default(CancellationToken))Type: string?
An optional field that, if specified, list bases starting from this offset.
Type: CancellationToken
An optional field for providing a means to cancel the operation.
The task object representing the asynchronous operation.
This operation will not block. The returned task object will complete once the entire response including content is read.
using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Linq;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Text.Json;
using System.Text.Json.Serialization;
using AirtableApiClient;
readonly string appKeyOrAccessToken= YOUR_APP_KEY_OR_ACCESS_TOKEN; using (AirtableBase airtableBase = new AirtableBase(appKeyOrAccessToken))
{
Task<AirtableListBasesResponse> task = airtableBase.ListBases(); // List bases, 1000 at a time, your token can access
var response = await task;
if (!response.Success)
{
string errorMessage = null;
if (response.AirtableApiError is AirtableApiException)
{
errorMessage = response.AirtableApiError.ErrorMessage;
if (response.AirtableApiError is AirtableInvalidRequestException)
{
errorMessage += "\nDetailed error message: ";
errorMessage += response.AirtableApiError.DetailedErrorMessage;
}
else
{
errorMessage = "Unknown error";
}
}
// Report errorMessage
}
else
{
string? offset = response!.Offset; // Save this offset. If non null, use it in your subsequent calls of ListBases()
IEnumerable<BaseModel>? bases = response!.Bases;
Assert.IsNotNull(bases);
Assert.IsTrue(bases.Count() > 0);
foreach (var airBase in bases)
{
// Do something with each base in the list.
}
}
}Airtable.GetBaseSchema(string?, BaseSchemaInclude[]?, CancellationToken)
Returns the schema of the tables in the specified base. This method is an asynchronous operation.
Namespace: AirtableApiClient
Assembly: AirtableApiClient.dll
public async Task<AirtableGetBaseSchemaResponse> GetBaseSchema(
string? baseId = null,
BaseSchemaInclude[]? baseSchemaInclude = null,
CancellationToken token = default(CancellationToken))Type: string?
Optional, if specified, the schema of tables of this base will be returned.
Otherwise, the schema of the tables of the base ID specified by SetBaseId(baseId).
SetBaseId may be called by the Airtable ctor of directly by users.
Type: BaseSchemaInclude[]?
An optional field that, if specified, indicates the additional fields to include in the views object response.
Currently, this list only allows a single literal value visibleFieldIds (for views of type grid only)
For this reason BaseSchemaInclude is an enum with one single literal value visibleFieldIds.
See usage example in the Example section below.
Type: CancellationToken
An optional field for providing a means to cancel the operation.
The task object representing the asynchronous operation.
This operation will not block. The returned task object will complete once the entire response including content is read.
using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Linq;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Text.Json;
using System.Text.Json.Serialization;
using AirtableApiClient;
## Syntax
```cs
public async Task<AirtableGetBaseSchemaResponse> GetBaseSchema(
string? baseId = null,
BaseSchemaInclude[]? baseSchemaInclude = null,
CancellationToken token = default(CancellationToken))Type: string?
Optional, if specified, the schema of tables of this base will be returned.
Otherwise, the schema of the tables of the base ID specified by SetBaseId(baseId).
SetBaseId may be called by the Airtable ctor of directly by users.
Type: BaseSchemaInclude[]?
An optional field that, if specified, indicates the additional fields to include in the views object response.
Currently, this list only allows a single literal value visibleFieldIds (for views of type grid only)
For this reason BaseSchemaInclude is an enum with one single literal value visibleFieldIds.
See usage example in the Example section below.
Type: CancellationToken
An optional field for providing a means to cancel the operation.
The task object representing the asynchronous operation.
This operation will not block. The returned task object will complete once the entire response including content is read.
using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Linq;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Text.Json;
using System.Text.Json.Serialization;
using AirtableApiClient;
readonly string appKeyOrAccessToken= YOUR_APP_KEY_OR_ACCESS_TOKEN;
readonly string baseId = YOUR_BASE_ID; using (AirtableBase airtableBase = new AirtableBase(appKeyOrAccessToken, baseId))
{
BaseSchemaInclude[] scInclude = new BaseSchemaInclude[1];
scInclude[0] = BaseSchemaInclude.visibleFieldIds;
// Base ID passed in AirtableBase ctor earlier will be used so no need to pass in baseId here.
Task<AirtableGetBaseSchemaResponse> task = airtableBase.GetBaseSchema(baseId: null, scInclude);
var response = await task;
if (!response.Success)
{
string errorMessage = null;
if (response.AirtableApiError is AirtableApiException)
{
errorMessage = response.AirtableApiError.ErrorMessage;
if (response.AirtableApiError is AirtableInvalidRequestException)
{
errorMessage += "\nDetailed error message: ";
errorMessage += response.AirtableApiError.DetailedErrorMessage;
}
else
{
errorMessage = "Unknown error";
}
}
// Report errorMessage
}
else
{
IEnumerable<TableModel>? tables = response!.Tables;
Assert.IsNotNull(tables);
Assert.IsTrue(tables.Count() > 0);
foreach (var tableModel in tables)
{
// do something with each tableModel which is the table schema
}
}
}Airtable.CreateBase(string, string, TableConfig[], CancellationToken)
Creates a new base with the provided tables and returns the schema for the newly created base.
Refer to field types for supported field types, the write format for field options, and other specifics for certain field types. Supported field types have a write format shown.
At least one table and field must be specified. The first field in the fields array will be used as the table's primary field and must be a supported primary field type. Fields must have case-insensitive unique names within the table.
A default grid view will be created with all fields visible for each provided table.
Namespace: AirtableApiClient
Assembly: AirtableApiClient.dll
public async CreateTable(string nameOfBaseToCreate, string workspaceIdofBase, TableConfig[] tablesToCreate, CancellationToken token = default(CancellationToken))Type: string
Name of base to be created
Type: string
ID of workspace that the base to be created will be in
Type: [TableConfig](https://github.com/ngocnicholas/airtable.net/wiki/TableConfig)[]
Array of TableConfig, each element of the array contains the list of fields for each table to be created in the new base.
Type: CancellationToken
An optional field for providing a means to cancel the operation.
The task object representing the asynchronous operation.
This operation will not block. The returned task object will complete once the entire response including content is read.
using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Linq;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Text.Json;
using System.Text.Json.Serialization;
using AirtableApiClient;
readonly string appKeyOrAccessToken= YOUR_APP_KEY_OR_ACCESS_TOKEN;
readonly string baseName = YOUR_BASE_NAME;
readonly string workspaceId = YOUR_WORKSPACE_ID;
readonly string tableName = NAME_OF_TABLE_TO_BE_CREATED; IFieldConfig[] fieldsForTable0 = new IFieldConfig[10]; // In this example, we have 10 fields in the 1st table to be created.
fieldsForTable0[0] = new SingleLineTextFieldConfig
{
Name = "Name",
};
fieldsForTable0[1] = new LongTextFieldConfig() { Name = "Notes" };
fieldsForTable0[2] = new AttachmentFieldConfig { Name = "Attachments" };
fieldsForTable0[3] = new CheckboxFieldConfig
{
Name = "Checkbox",
ConfigOptions = new CheckboxConfigOptions
{
Icon = "xCheckbox",
Color = "cyanBright"
}
};
fieldsForTable0[4] = new UrlFieldConfig() { Name = "URL" };
fieldsForTable0[5] = new PhoneFieldConfig { Name = "Phone Number" };
fieldsForTable0[6] = new NumberFieldConfig
{
Name = "Our House Worth",
ConfigOptions = new NumberConfigOptions { Precision = 3 }
};
fieldsForTable0[7] = new NumberFieldConfig { Name = "My savings", ConfigOptions = new NumberConfigOptions { Precision = 2 } };
fieldsForTable0[8] = new PercentFieldConfig { Name = "Percent", ConfigOptions = new PercentConfigOptions { Precision = 1 } };
fieldsForTable0[9] = new RatingFieldConfig
{
Name = "Rating",
ConfigOptions = new RatingConfigOptions
{
Max = 5,
Color = "orangeBright",
Icon = "star"
}
};
using (AirtableBase airtableBase = new AirtableBase(appKeyOrAccessToken))
{
TableConfig[] tableConfigs = new TableConfig[1]; // In this example we will create only one table in the new base to be created
tableConfigs[0] = new TableConfig
{
Name = NAME_OF_TABLE_TO_BE_CREATED,
Description = "Some description for this table",
Fields = fieldsForTable0!
};
Task<AirtableCreateBaseResponse> task = airtableBase.CrateBase(NAME_OF_BASE_TO_BE_CREATED, YOUR_WORKSPACE_ID, tableConfigs);
var response = await task;
if (!response.Success)
{
string errorMessage = null;
if (response.AirtableApiError is AirtableApiException)
{
errorMessage = response.AirtableApiError.ErrorMessage;
if (response.AirtableApiError is AirtableInvalidRequestException)
{
errorMessage += "\nDetailed error message: ";
errorMessage += response.AirtableApiError.DetailedErrorMessage;
}
else
{
errorMessage = "Unknown error";
}
}
// Report errorMessage
}
else
{
IEnumerable<TableModel>? tables = response!.Tables;
Assert.IsNotNull(tables);
Assert.IsTrue(tables.Count() > 0);
var tableModel = tables.First(); // In this example, we only created one table in the newly created new base.
// tableModel represents the schema of the new table.
var fields = tableModel.Fields;
// now you can do something with the table schema such as using all the fields in tis table.
}
}Airtable.ListRecords(string, string, IEnumerable, string, int?, int?, IEnumerable<Sort>, string, string, string, string, bool, bool?, CancellationToken))
Get a list of records in a specific table. Start the listing at a specific offset. Specify what fields should be included in the record together with a specific filter formula, the number of records per page. Specify how the record list should be sorted and from which view of the table. This method is an asynchronous operation.
Namespace: AirtableApiClient
Assembly: AirtableApiClient.dll
public async Task<AirtableListRecordsResponse> ListRecords(
string tableIdOrName,
string offset = null,
IEnumerable<string> fields = null,
string filterByFormula = null,
int? maxRecords = null,
int? pageSize = null,
IEnumerable<Sort> sort = null,
string view = null,
string cellFormat = null,
string timeZone = null,
string userLocale = null,
bool returnFieldsByFieldId = false,
bool? includeCommentCount = null,
CancellationToken token = default(CancellationToken))Type: string
Name of the table of which the records to be retrieved from
Type: string
offset into the table where the record listing starts
Type: Inumerable<string>
Only data for fields whose names or ID's are in this list will be included in the records. If you
don't need every field, you can use this parameter to reduce the amount of data transferred.
Type: string
A formula used to filter records. The formula will be evaluated for each record, and if the
result is not 0, false, "", NaN, [], or #Error! the record will be included in the response.
Type: int
The maximum total number of records that will be returned.
Type: int
The number of records returned in each request. Must be less than or equal to 100.
Default is 100.
Type: Sort
A list of Sort objects that specifies how the records will be ordered. Each Sort
object must have a field key specifying the name of the field to sort on, and an
optional direction key that is either Direction.Asc or Direction.Desc. The default
direction is Direction.Asc.
Type: string
The name or ID of a view in the Artists table. If set, only the records in that view
will be returned. The records will be sorted according to the order of the view.
Type: string
The format that should be used for cell values. Supported values are:
json: cells will be formatted as JSON, depending on the field type.
string: cells will be formatted as user-facing strings, regardless of the field type.
The timeZone and userLocale parameters are required when using string as the cellFormat.
Type: string
The time zone that should be used to format dates when using string as the cellFormat. This parameter is required when using string as the cellFormat.
Type: string
The user locale that should be used to format dates when using string as the cellFormat. This parameter is required when using string as the cellFormat.
Type: bool
An optional boolean value that lets you return field objects where the key is the field id.
This defaults to false, which returns field objects where the key is the field name.
Type: bool?
An optional field that, if specified, includes commentCount on each record returned.
Type: CancellationToken
An optional field for providing a means to cancel the operation.
The task object representing the asynchronous operation.
This operation will not block. The returned task object will complete once the entire response including content is read.
Returned records do not include any fields with "empty" values, e.g. "", [], or false.
The server returns one page of records at a time. Each page will contain pageSize records, which is 100 by default.
If there are more records, the response will contain an offset. To fetch the next page of records, include offset in the next request's parameters
using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Linq;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Text.Json;
using System.Text.Json.Serialization;
using AirtableApiClient;
readonly string baseId = YOUR_BASE_ID;
readonly string appKey = YOUR_APP_KEY_OR_ACCESS_TOKEN; string offset = null;
string errorMessage = null;
var records = new List<AirtableRecord>();
using (AirtableBase airtableBase = new AirtableBase(appKeyOrAccessToken, baseId))
{
//
/ Use 'offset' and 'pageSize' to specify the records that you want
// to retrieve.
// Only use a 'do while' loop if you want to get multiple pages
// of records.
//
do
{
Task<AirtableListRecordsResponse> task = airtableBase.ListRecords(
YOUR_TABLE_NAME,
offset,
fields,
filterByFormula,
maxRecords,
pageSize,
sort,
view,
cellFormat
timeZone,
userLocale,
returnFieldsByFieldId,
includeCommentCount,
token)
AirtableListRecordsResponse response = await task;
if (response.Success)
{
records.AddRange(response.Records.ToList());
offset = response.Offset;
}
else if (response.AirtableApiError is AirtableApiException)
{
errorMessage = response.AirtableApiError.ErrorMessage;
if (response.AirtableApiError is AirtableInvalidRequestException)
{
errorMessage += "\nDetailed error message: ";
errorMessage += response.AirtableApiError.DetailedErrorMessage;
}
break;
}
else
{
errorMessage = "Unknown error";
break;
}
} while (offset != null);
}
if (!string.IsNullOrEmpty(errorMessage))
{
// Error reporting
}
else
{
// Do something with the retrieved 'records' and the 'offset'
// for the next page of the record list.
}Airtable.ListRecords(string, string, IEnumerable, string, int?, int?, IEnumerable<Sort>, string, string, string, string, bool, bool?, CancellationToken)
Get a list of record<T> in a specific table as an asynchronous operation. The fields of each record are deserialized to type <T>. Start the listing at a specific offset. Specify what fields should be included in the record together with a specific filter formula, the number of records per page. Specify how the record list should be sorted and from which view of the table. This method is an asynchronous operation.
Namespace: AirtableApiClient
Assembly: AirtableApiClient.dll
public async Task<AirtableListRecordsResponse<T>> ListRecords<T>(
string tableIdOrName,
string offset = null,
IEnumerable<string> fields = null,
string filterByFormula = null,
int? maxRecords = null,
int? pageSize = null,
IEnumerable<Sort> sort = null,
string view = null,
string cellFormat = null,
string timeZone = null,
string userLocale = null,
bool returnFieldsByFieldId = false,
bool? includeCommentCount = null,
Cancellation token = default(CancellationToken))Type: string
Name of the table of which the records to be retrieved from
Type: string
offset into the table where the record listing starts
Type: Inumerable<string>
Only data for fields whose names or ID's are in this list will be included in the records. If you
don't need every field, you can use this parameter to reduce the amount of data transferred.
Type: string
A formula used to filter records. The formula will be evaluated for each record, and if the
result is not 0, false, "", NaN, [], or #Error! the record will be included in the response.
Type: int
The maximum total number of records that will be returned.
Type: int
The number of records returned in each request. Must be less than or equal to 100.
Default is 100.
Type: Sort
A list of Sort objects that specifies how the records will be ordered. Each Sort
object must have a field key specifying the name of the field to sort on, and an
optional direction key that is either Direction.Asc or Direction.Desc. The default
direction is Direction.Asc.
Type: string
The name or ID of a view in the Artists table. If set, only the records in that view
will be returned. The records will be sorted according to the order of the view.
Type: string
The format that should be used for cell values. Supported values are:
json: cells will be formatted as JSON, depending on the field type.
string: cells will be formatted as user-facing strings, regardless of the field type.
The timeZone and userLocale parameters are required when using string as the cellFormat.
Type: string
The time zone that should be used to format dates when using string as the cellFormat. This parameter is required when using string as the cellFormat.
Type: string
The user locale that should be used to format dates when using string as the cellFormat. This parameter is required when using string as the cellFormat.
Type: bool
An optional boolean value that lets you return field objects where the key is the field id.
This defaults to false, which returns field objects where the key is the field name.
Type: bool?
An optional field that, if specified, includes commentCount on each record returned.
Type: CancellationToken
An optional field for providing a means to cancel the operation.
The task object representing the asynchronous operation.
This operation will not block. The returned task object will complete once the entire response including content is read.
Returned records do not include any fields with "empty" values, e.g. "", [], or false.
The server returns one page of records at a time. Each page will contain pageSize records, which is 100 by default.
If there are more records, the response will contain an offset. To fetch the next page of records, include offset in the next request's parameters
The class Artist is used to encapsulate all fields of each record of the
Artists table to be used in this example.
In this process we need to make sure that all Airtable field names are
valid C# field names by making use of the [JsonProperty("AirtableFieldName"]
annotation; see JsonProperty("On Display?")] below as an example.
public class Artist
{
public string Name { get; set; }
public List<AirtableAttachment> Attachments { get; set; }
public string Bio { get; set; }
[JsonProperty("On Display?")]
public bool OnDisplay { get; set; }
public List<string> Collection { get; set; }
public List<string> Genre { get; set; }
}using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Linq;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Text.Json;
using System.Text.Json.Serialization;
using AirtableApiClient;
readonly string baseId = YOUR_BASE_ID;
readonly string appKey = YOUR_APP_KEY_OR_ACCESS_TOKEN; string offset = null;
string errorMessage = null;
var records = new List<AirtableRecord<Artist>();
using (AirtableBase airtableBase = new AirtableBase(appKeyOrAccessToken, baseId))
{
//
/ Use 'offset' and 'pageSize' to specify the records that you want
// to retrieve.
// Only use a 'do while' loop if you want to get multiple pages
// of records.
//
do
{
Task<AirtableListRecordsResponse<Artist>> task = airtableBase.ListRecords<Artist>(
ARTISTS_TABLE_NAME,
offset,
fields,
filterByFormula,
maxRecords,
pageSize,
sort,
view,
cellFormat,
timeZone,
userLocale,
returnFieldsByFieldId,
includeCommentCount);
AirtableListRecordsResponse response = await task;
if (response.Success)
{
records.AddRange(response.Records.ToList());
offset = response.Offset;
}
else if (response.AirtableApiError is AirtableApiException)
{
errorMessage = response.AirtableApiError.ErrorMessage;
if (response.AirtableApiError is AirtableInvalidRequestException)
{
errorMessage += "\nDetailed error message: ";
errorMessage += response.AirtableApiError.DetailedErrorMessage;
}
break;
}
else
{
errorMessage = "Unknown error";
break;
}
} while (offset != null);
}
if (!string.IsNullOrEmpty(errorMessage))
{
// Error reporting
}
else
{
// Do something with the retrieved 'records' and the 'offset'
// for the next page of the record list.
// See how to extract fields of each record as an instance of Artist in the example section below
} // Retrieve all fields of the 1st record from an instance of Artist.
// If the first Artist record in the list is Al Held then:
Artist AlHeld = response.RecordList[0].Fields;
Assert.AreEqual(AlHeld.Name, "Al Held");
Assert.IsTrue(AlHeld.OnDisplay);
Assert.AreEqual(AlHeld.Collection.Count, 1);
Assert.AreEqual(AlHeld.Genre.Count, 2);
Assert.IsNotNull(AlHeld.Bio);
Assert.AreEqual(AlHeld.Attachments.Count, 4);
Airtable.RetrieveRecord(string, string, CancellationToken))
Retrieve a record with a specific ID from a specific table as an asynchronous operation.
Namespace: AirtableApiClient
Assembly: AirtableApiClient.dll
public async Task<AirtableRetrieveRecordResponse> RetrieveRecord(
string tableIdOrName,
string id,
string cellFormat = null,
string timeZone = null,
string userLocale = null,
bool returnFieldsByFieldId = false,
Cancellation token = default(CancellationToken))Type: string
Name of the table of which the record to be retrieved from
Type: string
ID of the record to be retrieved.
Type: string
The format that should be used for cell values. Supported values are:
json: cells will be formatted as JSON, depending on the field type.
string: cells will be formatted as user-facing strings, regardless of the field type.
The timeZone and userLocale parameters are required when using string as the cellFormat.
Type: string
The time zone that should be used to format dates when using string as the cellFormat. This parameter is required when using string as the cellFormat.
Type: string
The user locale that should be used to format dates when using string as the cellFormat. This parameter is required when using string as the cellFormat.
Type: bool
An optional boolean value that lets you return field objects where the key is the field id.
This defaults to false, which returns field objects where the key is the field name.
Type: CancellationToken
An optional field for providing a means to cancel the operation.
The task object representing the asynchronous operation.
This operation will not block. The returned task object will complete once the entire response including content is read. Any "empty" fields (e.g. "", [], or false) in the record will not be returned. In attachment objects included in the retrieved record (Attachments), only id, url, and filename are always returned. Other attachment properties may not be included.
using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Linq;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Text.Json;
using System.Text.Json.Serialization;
using AirtableApiClient;
readonly string baseId = YOUR_BASE_ID;
readonly string appKey = YOUR_APP_KEY_OR_ACCESS_TOKEN; using (AirtableBase airtableBase = new AirtableBase(appKeyOrAccessToken, baseId))
{
Task<AirtableRetrieveRecordResponse> task = airtableBase.RetrieveRecord(YOR_TABLE_NAME, ID_OF_RECORD_TO_RETRIEVE);
var response = await task;
if (!response.Success)
{
string errorMessage = null;
if (response.AirtableApiError is AirtableApiException)
{
errorMessage = response.AirtableApiError.ErrorMessage;
}
else
{
errorMessage = "Unknown error";
}
// Report errorMessage
}
else
{
var record = response.Record;
// Do something with your retrieved record.
// Such as getting the attachmentList of the record if you
// know the Attachment field name
var attachmentList = response.Record.GetAttachmentField(YOUR_ATTACHMENT_FIELD_NAME);
}
}Airtable.RetrieveRecord<T>(string, string, CancellationToken token)
Retrieve a record with a specific ID from a specific table as an asynchronous operation.
The fields of the retrieved record are deserialized in type <T>.
Namespace: AirtableApiClient
Assembly: AirtableApiClient.dll
public async Task<AirtableRetrieveRecordResponse<T>> RetrieveRecord<T>(
string tableIdOrName,
string id,
string cellFormat = null,
string timeZone = null,
string userLocale = null,
bool returnFieldsByFieldId = false,
Cancellation token = default(CancellationToken))Type: string
Name of the table of which the record to be retrieved from
Type: string
ID of the record to be retrieved.
Type: string
The format that should be used for cell values. Supported values are:
json: cells will be formatted as JSON, depending on the field type.
string: cells will be formatted as user-facing strings, regardless of the field type.
The timeZone and userLocale parameters are required when using string as the cellFormat.
Type: string
The time zone that should be used to format dates when using string as the cellFormat. This parameter is required when using string as the cellFormat.
Type: string
The user locale that should be used to format dates when using string as the cellFormat. This parameter is required when using string as the cellFormat.
Type: bool
An optional boolean value that lets you return field objects where the key is the field id.
This defaults to false, which returns field objects where the key is the field name.
Type: CancellationToken
An optional field for providing a means to cancel the operation.
The task object representing the asynchronous operation.
This operation will not block. The returned task object will complete once the entire response including content is read. Any "empty" fields (e.g. "", [], or false) in the record will not be returned. In attachment objects included in the retrieved record (Attachments), only id, url, and filename are always returned. Other attachment properties may not be included.
The class Artist is used to encapsulate all fields of each record of the Artists
table. In this process we need to make sure that all Airtable field names are
valid C# field names by making use of the [JsonProperty("AirtableFieldName")]
annotation; see [JsonProperty("On Display?")] below as an example.
public class Artist
{
public string Name { get; set; }
public List<AirtableAttachment> Attachments { get; set; }
public string Bio { get; set; }
[JsonProperty("On Display?")]
public bool OnDisplay { get; set; }
public List<string> Collection { get; set; }
public List<string> Genre { get; set; }
}using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Linq;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Text.Json;
using System.Text.Json.Serialization;
using AirtableApiClient;
readonly string baseId = YOUR_BASE_ID;
readonly string appKey = YOUR_APP_KEY_OR_ACCESS_TOKEN; using (AirtableBase airtableBase = new AirtableBase(appKeyOrAccessToken, baseId))
{
Task<AirtableRetrieveRecordResponse<Artist> task = airtableBase.RetrieveRecord<Artist>(ARTISTS_TABLE_NAME, ID_OF_RECORD_TO_RETRIEVE);
var response = await task;
if (!response.Success)
{
string errorMessage = null;
if (response.AirtableApiError is AirtableApiException)
{
errorMessage = response.AirtableApiError.ErrorMessage;
}
else
{
errorMessage = "Unknown error";
}
// Report errorMessage
}
else
{
// Do something with your retrieved record.
// See how to extract fields of the retrieved record as an instance of Artist in the example section below
}
} // Assuming ID_OF_RECORD_TO_RETRIEVE is the Id string of Miya Ando then all test results should be as expected.
Assert.IsTrue(string.Compare(response.Record.Id, ID_OF_RECORD_TO_RETRIEVE) == 0);
// Abstract all fields of the record as an instance of Artist.
Artist MiyaAndo = response.Record.Fields;
Assert.AreEqual(MiyaAndo.Name, "MiyaAndo");
Assert.IsFalse(MiyaAndo.OnDisplay);
Assert.AreEqual(MiyaAndo.Collection.Count, 1);
Assert.AreEqual(MiyaAndo.Genre.Count, 2);
Assert.IsNotNull(MiyaAndo.Bio);
Assert.AreEqual(MiyaAndo.Attachments.Count, 4);
AirtableBase.CreateRecord( string, Fields, bool, CancellationToken)
Create a record in a specific table using provided information as an asynchronous operation. To create new attachments in an attachment field, set the field value to an array of attachment objects. When creating an attachment, url is required, and filename is optional. Airtable will download the file at the given url and keep its own copy of it. All other attachment object properties will be generated server-side soon afterward.
Namespace: AirtableApiClient
Assembly: AirtableApiClient.dll
public async Task<AirtableCreateUpdateReplaceRecordResponse> CreateRecord(
string tableIdOrName,
Fields fields,
bool typecast = false,
Cancellation token = default(CancellationToken))Type: string
Name of the table where the record will be created
Type: Fields parameter representing the fields in the record to be created.
Type: bool
Enable/Disable automatic data conversion. Automatic conversion is disabled by default to
ensure data integrity, but it may be helpful for integrating with 3rd party data sources.
Type: CancellationToken
An optional field for providing a means to cancel the operation.
The task object representing the asynchronous operation.
This operation will not block. The returned task object will complete once the entire response including content is read. You can include all, some, or none of the field values. Returns the created record object if the call succeeded, including a record ID which will uniquely identify the record within the specified table.
using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Linq;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Text.Json;
using System.Text.Json.Serialization;
using AirtableApiClient;
readonly string baseId = YOUR_BASE_ID;
readonly string appKey = YOUR_APP_KEY_OR_ACCESS_TOKEN; using (AirtableBase airtableBase = new AirtableBase(appKeyOrAccessToken, baseId))
{
// Create Attachments list
var attachmentList = new List<AirtableAttachment>();
attachmentList.Add(new AirtableAttachment { Url = "https://upload.wikimedia.org/wikipedia/en/d/d1/Picasso_three_musicians_moma_2006.jpg" });
var fields = new Fields();
fields.AddField("Name", "Pablo Picasso");
fields.AddField("Bio", "Spanish expatriate Pablo Picasso was one of the greatest and most influential artists of the 20th century, as well as the co-creator of Cubism.");
fields.AddField("Attachments", attachmentList);
fields.AddField("On Display?", false);
Task<AirtableCreateUpdateReplaceRecordResponse> task = airtableBase.CreateRecord(tableIdOrName, fields, true);
var response = await task;
if (!response.Success)
{
string errorMessage = null;
if (response.AirtableApiError is AirtableApiException)
{
errorMessage = response.AirtableApiError.ErrorMessage;
}
else
{
errorMessage = "Unknown error";
}
// Report errorMessage
}
else
{
var record = response.Record;
// Do something with your created record.
}
}AirtableBase.CreateRecordGeneric( string, T record, bool, CancellationToken)
Create a record in a specific table using provided information as an asynchronous operation.
Namespace: AirtableApiClient
Assembly: AirtableApiClient.dll
public async Task<AirtableCreateReplaceRecordGenericResponse<T>> CreateRecordGeneric<T>(
string tableIdOrName,
T record,
bool typecast = false,
Cancellation token = default(CancellationToken))Type: string
Name of the table where the record will be created
Type: T
parameter of type T which has the info representing the fields of the record to be created.
Type: bool
Enable/Disable automatic data conversion. Automatic conversion is disabled by default to
ensure data integrity, but it may be helpful for integrating with 3rd party data sources.
Type: CancellationToken
An optional field for providing a means to cancel the operation.
The task object representing the asynchronous operation.
This operation will not block. The returned task object will complete once the entire response including content is read. You can include all, some, or none of the field values. Returns the created record object if the call succeeded, including a record ID which will uniquely identify the record within the specified table.
using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Linq;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Text.Json;
using System.Text.Json.Serialization;
using AirtableApiClient;
readonly string baseId = YOUR_BASE_ID;
readonly string appKey = YOUR_APP_KEY_OR_ACCESS_TOKEN; //--- Some code here -----
// Define your record of type YOUR_RECORD_T
//------------------------
using (AirtableBase airtableBase = new AirtableBase(appKeyOrAccessToken, baseId))
{
Task<AirtableCreateReplaceRecordGenericResponse<YOUR_RECORD_T >> task = airtableBase.CreateRecordGeneric<YOUR_RECORD_T >(tableIdOrName, record, true);
var response = await task;
if (!response.Success)
{
string errorMessage = null;
if (response.AirtableApiError is AirtableApiException)
{
errorMessage = response.AirtableApiError.ErrorMessage;
}
else
{
errorMessage = "Unknown error";
}
// Report errorMessage
}
else
{
YOUR_RECORD_T record = response.Record.Fields;
// Do something with your created record.
}
}AirtableBase.UpdateRecord(string, Fields, string, bool, CancellationToken)
Update some (but not all) fields of a record in a specific table using provided information as an asynchronous operation. Any fields that are not included will not be updated.
To add attachments to an attachment field, add new attachment objects to the existing array. Be sure to include all existing attachment objects that you wish to retain. For the new attachments being added, url is required, and filename is optional. To remove attachments, include the existing array of attachment objects, excluding any that you wish to remove.
Namespace: AirtableApiClient
Assembly: AirtableApiClient.dll
public async Task<AirtableCreateUpdateReplaceRecordResponse> UpdateRecord(
string tableIdOrName,
Fields fields,
string id,
bool typeCast = false,
Cancellation token = default(CancellationToken))Type: string
Name of the table where the record will be updated
Type: Fields parameter representing the fields in the record to be updated.
Type: string
ID of the record to be updated.
Type: bool
Enable/Disable automatic data conversion. Automatic conversion is disabled by default to
ensure data integrity, but it may be helpful for integrating with 3rd party data sources.
Type: CancellationToken
An optional field for providing a means to cancel the operation.
The task object representing the asynchronous operation.
This operation will not block. The returned task object will complete once the entire response including content is read.
using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Linq;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Text.Json;
using System.Text.Json.Serialization;
using AirtableApiClient;
readonly string baseId = YOUR_BASE_ID;
readonly string appKey = YOUR_APP_KEY_OR_ACCESS_TOKEN; using (AirtableBase airtableBase = new AirtableBase(appKeyOrAccessToken, baseId))
{
var fields = new Fields();
fields.AddField("Name", "Pablo Picasso Updated");
fields.AddField("On Display?", true);
Task<AirtableCreateUpdateReplaceRecordResponse> task = airtableBase.UpdateRecord(tableIdOrName, fields, ID_OF_RECORD_TO_UPDATE);
var response = await task;
if (!response.Success)
{
string errorMessage = null;
if (response.AirtableApiError is AirtableApiException)
{
errorMessage = response.AirtableApiError.ErrorMessage;
}
else
{
errorMessage = "Unknown error";
}
// Report errorMessage
}
else
{
var record = response.Record;
// Do something with your updated record.
}
}AirtableBase.ReplaceRecord(string, Fields, string, bool, CancellationToken)
Replace a record with a specific ID in a specific table using provided information as an asynchronous operation.
Namespace: AirtableApiClient
Assembly: AirtableApiClient.dll
public async Task<AirtableCreateUpdateReplaceRecordResponse> ReplaceRecord(
string tableIdOrName,
Fields fields,
string id,
bool typeCast = false,
Cancellation token = default(CancellationToken))Type: string
Name of the table where the record will be replaced with information provided by caller.
Type: Fields parameter representing the fields in the record to be replaced. Any fields that are not included will be cleared.
Type: string
ID of the record to be replaced.
Type: bool
Enable/Disable automatic data conversion. Automatic conversion is disabled by default to
ensure data integrity, but it may be helpful for integrating with 3rd party data sources.
Type: CancellationToken
An optional field for providing a means to cancel the operation.
The task object representing the asynchronous operation.
This operation will not block. The returned task object will complete once the entire response including content is read.
using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Linq;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Text.Json;
using System.Text.Json.Serialization;
using AirtableApiClient;
readonly string baseId = YOUR_BASE_ID;
readonly string appKey = YOUR_APP_KEY_OR_ACCESS_TOKEN; using (AirtableBase airtableBase = new AirtableBase(appKeyOrAccessToken, baseId))
{
var fields = new Fields();
fields.AddField("Name", "Pablo Picasso Replaced");
fields.AddField("On Display?", true);
var attachment1 = new AirtableAttachment { Url = "https://upload.wikimedia.org/wikipedia/en/d/d1/Picasso_three_musicians_moma_2006.jpg" };
var attachment2 = new AirtableAttachment { Url = "https://upload.wikimedia.org/wikipedia/en/thumb/6/6a/Pablo_Picasso%2C_1921%2C_Nous_autres_musiciens_%28Three_Musicians%29%2C_oil_on_canvas%2C_204.5_x_188.3_cm%2C_Philadelphia_Museum_of_Art.jpg/800px-Pablo_Picasso%2C_1921%2C_Nous_autres_musiciens_%28Three_Musicians%29%2C_oil_on_canvas%2C_204.5_x_188.3_cm%2C_Philadelphia_Museum_of_Art.jpg" };
var attachmentList = new List<AirtableAttachment>();
attachmentList.Add(attachment1);
attachmentList.Add(attachment1);
fields.AddField("Attachments", attachmentList);
Task<AirtableCreateUpdateReplaceRecordResponse> task = airtableBase.ReplaceRecord(tableIdOrName, fields, ID_OF_RECORD_TO_BE_REPLACED);
var response = await task;
if (!response.Success)
{
string errorMessage = null;
if (response.AirtableApiError is AirtableApiException)
{
errorMessage = response.AirtableApiError.ErrorMessage;
}
else
{
errorMessage = "Unknown error";
}
// Report errorMessage
}
else
{
var record = response.Record;
// Do something with your replaced record.
}
}AirtableBase.ReplaceRecord(string, T, string, bool, CancellationToken)
Replace a record with a specific ID in a specific table using provided information as an asynchronous operation.
Namespace: AirtableApiClient
Assembly: AirtableApiClient.dll
public async Task<AirtableCreateReplaceRecordGenericResponse<T>> ReplaceRecordGeneric<T>(
string tableIdOrName,
T record,
string id,
bool typeCast = false,
Cancellation token = default(CancellationToken))Type: string
Name of the table where the record will be replaced with information provided by caller.
Type: T
parameter of type T which has the info representing the fields of the record to be replaced.
Any fields that are not included will be cleared.
Type: string ID of the record to be replaced.
Type: bool
Enable/Disable automatic data conversion. Automatic conversion is disabled by default to
ensure data integrity, but it may be helpful for integrating with 3rd party data sources.
Type: CancellationToken
An optional field for providing a means to cancel the operation.
The task object representing the asynchronous operation.
This operation will not block. The returned task object will complete once the entire response including content is read.
using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Linq;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Text.Json;
using System.Text.Json.Serialization;
using AirtableApiClient;
readonly string baseId = YOUR_BASE_ID;
readonly string appKey = YOUR_APP_KEY_OR_ACCESS_TOKEN; using (AirtableBase airtableBase = new AirtableBase(appKeyOrAccessToken, baseId))
{
//--- Some code here -----
// Define your record of type YOUR_RECORD_T and the ID of the record to be replaced.
//------------------------
Task<AirtableCreateReplaceRecordGenericResponse<YOUR_RECORD_T> task = airtableBase.ReplaceRecordGeneric<YOUR_RECORD_T>(tableIdOrName, record, ID_OF_RECORD_TO_BE_REPLACED);
var response = await task;
if (!response.Success)
{
string errorMessage = null;
if (response.AirtableApiError is AirtableApiException)
{
errorMessage = response.AirtableApiError.ErrorMessage;
}
else
{
errorMessage = "Unknown error";
}
// Report errorMessage
}
else
{
var record = response.Record;
// Do something with your replaced record.
}
}AirtableBase.DeleteRecord(string, string, CancellationToken))
Delete a record with a specific ID in a specific table as an asynchronous operation.
Namespace: AirtableApiClient
Assembly: AirtableApiClient.dll
public async Task<AirtableDeleteRecordResponse> DeleteRecord(
string tableIdOrName,
string id,
Cancellation token = default(CancellationToken))Type: string
Name of the table where the record will be deleted
Type: string
ID of the record to be deleted.
Type: CancellationToken
An optional field for providing a means to cancel the operation.
The task object representing the asynchronous operation.
This operation will not block. The returned task object will complete once the entire response including content is read.
using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Linq;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Text.Json;
using System.Text.Json.Serialization;
using AirtableApiClient;
readonly string baseId = YOUR_BASE_ID;
readonly string appKey = YOUR_APP_KEY_OR_ACCESS_TOKEN; using (AirtableBase airtableBase = new AirtableBase(appKeyOrAccessToken, baseId))
{
Task<AirtableDeleteRecordResponse> task = airtableBase.DeleteRecord(YOUR_TABLE_NAME, ID_OF_RECORD_TO_DELETE);
var response = await task;
if (!response.Success)
{
string errorMessage = null;
if (response.AirtableApiError is AirtableApiException)
{
errorMessage = response.AirtableApiError.ErrorMessage;
if (response.AirtableApiError is AirtableInvalidRequestException)
{
errorMessage += "\nDetailed error message: ";
errorMessage += response.AirtableApiError.DetailedErrorMessage;
}
else
{
errorMessage = "Unknown error";
}
}
// Report errorMessage
}
}
AirtableBase.CreateMultipleRecords(string, Fields[], bool, CancellationToken))
Create multiple records in a specific table using provided information in a single an asynchronous operation. The fields of each record are provided in a Fields[]. To create new attachments in an attachment field, set the field value to an array of attachment objects. When creating an attachment, url is required, and filename is optional. Airtable will download the file at the given url and keep its own copy of it. All other attachment object properties will be generated server-side soon afterward.
**Namespace: AirtableApiClient
**Assembly: AirtableApiClient.dll
##Syntax
public async Task<AirtableCreateUpdateReplaceMultipleRecordsResponse> CreateMultipleRecords(
string tableIdOrName,
Fields[] fields,
bool typecast = false,
Cancellation token = default(CancellationToken))Type: string
Name of the table where the record will be created
Type: [Fields](https://github.com/ngocnicholas/airtable.net/wiki/Fields)
parameter representing the fields in the record to be created.
Type: bool
Enable/Disable automatic data conversion. Automatic conversion is disabled by default to
ensure data integrity, but it may be helpful for integrating with 3rd party data sources.
Type: CancellationToken
An optional field for providing a means to cancel the operation.
The task object representing the asynchronous operation.
This operation will not block. The returned task object will complete once the entire response including content is read. You can include all, some, or none of the field values. Returns the created record list object if the call succeeded. Each record in the list has a record ID which will uniquely identify the record within the specified table.
##Example
using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Linq;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Text.Json;
using System.Text.Json.Serialization;
using AirtableApiClient;
readonly string baseId = YOUR_BASE_ID;
readonly string appKey = YOUR_APP_KEY_OR_ACCESS_TOKEN; using (AirtableBase airtableBase = new AirtableBase(appKeyOrAccessToken, baseId))
{
Fields[] fields = new Fields[2];
fields[0] = new Fields();
fields[0].AddField("Name", "Claude Monet");
fields[0].AddField("Bio", "Oscar-Claude Monet was a French painter, a founder of French Impressionist painting and the most consistent and prolific practitioner of the movement's philosophy of expressing one's perceptions before nature, especially as applied to plein air landscape painting");
fields[1] = new Fields();
fields[1].AddField("Name", "Vincent van Gogh");
fields[1].AddField("Bio", "Vincent Willem van Gogh was a Dutch post-impressionist painter who is among the most famous and influential figures in the history of Western art. In just over a decade he created about 2,100 artworks, including around 860 oil paintings, most of them in the last two years of his life.");
Task<AirtableCreateUpdateReplaceMultipleRecordsResponse> task = airtableBase.CreateMultipleRecords(TABLE_NAME, fields, true);
var response = await task;
if (!response.Success)
{
string errorMessage = null;
if (response.AirtableApiError is AirtableApiException)
{
errorMessage = response.AirtableApiError.ErrorMessage;
if (response.AirtableApiError is AirtableInvalidRequestException)
{
errorMessage += "\nDetailed error message: ";
errorMessage += response.AirtableApiError.DetailedErrorMessage;
}
}
else
{
errorMessage = "Unknown error";
}
// Report errorMessage
}
else
{
AirtableRecord[] records = response.Records;
// Do something with your created records.
}
}AirtableBase.CreateMultipleRecords(string, AirtableRecord[], bool, CancellationToken))
Create multiple records in a specific table using provided information in a single an asynchronous operation. The fields information for the records to be created are provided in a AirtableRecord[]. To create new attachments in an attachment field, set the field value to an array of attachment objects. When creating an attachment, url is required, and filename is optional. Airtable will download the file at the given url and keep its own copy of it. All other attachment object properties will be generated server-side soon afterward.
**Namespace: AirtableApiClient
**Assembly: AirtableApiClient.dll
##Syntax
public async Task<AirtableCreateUpdateReplaceMultipleRecordsResponse> CreateMultipleRecords(
string tableIdOrName,
AirtableRecord[] records,
bool typecast = false,
Cancellation token = default(CancellationToken))Type: string
Name of the table where the record will be created
Type: AirtableRecord[] parameter representing the fields information of the records to be created.
Type: bool
Enable/Disable automatic data conversion. Automatic conversion is disabled by default to
ensure data integrity, but it may be helpful for integrating with 3rd party data sources.
Type: CancellationToken
An optional field for providing a means to cancel the operation.
The task object representing the asynchronous operation.
This operation will not block. The returned task object will complete once the entire response including content is read. You can include all, some, or none of the field values. Returns the created record list object if the call succeeded. Each record in the list has a record ID which will uniquely identify the record within the specified table.
##Example
using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Linq;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Text.Json;
using System.Text.Json.Serialization;
using AirtableApiClient;
readonly string baseId = YOUR_BASE_ID;
readonly string appKey = YOUR_APP_KEY_OR_ACCESS_TOKEN; using (AirtableBase airtableBase = new AirtableBase(appKeyOrAccessToken, baseId))
{
// Do something to obtain the fields information of the records to be created and store it in AirtableRecord[] records.
// This AirtableRecord[] records has the same syntax as AirtableListRecordsResponse.Records returned by ListRecords().
Task<AirtableCreateUpdateReplaceMultipleRecordsResponse> task = airtableBase.CreateMultipleRecords(TABLE_NAME, records);
var response = await task;
if (!response.Success)
{
string errorMessage = null;
if (response.AirtableApiError is AirtableApiException)
{
errorMessage = response.AirtableApiError.ErrorMessage;
if (response.AirtableApiError is AirtableInvalidRequestException)
{
errorMessage += "\nDetailed error message: ";
errorMessage += response.AirtableApiError.DetailedErrorMessage;
}
}
else
{
errorMessage = "Unknown error";
}
// Report errorMessage
}
else
{
AirtableRecord[] records = response.Records;
// Do something with your created records.
}
}AirtableBase.CreateMultipleRecordsGeneric<T>(string, T[], bool, bool, CancellationToken))
Create multiple records in a specific table using provided information in a single an asynchronous operation. The fields information for the records to be created are provided in a T[].
**Namespace: AirtableApiClient
**Assembly: AirtableApiClient.dll
##Syntax
public async Task<AirtableCreateReplaceMultipleRecordsGenericResponse<T>> CreateMultipleRecordsGeneric<T>(
string tableIdOrName,
T[] records,
bool returnFieldsByFieldId = false,
bool typecast = false,
Cancellation token = default(CancellationToken))Type: string
Name of the table where the record will be created
Type: T[] parameter of type T[] each array element of which has the info representing the fields of the records to be created.
Type: bool
Enable/Disable automatic data conversion. Automatic conversion is disabled by default to
ensure data integrity, but it may be helpful for integrating with 3rd party data sources.
Type: boolean
An optional boolean value that lets you return field objects where the key is the field id.
This defaults to false, which returns field objects where the key is the field name.
Type: CancellationToken
An optional field for providing a means to cancel the operation.
The task object representing the asynchronous operation.
This operation will not block. The returned task object will complete once the entire response including content is read. You can include all, some, or none of the field values. Returns the created record list object if the call succeeded. Each record in the list has a record ID which will uniquely identify the record within the specified table.
##Example
using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Linq;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Text.Json;
using System.Text.Json.Serialization;
using AirtableApiClient;
readonly string baseId = YOUR_BASE_ID;
readonly string appKey = YOUR_APP_KEY_OR_ACCESS_TOKEN; using (AirtableBase airtableBase = new AirtableBase(appKeyOrAccessToken, baseId))
{
//----- Some code here -----------
// Define records of YOUR_RECORD_T.
//--------------------------------
Task<AirtableCreateReplaceMultipleRecordsGenericResponse<YOUR_RECORD_T>> task = airtableBase.CreateMultipleRecordsGeneric<YOUR_RECORD_T>(TABLE_NAME, records, true);
var response = await task;
if (!response.Success)
{
string errorMessage = null;
if (response.AirtableApiError is AirtableApiException)
{
errorMessage = response.AirtableApiError.ErrorMessage;
if (response.AirtableApiError is AirtableInvalidRequestException)
{
errorMessage += "\nDetailed error message: ";
errorMessage += response.AirtableApiError.DetailedErrorMessage;
}
}
else
{
errorMessage = "Unknown error";
}
// Report errorMessage
}
else
{
AirtableRecord<YOUR_RECORD_T>[] recordArr = response.Records;
// Do something with your created records.
}
}AirtableBase.UpdateMultipleRecords(string, IdFields[], bool, CancellationToken)
Update one or more records in a specific table using provided information in a single asynchronous operation. Any fields that are not included in the provided information will not be updated.
To add attachments to an attachment field, add new attachment objects to the existing array. Be sure to include all existing attachment objects that you wish to retain. For the new attachments being added, url is required, and filename is optional. To remove attachments, include the existing array of attachment objects, excluding any that you wish to remove.
Namespace: AirtableApiClient
Assembly: AirtableApiClient.dll
public async Task<AirtableCreateUpdateReplaceMultipleRecordsResponse> UpdateMultipleRecords(
string tableIdOrName,
IdFields[] idFields,
bool typeCast = false,
returnFieldsByFieldId false,
performUpsert = null,
Cancellation token = default(CancellationToken))Type: string
Name of the table where the record(s) will be updated
Type: IdFields An array of ID and fields of the records to be updated.
Type: bool
Enable/Disable automatic data conversion. Automatic conversion is disabled by default to
ensure data integrity, but it may be helpful for integrating with 3rd party data sources.
Type: boolean
An optional boolean value that lets you return field objects where the key is the field id.
This defaults to false, which returns field objects where the key is the field name.
Type: PerformUpsert
Optional. Enable/Disable upsert behavior.
When performUpsert is not null, the id property of records becomes optional.
Records that do not include id will use the fields chosen by fieldsToMergeOn as an external
ID to match with existing records.
This operation will not block. The returned task object will complete once the entire response including content is read.
using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Linq;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Text.Json;
using System.Text.Json.Serialization;
using AirtableApiClient;
readonly string baseId = YOUR_BASE_ID;
readonly string appKey = YOUR_APP_KEY_OR_ACCESS_TOKEN; using (AirtableBase airtableBase = new AirtableBase(appKeyOrAccessToken, baseId))
{
IdFields[] idFields = new IdFields[2];
idFields[0] = new IdFields(ID_MONET_TO_UPDATE);
idFields[0].AddField("On Display?", true);
idFields[1] = new IdFields(ID_VANGOGH_TO_UPDATE);
idFields[1].AddField("Name", "UpdatedNameVincentVanGogh");
Task<AirtableCreateUpdateReplaceMultipleRecordsResponse> task = airtableBase.UpdateMultipleRecords(TABLE_NAME, idFields);
var response = await task;
if (!response.Success)
{
string errorMessage = null;
if (response.AirtableApiError is AirtableApiException)
{
errorMessage = response.AirtableApiError.ErrorMessage;
if (response.AirtableApiError is AirtableInvalidRequestException)
{
errorMessage += "\nDetailed error message: ";
errorMessage += response.AirtableApiError.DetailedErrorMessage;
}
}
else
{
errorMessage = "Unknown error";
}
// Report errorMessage
}
else
{
AirtableRecord[] records = response.Records;
// Do something with the updated records.
}
}AirtableBase.UpdateMultipleRecords(string, [AirtableRecord](AirtableRecord, bool, CancellationToken))
Update one or more records in a specific table using provided information in a single asynchronous operation. Any fields (in the input records) that are not included in the provided information will not be updated.
To add attachments to an attachment field, add new attachment objects to the existing array. Be sure to include all existing attachment objects that you wish to retain. For the new attachments being added, url is required, and filename is optional. To remove attachments, include the existing array of attachment objects, excluding any that you wish to remove.
Namespace: AirtableApiClient
Assembly: AirtableApiClient.dll
public async Task<AirtableCreateUpdateReplaceMultipleRecordsResponse> UpdateMultipleRecords(
string tableIdOrName,
AirtableRecord[] records,
bool typeCast = false,
returnFieldsByFieldId = false,
performUpsert = null,
Cancellation token = default(CancellationToken))Type: string
Name of the table where the record(s) will be updated
Type: AirtableRecord
parameter representing the records to be updated with the new fields stored in this parameters.
To obtain an AirtableReord[] easily, use ListRecords() to obtain one and then tailor
them to what you want.
Type: bool
Enable/Disable automatic data conversion. Automatic conversion is disabled by default to
ensure data integrity, but it may be helpful for integrating with 3rd party data sources.
Type: boolean
An optional boolean value that lets you return field objects where the key is the field id.
This defaults to false, which returns field objects where the key is the field name.
Type: PerformUpsert
Optional. Enable/Disable upsert behavior.
When performUpsert is not null, the id property of records becomes optional.
Records that do not include id will use the fields chosen by fieldsToMergeOn as an external
ID to match with existing records.
This operation will not block. The returned task object will complete once the entire response including content is read.
using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Linq;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Text.Json;
using System.Text.Json.Serialization;
using AirtableApiClient;
readonly string baseId = YOUR_BASE_ID;
readonly string appKey = YOUR_APP_KEY_OR_ACCESS_TOKEN; using (AirtableBase airtableBase = new AirtableBase(appKeyOrAccessToken, baseId))
{
// Do something to obtain a AirtableRecord[] records to use as an input argument.
// This AirtableRecord[] records has the same syntax as AirtableListRecordsResponse.Records returned by ListRecords().
// The fields of input records are the fields to be used in this update operation.
Task<AirtableCreateUpdateReplaceMultipleRecordsResponse> task = airtableBase.UpdateMultipleRecords(TABLE_NAME, records);
var response = await task;
if (!response.Success)
{
string errorMessage = null;
if (response.AirtableApiError is AirtableApiException)
{
errorMessage = response.AirtableApiError.ErrorMessage;
if (response.AirtableApiError is AirtableInvalidRequestException)
{
errorMessage += "\nDetailed error message: ";
errorMessage += response.AirtableApiError.DetailedErrorMessage;
}
}
else
{
errorMessage = "Unknown error";
}
// Report error message
}
else
{
AirtableRecord[] records = response.Records;
// Do something with the updated records.
}
}AirtableBase.ReplaceMultipleRecords(string, IdFields), bool, CancellationToken))
Replace one or more records in a specific table using provided information in a single asynchronous operation.
Namespace: AirtableApiClient
Assembly: AirtableApiClient.dll
public async Task<AirtableCreateUpdateReplaceMultipleRecordsResponse> ReplaceMultipleRecords(
string tableIdOrName,
IdFields[] idFields,
bool typeCast = false,
returnFieldsByFieldId,
performUpsert = null,
Cancellation token = default(CancellationToken))Type: string
Name of the table where the record(s) will be replaced
Type: IdFields An array of ID and fields of the records to be updated.
Type: bool
Enable/Disable automatic data conversion. Automatic conversion is disabled by default to
ensure data integrity, but it may be helpful for integrating with 3rd party data sources.
Type: boolean
An optional boolean value that lets you return field objects where the key is the field id.
This defaults to false, which returns field objects where the key is the field name.
Type: PerformUpsert
Optional. Enable/Disable upsert behavior.
When performUpsert is not null, the id property of records becomes optional.
Records that do not include id will use the fields chosen by fieldsToMergeOn as an external
ID to match with existing records.
Type: CancellationToken
An optional field for providing a means to cancel the operation.
The task object representing the asynchronous operation.
This operation will not block. The returned task object will complete once the entire response including content is read.
using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Linq;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Text.Json;
using System.Text.Json.Serialization;
using AirtableApiClient;
readonly string baseId = YOUR_BASE_ID;
readonly string appKey = YOUR_APP_KEY_OR_ACCESS_TOKEN; using (AirtableBase airtableBase = new AirtableBase(appKeyOrAccessToken, baseId))
{
IdFields[] idFields = new IdFields[2];
idFields[0] = new IdFields(ID_MONET_TO_REPLACE);
idFields[0].AddField("Name", "Claude Monet");
idFields[0].AddField("On Display?", true);
idFields[1] = new IdFields(ID_VANGOGH_TO_REPLACE);
idFields[1].AddField("Name", "Vincent VanGogh replaced");
Task<AirtableCreateUpdateReplaceMultipleRecordsResponse> task = airtableBase.ReplaceMultipleRecords(TABLE_NAME, idFields);
var response = await task;
if (!response.Success)
{
string errorMessage = null;
else if (response.AirtableApiError is AirtableApiException)
{
errorMessage = response.AirtableApiError.ErrorMessage;
if (response.AirtableApiError is AirtableInvalidRequestException)
{
errorMessage += "\nDetailed error message: ";
errorMessage += response.AirtableApiError.DetailedErrorMessage;
}
}
else
{
errorMessage = "Unknown error";
}
// Report errorMessage
}
else
{
AirtableRecord[] records = response.Records;
// Do something with the replaced records
}
}AirtableBase.ReplaceMultipleRecords(string, AirtableRecord, bool, CancellationToken))
Replace one or more records in a specific table using provided information in a single asynchronous operation.
Namespace: AirtableApiClient
Assembly: AirtableApiClient.dll
public async Task<AirtableCreateUpdateReplaceMultipleRecordsResponse> ReplaceMultipleRecords(
string tableIdOrName,
AirtableRecord[] records,
bool typeCast = false,
returnFieldsByFieldId = false,
performUpsert = null,
Cancellation token = default(CancellationToken))Type: string
Name of the table where the record(s) will be replaced
Type: [AirtableRecord](https://github.com/ngocnicholas/airtable.net/wiki/AirtableRecord)
parameter representing the fields in the record to be updated.
To obtain an AirtableRecord[] easily, use ListRecords to get one and then tailor them to what you need.
Type: bool
Enable/Disable automatic data conversion. Automatic conversion is disabled by default to
ensure data integrity, but it may be helpful for integrating with 3rd party data sources.
Type: boolean
An optional boolean value that lets you return field objects where the key is the field id.
This defaults to false, which returns field objects where the key is the field name.
Type: PerformUpsert
Optional. Enable/Disable upsert behavior.
When performUpsert is not null, the id property of records becomes optional.
Records that do not include id will use the fields chosen by fieldsToMergeOn as an external ID
to match with existing records.
Type: CancellationToken
An optional field for providing a means to cancel the operation.
The task object representing the asynchronous operation.
This operation will not block. The returned task object will complete once the entire response including content is read.
using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Linq;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Text.Json;
using System.Text.Json.Serialization;
using AirtableApiClient;
readonly string baseId = YOUR_BASE_ID;
readonly string appKey = YOUR_APP_KEY_OR_ACCESS_TOKEN; using (AirtableBase airtableBase = new AirtableBase(appKeyOrAccessToken, baseId))
{
// Do something to obtain a AirtableRecord[] records containing records to replace the ones currently in the table.
// This AirtableRecord[] records has the same syntax as AirtableListRecordsResponse.Records returned by ListRecords().
Task<AirtableCreateUpdateReplaceMultipleRecordsResponse> task = airtableBase.ReplaceMultipleRecords(TABLE_NAME, records);
var response = await task;
if (!response.Success)
{
string errorMessage = null;
if (response.AirtableApiError is AirtableApiException)
{
errorMessage = response.AirtableApiError.ErrorMessage;
if (response.AirtableApiError is AirtableInvalidRequestException)
{
errorMessage += "\nDetailed error message: ";
errorMessage += response.AirtableApiError.DetailedErrorMessage;
}
}
else
{
errorMessage = "Unknown error";
}
// Report errorMessage
}
else
{
AirtableRecord[] records = response.Records;
// Do something with the replaced records
}
}AirtableBase.ReplaceMultipleRecordsGeneric<T>(string, T[], string[], bool, bool, CancellationToken))
Replace one or more records in a specific table using provided information in a single asynchronous operation.
Namespace: AirtableApiClient
Assembly: AirtableApiClient.dll
public async Task<AirtableCreateReplaceMultipleRecordsGenericResponse<T>> ReplaceMultipleRecordsGeneric<T>(
string tableIdOrName,
T[] records,
string[] ids,
bool typeCast = false,
returnFieldsByFieldId = false,
Cancellation token = default(CancellationToken))Type: string Name of the table where the record(s) will be replaced
Type: <T>
parameter representing the fields information of the records to be created.
Type: string IDs of the records to be replaced.
Type: bool Enable/Disable automatic data conversion. Automatic conversion is disabled by default to ensure data integrity, but it may be helpful for integrating with 3rd party data sources.
Type: boolean An optional boolean value that lets you return field objects where the key is the field id. This defaults to false, which returns field objects where the key is the field name.
Type: CancellationToken An optional field for providing a means to cancel the operation.
The task object representing the asynchronous operation.
This operation will not block. The returned task object will complete once the entire response including content is read.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Text.Json.Serialization;
using System.Threading;
using System.Threading.Tasks;
using System.Web;
readonly string baseId = YOUR_BASE_ID;
readonly string appKey = YOUR_APP_KEY_OR_ACCESS_TOKEN; using (AirtableBase airtableBase = new AirtableBase(appKeyOrAccessToken, baseId))
{
//---- Some code here -------
// Define records of YOUR_RECORD_T.
//---------------------------
Task<AirtableCreateReplaceMultipleRecordsGenericResponse<YOUR_RECORD_T> task = airtableBase.ReplaceMultipleRecordsGeneric<YOUR_RECORD_T>(TABLE_NAME, records, ids);
var response = await task;
if (!response.Success)
{
string errorMessage = null;
if (response.AirtableApiError is AirtableApiException)
{
errorMessage = response.AirtableApiError.ErrorMessage;
if (response.AirtableApiError is AirtableInvalidRequestException)
{
errorMessage += "\nDetailed error message: ";
errorMessage += response.AirtableApiError.DetailedErrorMessage;
}
}
else
{
errorMessage = "Unknown error";
}
// Report errorMessage
}
else
{
AirtableRecord<YOUR_RECORD_T>[] records = response.Records;
// Do something with the replaced records
}
}AirtableBase.ListComments(string, string, string, int?, CancellationToken))
List all comments for the record with a specific ID in a specific table as an asynchronous operation.
Namespace: AirtableApiClient
Assembly: AirtableApiClient.dll
public async Task<AirtableListCommentsResponse> ListComments(
string tableIdOrName,
string recordId,
string offset = null,
int? pageSize = null,
Cancellation token = default(CancellationToken))Type: string
Name of the table where the record is in.
Type: string
ID of the record to have all its comments listed.
string
A pointer to a specific comment. If specified, the returned comments will begin at the specified offset. An offset to the next set of comments will be provided by the API if the number of returned comments exceed the pageSize.
Type: int?
The number of records returned in each request. Must be less than or equal to 100.
Default is 100.
Type: CancellationToken
An optional field for providing a means to cancel the operation.
The task object representing the asynchronous operation.
This operation will not block. The returned task object will complete once the entire response including content is read.
using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Linq;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Text.Json;
using System.Text.Json.Serialization;
using AirtableApiClient;
readonly string baseId = YOUR_BASE_ID;
readonly string appKey = YOUR_APP_KEY_OR_ACCESS_TOKEN; using (AirtableBase airtableBase = new AirtableBase(appKeyOrAccessToken, baseId))
{
Task<AirtableListCommentsResponse> task = airtableBase.ListComments(YOUR_TABLE_NAME, recordId);
var response = await task;
if (!response.Success)
{
string errorMessage = null;
if (response.AirtableApiError is AirtableApiException)
{
errorMessage = response.AirtableApiError.ErrorMessage;
if (response.AirtableApiError is AirtableInvalidRequestException)
{
errorMessage += "\nDetailed error message: ";
errorMessage += response.AirtableApiError.DetailedErrorMessage;
}
else
{
errorMessage = "Unknown error";
}
}
// Report errorMessage
}
}
AirtableBase.CreateComment(string, string, string, CancellationToken)
Creates a comment on the record with a specific ID in a specific table as an asynchronous operation.
Namespace: AirtableApiClient
Assembly: AirtableApiClient.dll
public async Task<AirtableCreateUpdateCommentResponse> CreateComment(
string tableIdOrName,
string recordId,
string commentText,
Cancellation token = default(CancellationToken))Type: string
Name of the table where the record is in.
Type: string
ID of the record to have a comment created on.
string
Text of the comment to be created.
Type: CancellationToken
An optional field for providing a means to cancel the operation.
The task object representing the asynchronous operation.
This operation will not block. The returned task object will complete once the entire response including content is read.
using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Linq;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Text.Json;
using System.Text.Json.Serialization;
using AirtableApiClient;
readonly string baseId = YOUR_BASE_ID;
readonly string appKey = YOUR_APP_KEY_OR_ACCESS_TOKEN; using (AirtableBase airtableBase = new AirtableBase(appKeyOrAccessToken, baseId))
{
Task<AirtableCreateUpdateCommentResponse> task = airtableBase.CreateComment(YOUR_TABLE_NAME, recordId, commentText);
var response = await task;
if (!response.Success)
{
string errorMessage = null;
if (response.AirtableApiError is AirtableApiException)
{
errorMessage = response.AirtableApiError.ErrorMessage;
if (response.AirtableApiError is AirtableInvalidRequestException)
{
errorMessage += "\nDetailed error message: ";
errorMessage += response.AirtableApiError.DetailedErrorMessage;
}
else
{
errorMessage = "Unknown error";
}
}
// Report errorMessage
}
}AirtableBase.UpdateComment(string, string, string, CancellationToken))
Update a comment specified by its ID on the record with a specific ID in a specific table as an asynchronous operation.
Namespace: AirtableApiClient
Assembly: AirtableApiClient.dll
public async Task<AirtableCreateUpdateCommentResponse> UpdateComment(
string tableIdOrName,
string recordId,
string commentText,
string rowCommentId,
Cancellation token = default(CancellationToken))Type: string
Name of the table where the record is in.
Type: string
ID of the record to have its comment updated.
string
Update text of the comment.
string
Id of rowmComment to be updated.
Type: CancellationToken
An optional field for providing a means to cancel the operation.
The task object representing the asynchronous operation.
This operation will not block. The returned task object will complete once the entire response including content is read.
using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Linq;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Text.Json;
using System.Text.Json.Serialization;
using AirtableApiClient;
readonly string baseId = YOUR_BASE_ID;
readonly string appKey = YOUR_APP_KEY_OR_ACCESS_TOKEN; using (AirtableBase airtableBase = new AirtableBase(appKeyOrAccessToken, baseId))
{
Task<AirtableCreateUpdateCommentResponse> task = airtableBase.UpdateComment(YOUR_TABLE_NAME, recordId, commentText, rowCommentId);
var response = await task;
if (!response.Success)
{
string errorMessage = null;
if (response.AirtableApiError is AirtableApiException)
{
errorMessage = response.AirtableApiError.ErrorMessage;
if (response.AirtableApiError is AirtableInvalidRequestException)
{
errorMessage += "\nDetailed error message: ";
errorMessage += response.AirtableApiError.DetailedErrorMessage;
}
else
{
errorMessage = "Unknown error";
}
}
// Report errorMessage
}
}
AirtableBase.DeleteComment(string, string, string, CancellationToken))
Delete a comment specified by its ID on the record with a specific ID in a specific table as an asynchronous operation.
Namespace: AirtableApiClient
Assembly: AirtableApiClient.dll
public async Task<AirtableDeleteCommentResponse> UpdateComment(
string tableIdOrName,
string recordId,
string rowCommentId,
Cancellation token = default(CancellationToken))Type: string
Name of the table where the record is in.
Type: string
ID of the record to have its comment deleted.
string
Id of rowmComment to be delted.
Type: CancellationToken
An optional field for providing a means to cancel the operation.
The task object representing the asynchronous operation.
This operation will not block. The returned task object will complete once the entire response including content is read.
using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Linq;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Text.Json;
using System.Text.Json.Serialization;
using AirtableApiClient;
readonly string baseId = YOUR_BASE_ID;
readonly string appKey = YOUR_APP_KEY_OR_ACCESS_TOKEN; using (AirtableBase airtableBase = new AirtableBase(appKeyOrAccessToken, baseId))
{
Task<AirtableDeleteCommentResponse> task = airtableBase.DeleteComment(YOUR_TABLE_NAME, recordId, rowCommentId);
var response = await task;
if (!response.Success)
{
string errorMessage = null;
if (response.AirtableApiError is AirtableApiException)
{
errorMessage = response.AirtableApiError.ErrorMessage;
if (response.AirtableApiError is AirtableInvalidRequestException)
{
errorMessage += "\nDetailed error message: ";
errorMessage += response.AirtableApiError.DetailedErrorMessage;
}
else
{
errorMessage = "Unknown error";
}
}
// Report errorMessage
}
}AirtableBase.CreateWebhook(WebhooksSpecification, string, CancellationToken))
Creates a new webhook in the specified base. Payloads may be generated and the notification URL (if given) will get a ping shortly after this completes.
Namespace: AirtableApiClient
Assembly: AirtableApiClient.dll
public async Task<AirtableDeleteCommentResponse> CreateWebhook(
WebhooksSpecification spec,
string notificationUrl = null,
Cancellation token = default(CancellationToken))Type: WebhooksSpecification
A object that describe the types of changes the webhook is interested in.
Type: string
An optional URL that can receive notification pings.
Type: CancellationToken
An optional field for providing a means to cancel the operation.
The task object representing the asynchronous operation.
This operation will not block. The returned task object will complete once the entire response including content is read.
using System;
using System.ComponentModel;
using System.Linq;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Text.Json.Serialization;
using AirtableApiClient;
readonly string baseId = YOUR_BASE_ID;
readonly string appKey = YOUR_APP_KEY_OR_ACCESS_TOKEN; using (AirtableBase airtableBase = new AirtableBase(appKeyOrAccessToken, baseId))
{
WebhooksSpecification spec = CreateSpecForWebhook("tableData");
Task<AirtableCreateWebhookResponse> task = airtableBase.CreateWebhook(spec, YOUR_NOTIFICATION_URL);
var response = await task;
if (!response.Success)
{
string errorMessage = null;
if (response.AirtableApiError is AirtableApiException)
{
errorMessage = response.AirtableApiError.ErrorMessage;
if (response.AirtableApiError is AirtableInvalidRequestException)
{
errorMessage += "\nDetailed error message: ";
errorMessage += response.AirtableApiError.DetailedErrorMessage;
}
else
{
errorMessage = "Unknown error";
}
}
// Report errorMessage
}
}
} private WebhooksSpecification CreateSpecForWebhook(string dataTypes)
{
WebhooksSpecification spec = new WebhooksSpecification();
WebhooksOptions options = new WebhooksOptions ();
spec.Options = options;
WebhooksFilters filters = new WebhooksFilters ();
options.Filters = filters;
filters.RecordChangeScope = YOUR_TABLE_ID;
filters.DataTypes = new string[] { "tableData" /* , "tableFields"*/ };
WebhooksIncludes includes = new Includes();
includes.IncludePreviousCellValues = true;
includes.IncludeCellValuesInFieldIds = new string[] { "all" };
options.Includes = includes;
return spec;
}AirtableBase.ListWebhooks(CancellationToken)
Lists all webhooks that are registered for a base, along with their statuses as an asynchronous operation. The base Id was provided when AirtableBase was constructed.
Namespace: AirtableApiClient
Assembly: AirtableApiClient.dll
public async Task<AirtableListWebhooksResponse> ListWebhooks(Cancellation token = default(CancellationToken))
## Parameters
### token
Type: CancellationToken
An optional field for providing a means to cancel the operation.The task object representing the asynchronous operation.
This operation will not block. The returned task object will complete once the entire response including content is read.
using System;
using System.Linq;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Text.Json.Serialization;
using AirtableApiClient;
readonly string baseId = YOUR_BASE_ID;
readonly string appKey = YOUR_APP_KEY_OR_ACCESS_TOKEN;using (AirtableBase airtableBase = new AirtableBase(appKeyOrAccessToken, baseId))
{
Task<AirtableListWebhooksResponse> task = airtableBase.ListWebhooks();
var response = await task;
if (!response.Success)
{
string errorMessage = null;
if (response.AirtableApiError is AirtableApiException)
{
errorMessage = response.AirtableApiError.ErrorMessage;
if (response.AirtableApiError is AirtableInvalidRequestException)
{
errorMessage += "\nDetailed error message: ";
errorMessage += response.AirtableApiError.DetailedErrorMessage;
}
else
{
errorMessage = "Unknown error";
}
}
// Report errorMessage
}
}
AirtableBase.ListPayloads(CancellationToken)
Enumerate the update messages for a client to consume. Clients should call this after they receive a ping.
Namespace: AirtableApiClient
Assembly: AirtableApiClient.dll
public async Task<AirtableListPayloadsResponse> ListPayloads(
string webhookId,
int? cursor = null,
int? limit = null,
Cancellation token = default(CancellationToken))
)Type: string
Webhook ID
Type: int?
Transaction number of the payload to start listing from.
Type: int?
If given the limit parameter specifies the maximum number of payloads to return in the response.
A maximum of 50 payloads can be returned in a single request. A single payload can contain multiple updates.
Type: CancellationToken
An optional field for providing a means to cancel the operation.
The task object representing the asynchronous operation.
This operation will not block. The returned task object will complete once the entire response including content is read.
using System;
using System.Linq;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Text.Json.Serialization;
using AirtableApiClient;
readonly string baseId = YOUR_BASE_ID;
readonly string appKey = YOUR_APP_KEY_OR_ACCESS_TOKEN;using (AirtableBase airtableBase = new AirtableBase(appKeyOrAccessToken, baseId))
{
/* Do something such as adding a record to a table and the Specification
* of a previously created Webhook (assuming its ID is WEBHOOK_ID) is for
* filtering "tableData".
*/
Task<AirtableListPayloadsResponse> task = airtableBase.ListPayloads(WEBHOOK_ID);
var response = await task;
if (!response.Success)
{
string errorMessage = null;
if (response.AirtableApiError is AirtableApiException)
{
errorMessage = response.AirtableApiError.ErrorMessage;
if (response.AirtableApiError is AirtableInvalidRequestException)
{
errorMessage += "\nDetailed error message: ";
errorMessage += response.AirtableApiError.DetailedErrorMessage;
}
else
{
errorMessage = "Unknown error";
}
}
// Report errorMessage
}
var payloads = response.Payloads;
/* Do something with your WebhooksPayload[] payloads */
}
AirtableBase.EnableWebhookNotifications(CancellationToken)
Enables or disables notification pings for a webhook.
Namespace: AirtableApiClient
Assembly: AirtableApiClient.dll
public async Task<AirtabeEnableWebhookNotificationsResponse> EnableWebhookNotifications(
string webhookId,
bool enable,
Cancellation token = default(CancellationToken))Type: string
Webhook ID
Type: bool
true for enabling, false for disabling
Type: CancellationToken
An optional field for providing a means to cancel the operation.
The task object representing the asynchronous operation.
This operation will not block. The returned task object will complete once the entire response including content is read.
using System;
using System.Linq;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Text.Json.Serialization;
using AirtableApiClient;
readonly string baseId = YOUR_BASE_ID;
readonly string appKey = YOUR_APP_KEY_OR_ACCESS_TOKEN;using (AirtableBase airtableBase = new AirtableBase(appKeyOrAccessToken, baseId))
{
Task<AirtabeEnableWebhookNotificationsResponse> task = airtableBase.EnableWebhookNotifications(webhookId, true);
var response = await task;
if (!response.Success)
{
string errorMessage = null;
if (response.AirtableApiError is AirtableApiException)
{
errorMessage = response.AirtableApiError.ErrorMessage;
if (response.AirtableApiError is AirtableInvalidRequestException)
{
errorMessage += "\nDetailed error message: ";
errorMessage += response.AirtableApiError.DetailedErrorMessage;
}
else
{
errorMessage = "Unknown error";
}
}
// Report errorMessage
}
}
AirtableBase.RefreshWebhook(CancellationToken)
Extend the life of a webhook. The new expiration time will be 7 days after the refresh time. Note that this endpoint only applies to active webhooks with an expiration time. Creator level permissions are required in order to refresh a webhook.
Namespace: AirtableApiClient
Assembly: AirtableApiClient.dll
public async Task<AirtabeRefreshWebhookResponse> RefreshWebhook(
string webhookId,
Cancellation token = default(CancellationToken))Type: string
Webhook ID
Type: CancellationToken
An optional field for providing a means to cancel the operation.
The task object representing the asynchronous operation.
This operation will not block. The returned task object will complete once the entire response including content is read.
using System;
using System.Linq;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Text.Json.Serialization;
using AirtableApiClient;
readonly string baseId = YOUR_BASE_ID;
readonly string appKey = YOUR_APP_KEY_OR_ACCESS_TOKEN;using (AirtableBase airtableBase = new AirtableBase(appKeyOrAccessToken, baseId))
{
Task<AirtabeRefreshWebhookResponse> task = airtableBase.RefreshWebhook(webhookId);
var response = await task;
if (!response.Success)
{
string errorMessage = null;
if (response.AirtableApiError is AirtableApiException)
{
errorMessage = response.AirtableApiError.ErrorMessage;
if (response.AirtableApiError is AirtableInvalidRequestException)
{
errorMessage += "\nDetailed error message: ";
errorMessage += response.AirtableApiError.DetailedErrorMessage;
}
else
{
errorMessage = "Unknown error";
}
}
// Report errorMessage
}
// Code making use of response.ExpirationTime goes here
}
AirtableBase.DeleteWebhook(CancellationToken)
Deletes a webhook. Creator level permissions are required in order to delete a webhook.
Namespace: AirtableApiClient
Assembly: AirtableApiClient.dll
public async Task<AirtableDeleteWebhookResponse> DeleteWebhook(
string webhookId,
Cancellation token = default(CancellationToken))Type: string
Webhook ID
Type: CancellationToken
An optional field for providing a means to cancel the operation.
The task object representing the asynchronous operation.
This operation will not block. The returned task object will complete once the entire response including content is read.
using System;
using System.Linq;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Text.Json.Serialization;
using AirtableApiClient;
readonly string baseId = YOUR_BASE_ID;
readonly string appKey = YOUR_APP_KEY_OR_ACCESS_TOKEN;using (AirtableBase airtableBase = new AirtableBase(appKeyOrAccessToken, baseId))
{
Task<AirtableDeleteWebhookResponse> task = airtableBase.DeleteWebhook(webhookId);
var response = await task;
if (!response.Success)
{
string errorMessage = null;
if (response.AirtableApiError is AirtableApiException)
{
errorMessage = response.AirtableApiError.ErrorMessage;
if (response.AirtableApiError is AirtableInvalidRequestException)
{
errorMessage += "\nDetailed error message: ";
errorMessage += response.AirtableApiError.DetailedErrorMessage;
}
else
{
errorMessage = "Unknown error";
}
}
// Report errorMessage
}
}AirtableBase.Dispose(CancellationToken)
Releases the unmanaged resources and disposes of the managed resources used by the class.
Namespace: AirtableApiClient
Assembly: AirtableApiClient.dll
public void Dispose()IDisposable.Dispose()
- AirtableBase
- AirtableRecordList
-
AirtableRecordList
<T>
1. AirtableRecord<T> - AirtableUpSertRecordList
- AirtableUpSertRecordList
<T> - AirtableApiException
-
AirtableApiResponse
- AirtableGetUserIdAndScopesResponse
- AirtableListRecordsResponse
- AirtableListRecordsResponse
<T> - AirtableRetrieveRecordResponse
- AirtableRetrieveRecordResponse
<T> - AirtableCreateUpdateReplaceRecordResponse
- AirtableCreateReplaceRecordResponse
<T> - AirtableCreateReplaceMultipleRecordsResponse
<T> - AirtableCreateUpdateReplaceMultipleRecordsResponse
- AirtableDeleteRecordResponse
- AirtableCreateUpdateCommentResponse
- AirtableListCommentsResponse
- AirtableDeleteCommentResponse
- AirtableListWebhooksResponse
- AirtableListPayloadsResponse
- AirtableCreateWebhookResponse
- AirtableDeleteWebhookResponse
- AirtabeEnableWebhookNotificationsResponse
- AirtabeRefreshWebhookResponse
- AirtableListBasesResponse
- AirtableGetBaseSchemaResponse
- AirtableCreateBaseResponse
- CommentList
- IdFields
- PerformUpsert
- UserIdAndScopes
- Webhooks
- PayloadList
- WebhooksNotification
-
TableModelList
-
TableModel
- DateDependencySettings
- ViewModel
- FieldModel
-
FieldModel<TModelOptions>
- aitextfieldmodel-and-aitextmodeloptions
- AttachmentFieldModel-and-AttachmentModelOptions
- AutoNumberFieldModel
- BarcodeFieldModel
- ButtonFieldModel
- CheckboxFieldModel
- CollaboratorFieldModel
- CountFieldModel-and-CountModelOptions
- CreatedByFieldModel
- CreatedTimeFieldModel-and-CreatedTimeModelOptions
- CurrencyFieldModel
- DateFieldModel
- DateTimeFieldModel
- DurationFieldModel
- EmailFieldModel
- FormulaFieldModel--and-FormulaModelOptions
- LastModifiedByFieldModel
- LastModifiedTimeFieldModel-and-LastModifiedTimeModelOptions
- LinkToAnotherRecordFieldModel-and-LinkToAnotherRecordModelOptions
- LongTextFieldModel
- LookupFieldModel-and-LookupModelOptions
- MultipleCollaboratorFieldModel
- MultipleSelectFieldModel-and-MultipleSelectdModelOptions
- NumberFieldModel-and-NumberModelOptions
- PercentFieldModel-and-PercentModelOptions)
- PhoneFieldModel
- RatingFieldModel
- RichTextFieldModel
- RollupFieldModel-and-RollupModelOptions
- SingleLineTextFieldModel
- SingleSelectFieldModel-and-SingleSelectdModelOptions
- SyncSourceFieldModel-and-SyncSourceModelOptions
- UrlFieldModel
- UnknownFieldModel
- FieldModelExtensions
-
TableModel
-
TableConfig
-
IFieldConfig
- Field
-
FieldConfig
- AttachmentFieldConfig
- BarcodeFieldConfig
- CheckboxFieldConfig
- CollaboratorFieldConfig
- CurrencyFieldConfig
- DateFieldConfig
- DateTimeFieldConfig
- DurationFieldConfig
- EmailFieldConfig
- LinkToAnotherRecordFieldConfig-and-LinkToAnotherRecordConfigOptions
- LongTextFieldConfig
- MultipleCollaboratorFieldConfig
- MultipleSelectFieldConfig-and-MultipleSelectdConfigOptions
- NumberFieldConfig-and-NumberConfigOptions
- PercentFieldConfig-and-PercentConfigOptions
- PhoneFieldConfig
- RatingFieldConfig
- RichTextFieldConfig
- SingleLineTextFieldConfig
- SingleSelectFieldConfig-and-SingleSelectdConfigOptions
- UrlFieldConfig
-
IFieldConfig
[Airtable]: http://www.airtable.com