Azure .NET 1.0

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Azure.Storage;
using Azure.Storage.Blobs;
using Azure.Storage.Blobs.Models;
using Azure.Storage.Sas;

namespace BlobAzure
{
    public class Pgm
    {
    	private readonly BlobServiceClient _blobClient;
        public async Task<bool> Delete(string file)
        {
        	_blobClient = new BlobServiceClient();
        	string containerName = "containerName";
            var containerClient = _blobClient.GetBlobContainerClient(containerName);
            await containerClient.DeleteBlobAsync(file, Azure.Storage.Blobs.Models.DeleteSnapshotsOption.IncludeSnapshots);
            return true;
        }
        
        public async Task<bool> DeleteWithContainerName(string file, string containerName)
        {
        	_blobClient = new BlobServiceClient();
            var containerClient = _blobClient.GetBlobContainerClient(containerName);
            await containerClient.DeleteBlobAsync(file, Azure.Storage.Blobs.Models.DeleteSnapshotsOption.IncludeSnapshots);
            return true;
        }
        
        public Task<bool> UploadFile()
        {
        // Get a connection string to our Azure Storage account.
			string connectionString = "<connection_string>";
			string containerName = "sample-container";
			string filePath = "hello.jpg";
			
			// Get a reference to a container named "sample-container" and then create it
			BlobContainerClient container = new BlobContainerClient(connectionString, containerName);
			container.Create();
			
			// Upload a few blobs so we have something to list
			container.UploadBlob("first", File.OpenRead(filePath));
		}
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Azure.Storage;
using Azure.Storage.Blobs;
using Azure.Storage.Blobs.Models;
using Azure.Storage.Blobs.Specialized;
using Azure.Storage.Sas;

namespace BlobAzure
{
    public class Pgm
    {
        static string containerName = "data";
        static string filename = "sample.txt";
        static string uriCustom = "https://myaccount.blob.core.windows.net/my_source_container/myblob";
        
        static async Task GetBlobs(string connectionString, string blobName, BlobClientOptions options)
        {
            
			AppendBlobClient appendBlob = new AppendBlobClient(connectionString, containerName, blobName, options);
                        
            Uri uri = new("https://myaccount.blob.core.windows.net/my_source_container/myblob");
			var response = appendBlob.AppendBlockFromUri(uri);
        }
          
    }
}

using Azure.Messaging.ServiceBus;
using Azure.Messaging.ServiceBus.Administration;

namespace ServiceBus
{
    public class Pgm1
    {
        private string queueName = "toto";
        
        public static async Task SendMessageAsync(string connectionString, string messageText)
        {
            await using var client = new ServiceBusClient(connectionString);
			using var messageBatch = await this.sender.CreateMessageBatchAsync();
            
            // create the sender
            ServiceBusSender sender = new ServiceBusSender(client, queueName);

            // create a message that we can send. UTF-8 encoding is used when providing a string.
            ServiceBusMessage message = new ServiceBusMessage(messageText);

            // send the message
            await sender.SendMessageAsync(message);
        }
}

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using Azure.Messaging.ServiceBus;
using Azure.Messaging.ServiceBus.Administration;

namespace ServiceBus
{
    public class Pgm
    {
        private string queueName = "toto";
        
        public static async Task<ServiceBusReceivedMessage> GetMessageFromSessionAsync(string connectionString)
        {
            await using var client = new ServiceBusClient(connectionString);
                                 
            // create the sender			
			ServiceBusReceiver receiver = client.CreateReceiver(queueName);
			
            // the received message is a different type as it contains some service set properties
            return await receiver.ReceiveMessageAsync();
        }      
    }
}

public class Send
{
	// connection string to the Event Hubs namespace
    private const string connectionString = "<EVENT HUBS NAMESPACE - CONNECTION STRING>";

    // name of the event hub
    private const string eventHubName = "<EVENT HUB NAME>";

    // number of events to be sent to the event hub
    private const int numOfEvents = 3;
    
