microsoft-development

## Skill Paths

- Workspace skills: `.github/skills/`
- Global skills: `C:/Users/LOQ/.agents/skills/`

"Azure Functions"



## Skill Paths

- Workspace skills: `.github/skills/`
- Global skills: `C:/Users/LOQ/.agents/skills/`

"Azure Functions Python v2 programming model"
"Cosmos DB partition key design best practices"
"Container Apps scaling rules KEDA"

## Skill Paths

- Workspace skills: `.github/skills/`
- Global skills: `C:/Users/LOQ/.agents/skills/`

microsoft_docs_search("Azure Static Web Apps deployment patterns")
microsoft_docs_search(".NET Core dependency injection best practices")
microsoft_docs_search("Power BI row-level security implementation")



## Skill Paths

- Workspace skills: `.github/skills/`
- Global skills: `C:/Users/LOQ/.agents/skills/`

microsoft_docs_search("App Service app settings reference")
microsoft_docs_search("Functions host.json configuration options")



## Skill Paths

- Workspace skills: `.github/skills/`
- Global skills: `C:/Users/LOQ/.agents/skills/`

microsoft_docs_search("Azure OpenAI rate limits pricing tiers")
microsoft_docs_search("Azure Storage account limits and quotas")

microsoft_code_sample_search(query="upload file to blob storage", language="csharp")
microsoft_code_sample_search(query="authenticate with managed identity", language="python")
microsoft_code_sample_search(query="send message service bus", language="javascript")
microsoft_code_sample_search(query="Power BI embed report", language="csharp")

// Using Azure.Storage.Blobs
var blobServiceClient = new BlobServiceClient(connectionString);
var blobContainerClient = blobServiceClient.GetBlobContainerClient("mycontainer");
var blobClient = blobContainerClient.GetBlobClient("myfile.txt");

await blobClient.UploadAsync(filePath);

// Using azure-storage-blob
from azure.storage.blob import BlobServiceClient

blob_service_client = BlobServiceClient.from_connection_string(connection_string)
blob_client = blob_service_client.get_blob_client(container="mycontainer", blob="myfile.txt")

with open("myfile.txt", "rb") as data:
    blob_client.upload_blob(data)

const { BlobServiceClient } = require("@azure/storage-blob");

const blobServiceClient = BlobServiceClient.fromConnectionString(connectionString);
const containerClient = blobServiceClient.getContainerClient("mycontainer");
const blobClient = containerClient.getBlobClient("myfile.txt");

await blobClient.downloadToFile("downloaded.txt");

await foreach (var blob in blobContainerClient.GetBlobsAsync())
{
    if (blob.Name.EndsWith(".txt"))
    {
        Console.WriteLine($"{blob.Name} (Size: {blob.Properties.ContentLength})");
    }
}

// .NET 8 Isolated Worker
using Microsoft.Azure.Functions.Worker;

[Function("HttpExample")]
public HttpResponseData Run(
    [HttpTrigger(AuthorizationLevel.Function, "get", "post")] HttpRequestData req,
    FunctionContext executionContext)
{
    var logger = executionContext.GetLogger("HttpExample");
    logger.LogInformation("C# HTTP trigger function processed a request.");

    var response = new HttpResponseData(HttpStatusCode.OK);
    response.Headers.Add("Content-Type", "text/plain; charset=utf-8");
    response.Body = $"Welcome to Azure Functions, {req.Query["name"]}!";

    return response;
}

// Node.js v4 model
const { app } = require('@azure/functions');

app.http('httpExample', {
    route: 'hello/{name:alpha}',
    methods: ['GET'],
    authLevel: 'function',
    handler: async (request, context) => {
        const name = request.params.name || 'world';
        return { body: `Hello, ${name}!` };
    }
});

## Skill Paths

- Workspace skills: `.github/skills/`
- Global skills: `C:/Users/LOQ/.agents/skills/`

config:
  appLocation: "/"
  outputLocation: "dist"
  apiLocation: "api"

platform:
  apiRuntime: "node:18"

production:
  branch: "main"
  pullRequestPreviewSettings:
    branch: "main"

## Skill Paths

