GCP .NET - 1.0

using Google.Cloud.Bigtable.Admin.V2;
using Google.Cloud.Bigtable.V2;
using System;

namespace GoogleCloudSamples.Bigtable
{
    public class HelloWorld
    {

        private const string projectId = "YOUR-PROJECT-ID";
        private const string instanceId = "YOUR-INSTANCE-ID";
        private const string tableId = "Hello-Bigtable";

        Google.Cloud.Bigtable.Common.V2.TableName tableName = new Google.Cloud.Bigtable.Common.V2.TableName(projectId, instanceId, tableId);
        BigtableTableAdminClient bigtableTableAdminClient = BigtableTableAdminClient.Create();
        BigtableClient bigtableClient = BigtableClient.Create();

        bigtableTableAdminClient.CreateTable(new InstanceName(projectId, instanceId,tableId)
                        
        private static void ReadRowMethod()
        {
            
            RowFilter filter = RowFilters.CellsPerRowLimit(1);
            int rowIndex = 0;

            Row rowRead = bigtableClient.ReadRow(tableName, rowKey: rowKeyPrefix + rowIndex, filter: filter); 
        }
     }
}

using Google.Cloud.Storage.V1;
using System;

public class DeleteFileSample
{
    public void DeleteFile(
        string bucketName = "your-unique-bucket-name",
        string objectName = "your-object-name")
    {
        var storage = StorageClient.Create();
        storage.DeleteObject(bucketName, objectName);
        Console.WriteLine($"Deleted {objectName}.");
    }
}

public class PublishMessagesAsyncSample
{
    public async Task<int> PublishMessagesAsync(string project, string topic, IEnumerable<string> messageTexts)
    {
        TopicName topicName = TopicName.FromProjectTopic("projectId", "topicId");
        PublisherClient publisher = await PublisherClient.CreateAsync(topicName);

        int publishedMessageCount = 0;
        var publishTasks = messageTexts.Select(async text =>
        {
            try
            {
                string message = await publisher.PublishAsync(text);
                Console.WriteLine($"Published message {message}");
                Interlocked.Increment(ref publishedMessageCount);
            }
            catch (Exception exception)
            {
                Console.WriteLine($"An error ocurred when publishing message {text}: {exception.Message}");
            }
        });
        await Task.WhenAll(publishTasks);
        return publishedMessageCount;
    }
}

public class CreateSubscriptionSample
{
    public Subscription CreateSubscription(string project, string topic, string subscription)
    {
        SubscriberServiceApiClient subscriber = SubscriberServiceApiClient.Create();
        TopicName topicName = TopicName.FromProjectTopic("projectId", "topicId");

        SubscriptionName subscriptionName = SubscriptionName.FromProjectSubscription("projectId", "subscriptionId");
        Subscription subscription = null;

        try
        {
            subscription = subscriber.CreateSubscription(subscriptionName, topicName, pushConfig: null, ackDeadlineSeconds: 60);
        }
        catch (RpcException e) when (e.Status.StatusCode == StatusCode.AlreadyExists)
        {
            // Already exists.  That's fine.
        }
        return subscription;
    }
}

public class PullMessagesAsyncSample
{
    public async Task<int> PullMessagesAsync(string project, string subscription, bool acknowledge)
    {
        SubscriptionName subscriptionName = SubscriptionName.FromProjectSubscription("projectId", "subscriptionId");
        SubscriberClient subscriber = await SubscriberClient.CreateAsync(subscriptionName);
        // SubscriberClient runs your message handle function on multiple
        // threads to maximize throughput.
        int messageCount = 0;
        Task startTask = subscriber.StartAsync((PubsubMessage message, CancellationToken cancel) =>
        {
            string text = System.Text.Encoding.UTF8.GetString(message.Data.ToArray());
            Console.WriteLine($"Message {message.MessageId}: {text}");
            Interlocked.Increment(ref messageCount);
            return Task.FromResult(acknowledge ? SubscriberClient.Reply.Ack : SubscriberClient.Reply.Nack);
        });
        // Run for 5 seconds.
        await Task.Delay(5000);
        await subscriber.StopAsync(CancellationToken.None);
        // Lets make sure that the start task finished successfully after the call to stop.
        await startTask;
        return messageCount;
    }
}