    // The Event Hubs client types are safe to cache and use as a singleton for the lifetime
    // of the application, which is best practice when events are being published or read regularly.
    static EventHubProducerClient producerClient;  
    
    static async Task Send()
    {
        // Create a producer client that you can use to send events to an event hub
        producerClient = new EventHubProducerClient(connectionString, eventHubName);

        // Create a batch of events 
        using EventDataBatch eventBatch = await producerClient.CreateBatchAsync();

        for (int i = 1; i <= numOfEvents; i++)
        {
            if (! eventBatch.TryAdd(new EventData(Encoding.UTF8.GetBytes($"Event {i}"))))
            {
                // if it is too large for the batch
                throw new Exception($"Event {i} is too large for the batch and cannot be sent.");
            }
        }

        try
        {
            // Use the producer client to send the batch of events to the event hub
            await producerClient.SendAsync(eventBatch);
            Console.WriteLine($"A batch of {numOfEvents} events has been published.");
        }
        finally
        {
            await producerClient.DisposeAsync();
        }
    }
    				
}

public class Receive
{
	private const string ehubNamespaceConnectionString = "<EVENT HUBS NAMESPACE - CONNECTION STRING>";
    private const string eventHubName = "<EVENT HUB NAME>";
    private const string blobStorageConnectionString = "<AZURE STORAGE CONNECTION STRING>";
    private const string blobContainerName = "<BLOB CONTAINER NAME>";
    
    static BlobContainerClient storageClient;

    // The Event Hubs client types are safe to cache and use as a singleton for the lifetime
    // of the application, which is best practice when events are being published or read regularly.        
    static EventProcessorClient processor;
    
    static async Task Receive()
    {
        // Read from the default consumer group: $Default
        string consumerGroup = EventHubConsumerClient.DefaultConsumerGroupName;

        // Create a blob container client that the event processor will use 
        storageClient = new BlobContainerClient(blobStorageConnectionString, blobContainerName);

        // Create an event processor client to process events in the event hub
        processor = new EventProcessorClient(storageClient, consumerGroup, ehubNamespaceConnectionString, eventHubName);

        // Register handlers for processing events and handling errors
        processor.ProcessEventAsync += ProcessEventHandler;
        processor.ProcessErrorAsync += ProcessErrorHandler;

        // Start the processing
        await processor.StartProcessingAsync();

        // Wait for 30 seconds for the events to be processed
        await Task.Delay(TimeSpan.FromSeconds(30));

        // Stop the processing
        await processor.StopProcessingAsync();
    }

[FunctionName("WriteOneDoc")]
public static void Run(

    	[Function("ServiceBusFunction")]
        [ServiceBusOutput("outputQueue", Connection = "ServiceBusConnection")]
        public static string Run([ServiceBusTrigger("queue", Connection = "ServiceBusConnection")] string item,
            FunctionContext context)
        {
            var logger = context.GetLogger("ServiceBusFunction");

            logger.LogInformation(item);

            var message = $"Output message created at {DateTime.Now}";
    	            return message;
    	}   

		[FunctionName("Function1")]
		public static IActionResult Run2(
		[HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = "products/{category:alpha}/{id:int?}")] HttpRequest req,
		string category, int? id, ILogger log)
		{
		    log.LogInformation("C# HTTP trigger function processed a request.");

		    var message = String.Format($"Category: {category}, ID: {id}");
		    return (ActionResult)new OkObjectResult(message);
		}

