Advanced Operations Samples

The code samples below provide examples of common advanced operations using the AdWords API. Client Library.

Add an ad customizer feed

// 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;
using System.Collections.Generic;

namespace Google.Api.Ads.AdWords.Examples.CSharp.v201809
{
    /// <summary>
    /// This code example adds an ad customizer feed. Then it adds an ad in two
    /// different ad groups that uses the feed to populate dynamic data.
    /// </summary>
    public class AddAdCustomizers : 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)
        {
            AddAdCustomizers codeExample = new AddAdCustomizers();
            Console.WriteLine(codeExample.Description);
            try
            {
                long adGroupId1 = long.Parse("INSERT_ADGROUP_ID_HERE");
                long adGroupId2 = long.Parse("INSERT_ADGROUP_ID_HERE");
                string feedName = "INSERT_FEED_NAME_HERE";
                codeExample.Run(new AdWordsUser(), adGroupId1, adGroupId2, feedName);
            }
            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 adds an ad customizer feed. Then it adds an ad in two " +
                    "different ad groups that uses the feed to populate dynamic data.";
            }
        }

        /// <summary>
        /// Runs the code example.
        /// </summary>
        /// <param name="user">The AdWords user.</param>
        /// <param name="adGroupId1">Id of the first adgroup to which ads with ad
        /// customizers are added.</param>
        /// <param name="adGroupId2">Id of the second adgroup to which ads with ad
        /// customizers are added.</param>
        /// <param name="feedName">Name of the feed to be created.</param>
        public void Run(AdWordsUser user, long adGroupId1, long adGroupId2, string feedName)
        {
            try
            {
                // Create a customizer feed. One feed per account can be used for all ads.
                AdCustomizerFeed adCustomizerFeed = CreateCustomizerFeed(user, feedName);

                // Add feed items containing the values we'd like to place in ads.
                CreateCustomizerFeedItems(user, new long[]
                {
                    adGroupId1,
                    adGroupId2
                }, adCustomizerFeed);

                // All set! We can now create ads with customizations.
                CreateAdsWithCustomizations(user, new long[]
                {
                    adGroupId1,
                    adGroupId2
                }, feedName);
            }
            catch (Exception e)
            {
                throw new System.ApplicationException("Failed to add ad customizers.", e);
            }
        }

        /// <summary>
        /// Creates a new Feed for ad customizers.
        /// </summary>
        /// <param name="user">The AdWords user.</param>
        /// <param name="feedName">Name of the feed to be created.</param>
        /// <returns>A new Ad customizer feed.</returns>
        private static AdCustomizerFeed CreateCustomizerFeed(AdWordsUser user, string feedName)
        {
            using (AdCustomizerFeedService adCustomizerFeedService =
                (AdCustomizerFeedService) user.GetService(AdWordsService.v201809
                    .AdCustomizerFeedService))
            {
                AdCustomizerFeed feed = new AdCustomizerFeed()
                {
                    feedName = feedName,
                    feedAttributes = new AdCustomizerFeedAttribute[]
                    {
                        new AdCustomizerFeedAttribute()
                        {
                            name = "Name",
                            type = AdCustomizerFeedAttributeType.STRING
                        },
                        new AdCustomizerFeedAttribute()
                        {
                            name = "Price",
                            type = AdCustomizerFeedAttributeType.PRICE
                        },
                        new AdCustomizerFeedAttribute()
                        {
                            name = "Date",
                            type = AdCustomizerFeedAttributeType.DATE_TIME
                        },
                    }
                };

                AdCustomizerFeedOperation feedOperation = new AdCustomizerFeedOperation()
                {
                    operand = feed,
                    @operator = (Operator.ADD)
                };

                AdCustomizerFeed addedFeed = adCustomizerFeedService.mutate(
                    new AdCustomizerFeedOperation[]
                    {
                        feedOperation
                    }).value[0];

                Console.WriteLine(
                    "Created ad customizer feed with ID = {0} and name = '{1}' and " +
                    "attributes: ", addedFeed.feedId, addedFeed.feedName);

                foreach (AdCustomizerFeedAttribute feedAttribute in addedFeed.feedAttributes)
                {
                    Console.WriteLine("  ID: {0}, name: '{1}', type: {2}", feedAttribute.id,
                        feedAttribute.name, feedAttribute.type);
                }

                return addedFeed;
            }
        }

        /// <summary>
        /// Restricts the feed item to an ad group.
        /// </summary>
        /// <param name="user">The user.</param>
        /// <param name="feedItem">The feed item.</param>
        /// <param name="adGroupId">The ad group ID.</param>
        private static void RestrictFeedItemToAdGroup(AdWordsUser user, FeedItem feedItem,
            long? adGroupId)
        {
            FeedItemAdGroupTarget adGroupTarget = new FeedItemAdGroupTarget()
            {
                feedId = feedItem.feedId,
                feedItemId = feedItem.feedItemId,
                adGroupId = adGroupId.Value
            };

            using (FeedItemTargetService feedItemTargetService =
                (FeedItemTargetService) user.GetService(
                    AdWordsService.v201802.FeedItemTargetService))
            {
                FeedItemTargetOperation operation = new FeedItemTargetOperation()
                {
                    @operator = Operator.ADD,
                    operand = adGroupTarget
                };

                FeedItemTargetReturnValue retval = feedItemTargetService.mutate(
                    new FeedItemTargetOperation[]
                    {
                        operation
                    });
                FeedItemAdGroupTarget newAdGroupTarget = (FeedItemAdGroupTarget) retval.value[0];
                Console.WriteLine(
                    "Feed item target for feed ID {0} and feed item ID {1}" +
                    " was created to restrict serving to ad group ID {2}", newAdGroupTarget.feedId,
                    newAdGroupTarget.feedItemId, newAdGroupTarget.adGroupId);
            }
        }

        /// <summary>
        /// Creates feed items with the values to use in ad customizations for each
        /// ad group in <code>adGroupIds</code>.
        /// </summary>
        /// <param name="user">The AdWords user.</param>
        /// <param name="adGroupIds">IDs of adgroups to which ad customizations are
        /// made.</param>
        /// <param name="adCustomizerFeed">The ad customizer feed.</param>
        private static void CreateCustomizerFeedItems(AdWordsUser user, long[] adGroupIds,
            AdCustomizerFeed adCustomizerFeed)
        {
            using (FeedItemService feedItemService =
                (FeedItemService) user.GetService(AdWordsService.v201809.FeedItemService))
            {
                List<FeedItemOperation> feedItemOperations = new List<FeedItemOperation>();

                DateTime marsDate = new DateTime(DateTime.Now.Year, DateTime.Now.Month, 1);
                feedItemOperations.Add(CreateFeedItemAddOperation(adCustomizerFeed, "Mars",
                    "$1234.56", marsDate.ToString("yyyyMMdd HHmmss")));

                DateTime venusDate = new DateTime(DateTime.Now.Year, DateTime.Now.Month, 15);
                feedItemOperations.Add(CreateFeedItemAddOperation(adCustomizerFeed, "Venus",
                    "$1450.00", venusDate.ToString("yyyyMMdd HHmmss")));

                FeedItemReturnValue feedItemReturnValue =
                    feedItemService.mutate(feedItemOperations.ToArray());

                foreach (FeedItem addedFeedItem in feedItemReturnValue.value)
                {
                    Console.WriteLine("Added feed item with ID {0}", addedFeedItem.feedItemId);
                }

                // Add feed item targeting to restrict the feed item to specific ad groups.
                RestrictFeedItemToAdGroup(user, feedItemReturnValue.value[0], adGroupIds[0]);
                RestrictFeedItemToAdGroup(user, feedItemReturnValue.value[1], adGroupIds[1]);
            }
        }

        /// <summary>
        /// Creates a FeedItemOperation that will create a FeedItem with the
        /// specified values when sent to FeedItemService.mutate.
        /// </summary>
        /// <param name="adCustomizerFeed">The ad customizer feed.</param>
        /// <param name="name">The value for the name attribute of the FeedItem.
        /// </param>
        /// <param name="price">The value for the price attribute of the FeedItem.
        /// </param>
        /// <param name="date">The value for the date attribute of the FeedItem.
        /// </param>
        /// <returns>A new FeedItemOperation for adding a FeedItem.</returns>
        private static FeedItemOperation CreateFeedItemAddOperation(
            AdCustomizerFeed adCustomizerFeed, string name, string price, string date)
        {
            FeedItem feedItem = new FeedItem()
            {
                feedId = adCustomizerFeed.feedId,

                // FeedAttributes appear in the same order as they were created
                // - Name, Price, Date. See CreateCustomizerFeed method for details.
                attributeValues = new FeedItemAttributeValue[]
                {
                    new FeedItemAttributeValue()
                    {
                        feedAttributeId = adCustomizerFeed.feedAttributes[0].id,
                        stringValue = name
                    },

                    new FeedItemAttributeValue()
                    {
                        feedAttributeId = adCustomizerFeed.feedAttributes[1].id,
                        stringValue = price
                    },

                    new FeedItemAttributeValue()
                    {
                        feedAttributeId = adCustomizerFeed.feedAttributes[2].id,
                        stringValue = date
                    }
                },
            };

            return new FeedItemOperation()
            {
                operand = feedItem,
                @operator = Operator.ADD
            };
        }

        /// <summary>
        /// Creates text ads that use ad customizations for the specified ad group
        /// IDs.
        /// </summary>
        /// <param name="user">The AdWords user.</param>
        /// <param name="adGroupIds">IDs of the ad groups to which customized ads
        /// are added.</param>
        /// <param name="feedName">Name of the feed to be used.</param>
        private static void CreateAdsWithCustomizations(AdWordsUser user, long[] adGroupIds,
            string feedName)
        {
            using (AdGroupAdService adGroupAdService =
                (AdGroupAdService) user.GetService(AdWordsService.v201809.AdGroupAdService))
            {
                ExpandedTextAd expandedTextAd = new ExpandedTextAd()
                {
                    headlinePart1 = string.Format("Luxury Cruise to {{={0}.Name}}", feedName),
                    headlinePart2 = string.Format("Only {{={0}.Price}}", feedName),
                    description =
                        string.Format("Offer ends in {{=countdown({0}.Date)}}!", feedName),
                    finalUrls = new string[]
                    {
                        "http://www.example.com"
                    }
                };

                // We add the same ad to both ad groups. When they serve, they will show
                // different values, since they match different feed items.
                List<AdGroupAdOperation> adGroupAdOperations = new List<AdGroupAdOperation>();
                foreach (long adGroupId in adGroupIds)
                {
                    AdGroupAd adGroupAd = new AdGroupAd()
                    {
                        adGroupId = adGroupId,
                        ad = expandedTextAd
                    };

                    AdGroupAdOperation adGroupAdOperation = new AdGroupAdOperation()
                    {
                        operand = adGroupAd,
                        @operator = Operator.ADD
                    };

                    adGroupAdOperations.Add(adGroupAdOperation);
                }

                AdGroupAdReturnValue adGroupAdReturnValue =
                    adGroupAdService.mutate(adGroupAdOperations.ToArray());

                foreach (AdGroupAd addedAd in adGroupAdReturnValue.value)
                {
                    Console.WriteLine("Created an ad with ID {0}, type '{1}' and status '{2}'.",
                        addedAd.ad.id, addedAd.ad.AdType, addedAd.status);
                }
            }
        }
    }
}

Add an ad group level bid modifier

// 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 illustrates how to add ad group level mobile bid
    /// modifier override.
    /// </summary>
    public class AddAdGroupBidModifier : 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)
        {
            AddAdGroupBidModifier codeExample = new AddAdGroupBidModifier();
            Console.WriteLine(codeExample.Description);
            try
            {
                long adGroupId = long.Parse("INSERT_ADGROUP_ID_HERE");
                double bidModifier = double.Parse("INSERT_ADGROUP_BID_MODIFIER_HERE");
                codeExample.Run(new AdWordsUser(), adGroupId, bidModifier);
            }
            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 illustrates how to add ad group level mobile bid modifier " +
                    "override.";
            }
        }

        /// <summary>
        /// Runs the code example.
        /// </summary>
        /// <param name="user">The AdWords user.</param>
        /// <param name="adGroupId">Id of the adgroup for which bid modifier is
        /// set.</param>
        /// <param name="bidModifier">The mobile bid modifier for adgroup</param>
        public void Run(AdWordsUser user, long adGroupId, double bidModifier)
        {
            using (AdGroupBidModifierService adGroupBidModifierService =
                (AdGroupBidModifierService) user.GetService(AdWordsService.v201809
                    .AdGroupBidModifierService))
            {
                // Mobile criterion ID.
                long criterionId = 30001;

                // Create the adgroup bid modifier.
                AdGroupBidModifier adGroupBidModifier = new AdGroupBidModifier
                {
                    bidModifier = bidModifier,
                    adGroupId = adGroupId
                };

                Platform platform = new Platform
                {
                    id = criterionId
                };

                adGroupBidModifier.criterion = platform;

                AdGroupBidModifierOperation operation = new AdGroupBidModifierOperation
                {
                    @operator = Operator.ADD,
                    operand = adGroupBidModifier
                };

                try
                {
                    // Add ad group level mobile bid modifier.
                    AdGroupBidModifierReturnValue retval = adGroupBidModifierService.mutate(
                        new AdGroupBidModifierOperation[]
                        {
                            operation
                        });

                    // Display the results.
                    if (retval != null && retval.value != null && retval.value.Length > 0)
                    {
                        AdGroupBidModifier newBidModifier = retval.value[0];
                        Console.WriteLine(
                            "AdGroup ID {0}, Criterion ID {1} was updated with ad group level " +
                            "modifier: {2}", newBidModifier.adGroupId, newBidModifier.criterion.id,
                            newBidModifier.bidModifier);
                    }
                    else
                    {
                        Console.WriteLine("No bid modifiers were added to the adgroup.");
                    }
                }
                catch (Exception e)
                {
                    throw new System.ApplicationException("Failed to add bid modifiers to adgroup.",
                        e);
                }
            }
        }
    }
}

