Azure SDK for .NET (October 2024)

The Azure SDK team shipped 64 package updates in October 2024, spanning stable releases, patch fixes, and beta previews. Most months you can skim the changelog and move on. This one has a few changes worth a closer look if you work with Azure AI Search, Microsoft Entra authentication, or Azure Communication Services.

Below I cover the four changes that matter most for day to day development: vector search compression with dimension truncation, vector query filter overrides, Continuous Access Evaluation support built into the core authentication policy, and content ID support for email attachments. I also flag the breaking changes in the Azure OpenAI SDK that will catch you out if you upgrade without reading the notes.

Vector search compression gets a truncation option

Azure AI Search’s Azure.Search.Documents package moved to 11.7.0-beta.1 with a new TruncationDimension property on VectorSearchCompression. If you run vector search in production, you already know storing full precision embeddings gets expensive fast. A 3072 dimension embedding from text-embedding-3-large costs roughly four times the storage of a 768 dimension one, multiplied across every document in your index.

TruncationDimension lets you cut an embedding down before quantization even runs. This works only with embeddings trained using Matryoshka Representation Learning, which OpenAI’s text-embedding-3 family supports. The first N dimensions of the vector carry most of the semantic signal, so you can drop the rest without losing much accuracy.

var vectorSearch = new VectorSearch
{
    Profiles =
    {
        new VectorSearchProfile("profile-1", "hnsw-1")
        {
            CompressionName = "scalar-compression"
        }
    },
    Algorithms = { new HnswAlgorithmConfiguration("hnsw-1") },
    Compressions =
    {
        new ScalarQuantizationCompression("scalar-compression")
        {
            TruncationDimension = 1024,
            RerankWithOriginalVectors = true,
            DefaultOversampling = 10
        }
    }
};

This configuration truncates every embedding to 1024 dimensions before scalar quantization runs, then reranks the top candidates using the original, pre quantization vectors for accuracy. In practice, truncation plus quantization plus rerank is where most of the storage savings come from without a noticeable drop in search relevance.

Two things to check before you turn this on in production. First, confirm your embedding model actually supports Matryoshka truncation. Truncating an embedding that was not trained this way will not throw an error, it will just quietly return worse results, which is a harder bug to catch than a crash. Second, measure recall on a representative query set before and after truncation. A drop from 3072 to 1024 dimensions is usually safe, but the right number depends on your data and is worth testing rather than assuming.

FilterOverride on vector queries

VectorQuery.FilterOverride solves a specific but common problem: a hybrid search request needs one filter for the overall query and a different, tighter filter for a particular vector field. Previously this meant issuing separate requests and merging results yourself. Now a single call can mix filter scopes.

var vectorQuery = new VectorizedQuery(queryEmbedding)
{
    KNearestNeighborsCount = 10,
    Fields = { "productVector" },
    FilterOverride = "category eq 'electronics' and inStock eq true"
};
 
var options = new SearchOptions
{
    Filter = "region eq 'EU'",
    VectorSearch = new VectorSearchOptions { Queries = { vectorQuery } }
};
 
var results = await searchClient.SearchAsync<Product>("wireless headphones", options);

SearchOptions.Filter still narrows the overall request to the EU region, but vector matching against productVector obeys the tighter electronics and in-stock filter instead. This is useful in multi tenant catalogs or recommendation scenarios where the vector similarity search needs stricter scoping than the keyword search around it.

Continuous Access Evaluation lands in Azure.Core

Azure.Core 1.44.0 updated BearerTokenAuthenticationPolicy to automatically handle Continuous Access Evaluation, or CAE, challenges. If your organization enforces Conditional Access policies, such as blocking sign-in from unfamiliar locations or requiring MFA for sensitive actions, tokens can now get revoked mid-session rather than only at expiry. Before this update, your application had to detect a 401 response with a specific WWW-Authenticate claims challenge and retry the request manually.

var credential = new DefaultAzureCredential();
var client = new SecretClient(new Uri(vaultUri), credential);
 