		[FunctionName("Orchestrator_HttpStart")]
        public static async Task<HttpResponseMessage> HttpStart(
            [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post")] HttpRequestMessage req,
            [DurableClient] IDurableOrchestrationClient client,
            ILogger log)
        {
            // Function input comes from the request content.
            string instanceId = await client.StartNewAsync("Orchestrator", null, "Nuget");

            log.LogInformation($"Started orchestration with ID = '{instanceId}'.");

            return client.CreateCheckStatusResponse(req, instanceId);
        }

        [FunctionName("Orchestrator")]
        public static async Task<string> RunOrchestrator(
            [OrchestrationTrigger] IDurableOrchestrationContext context)
        {
            // retrieves the organization name from the Orchestrator_HttpStart function
            var organizationName = context.GetInput<string>();
            // retrieves the list of repositories for an organization by invoking a separate Activity Function.
            var repositories = await context.CallActivityAsync<List<(long id, string name)>>("GetAllRepositoriesForOrganization", organizationName);

            // Creates an array of task to store the result of each functions
            var tasks = new Task<(long id, int openedIssues, string name)>[repositories.Count];
            for (int i = 0; i < repositories.Count; i++)
            {
                // Starting a `GetOpenedIssues` activity WITHOUT `async`
                // This will starts Activity Functions in parallel instead of sequentially.
                tasks[i] = context.CallActivityAsync<(long, int, string)>("GetOpenedIssues", (repositories[i]));
            }

            // Wait for all Activity Functions to complete execution
            await Task.WhenAll(tasks);

            // Retrieve the result of each Activity Function and return them in a list
            var openedIssues = tasks.Select(x => x.Result).ToList();

            // Send the list to an Activity Function to save them to Blob Storage.
            await context.CallActivityAsync("SaveRepositories", openedIssues);

            return context.InstanceId;
        }

		[FunctionName("GetAllRepositoriesForOrganization")]
        public static async Task<List<(long id, string name)>> GetAllRepositoriesForOrganization([ActivityTrigger] IDurableActivityContext context)
        {
            // retrieves the organization name from the Orchestrator function
            var organizationName = context.GetInput<string>();
            // invoke the API to retrieve the list of repositories of a specific organization
            var repositories = (await github.Repository.GetAllForOrg(organizationName)).Select(x => (x.Id, x.Name)).ToList();
            return repositories;
        }

        [FunctionName("GetOpenedIssues")]
        public static async Task<(long id, int openedIssues, string name)> GetOpenedIssues([ActivityTrigger] IDurableActivityContext context)
        {
            // retrieve a tuple of repositoryId and repository name from the Orchestrator function
            var parameters = context.GetInput<(long id, string name)>();

            // retrieves a list of issues from a specific repository
            var issues = (await github.Issue.GetAllForRepository(parameters.id)).ToList();

            // returns a tuple of the count of opened issues for a specific repository
            return (parameters.id, issues.Count(x => x.State == ItemState.Open), parameters.name);
        }

		[FunctionName("SaveRepositories")]
        public static async Task SaveRepositories([ActivityTrigger] IDurableActivityContext context)
        {
            // retrieves a tuple from the Orchestrator function
            var parameters = context.GetInput<List<(long id, int openedIssues, string name)>>();

            // create the client and table reference for Blob Storage
            var client = account.CreateCloudTableClient();
            var table = client.GetTableReference("Repositories");

            // create the table if it doesn't exist already.
            await table.CreateIfNotExistsAsync();

            // creates a batch of operation to be executed
            var batchOperation = new TableBatchOperation();
            foreach (var parameter in parameters)
            {
                // Creates an operation to add the repository to Table Storage
                batchOperation.Add(TableOperation.InsertOrMerge(new Repository(parameter.id)
                {
                    OpenedIssues = parameter.openedIssues,
                    RepositoryName = parameter.name
                }));
            }

            await table.ExecuteBatchAsync(batchOperation);
        }

		[FunctionName("HttpStart")]
        public static async Task<HttpResponseMessage> Run3(
            [HttpTrigger(AuthorizationLevel.Function, methods: "post", Route = "orchestrators/{functionName}")] HttpRequestMessage req,
            [DurableClient] IDurableClient starter,
            string functionName,
            ILogger log)
        {
            // Function input comes from the request content.
            object eventData = await req.Content.ReadAsAsync<object>();
            string instanceId = await starter.StartNewAsync(functionName, eventData);

            log.LogInformation($"Started orchestration with ID = '{instanceId}'.");

            return starter.CreateCheckStatusResponse(req, instanceId);
        }

		[FunctionName("BlobTriggerCSharp")]        
		public static void Run([BlobTrigger("sample-container/{name}")] Stream myBlob, string name, ILogger log)
		{
		    log.LogInformation($"C# Blob trigger function Processed blob\n Name:{name} \n Size: {myBlob.Length} Bytes");
		}   

		[Function("BlobFunction")]
	    [BlobOutput("test-samples-output/{name}-output.txt")]
	    public static string Run(
	        [BlobTrigger("test-samples-trigger/{name}")] string myTriggerItem,
	        [BlobInput("test-samples-input/sample1.txt")] string myBlob,
	        FunctionContext context)
	    {
	        var logger = context.GetLogger("BlobFunction");
	        logger.LogInformation($"Triggered Item = {myTriggerItem}");
	        logger.LogInformation($"Input Item = {myBlob}");

	        // Blob Output
	        return "blob-output content";
	    }

	[FunctionName("CosmosTrigger")]
	public static void Run([CosmosDBTrigger(
		databaseName: "FamilyDatabase",
		collectionName: "FamilyCollection",
		ConnectionStringSetting = "CosmosDBConnection",
		LeaseCollectionName = "leases",
		CreateLeaseCollectionIfNotExists = true)]IReadOnlyList<Document> documents,
		ILogger log)
	{
		if (documents != null && documents.Count > 0)
		{
			log.LogInformation($"Documents modified: {documents.Count}");
			log.LogInformation($"First document Id: {documents[0].Id}");
		}
    }

		[FunctionName("DocByIdFromJSON")]
        public static void Run(
            [QueueTrigger("todoqueueforlookup")] ToDoItemLookup toDoItemLookup,
            [CosmosDB(
                databaseName: "ToDoItems",
                collectionName: "Items",
                ConnectionStringSetting = "CosmosDBConnection",
                Id = "{ToDoItemId}",
                PartitionKey = "{ToDoItemPartitionKeyValue}")]ToDoItem toDoItem,
            ILogger log)
        {
            log.LogInformation($"C# Queue trigger function processed Id={toDoItemLookup?.ToDoItemId} Key={toDoItemLookup?.ToDoItemPartitionKeyValue}");

            if (toDoItem == null)
            {
                log.LogInformation($"ToDo item not found");
            }
            else
            {
                log.LogInformation($"Found ToDo item, Description={toDoItem.Description}");
            }
        }

		[FunctionName("WriteDocsIAsyncCollector")]
        public static async Task Run(
            [QueueTrigger("todoqueueforwritemulti")] ToDoItem[] toDoItemsIn,
            [CosmosDB(
                databaseName: "ToDoItems",
                collectionName: "Items",
                ConnectionStringSetting = "CosmosDBConnection")]
                IAsyncCollector<ToDoItem> toDoItemsOut,
            ILogger log)
        {
            log.LogInformation($"C# Queue trigger function processed {toDoItemsIn?.Length} items");

            foreach (ToDoItem toDoItem in toDoItemsIn)
            {
                log.LogInformation($"Description={toDoItem.Description}");
                await toDoItemsOut.AddAsync(toDoItem);
            }
        }

		[Function("EventHubsFunction")]
		[EventHubOutput("dest", Connection = "EventHubConnectionAppSetting")]
		public static string Run([EventHubTrigger("src", Connection = "EventHubConnectionAppSetting")] string[] input,
		    FunctionContext context)
		{
		    var logger = context.GetLogger("EventHubsFunction");

		    logger.LogInformation($"First Event Hubs triggered message: {input[0]}");

		    var message = $"Output message created at {DateTime.Now}";
		    return message;
		}

		[FunctionName("broadcast")]
        public static async Task Broadcast(
        	[SignalRTrigger("HubName", "messages", "SendMessage", parameterNames: new string[] {"message"})]InvocationContext invocationContext, string message, ILogger logger)
        {
            ...
        }

		// Passes a service bus message from a queue to another queue using strings
        public static void SBQueue2SBQueue(
            [ServiceBusTrigger(StartQueueName)] string start,
            [ServiceBus(QueueNamePrefix + "1")] out string message,
            TextWriter log)
        {
            message = start + "-SBQueue2SBQueue";
            log.WriteLine("SBQueue2SBQueue: " + message);
        }

		public static void FailAlways(
            [BlobTrigger("badcontainer/{name}")] string message, 
            TextWriter log)
        {
            log.WriteLine("When we reach 5 retries, the message will be moved into the badqueue-poison queue");

            throw new InvalidOperationException("Simulated failure");
        }

		public static async Task BlobBindingInput(
            [QueueTrigger("persons")] Person persons,
            string Name,
            [Blob("persons/{Name}BlobBindingInput", FileAccess.Read)] Stream input)
        {
            ...
        }

 		public static async Task BlobNameFromQueueMessage(            
            string Name,
            [Blob("persons/{Name}BlobNameFromQueueMessage", FileAccess.Write)] Stream output)
        {
            byte[] messageBytes = Encoding.UTF8.GetBytes("Hello " + Name);

            await output.WriteAsync(messageBytes, 0, messageBytes.Length);
        }

 		public static void Run([CosmosDBTrigger(
            databaseName: "FamilyDatabase",
            collectionName: "FamilyCollection",
            ConnectionStringSetting = "CosmosDBConnection",
            LeaseCollectionName = "leases",
            CreateLeaseCollectionIfNotExists = true)]IReadOnlyList<Document> documents,
            ILogger log)
        {
            if (documents != null && documents.Count > 0)
            {
                log.LogInformation($"Documents modified: {documents.Count}");
                log.LogInformation($"First document Id: {documents[0].Id}");
    	    }
    	}

		public static void Run(
            [QueueTrigger("todoqueueforlookup")] ToDoItemLookup toDoItemLookup,
            [CosmosDB(
                databaseName: "ToDoItems",
                collectionName: "Items",
                ConnectionStringSetting = "CosmosDBConnection",
                Id = "{ToDoItemId}",
                PartitionKey = "{ToDoItemPartitionKeyValue}")]ToDoItem toDoItem,
            ILogger log)
        {
            log.LogInformation($"C# Queue trigger function processed Id={toDoItemLookup?.ToDoItemId} Key={toDoItemLookup?.ToDoItemPartitionKeyValue}");

            if (toDoItem == null)
            {
                log.LogInformation($"ToDo item not found");
            }
            else
            {
                log.LogInformation($"Found ToDo item, Description={toDoItem.Description}");
            }
        }

		public static async Task Run(            
            [CosmosDB(
                databaseName: "ToDoItems",
                collectionName: "Items",
                ConnectionStringSetting = "CosmosDBConnection")]
                IAsyncCollector<ToDoItem> toDoItemsOut,
            ILogger log)
        {
            log.LogInformation($"C# Queue trigger function processed {toDoItemsIn?.Length} items");

            foreach (ToDoItem toDoItem in toDoItemsIn)
            {
                log.LogInformation($"Description={toDoItem.Description}");
                await toDoItemsOut.AddAsync(toDoItem);
            }
        }

		public static async Task CronJob(           
            [OrchestrationClient] DurableOrchestrationClient client,
            ILogger logger)
        {
            logger.LogInformation("Cron job fired!");

            string instanceId = await client.StartNewAsync('HelloSequence', input: null);
            logger.LogInformation($"Started new instance with ID = {instanceId}.");
			...
           
        }

        public static async Task<List<string>> HelloSequence(
            [OrchestrationTrigger] DurableOrchestrationContextBase context)
        {
            var outputs = new List<string>();

            outputs.Add(await context.CallActivityAsync<string>('SayHello', "Tokyo"));
            outputs.Add(await context.CallActivityAsync<string>('SayHello', "Seattle"));
            outputs.Add(await context.CallActivityAsync<string>('SayHello', "London"));

            // returns ["Hello Tokyo!", "Hello Seattle!", "Hello London!"]
            return outputs;
        }

        public static string SayHello([ActivityTrigger] string name, ILogger logger)
        {
            string greeting = $"Hello {name}!";
            logger.LogInformation(greeting);
            Thread.Sleep(5000);
            return greeting;
        }

		[NoAutomaticTrigger]
		public static void CreateQueueMessage(
		ILogger logger,
		string value,
		[Queue("outputqueue")] out string message)
		{
		    message = value;
		    logger.LogInformation("Creating queue message: ", message);
		}

		static async Task Main(string[] args)
    	{
    	    var builder = new HostBuilder();
    	    builder.ConfigureWebJobs(b =>
    	    {
    	        b.AddAzureStorageCoreServices();
    	        b.AddAzureStorage();
    	    });
    	    var host = builder.Build();
    	    using (host)
    	    {
    	        var jobHost = host.Services.GetService(typeof(IJobHost)) as JobHost;
    	        var inputs = new Dictionary<string, object>
    	        {
    	            { "value", "Hello world!" }
    	        };

    	        await host.StartAsync();
    	        await jobHost.CallAsync("CreateQueueMessage", inputs);
    	        await host.StopAsync();
    	    }
    	}

		static void Main(string[] args)
    	{
    	    JobHost host = new JobHost();
    	    host.Call(typeof(Program).GetMethod("CreateQueueMessage"), new { value = "Hello world!" });
    	}

		public void Run(
		    [EventHubTrigger("source", Connection = "EventHubConnectionAppSetting")] EventData myEventHubMessage,
			[EventHub("dest", Connection = "EventHubConnectionAppSetting")]IAsyncCollector<string> outputEvents,
		    DateTime enqueuedTimeUtc,
		    Int64 sequenceNumber,
		    string offset,
		    ILogger log)
		{
		    log.LogInformation($"Event: {Encoding.UTF8.GetString(myEventHubMessage.Body)}");
		    // Metadata accessed by binding to EventData
		    log.LogInformation($"EnqueuedTimeUtc={myEventHubMessage.SystemProperties.EnqueuedTimeUtc}");
		    log.LogInformation($"SequenceNumber={myEventHubMessage.SystemProperties.SequenceNumber}");
		    log.LogInformation($"Offset={myEventHubMessage.SystemProperties.Offset}");
		    // Metadata accessed by using binding expressions in method parameters
		    log.LogInformation($"EnqueuedTimeUtc={enqueuedTimeUtc}");
		    log.LogInformation($"SequenceNumber={sequenceNumber}");
		    log.LogInformation($"Offset={offset}");
		}

	public class ChatHub : Hub
    {
    	
        public async Task SendMessage(string name, string message)
        {            
            await Clients.All.SendAsync("ReceiveMessage", name, message);           
        }
    	
    	public async Task AddGroup(string name, string message)
        {
    		 await Groups.AddToGroupAsync(Context.ConnectionId, "SignalR Users");
        }
    	
    	public override async Task OnConnectedAsync()
    	{
    	    
    	    await base.OnConnectedAsync();
    	}
    	
    	public override async Task OnDisconnectedAsync(Exception? exception)
    	{
    	    await base.OnDisconnectedAsync(exception);
    	}
    }

			app.UseEndpoints(endpoints =>
            {
                endpoints.MapHub<ChatHub>("/HubName");
            });

	private async void sendButton_Click(object sender, RoutedEventArgs e)
        {
            #region snippet_ErrorHandling
            try
            {
                #region snippet_InvokeAsync
                await connection.InvokeAsync("SendMessage", 
                    userTextBox.Text, messageTextBox.Text);
                #endregion
            }
			...