Add a page feed specifying URLs for a DSA campaign

// 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 adds a page feed to specify precisely which URLs to use with your
    /// Dynamic Search Ads campaign. To create a Dynamic Search Ads campaign, run
    /// AddDynamicSearchAdsCampaign.cs. To get campaigns, run GetCampaigns.cs.
    /// </summary>
    public class AddDynamicPageFeed : ExampleBase
    {
        /// <summary>
        /// The criterion type to be used for DSA page feeds.
        /// </summary>
        /// <remarks>DSA page feeds use criterionType field instead of the placeholderType field
        /// unlike most other feed types.</remarks>
        private const int DSA_PAGE_FEED_CRITERION_TYPE = 61;

        /// <summary>
        /// ID that corresponds to the page URLs.
        /// </summary>
        private const int DSA_PAGE_URLS_FIELD_ID = 1;

        /// <summary>
        /// ID that corresponds to the labels.
        /// </summary>
        private const int DSA_LABEL_FIELD_ID = 2;

        /// <summary>
        /// Class to keep track of DSA page feed details.
        /// </summary>
        private class DSAFeedDetails
        {
            public long feedId { get; set; }
            public long urlAttributeId { get; set; }
            public long labelAttributeId { get; set; }
        }

        /// <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)
        {
            AddDynamicPageFeed codeExample = new AddDynamicPageFeed();
            Console.WriteLine(codeExample.Description);
            try
            {
                long campaignId = long.Parse("INSERT_CAMPAIGN_ID_HERE");
                long adGroupId = long.Parse("INSERT_ADGROUP_ID_HERE");
                codeExample.Run(new AdWordsUser(), campaignId, adGroupId);
            }
            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 adds a page feed to specify precisely which URLs to " +
                    "use with your Dynamic Search Ads campaign. To create a Dynamic Search Ads " +
                    "campaign, run AddDynamicSearchAdsCampaign.cs. To get campaigns, " +
                    "run GetCampaigns.cs.";
            }
        }

        /// <summary>
        /// Runs the code example.
        /// </summary>
        /// <param name="user">The AdWords user.</param>
        /// <param name="campaignId">The DSA campaign ID.</param>
        /// <param name="adGroupId">The DSA ad group ID.</param>
        public void Run(AdWordsUser user, long campaignId, long adGroupId)
        {
            string dsaPageUrlLabel = "discounts";

            // Get the page feed details. This code example creates a new feed, but you can
            // fetch and re-use an existing feed.
            DSAFeedDetails feedDetails = CreateFeed(user);
            CreateFeedMapping(user, feedDetails);
            CreateFeedItems(user, feedDetails, dsaPageUrlLabel);

            // Associate the page feed with the campaign.
            UpdateCampaignDsaSetting(user, campaignId, feedDetails.feedId);

            // Optional: Target web pages matching the feed's label in the ad group.
            AddDsaTargeting(user, adGroupId, dsaPageUrlLabel);

            Console.WriteLine("Dynamic page feed setup is complete for campaign ID '{0}'.",
                campaignId);
        }

        /// <summary>
        /// Creates the feed for DSA page URLs.
        /// </summary>
        /// <param name="user">The AdWords User.</param>
        /// <returns>The feed details.</returns>
        private static DSAFeedDetails CreateFeed(AdWordsUser user)
        {
            using (FeedService feedService =
                (FeedService) user.GetService(AdWordsService.v201809.FeedService))
            {
                // Create attributes.
                FeedAttribute urlAttribute = new FeedAttribute
                {
                    type = FeedAttributeType.URL_LIST,
                    name = "Page URL"
                };

                FeedAttribute labelAttribute = new FeedAttribute
                {
                    type = FeedAttributeType.STRING_LIST,
                    name = "Label"
                };

                // Create the feed.
                Feed sitelinksFeed = new Feed
                {
                    name = "DSA Feed " + ExampleUtilities.GetRandomString(),
                    attributes = new FeedAttribute[]
                    {
                        urlAttribute,
                        labelAttribute
                    },
                    origin = FeedOrigin.USER
                };

                // Create operation.
                FeedOperation operation = new FeedOperation
                {
                    operand = sitelinksFeed,
                    @operator = Operator.ADD
                };

                try
                {
                    // Add the feed.
                    FeedReturnValue result = feedService.mutate(new FeedOperation[]
                    {
                        operation
                    });

                    Feed savedFeed = result.value[0];
                    return new DSAFeedDetails
                    {
                        feedId = savedFeed.id,
                        urlAttributeId = savedFeed.attributes[0].id,
                        labelAttributeId = savedFeed.attributes[1].id,
                    };
                }
                catch (Exception e)
                {
                    throw new System.ApplicationException("Failed to create DSA feed.", e);
                }
            }
        }

        /// <summary>
        /// Creates the feed mapping for DSA page feeds.
        /// </summary>
        /// <param name="user">The AdWords user.</param>
        /// <param name="feedDetails">The feed details.</param>
        private static void CreateFeedMapping(AdWordsUser user, DSAFeedDetails feedDetails)
        {
            using (FeedMappingService feedMappingService =
                (FeedMappingService) user.GetService(AdWordsService.v201809.FeedMappingService))
            {
                // Map the FeedAttributeIds to the fieldId constants.
                AttributeFieldMapping urlFieldMapping = new AttributeFieldMapping
                {
                    feedAttributeId = feedDetails.urlAttributeId,
                    fieldId = DSA_PAGE_URLS_FIELD_ID
                };

                AttributeFieldMapping labelFieldMapping = new AttributeFieldMapping
                {
                    feedAttributeId = feedDetails.labelAttributeId,
                    fieldId = DSA_LABEL_FIELD_ID
                };

                // Create the FieldMapping and operation.
                FeedMapping feedMapping = new FeedMapping
                {
                    criterionType = DSA_PAGE_FEED_CRITERION_TYPE,
                    feedId = feedDetails.feedId,
                    attributeFieldMappings = new AttributeFieldMapping[]
                    {
                        urlFieldMapping,
                        labelFieldMapping
                    }
                };

                FeedMappingOperation operation = new FeedMappingOperation
                {
                    operand = feedMapping,
                    @operator = Operator.ADD
                };

                try
                {
                    // Add the field mapping.
                    feedMappingService.mutate(new FeedMappingOperation[]
                    {
                        operation
                    });
                    return;
                }
                catch (Exception e)
                {
                    throw new System.ApplicationException("Failed to create feed mapping.", e);
                }
            }
        }

        /// <summary>
        /// Creates the page URLs in the DSA page feed.
        /// </summary>
        /// <param name="user">The AdWords user.</param>
        /// <param name="feedDetails">The feed details.</param>
        /// <param name="labelName">The pagefeed url label.</param>
        private static void CreateFeedItems(AdWordsUser user, DSAFeedDetails feedDetails,
            string labelName)
        {
            using (FeedItemService feedItemService =
                (FeedItemService) user.GetService(AdWordsService.v201809.FeedItemService))
            {
                FeedItemOperation[] operations = new FeedItemOperation[]
                {
                    CreateDsaUrlAddOperation(feedDetails,
                        "http://www.example.com/discounts/rental-cars", labelName),
                    CreateDsaUrlAddOperation(feedDetails,
                        "http://www.example.com/discounts/hotel-deals", labelName),
                    CreateDsaUrlAddOperation(feedDetails,
                        "http://www.example.com/discounts/flight-deals", labelName),
                };
                feedItemService.mutate(operations);
            }
        }

        /// <summary>
        /// Creates the DSA URL add operation.
        /// </summary>
        /// <param name="details">The page feed details.</param>
        /// <param name="url">The DSA page feed URL.</param>
        /// <param name="label">DSA page feed label.</param>
        /// <returns>The DSA URL add operation.</returns>
        private static FeedItemOperation CreateDsaUrlAddOperation(DSAFeedDetails details,
            string url, string label)
        {
            // Create the FeedItemAttributeValues for our text values.
            FeedItemAttributeValue urlAttributeValue = new FeedItemAttributeValue
            {
                feedAttributeId = details.urlAttributeId,

                // See https://support.google.com/adwords/answer/7166527 for page feed URL
                // recommendations and rules.
                stringValues = new string[]
                {
                    url
                }
            };

            FeedItemAttributeValue labelAttributeValue = new FeedItemAttributeValue
            {
                feedAttributeId = details.labelAttributeId,
                stringValues = new string[]
                {
                    label
                }
            };

            // Create the feed item and operation.
            FeedItem item = new FeedItem
            {
                feedId = details.feedId,

                attributeValues = new FeedItemAttributeValue[]
                {
                    urlAttributeValue,
                    labelAttributeValue
                }
            };

            FeedItemOperation operation = new FeedItemOperation
            {
                operand = item,
                @operator = Operator.ADD
            };

            return operation;
        }

        /// <summary>
        /// Updates the campaign DSA setting to add DSA pagefeeds.
        /// </summary>
        /// <param name="user">The AdWords user.</param>
        /// <param name="campaignId">The Campaign ID.</param>
        /// <param name="feedId">The page feed ID.</param>
        private static void UpdateCampaignDsaSetting(AdWordsUser user, long campaignId, long feedId)
        {
            using (CampaignService campaignService =
                (CampaignService) user.GetService(AdWordsService.v201809.CampaignService))
            {
                Selector selector = new Selector()
                {
                    fields = new string[]
                    {
                        Campaign.Fields.Id,
                        Campaign.Fields.Settings
                    },
                    predicates = new Predicate[]
                    {
                        Predicate.Equals(Campaign.Fields.Id, campaignId)
                    },
                    paging = Paging.Default
                };

                CampaignPage page = campaignService.get(selector);

                if (page == null || page.entries == null || page.entries.Length == 0)
                {
                    throw new System.ApplicationException(
                        string.Format("Failed to retrieve campaign with ID = {0}.", campaignId));
                }

                Campaign campaign = page.entries[0];

                if (campaign.settings == null)
                {
                    throw new System.ApplicationException("This is not a DSA campaign.");
                }

                DynamicSearchAdsSetting dsaSetting = null;
                Setting[] campaignSettings = campaign.settings;

                for (int i = 0; i < campaign.settings.Length; i++)
                {
                    Setting setting = campaignSettings[i];
                    if (setting is DynamicSearchAdsSetting)
                    {
                        dsaSetting = (DynamicSearchAdsSetting) setting;
                        break;
                    }
                }

                if (dsaSetting == null)
                {
                    throw new System.ApplicationException("This is not a DSA campaign.");
                }

                // Use a page feed to specify precisely which URLs to use with your
                // Dynamic Search Ads.
                dsaSetting.pageFeed = new PageFeed()
                {
                    feedIds = new long[]
                    {
                        feedId
                    },
                };

                // Optional: Specify whether only the supplied URLs should be used with your
                // Dynamic Search Ads.
                dsaSetting.useSuppliedUrlsOnly = true;

                Campaign campaignToUpdate = new Campaign
                {
                    id = campaignId,
                    settings = campaignSettings
                };

                CampaignOperation operation = new CampaignOperation
                {
                    operand = campaignToUpdate,
                    @operator = Operator.SET
                };

                try
                {
                    CampaignReturnValue retval = campaignService.mutate(new CampaignOperation[]
                    {
                        operation
                    });
                    Campaign updatedCampaign = retval.value[0];
                    Console.WriteLine(
                        "DSA page feed for campaign ID '{0}' was updated with feed ID '{1}'.",
                        updatedCampaign.id, feedId);
                }
                catch (Exception e)
                {
                    throw new System.ApplicationException("Failed to set page feed for campaign.",
                        e);
                }
            }

        }

        /// <summary>
        /// Set custom targeting for the page feed URLs based on a list of labels.
        /// </summary>
        /// <param name="user">The AdWords user.</param>
        /// <param name="adGroupId">Ad group ID.</param>
        /// <param name="labelName">The label name.</param>
        /// <returns>The newly created webpage criterion.</returns>
        private static BiddableAdGroupCriterion AddDsaTargeting(AdWordsUser user, long adGroupId,
            string labelName)
        {
            using (AdGroupCriterionService adGroupCriterionService =
                (AdGroupCriterionService) user.GetService(AdWordsService.v201809
                    .AdGroupCriterionService))
            {
                // Create a webpage criterion.
                Webpage webpage = new Webpage();

                WebpageParameter parameter = new WebpageParameter
                {
                    criterionName = "Test criterion"
                };
                webpage.parameter = parameter;

                // Add a condition for label=specified_label_name.
                WebpageCondition condition = new WebpageCondition
                {
                    operand = WebpageConditionOperand.CUSTOM_LABEL,
                    argument = labelName
                };
                parameter.conditions = new WebpageCondition[]
                {
                    condition
                };

                BiddableAdGroupCriterion criterion = new BiddableAdGroupCriterion
                {
                    adGroupId = adGroupId,
                    criterion = webpage
                };

                // Set a custom bid for this criterion.
                BiddingStrategyConfiguration biddingStrategyConfiguration =
                    new BiddingStrategyConfiguration
                    {
                        bids = new Bids[]
                        {
                            new CpcBid()
                            {
                                bid = new Money()
                                {
                                    microAmount = 1500000
                                }
                            }
                        }
                    };

                criterion.biddingStrategyConfiguration = biddingStrategyConfiguration;

                AdGroupCriterionOperation operation = new AdGroupCriterionOperation
                {
                    operand = criterion,
                    @operator = Operator.ADD
                };

                try
                {
                    AdGroupCriterionReturnValue retval = adGroupCriterionService.mutate(
                        new AdGroupCriterionOperation[]
                        {
                            operation
                        });
                    BiddableAdGroupCriterion newCriterion =
                        (BiddableAdGroupCriterion) retval.value[0];

                    Console.WriteLine(
                        "Web page criterion with ID = {0} and status = {1} was created.",
                        newCriterion.criterion.id, newCriterion.userStatus);
                    return newCriterion;
                }
                catch (Exception e)
                {
                    throw new System.ApplicationException(
                        "Failed to create webpage criterion for " + "custom page feed label.", e);
                }
            }
        }

    }
}

