Accesso a Google Spreadsheets con C # utilizzando Google Data API

Sto avendo alcune informazioni in Google Spreadsheets come un unico foglio. Esiste un modo per leggere queste informazioni da .NET fornendo le credenziali di Google e l'indirizzo del foglio di calcolo. È possibile utilizzare le API di dati di Google. In definitiva, ho bisogno di ottenere le informazioni dal foglio di calcolo di Google in una tabella dati. Come posso farlo? Se qualcuno lo ha provato, pls condivide alcune informazioni.

Secondo la guida utente .NET :

Scarica la libreria client .NET :

Aggiungi queste istruzioni using:

using Google.GData.Client;
using Google.GData.Extensions;
using Google.GData.Spreadsheets;

Autenticare:

SpreadsheetsService myService = new SpreadsheetsService("exampleCo-exampleApp-1");
myService.setUserCredentials("jo@gmail.com", "mypassword");

Ottieni un elenco di fogli di lavoro:

SpreadsheetQuery query = new SpreadsheetQuery();
SpreadsheetFeed feed = myService.Query(query);

Console.WriteLine("Your spreadsheets: ");
foreach (SpreadsheetEntry entry in feed.Entries)
{
    Console.WriteLine(entry.Title.Text);
}

Dato un SpreadsheetEntry che hai già recuperato, puoi ottenere un elenco di tutti i fogli di lavoro in questo foglio di lavoro come segue:

AtomLink link = entry.Links.FindService(GDataSpreadsheetsNameTable.WorksheetRel, null);

WorksheetQuery query = new WorksheetQuery(link.HRef.ToString());
WorksheetFeed feed = service.Query(query);

foreach (WorksheetEntry worksheet in feed.Entries)
{
    Console.WriteLine(worksheet.Title.Text);
}

E ottieni un feed basato su celle:

AtomLink cellFeedLink = worksheetentry.Links.FindService(GDataSpreadsheetsNameTable.CellRel, null);

CellQuery query = new CellQuery(cellFeedLink.HRef.ToString());
CellFeed feed = service.Query(query);

Console.WriteLine("Cells in this worksheet:");
foreach (CellEntry curCell in feed.Entries)
{
    Console.WriteLine("Row {0}, column {1}: {2}", curCell.Cell.Row,
        curCell.Cell.Column, curCell.Cell.Value);
}

Ho scritto un semplice wrapper attorno alla libreria client .Net di Google , che espone un'interfaccia simile a un database più semplice, con tipi di record fortemente tipizzati. Ecco un po 'di codice di esempio:

public class Entity {
    public int IntProp { get; set; }
    public string StringProp { get; set; }
}

var e1 = new Entity { IntProp = 2 };
var e2 = new Entity { StringProp = "hello" };
var client = new DatabaseClient("you@gmail.com", "password");
const string dbName = "IntegrationTests";
Console.WriteLine("Opening or creating database");
db = client.GetDatabase(dbName) ?? client.CreateDatabase(dbName); // databases are spreadsheets
const string tableName = "IntegrationTests";
Console.WriteLine("Opening or creating table");
table = db.GetTable<Entity>(tableName) ?? db.CreateTable<Entity>(tableName); // tables are worksheets
table.DeleteAll();
table.Add(e1);
table.Add(e2);
var r1 = table.Get(1);

C'è anche un provider LINQ che si traduce negli operatori di query strutturate di Google :

var q = from r in table.AsQueryable()
        where r.IntProp > -1000 && r.StringProp == "hello"
        orderby r.IntProp
        select r;

(Giugno-novembre 2016) La domanda e le sue risposte sono ormai obsolete poiché: 1) le API GData sono la generazione precedente di API di Google. Anche se non tutte le API GData sono stati deprecati, tutte le più recenti API di Google non non utilizzano il protocollo dei dati di Google ; e 2) c'è una nuova API di Fogli Google v4 (anche non GData).

Andando avanti da qui, devi ottenere la libreria client delle API di Google per .NET e utilizzare l'ultima API di Fogli , che è molto più potente e flessibile di qualsiasi API precedente. Ecco un esempio di codice C # per aiutarti a iniziare. Controlla anche i documenti di riferimento .NET per l'API di Fogli e la guida per gli sviluppatori della libreria client delle API di Google .NET .

Se non sei allergico a Python (se lo sei, fai finta che sia pseudocodice;)), ho realizzato diversi video con esempi leggermente più lunghi e più "reali" di utilizzo dell'API da cui puoi imparare e migrare a C # se lo desideri :

• Migrazione dei dati SQL per un foglio (codice di immersione profonda postale )
• Formattazione di testo utilizzando l'API Fogli (codice deep postale )
• Generazione di diapositive dai dati del foglio di calcolo ( post di immersione profonda del codice )
• Quelli e altri nella libreria video dell'API di Fogli

Puoi fare ciò che chiedi in diversi modi:

