Il presente articolo è stato tradotto automaticamente.
C++
Utilizzo di C++ REST SDK nelle applicazioni Windows Store
Scaricare il codice di esempio
Nel mio articolo precedente (msdn.microsoft.com/magazine/dn342869) introdotto il SDK del resto C++ e come possono essere utilizzati in applicazioni Win32/MFC. In questo articolo, illustrerò come resto SDK C++ può essere integrato all'interno di applicazioni Windows Store. Uno dei miei obiettivi originali utilizzando il SDK del resto C++ e la classe di autenticazione OAuth era di utilizzare come C++ molto standard come possibili e solo di interfaccia con le API specifiche della piattaforma ove necessario. Ecco un veloce riepilogo del precedente articolo:
- Codice utilizzato nella classe di autenticazione OAuth utilizza tipi standard del C++ e nessun tipi specifici di Windows.
- Codice utilizzato per fare le richieste Web al servizio Dropbox resto utilizza i tipi da C++ resto SDK.
- Il codice specifico della piattaforma solo è la funzione per avviare Internet Explorer e completare l'applicazione autenticazione e approvazione sul portale console app Dropbox.
Mantenuto gli stessi obiettivi per la mia app Store Windows supportare l'autenticazione e caricare un file su Dropbox. Cercato di fornire la massima quantità di codice C++ portabile come possibile e interfaccia con Windows Runtime (WinRT) solo dove necessario. Il download di codice di esempio per entrambi gli articoli si possono trovare presso archive.msdn.microsoft.com/mag201308CPP.
Problemi con la soluzione di Win32
Uno dei grandi svantaggi dall'applicazione Win32 precedente era la necessità di avviare un'applicazione esterna per completare il processo di autorizzazione OAuth. Questo significava che dovevo avviare Internet Explorer (si potrebbe lanciare il vostro browser preferito pure), accedere a Dropbox utilizzando le mie credenziali e quindi completare il flusso di lavoro. Questo è mostrato figure 1 e 2.
.png)
Figura 1 accesso a Dropbox utilizzando le mie credenziali prima di autorizzare l'accesso alle applicazioni
.png)
Figura 2 autorizzazione di successo per la mia applicazione sul portale Dropbox
Come potete vedere, lanciare un'applicazione esterna e chiedendo agli utenti di completare il flusso di lavoro attraverso l'applicazione esterna prende fuoco lontano dalla mia app. Gli sviluppatori non hanno anche nessun meccanismo standard attraverso il quale il mio app possono essere notificati quando il flusso di lavoro è completo. Con il mio focus sulla programmazione asincrona e SDK C++ resto progettato per supportare la programmazione basata su attività asincrona, dover lanciare un programma esterno è chiaramente una rottura per me. Ho esplorato utilizzando named pipe, memory-mapped-file e così via, ma tutti questi approcci richiedono un'altra applicazione per essere scritti per ospitare un'istanza del controllo Web e quindi scrivere il valore di successo di nuovo tramite una named pipe, memoria condivisa o un memory-mapped-file. Ho finalmente risolto utilizzando il browser per fare il compito, come io non volevo scrivere un'altra applicazione che ha avvolto il controllo del browser.
Integrazione con Windows Runtime
Come ho iniziato a progettare la mia app per supportare Windows Runtime, considerato alcune opzioni. Io li elenco brevemente qui e poi discutere l'approccio prescelto più dettagliatamente:
- Utilizzare l'attivazione del protocollo e lasciare che il sistema di lancio il giusto processo per gestire il protocollo chiamando il Windows::System::Schermata avvio:: funzione LaunchUriAsync. Questo significa che per un URI basato su HTTPS, l'OS lancerà il browser predefinito. Questo è simile al lancio di Internet Explorer dal campione Win32, ma con un doppio smacco: Mia app Windows Store sarà spinto allo sfondo, il browser predefinito lancerà a schermo intero, e — nella peggiore delle ipotesi — mia app sarebbe ottenere sospeso per il momento il flusso di lavoro è completato dall'utente. Un grande no-no.
- Integrare il controllo WebView nel mio app. Utilizzando il controllo XAML WebView mi permette di incorporare la navigazione dell'intero flusso di lavoro nell'ambito della mia app. Teoricamente, io posso anche essere notificato se il processo è stato completato da ascoltando il Window. external. notifica eventi generati dal controllo WebView. La realtà, però, è che l'evento viene generato solo se la pagina Web viene generato l'evento di notifica. Tuttavia, nel mio caso, la pagina di Dropbox dove viene completato il processo di autorizzazione non spara l'evento. Bummer!
- Utilizzare il WebAuthenticationBroker nel mio app. Come continuato a scavare intorno al Runtime di Windows, ho la fortuna della classe WebAuthenticationBroker. Sembrava che potesse aiutarmi a completare il processo di autorizzazione, e con poche righe di codice sono stato in grado di ottenere la completa funzionalità di lavoro. Prima di scavare attraverso codice, mi spiego il WebAuthenticationBroker in dettaglio.
Il WebAuthenticationBroker
In un mondo connesso-app, chiedendo le credenziali dell'utente tramite un meccanismo affidabile e sicuro è importante per ottenere il consenso dell'utente e l'approvazione per un app. Nessuno vuole essere lo sviluppatore cui app perdite le credenziali dell'utente o è oggetto di un attacco furtivo per dirottare le informazioni utente. Il Runtime di Windows include una serie di API e tecnologie necessarie che consentono agli sviluppatori di cercare le credenziali dell'utente in modo sicuro e affidabile. Il WebAuthenticationBroker è uno degli strumenti che consentono per le applicazioni Windows Store di utilizzare protocolli di autenticazione e autorizzazione basata su Internet come OAuth e OpenID. Quindi, come questo lavoro nella mia Dropbox campione app? Ecco come:
- Faccio la richiesta asincrona iniziale di Dropbox, che restituisce un token e token segreto per la mia applicazione. Questa richiesta iniziale viene effettuata tramite la funzione oAuthLoginAsync.
- Una volta che la funzione oAuthLoginAsync restituisce, in continuazione della sequenza, costruisco l'URI dove dovrebbe iniziare il processo di autorizzazione. Nel mio esempio, ho definito l'URI iniziale come una stringa costante:
const std::wstring DropBoxAuthorizeURI =
L"https://www.dropbox.com/1/oauth/authorize?oauth_token=";
- Quindi possibile compilare la richiesta HTTP URI aggiungendo il token restituito da Dropbox.
- Come un ulteriore passaggio, costruisco il parametro callback URI chiamando il WebAuthenticationBroker::GetCurrentApplicationCallbackUri funzione. Si noti che non ho usato il parametro callback URI nella mia applicazione desktop perché il parametro callback è opzionale, e stavo affidarsi a Internet Explorer per fare il compito di autorizzazione.
- Ora mia stringa richiesta è pronta e posso inserire la mia richiesta. Anziché utilizzare C++ resto SDK http_client classe o interfaccia IHttpWebRequest2 per effettuare chiamate di servizio Web, richiamata la funzione WebAuthenticationBroker::AuthenticateAsync.
- La funzione WebAuthenticationBroker::AuthenticateAsync accetta due parametri: un'enumerazione WebAuthenticationOptions e un URI. Un'istanza di overload della funzione stessa accetta l'enumerazione WebAuthenticationOptions e due URI, uno per l'URI dove inizia il processo di autenticazione di inizio e fine URI dove l'autenticazione processo finisce.
- Io uso la prima versione della funzione AuthenticateAsync e passa un None valore per l'enumerazione WebAuthenticationOptions. Per l'URI, passare l'URI ho realizzato per mia richiesta Web.
- Il WebAuthenticationBroker si trova tra la mia app e il sistema. Nel punto dove io chiamo AuthenticateAsync, crea un dialogo modale di sistema che è un modale al mio app.
- Il broker si attacca una finestra host Web per la finestra di dialogo modale che ha creato.
- Il broker seleziona quindi un processo di contenitore app dedicato separato dal contenitore di app in cui è in esecuzione il mio app. Elimina anche eventuali dati persistenti dal mio app.
- Il broker quindi avvia il processo di autenticazione in questo contenitore di app appena selezionato e si sposta all'URI come specificato nella funzione AuthenticateAsync.
- Come gli utenti interagiscono con le pagine Web, il broker mantiene controllando ogni URL per il callback URI che è stato specificato.
- Una volta che viene trovata una corrispondenza, il Web host termina la navigazione e invia un segnale al broker. Il broker prende giù la finestra di dialogo, cancella i cookie persistenti creati dall'host Web dal contenitore app e restituisce i dati di protocollo al app.
Figura 3 illustra il WebAuthenticationBroker finestra di dialogo modale nella mia app di Dropbox dopo l'host Web si è spostato all'URI iniziale. Come Dropbox prevede agli utenti di essere firmato prima che può essere visualizzata la pagina di autorizzazione, l'host Web reindirizza navigazione la Dropbox nella pagina di accesso.
.png)
Figura 3 la pagina di accesso di Dropbox, come visualizzato nella finestra di dialogo modale
Una volta che un utente ha eseguito l'accesso a Dropbox, il Web host si sposta poi all'effettiva autorizzazione URI. Questo è mostrato Figura 4. È chiaro da entrambi Figura 3 e Figura 4 che il dialogo è sovrapposto sulla cima della mia app UI. L'interfaccia utente rimane anche coerenza indipendentemente dalla fonte app chiamando il WebAuthenticationBroker::AuthenticateAsync metodo. Perché l'intera esperienza rimane coerenza, gli utenti possono fornire informazioni sulle credenziali senza preoccuparsi di applicazioni di gestione delle informazioni sulle credenziali e tali informazioni che perde accidentalmente.
.png)
Figura 4 consenso dell'utente viene chiesto di autorizzazione applicazione da Dropbox
Una cosa importante che non ho menzionato è la necessità di chiamare la funzione WebAuthenticationBroker::AuthenticateAsync dal thread UI. Tutte le richieste Web SDK C++ resto sono fatte su un thread in background, e io non riesco a visualizzare l'interfaccia utente da un thread in background. Invece, io uso il dispatcher del sistema e chiamare la funzione membro, RunAsync, per visualizzare l'interfaccia utente modale, come mostrato Figura 5.
Figura 5 utilizzando il sistema Dispatcher per visualizzare l'interfaccia utente modale
auto action = m_dispatcher->RunAsync(
Windows::UI::Core::CoreDispatcherPriority::Normal,
ref new Windows::UI::Core::DispatchedHandler([this]()
{
auto beginUri = ref new Uri(ref new String(m_authurl.c_str()));
task<WebAuthenticationResult^> authTask(WebAuthenticationBroker::
AuthenticateAsync(WebAuthenticationOptions::None, beginUri));
authTask.then([this](WebAuthenticationResult^ result)
{
String^ statusString;
switch(result->ResponseStatus)
{
case WebAuthenticationStatus::Success:
{
auto actionEnable = m_dispatcher->RunAsync(
Windows::UI::Core::CoreDispatcherPriority::Normal,
ref new Windows::UI::Core::DispatchedHandler([this]()
{
UploadFileBtn->IsEnabled = true;
}));
}
}
});
}));
Una volta completato il processo di autorizzazione, eseguire il dispatcher nuovamente per attivare il pulsante "Carica File" sul mio principale dell'interfaccia utente. Questo pulsante rimane in uno stato disattivato fino a quando i miei utenti hanno autenticato e autorizzato la mia app per accedere a Dropbox.
Concatenamento Web asincrona richieste
Ora è facile mettere tutto insieme. In tutte le funzioni che non interfacciano con Windows Runtime, io ho riutilizzato il codice stesso dalla mia applicazione desktop. Non ci sono cambiamenti di codice principale tranne questo: la decisione di utilizzare l'oggetto WinRT StorageFile contro un iostream C++ nella funzione UploadFileToDropboxAsync.
Durante la scrittura di applicazioni per Windows Store, ci sono alcune limitazioni che è necessario per vivere con. Uno dei limiti è la necessità di utilizzare oggetti WinRT StorageFile anziché flussi di C++ per leggere e scrivere dati da file. Quando lo sviluppo di un'applicazione Windows Store e utilizzando il SDK C++ resto, tutte le operazioni relative ai file aspettare lo sviluppatore per passare un oggetto StorageFile, piuttosto che un oggetto di flusso di C++. Un cambio di minori, sono in grado di riutilizzare tutto il mio codice C++ standard sostenendo il codice di autorizzazione OAuth e Dropbox nel mio app di Windows Store.
Ecco il mio flusso di pseudo-codice (Tratterò le singole funzioni dopo il pseudo-codice):
On clicking the SignIn Button
Call oAuthLoginAsync function
Then call WebAuthenticationBroker::AuthenticateAsync
Then enable the "Upload File" button on my UI
On clicking the "Upload File" button
Call the Windows::Storage::Pickers::FileOpenPicker::
PickSingleFileAsync function
Then call oAuthAcquireTokenAsync function
Then call UploadFileToDropboxAsync function
Nel gestore eventi SignInBtnClicked pulsante mostrato nella Figura 6, io prima eseguire la convalida del parametro semplice per assicurarsi che i valori stringa non vuota sono passati per i parametri ConsumerKey e ConsumerSecret che passato a Dropbox per l'autenticazione. Successivamente per ottenere un'istanza dell'oggetto Dispatcher associato al thread corrente di CoreWindow e memorizzarlo in una variabile membro della classe MainPage. Un Dispatcher è responsabile dell'elaborazione dei messaggi della finestra e spedire gli eventi all'app. Accanto a creare un'istanza della classe OnlineIdAuthenticator. La classe OnlineIdAuthenticator contiene funzioni di supporto che mi permettono di pop-up una dialogo modale app e completare il flusso di lavoro sicuro autorizzazione. Questo elimina la necessità di lanciare un'istanza del browser e passare il fuoco app al browser.
Figura 6 la funzione di SignInBtnClicked
void MainPage::SignInBtnClicked(Platform::Object^ sender,
RoutedEventArgs^ e)
{
if ((ConsumerKey->Text == nullptr) ||
(ConsumerSecret->Text == nullptr))
{
using namespace Windows::UI::Popups;
auto msgDlg = ref new MessageDialog(
"Please check the input for the Consumer Key and/or Consumer Secret tokens");
msgDlg->ShowAsync();
}
m_dispatcher =
Windows::UI::Core::CoreWindow::GetForCurrentThread()->Dispatcher;
m_creds = std::make_shared<AppCredentials>();
m_authenticator = ref new OnlineIdAuthenticator();
consumerKey = ConsumerKey->Text->Data();
consumerSecret = ConsumerSecret->Text->Data();
ConsumerKey->Text = nullptr;
ConsumerSecret->Text = nullptr;
OAuthLoginAsync(m_creds).then([this]
{
m_authurl = DropBoxAuthorizeURI;
m_authurl +=
utility::conversions::to_string_t(this->m_creds->Token());
m_authurl += L"&oauth_callback=";
m_authurl += WebAuthenticationBroker::
GetCurrentApplicationCallbackUri()->AbsoluteUri->Data();
auto action = m_dispatcher->RunAsync(
Windows::UI::Core::CoreDispatcherPriority::Normal,
ref new Windows::UI::Core::DispatchedHandler([this]()
{
auto beginUri = ref new Uri(ref new String(m_authurl.c_str()));
task<WebAuthenticationResult^>authTask(
WebAuthenticationBroker::AuthenticateAsync(
WebAuthenticationOptions::None, beginUri));
authTask.then([this](WebAuthenticationResult^ result)
{
String^ statusString;
switch(result->ResponseStatus)
{
case WebAuthenticationStatus::Success:
{
auto actionEnable = m_dispatcher->RunAsync(
Windows::UI::Core::CoreDispatcherPriority::Normal,
ref new Windows::UI::Core::DispatchedHandler([this]()
{
UploadFileBtn->IsEnabled = true;
}));
}
}
});
}));
}
Quindi chiamare la funzione OAuthLoginAsync, che esegue l'operazione di login a Dropbox. Una volta che restituisce la funzione di async, io uso la funzione RunAsync dell'oggetto Dispatcher per effettuare il marshalling della chiamata al thread dell'interfaccia utente dal thread in background di mio compito async. La funzione RunAsync accetta due parametri: un valore di priorità e un'istanza di DispatchedHandler. Impostato il valore di priorità normale e passare una funzione lambda all'istanza DispatchedHandler. All'interno del corpo di lambda, richiamata la funzione statica AuthenticateAsync della classe WebAuthenticationBroker, che poi viene visualizzata la finestra di dialogo modale di app e aiuta a completare l'autorizzazione di sicuro.
Una volta completato il flusso di lavoro, la finestra di dialogo è preso giù e la funzione restituisce il completamento o eventuali condizioni di errore riscontrate. Nel mio caso, solo gestire il tipo restituito di WebAuthenticationStatus::Success e ancora una volta utilizzare l'oggetto dispatcher per abilitare il UploadFile Button sul app UI. Perché sono tutte le funzioni che sto chiamando async in natura, ho bisogno di utilizzare l'oggetto dispatcher per il marshalling di chiamate per il thread UI se voglio accedere a qualsiasi elemento dell'interfaccia utente.
Figura 7 illustrato il gestore eventi UploadFileBtnClicked. Non c'è molto codice nello stesso gestore. Fare una chiamata alla funzione FileOpenPicker::PickSingleFileAsync che permette la selezione di un file di testo unico attraverso l'interfaccia di selezione. Quindi chiamare la funzione OAuthAcquireTokenAsync come mostrato Figura 8 e, al completamento, effettuare una chiamata alla funzione UploadFileToDropBoxAsync mostrata Figura 9.
Figura 7 la funzione di UploadFileBtnClicked
void MainPage::UploadFileBtnClicked( Platform::Object^ sender,
RoutedEventArgs^ e)
{
using namespace Windows::Storage::Pickers;
using namespace Windows::Storage;
auto picker = ref new FileOpenPicker();
picker->SuggestedStartLocation = PickerLocationId::DocumentsLibrary;
picker->FileTypeFilter->Append(".txt");
task<StorageFile^> (picker->PickSingleFileAsync())
.then([this](StorageFile^ selectedFile)
{
m_fileToUpload = selectedFile;
OAuthAcquireTokenAsync(m_creds).then([this](){
UploadFileToDropBoxAsync(m_creds);
});
});
}
Figura 8 la funzione OAuthAcquireTokenAsync
task<void> MainPage::OAuthAcquireTokenAsync(
std::shared_ptr<AppCredentials>& creds)
{
uri url(DropBoxAccessTokenURI);
std::shared_ptr<OAuth> oAuthObj = std::make_shared<OAuth>();
auto signatureParams =
oAuthObj->CreateOAuthSignedParameters(url.to_string(),
L"GET",
NULL,
consumerKey,
consumerSecret,
creds->Token(),
creds->TokenSecret()
);
std::wstring sb = oAuthObj->OAuthBuildSignedHeaders(url);
http_client client(sb);
// Make the request and asynchronously process the response.
return client.request(methods::GET)
.then([&creds](http_response response)
{
if(response.status_code() != status_codes::OK)
{
auto stream = response.body();
container_buffer<std::string> inStringBuffer;
return stream.read_to_end(inStringBuffer)
.then([inStringBuffer](pplx::task<size_t> previousTask)
{
UNREFERENCED_PARAMETER(previousTask);
const std::string &text = inStringBuffer.collection();
// Convert the response text to a wide-character string.
std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>,
wchar_t> utf16conv;
std::wostringstream ss;
ss << utf16conv.from_bytes(text.c_str()) << std::endl;
OutputDebugString(ss.str().data());
// Handle error cases.
return pplx::task_from_result();
});
}
// Perform actions here reading from the response stream.
istream bodyStream = response.body();
container_buffer<std::string> inStringBuffer;
return bodyStream.read_to_end(inStringBuffer)
.then([inStringBuffer, &creds](pplx::task<size_t> previousTask)
{
UNREFERENCED_PARAMETER(previousTask);
const std::string &text = inStringBuffer.collection();
// Convert the response text to a wide-character string.
std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>,
wchar_t> utf16conv;
std::wostringstream ss;
std::vector<std::wstring> parts;
ss << utf16conv.from_bytes(text.c_str()) << std::endl;
Split(ss.str(), parts, '&', false);
unsigned pos = parts[1].find('=');
std::wstring token = parts[1].substr(pos + 1, 16);
pos = parts[0].find('=');
std::wstring tokenSecret = parts[0].substr(pos + 1);
creds->SetToken(token);
creds->SetTokenSecret(tokenSecret);
});
});
}
Figura 9 la funzione di UploadFileToDropBoxAsync
task<void> MainPage::UploadFileToDropBoxAsync(
std::shared_ptr<AppCredentials>& creds)
{
using concurrency::streams::file_stream;
using concurrency::streams::basic_istream;
uri url(DropBoxFileUploadURI);
std::shared_ptr<oAuth> oAuthObj = std::make_shared<oAuth>();
auto signatureParams =
oAuthObj->CreateOAuthSignedParameters(url.to_string(),
L"PUT",
NULL,
consumerKey,
consumerSecret,
creds->Token(),
creds->TokenSecret()
);
std::wstring sb = oAuthObj->OAuthBuildSignedHeaders(url);
return file_stream<unsigned char>::open_istream(this->m_fileToUpload)
.then([this, sb, url](pplx::task<basic_istream<unsigned char>> previousTask)
{
try
{
auto fileStream = previousTask.get();
// Get the content length, used to set the Content-Length property.
fileStream.seek(0, std::ios::end);
auto length = static_cast<size_t>(fileStream.tell());
fileStream.seek(0, 0);
// Make HTTP request with the file stream as the body.
http_request req;
http_client client(sb);
req.set_body(fileStream, length);
req.set_method(methods::PUT);
return client.request(req)
.then([this, fileStream](pplx::task<http_response> previousTask)
{
fileStream.close();
std::wostringstream ss;
try
{
auto response = previousTask.get();
auto body = response.body();
// Log response success code.
ss << L"Server returned status code "
<< response.status_code() << L"."
<< std::endl;
OutputDebugString(ss.str().data());
if (response.status_code() == web::http::status_codes::OK)
{
auto action = m_dispatcher->RunAsync(
Windows::UI::Core::CoreDispatcherPriority::Normal,
ref new Windows::UI::Core::DispatchedHandler([this]()
{
using namespace Windows::UI::Popups;
auto msgDlg = ref new MessageDialog(
"File uploaded successfully to Dropbox");
msgDlg->ShowAsync();
}));
}
}
catch (const http_exception& e)
{
ss << e.what() << std::endl;
OutputDebugString(ss.str().data());
}
});
}
catch (const std::system_error& e)
{
// Log any errors here.
// Return an empty task.
std::wostringstream ss;
ss << e.what() << std::endl;
OutputDebugString(ss.str().data());
return pplx::task_from_result();
}
});
}
La funzione OAuthAcquireTokenAsync esegue l'azione per acquisire l'effettivo token associato all'account Dropbox. Innanzitutto costruire la stringa di accesso richiesto e le intestazioni di richiesta HTTP e chiamare il servizio Dropbox per eseguire la convalida delle credenziali. Questa richiesta HTTP è di tipo GET e la risposta viene restituita come un flusso di caratteri. I analizzare il flusso e dividere il flusso di caratteri per ottenere il token di effettivi e valori segreti dei token. Questi vengono quindi archiviati nell'istanza della classe AppCredentials.
Una volta che ho ottenuto con successo il token di effettivi e valori dei token segreti da Dropbox, è il momento di mettere loro di utilizzare caricando un file a Dropbox. Come è la norma con qualsiasi accesso di endpoint Dropbox Web, prima costruisco il parametro stringa e le intestazioni HTTP. Invito quindi l'endpoint del servizio Dropbox associato con il caricamento dei file. Questa richiesta HTTP è di tipo mettere perché sto tentando di inserire il contenuto del servizio. Prima di inserire contenuti, devo anche far conoscere le dimensioni del contenuto a Dropbox. Questo è specificato impostando la proprietà content_length della HTTP_request::set_body metodo per le dimensioni del file di essere caricato. Una volta che il metodo PUT restituisce correttamente, utilizzare l'oggetto dispatcher per visualizzare all'utente un messaggio di successo.
Linux è prossimo
Integrando il resto SDK C++ nelle applicazioni Windows 8 (Windows Store e desktop) è semplice e lineare. Aggiungere i benefici della scrittura del codice che può essere condiviso tra entrambe le piattaforme, di utilizzare C++ moderna programmazione idiomi, e fatto il codice è portatile sia Windows e non Windows apps, e si ha un vincitore. Si può smettere di preoccuparsi di piattaforma specifiche complessità quanto siete legati alla rete API e invece usare il vostro tempo a pensare a caratteristiche che dovrebbe sostenere l'applicazione. In questo semplice esempio, ho usato il SDK del resto C++ per autenticare un utente con Dropbox e poi caricare un file nel cloud di Dropbox. Per ulteriori informazioni sull'API REST di Dropbox, è possibile fare riferimento alla documentazione a bit.ly/10OdTD0. In un prossimo articolo, vi mostrerò come realizzare questo compito stesso da un client Linux.
Sridhar Poduri è un program manager del team Windows in Microsoft. Un appassionato di C++ e autore del libro, "Modern C++ e Windows App Store" (Sridhar Poduri, 2013), ha Blog regolarmente su C++ e il Runtime di Windows a sridharpoduri.com.
Grazie ai seguenti esperti tecnici Microsoft per la revisione di questo articolo: Niklas Gustaffson, Mithani Sana e Sobajic di Oggy