Add a DSA campaign

// 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 adds a Dynamic Search Ads campaign. To get campaigns, run GetCampaigns.cs.
    /// </summary>
    public class AddDynamicSearchAdsCampaign : 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)
        {
            AddDynamicSearchAdsCampaign codeExample = new AddDynamicSearchAdsCampaign();
            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 adds a Dynamic Search Ads campaign. To get campaigns, " +
                    "run GetCampaigns.cs.";
            }
        }

        /// <summary>
        /// Runs the code example.
        /// </summary>
        /// <param name="user">The AdWords user.</param>
        public void Run(AdWordsUser user)
        {
            Budget budget = CreateBudget(user);
            Campaign campaign = CreateCampaign(user, budget);
            AdGroup adGroup = CreateAdGroup(user, campaign.id);
            CreateExpandedDSA(user, adGroup.id);
            AddWebPageCriteria(user, adGroup.id);
            Console.WriteLine("Dynamic Search Ads campaign setup is complete.");
        }

        /// <summary>
        /// Creates the budget.
        /// </summary>
        /// <param name="user">The AdWords user.</param>
        /// <returns>The newly created budget.</returns>
        private static Budget CreateBudget(AdWordsUser user)
        {
            using (BudgetService budgetService =
                (BudgetService) user.GetService(AdWordsService.v201809.BudgetService))
            {
                // Create the campaign budget.
                Budget budget = new Budget
                {
                    name = "Interplanetary Cruise Budget #" + ExampleUtilities.GetRandomString(),
                    deliveryMethod = BudgetBudgetDeliveryMethod.STANDARD,
                    amount = new Money
                    {
                        microAmount = 500000
                    }
                };

                BudgetOperation budgetOperation = new BudgetOperation
                {
                    @operator = Operator.ADD,
                    operand = budget
                };

                try
                {
                    BudgetReturnValue budgetRetval = budgetService.mutate(new BudgetOperation[]
                    {
                        budgetOperation
                    });
                    Budget newBudget = budgetRetval.value[0];
                    Console.WriteLine("Budget with ID = '{0}' and name = '{1}' was created.",
                        newBudget.budgetId, newBudget.name);
                    budgetService.Close();
                    return newBudget;
                }
                catch (Exception e)
                {
                    throw new System.ApplicationException("Failed to add budget.", e);
                }
            }
        }


        /// <summary>
        /// Creates the campaign.
        /// </summary>
        /// <param name="user">The AdWords user.</param>
        /// <param name="budget">The campaign budget.</param>
        /// <returns>The newly created campaign.</returns>
        private static Campaign CreateCampaign(AdWordsUser user, Budget budget)
        {
            using (CampaignService campaignService =
                (CampaignService) user.GetService(AdWordsService.v201809.CampaignService))
            {
                // Create a Dynamic Search Ads campaign.
                Campaign campaign = new Campaign
                {
                    name = "Interplanetary Cruise #" + ExampleUtilities.GetRandomString(),
                    advertisingChannelType = AdvertisingChannelType.SEARCH,

                    // Recommendation: Set the campaign to PAUSED when creating it to prevent
                    // the ads from immediately serving. Set to ENABLED once you've added
                    // targeting and the ads are ready to serve.
                    status = CampaignStatus.PAUSED
                };

                BiddingStrategyConfiguration biddingConfig = new BiddingStrategyConfiguration
                {
                    biddingStrategyType = BiddingStrategyType.MANUAL_CPC
                };
                campaign.biddingStrategyConfiguration = biddingConfig;

                campaign.budget = new Budget
                {
                    budgetId = budget.budgetId
                };

                // Required: Set the campaign's Dynamic Search Ads settings.
                DynamicSearchAdsSetting dynamicSearchAdsSetting = new DynamicSearchAdsSetting
                {
                    // Required: Set the domain name and language.
                    domainName = "example.com",
                    languageCode = "en"
                };

                // Set the campaign settings.
                campaign.settings = new Setting[]
                {
                    dynamicSearchAdsSetting
                };

                // Optional: Set the start date.
                campaign.startDate = DateTime.Now.AddDays(1).ToString("yyyyMMdd");

                // Optional: Set the end date.
                campaign.endDate = DateTime.Now.AddYears(1).ToString("yyyyMMdd");

                // Create the operation.
                CampaignOperation operation = new CampaignOperation
                {
                    @operator = Operator.ADD,
                    operand = campaign
                };

                try
                {
                    // Add the campaign.
                    CampaignReturnValue retVal = campaignService.mutate(new CampaignOperation[]
                    {
                        operation
                    });

                    // Display the results.
                    Campaign newCampaign = retVal.value[0];
                    Console.WriteLine("Campaign with id = '{0}' and name = '{1}' was added.",
                        newCampaign.id, newCampaign.name);
                    return newCampaign;
                }
                catch (Exception e)
                {
                    throw new System.ApplicationException("Failed to add campaigns.", e);
                }
            }
        }


        /// <summary>
        /// Creates an ad group.
        /// </summary>
        /// <param name="user">The AdWords user.</param>
        /// <param name="campaignId">The campaign ID.</param>
        /// <returns>the newly created ad group.</returns>
        private static AdGroup CreateAdGroup(AdWordsUser user, long campaignId)
        {
            using (AdGroupService adGroupService =
                (AdGroupService) user.GetService(AdWordsService.v201809.AdGroupService))
            {
                // Create the ad group.
                AdGroup adGroup = new AdGroup
                {
                    // Required: Set the ad group's type to Dynamic Search Ads.
                    adGroupType = AdGroupType.SEARCH_DYNAMIC_ADS,

                    name = string.Format("Earth to Mars Cruises #{0}",
                        ExampleUtilities.GetRandomString()),
                    campaignId = campaignId,
                    status = AdGroupStatus.PAUSED,

                    // Recommended: Set a tracking URL template for your ad group if you want to use
                    // URL tracking software.
                    trackingUrlTemplate = "http://tracker.example.com/traveltracker/{escapedlpurl}"
                };

                // Set the ad group bids.
                BiddingStrategyConfiguration biddingConfig = new BiddingStrategyConfiguration();

                CpcBid cpcBid = new CpcBid
                {
                    bid = new Money
                    {
                        microAmount = 3000000
                    }
                };

                biddingConfig.bids = new Bids[]
                {
                    cpcBid
                };

                adGroup.biddingStrategyConfiguration = biddingConfig;

                // Create the operation.
                AdGroupOperation operation = new AdGroupOperation
                {
                    @operator = Operator.ADD,
                    operand = adGroup
                };

                try
                {
                    // Create the ad group.
                    AdGroupReturnValue retVal = adGroupService.mutate(new AdGroupOperation[]
                    {
                        operation
                    });

                    // Display the results.
                    AdGroup newAdGroup = retVal.value[0];
                    Console.WriteLine("Ad group with id = '{0}' and name = '{1}' was created.",
                        newAdGroup.id, newAdGroup.name);
                    return newAdGroup;
                }
                catch (Exception e)
                {
                    throw new System.ApplicationException("Failed to create ad group.", e);
                }
            }
        }


        /// <summary>
        /// Creates an expanded Dynamic Search Ad.
        /// </summary>
        /// <param name="user">The AdWords user.</param>
        /// <param name="adGroupId">ID of the ad group in which ad is created.</param>
        /// <returns>The newly created ad.</returns>
        private static ExpandedDynamicSearchAd CreateExpandedDSA(AdWordsUser user, long adGroupId)
        {
            using (AdGroupAdService adGroupAdService =
                (AdGroupAdService) user.GetService(AdWordsService.v201809.AdGroupAdService))
            {
                // Create an Expanded Dynamic Search Ad. This ad will have its headline, display URL
                // and final URL auto-generated at serving time according to domain name specific
                // information provided by DynamicSearchAdsSetting at the campaign level.
                ExpandedDynamicSearchAd expandedDSA = new ExpandedDynamicSearchAd
                {
                    // Set the ad description.
                    description = "Buy your tickets now!",
                    description2 = "Discount ends soon"
                };

                // Create the ad group ad.
                AdGroupAd adGroupAd = new AdGroupAd
                {
                    adGroupId = adGroupId,
                    ad = expandedDSA,

                    // Optional: Set the status.
                    status = AdGroupAdStatus.PAUSED
                };

                // Create the operation.
                AdGroupAdOperation operation = new AdGroupAdOperation
                {
                    @operator = Operator.ADD,
                    operand = adGroupAd
                };

                try
                {
                    // Create the ad.
                    AdGroupAdReturnValue retval = adGroupAdService.mutate(new AdGroupAdOperation[]
                    {
                        operation
                    });

                    // Display the results.
                    AdGroupAd newAdGroupAd = retval.value[0];
                    ExpandedDynamicSearchAd newAd = newAdGroupAd.ad as ExpandedDynamicSearchAd;
                    Console.WriteLine(
                        "Expanded Dynamic Search Ad with ID '{0}' and description '{1}' " +
                        "was added.", newAd.id, newAd.description);
                    return newAd;
                }
                catch (Exception e)
                {
                    throw new System.ApplicationException(
                        "Failed to create Expanded Dynamic Search Ad.", e);
                }
            }
        }


        /// <summary>
        /// Adds a web page criterion to target Dynamic Search Ads.
        /// </summary>
        /// <param name="user">The AdWords user.</param>
        /// <param name="adGroupId">The ad group ID.</param>
        /// <returns>The newly created web page criterion.</returns>
        private static BiddableAdGroupCriterion AddWebPageCriteria(AdWordsUser user, long adGroupId)
        {
            using (AdGroupCriterionService adGroupCriterionService =
                (AdGroupCriterionService) user.GetService(AdWordsService.v201809
                    .AdGroupCriterionService))
            {
                // Create a webpage criterion for special offers for mars cruise.
                WebpageParameter param = new WebpageParameter
                {
                    criterionName = "Special offers for mars"
                };

                WebpageCondition urlCondition = new WebpageCondition
                {
                    operand = WebpageConditionOperand.URL,
                    argument = "/marscruise/special"
                };

                WebpageCondition titleCondition = new WebpageCondition
                {
                    operand = WebpageConditionOperand.PAGE_TITLE,
                    argument = "Special Offer"
                };

                param.conditions = new WebpageCondition[]
                {
                    urlCondition,
                    titleCondition
                };

                Webpage webpage = new Webpage
                {
                    parameter = param
                };

                // Create biddable ad group criterion.
                BiddableAdGroupCriterion biddableAdGroupCriterion = new BiddableAdGroupCriterion
                {
                    adGroupId = adGroupId,
                    criterion = webpage,
                    userStatus = UserStatus.PAUSED
                };

                // Optional: set a custom bid.
                BiddingStrategyConfiguration biddingStrategyConfiguration =
                    new BiddingStrategyConfiguration();
                CpcBid bid = new CpcBid()
                {
                    bid = new Money()
                    {
                        microAmount = 10000000L
                    }
                };
                biddingStrategyConfiguration.bids = new Bids[]
                {
                    bid
                };
                biddableAdGroupCriterion.biddingStrategyConfiguration =
                    biddingStrategyConfiguration;

                // Create the operation.
                AdGroupCriterionOperation operation = new AdGroupCriterionOperation
                {
                    @operator = Operator.ADD,
                    operand = biddableAdGroupCriterion
                };

                try
                {
                    AdGroupCriterionReturnValue result = adGroupCriterionService.mutate(
                        new AdGroupCriterionOperation[]
                        {
                            operation
                        });

                    BiddableAdGroupCriterion newCriterion =
                        (BiddableAdGroupCriterion) result.value[0];
                    Console.WriteLine(
                        "Webpage criterion with ID = '{0}' was added to ad group ID '{1}'.",
                        newCriterion.criterion.id, newCriterion.adGroupId);
                    return newCriterion;
                }
                catch (Exception e)
                {
                    throw new System.ApplicationException("Failed to create webpage criterion.", e);
                }
            }
        }

    }
}

Add an expanded text ad with Upgraded URLs

// 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;
using System.Collections.Generic;