1. Utilizzando la libreria C # del foglio di calcolo di Google (come nella risposta di Tacoman667) per recuperare un ListFeed che può restituire un elenco di righe (ListEntry nel gergo di Google) ognuna delle quali ha un elenco di coppie nome-valore. La documentazione dell'API del foglio di lavoro di Google ( http://code.google.com/apis/spreadsheets/code.html ) contiene informazioni più che sufficienti per iniziare.

2. Utilizzando l'API di visualizzazione di Google che ti consente di inviare query più sofisticate (quasi come SQL) per recuperare solo le righe / colonne necessarie.

3. Il contenuto del foglio di calcolo viene restituito come feed Atom in modo da poter utilizzare l'analisi XPath o SAX per estrarre il contenuto di un feed elenco. C'è un esempio di farlo in questo modo (solo in Java e Javascript anche se temo) su http://gqlx.twyst.co.za .

Sono abbastanza sicuro che ci saranno alcuni SDK / toolkit C # su Google Code per questo. Ho trovato questo , ma potrebbero essercene altri, quindi vale la pena dare un'occhiata in giro.

http://code.google.com/apis/gdata/articles/dotnet_client_lib.html

Questo dovrebbe farti cominciare. Non ci ho giocato ultimamente ma ho scaricato una versione molto vecchia qualche tempo fa e sembrava piuttosto solida. Anche questo è aggiornato a Visual Studio 2008, quindi controlla i documenti!

Questa pagina del blog Twilio creata il 24 marzo 2017 da Marcos Placona potrebbe essere utile.

Fogli di lavoro Google e .NET Core

Fa riferimento a Google.Api.Sheets.v4 e OAuth2 .

La risposta più votata da @Kelly non è più valida come dice @wescpy. Tuttavia dopo 2020-03-03 non funzionerà affatto poiché la libreria utilizzata utilizza Google Sheets v3 API.

L'API di Fogli Google v3 verrà disattivata il 3 marzo 2020

https://developers.google.com/sheets/api/v3

Questo è stato annunciato il 10/09/2019 da Google:

https://cloud.google.com/blog/products/g-suite/migrate-your-apps-use-latest-sheets-api

Nuovo esempio di codice per Google Sheets v4 API:

Vai a

https://developers.google.com/sheets/api/quickstart/dotnet

e generare credentials.json. Quindi installa Google.Apis.Sheets.v4NuGet e prova il seguente esempio:

Nota che ho ricevuto l'errore Unable to parse range: Class Data!A2:Econ il codice di esempio ma con il mio foglio di calcolo. Il passaggio a ha Sheet1!A2:Efunzionato tuttavia poiché il mio foglio è stato chiamato così. Funzionava anche solo con A2:E.

using Google.Apis.Auth.OAuth2;
using Google.Apis.Sheets.v4;
using Google.Apis.Sheets.v4.Data;
using Google.Apis.Services;
using Google.Apis.Util.Store;
using System;
using System.Collections.Generic;
using System.IO;
using System.Threading;

namespace SheetsQuickstart
{
    class Program
    {
        // If modifying these scopes, delete your previously saved credentials
        // at ~/.credentials/sheets.googleapis.com-dotnet-quickstart.json
        static string[] Scopes = { SheetsService.Scope.SpreadsheetsReadonly };
        static string ApplicationName = "Google Sheets API .NET Quickstart";

        static void Main(string[] args)
        {
            UserCredential credential;

            using (var stream =
                new FileStream("credentials.json", FileMode.Open, FileAccess.Read))
            {
                // The file token.json stores the user's access and refresh tokens, and is created
                // automatically when the authorization flow completes for the first time.
                string credPath = "token.json";
                credential = GoogleWebAuthorizationBroker.AuthorizeAsync(
                    GoogleClientSecrets.Load(stream).Secrets,
                    Scopes,
                    "user",
                    CancellationToken.None,
                    new FileDataStore(credPath, true)).Result;
                Console.WriteLine("Credential file saved to: " + credPath);
            }

            // Create Google Sheets API service.
            var service = new SheetsService(new BaseClientService.Initializer()
            {
                HttpClientInitializer = credential,
                ApplicationName = ApplicationName,
            });

            // Define request parameters.
            String spreadsheetId = "1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OgvE2upms";
            String range = "Class Data!A2:E";
            SpreadsheetsResource.ValuesResource.GetRequest request =
                    service.Spreadsheets.Values.Get(spreadsheetId, range);

            // Prints the names and majors of students in a sample spreadsheet:
            // https://docs.google.com/spreadsheets/d/1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OgvE2upms/edit
            ValueRange response = request.Execute();
            IList<IList<Object>> values = response.Values;
            if (values != null && values.Count > 0)
            {
                Console.WriteLine("Name, Major");
                foreach (var row in values)
                {
                    // Print columns A and E, which correspond to indices 0 and 4.
                    Console.WriteLine("{0}, {1}", row[0], row[4]);
                }
            }
            else
            {
                Console.WriteLine("No data found.");
            }
            Console.Read();
        }
    }
}