The code samples below provide examples of common reporting functions using the AdWords API. Client Library.
Download a criteria performance report with AWQL
// Copyright 2018 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
using Google.Api.Ads.AdWords.Lib;
using Google.Api.Ads.AdWords.Util.Reports;
using Google.Api.Ads.AdWords.Util.Reports.v201809;
using Google.Api.Ads.AdWords.v201809;
using Google.Api.Ads.Common.Util.Reports;
using System;
using System.IO;
namespace Google.Api.Ads.AdWords.Examples.CSharp.v201809
{
/// <summary>
/// This code example gets and downloads a criteria Ad Hoc report from an AWQL
/// query. See https://developers.google.com/adwords/api/docs/guides/awql for
/// AWQL documentation.
/// </summary>
public class DownloadCriteriaReportWithAwql : ExampleBase
{
/// <summary>
/// Main method, to run this code example as a standalone application.
/// </summary>
/// <param name="args">The command line arguments.</param>
public static void Main(string[] args)
{
DownloadCriteriaReportWithAwql codeExample = new DownloadCriteriaReportWithAwql();
Console.WriteLine(codeExample.Description);
try
{
string fileName = "INSERT_FILE_NAME_HERE";
codeExample.Run(new AdWordsUser(), fileName);
}
catch (Exception e)
{
Console.WriteLine("An exception occurred while running this code example. {0}",
ExampleUtilities.FormatException(e));
}
}
/// <summary>
/// Returns a description about the code example.
/// </summary>
public override string Description
{
get
{
return "This code example gets and downloads a criteria Ad Hoc report from an " +
"AWQL query. See " +
"https://developers.google.com/adwords/api/docs/guides/awql for AWQL " +
"documentation.";
}
}
/// <summary>
/// Runs the code example.
/// </summary>
/// <param name="user">The AdWords user.</param>
/// <param name="fileName">The file to which the report is downloaded.
/// </param>
public void Run(AdWordsUser user, string fileName)
{
ReportQuery query = new ReportQueryBuilder()
.Select("CampaignId", "AdGroupId", "Id", "Criteria", "CriteriaType",
"Impressions", "Clicks", "Cost")
.From(ReportDefinitionReportType.CRITERIA_PERFORMANCE_REPORT)
.Where("Status").In("ENABLED", "PAUSED")
.During(ReportDefinitionDateRangeType.LAST_7_DAYS)
.Build();
string filePath =
ExampleUtilities.GetHomeDir() + Path.DirectorySeparatorChar + fileName;
try
{
ReportUtilities utilities = new ReportUtilities(user, "v201809", query,
DownloadFormat.GZIPPED_CSV.ToString());
using (ReportResponse response = utilities.GetResponse())
{
response.Save(filePath);
}
Console.WriteLine("Report was downloaded to '{0}'.", filePath);
}
catch (Exception e)
{
throw new System.ApplicationException("Failed to download report.", e);
}
}
}
}
Download a criteria performance report using selectors
// Copyright 2018 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
using Google.Api.Ads.AdWords.Lib;
using Google.Api.Ads.AdWords.Util.Reports;
using Google.Api.Ads.AdWords.v201809;
using Google.Api.Ads.Common.Util.Reports;
using System;
using System.IO;
namespace Google.Api.Ads.AdWords.Examples.CSharp.v201809
{
/// <summary>
/// This code example gets and downloads a criteria Ad Hoc report from an XML
/// report definition.
/// </summary>
public class DownloadCriteriaReportWithSelector : ExampleBase
{
/// <summary>
/// Main method, to run this code example as a standalone application.
/// </summary>
/// <param name="args">The command line arguments.</param>
public static void Main(string[] args)
{
DownloadCriteriaReportWithSelector codeExample =
new DownloadCriteriaReportWithSelector();
Console.WriteLine(codeExample.Description);
try
{
string fileName = "INSERT_FILE_NAME_HERE";
codeExample.Run(new AdWordsUser(), fileName);
}
catch (Exception e)
{
Console.WriteLine("An exception occurred while running this code example. {0}",
ExampleUtilities.FormatException(e));
}
}
/// <summary>
/// Returns a description about the code example.
/// </summary>
public override string Description
{
get
{
return "This code example gets and downloads a criteria Ad Hoc report from an " +
"XML report definition.";
}
}
/// <summary>
/// Runs the code example.
/// </summary>
/// <param name="user">The AdWords user.</param>
/// <param name="fileName">The file to which the report is downloaded.
/// </param>
public void Run(AdWordsUser user, string fileName)
{
ReportDefinition definition = new ReportDefinition()
{
reportName = "Last 7 days CRITERIA_PERFORMANCE_REPORT",
reportType = ReportDefinitionReportType.CRITERIA_PERFORMANCE_REPORT,
downloadFormat = DownloadFormat.GZIPPED_CSV,
dateRangeType = ReportDefinitionDateRangeType.LAST_7_DAYS,
selector = new Selector()
{
fields = new string[]
{
"CampaignId",
"AdGroupId",
"Id",
"CriteriaType",
"Criteria",
"FinalUrls",
"Clicks",
"Impressions",
"Cost"
},
predicates = new Predicate[]
{
Predicate.In("Status", new string[]
{
"ENABLED",
"PAUSED"
})
}
},
};
// Optional: Include zero impression rows.
(user.Config as AdWordsAppConfig).IncludeZeroImpressions = true;
// Optional: You can also skip the report headers, column headers and
// report summary etc. to make the report parsing simpler.
// (user.Config as AdWordsAppConfig).SkipColumnHeader = true;
// (user.Config as AdWordsAppConfig).SkipReportHeader = true;
// (user.Config as AdWordsAppConfig).SkipReportSummary = true;
string filePath =
ExampleUtilities.GetHomeDir() + Path.DirectorySeparatorChar + fileName;
try
{
ReportUtilities utilities = new ReportUtilities(user, "v201809", definition);
using (ReportResponse response = utilities.GetResponse())
{
response.Save(filePath);
}
Console.WriteLine("Report was downloaded to '{0}'.", filePath);
}
catch (Exception e)
{
throw new System.ApplicationException("Failed to download report.", e);
}
}
}
}
Get the report fields from a report
// Copyright 2018 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
using Google.Api.Ads.AdWords.Lib;
using Google.Api.Ads.AdWords.v201809;
using System;
namespace Google.Api.Ads.AdWords.Examples.CSharp.v201809
{
/// <summary>
/// This code example gets report fields.
/// </summary>
public class GetReportFields : ExampleBase
{
/// <summary>
/// Main method, to run this code example as a standalone application.
/// </summary>
/// <param name="args">The command line arguments.</param>
public static void Main(string[] args)
{
GetReportFields codeExample = new GetReportFields();
Console.WriteLine(codeExample.Description);
try
{
ReportDefinitionReportType reportType =
(ReportDefinitionReportType) Enum.Parse(typeof(ReportDefinitionReportType),
"INSERT_REPORT_TYPE_HERE");
codeExample.Run(new AdWordsUser(), reportType);
}
catch (Exception e)
{
Console.WriteLine("An exception occurred while running this code example. {0}",
ExampleUtilities.FormatException(e));
}
}
/// <summary>
/// Returns a description about the code example.
/// </summary>
public override string Description
{
get { return "This code example gets report fields."; }
}
/// <summary>
/// Runs the code example.
/// </summary>
/// <param name="user">The AdWords user.</param>
/// <param name="reportType">The report type to be run.</param>
public void Run(AdWordsUser user, ReportDefinitionReportType reportType)
{
using (ReportDefinitionService reportDefinitionService =
(ReportDefinitionService) user.GetService(AdWordsService.v201809
.ReportDefinitionService))
{
try
{
// Get the report fields.
ReportDefinitionField[] reportDefinitionFields =
reportDefinitionService.getReportFields(reportType);
if (reportDefinitionFields != null && reportDefinitionFields.Length > 0)
{
// Display report fields.
Console.WriteLine("The report type '{0}' contains the following fields:",
reportType);
foreach (ReportDefinitionField reportDefinitionField in
reportDefinitionFields)
{
Console.Write("- {0} ({1})", reportDefinitionField.fieldName,
reportDefinitionField.fieldType);
if (reportDefinitionField.enumValues != null)
{
Console.Write(" := [{0}]",
string.Join(", ", reportDefinitionField.enumValues));
}
Console.WriteLine();
}
}
else
{
Console.WriteLine("This report type has no fields.");
}
}
catch (Exception e)
{
throw new System.ApplicationException(
"Failed to retrieve fields for report type.", e);
}
}
}
}
}
Download a report for multiple accounts
// Copyright 2018 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
using Google.Api.Ads.AdWords.Lib;
using Google.Api.Ads.AdWords.Util.Reports;
using Google.Api.Ads.AdWords.Util.Reports.v201809;
using Google.Api.Ads.AdWords.v201809;
using Google.Api.Ads.Common.Util.Reports;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.IO;
using System.Threading;
namespace Google.Api.Ads.AdWords.Examples.CSharp.v201809
{
/// <summary>
/// This code example runs a report for every advertiser account under a
/// given manager account, using multiple parallel threads. This code example
/// needs to be run against an AdWords manager account.
/// </summary>
public class ParallelReportDownload : ExampleBase
{
/// <summary>
/// The maximum number of reports to download in parallel. This number should
/// be less than or equal to <see cref="MAX_NUMBER_OF_THREADS"/>.
/// </summary>
private const int MAX_REPORT_DOWNLOADS_IN_PARALLEL = 3;
/// <summary>
/// The maximum number of threads to initialize for report downloads.
/// Normally, you would set this to <see cref="MAX_REPORT_DOWNLOADS_IN_PARALLEL"/>.
/// However, a more dynamic strategy involves changing
/// MAX_REPORT_DOWNLOADS_IN_PARALLEL at runtime depending on the AdWords
/// API server loads.
/// </summary>
private const int MAX_NUMBER_OF_THREADS = 10;
/// <summary>
/// Represents a report that was successfully downloaded.
/// </summary>
public class SuccessfulReportDownload
{
/// <summary>
/// Gets or sets the customer ID for the report.
/// </summary>
public long CustomerId { get; set; }
/// <summary>
/// Gets or sets the path to which report was downloaded.
/// </summary>
public string Path { get; set; }
}
/// <summary>
/// Represents a report download that failed.
/// </summary>
public class FailedReportDownload
{
/// <summary>
/// Gets or sets the customer ID for the report.
/// </summary>
public long CustomerId { get; set; }
/// <summary>
/// Gets or sets the exception that was thrown..
/// </summary>
public AdWordsReportsException Exception { get; set; }
}
/// <summary>
/// A data structure to hold data specific for a particular report download
/// thread.
/// </summary>
public class ReportDownloadData
{
/// <summary>
/// Gets or sets the application configuration.
/// </summary>
public AdWordsAppConfig Config { get; set; }
/// <summary>
/// Gets or sets the index of the thread that identifies it.
/// </summary>
public int ThreadIndex { get; set; }
/// <summary>
/// Gets or sets the folder to which reports are downloaded.
/// </summary>
public string DownloadFolder { get; set; }
/// <summary>
/// Gets or sets the event that signals the main thread that this thread
/// is finished with its job.
/// </summary>
public ManualResetEvent SignalEvent { get; set; }
/// <summary>
/// Gets or sets the queue that holds the list of all customerIDs to be
/// processed.
/// </summary>
public IProducerConsumerCollection<long> CustomerIdQueue { get; set; }
/// <summary>
/// Gets or sets the queue that holds the list of successful report
/// downloads.
/// </summary>
public IProducerConsumerCollection<SuccessfulReportDownload> SuccessfulReports
{
get;
set;
}
/// <summary>
/// Gets or sets the queue that holds the list of failed report downloads.
/// </summary>
public IProducerConsumerCollection<FailedReportDownload> FailedReports { get; set; }
/// <summary>
/// Gets or sets the lock that ensures only a fixed number of report
/// downloads happen simultaneously.
/// </summary>
public Semaphore QuotaLock { get; set; }
/// <summary>
/// The callback method for the report download thread.
/// </summary>
public void ThreadCallback(object arg)
{
string query = (string) arg;
AdWordsUser user = new AdWordsUser(this.Config);
while (true)
{
// Wait to acquire a lock on the quota lock.
QuotaLock.WaitOne();
// Try to get a customer ID from the queue.
long customerId = 0;
bool hasMoreCustomers = CustomerIdQueue.TryTake(out customerId);
if (!hasMoreCustomers)
{
// Nothing more to do, break the loop.
QuotaLock.Release();
break;
}
try
{
ProcessCustomer(user, customerId, query);
}
finally
{
// Release the quota lock once we have downloaded the report for the
// customer ID.
QuotaLock.Release();
}
}
// Mark the download as finished.
this.SignalEvent.Set();
}
/// <summary>
/// Processes the customer.
/// </summary>
/// <param name="user">The AdWords user.</param>
/// <param name="customerId">The customer ID.</param>
/// <param name="query">The report query.</param>
private void ProcessCustomer(AdWordsUser user, long customerId, string query)
{
// Set the customer ID to the current customer.
this.Config.ClientCustomerId = customerId.ToString();
string downloadFile = string.Format("{0}{1}adgroup_{2:D10}.gz", this.DownloadFolder,
Path.DirectorySeparatorChar, customerId);
// Download the report.
Console.WriteLine("[Thread #{0}]: Downloading report for customer: {1} into {2}...",
this.ThreadIndex, customerId, downloadFile);
try
{
ReportUtilities utilities = new ReportUtilities(user, "v201809", query,
DownloadFormat.GZIPPED_CSV.ToString());
using (ReportResponse response = utilities.GetResponse())
{
response.Save(downloadFile);
}
// Mark this report download as success.
SuccessfulReportDownload success = new SuccessfulReportDownload
{
CustomerId = customerId,
Path = downloadFile
};
SuccessfulReports.TryAdd(success);
Console.WriteLine("Report was downloaded to '{0}'.", downloadFile);
}
catch (AdWordsReportsException e)
{
// Mark this report download as failure.
FailedReportDownload failure = new FailedReportDownload
{
CustomerId = customerId,
Exception = e
};
FailedReports.TryAdd(failure);
Console.WriteLine(
"Failed to download report for customer: {0}. Exception says {1}",
customerId, e.Message);
}
}
}
/// <summary>
/// Main method, to run this code example as a standalone application.
/// </summary>
/// <param name="args">The command line arguments.</param>
public static void Main(string[] args)
{
ParallelReportDownload codeExample = new ParallelReportDownload();
Console.WriteLine(codeExample.Description);
try
{
string fileName = "INSERT_FOLDER_NAME_HERE";
codeExample.Run(new AdWordsUser(), fileName);
}
catch (Exception e)
{
Console.WriteLine("An exception occurred while running this code example. {0}",
ExampleUtilities.FormatException(e));
}
}
/// <summary>
/// Returns a description about the code example.
/// </summary>
public override string Description
{
get
{
return "This code example runs a report for every advertiser account under a " +
"given manager account, using multiple parallel threads. This code example " +
"needs to be run against an AdWords manager account.";
}
}
/// <summary>
/// Runs the code example.
/// </summary>
/// <param name="user">The AdWords user.</param>
/// <param name="downloadFolder">The file to which the report is downloaded.
/// </param>
public void Run(AdWordsUser user, string downloadFolder)
{
// Increase the number of HTTP connections we can do in parallel.
System.Net.ServicePointManager.DefaultConnectionLimit = 100;
try
{
// Start the rate limiter with an initial value of zero, so that all
// threads block immediately.
Semaphore rateLimiter = new Semaphore(0, MAX_REPORT_DOWNLOADS_IN_PARALLEL);
// Get all the advertiser accounts under this manager account.
List<long> allCustomerIds = GetDescendantAdvertiserAccounts(user);
// Create a concurrent queue of customers so that all threads can work
// on the collection in parallel.
ConcurrentQueue<long> customerQueue = new ConcurrentQueue<long>(allCustomerIds);
// Create queues to keep track of successful and failed report downloads.
ConcurrentQueue<SuccessfulReportDownload> reportsSucceeeded =
new ConcurrentQueue<SuccessfulReportDownload>();
ConcurrentQueue<FailedReportDownload> reportsFailed =
new ConcurrentQueue<FailedReportDownload>();
// Keep an array of events. This is used by the main thread to wait for
// all worker threads to join.
ManualResetEvent[] doneEvents = new ManualResetEvent[MAX_NUMBER_OF_THREADS];
// The list of threads to download reports.
Thread[] threads = new Thread[MAX_NUMBER_OF_THREADS];
// The data for each thread.
ReportDownloadData[] threadData = new ReportDownloadData[MAX_NUMBER_OF_THREADS];
// The query to be run on each account.
ReportQuery query = new ReportQueryBuilder()
.Select("CampaignId", "AdGroupId", "Impressions", "Clicks", "Cost")
.From(ReportDefinitionReportType.ADGROUP_PERFORMANCE_REPORT)
.Where("AdGroupStatus").In("ENABLED", "PAUSED")
.During(ReportDefinitionDateRangeType.LAST_7_DAYS).Build();
// Initialize the threads and their data.
for (int i = 0; i < MAX_NUMBER_OF_THREADS; i++)
{
doneEvents[i] = new ManualResetEvent(false);
threadData[i] = new ReportDownloadData()
{
Config = (AdWordsAppConfig) (user.Config.Clone()),
DownloadFolder = downloadFolder,
SignalEvent = doneEvents[i],
ThreadIndex = i,
QuotaLock = rateLimiter,
CustomerIdQueue = customerQueue,
SuccessfulReports = reportsSucceeeded,
FailedReports = reportsFailed
};
threads[i] = new Thread(threadData[i].ThreadCallback);
}
// Start the threads. Since the initial value of rate limiter is zero,
// all threads will block immediately.
for (int i = 0; i < threads.Length; i++)
{
threads[i].Start(query);
}
// Now reset the rate limiter so all threads can start downloading reports.
rateLimiter.Release(MAX_REPORT_DOWNLOADS_IN_PARALLEL);
// Wait for all threads in pool to complete.
WaitHandle.WaitAll(doneEvents);
Console.WriteLine("Download completed, results:");
Console.WriteLine("Successful reports:");
while (!reportsSucceeeded.IsEmpty)
{
SuccessfulReportDownload success = null;
if (reportsSucceeeded.TryDequeue(out success))
{
Console.WriteLine("Client ID: {0}, Path: {1}", success.CustomerId,
success.Path);
}
}
Console.WriteLine("Failed reports:");
while (!reportsFailed.IsEmpty)
{
FailedReportDownload failure = null;
if (reportsFailed.TryDequeue(out failure))
{
Console.WriteLine("Client ID: {0}, Cause: {1}", failure.CustomerId,
failure.Exception.Message);
}
}
Console.WriteLine("All reports are downloaded.");
}
catch (Exception e)
{
throw new System.ApplicationException("Failed to download reports.", e);
}
}
/// <summary>
/// Gets the list of all descendant advertiser accounts under the manager
/// account.
/// </summary>
/// <param name="user">The AdWords user.</param>
/// <returns>A list of customer IDs for descendant advertiser accounts.</returns>
public static List<long> GetDescendantAdvertiserAccounts(AdWordsUser user)
{
List<long> retval = new List<long>();
// Get the ManagedCustomerService.
ManagedCustomerService managedCustomerService =
(ManagedCustomerService) user.GetService(AdWordsService.v201809
.ManagedCustomerService);
// Create selector.
Selector selector = new Selector()
{
fields = new string[]
{
ManagedCustomer.Fields.CustomerId
},
predicates = new Predicate[]
{
// Select only advertiser accounts.
Predicate.Equals(ManagedCustomer.Fields.CanManageClients, false.ToString())
},
paging = Paging.Default
};
ManagedCustomerPage page = null;
try
{
do
{
page = managedCustomerService.get(selector);
if (page.entries != null)
{
foreach (ManagedCustomer customer in page.entries)
{
retval.Add(customer.customerId);
}
}
selector.paging.IncreaseOffset();
} while (selector.paging.startIndex < page.totalNumEntries);
}
catch (Exception)
{
Console.WriteLine(
"Failed to retrieve advertiser accounts under the manager account.");
throw;
}
return retval;
}
}
}
Stream results from a report
// Copyright 2018 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
using Google.Api.Ads.AdWords.Lib;
using Google.Api.Ads.AdWords.Util.Reports;
using Google.Api.Ads.AdWords.Util.Reports.v201809;
using Google.Api.Ads.AdWords.v201809;
using Google.Api.Ads.Common.Util.Reports;
using System;
using System.Collections.Generic;
using System.IO.Compression;
using System.Xml;
namespace Google.Api.Ads.AdWords.Examples.CSharp.v201809
{
/// <summary>
/// This code example streams the results of an ad hoc report, collecting
/// total impressions by network from each line. This demonstrates how you
/// can extract data from a large report without holding the entire result
/// set in memory or using files.
/// </summary>
public class StreamCriteriaReportResults : ExampleBase
{
/// <summary>
/// Main method, to run this code example as a standalone application.
/// </summary>
/// <param name="args">The command line arguments.</param>
public static void Main(string[] args)
{
StreamCriteriaReportResults codeExample = new StreamCriteriaReportResults();
Console.WriteLine(codeExample.Description);
try
{
codeExample.Run(new AdWordsUser());
}
catch (Exception e)
{
Console.WriteLine("An exception occurred while running this code example. {0}",
ExampleUtilities.FormatException(e));
}
}
/// <summary>
/// Returns a description about the code example.
/// </summary>
public override string Description
{
get
{
return "This code example streams the results of an ad hoc report, collecting " +
"total impressions by network from each line. This demonstrates how you can " +
"extract data from a large report without holding the entire result set in " +
"memory or using files.";
}
}
/// <summary>
/// Runs the code example.
/// </summary>
/// <param name="user">The AdWords user.</param>
public void Run(AdWordsUser user)
{
// Create the query.
ReportQuery query = new ReportQueryBuilder()
.Select("Id", "AdNetworkType1", "Impressions")
.From(ReportDefinitionReportType.CRITERIA_PERFORMANCE_REPORT)
.Where("Status").In("ENABLED", "PAUSED")
.During(ReportDefinitionDateRangeType.LAST_7_DAYS)
.Build();
ReportUtilities reportUtilities = new ReportUtilities(user, "v201809", query,
DownloadFormat.GZIPPED_XML.ToString());
Dictionary<string, long> impressionsByAdNetworkType1 = new Dictionary<string, long>();
try
{
using (ReportResponse response = reportUtilities.GetResponse())
{
using (GZipStream gzipStream =
new GZipStream(response.Stream, CompressionMode.Decompress))
{
using (XmlTextReader reader = new XmlTextReader(gzipStream))
{
while (reader.Read())
{
switch (reader.NodeType)
{
case XmlNodeType.Element: // The node is an Element.
if (reader.Name == "row")
{
ParseRow(impressionsByAdNetworkType1, reader);
}
break;
}
}
}
}
}
Console.WriteLine("Network, Impressions");
foreach (string network in impressionsByAdNetworkType1.Keys)
{
Console.WriteLine("{0}, {1}", network, impressionsByAdNetworkType1[network]);
}
}
catch (Exception e)
{
throw new System.ApplicationException("Failed to download report.", e);
}
}
/// <summary>
/// Parses a report row.
/// </summary>
/// <param name="impressionsByAdNetworkType1">The map that keeps track of
/// the impressions grouped by by ad network type1.</param>
/// <param name="reader">The XML reader that parses the report.</param>
private static void ParseRow(Dictionary<string, long> impressionsByAdNetworkType1,
XmlTextReader reader)
{
string network = null;
long impressions = 0;
while (reader.MoveToNextAttribute())
{
switch (reader.Name)
{
case "network":
network = reader.Value;
break;
case "impressions":
impressions = long.Parse(reader.Value);
break;
}
}
if (network != null)
{
if (!impressionsByAdNetworkType1.ContainsKey(network))
{
impressionsByAdNetworkType1[network] = 0;
}
impressionsByAdNetworkType1[network] += impressions;
}
}
}
}
Stream results from a report as objects
// Copyright 2018 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
using Google.Api.Ads.AdWords.Lib;
using Google.Api.Ads.AdWords.Util.Reports;
using Google.Api.Ads.AdWords.Util.Reports.v201809;
using Google.Api.Ads.AdWords.v201809;
using Google.Api.Ads.Common.Util.Reports;
using System;
using System.IO.Compression;
namespace Google.Api.Ads.AdWords.Examples.CSharp.v201809
{
/// <summary>
/// The class that holds the data of one row of the report.
/// </summary>
public class CriteriaReportRow
{
/// <summary>
/// The Keyword ID column.
/// </summary>
[ReportColumn("keywordID")]
public long KeywordID { get; set; }
/// <summary>
/// The impressions column.
/// </summary>
[ReportColumn("impressions")]
public long Impressions { get; set; }
/// <summary>
/// The network column.
/// </summary>
[ReportColumn("network")]
public string NetworkType { get; set; }
/// <summary>
/// Returns a string that represents the current report row.
/// </summary>
override public string ToString()
{
return "Id: " + KeywordID + " Impressions: " + Impressions + " NetworkType: " +
NetworkType;
}
}
/// <summary>
/// This code example streams the results of an ad hoc report, and
/// returns the data in the report as objects of a given type.
/// </summary>
public class StreamCriteriaReportToPoco : ExampleBase
{
/// <summary>
/// Main method, to run this code example as a standalone application.
/// </summary>
/// <param name="args">The command line arguments.</param>
public static void Main(string[] args)
{
StreamCriteriaReportToPoco codeExample = new StreamCriteriaReportToPoco();
Console.WriteLine(codeExample.Description);
try
{
codeExample.Run(new AdWordsUser());
}
catch (Exception e)
{
Console.WriteLine("An exception occurred while running this code example. {0}",
ExampleUtilities.FormatException(e));
}
Console.ReadLine();
}
/// <summary>
/// Returns a description about the code example.
/// </summary>
public override string Description
{
get
{
return "This code example streams the results of an ad hoc report, and " +
"returns the data in the report as objects of a given type.";
}
}
/// <summary>
/// Runs the code example.
/// </summary>
/// <param name="user">The AdWords user.</param>
public void Run(AdWordsUser user)
{
// Create the query.
ReportQuery query = new ReportQueryBuilder()
.Select("Id", "AdNetworkType1", "Impressions")
.From(ReportDefinitionReportType.CRITERIA_PERFORMANCE_REPORT)
.Where("Status").In("ENABLED", "PAUSED")
.During(ReportDefinitionDateRangeType.LAST_7_DAYS)
.Build();
ReportUtilities reportUtilities = new ReportUtilities(user, "v201809", query,
DownloadFormat.GZIPPED_XML.ToString());
try
{
using (ReportResponse response = reportUtilities.GetResponse())
{
using (GZipStream gzipStream =
new GZipStream(response.Stream, CompressionMode.Decompress))
{
// Deserialize the report into a list of CriteriaReportRow.
// You can also deserialize the list into your own POCOs as follows.
// 1. Annotate your class properties with ReportRow annotation.
//
// public class MyCriteriaReportRow {
//
// [ReportColumn]
// public long KeywordID { get; set; }
//
// [ReportColumn]
// public long Impressions { get; set; }
// }
//
// 2. Deserialize into your own report rows.
//
// var report = new AwReport<MyCriteriaReportRow>(
// new AwXmlTextReader(gzipStream), "Example");
using (var report =
new AwReport<CriteriaReportRow>(new AwXmlTextReader(gzipStream),
"Example"))
{
// Print the contents of each row object.
foreach (var record in report.Rows)
{
Console.WriteLine(record);
}
}
}
}
}
catch (Exception e)
{
throw new System.ApplicationException("Failed to download and parse report.", e);
}
}
}
}
Stream results from a report as objects of a predefined report row type
// Copyright 2018 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
using Google.Api.Ads.AdWords.Lib;
using Google.Api.Ads.AdWords.Util.Reports;
using Google.Api.Ads.AdWords.Util.Reports.v201809;
using Google.Api.Ads.AdWords.v201809;
using Google.Api.Ads.Common.Util.Reports;
using System;
using System.IO.Compression;
namespace Google.Api.Ads.AdWords.Examples.CSharp.v201809
{
/// <summary>
/// This code example streams the results of an ad hoc report, and
/// returns the data in the report as objects of a predefined report row type.
/// </summary>
public class StreamReportToPredefinedReportRowType : ExampleBase
{
/// <summary>
/// Main method, to run this code example as a standalone application.
/// </summary>
/// <param name="args">The command line arguments.</param>
public static void Main(string[] args)
{
StreamReportToPredefinedReportRowType codeExample =
new StreamReportToPredefinedReportRowType();
Console.WriteLine(codeExample.Description);
try
{
codeExample.Run(new AdWordsUser());
}
catch (Exception e)
{
Console.WriteLine("An exception occurred while running this code example. {0}",
ExampleUtilities.FormatException(e));
}
Console.ReadLine();
}
/// <summary>
/// Returns a description about the code example.
/// </summary>
public override string Description
{
get
{
return "This code example streams the results of an ad hoc report, and " +
"returns the data in the report as objects of a predefined report row type.";
}
}
/// <summary>
/// Runs the code example.
/// </summary>
/// <param name="user">The AdWords user.</param>
public void Run(AdWordsUser user)
{
// Retreiving the raw values of enum-type fields instead of display values
(user.Config as AdWordsAppConfig).UseRawEnumValues = true;
// Create the query.
string query =
"SELECT AccountCurrencyCode, AccountDescriptiveName FROM FINAL_URL_REPORT " +
"DURING LAST_7_DAYS";
ReportUtilities reportUtilities = new ReportUtilities(user, "v201809", query,
DownloadFormat.GZIPPED_XML.ToString());
try
{
using (ReportResponse response = reportUtilities.GetResponse())
{
using (GZipStream gzipStream =
new GZipStream(response.Stream, CompressionMode.Decompress))
{
// Create the report object using the stream.
using (var report =
new AwReport<FinalUrlReportReportRow>(new AwXmlTextReader(gzipStream),
"Example"))
{
// Print the contents of each row object.
while (report.MoveNext())
{
Console.WriteLine(report.Current.accountCurrencyCode + " " +
report.Current.accountDescriptiveName);
}
}
}
}
}
catch (Exception e)
{
throw new System.ApplicationException("Failed to download and parse report.", e);
}
}
}
}