namespace Google.Api.Ads.AdWords.Examples.CSharp.v201809
{
    /// <summary>
    /// This code example adds an expanded text ad that uses advanced features
    /// of upgraded URLs.
    /// </summary>
    public class AddExpandedTextAdWithUpgradedUrls : 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)
        {
            AddExpandedTextAdWithUpgradedUrls codeExample = new AddExpandedTextAdWithUpgradedUrls();
            Console.WriteLine(codeExample.Description);
            try
            {
                long adGroupId = long.Parse("INSERT_ADGROUP_ID_HERE");
                codeExample.Run(new AdWordsUser(), adGroupId);
            }
            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 adds an expanded text ad that uses advanced features of " +
                    "upgraded URLs.";
            }
        }

        /// <summary>
        /// Runs the code example.
        /// </summary>
        /// <param name="user">The AdWords user.</param>
        /// <param name="adGroupId">ID of the ad group to which ad is added.
        /// </param>
        public void Run(AdWordsUser user, long adGroupId)
        {
            using (AdGroupAdService adGroupAdService =
                (AdGroupAdService) user.GetService(AdWordsService.v201809.AdGroupAdService))
            {
                // Create the expanded text ad.
                ExpandedTextAd expandedTextAd = new ExpandedTextAd()
                {
                    headlinePart1 = "Luxury Cruise to Mars",
                    headlinePart2 = "Visit the Red Planet in style.",
                    description = "Low-gravity fun for everyone!",
                };

                // Specify a tracking URL for 3rd party tracking provider. You may
                // specify one at customer, campaign, ad group, ad, criterion or
                // feed item levels.
                expandedTextAd.trackingUrlTemplate =
                    "http://tracker.example.com/?season={_season}&promocode={_promocode}&u={lpurl}";

                // Since your tracking URL has two custom parameters, provide their
                // values too. This can be provided at campaign, ad group, ad, criterion
                // or feed item levels.
                CustomParameter seasonParameter = new CustomParameter
                {
                    key = "season",
                    value = "christmas"
                };

                CustomParameter promoCodeParameter = new CustomParameter
                {
                    key = "promocode",
                    value = "NYC123"
                };

                expandedTextAd.urlCustomParameters = new CustomParameters
                {
                    parameters = new CustomParameter[]
                    {
                        seasonParameter,
                        promoCodeParameter
                    }
                };

                // Specify a list of final URLs. This field cannot be set if URL field is
                // set. This may be specified at ad, criterion and feed item levels.
                expandedTextAd.finalUrls = new string[]
                {
                    "http://www.example.com/cruise/space/",
                    "http://www.example.com/locations/mars/"
                };

                // Specify a list of final mobile URLs. This field cannot be set if URL
                // field is set, or finalUrls is unset. This may be specified at ad,
                // criterion and feed item levels.
                expandedTextAd.finalMobileUrls = new string[]
                {
                    "http://mobile.example.com/cruise/space/",
                    "http://mobile.example.com/locations/mars/"
                };

                AdGroupAd adGroupAd = new AdGroupAd
                {
                    adGroupId = adGroupId,
                    ad = expandedTextAd,

                    // Optional: Set the status.
                    status = AdGroupAdStatus.PAUSED
                };

                // Create the operation.
                AdGroupAdOperation operation = new AdGroupAdOperation
                {
                    @operator = Operator.ADD,
                    operand = adGroupAd
                };

                AdGroupAdReturnValue retVal = null;

                try
                {
                    // Create the ads.
                    retVal = adGroupAdService.mutate(new AdGroupAdOperation[]
                    {
                        operation
                    });

                    // Display the results.
                    if (retVal != null && retVal.value != null)
                    {
                        ExpandedTextAd newExpandedTextAd = retVal.value[0].ad as ExpandedTextAd;

                        Console.WriteLine(
                            "Expanded text ad with ID '{0}' and headline '{1} - {2}' was added.",
                            newExpandedTextAd.id, newExpandedTextAd.headlinePart1,
                            newExpandedTextAd.headlinePart2);

                        Console.WriteLine("Upgraded URL properties:");

                        Console.WriteLine("  Final URLs: {0}",
                            string.Join(", ", newExpandedTextAd.finalUrls));
                        Console.WriteLine("  Final Mobile URLs: {0}",
                            string.Join(", ", newExpandedTextAd.finalMobileUrls));
                        Console.WriteLine("  Tracking URL template: {0}",
                            newExpandedTextAd.trackingUrlTemplate);

                        List<string> parameters = new List<string>();
                        foreach (CustomParameter customParam in newExpandedTextAd
                            .urlCustomParameters.parameters)
                        {
                            parameters.Add(string.Format("{0}={1}", customParam.key,
                                customParam.value));
                        }

                        Console.WriteLine("  Custom parameters: {0}",
                            string.Join(", ", parameters.ToArray()));
                    }
                    else
                    {
                        Console.WriteLine("No expanded text ads were created.");
                    }
                }
                catch (Exception e)
                {
                    throw new System.ApplicationException("Failed to create expanded text ad.", e);
                }
            }
        }
    }
}

Add a Gmail ad to an ad group

// 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 Google.Api.Ads.Common.Util;

using System;

namespace Google.Api.Ads.AdWords.Examples.CSharp.v201809
{
    /// <summary>
    /// This code example adds a Gmail ad to a given ad group. The ad group's
    /// campaign needs to have an AdvertisingChannelType of DISPLAY and
    /// AdvertisingChannelSubType of DISPLAY_GMAIL_AD.
    /// To get ad groups, run GetAdGroups.cs.
    /// </summary>
    public class AddGmailAd : 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)
        {
            AddGmailAd codeExample = new AddGmailAd();
            Console.WriteLine(codeExample.Description);
            try
            {
                long adGroupId = long.Parse("INSERT_ADGROUP_ID_HERE");
                codeExample.Run(new AdWordsUser(), adGroupId);
            }
            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 adds a Gmail ad to a given ad group. The ad group's " +
                    "campaign needs to have an AdvertisingChannelType of DISPLAY and " +
                    "AdvertisingChannelSubType of DISPLAY_GMAIL_AD. To get ad groups, " +
                    "run GetAdGroups.cs.";
            }
        }

        /// <summary>
        /// Runs the code example.
        /// </summary>
        /// <param name="user">The AdWords user.</param>
        /// <param name="adGroupId">Id of the adgroup to which ads are added.</param>
        public void Run(AdWordsUser user, long adGroupId)
        {
            using (AdGroupAdService adGroupAdService =
                (AdGroupAdService) user.GetService(AdWordsService.v201809.AdGroupAdService))
            {
                // This ad format does not allow the creation of an image using the
                // Image.data field. An image must first be created using the
                // MediaService, and Image.mediaId must be populated when creating the
                // ad.
                Image logoImage = new Image
                {
                    mediaId = UploadImage(user, "https://goo.gl/mtt54n").mediaId
                };

                Image marketingImage = new Image
                {
                    mediaId = UploadImage(user, "https://goo.gl/3b9Wfh").mediaId
                };

                GmailTeaser teaser = new GmailTeaser
                {
                    headline = "Dream",
                    description = "Create your own adventure",
                    businessName = "Interplanetary Ships",
                    logoImage = logoImage
                };

                // Creates a Gmail ad.
                GmailAd gmailAd = new GmailAd
                {
                    teaser = teaser,
                    marketingImage = marketingImage,
                    marketingImageHeadline = "Travel",
                    marketingImageDescription = "Take to the skies!",
                    finalUrls = new string[]
                    {
                        "http://www.example.com/"
                    }
                };

                // Creates ad group ad for the Gmail ad.
                AdGroupAd adGroupAd = new AdGroupAd
                {
                    adGroupId = adGroupId,
                    ad = gmailAd,
                    // Optional: Set additional settings.
                    status = AdGroupAdStatus.PAUSED
                };

                // Creates ad group ad operation and add it to the list.
                AdGroupAdOperation operation = new AdGroupAdOperation
                {
                    operand = adGroupAd,
                    @operator = Operator.ADD
                };

                try
                {
                    // Adds a responsive display ad on the server.
                    AdGroupAdReturnValue result = adGroupAdService.mutate(new AdGroupAdOperation[]
                    {
                        operation
                    });

                    if (result == null || result.value == null || result.value.Length == 0)
                    {
                        Console.WriteLine("No Gmail ads were added.");
                        return;
                    }

                    // Prints out some information for each created Gmail ad.
                    foreach (AdGroupAd newAdGroupAd in result.value)
                    {
                        Console.WriteLine("A Gmail ad with ID {0} and headline '{1}' was added.",
                            newAdGroupAd.ad.id, (newAdGroupAd.ad as GmailAd).teaser.headline);
                    }
                }
                catch (Exception e)
                {
                    throw new System.ApplicationException("Failed to add Gmail ads.", e);
                }
            }
        }

        /// <summary>
        /// Uploads an image to the server.
        /// </summary>
        /// <param name="user">The AdWords user.</param>
        /// <param name="url">The URL of image to upload.</param>
        /// <returns>The created image.</returns>
        private static Media UploadImage(AdWordsUser user, string url)
        {
            using (MediaService mediaService =
                (MediaService) user.GetService(AdWordsService.v201809.MediaService))
            {
                Image image = new Image
                {
                    data = MediaUtilities.GetAssetDataFromUrl(url, user.Config),
                    type = MediaMediaType.IMAGE
                };
                return mediaService.upload(new Media[]
                {
                    image
                })[0];
            }
        }
    }
}

Add an HTML 5 ad to an ad group

// 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 Google.Api.Ads.Common.Util;

using System;

namespace Google.Api.Ads.AdWords.Examples.CSharp.v201809
{
    /// <summary>
    /// This code example adds an HTML5 ad to a given ad group. To get ad groups,
    /// run GetAdGroups.cs.
    /// </summary>
    public class AddHtml5Ad : 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)
        {
            AddHtml5Ad codeExample = new AddHtml5Ad();
            Console.WriteLine(codeExample.Description);
            try
            {
                long adGroupId = long.Parse("INSERT_ADGROUP_ID_HERE");
                codeExample.Run(new AdWordsUser(), adGroupId);
            }
            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 adds an HTML5 ad to a given ad group. To get ad groups," +
                    " run GetAdGroups.cs.";
            }
        }

        /// <summary>
        /// Runs the code example.
        /// </summary>
        /// <param name="user">The AdWords user.</param>
        /// <param name="adGroupId">Id of the first adgroup to which ad is added.</param>
        public void Run(AdWordsUser user, long adGroupId)
        {
            using (AdGroupAdService adGroupAdService =
                (AdGroupAdService) user.GetService(AdWordsService.v201809.AdGroupAdService))
            {
                // Create the HTML5 template ad. See
                // https://developers.google.com/adwords/api/docs/guides/template-ads#html5_ads
                // for more details.
                TemplateAd html5Ad = new TemplateAd()
                {
                    name = "Ad for HTML5",
                    templateId = 419,
                    finalUrls = new string[]
                    {
                        "http://example.com/html5"
                    },
                    displayUrl = "www.example.com/html5",
                    dimensions = new Dimensions()
                    {
                        width = 300,
                        height = 250
                    }
                };

                // The HTML5 zip file contains all the HTML, CSS, and images needed for the
                // HTML5 ad. For help on creating an HTML5 zip file, check out Google Web
                // Designer (https://www.google.com/webdesigner/).
                byte[] html5Zip =
                    MediaUtilities.GetAssetDataFromUrl("https://goo.gl/9Y7qI2", user.Config);

                // Create a media bundle containing the zip file with all the HTML5 components.
                MediaBundle mediaBundle = new MediaBundle()
                {
                    // You may also upload an HTML5 zip using MediaService.upload() method
                    // set the mediaId field. See UploadMediaBundle.cs for an example on
                    // how to upload HTML5 zip files.
                    data = html5Zip,
                    entryPoint = "carousel/index.html",
                    type = MediaMediaType.MEDIA_BUNDLE
                };

                // Create the template elements for the ad. You can refer to
                // https://developers.google.com/adwords/api/docs/appendix/templateads
                // for the list of available template fields.
                html5Ad.templateElements = new TemplateElement[]
                {
                    new TemplateElement()
                    {
                        uniqueName = "adData",
                        fields = new TemplateElementField[]
                        {
                            new TemplateElementField()
                            {
                                name = "Custom_layout",
                                fieldMedia = mediaBundle,
                                type = TemplateElementFieldType.MEDIA_BUNDLE
                            },
                            new TemplateElementField()
                            {
                                name = "layout",
                                fieldText = "Custom",
                                type = TemplateElementFieldType.ENUM
                            },
                        },
                    }
                };

                // Create the AdGroupAd.
                AdGroupAd html5AdGroupAd = new AdGroupAd()
                {
                    adGroupId = adGroupId,
                    ad = html5Ad,
                    // Additional properties (non-required).
                    status = AdGroupAdStatus.PAUSED
                };
                AdGroupAdOperation adGroupAdOperation = new AdGroupAdOperation()
                {
                    @operator = Operator.ADD,
                    operand = html5AdGroupAd
                };

                try
                {
                    // Add HTML5 ad.
                    AdGroupAdReturnValue result = adGroupAdService.mutate(new AdGroupAdOperation[]
                    {
                        adGroupAdOperation
                    });

                    // Display results.
                    if (result != null && result.value != null && result.value.Length > 0)
                    {
                        foreach (AdGroupAd adGroupAd in result.value)
                        {
                            Console.WriteLine(
                                "New HTML5 ad with id \"{0}\" and display url \"{1}\" was added.",
                                adGroupAd.ad.id, adGroupAd.ad.displayUrl);
                        }
                    }
                    else
                    {
                        Console.WriteLine("No HTML5 ads were added.");
                    }
                }
                catch (Exception e)
                {
                    throw new System.ApplicationException("Failed to create HTML5 ad.", e);
                }
            }
        }
    }
}

Add a multi-asset responsive display ad to an ad group

// 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 Google.Api.Ads.Common.Util;

using System;