// No extra code needed here. CAE retry now happens
// automatically inside BearerTokenAuthenticationPolicy.
var secret = await client.GetSecretAsync("connection-string");

Nothing changes in your calling code. The retry logic now lives inside the pipeline itself. If you had already built your own CAE handling by catching the claims challenge and reacquiring a token, you can remove that workaround once every Azure client library in your project references Core 1.44.0 or later. Mismatched Core versions across packages have caused subtle authentication bugs before, so check your lock file after upgrading rather than assuming one package update covers you.

Content ID support for Azure Communication Services email attachments

Azure.Communication.Email 1.1.0-beta.2 added a ContentId property on EmailAttachment, which finally lets you reference an attachment as an inline image using the cid scheme instead of hosting it on a public URL.

var logoBytes = await File.ReadAllBytesAsync("logo.png");
 
var attachment = new EmailAttachment(
    name: "logo.png",
    contentType: "image/png",
    content: BinaryData.FromBytes(logoBytes))
{
    ContentId = "companyLogo"
};
 
var emailContent = new EmailContent("Welcome aboard")
{
    Html = "<html><body><img src=\"cid:companyLogo\" /><p>Thanks for signing up.</p></body></html>"
};
 
var message = new EmailMessage("sender@contoso.com", "user@example.com", emailContent);
message.Attachments.Add(attachment);
 
await emailClient.SendAsync(WaitUntil.Completed, message);

Without ContentId, embedding a logo or a screenshot inside an HTML email meant hosting the image on a public URL and hoping the recipient’s mail client did not block remote images by default, which many do. Referencing the attachment inline through the cid scheme avoids that problem entirely, since the image travels with the message and nothing needs to be fetched externally to render it.

Watch the OpenAI Inference breaking changes before you upgrade

Azure.AI.OpenAI jumped from beta straight to 2.0.0 stable this month, and then to 2.1.0-beta.1 for early Realtime API support. The stable release renamed a long list of members: MaxTokens became MaxOutputTokenCount, the InputTokens and OutputTokens properties on ChatTokenUsage became InputTokenCount and OutputTokenCount, and several factory methods got shorter names, for example CreateTextMessageContentPart became CreateTextPart.

None of these renames are dangerous on their own, but they will break your build the moment you bump the package version. Treat this as a scheduled migration with a find and replace pass and a test run, not a routine patch bump you merge without looking.

The more interesting addition, if you are experimenting with OpenAI’s o1 reasoning models, is the OutputTokenDetails.ReasoningTokenCount property on Usage. Reasoning models spend tokens on internal reasoning steps before producing visible output, and those tokens are billed even though they were previously invisible in the usage response. If your cost monitoring only tracks OutputTokenCount, add ReasoningTokenCount to your dashboards, because the sum of the two is what you are actually paying for.

A quieter Service Bus

Azure.Messaging.ServiceBus 7.18.2 changed how session acquisition timeouts get logged. Session based processors already treated a timeout while waiting for a session as an expected, low severity event. Direct session receivers, however, logged the identical condition as an error, which is an inconsistency that generated false alarms in production for applications that poll for sessions and treat empty polls as normal.

Both code paths now log at verbose level instead. If your alerting rules watch Service Bus error logs, this update should quiet things down considerably. If you were actually relying on that error log to catch a real problem, switch your monitoring to track failed message processing counts instead of raw log severity, since the log level itself is no longer a reliable signal for that.

Should you upgrade this month

Most of what shipped in October 2024 is routine patch level work, mainly a System.Text.Json bump to 6.0.10 for a security fix across half a dozen Storage and Functions packages, and you should take that regardless of anything else in this release. The features actually worth planning around are the vector search compression truncation option if you run Azure AI Search at meaningful scale, and the CAE support in Azure.Core if your organization enforces Conditional Access policies. Treat the OpenAI SDK jump to 2.0.0 as a scheduled migration with a proper test pass rather than a drop in update.