- Workspace skills: `.github/skills/`
- Global skills: `C:/Users/LOQ/.agents/skills/`

name: Deploy to Azure

on:
  push:
    branches: [ main ]

env:
  AZURE_WEBAPP_NAME: "myapp"
  AZURE_WEBAPP_PACKAGE_PATH: "./dist"

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v4

      - name: Set up Node.js
        uses: actions/setup-node@v4
        with:
          node-version: "18"

      - name: Install dependencies
        run: npm ci

      - name: Build
        run: npm run build

      - name: Deploy to Azure Static Web Apps
        uses: azure/static-web-apps-deploy@v1
        with:
          azure_static_web_apps_api_token: ${{ secrets.AZURE_STATIC_WEB_APPS_API_TOKEN }}
          repo_token: ${{ secrets.GITHUB_TOKEN }}
          action: "upload"
          app_location: "src"
          api_location: "api"
          output_location: "dist"

// Program.cs
var builder = WebApplication.CreateBuilder(args);

// Register services
builder.Services.AddDbContext<AppDbContext>(options =>
    options.UseSqlServer(connectionString));

builder.Services.AddScoped<IRepository, EFRepository>();
builder.Services.AddHttpClient();

var app = builder.Build();

// Inject in controllers
app.MapControllers();

app.Run();

// ✅ Correct - ConfigureAwait(true)
public async Task<IEnumerable<User>> GetUsersAsync()
{
    var users = await _repository.GetAllAsync().ConfigureAwait(false);
    return users;
}

// ✅ Correct - Use async all the way
public async Task<User> CreateUserAsync(User user)
{
    _dbContext.Users.Add(user);
    await _dbContext.SaveChangesAsync().ConfigureAwait(false);
    return user;
}

// Constructor injection
public class ProductService
{
    private readonly ILogger<ProductService> _logger;

    public ProductService(ILogger<ProductService> logger)
    {
        _logger = logger;
    }

    public void ProcessProducts()
    {
        _logger.LogInformation("Starting product processing");
        // ... code
        _logger.LogWarning("Product count exceeds threshold: {Count}", count);
    }
}

// Using Azure.Identity and Microsoft.Graph
using Azure.Identity;
using Microsoft.Graph;

var credential = new ClientSecretCredential(
    tenantId,
    clientId,
    clientSecret);

var graphClient = new GraphServiceClient(credential, new[] { "https://graph.microsoft.com/.default" });

// Using @azure/identity and @microsoft/microsoft-graph-client
const { ClientSecretCredential } = require("@azure/identity");
const { Client } = require("@microsoft/microsoft-graph-client");

const credential = new ClientSecretCredential(tenantId, clientId, clientSecret);
const client = Client.initWithMiddleware({
    authenticationProvider: credential,
});

var user = await graphClient.Users["user@example.com"].GetAsync();
Console.WriteLine($"User: {user.DisplayName} ({user.Mail})");

var message = new Message
{
    Subject = "Meeting Tomorrow",
    Body = new ItemBody
    {
        ContentType = BodyType.Text,
        Content = "Don't forget about our meeting at 2 PM."
    },
    ToRecipients = new[] { new Recipient { EmailAddress = new EmailAddress { Address = "recipient@example.com" } } }
};

await graphClient.Me.SendMailAsync(message);

Error: "The remote server returned an error: (401) Unauthorized"

Solutions:
1. Verify credentials are correct
2. Check token hasn't expired
3. Verify right permissions/scopes are granted
4. For Azure: check Managed Identity is properly configured

Error: "Configuration value not found" or "Invalid connection string"

Solutions:
1. Verify key names in appsettings.json / environment variables
2. Check connection string format (semicolon-separated key=value pairs)
3. For Azure: Use GetConnectionString() or proper secret reference

Error: "Request rate limit exceeded" or HTTP 429

Solutions:
1. Implement retry with exponential backoff
2. Use batching for multiple operations
3. Increase service tier if needed
4. Implement caching to reduce unnecessary calls

// Core
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Configuration;

// Azure
using Azure.Identity;
using Azure.Storage.Blobs;
using Microsoft.Azure.Cosmos;

// General
using System.Net;
using System.Text.Json;