namespace Google.Api.Ads.AdWords.Examples.CSharp.v201809
{
    /// <summary>
    /// This code example adds a responsive display ad (MultiAssetResponsiveDisplayAd)
    /// to an ad group. Image assets are uploaded using AssetService. To get ad groups,
    /// run GetAdGroups.cs.
    /// </summary>
    public class AddMultiAssetResponsiveDisplayAd : 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)
        {
            AddMultiAssetResponsiveDisplayAd codeExample = new AddMultiAssetResponsiveDisplayAd();
            Console.WriteLine(codeExample.Description);
            try
            {
                long adGroupId = long.Parse("INSERT_ADGROUP_ID_HERE");
                codeExample.Run(new AdWordsUser(), adGroupId);
            }
            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 adds a responsive display ad " +
                    "(MultiAssetResponsiveDisplayAd) to an ad group. Image assets are uploaded " +
                    "using AssetService. To get ad groups, run GetAdGroups.cs.";
            }
        }

        /// <summary>
        /// Runs the code example.
        /// </summary>
        /// <param name="user">The AdWords user.</param>
        /// <param name="adGroupId">Id of the ad group to which ads are added.
        /// </param>
        public void Run(AdWordsUser user, long adGroupId)
        {
            using (AdGroupAdService adGroupAdService =
                (AdGroupAdService) user.GetService(AdWordsService.v201809.AdGroupAdService))
            {
                try
                {
                    // Create the ad.
                    MultiAssetResponsiveDisplayAd ad = new MultiAssetResponsiveDisplayAd()
                    {
                        headlines = new AssetLink[]
                        {
                            new AssetLink()
                            {
                                // Text assets can be specified directly in the asset field when
                                // creating the ad.
                                asset = new TextAsset()
                                {
                                    assetText = "Travel to Mars",
                                },
                            },
                            new AssetLink()
                            {
                                asset = new TextAsset()
                                {
                                    assetText = "Travel to Jupiter",
                                },
                            },
                            new AssetLink()
                            {
                                asset = new TextAsset()
                                {
                                    assetText = "Travel to Pluto",
                                },
                            },
                        },
                        descriptions = new AssetLink[]
                        {
                            new AssetLink()
                            {
                                asset = new TextAsset()
                                {
                                    assetText = "Visit the planet in a luxury spaceship.",
                                },
                            },
                            new AssetLink()
                            {
                                asset = new TextAsset()
                                {
                                    assetText = "See the planet in style.",
                                },
                            },
                        },
                        businessName = "Galactic Luxury Cruises",
                        longHeadline = new AssetLink()
                        {
                            asset = new TextAsset()
                            {
                                assetText = "Visit the planet in a luxury spaceship.",
                            },
                        },

                        // This ad format does not allow the creation of an image asset by setting
                        // the asset.imageData field. An image asset must first be created using the
                        // AssetService, and asset.assetId must be populated when creating the ad.
                        marketingImages = new AssetLink[]
                        {
                            new AssetLink()
                            {
                                asset = new ImageAsset()
                                {
                                    assetId = UploadImageAsset(user, "https://goo.gl/3b9Wfh")
                                },
                            }
                        },
                        squareMarketingImages = new AssetLink[]
                        {
                            new AssetLink()
                            {
                                asset = new ImageAsset()
                                {
                                    assetId = UploadImageAsset(user, "https://goo.gl/mtt54n")
                                },
                            }
                        },
                        finalUrls = new string[]
                        {
                            "http://www.example.com"
                        },

                        // Optional: set call to action text.
                        callToActionText = "Shop Now",

                        // Set color settings using hexadecimal values. Set allowFlexibleColor to
                        // false if you want your ads to render by always using your colors
                        // strictly.
                        mainColor = "#0000ff",
                        accentColor = "#ffff00",
                        allowFlexibleColor = false,

                        // Set the format setting that the ad will be served in.
                        formatSetting = DisplayAdFormatSetting.NON_NATIVE,

                        // Optional: Set dynamic display ad settings, composed of landscape logo
                        // image, promotion text, and price prefix.
                        dynamicSettingsPricePrefix = "as low as",
                        dynamicSettingsPromoText = "Free shipping!",
                        logoImages = new AssetLink[]
                        {
                            new AssetLink()
                            {
                                asset = new ImageAsset()
                                {
                                    assetId = UploadImageAsset(user, "https://goo.gl/mtt54n")
                                },
                            }
                        }
                    };

                    // Create the ad group ad.
                    AdGroupAd adGroupAd = new AdGroupAd()
                    {
                        ad = ad,
                        adGroupId = adGroupId
                    };

                    // Create the operation.
                    AdGroupAdOperation operation = new AdGroupAdOperation()
                    {
                        operand = adGroupAd,
                        @operator = Operator.ADD
                    };

                    // Make the mutate request.
                    AdGroupAdReturnValue result = adGroupAdService.mutate(new AdGroupAdOperation[]
                    {
                        operation
                    });

                    // Display results.
                    if (result != null && result.value != null)
                    {
                        foreach (AdGroupAd newAdGroupAd in result.value)
                        {
                            MultiAssetResponsiveDisplayAd newAd =
                                newAdGroupAd.ad as MultiAssetResponsiveDisplayAd;
                            Console.WriteLine(
                                "Responsive display ad with ID '{0}' and long headline '{1}'" +
                                " was added.", newAd.id,
                                (newAd.longHeadline.asset as TextAsset).assetText);
                        }
                    }
                    else
                    {
                        Console.WriteLine("No responsive display ads were created.");
                    }
                }
                catch (Exception e)
                {
                    throw new System.ApplicationException("Failed to create responsive display ad.",
                        e);
                }
            }
        }

        /// <summary>
        /// Uploads the image from the specified <paramref name="url"/>.
        /// </summary>
        /// <param name="user">The AdWords user.</param>
        /// <param name="url">The image URL.</param>
        /// <returns>ID of the uploaded image.</returns>
        private static long UploadImageAsset(AdWordsUser user, string url)
        {
            using (AssetService assetService =
                (AssetService) user.GetService(AdWordsService.v201809.AssetService))
            {
                // Create the image asset.
                ImageAsset imageAsset = new ImageAsset()
                {
                    // Optional: Provide a unique friendly name to identify your asset. If you
                    // specify the assetName field, then both the asset name and the image being
                    // uploaded should be unique, and should not match another ACTIVE asset in this
                    // customer account.
                    // assetName = "Image asset " + ExampleUtilities.GetRandomString(),
                    imageData = MediaUtilities.GetAssetDataFromUrl(url, user.Config),
                };

                // Create the operation.
                AssetOperation operation = new AssetOperation()
                {
                    @operator = Operator.ADD,
                    operand = imageAsset
                };

                // Create the asset and return the ID.
                return assetService.mutate(new AssetOperation[]
                {
                    operation
                }).value[0].assetId;
            }
        }
    }
}

   

Add a responsive display ad

// 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 Google.Api.Ads.Common.Util;

using System;

namespace Google.Api.Ads.AdWords.Examples.CSharp.v201809
{
    /// <summary>
    /// This code example adds an image representing the ad using the MediaService
    /// and then adds a responsive display ad to an ad group. To get ad groups,
    /// run GetAdGroups.cs.
    /// </summary>
    public class AddResponsiveDisplayAd : 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)
        {
            AddResponsiveDisplayAd codeExample = new AddResponsiveDisplayAd();
            Console.WriteLine(codeExample.Description);
            try
            {
                long adGroupId = long.Parse("INSERT_ADGROUP_ID_HERE");
                codeExample.Run(new AdWordsUser(), adGroupId);
            }
            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 adds an image representing the ad using the MediaService " +
                    "and then adds a responsive display ad to an ad group. To get ad groups, " +
                    "run GetAdGroups.cs.";
            }
        }

        /// <summary>
        /// Runs the code example.
        /// </summary>
        /// <param name="user">The AdWords user.</param>
        /// <param name="adGroupId">Id of the ad group to which ads are added.
        /// </param>
        public void Run(AdWordsUser user, long adGroupId)
        {
            using (AdGroupAdService adGroupAdService =
                (AdGroupAdService) user.GetService(AdWordsService.v201809.AdGroupAdService))
            {
                try
                {
                    // Create a responsive display ad.
                    ResponsiveDisplayAd responsiveDisplayAd = new ResponsiveDisplayAd
                    {
                        // This ad format does not allow the creation of an image using the
                        // Image.data field. An image must first be created using the MediaService,
                        // and Image.mediaId must be populated when creating the ad.
                        marketingImage = new Image()
                        {
                            mediaId = UploadImage(user, "https://goo.gl/3b9Wfh")
                        },
                        shortHeadline = "Travel",
                        longHeadline = "Travel the World",
                        description = "Take to the air!",
                        businessName = "Google",
                        finalUrls = new string[]
                        {
                            "http://www.example.com"
                        },

                        // Optional: Create a square marketing image using MediaService, and set it
                        // to the ad.
                        squareMarketingImage = new Image()
                        {
                            mediaId = UploadImage(user, "https://goo.gl/mtt54n"),
                        },

                        // Optional: set call to action text.
                        callToActionText = "Shop Now",

                        // Optional: Set dynamic display ad settings, composed of landscape logo
                        // image, promotion text, and price prefix.
                        dynamicDisplayAdSettings = CreateDynamicDisplayAdSettings(user)
                    };

                    // Whitelisted accounts only: Set color settings using hexadecimal values.
                    // Set allowFlexibleColor to false if you want your ads to render by always
                    // using your colors strictly.

                    // responsiveDisplayAd.mainColor = "#0000ff";
                    // responsiveDisplayAd.accentColor = "#ffff00";
                    // responsiveDisplayAd.allowFlexibleColor = false;

                    // Whitelisted accounts only: Set the format setting that the ad will be
                    // served in.

                    // responsiveDisplayAd.formatSetting = DisplayAdFormatSetting.NON_NATIVE;

                    // Create ad group ad.
                    AdGroupAd adGroupAd = new AdGroupAd()
                    {
                        adGroupId = adGroupId,
                        ad = responsiveDisplayAd,
                        status = AdGroupAdStatus.PAUSED
                    };

                    // Create operation.
                    AdGroupAdOperation operation = new AdGroupAdOperation()
                    {
                        operand = adGroupAd,
                        @operator = Operator.ADD
                    };

                    // Make the mutate request.
                    AdGroupAdReturnValue result = adGroupAdService.mutate(new AdGroupAdOperation[]
                    {
                        operation
                    });

                    // Display results.
                    if (result != null && result.value != null)
                    {
                        foreach (AdGroupAd newAdGroupAd in result.value)
                        {
                            ResponsiveDisplayAd newAd = newAdGroupAd.ad as ResponsiveDisplayAd;
                            Console.WriteLine(
                                "Responsive display ad with ID '{0}' and short headline '{1}'" +
                                " was added.", newAd.id, newAd.shortHeadline);
                        }
                    }
                    else
                    {
                        Console.WriteLine("No responsive display ads were created.");
                    }
                }
                catch (Exception e)
                {
                    throw new System.ApplicationException("Failed to create responsive display ad.",
                        e);
                }
            }

        }

        /// <summary>
        /// Creates the dynamic display ad settings.
        /// </summary>
        /// <param name="user">The AdWords user.</param>
        /// <returns></returns>
        private static DynamicSettings CreateDynamicDisplayAdSettings(AdWordsUser user)
        {
            long logoImageMediaId = UploadImage(user, "https://goo.gl/dEvQeF");
            Image logo = new Image()
            {
                mediaId = logoImageMediaId
            };

            return new DynamicSettings()
            {
                landscapeLogoImage = logo,
                pricePrefix = "as low as",
                promoText = "Free shipping!"
            };
        }

        /// <summary>
        /// Uploads the image from the specified <paramref name="url"/>.
        /// </summary>
        /// <param name="user">The AdWords user.</param>
        /// <param name="url">The image URL.</param>
        /// <returns>ID of the uploaded image.</returns>
        private static long UploadImage(AdWordsUser user, string url)
        {
            using (MediaService mediaService =
                (MediaService) user.GetService(AdWordsService.v201809.MediaService))
            {
                // Create the image.
                Image image = new Image()
                {
                    data = MediaUtilities.GetAssetDataFromUrl(url, user.Config),
                    type = MediaMediaType.IMAGE
                };

                // Upload the image and return the ID.
                return mediaService.upload(new Media[]
                {
                    image
                })[0].mediaId;
            }
        }
    }
}

   

Add a Shopping dynamic remarketing campaign

// 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 Google.Api.Ads.Common.Util;

using System;

