/*
* This sample demonstrates how to use Azure App Configuration to store
* two (2) groups of settings with information about two different
* application environments "beta" and "production". To do this, we will
* create Configuration Settings with the same key, but different labels:
* one for "beta" and one for "production".
*/
public async Task HelloWorldExtended()
{
// Retrieve the connection string from the environment.
// The connection string is available from the App Configuration Access Keys view in the Azure Portal.
var connectionString = Environment.GetEnvironmentVariable("APPCONFIGURATION_CONNECTION_STRING");
// Instantiate a client that will be used to call the service.
var client = new ConfigurationClient(connectionString);
// Create the Configuration Settings to be stored in the Configuration Store.
var betaEndpoint = new ConfigurationSetting("endpoint", "https://beta.endpoint.com", "beta");
var betaInstances = new ConfigurationSetting("instances", "1", "beta");
var productionEndpoint = new ConfigurationSetting("endpoint", "https://production.endpoint.com", "production");
var productionInstances = new ConfigurationSetting("instances", "1", "production");
// There are two ways to create a Configuration Setting:
// - AddConfigurationSettingAsync creates a setting only if the setting does not already exist in the store.
// - SetConfigurationSettingAsync creates a setting if it doesn't exist or overrides an existing setting with the same key and label.
await client.AddConfigurationSettingAsync(betaEndpoint);
await client.AddConfigurationSettingAsync(betaInstances);
await client.AddConfigurationSettingAsync(productionEndpoint);
await client.AddConfigurationSettingAsync(productionInstances);
// In our scenario, there is a need to increase production instances from 1 to 5.
// We use GetConfigurationSettingAsync to accomplish this.
ConfigurationSetting instancesToUpdate = await client.GetConfigurationSettingAsync(productionInstances.Key, productionInstances.Label);
instancesToUpdate.Value = "5";
await client.SetConfigurationSettingAsync(instancesToUpdate);
// To gather all the information available for the "production" environment, we can
// call GetConfigurationSettingsAsync a setting selector that filters for settings
// with the "production" label. This will retrieve all the Configuration Settings
// in the store that satisfy that condition.
var selector = new SettingSelector {
LabelFilter = "production"
};
Debug.WriteLine("Settings for Production environment:");
await foreach (ConfigurationSetting setting in client.GetConfigurationSettingsAsync(selector))
{
Debug.WriteLine(setting);
}
// Delete the Configuration Settings from the Configuration Store.
await client.DeleteConfigurationSettingAsync(betaEndpoint.Key, betaEndpoint.Label);
await client.DeleteConfigurationSettingAsync(betaInstances.Key, betaInstances.Label);
await client.DeleteConfigurationSettingAsync(productionEndpoint.Key, productionEndpoint.Label);
await client.DeleteConfigurationSettingAsync(productionInstances.Key, productionInstances.Label);
}
/*
* Sample demonstrates how to use Azure App Configuration to save information about two(2) environments
* "beta" and "production".
* To do this, we will create Configuration Settings with the same key,
* but different labels: one for "beta" and one for "production".
*/
public async Task HelloWorldExtended()
{
// Retrieve the connection string from the configuration store.
// You can get the string from your Azure portal or using Azure CLI.
var connectionString = Environment.GetEnvironmentVariable("APPCONFIGURATION_CONNECTION_STRING");
// Instantiate a client that will be used to call the service.
var client = new ConfigurationClient(connectionString);
// Create the Configuration Settings to be stored in the Configuration Store.
var betaEndpoint = new ConfigurationSetting("endpoint", "https://beta.endpoint.com", "beta");
var betaInstances = new ConfigurationSetting("instances", "1", "beta");
var productionEndpoint = new ConfigurationSetting("endpoint", "https://production.endpoint.com", "production");
var productionInstances = new ConfigurationSetting("instances", "1", "production");
// There are two(2) ways to store a Configuration Setting:
// -AddAsync creates a setting only if the setting does not already exist in the store.
// -SetAsync creates a setting if it doesn't exist or overrides an existing setting
await client.AddConfigurationSettingAsync(betaEndpoint);
await client.AddConfigurationSettingAsync(betaInstances);
await client.AddConfigurationSettingAsync(productionEndpoint);
await client.AddConfigurationSettingAsync(productionInstances);
// There is a need to increase the production instances from 1 to 5.
// The SetAsync will help us with this.
ConfigurationSetting instancesToUpdate = await client.GetConfigurationSettingAsync(productionInstances.Key, productionInstances.Label);
instancesToUpdate.Value = "5";
await client.SetConfigurationSettingAsync(instancesToUpdate);
// We want to gather all the information available for the "production' environment.
// By calling GetBatchSync with the proper filter for label "production", we will get
// all the Configuration Settings that satisfy that condition.
var selector = new SettingSelector(SettingSelector.Any, "production");
Debug.WriteLine("Settings for Production environment:");
await foreach (ConfigurationSetting setting in client.GetConfigurationSettingsAsync(selector))
{
Debug.WriteLine(setting);
}
// Once we don't need the Configuration Settings, we can delete them.
await client.DeleteConfigurationSettingAsync(betaEndpoint.Key, betaEndpoint.Label);
await client.DeleteConfigurationSettingAsync(betaInstances.Key, betaInstances.Label);
await client.DeleteConfigurationSettingAsync(productionEndpoint.Key, productionEndpoint.Label);
await client.DeleteConfigurationSettingAsync(productionInstances.Key, productionInstances.Label);
}
public async Task SetSettingReadOnly()
{
ConfigurationClient service = GetClient();
ConfigurationSetting testSetting = CreateSetting();
try
{
await service.AddConfigurationSettingAsync(testSetting);
await service.SetReadOnlyAsync(testSetting.Key, testSetting.Label, true);
testSetting.Value = "new_value";
// Test
RequestFailedException exception = Assert.ThrowsAsync <RequestFailedException>(async() =>
await service.SetConfigurationSettingAsync(testSetting.Key, "new_value", testSetting.Label));
Assert.AreEqual(409, exception.Status);
}
finally
{
await service.SetReadOnlyAsync(testSetting.Key, testSetting.Label, false);
await service.DeleteConfigurationSettingAsync(testSetting.Key, testSetting.Label);
}
}
public async Task GetIfChangedSettingUnmodified()
{
ConfigurationClient service = GetClient();
ConfigurationSetting testSetting = CreateSetting();
try
{
ConfigurationSetting setting = await service.AddConfigurationSettingAsync(testSetting);
// Test
Response <ConfigurationSetting> response = await service.GetConfigurationSettingAsync(setting, onlyIfChanged : true).ConfigureAwait(false);
Assert.AreEqual(304, response.GetRawResponse().Status);
bool throws = false;
try
{
ConfigurationSetting value = response.Value;
}
catch
{
throws = true;
}
Assert.IsTrue(throws);
}
finally
{
await service.DeleteConfigurationSettingAsync(testSetting.Key, testSetting.Label);
}
}
public async Task GetBatchSettingWithReadOnly()
{
ConfigurationClient service = GetClient();
string key = GenerateKeyId("key-");
ConfigurationSetting setting = await service.AddConfigurationSettingAsync(key, "my_value", "my_label");
try
{
SettingSelector selector = new SettingSelector
{
KeyFilter = key,
Fields = SettingFields.Key | SettingFields.IsReadOnly
};
List <ConfigurationSetting> batch = await service.GetConfigurationSettingsAsync(selector, CancellationToken.None).ToEnumerableAsync();
CollectionAssert.IsNotEmpty(batch);
Assert.IsNotNull(batch[0].Key);
Assert.IsNotNull(batch[0].IsReadOnly);
Assert.IsNull(batch[0].Label);
Assert.IsNull(batch[0].Value);
Assert.IsNull(batch[0].ContentType);
Assert.IsNull(batch[0].LastModified);
Assert.AreEqual(batch[0].ETag, default(ETag));
}
finally
{
await service.DeleteConfigurationSettingAsync(setting.Key, setting.Label);
}
}
public async Task GetBatchSettingWithFields()
{
ConfigurationClient service = GetClient();
string key = GenerateKeyId("keyFields-");
ConfigurationSetting setting = await service.AddConfigurationSettingAsync(key, "my_value", "my_label");
try
{
SettingSelector selector = new SettingSelector
{
KeyFilter = key,
Fields = SettingFields.Key | SettingFields.Label | SettingFields.ETag
};
ConfigurationSetting[] batch = (await service.GetConfigurationSettingsAsync(selector, CancellationToken.None).ToEnumerableAsync())
.ToArray();
Assert.AreEqual(1, batch.Length);
Assert.IsNotNull(batch[0].Key);
Assert.IsNotNull(batch[0].Label);
Assert.IsNotNull(batch[0].ETag);
Assert.IsNull(batch[0].Value);
Assert.IsNull(batch[0].ContentType);
Assert.IsNull(batch[0].LastModified);
Assert.IsNull(batch[0].IsReadOnly);
}
finally
{
await service.DeleteConfigurationSettingAsync(setting.Key, setting.Label);
}
}
public async Task RequestHasSpecificApiVersionOnlyOnceOnRetry()
{
var response = new MockResponse(200);
response.SetContent(SerializationHelpers.Serialize(s_testSetting, SerializeSetting));
var mockTransport = new MockTransport(new MockResponse(503), response);
var options = new ConfigurationClientOptions(ConfigurationClientOptions.ServiceVersion.V1_0);
options.Diagnostics.ApplicationId = "test_application";
options.Transport = mockTransport;
ConfigurationClient client = CreateClient <ConfigurationClient>(s_connectionString, options);
await client.AddConfigurationSettingAsync(s_testSetting);
MockRequest request = mockTransport.Requests[0];
MockRequest retriedRequest = mockTransport.Requests[1];
const string expectedApiString = "api-version=1.0";
StringAssert.Contains(expectedApiString, request.Uri.Query);
StringAssert.Contains(expectedApiString, retriedRequest.Uri.Query);
var apiStringFirstIndex = retriedRequest.Uri.Query.IndexOf(expectedApiString, StringComparison.Ordinal);
var apiStringLastIndex = retriedRequest.Uri.Query.LastIndexOf(expectedApiString, StringComparison.Ordinal);
Assert.AreEqual(apiStringFirstIndex, apiStringLastIndex);
}
private async Task <string> SetMultipleKeys(ConfigurationClient service, int expectedEvents)
{
string key = GenerateKeyId("key-");
/*
* The configuration store contains a KV with the Key
* that represents {expectedEvents} data points.
* If not set, create the {expectedEvents} data points and the "BatchKey"
*/
const string batchKey = "BatchKey";
try
{
Response <ConfigurationSetting> responseGet = await service.GetConfigurationSettingAsync(batchKey);
key = responseGet.Value.Value;
}
catch
{
for (int i = 0; i < expectedEvents; i++)
{
await service.AddConfigurationSettingAsync(new ConfigurationSetting(key, "test_value", $"{i.ToString()}"));
}
await service.SetConfigurationSettingAsync(new ConfigurationSetting(batchKey, key));
}
return(key);
}
public async Task DeleteIfUnchangedSettingUnmodified()
{
ConfigurationClient service = GetClient();
ConfigurationSetting testSetting = CreateSetting();
ConfigurationSetting setting = await service.AddConfigurationSettingAsync(testSetting);
AssertStatus200(await service.DeleteConfigurationSettingAsync(setting, onlyIfUnchanged: true));
}
public async Task AddExistingSetting()
{
ConfigurationClient service = GetClient();
ConfigurationSetting testSetting = CreateSetting();
try
{
await service.AddConfigurationSettingAsync(testSetting);
RequestFailedException exception = Assert.ThrowsAsync <RequestFailedException>(async() =>
{
await service.AddConfigurationSettingAsync(testSetting);
});
Assert.AreEqual(412, exception.Status);
}
finally
{
await service.DeleteConfigurationSettingAsync(testSetting.Key, testSetting.Label);
}
}
public void AddAlreadyExists()
{
var response = new MockResponse(412);
var mockTransport = new MockTransport(response);
ConfigurationClient service = CreateTestService(mockTransport);
RequestFailedException exception = Assert.ThrowsAsync <RequestFailedException>(async() =>
{
ConfigurationSetting setting = await service.AddConfigurationSettingAsync(s_testSetting);
});
Assert.AreEqual(412, exception.Status);
}
public async Task RequestHasApiVersionQuery()
{
var response = new MockResponse(200);
response.SetContent(SerializationHelpers.Serialize(s_testSetting, SerializeSetting));
var mockTransport = new MockTransport(response);
ConfigurationClient service = CreateTestService(mockTransport);
ConfigurationSetting setting = await service.AddConfigurationSettingAsync(s_testSetting);
MockRequest request = mockTransport.SingleRequest;
StringAssert.Contains("api-version", request.Uri.ToUri().ToString());
}
public async Task AddSettingDefaultAAD()
{
ConfigurationClient service = GetAADClient();
ConfigurationSetting testSetting = CreateSetting();
try
{
ConfigurationSetting setting = await service.AddConfigurationSettingAsync(testSetting);
Assert.True(ConfigurationSettingEqualityComparer.Instance.Equals(testSetting, setting));
}
finally
{
AssertStatus200(await service.DeleteConfigurationSettingAsync(testSetting));
}
}
public async Task AddSetting()
{
ConfigurationClient service = GetClient();
ConfigurationSetting testSetting = CreateSetting();
try
{
ConfigurationSetting setting = await service.AddConfigurationSettingAsync(testSetting);
Assert.True(ConfigurationSettingEqualityComparer.Instance.Equals(testSetting, setting));
}
finally
{
await service.DeleteConfigurationSettingAsync(testSetting.Key, testSetting.Label);
}
}
public async Task ClearReadOnlyFromSetting()
{
ConfigurationClient service = GetClient();
ConfigurationSetting testSetting = CreateSetting();
try
{
var setting = await service.AddConfigurationSettingAsync(testSetting);
var readOnly = await service.SetReadOnlyAsync(testSetting.Key, testSetting.Label, false);
Assert.IsFalse(readOnly.Value.IsReadOnly);
}
finally
{
await service.DeleteConfigurationSettingAsync(testSetting.Key, testSetting.Label);
}
}
public async Task AddKeyValue()
{
ConfigurationClient service = GetClient();
string key = GenerateKeyId("key-");
try
{
string value = "my_value";
ConfigurationSetting setting = await service.AddConfigurationSettingAsync(key, value);
Assert.AreEqual(key, setting.Key);
Assert.AreEqual(value, setting.Value);
}
finally
{
await service.DeleteConfigurationSettingAsync(key);
}
}
public async Task DeleteIfUnchangedSettingUnmodified()
{
ConfigurationClient service = GetClient();
ConfigurationSetting testSetting = CreateSetting();
try
{
ConfigurationSetting setting = await service.AddConfigurationSettingAsync(testSetting);
// Test
Response response = await service.DeleteConfigurationSettingAsync(setting, onlyIfUnchanged : true);
Assert.AreEqual(200, response.Status);
}
finally
{
await service.DeleteConfigurationSettingAsync(testSetting.Key, testSetting.Label);
}
}
public async Task AddSettingNoLabel()
{
ConfigurationClient service = GetClient();
ConfigurationSetting testSetting = CreateSetting();
ConfigurationSetting testSettingNoLabel = testSetting.Clone();
testSettingNoLabel.Label = null;
try
{
ConfigurationSetting setting = await service.AddConfigurationSettingAsync(testSettingNoLabel);
Assert.True(ConfigurationSettingEqualityComparer.Instance.Equals(testSettingNoLabel, setting));
}
finally
{
AssertStatus200(await service.DeleteConfigurationSettingAsync(testSetting.Key));
}
}
public async Task AuthorizationHeaderFormat()
{
var expectedSyntax = $"HMAC-SHA256 Credential={s_credential}&SignedHeaders=date;host;x-ms-content-sha256&Signature=(.+)";
var response = new MockResponse(200);
response.SetContent(SerializationHelpers.Serialize(s_testSetting, SerializeSetting));
var mockTransport = new MockTransport(response);
ConfigurationClient service = CreateTestService(mockTransport);
ConfigurationSetting setting = await service.AddConfigurationSettingAsync(s_testSetting);
MockRequest request = mockTransport.SingleRequest;
AssertRequestCommon(request);
Assert.True(request.Headers.TryGetValue("Authorization", out var authHeader));
Assert.True(Regex.IsMatch(authHeader, expectedSyntax));
}
public async Task RequestHasSpecificApiVersion()
{
var response = new MockResponse(200);
response.SetContent(SerializationHelpers.Serialize(s_testSetting, SerializeSetting));
var mockTransport = new MockTransport(response);
var options = new ConfigurationClientOptions(ConfigurationClientOptions.ServiceVersion.V1_0);
options.Diagnostics.ApplicationId = "test_application";
options.Transport = mockTransport;
ConfigurationClient client = CreateClient <ConfigurationClient>(s_connectionString, options);
ConfigurationSetting setting = await client.AddConfigurationSettingAsync(s_testSetting);
MockRequest request = mockTransport.SingleRequest;
StringAssert.Contains("api-version=1.0", request.Uri.ToUri().ToString());
}
public async Task AddKeyValueLabel()
{
ConfigurationClient service = GetClient();
string key = GenerateKeyId("key-");
string value = "my_value";
string label = "my_label";
try
{
ConfigurationSetting setting = await service.AddConfigurationSettingAsync(key, value, label);
Assert.AreEqual(key, setting.Key);
Assert.AreEqual(value, setting.Value);
Assert.AreEqual(label, setting.Label);
}
finally
{
AssertStatus200(await service.DeleteConfigurationSettingAsync(key, label));
}
}
public async Task Add()
{
var response = new MockResponse(200);
response.SetContent(SerializationHelpers.Serialize(s_testSetting, SerializeSetting));
var mockTransport = new MockTransport(response);
ConfigurationClient service = CreateTestService(mockTransport);
ConfigurationSetting setting = await service.AddConfigurationSettingAsync(s_testSetting);
MockRequest request = mockTransport.SingleRequest;
AssertRequestCommon(request);
Assert.AreEqual(RequestMethod.Put, request.Method);
Assert.AreEqual($"https://contoso.appconfig.io/kv/test_key?label=test_label&api-version={s_version}", request.Uri.ToString());
Assert.True(request.Headers.TryGetValue("If-None-Match", out var ifNoneMatch));
Assert.AreEqual("*", ifNoneMatch);
AssertContent(SerializationHelpers.Serialize(s_testSetting, SerializeRequestSetting), request);
Assert.True(ConfigurationSettingEqualityComparer.Instance.Equals(s_testSetting, setting));
}
public async Task ConfigurationClient_SetReadOnly_OnlyIfUnchanged_Modified([Values(true, false)] bool isReadOnly)
{
ConfigurationClient service = GetClient();
ConfigurationSetting testSetting = CreateSetting();
try
{
ConfigurationSetting setting = await service.AddConfigurationSettingAsync(testSetting);
ConfigurationSetting modifiedSetting = setting.Clone();
modifiedSetting.Value = "new_value";
await service.SetConfigurationSettingAsync(modifiedSetting);
// Test
RequestFailedException exception = Assert.ThrowsAsync <RequestFailedException>(async() => await service.SetReadOnlyAsync(setting, isReadOnly, onlyIfUnchanged: true));
Assert.AreEqual(412, exception.Status);
}
finally
{
AssertStatus200(await service.DeleteConfigurationSettingAsync(testSetting.Key, testSetting.Label));
}
}
public async Task SetIfUnchangedSettingModified()
{
ConfigurationClient service = GetClient();
ConfigurationSetting testSetting = CreateSetting();
try
{
ConfigurationSetting setting = await service.AddConfigurationSettingAsync(testSetting);
ConfigurationSetting modifiedSetting = setting.Clone();
modifiedSetting.Value = "new_value";
modifiedSetting = await service.SetConfigurationSettingAsync(modifiedSetting);
// Test
RequestFailedException exception = Assert.ThrowsAsync <RequestFailedException>(async() =>
await service.SetConfigurationSettingAsync(setting, onlyIfUnchanged: true));
Assert.AreEqual(412, exception.Status);
}
finally
{
await service.DeleteConfigurationSettingAsync(testSetting.Key, testSetting.Label);
}
}
public async Task SetIfUnchangedSettingUnmodified()
{
ConfigurationClient service = GetClient();
ConfigurationSetting testSetting = CreateSetting();
try
{
ConfigurationSetting setting = await service.AddConfigurationSettingAsync(testSetting);
setting.Value = "new_value";
// Test
Response <ConfigurationSetting> response = await service.SetConfigurationSettingAsync(setting, onlyIfUnchanged : true);
Assert.AreEqual(200, response.GetRawResponse().Status);
Assert.AreEqual(setting.Value, response.Value.Value);
Assert.AreNotEqual(setting.ETag, response.Value.ETag);
}
finally
{
await service.DeleteConfigurationSettingAsync(testSetting.Key, testSetting.Label);
}
}
public async Task ConfigurationClient_SetReadOnly_OnlyIfUnchanged_Unmodified([Values(true, false)] bool isReadOnly)
{
ConfigurationClient service = GetClient();
ConfigurationSetting testSetting = CreateSetting();
try
{
ConfigurationSetting setting = await service.AddConfigurationSettingAsync(testSetting);
setting = await service.SetReadOnlyAsync(setting, !isReadOnly, onlyIfUnchanged : true);
Assert.AreEqual(!isReadOnly, setting.IsReadOnly);
setting = await service.SetReadOnlyAsync(setting, isReadOnly, onlyIfUnchanged : true);
Assert.AreEqual(isReadOnly, setting.IsReadOnly);
}
finally
{
await service.SetReadOnlyAsync(testSetting.Key, testSetting.Label, false);
AssertStatus200(await service.DeleteConfigurationSettingAsync(testSetting.Key, testSetting.Label));
}
}
public async Task GetIfChangedSettingModified()
{
ConfigurationClient service = GetClient();
ConfigurationSetting testSetting = CreateSetting();
try
{
ConfigurationSetting setting = await service.AddConfigurationSettingAsync(testSetting);
ConfigurationSetting modifiedSetting = setting.Clone();
modifiedSetting.Value = "new_value";
modifiedSetting = await service.SetConfigurationSettingAsync(modifiedSetting);
Response <ConfigurationSetting> response = await service.GetConfigurationSettingAsync(setting, onlyIfChanged : true).ConfigureAwait(false);
Assert.AreEqual(200, response.GetRawResponse().Status);
Assert.True(ConfigurationSettingEqualityComparer.Instance.Equals(modifiedSetting, response.Value));
}
finally
{
await service.DeleteConfigurationSettingAsync(testSetting.Key, testSetting.Label);
}
}
public async Task DeleteSettingReadOnly()
{
ConfigurationClient service = GetClient();
ConfigurationSetting testSetting = CreateSetting();
try
{
var setting = await service.AddConfigurationSettingAsync(testSetting);
var readOnly = await service.SetReadOnlyAsync(testSetting.Key, testSetting.Label);
// Test
RequestFailedException exception = Assert.ThrowsAsync <RequestFailedException>(async() =>
await service.DeleteConfigurationSettingAsync(testSetting.Key, testSetting.Label)
);
Assert.AreEqual(409, exception.Status);
}
finally
{
await service.ClearReadOnlyAsync(testSetting.Key, testSetting.Label);
await service.DeleteConfigurationSettingAsync(testSetting.Key, testSetting.Label);
}
}
static async Task Main(string[] args)
{
int value;
var client = new ConfigurationClient("");
Console.WriteLine("Hello!");
Console.WriteLine("Enter 1 for app configuration and 2 for feature flags");
Console.WriteLine("Enter:");
value = Convert.ToInt32(Console.ReadLine());
if (value == 1)
{
Console.WriteLine("Enter 1 to write the following configuration values to Azure App Configuration");
Console.WriteLine("{'InspectionBookings':true, 'Inspections':true, 'InspectionPlans':true, 'InspectionTasks':true}");
Console.WriteLine("Enter:");
value = Convert.ToInt32(Console.ReadLine());
if (value == 1)
{
var inspectionBookings = new ConfigurationSetting("InspectionBookings", "true", "SubDemo");
var inspections = new ConfigurationSetting("Inspections", "true", "SubDemo");
var inspectionPlans = new ConfigurationSetting("InspectionPlans", "true", "SubDemo");
var inspectionTasks = new ConfigurationSetting("InspectionTasks", "true", "SubDemo");
await client.AddConfigurationSettingAsync(inspectionBookings);
await client.AddConfigurationSettingAsync(inspections);
await client.AddConfigurationSettingAsync(inspectionPlans);
await client.AddConfigurationSettingAsync(inspectionTasks);
Console.WriteLine();
Console.WriteLine("Enter 2 to update the value of Inspections and InspectionPlans to false");;
Console.WriteLine("Enter:");
ConfigurationSetting inspectionToUpdate = await client.GetConfigurationSettingAsync(inspections.Key, inspections.Label);
ConfigurationSetting inspectionPlansToUpdate = await client.GetConfigurationSettingAsync(inspectionPlans.Key, inspectionPlans.Label);
inspectionToUpdate.Value = "false";
inspectionPlansToUpdate.Value = "false";
value = Convert.ToInt32(Console.ReadLine());
if (value == 2)
{
await client.SetConfigurationSettingAsync(inspectionToUpdate);
await client.SetConfigurationSettingAsync(inspectionPlansToUpdate);
Console.WriteLine();
Console.WriteLine("Enter 3 to delete added configuration values");
Console.WriteLine("Enter:");
value = Convert.ToInt32(Console.ReadLine());
if (value == 3)
{
await client.DeleteConfigurationSettingAsync(inspectionBookings.Key, inspectionBookings.Label);
await client.DeleteConfigurationSettingAsync(inspections.Key, inspections.Label);
await client.DeleteConfigurationSettingAsync(inspectionPlans.Key, inspectionPlans.Label);
await client.DeleteConfigurationSettingAsync(inspectionTasks.Key, inspectionTasks.Label);
}
}
}
}
else if (value == 2)
{
Console.WriteLine("Enter 1 to write the following feature flags to Azure App Configuration feature manager");
Console.WriteLine("{'Subscriptions':true, 'Inspections':true, 'Registry':true, 'Schools':true}");
Console.WriteLine("Enter:");
value = Convert.ToInt32(Console.ReadLine());
if (value == 1)
{
var featurefilters = new List <FeatureFlagFilter>
{
new FeatureFlagFilter("BrowserFeatureFilter", new Dictionary <string, object> {
{ "Allowed", new string[] { "Edg" } }
}),
new FeatureFlagFilter("PercentageFilter", new Dictionary <string, object> {
{ "Value", 55 }
})
};
var xxx = new {
id = "Subscriptions",
description = "",
enabled = true,
conditions = new
{
client_filters = new [] {
new { name = "Microsoft.Percentage", parameters = new { Value = 55 } },
new { name = "Browser", parameters = new { Value = 55 } },
}
}
};
var stinxxx = xxx.ToString();
var strinxxx = JsonConvert.SerializeObject(xxx);
var subscriptions = new ConfigurationSetting($"{FeatureFlagConfigurationSetting.KeyPrefix}Subscriptions", strinxxx, "SubDemo")
{
ContentType = "application/vnd.microsoft.appconfig.ff+json;charset=utf-8"
};
var inspections = new FeatureFlagConfigurationSetting("Inspections", true, "SubDemo");
var registry = new FeatureFlagConfigurationSetting("Registry", true, "SubDemo");
var schools = new FeatureFlagConfigurationSetting("Schools", true, "SubDemo");
await client.AddConfigurationSettingAsync(subscriptions);
await client.AddConfigurationSettingAsync(inspections);
await client.AddConfigurationSettingAsync(registry);
await client.AddConfigurationSettingAsync(schools);
Console.WriteLine();
Console.WriteLine("Enter 2 to update the value of Inspections and Registry to false");;
Console.WriteLine("Enter:");
inspections.IsEnabled = false;
registry.IsEnabled = false;
value = Convert.ToInt32(Console.ReadLine());
if (value == 2)
{
await client.SetConfigurationSettingAsync(inspections);
await client.SetConfigurationSettingAsync(registry);
Console.WriteLine();
Console.WriteLine("Enter 3 to delete added configuration values");
Console.WriteLine("Enter:");
value = Convert.ToInt32(Console.ReadLine());
if (value == 3)
{
await client.DeleteConfigurationSettingAsync(subscriptions);
await client.DeleteConfigurationSettingAsync(inspections);
await client.DeleteConfigurationSettingAsync(registry);
await client.DeleteConfigurationSettingAsync(schools);
}
}
}
}
}
public async Task HelloWorldExtended()
{
var connectionString = TestEnvironment.ConnectionString;
#region Snippet:AzConfigSample2_CreateConfigurationClient
var client = new ConfigurationClient(connectionString);
#endregion
#region Snippet:AzConfigSample2_CreateConfigurationSettingAsync
var betaEndpoint = new ConfigurationSetting("endpoint", "https://beta.endpoint.com", "beta");
var betaInstances = new ConfigurationSetting("instances", "1", "beta");
var productionEndpoint = new ConfigurationSetting("endpoint", "https://production.endpoint.com", "production");
var productionInstances = new ConfigurationSetting("instances", "1", "production");
#endregion
#region Snippet:AzConfigSample2_AddConfigurationSettingAsync
await client.AddConfigurationSettingAsync(betaEndpoint);
await client.AddConfigurationSettingAsync(betaInstances);
await client.AddConfigurationSettingAsync(productionEndpoint);
await client.AddConfigurationSettingAsync(productionInstances);
#endregion
#region Snippet:AzConfigSample2_GetConfigurationSettingAsync
ConfigurationSetting instancesToUpdate = await client.GetConfigurationSettingAsync(productionInstances.Key, productionInstances.Label);
#endregion
#region Snippet:AzConfigSample2_SetUpdatedConfigurationSettingAsync
instancesToUpdate.Value = "5";
await client.SetConfigurationSettingAsync(instancesToUpdate);
#endregion
#region Snippet:AzConfigSample2_GetConfigurationSettingsAsync
var selector = new SettingSelector {
LabelFilter = "production"
};
Debug.WriteLine("Settings for Production environment:");
await foreach (ConfigurationSetting setting in client.GetConfigurationSettingsAsync(selector))
{
Console.WriteLine(setting);
}
#endregion
// Delete the Configuration Settings from the Configuration Store.
#region Snippet:AzConfigSample2_DeleteConfigurationSettingAsync
await client.DeleteConfigurationSettingAsync(betaEndpoint.Key, betaEndpoint.Label);
await client.DeleteConfigurationSettingAsync(betaInstances.Key, betaInstances.Label);
await client.DeleteConfigurationSettingAsync(productionEndpoint.Key, productionEndpoint.Label);
await client.DeleteConfigurationSettingAsync(productionInstances.Key, productionInstances.Label);
#endregion
}
