static void Main(string[] args)
{
IUnityContainer container = new UnityContainer();
UnityApplicationFrameworkDependencyResolver resolver = new UnityApplicationFrameworkDependencyResolver(container);
Bootstrapper.RegisterDependencies(resolver, null, Bootstrapper.LoggerTypeEnum.Console, "correlation-id");
resolver.Register<IHostableComponent, ExampleHostableComponent>(ExampleHostableComponent.FullyQualifiedName);
IComponentHost componentHost = resolver.Resolve<IComponentHost>();
componentHost.Start(new StaticComponentHostConfigurationProvider(new List<ComponentConfiguration>
{
new ComponentConfiguration
{
ComponentIdentity = new ComponentIdentity(ExampleHostableComponent.FullyQualifiedName),
Instances = 1,
RestartEvaluator = (ex, retryCount) =>
{
RestartHandler(ex, retryCount,
new ComponentIdentity(ExampleHostableComponent.FullyQualifiedName));
return true;
}
}
}), new CancellationTokenSource());
Console.Read();
}
private static async Task SimpleSaveAndRetrieve()
{
IUnityContainer container = new UnityContainer();
UnityApplicationFrameworkDependencyResolver resolver = new UnityApplicationFrameworkDependencyResolver(container);
resolver
.UseCore(defaultTraceLoggerMinimumLogLevel:LogLevelEnum.Verbose)
.UseAzure();
var resourceManager = container.Resolve<IAzureResourceManager>();
var tableStorageRepositoryFactory = container.Resolve<ITableStorageRepositoryFactory>();
var table = tableStorageRepositoryFactory.CreateAsynchronousNoSqlRepository<SampleEntity>(StorageAccountConnectionString, TableName);
await resourceManager.CreateIfNotExistsAsync(table);
string partitionKey = Guid.NewGuid().ToString();
string rowKey = Guid.NewGuid().ToString();
await table.InsertAsync(new SampleEntity
{
Name = "Someone New",
PartitionKey = partitionKey,
RowKey = rowKey
});
SampleEntity retrievedEntity = await table.GetAsync(partitionKey, rowKey);
Console.WriteLine(retrievedEntity.Name);
}
static void Main(string[] args)
{
IUnityContainer container = new UnityContainer();
UnityApplicationFrameworkDependencyResolver resolver = new UnityApplicationFrameworkDependencyResolver(container);
resolver.UseCore(defaultTraceLoggerMinimumLogLevel: LogLevelEnum.Verbose);
IAsynchronousBackoffPolicy policy = resolver.Resolve<IAsynchronousBackoffPolicy>();
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
Task.Run(async () =>
{
try
{
await policy.ExecuteAsync(BackoffTask, cancellationTokenSource.Token);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
});
Console.WriteLine("Press a key to finish...");
Console.ReadKey();
cancellationTokenSource.Cancel();
}
static void Main(string[] args)
{
// don't do this in a production app - use something like Stephen Cleary's AsyncContext
Task.Run(async () =>
{
IUnityContainer container = new UnityContainer();
IDependencyResolver resolver = new UnityApplicationFrameworkDependencyResolver(container);
string clientId = ConfigurationManager.AppSettings["keyVaultClientId"];
string clientSecret = ConfigurationManager.AppSettings["keyVaultClientSecret"];
string vaultUri = ConfigurationManager.AppSettings["keyVaultUri"];
resolver
.UseCore()
.UseAzure()
.UseAsyncKeyVaultApplicationConfiguration(clientId, clientSecret, vaultUri);
resolver.Register<ISampleWorker, SampleWorker>();
ISampleWorker worker = resolver.Resolve<ISampleWorker>();
await worker.Post();
await worker.Read();
}).Wait();
Console.ReadKey();
}
static void Main(string[] args)
{
IUnityContainer container = new UnityContainer();
UnityApplicationFrameworkDependencyResolver resolver = new UnityApplicationFrameworkDependencyResolver(container);
Bootstrapper.RegisterDependencies(resolver);
IAsynchronousBackoffPolicy policy = resolver.Resolve<IAsynchronousBackoffPolicy>();
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
Task.Run(async () =>
{
try
{
await policy.Execute(BackoffTask, cancellationTokenSource.Token);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
});
Console.WriteLine("Press a key to finish...");
Console.ReadKey();
cancellationTokenSource.Cancel();
}
static void Main(string[] args)
{
IUnityContainer container = new UnityContainer();
IDependencyResolver dependencyResolver = new UnityApplicationFrameworkDependencyResolver(container);
dependencyResolver
.UseCore()
.UseAzure();
IAzureResourceManager azureResourceManager = dependencyResolver.Resolve<IAzureResourceManager>();
ILargeMessageQueueFactory largeMessageQueueFactory = dependencyResolver.Resolve<ILargeMessageQueueFactory>();
ILargeMessageQueue<SampleLargeQueueItem> queue = largeMessageQueueFactory.Create<SampleLargeQueueItem>(StorageAccountConnectionString, "samplereferencequeue", "samplequeueblobs");
azureResourceManager.CreateIfNotExistsAsync(queue.ReferenceQueue).Wait();
azureResourceManager.CreateIfNotExistsAsync(queue.BlobRepository).Wait();
queue.EnqueueAsync(CreateLargeQueueItem()).Wait();
Console.WriteLine("Queued large item. Press a key to dequeue...");
Console.ReadKey();
queue.DequeueAsync(message =>
{
SampleLargeQueueItem item = message.Item;
Console.WriteLine("Dequeued large item of text length {0}. Press a key....", item.LotsOfText.Length);
return Task.FromResult(true);
}).Wait();
Console.ReadKey();
}
private static async Task<string> LargeBatchInsert()
{
IUnityContainer container = new UnityContainer();
UnityApplicationFrameworkDependencyResolver resolver = new UnityApplicationFrameworkDependencyResolver(container);
resolver
.UseCore(defaultTraceLoggerMinimumLogLevel: LogLevelEnum.Verbose)
.UseAzure();
var resourceManager = container.Resolve<IAzureResourceManager>();
var tableStorageRepositoryFactory = container.Resolve<ITableStorageRepositoryFactory>();
var table = tableStorageRepositoryFactory.CreateAsynchronousNoSqlRepository<SampleEntity>(StorageAccountConnectionString, TableName);
await resourceManager.CreateIfNotExistsAsync(table);
string partitionKey = Guid.NewGuid().ToString();
List<SampleEntity> entities = new List<SampleEntity>();
for (int item = 0; item < 725; item++)
{
entities.Add(new SampleEntity
{
Name = $"Name {item}",
PartitionKey = partitionKey,
RowKey = Guid.NewGuid().ToString()
});
}
await table.InsertBatchAsync(entities);
Console.WriteLine($"Inserted 725 items into partition {partitionKey}");
return partitionKey;
}
static void Main(string[] args)
{
IUnityContainer container = new UnityContainer();
UnityApplicationFrameworkDependencyResolver resolver = new UnityApplicationFrameworkDependencyResolver(container);
resolver
.UseCore()
.UseAzure();
IApplicationResourceFactory applicationResourceFactory = container.Resolve<IApplicationResourceFactory>();
string secondSubscriptionName = applicationResourceFactory.Setting(SampleComponent, "second-subscription");
IAsynchronousTopic<MyMessage> topic = applicationResourceFactory.GetAsyncTopic<MyMessage>(SampleComponent);
IAsynchronousSubscription<MyMessage> firstSubscription = applicationResourceFactory.GetAsyncSubscription<MyMessage>(SampleComponent);
IAsynchronousSubscription<MyMessage> secondSubscription = applicationResourceFactory.GetAsyncSubscription<MyMessage>(secondSubscriptionName, SampleComponent);
// below is exceedingly naive but is just to illustrate api usage
Task.Run(async () =>
{
while (true)
{
await Task.Delay(1500);
await firstSubscription.RecieveAsync(m =>
{
System.Console.Write("First Subscription: ");
System.Console.WriteLine(m.SaySomething);
return Task.FromResult(true);
});
}
});
Task.Run(async () =>
{
while (true)
{
await Task.Delay(3333);
await secondSubscription.RecieveQueueItemAsync(m =>
{
System.Console.Write("Second Subscription: ");
System.Console.WriteLine(m.Item.SaySomething);
return Task.FromResult(true);
});
}
});
topic.SendAsync(new MyMessage
{
SaySomething = "Hello World"
}, new Dictionary<string, object>
{
{"P1", 56},
{"P2", "Zaphod"}
});
System.Console.Read();
}
// Default configuration writing to the trace pipe without using a factory.
private static void DefaultConfigurationSampleNoFactory()
{
IUnityContainer container = new UnityContainer();
IDependencyResolver dependencyResolver = new UnityApplicationFrameworkDependencyResolver(container);
dependencyResolver
.UseCore()
.UseSerilog();
ILogger sampleLogger = dependencyResolver.Resolve<ILogger>();
var structuredData = new { Hello = "World", SubObject = new { Some = "Bling" } };
sampleLogger.Warning("A simple log item with data {0}", structuredData);
}
// Default configuration writing to the trace pipe without using a factory.
private static void SupplyingADefaultSource()
{
IUnityContainer container = new UnityContainer();
IDependencyResolver dependencyResolver = new UnityApplicationFrameworkDependencyResolver(container);
dependencyResolver
.UseCore()
.UseSerilog(defaultLoggerSource: new LoggerSource("MyComponent"));
ILogger sampleLogger = dependencyResolver.Resolve<ILogger>();
var structuredData = new { Hello = "World", SubObject = new { Some = "Bling" } };
sampleLogger.Warning("A simple log item with data and source {@StructuredData} |{SourceFqn}| ", structuredData);
}
// Demonstrates how to:
// Set the default minimum log level
// Log an item against a component
// How to get the underlying Serilog logger
private static void LogDirectlyWithSerilog()
{
IUnityContainer container = new UnityContainer();
IDependencyResolver dependencyResolver = new UnityApplicationFrameworkDependencyResolver(container);
dependencyResolver
.UseCore()
.UseSerilog(defaultMinimumLogLevel:LogLevelEnum.Information);
ISerilogFactory loggerFactory = dependencyResolver.Resolve<ISerilogFactory>();
Serilog.ILogger sampleLogger = loggerFactory.CreateSerilog(new ComponentIdentity("accidentalfish.applicationsupport.samples.serilog"));
var structuredData = new {Hello = "World", SubObject = new {Some = "Bling"}};
sampleLogger.Information("A simple log item {@StructuredData} - {SourceFqn}", structuredData);
}
static void Main(string[] args)
{
IUnityContainer container = new UnityContainer();
IDependencyResolver resolver = new UnityApplicationFrameworkDependencyResolver(container);
resolver.UseCore().UseAzure();
IAzureQueueFactory queueFactory = resolver.Resolve<IAzureQueueFactory>();
IAzureResourceManager resourceManager = resolver.Resolve<IAzureResourceManager>();
IAsynchronousQueue<SampleQueueItem> queue = queueFactory.CreateAsynchronousBrokeredMessageQueue<SampleQueueItem>(ServiceBusConnectionString, "aqueue");
Task<bool> resultTask = resourceManager.CreateIfNotExistsAsync(queue);
resultTask.Wait();
Console.WriteLine(resultTask.Result);
Task<bool> deleteResultTask = resourceManager.DeleteIfExistsAsync(queue);
deleteResultTask.Wait();
Console.WriteLine(deleteResultTask.Result);
}
static void Main(string[] args)
{
IUnityContainer container = new UnityContainer();
IDependencyResolver dependencyResolver = new UnityApplicationFrameworkDependencyResolver(container);
AccidentalFish.ApplicationSupport.Core.Bootstrapper.RegisterDependencies(dependencyResolver);
AccidentalFish.ApplicationSupport.Azure.Bootstrapper.RegisterDependencies(dependencyResolver);
AccidentalFish.ApplicationSupport.Processes.Bootstrapper.RegisterDependencies(dependencyResolver);
IComponentHost componentHost = dependencyResolver.Resolve<IComponentHost>();
ILoggerFactory loggerFactory = dependencyResolver.Resolve<ILoggerFactory>();
ILogger logger = loggerFactory.CreateShortLivedLogger(new ComponentIdentity("com.accidental-fish.application-support"));
CancellationTokenSource source = new CancellationTokenSource();
StartComponentHost(componentHost, logger, source);
logger.Information("Something to log");
Console.ReadLine();
source.Cancel();
Thread.Sleep(500);
}
static void Main(string[] args)
{
IUnityContainer container = new UnityContainer();
UnityApplicationFrameworkDependencyResolver resolver = new UnityApplicationFrameworkDependencyResolver(container);
resolver
.UseCore(defaultTraceLoggerMinimumLogLevel:LogLevelEnum.Verbose)
.UseEntityFramework();
IUnitOfWorkFactoryProvider provider = container.Resolve<IUnitOfWorkFactoryProvider>();
_unitOfWorkFactory = provider.Create(
"UnitOfWorkAndRepository.Model.BookShopContext, UnitOfWorkAndRepository",
@"Server=(local);Database=BookStoreSample;Connection Timeout=30;;Integrated Security=True");
Database.SetInitializer(new DropCreateDatabaseAlways<BookShopContext>());
DemonstrateInsert().Wait();
DemonstrateSimpleFetch().Wait();
Console.WriteLine("\nPress a key...");
Console.ReadKey();
}
private static void RegularTimerDemo()
{
Console.WriteLine("Regular timer demo");
var container = new UnityContainer();
var dependencyResolver = new UnityApplicationFrameworkDependencyResolver(container);
dependencyResolver.UseCore();
var timerFactory = dependencyResolver.Resolve<ITimerFactory>();
var timer = timerFactory.CreateAsynchronousRegularTimer(TimeSpan.FromSeconds(1));
var source = new CancellationTokenSource();
var counter = 0;
timer.ExecuteAsync((ct) =>
{
Console.WriteLine($"Step {counter++}");
}, source.Token);
Console.ReadKey();
source.Cancel();
}
private static async Task AsyncMain(Options options)
{
if (!File.Exists(options.Configuration))
{
throw new ConsoleAppException("Configuration file does not exist");
}
IDependencyResolver dependencyResolver = new UnityApplicationFrameworkDependencyResolver(new UnityContainer());
dependencyResolver.UseCore().UseAzure();
string[] settingsFiles = options.Settings.Split(',');
ApplicationConfigurationSettings settings = ApplicationConfigurationSettings.FromFiles(settingsFiles);
ApplicationConfiguration configuration = await ApplicationConfiguration.FromFileAsync(options.Configuration, settings, false);
IKeyVaultFactory keyVaultFactory = dependencyResolver.Resolve<IKeyVaultFactory>();
IKeyVault keyVault = keyVaultFactory.Create(options.KeyVaultClientId, options.KeyVaultClientKey, options.KeyVaultUri);
IKeyVaultConfigurationKeyEncoder encoder = dependencyResolver.Resolve<IKeyVaultConfigurationKeyEncoder>();
await SetSecrets(configuration, keyVault, encoder, options.Verbose);
}
static void Main(string[] args)
{
IUnityContainer container = new UnityContainer();
IDependencyResolver dependencyResolver = new UnityApplicationFrameworkDependencyResolver(container);
dependencyResolver
.UseCore()
.UseAzure()
.UseQueueLogger(defaultMinimumLogLevel:LogLevelEnum.Verbose)
.UseHostableProcesses();
IComponentHost componentHost = dependencyResolver.Resolve<IComponentHost>();
ILoggerFactory loggerFactory = dependencyResolver.Resolve<ILoggerFactory>();
IAsynchronousLogger logger = loggerFactory.CreateAsynchronousLogger(new ComponentIdentity("com.accidental-fish.application-support"));
CancellationTokenSource source = new CancellationTokenSource();
StartComponentHost(componentHost, logger, source);
logger.InformationAsync("Something to log");
Console.ReadLine();
source.Cancel();
Thread.Sleep(500);
}
private static async Task AsyncMain(Options options)
{
WriteVerbose($"Processing configuration file {options.Configuration}");
if (!File.Exists(options.Configuration))
{
throw new ConsoleAppException("Configuration file does not exist");
}
IDependencyResolver dependencyResolver = new UnityApplicationFrameworkDependencyResolver(new UnityContainer());
dependencyResolver.UseCore().UseAzure();
bool useKeyVault = !string.IsNullOrWhiteSpace(options.KeyVaultClientId) && !string.IsNullOrWhiteSpace(options.KeyVaultClientKey) && !string.IsNullOrWhiteSpace(options.KeyVaultUri);
IAsyncConfiguration keyVaultConfiguration = null;
if (useKeyVault)
{
dependencyResolver.UseAsyncKeyVaultApplicationConfiguration(options.KeyVaultClientId, options.KeyVaultClientKey, options.KeyVaultUri);
keyVaultConfiguration = dependencyResolver.Resolve<IAsyncKeyVaultConfiguration>();
WriteVerbose($"Using key vault {options.KeyVaultUri}");
}
WriteVerbose("Reading settings");
string[] settingsFiles = options.Settings.Split(',');
ApplicationConfigurationSettings settings = ApplicationConfigurationSettings.FromFiles(settingsFiles);
WriteVerbose("Reading configuration");
ApplicationConfiguration configuration = await ApplicationConfiguration.FromFileAsync(options.Configuration, settings,
options.CheckForMissingSettings, keyVaultConfiguration, WriteVerbose);
ApplyCorsRules(configuration);
foreach (ApplicationComponent component in configuration.ApplicationComponents)
{
if (component.UsesServiceBus)
{
WriteVerbose($"Creating service bus resources for component {component.Fqn}");
if (!String.IsNullOrWhiteSpace(component.DefaultTopicName))
{
NamespaceManager namespaceManager =
NamespaceManager.CreateFromConnectionString(component.ServiceBusConnectionString);
if (!namespaceManager.TopicExists(component.DefaultTopicName))
{
namespaceManager.CreateTopic(new TopicDescription(component.DefaultTopicName));
}
if (!String.IsNullOrWhiteSpace(component.DefaultSubscriptionName))
{
if (
!namespaceManager.SubscriptionExists(component.DefaultTopicName,
component.DefaultSubscriptionName))
{
namespaceManager.CreateSubscription(
new SubscriptionDescription(component.DefaultTopicName,
component.DefaultSubscriptionName));
}
}
}
if (!String.IsNullOrWhiteSpace(component.DefaultBrokeredMessageQueueName))
{
NamespaceManager namespaceManager =
NamespaceManager.CreateFromConnectionString(component.ServiceBusConnectionString);
if (!namespaceManager.QueueExists(component.DefaultBrokeredMessageQueueName))
{
namespaceManager.CreateQueue(component.DefaultBrokeredMessageQueueName);
}
}
foreach (ApplicationComponentSetting setting in component.Settings)
{
string resourceType = setting.ResourceType;
if (resourceType != null)
{
resourceType = resourceType.ToLower();
if (resourceType == "topic")
{
NamespaceManager namespaceManager =
NamespaceManager.CreateFromConnectionString(component.ServiceBusConnectionString);
if (!namespaceManager.TopicExists(setting.Value))
{
namespaceManager.CreateTopic(new TopicDescription(setting.Value));
}
}
else if (resourceType == "subscription")
{
NamespaceManager namespaceManager =
NamespaceManager.CreateFromConnectionString(component.ServiceBusConnectionString);
string topicPath = setting.Attributes["topic"];
if (!namespaceManager.TopicExists(topicPath))
{
namespaceManager.CreateTopic(new TopicDescription(topicPath));
}
if (!namespaceManager.SubscriptionExists(topicPath, setting.Value))
{
namespaceManager.CreateSubscription(new SubscriptionDescription(topicPath,
setting.Value));
}
}
else if (resourceType == "brokered-message-queue")
{
NamespaceManager namespaceManager =
NamespaceManager.CreateFromConnectionString(component.ServiceBusConnectionString);
if (!namespaceManager.QueueExists(setting.Value))
{
namespaceManager.CreateQueue(setting.Value);
}
}
}
}
}
if (component.UsesAzureStorage)
{
CloudStorageAccount storageAccount =
CloudStorageAccount.Parse(component.StorageAccountConnectionString);
if (!string.IsNullOrWhiteSpace(component.DefaultBlobContainerName))
{
CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
CloudBlobContainer blobContainer =
blobClient.GetContainerReference(component.DefaultBlobContainerName);
blobContainer.CreateIfNotExists(
BlobContainerPublicAccessType(component.DefaultBlobContainerAccessType));
WriteVerbose($"Creating blob container {component.DefaultBlobContainerName} in {storageAccount.BlobEndpoint}");
if (component.Uploads != null)
{
foreach (string uploadFilename in component.Uploads)
{
string fullUploadFilename = Path.Combine(Path.GetDirectoryName(options.Configuration),
uploadFilename);
CloudBlockBlob blob =
blobContainer.GetBlockBlobReference(Path.GetFileName(uploadFilename));
blob.UploadFromFile(fullUploadFilename, FileMode.Open);
WriteVerbose($"Uploading file {uploadFilename} to blob container {component.DefaultBlobContainerName}");
}
}
}
if (!string.IsNullOrWhiteSpace(component.DefaultLeaseBlockName))
{
CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
CloudBlobContainer blobContainer =
blobClient.GetContainerReference(component.DefaultLeaseBlockName);
blobContainer.CreateIfNotExists(
BlobContainerPublicAccessType(component.DefaultBlobContainerAccessType));
WriteVerbose($"Creating lease block container {component.DefaultLeaseBlockName} in {storageAccount.BlobEndpoint}");
}
if (!string.IsNullOrWhiteSpace(component.DefaultQueueName))
{
CloudQueueClient queueClient = storageAccount.CreateCloudQueueClient();
CloudQueue queue = queueClient.GetQueueReference(component.DefaultQueueName);
queue.CreateIfNotExists();
WriteVerbose($"Creating queue {component.DefaultQueueName} in {storageAccount.QueueEndpoint}");
}
if (!string.IsNullOrWhiteSpace(component.DefaultTableName))
{
CloudTableClient tableClient = storageAccount.CreateCloudTableClient();
CloudTable table = tableClient.GetTableReference(component.DefaultTableName);
table.CreateIfNotExists();
WriteVerbose($"Creating table {component.DefaultTableName} in {storageAccount.TableEndpoint}");
if (!string.IsNullOrWhiteSpace(component.TableData))
{
XDocument document;
string tableDataFilename = Path.Combine(Path.GetDirectoryName(options.Configuration),
component.TableData);
try
{
using (StreamReader reader = new StreamReader(tableDataFilename))
{
document = XDocument.Load(reader);
}
}
catch (Exception ex)
{
document = null;
WriteVerbose($"Unable to load table data document {tableDataFilename}. Error: {ex.Message}");
}
if (document != null)
{
UploadTableData(table, document);
}
}
}
foreach (ApplicationComponentSetting setting in component.Settings)
{
string resourceType = setting.ResourceType;
if (resourceType != null)
{
resourceType = resourceType.ToLower();
if (resourceType == "table")
{
CloudTableClient tableClient = storageAccount.CreateCloudTableClient();
CloudTable table = tableClient.GetTableReference(setting.Value);
table.CreateIfNotExists();
WriteVerbose($"Creating table {setting.Value} in {storageAccount.TableEndpoint}");
}
else if (resourceType == "queue")
{
CloudQueueClient queueClient = storageAccount.CreateCloudQueueClient();
CloudQueue queue = queueClient.GetQueueReference(setting.Value);
queue.CreateIfNotExists();
WriteVerbose($"Creating queue {setting.Value} in {storageAccount.TableEndpoint}");
}
else if (resourceType == "blob-container")
{
CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
CloudBlobContainer blobContainer = blobClient.GetContainerReference(setting.Value);
blobContainer.CreateIfNotExists();
WriteVerbose($"Creating blob container {setting.Value} in {storageAccount.TableEndpoint}");
}
}
}
}
}
}
public void Setup()
{
_container = new UnityContainer();
_resolver = new UnityApplicationFrameworkDependencyResolver(_container);
_resolver.UseCore().UseAzure();
}
// Demonstrates how to access the underlying Serilog with a cast
private static void AccessSerilogWithCast()
{
IUnityContainer container = new UnityContainer();
IDependencyResolver dependencyResolver = new UnityApplicationFrameworkDependencyResolver(container);
dependencyResolver
.UseCore()
.UseSerilog();
ILoggerFactory loggerFactory = dependencyResolver.Resolve<ILoggerFactory>();
Serilog.ILogger sampleLogger = (Serilog.ILogger)loggerFactory.CreateLogger();
sampleLogger.Warning("Casts are handy");
}
private static async Task GetAllInPartition(string partitionKey)
{
IUnityContainer container = new UnityContainer();
UnityApplicationFrameworkDependencyResolver resolver = new UnityApplicationFrameworkDependencyResolver(container);
resolver
.UseCore(defaultTraceLoggerMinimumLogLevel: LogLevelEnum.Verbose)
.UseAzure();
var resourceManager = container.Resolve<IAzureResourceManager>();
var tableStorageRepositoryFactory = container.Resolve<ITableStorageRepositoryFactory>();
var table = tableStorageRepositoryFactory.CreateAsynchronousNoSqlRepository<SampleEntity>(StorageAccountConnectionString, TableName);
await resourceManager.CreateIfNotExistsAsync(table);
IEnumerable<SampleEntity> entities = await table.GetAsync(partitionKey);
Console.WriteLine($"Retrieved {entities.Count()} items");
}
// Demonstrates how to supply a custom basic log configuration to the factory
private static void FactorySerilogConfiguration()
{
IUnityContainer container = new UnityContainer();
IDependencyResolver dependencyResolver = new UnityApplicationFrameworkDependencyResolver(container);
dependencyResolver
.UseCore()
.UseSerilog(
configurationProvider: () => new LoggerConfiguration().WriteTo.ColoredConsole(),
defaultMinimumLogLevel: LogLevelEnum.Information);
ILoggerFactory loggerFactory = dependencyResolver.Resolve<ILoggerFactory>();
ILogger sampleLogger = loggerFactory.CreateLogger(new ComponentIdentity("accidentalfish.applicationsupport.samples.serilog"));
sampleLogger.Warning("Coloured console {SourceFqn}");
sampleLogger.Error("Colourful {SourceFqn}");
}