namespace Google.Api.Ads.AdWords.Examples.CSharp.v201809
{
    /// <summary>
    /// This code example adds a Shopping dynamic remarketing campaign for the Display Network
    /// via the following steps:
    /// <list type="bullet">
    ///   <item>
    ///     <description>Creates a new Display Network campaign.</description>
    ///   </item>
    ///   <item>
    ///     <description>Links the campaign with Merchant Center.</description>
    ///   </item>
    ///   <item>
    ///     <description>Links the user list to the ad group.</description>
    ///   </item>
    ///   <item>
    ///     <description>Creates a responsive display ad to render the dynamic text.</description>
    ///   </item>
    /// </list>
    /// </summary>
    public class AddShoppingDynamicRemarketingCampaign : 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)
        {
            AddShoppingDynamicRemarketingCampaign codeExample =
                new AddShoppingDynamicRemarketingCampaign();
            Console.WriteLine(codeExample.Description);
            try
            {
                // The ID of the merchant center account from which to source product feed data.
                long merchantId = long.Parse("INSERT_MERCHANT_CENTER_ID_HERE");

                // The ID of a shared budget to associate with the campaign.
                long budgetId = long.Parse("INSERT_BUDGET_ID_HERE");

                // The ID of a user list to target.
                long userListId = long.Parse("INSERT_USER_LIST_ID_HERE");
                codeExample.Run(new AdWordsUser(), merchantId, budgetId, userListId);
            }
            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 adds a Shopping dynamic remarketing campaign for the " +
                    "Display Network via the following steps:\n" +
                    "*  Creates a new Display Network campaign.\n" +
                    "*  Links the campaign with Merchant Center.\n" +
                    "*  Links the user list to the ad group.\n" +
                    "*  Creates a responsive display ad to render the dynamic text.";
            }
        }

        /// <summary>
        /// Runs the code example.
        /// </summary>
        /// <param name="user">The AdWords user.</param>
        /// <param name="merchantId">The ID of the merchant center account from which to source
        /// product feed data.</param>
        /// <param name="budgetId">The ID of a shared budget to associate with the campaign.</param>
        /// <param name="userListId">The ID of a user list to target.</param>
        public void Run(AdWordsUser user, long merchantId, long budgetId, long userListId)
        {
            try
            {
                Campaign campaign = CreateCampaign(user, merchantId, budgetId);
                Console.WriteLine("Campaign with name '{0}' and ID {1} was added.", campaign.name,
                    campaign.id);

                AdGroup adGroup = CreateAdGroup(user, campaign);
                Console.WriteLine("Ad group with name '{0}' and ID {1} was added.", adGroup.name,
                    adGroup.id);

                AdGroupAd adGroupAd = CreateAd(user, adGroup);
                Console.WriteLine("Responsive display ad with ID {0} was added.", adGroupAd.ad.id);

                AttachUserList(user, adGroup, userListId);
                Console.WriteLine("User list with ID {0} was attached to ad group with ID {1}.",
                    userListId, adGroup.id);
            }
            catch (Exception e)
            {
                throw new System.ApplicationException(
                    "Failed to create Shopping dynamic remarketing " +
                    "campaign for the Display Network.", e);
            }
        }

        /// <summary>
        /// Creates a Shopping dynamic remarketing campaign object (not including ad group level and
        /// below). This creates a Display campaign with the merchant center feed attached.
        /// Merchant Center is used for the product information in combination with a user list
        /// which contains hits with <code>ecomm_prodid</code> specified. See
        /// <a href="https://developers.google.com/adwords-remarketing-tag/parameters#retail">
        /// the guide</a> for more detail.
        /// </summary>
        /// <param name="user">The AdWords user.</param>
        /// <param name="merchantId">The ID of the Merchant Center account.</param>
        /// <param name="budgetId">The ID of the budget to use for the campaign.</param>
        /// <returns>The campaign that was created.</returns>
        private static Campaign CreateCampaign(AdWordsUser user, long merchantId, long budgetId)
        {
            using (CampaignService campaignService =
                (CampaignService) user.GetService(AdWordsService.v201809.CampaignService))
            {
                Campaign campaign = new Campaign
                {
                    name = "Shopping campaign #" + ExampleUtilities.GetRandomString(),
                    // Dynamic remarketing campaigns are only available on the Google Display
                    // Network.
                    advertisingChannelType = AdvertisingChannelType.DISPLAY,
                    status = CampaignStatus.PAUSED
                };

                Budget budget = new Budget
                {
                    budgetId = budgetId
                };
                campaign.budget = budget;

                // This example uses a Manual CPC bidding strategy, but you should select the
                // strategy that best aligns with your sales goals. More details here:
                //   https://support.google.com/adwords/answer/2472725
                BiddingStrategyConfiguration biddingStrategyConfiguration =
                    new BiddingStrategyConfiguration
                    {
                        biddingStrategyType = BiddingStrategyType.MANUAL_CPC
                    };
                campaign.biddingStrategyConfiguration = biddingStrategyConfiguration;

                ShoppingSetting setting = new ShoppingSetting
                {
                    // Campaigns with numerically higher priorities take precedence over those with
                    // lower priorities.
                    campaignPriority = 0,

                    // Set the Merchant Center account ID from which to source products.
                    merchantId = merchantId,

                    // Display Network campaigns do not support partition by country. The only
                    // supported value is "ZZ". This signals that products from all countries are
                    // available in the campaign. The actual products which serve are based on the
                    // products tagged in the user list entry.
                    salesCountry = "ZZ",

                    // Optional: Enable local inventory ads (items for sale in physical stores.)
                    enableLocal = true
                };

                campaign.settings = new Setting[]
                {
                    setting
                };

                CampaignOperation op = new CampaignOperation
                {
                    operand = campaign,
                    @operator = Operator.ADD
                };

                CampaignReturnValue result = campaignService.mutate(new CampaignOperation[]
                {
                    op
                });
                return result.value[0];
            }
        }

        /// <summary>
        /// Creates an ad group in the specified campaign.
        /// </summary>
        /// <param name="user">The AdWords user.</param>
        /// <param name="campaign">The campaign to which the ad group should be attached.</param>
        /// <returns>The ad group that was created.</returns>
        private static AdGroup CreateAdGroup(AdWordsUser user, Campaign campaign)
        {
            using (AdGroupService adGroupService =
                (AdGroupService) user.GetService(AdWordsService.v201809.AdGroupService))
            {
                AdGroup group = new AdGroup
                {
                    name = "Dynamic remarketing ad group",
                    campaignId = campaign.id,
                    status = AdGroupStatus.ENABLED
                };

                AdGroupOperation op = new AdGroupOperation
                {
                    operand = group,
                    @operator = Operator.ADD
                };
                AdGroupReturnValue result = adGroupService.mutate(new AdGroupOperation[]
                {
                    op
                });
                return result.value[0];
            }
        }

        /// <summary>
        /// Attach a user list to an ad group. The user list provides positive targeting and feed
        /// information to drive the dynamic content of the ad.
        /// </summary>
        /// <param name="user">The user.</param>
        /// <param name="adGroup">The ad group which will have the user list attached.</param>
        /// <param name="userListId">The user list to use for targeting and dynamic content.</param>
        /// <remarks>User lists must be attached at the ad group level for positive targeting in
        /// Shopping dynamic remarketing campaigns.</remarks>
        private static void AttachUserList(AdWordsUser user, AdGroup adGroup, long userListId)
        {
            using (AdGroupCriterionService adGroupCriterionService =
                (AdGroupCriterionService) user.GetService(AdWordsService.v201809
                    .AdGroupCriterionService))
            {
                CriterionUserList userList = new CriterionUserList
                {
                    userListId = userListId
                };
                BiddableAdGroupCriterion adGroupCriterion = new BiddableAdGroupCriterion
                {
                    criterion = userList,
                    adGroupId = adGroup.id
                };

                AdGroupCriterionOperation op = new AdGroupCriterionOperation
                {
                    operand = adGroupCriterion,
                    @operator = Operator.ADD
                };

                adGroupCriterionService.mutate(new AdGroupCriterionOperation[]
                {
                    op
                });
            }
        }

        /// <summary>
        /// Creates an ad for serving dynamic content in a remarketing campaign.
        /// </summary>
        /// <param name="user">The AdWords user.</param>
        /// <param name="adGroup">The ad group under which to create the ad.</param>
        /// <returns>The ad that was created.</returns>
        private static AdGroupAd CreateAd(AdWordsUser user, AdGroup adGroup)
        {
            using (AdGroupAdService adService =
                (AdGroupAdService) user.GetService(AdWordsService.v201809.AdGroupAdService))
            {
                ResponsiveDisplayAd ad = new ResponsiveDisplayAd
                {
                    // This ad format does not allow the creation of an image using the
                    // Image.data field. An image must first be created using the MediaService,
                    // and Image.mediaId must be populated when creating the ad.
                    marketingImage = UploadImage(user, "https://goo.gl/3b9Wfh"),

                    shortHeadline = "Travel",
                    longHeadline = "Travel the World",
                    description = "Take to the air!",
                    businessName = "Interplanetary Cruises",
                    finalUrls = new string[]
                    {
                        "http://www.example.com/"
                    },

                    // Optional: Call to action text.
                    // Valid texts: https://support.google.com/adwords/answer/7005917
                    callToActionText = "Apply Now",

                    // Optional: Set dynamic display ad settings, composed of landscape logo
                    // image, promotion text, and price prefix.
                    dynamicDisplayAdSettings = CreateDynamicDisplayAdSettings(user),

                    // Optional: Create a logo image and set it to the ad.
                    logoImage = UploadImage(user, "https://goo.gl/mtt54n"),

                    // Optional: Create a square marketing image and set it to the ad.
                    squareMarketingImage = UploadImage(user, "https://goo.gl/mtt54n")
                };

                // Whitelisted accounts only: Set color settings using hexadecimal values.
                // Set allowFlexibleColor to false if you want your ads to render by always
                // using your colors strictly.
                // ad.mainColor = "#0000ff";
                // ad.accentColor = "#ffff00";
                // ad.allowFlexibleColor = false;

                // Whitelisted accounts only: Set the format setting that the ad will be
                // served in.
                // ad.formatSetting = DisplayAdFormatSetting.NON_NATIVE;

                AdGroupAd adGroupAd = new AdGroupAd
                {
                    ad = ad,
                    adGroupId = adGroup.id
                };

                AdGroupAdOperation op = new AdGroupAdOperation
                {
                    operand = adGroupAd,
                    @operator = Operator.ADD
                };

                AdGroupAdReturnValue result = adService.mutate(new AdGroupAdOperation[]
                {
                    op
                });
                return result.value[0];
            }
        }

        /// <summary>
        /// Creates the additional content (images, promo text, etc.) supported by dynamic ads.
        /// </summary>
        /// <param name="user">The AdWords user.</param>
        /// <returns>The DynamicSettings object to be used.</returns>
        private static DynamicSettings CreateDynamicDisplayAdSettings(AdWordsUser user)
        {
            Image logo = UploadImage(user, "https://goo.gl/dEvQeF");

            DynamicSettings dynamicSettings = new DynamicSettings
            {
                landscapeLogoImage = logo,
                pricePrefix = "as low as",
                promoText = "Free shipping!"
            };
            return dynamicSettings;
        }

        /// <summary>
        /// Uploads the image from the specified <paramref name="url"/>.
        /// </summary>
        /// <param name="user">The AdWords user.</param>
        /// <param name="url">The image URL.</param>
        /// <returns>ID of the uploaded image.</returns>
        private static Image UploadImage(AdWordsUser user, string url)
        {
            using (MediaService mediaService =
                (MediaService) user.GetService(AdWordsService.v201809.MediaService))
            {
                // Create the image.
                Image image = new Image()
                {
                    data = MediaUtilities.GetAssetDataFromUrl(url, user.Config),
                    type = MediaMediaType.IMAGE
                };

                // Upload the image and return the ID.
                return (Image) mediaService.upload(new Media[]
                {
                    image
                })[0];
            }
        }
    }
}

Add a universal app campaign

// 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;
using System.Collections.Generic;

namespace Google.Api.Ads.AdWords.Examples.CSharp.v201809
{
    /// <summary>
    /// This code example adds a universal app campaign. To get campaigns, run GetCampaigns.cs.
    /// To upload image assets for this campaign, use UploadImage.cs.
    /// </summary>
    public class AddUniversalAppCampaign : 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)
        {
            AddUniversalAppCampaign codeExample = new AddUniversalAppCampaign();
            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 adds a universal app campaign. To get campaigns, " +
                    "run GetCampaigns.cs. To upload image assets for this campaign, " +
                    "use UploadImage.cs.";
            }
        }

        /// <summary>
        /// Runs the code example.
        /// </summary>
        /// <param name="user">The AdWords user.</param>
        public void Run(AdWordsUser user)
        {
            using (CampaignService campaignService =
                (CampaignService) user.GetService(AdWordsService.v201809.CampaignService))
            {
                // Create the campaign.
                Campaign campaign = new Campaign
                {
                    name = "Interplanetary Cruise App #" + ExampleUtilities.GetRandomString(),

                    // Recommendation: Set the campaign to PAUSED when creating it to prevent
                    // the ads from immediately serving. Set to ENABLED once you've added
                    // targeting and the ads are ready to serve.
                    status = CampaignStatus.PAUSED,

                    // Set the advertising channel and subchannel types for universal app campaigns.
                    advertisingChannelType = AdvertisingChannelType.MULTI_CHANNEL,
                    advertisingChannelSubType = AdvertisingChannelSubType.UNIVERSAL_APP_CAMPAIGN
                };

                // Set the campaign's bidding strategy. Universal app campaigns
                // only support TARGET_CPA bidding strategy.
                BiddingStrategyConfiguration biddingConfig = new BiddingStrategyConfiguration
                {
                    biddingStrategyType = BiddingStrategyType.TARGET_CPA
                };

                // Set the target CPA to $1 / app install.
                TargetCpaBiddingScheme biddingScheme = new TargetCpaBiddingScheme
                {
                    targetCpa = new Money
                    {
                        microAmount = 1000000
                    }
                };

                biddingConfig.biddingScheme = biddingScheme;
                campaign.biddingStrategyConfiguration = biddingConfig;

                // Set the campaign's budget.
                campaign.budget = new Budget
                {
                    budgetId = CreateBudget(user).budgetId
                };

                // Optional: Set the start date.
                campaign.startDate = DateTime.Now.AddDays(1).ToString("yyyyMMdd");

                // Optional: Set the end date.
                campaign.endDate = DateTime.Now.AddYears(1).ToString("yyyyMMdd");

                // Set the campaign's assets and ad text ideas. These values will be used to
                // generate ads.
                UniversalAppCampaignSetting universalAppSetting = new UniversalAppCampaignSetting
                {
                    appId = "com.labpixies.colordrips",
                    appVendor = MobileApplicationVendor.VENDOR_GOOGLE_MARKET,
                    description1 = "A cool puzzle game",
                    description2 = "Remove connected blocks",
                    description3 = "3 difficulty levels",
                    description4 = "4 colorful fun skins",

                    // Optional: You can set up to 20 image assets for your campaign.
                    // See UploadImage.cs for an example on how to upload images.
                    //
                    // universalAppSetting.imageMediaIds =
                    //     new long[] { INSERT_IMAGE_MEDIA_ID_HERE };

                    // Optimize this campaign for getting new users for your app.
                    universalAppBiddingStrategyGoalType = UniversalAppBiddingStrategyGoalType
                        .OPTIMIZE_FOR_INSTALL_CONVERSION_VOLUME
                };

                // Optional: If you select the OPTIMIZE_FOR_IN_APP_CONVERSION_VOLUME goal
                // type, then also specify your in-app conversion types so AdWords can
                // focus your campaign on people who are most likely to complete the
                // corresponding in-app actions.
                // Conversion type IDs can be retrieved using ConversionTrackerService.get.
                //
                // campaign.selectiveOptimization = new SelectiveOptimization();
                // campaign.selectiveOptimization.conversionTypeIds = new long[]
                //     {
                //         INSERT_CONVERSION_TYPE_ID_1_HERE,
                //         INSERT_CONVERSION_TYPE_ID_2_HERE
                //     };

                // Optional: Set the campaign settings for Advanced location options.
                GeoTargetTypeSetting geoSetting = new GeoTargetTypeSetting
                {
                    positiveGeoTargetType =
                        GeoTargetTypeSettingPositiveGeoTargetType.LOCATION_OF_PRESENCE,
                    negativeGeoTargetType = GeoTargetTypeSettingNegativeGeoTargetType.DONT_CARE
                };

                campaign.settings = new Setting[]
                {
                    universalAppSetting,
                    geoSetting
                };

                // Create the operation.
                CampaignOperation operation = new CampaignOperation
                {
                    @operator = Operator.ADD,
                    operand = campaign
                };

                try
                {
                    // Add the campaign.
                    CampaignReturnValue retVal = campaignService.mutate(new CampaignOperation[]
                    {
                        operation
                    });

                    // Display the results.
                    if (retVal != null && retVal.value != null && retVal.value.Length > 0)
                    {
                        foreach (Campaign newCampaign in retVal.value)
                        {
                            Console.WriteLine(
                                "Universal app campaign with name = '{0}' and id = '{1}' " +
                                "was added.", newCampaign.name, newCampaign.id);

                            // Optional: Set the campaign's location and language targeting.
                            // No other targeting criteria can be used for universal app campaigns.
                            SetCampaignTargetingCriteria(user, newCampaign);
                        }
                    }
                    else
                    {
                        Console.WriteLine("No universal app campaigns were added.");
                    }
                }
                catch (Exception e)
                {
                    throw new System.ApplicationException("Failed to add universal app campaigns.",
                        e);
                }
            }

        }

        /// <summary>
        /// Creates the budget for the campaign.
        /// </summary>
        /// <param name="user">The AdWords user.</param>
        /// <returns>The budget.</returns>
        private Budget CreateBudget(AdWordsUser user)
        {
            // Get the BudgetService.
            using (BudgetService budgetService =
                (BudgetService) user.GetService(AdWordsService.v201809.BudgetService))
            {
                // Create the campaign budget.
                Budget budget = new Budget
                {
                    name =
                        "Interplanetary Cruise App Budget #" + ExampleUtilities.GetRandomString(),
                    deliveryMethod = BudgetBudgetDeliveryMethod.STANDARD,
                    amount = new Money
                    {
                        microAmount = 5000000
                    },

                    // Universal app campaigns don't support shared budgets.
                    isExplicitlyShared = false
                };

                BudgetOperation budgetOperation = new BudgetOperation
                {
                    @operator = Operator.ADD,
                    operand = budget
                };

                BudgetReturnValue budgetRetval = budgetService.mutate(new BudgetOperation[]
                {
                    budgetOperation
                });
                Budget newBudget = budgetRetval.value[0];

                Console.WriteLine("Budget with ID = '{0}' and name = '{1}' was created.",
                    newBudget.budgetId, newBudget.name);
                return newBudget;
            }
        }

        /// <summary>
        /// Sets the campaign's targeting criteria.
        /// </summary>
        /// <param name="user">The AdWords user.</param>
        /// <param name="campaign">The campaign for which targeting criteria is
        /// created.</param>
        private void SetCampaignTargetingCriteria(AdWordsUser user, Campaign campaign)
        {
            using (CampaignCriterionService campaignCriterionService =
                (CampaignCriterionService) user.GetService(AdWordsService.v201809
                    .CampaignCriterionService))
            {
                // Create locations. The IDs can be found in the documentation or
                // retrieved with the LocationCriterionService.
                Location california = new Location()
                {
                    id = 21137L
                };

                Location mexico = new Location()
                {
                    id = 2484L
                };

                // Create languages. The IDs can be found in the documentation or
                // retrieved with the ConstantDataService.
                Language english = new Language()
                {
                    id = 1000L
                };

                Language spanish = new Language()
                {
                    id = 1003L
                };

                List<Criterion> criteria = new List<Criterion>()
                {
                    california,
                    mexico,
                    english,
                    spanish
                };

                // Create operations to add each of the criteria above.
                List<CampaignCriterionOperation>
                    operations = new List<CampaignCriterionOperation>();
                foreach (Criterion criterion in criteria)
                {
                    CampaignCriterionOperation operation = new CampaignCriterionOperation()
                    {
                        operand = new CampaignCriterion()
                        {
                            campaignId = campaign.id,
                            criterion = criterion
                        },
                        @operator = Operator.ADD
                    };

                    operations.Add(operation);
                }

                // Set the campaign targets.
                CampaignCriterionReturnValue retVal =
                    campaignCriterionService.mutate(operations.ToArray());

                if (retVal != null && retVal.value != null)
                {
                    // Display the added campaign targets.
                    foreach (CampaignCriterion criterion in retVal.value)
                    {
                        Console.WriteLine("Campaign criteria of type '{0}' and id '{1}' was added.",
                            criterion.criterion.CriterionType, criterion.criterion.id);
                    }
                }
            }

        }
    }
}

Create a negative broad match keywords list and attach it to a campaign

// 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;
using System.Collections.Generic;

namespace Google.Api.Ads.AdWords.Examples.CSharp.v201809
{
    /// <summary>
    /// This code example creates a shared keyword list, adds keywords to the list
    /// and attaches it to an existing campaign. To get the list of campaigns,
    /// run GetCampaigns.cs.
    /// </summary>
    public class CreateAndAttachSharedKeywordSet : 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)
        {
            CreateAndAttachSharedKeywordSet codeExample = new CreateAndAttachSharedKeywordSet();
            Console.WriteLine(codeExample.Description);
            try
            {
                long campaignId = long.Parse("INSERT_CAMPAIGN_ID_HERE");
                codeExample.Run(new AdWordsUser(), campaignId);
            }
            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 creates a shared keyword list, adds keywords to the list " +
                    "and attaches it to an existing campaign. To get the list of campaigns, run " +
                    "GetCampaigns.cs.";
            }
        }

        /// <summary>
        /// Runs the code example.
        /// </summary>
        /// <param name="user">The AdWords user.</param>
        /// <param name="campaignId">Id of the campaign to which keywords are added.</param>
        public void Run(AdWordsUser user, long campaignId)
        {
            try
            {
                // Create a shared set.
                SharedSet sharedSet = CreateSharedKeywordSet(user);

                Console.WriteLine(
                    "Shared set with id = {0}, name = {1}, type = {2}, status = {3} " +
                    "was created.", sharedSet.sharedSetId, sharedSet.name, sharedSet.type,
                    sharedSet.status);

                // Add new keywords to the shared set.
                string[] keywordTexts = new string[]
                {
                    "mars cruise",
                    "mars hotels"
                };
                SharedCriterion[] sharedCriteria =
                    AddKeywordsToSharedSet(user, sharedSet.sharedSetId, keywordTexts);
                foreach (SharedCriterion sharedCriterion in sharedCriteria)
                {
                    Keyword keyword = sharedCriterion.criterion as Keyword;
                    Console.WriteLine(
                        "Added keyword with id = {0}, text = {1}, matchtype = {2} to " +
                        "shared set with id = {3}.", keyword.id, keyword.text, keyword.matchType,
                        sharedSet.sharedSetId);
                }

                // Attach the shared set to the campaign.
                CampaignSharedSet attachedSharedSet =
                    AttachSharedSetToCampaign(user, campaignId, sharedSet.sharedSetId);

                Console.WriteLine("Attached shared set with id = {0} to campaign id {1}.",
                    attachedSharedSet.sharedSetId, attachedSharedSet.campaignId);
            }
            catch (Exception e)
            {
                throw new System.ApplicationException(
                    "Failed to create shared keyword set and attach " + "it to a campaign.", e);
            }
        }

        /// <summary>
        /// Create a shared keyword set.
        /// </summary>
        /// <param name="user">The AdWords user.</param>
        /// <returns>The shared set.</returns>
        public SharedSet CreateSharedKeywordSet(AdWordsUser user)
        {
            using (SharedSetService sharedSetService =
                (SharedSetService) user.GetService(AdWordsService.v201809.SharedSetService))
            {
                SharedSetOperation operation = new SharedSetOperation
                {
                    @operator = Operator.ADD
                };
                SharedSet sharedSet = new SharedSet
                {
                    name = "API Negative keyword list - " + ExampleUtilities.GetRandomString(),
                    type = SharedSetType.NEGATIVE_KEYWORDS
                };
                operation.operand = sharedSet;

                SharedSetReturnValue retval = sharedSetService.mutate(new SharedSetOperation[]
                {
                    operation
                });
                return retval.value[0];
            }
        }

        /// <summary>
        /// Adds a set of keywords to a shared set.
        /// </summary>
        /// <param name="user">The AdWords user.</param>
        /// <param name="sharedSetId">The shared set id.</param>
        /// <param name="keywordTexts">The keywords to be added to the shared set.</param>
        /// <returns>The newly added set of shared criteria.</returns>
        public SharedCriterion[] AddKeywordsToSharedSet(AdWordsUser user, long sharedSetId,
            string[] keywordTexts)
        {
            using (SharedCriterionService sharedCriterionService =
                (SharedCriterionService) user.GetService(AdWordsService.v201809
                    .SharedCriterionService))
            {
                List<SharedCriterionOperation> operations = new List<SharedCriterionOperation>();
                foreach (string keywordText in keywordTexts)
                {
                    Keyword keyword = new Keyword
                    {
                        text = keywordText,
                        matchType = KeywordMatchType.BROAD
                    };

                    SharedCriterion sharedCriterion = new SharedCriterion
                    {
                        criterion = keyword,
                        negative = true,
                        sharedSetId = sharedSetId
                    };
                    SharedCriterionOperation operation = new SharedCriterionOperation
                    {
                        @operator = Operator.ADD,
                        operand = sharedCriterion
                    };
                    operations.Add(operation);
                }

                SharedCriterionReturnValue retval =
                    sharedCriterionService.mutate(operations.ToArray());
                return retval.value;
            }
        }

        /// <summary>
        /// Attaches a shared set to a campaign.
        /// </summary>
        /// <param name="user">The AdWords user.</param>
        /// <param name="campaignId">The campaign id.</param>
        /// <param name="sharedSetId">The shared set id.</param>
        /// <returns>A CampaignSharedSet object that represents a binding between
        /// the specified campaign and the shared set.</returns>
        public CampaignSharedSet AttachSharedSetToCampaign(AdWordsUser user, long campaignId,
            long sharedSetId)
        {
            using (CampaignSharedSetService campaignSharedSetService =
                (CampaignSharedSetService) user.GetService(AdWordsService.v201809
                    .CampaignSharedSetService))
            {
                CampaignSharedSet campaignSharedSet = new CampaignSharedSet
                {
                    campaignId = campaignId,
                    sharedSetId = sharedSetId
                };

                CampaignSharedSetOperation operation = new CampaignSharedSetOperation
                {
                    @operator = Operator.ADD,
                    operand = campaignSharedSet
                };

                CampaignSharedSetReturnValue retval = campaignSharedSetService.mutate(
                    new CampaignSharedSetOperation[]
                    {
                        operation
                    });
                return retval.value[0];
            }
        }
    }
}

Find and remove shared sets and shared set criteria

// 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;
using System.Collections.Generic;

namespace Google.Api.Ads.AdWords.Examples.CSharp.v201809
{
    /// <summary>
    /// This code example demonstrates how to find and remove shared sets and
    /// shared set criteria.
    /// </summary>
    public class FindAndRemoveCriteriaFromSharedSet : ExampleBase
    {
        /// <summary>
        /// Returns a description about the code example.
        /// </summary>
        public override string Description
        {
            get
            {
                return "This code example demonstrates how to find and remove shared sets and " +
                    "shared set criteria.";
            }
        }

        /// <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)
        {
            FindAndRemoveCriteriaFromSharedSet codeExample =
                new FindAndRemoveCriteriaFromSharedSet();
            Console.WriteLine(codeExample.Description);
            try
            {
                long campaignId = long.Parse("INSERT_CAMPAIGN_ID_HERE");
                codeExample.Run(new AdWordsUser(), campaignId);
            }
            catch (Exception e)
            {
                Console.WriteLine("An exception occurred while running this code example. {0}",
                    ExampleUtilities.FormatException(e));
            }
        }

        /// <summary>
        /// Runs the code example.
        /// </summary>
        /// <param name="user">The AdWords user.</param>
        /// <param name="campaignId">Id of the campaign from which items shared
        /// criteria are removed.</param>
        public void Run(AdWordsUser user, long campaignId)
        {
            // Get the list of shared sets that are attached to the campaign.
            List<string> sharedSetIds = GetSharedSetIds(user, campaignId);

            // Get the shared criteria in those shared sets.
            List<SharedCriterion> sharedCriteria = GetSharedCriteria(user, sharedSetIds);

            // Remove the shared criteria from the shared sets.
            RemoveSharedCriteria(user, sharedCriteria);
        }

        /// <summary>
        /// Gets the shared set IDs associated with a campaign.
        /// </summary>
        /// <param name="user">The user that owns the campaign.</param>
        /// <param name="campaignId">The campaign identifier.</param>
        /// <returns>The list of shared set IDs associated with the campaign.</returns>
        private List<string> GetSharedSetIds(AdWordsUser user, long campaignId)
        {
            using (CampaignSharedSetService campaignSharedSetService =
                (CampaignSharedSetService) user.GetService(AdWordsService.v201809
                    .CampaignSharedSetService))
            {
                Selector selector = new Selector()
                {
                    fields = new string[]
                    {
                        CampaignSharedSet.Fields.SharedSetId,
                        CampaignSharedSet.Fields.CampaignId,
                        CampaignSharedSet.Fields.SharedSetName,
                        CampaignSharedSet.Fields.SharedSetType
                    },
                    predicates = new Predicate[]
                    {
                        Predicate.Equals(CampaignSharedSet.Fields.CampaignId, campaignId),
                        Predicate.In(CampaignSharedSet.Fields.SharedSetType, new string[]
                        {
                            SharedSetType.NEGATIVE_KEYWORDS.ToString()
                        }),
                    },
                    paging = Paging.Default,
                };

                List<string> sharedSetIds = new List<string>();
                CampaignSharedSetPage page = new CampaignSharedSetPage();

                try
                {
                    do
                    {
                        // Get the campaigns.
                        page = campaignSharedSetService.get(selector);

                        // Display the results.
                        if (page != null && page.entries != null)
                        {
                            int i = selector.paging.startIndex;
                            foreach (CampaignSharedSet campaignSharedSet in page.entries)
                            {
                                sharedSetIds.Add(campaignSharedSet.sharedSetId.ToString());
                                Console.WriteLine(
                                    "{0}) Campaign shared set ID {1} and name '{2}' found for " +
                                    "campaign ID {3}.\n", i + 1, campaignSharedSet.sharedSetId,
                                    campaignSharedSet.sharedSetName, campaignSharedSet.campaignId);
                                i++;
                            }
                        }

                        selector.paging.IncreaseOffset();
                    } while (selector.paging.startIndex < page.totalNumEntries);

                    return sharedSetIds;
                }
                catch (Exception e)
                {
                    throw new Exception("Failed to get shared set ids for campaign.", e);
                }
            }
        }

        /// <summary>
        /// Gets the shared criteria in a shared set.
        /// </summary>
        /// <param name="user">The user that owns the shared set.</param>
        /// <param name="sharedSetIds">The shared criteria IDs.</param>
        /// <returns>The list of shared criteria.</returns>
        private List<SharedCriterion> GetSharedCriteria(AdWordsUser user, List<string> sharedSetIds)
        {
            using (SharedCriterionService sharedCriterionService =
                (SharedCriterionService) user.GetService(AdWordsService.v201809
                    .SharedCriterionService))
            {
                Selector selector = new Selector()
                {
                    fields = new string[]
                    {
                        SharedSet.Fields.SharedSetId,
                        Criterion.Fields.Id,
                        Keyword.Fields.KeywordText,
                        Keyword.Fields.KeywordMatchType,
                        Placement.Fields.PlacementUrl
                    },
                    predicates = new Predicate[]
                    {
                        Predicate.In(SharedSet.Fields.SharedSetId, sharedSetIds)
                    },
                    paging = Paging.Default
                };

                List<SharedCriterion> sharedCriteria = new List<SharedCriterion>();
                SharedCriterionPage page = new SharedCriterionPage();

                try
                {
                    do
                    {
                        // Get the campaigns.
                        page = sharedCriterionService.get(selector);

                        // Display the results.
                        if (page != null && page.entries != null)
                        {
                            int i = selector.paging.startIndex;
                            foreach (SharedCriterion sharedCriterion in page.entries)
                            {
                                switch (sharedCriterion.criterion.type)
                                {
                                    case CriterionType.KEYWORD:
                                        Keyword keyword = (Keyword) sharedCriterion.criterion;
                                        Console.WriteLine(
                                            "{0}) Shared negative keyword with ID {1} and " +
                                            "text '{2}' was found.", i + 1, keyword.id, 
                                            keyword.text);
                                        break;

                                    case CriterionType.PLACEMENT:
                                        Placement placement = (Placement) sharedCriterion.criterion;
                                        Console.WriteLine(
                                            "{0}) Shared negative placement with ID {1} and " +
                                            "URL '{2}' was found.", i + 1, placement.id, 
                                            placement.url);
                                        break;

                                    default:
                                        Console.WriteLine(
                                            "{0}) Shared criteria with ID {1} was found.", i + 1,
                                            sharedCriterion.criterion.id);
                                        break;
                                }

                                i++;
                                sharedCriteria.Add(sharedCriterion);
                            }
                        }

                        selector.paging.IncreaseOffset();
                    } while (selector.paging.startIndex < page.totalNumEntries);

                    return sharedCriteria;
                }
                catch (Exception e)
                {
                    throw new Exception("Failed to get shared criteria.", e);
                }
            }
        }

        /// <summary>
        /// Removes a list of shared criteria.
        /// </summary>
        /// <param name="user">The user that owns the shared criteria.</param>
        /// <param name="sharedCriteria">The list shared criteria to be removed.</param>
        private void RemoveSharedCriteria(AdWordsUser user, List<SharedCriterion> sharedCriteria)
        {
            if (sharedCriteria.Count == 0)
            {
                Console.WriteLine("No shared criteria to remove.");
                return;
            }

            using (SharedCriterionService sharedCriterionService =
                (SharedCriterionService) user.GetService(AdWordsService.v201809
                    .SharedCriterionService))
            {
                List<SharedCriterionOperation> operations = new List<SharedCriterionOperation>();

                foreach (SharedCriterion sharedCriterion in sharedCriteria)
                {
                    operations.Add(new SharedCriterionOperation()
                    {
                        @operator = Operator.REMOVE,
                        operand = new SharedCriterion()
                        {
                            sharedSetId = sharedCriterion.sharedSetId,
                            criterion = new Criterion()
                            {
                                id = sharedCriterion.criterion.id
                            }
                        }
                    });
                }

                try
                {
                    SharedCriterionReturnValue sharedCriterionReturnValue =
                        sharedCriterionService.mutate(operations.ToArray());

                    foreach (SharedCriterion removedCriterion in sharedCriterionReturnValue.value)
                    {
                        Console.WriteLine(
                            "Shared criterion ID {0} was successfully removed from shared " +
                            "set ID {1}.", removedCriterion.criterion.id,
                            removedCriterion.sharedSetId);
                    }
                }
                catch (Exception e)
                {
                    throw new Exception("Failed to remove shared criteria.", e);
                }
            }
        }
    }
}

Get ad group level bid modifiers

// 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 illustrates how to retrieve ad group level mobile bid
    /// modifiers for a campaign.
    /// </summary>
    public class GetAdGroupBidModifiers : 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)
        {
            GetAdGroupBidModifiers codeExample = new GetAdGroupBidModifiers();
            Console.WriteLine(codeExample.Description);
            try
            {
                long campaignId = long.Parse("INSERT_CAMPAIGN_ID_HERE");
                codeExample.Run(new AdWordsUser(), campaignId);
            }
            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 illustrates how to retrieve ad group level mobile bid " +
                    "modifiers for a campaign.";
            }
        }

        /// <summary>
        /// Runs the code example.
        /// </summary>
        /// <param name="user">The AdWords user.</param>
        /// <param name="campaignId">Id of the campaign.</param>
        public void Run(AdWordsUser user, long campaignId)
        {
            using (AdGroupBidModifierService adGroupBidModifierService =
                (AdGroupBidModifierService) user.GetService(AdWordsService.v201809
                    .AdGroupBidModifierService))
            {
                // Get all ad group bid modifiers for the campaign.
                Selector selector = new Selector()
                {
                    fields = new string[]
                    {
                        AdGroupBidModifier.Fields.CampaignId,
                        AdGroupBidModifier.Fields.AdGroupId,
                        AdGroupBidModifier.Fields.BidModifier,
                        AdGroupBidModifier.Fields.BidModifierSource,
                        Criterion.Fields.CriteriaType,
                        Criterion.Fields.Id
                    },
                    predicates = new Predicate[]
                    {
                        Predicate.Equals(AdGroupBidModifier.Fields.CampaignId, campaignId)
                    },
                    paging = Paging.Default
                };

                AdGroupBidModifierPage page = new AdGroupBidModifierPage();

                try
                {
                    do
                    {
                        // Get the campaigns.
                        page = adGroupBidModifierService.get(selector);

                        // Display the results.
                        if (page != null && page.entries != null)
                        {
                            int i = selector.paging.startIndex;
                            foreach (AdGroupBidModifier adGroupBidModifier in page.entries)
                            {
                                string bidModifier = (adGroupBidModifier.bidModifierSpecified)
                                    ? adGroupBidModifier.bidModifier.ToString()
                                    : "UNSET";
                                Console.WriteLine(
                                    "{0}) Campaign ID {1}, AdGroup ID {2}, Criterion ID {3} has " +
                                    "ad group level modifier: {4} and source = {5}.", i + 1,
                                    adGroupBidModifier.campaignId, adGroupBidModifier.adGroupId,
                                    adGroupBidModifier.criterion.id, bidModifier,
                                    adGroupBidModifier.bidModifierSource);
                                i++;
                            }
                        }

                        selector.paging.IncreaseOffset();
                    } while (selector.paging.startIndex < page.totalNumEntries);

                    Console.WriteLine("Number of adgroup bid modifiers found: {0}",
                        page.totalNumEntries);
                }
                catch (Exception e)
                {
                    throw new System.ApplicationException(
                        "Failed to retrieve adgroup bid modifiers.", e);
                }
            }
        }
    }
}

Add a portfolio bidding strategy to a campaign

// 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 adds a portfolio bidding strategy and uses it to
    /// construct a campaign.
    /// </summary>
    public class UsePortfolioBiddingStrategy : 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)
        {
            UsePortfolioBiddingStrategy codeExample = new UsePortfolioBiddingStrategy();
            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 adds a portfolio bidding strategy and uses it to " +
                    "construct a campaign.";
            }
        }

        /// <summary>
        /// Runs the specified code example.
        /// </summary>
        /// <param name="user">The AdWords user.</param>
        public void Run(AdWordsUser user)
        {
            string BIDDINGSTRATEGY_NAME = "Maximize Clicks " + ExampleUtilities.GetRandomString();
            const long BID_CEILING = 2000000;
            const long SPEND_TARGET = 20000000;

            string BUDGET_NAME =
                "Shared Interplanetary Budget #" + ExampleUtilities.GetRandomString();
            const long BUDGET_AMOUNT = 30000000;

            string CAMPAIGN_NAME = "Interplanetary Cruise #" + ExampleUtilities.GetRandomString();

            try
            {
                SharedBiddingStrategy portfolioBiddingStrategy =
                    CreateBiddingStrategy(user, BIDDINGSTRATEGY_NAME, BID_CEILING, SPEND_TARGET);
                Console.WriteLine(
                    "Portfolio bidding strategy with name '{0}' and ID {1} of type " +
                    "{2} was created.", portfolioBiddingStrategy.name, portfolioBiddingStrategy.id,
                    portfolioBiddingStrategy.biddingScheme.BiddingSchemeType);

                Budget sharedBudget = CreateSharedBudget(user, BUDGET_NAME, BUDGET_AMOUNT);

                Campaign newCampaign = CreateCampaignWithBiddingStrategy(user, CAMPAIGN_NAME,
                    portfolioBiddingStrategy.id, sharedBudget.budgetId);

                Console.WriteLine(
                    "Campaign with name '{0}', ID {1} and bidding scheme ID {2} was " + "created.",
                    newCampaign.name, newCampaign.id,
                    newCampaign.biddingStrategyConfiguration.biddingStrategyId);
            }
            catch (Exception e)
            {
                throw new System.ApplicationException(
                    "Failed to create campaign that uses portfolio " + "bidding strategy.", e);
            }
        }

        /// <summary>
        /// Creates the portfolio bidding strategy.
        /// </summary>
        /// <param name="user">The AdWords user.</param>
        /// <param name="name">The bidding strategy name.</param>
        /// <param name="bidCeiling">The bid ceiling.</param>
        /// <param name="spendTarget">The spend target.</param>
        /// <returns>The bidding strategy object.</returns>
        private SharedBiddingStrategy CreateBiddingStrategy(AdWordsUser user, string name,
            long bidCeiling, long spendTarget)
        {
            using (BiddingStrategyService biddingStrategyService =
                (BiddingStrategyService) user.GetService(AdWordsService.v201809
                    .BiddingStrategyService))
            {
                // Create a portfolio bidding strategy.
                SharedBiddingStrategy portfolioBiddingStrategy = new SharedBiddingStrategy
                {
                    name = name
                };

                TargetSpendBiddingScheme biddingScheme = new TargetSpendBiddingScheme
                {
                    // Optionally set additional bidding scheme parameters.
                    bidCeiling = new Money
                    {
                        microAmount = bidCeiling
                    },

                    spendTarget = new Money
                    {
                        microAmount = spendTarget
                    }
                };

                portfolioBiddingStrategy.biddingScheme = biddingScheme;

                // Create operation.
                BiddingStrategyOperation operation = new BiddingStrategyOperation
                {
                    @operator = Operator.ADD,
                    operand = portfolioBiddingStrategy
                };

                return biddingStrategyService.mutate(new BiddingStrategyOperation[]
                {
                    operation
                }).value[0];
            }
        }

        /// <summary>
        /// Creates an explicit budget to be used only to create the Campaign.
        /// </summary>
        /// <param name="user">The AdWords user.</param>
        /// <param name="name">The budget name.</param>
        /// <param name="amount">The budget amount.</param>
        /// <returns>The budget object.</returns>
        private Budget CreateSharedBudget(AdWordsUser user, string name, long amount)
        {
            using (BudgetService budgetService =
                (BudgetService) user.GetService(AdWordsService.v201809.BudgetService))
            {
                // Create a shared budget
                Budget budget = new Budget
                {
                    name = name,
                    amount = new Money
                    {
                        microAmount = amount
                    },
                    deliveryMethod = BudgetBudgetDeliveryMethod.STANDARD,
                    isExplicitlyShared = true
                };

                // Create operation.
                BudgetOperation operation = new BudgetOperation
                {
                    operand = budget,
                    @operator = Operator.ADD
                };

                // Make the mutate request.
                return budgetService.mutate(new BudgetOperation[]
                {
                    operation
                }).value[0];
            }
        }

        /// <summary>
        /// Creates the campaign with a portfolio bidding strategy.
        /// </summary>
        /// <param name="user">The AdWords user.</param>
        /// <param name="name">The campaign name.</param>
        /// <param name="biddingStrategyId">The bidding strategy id.</param>
        /// <param name="sharedBudgetId">The shared budget id.</param>
        /// <returns>The campaign object.</returns>
        private Campaign CreateCampaignWithBiddingStrategy(AdWordsUser user, string name,
            long biddingStrategyId, long sharedBudgetId)
        {
            using (CampaignService campaignService =
                (CampaignService) user.GetService(AdWordsService.v201809.CampaignService))
            {
                // Create campaign.
                Campaign campaign = new Campaign
                {
                    name = name,
                    advertisingChannelType = AdvertisingChannelType.SEARCH,

                    // Recommendation: Set the campaign to PAUSED when creating it to prevent
                    // the ads from immediately serving. Set to ENABLED once you've added
                    // targeting and the ads are ready to serve.
                    status = CampaignStatus.PAUSED,

                    // Set the budget.
                    budget = new Budget
                    {
                        budgetId = sharedBudgetId
                    }
                };

                // Set bidding strategy (required).
                BiddingStrategyConfiguration biddingStrategyConfiguration =
                    new BiddingStrategyConfiguration
                    {
                        biddingStrategyId = biddingStrategyId
                    };

                campaign.biddingStrategyConfiguration = biddingStrategyConfiguration;

                // Set network targeting (recommended).
                NetworkSetting networkSetting = new NetworkSetting
                {
                    targetGoogleSearch = true,
                    targetSearchNetwork = true,
                    targetContentNetwork = true
                };
                campaign.networkSetting = networkSetting;

                // Create operation.
                CampaignOperation operation = new CampaignOperation
                {
                    operand = campaign,
                    @operator = Operator.ADD
                };

                return campaignService.mutate(new CampaignOperation[]
                {
                    operation
                }).value[0];
            }
        }
    }
}

发送以下问题的反馈:

此网页
AdWords API
AdWords API
需要帮助?请访问我们的支持页面