C# Archives - Blog IT

Provision a database programmatically in Azure SQL database with a failover group

Miguel Isidoro — Wed, 24 Jan 2024 14:32:24 +0000

This post will explain how to provision a database programmatically in a Azure SQL database and add it to an Azure SQL failover group.

Introduction

An Azure SQL Server failover group is a group of databases that can be automatically or manually failed over from a primary server to a secondary server in a different Azure region in case of a disaster in the primary server. Failover groups provide high availability and disaster recovery for Azure SQL Server databases.

The process described in this post is composed by two main steps:

Provisioning the database
Adding the database to the failover group

Provisioning the database

The first step is to create the database. This step is composed by the following actions:

Get the tenant information
Create the database

Tenant information class:

Code to create database programatically:

Adding the database to the failover group

The second step adds the newly created database to the failover group. This step is composed by the following actions:

Get the failover group where we want to add the database
Re-add the existing databases to the failover group – necessary since when we get the failover group the list of databases of the group is empty and, without this step, the failover group would only have the new database
Add the new database to the failover group

TWIL: The weird way .NET’s config system parses JSONs

Hugo Barroca — Mon, 07 Feb 2022 13:01:05 +0000

The day is a Friday. We were calmly deploying an app we tested locally to the test environment. The error we had was pointing towards the config files. Off we go to check the appsettings.json file…

Every value seems correct, but the error is definitely pointing us here. Here’s a simplified version of the offending line:

Console.Writeline(AConfig.ASubConfig);

And the corresponding appsettings:

{
    "AConfig" : {
        "ASubConfig" : []
    }
}

“But an empty array is not the same as a null value! And even if it was, it’s a value inside the “ASubConfig” property! There’s no way for this to be null!” was what I thought. And I thought wrong.

How the file is actually parsed

Actually, there’s a way for it to be null. Or at least, the JSON Provider which is gonna look at ours JSONs thinks so. Since .NET’s config system is ready to take in different providers, it was built with the common points of said providers in mind… And hierarchies aren’t one of those points.

What happens is that the JSON Provider’s parser is going to look at our JSON file and it’s going to map all those informations to a dictionary, in which every value is mapped with a key which corresponds to the path to that value in the file.

The “gotcha” here is in the way the arrays are processed: Each index of each array is processed as a part of the path. Meaning, that the following appsettings:

{
    "AnArray" : ["AThing", "AnotherThing", "AThirdThing"]
}

Will originate a dictionary with the following entries:

AnArray:0 = “AThing”
AnArray:1 = “AnotherThing”
AnArray:2 = “AThirdThing”

Why do empty arrays cause an issue?

What happens if the array is empty? Well, by convention, an empty array wont originate any entries in our dictionary… So, to the .NET binder which is gonna look at our dictionary, that array doesn’t exist at all.

Even moreso, as there is no value inside that array which we can map to some path, every object on top of it in the hierarchy won’t have any value we can map either, meaning those objects won’t exist themselves (assuming they don’t have any other properties with not null values).

In practice, our dictionary will be empty, our .NET binder won’t be able to map anything, and the number of “WTH”s per second will spike before lunch time.

TLDR: .NET’s config system treats any object in appsettings.json that does not have any value associated with it’s properties as if it didn’t exist, and the same happens if that value is an empty array.

If anyone wants to read more on this, here’s a link for the github issue where I found most of this information:

https://github.com/dotnet/extensions/issues/1341

Happy coding everyone!

The post TWIL: The weird way .NET’s config system parses JSONs appeared first on Blog IT.

log4net PatternLayout and PatternConverter

Ricardo Costa — Mon, 11 Jul 2016 16:50:58 +0000

I have the following scenario:

I’m using Unity dependency injection container and interception techniques to log some WCF operation calls. I need to log the input parameters and also the result of these operations so I’ve implemented a CallHandler that I can apply to whatever methods that I need to intercept.

In this CallHandler I’ve defined a class called LogEntry and I’m logging with log4net. Something like this:


LogEntry logEntry = new LogEntry();
....
// set some base properties
logEntry.MethodName = input.MethodBase.Name;
logEntry.TypeName = input.Target.GetType().FullName;
...
// set input parameters
logEntry.Input = ....;
...
// set return value
logEntry.ReturnValue = result.ReturnValue;
.....
// set total method duration
logEntry.CallTime = stopwatch.Elapsed.TotalMilliseconds;
.....

// use log4net logger to log this information
logger.Debug(logEntry);

So this LogEntry class has some properties that will hold the information that I want to log. Now I need to capture these properties and configure the log4net appenders properly.

I’m using log4net PatternLayout and PatternConverter features. Let’s start with PatternLayout


///
/// Extended version of 
/// 


public class ExtendedPatternLayout : PatternLayout
{
 ///
 /// Initializes a new instance of the  class.
 /// ;


 public ExtendedPatternLayout()
 {
   this.AddConverter(new ConverterInfo()
   {
     Name = "logEntry",
     Type = typeof(LogEntryConverter),
   });
 }
}

This layout just adds a new Converter named “logEntry” implemented by the class LogEntryConverter. There is no reference to LogEntry class here. And the LogEntryConverter class is here:


 /// 
 /// Custom  to handle 
 /// 
 public class LogEntryConverter : PatternConverter
 {
   /// 
   /// Converts the specified writer.
   /// 
   /// The writer.
   /// The state.
   protected override void Convert(System.IO.TextWriter writer, object state)
   {
       var loggingEvent = state as LoggingEvent;
       var logEntry = loggingEvent.MessageObject as LogEntry;

       if (logEntry != null)
       {
          switch (this.Option.ToLower())
          {
             case "calltime":
               writer.Write(logEntry.CallTime.HasValue ? logEntry.CallTime.Value : 0);
               break;
             case "methodname":
               writer.Write(logEntry.MethodName);
               break;
             case "returnvalue":
               writer.Write(SerializationService.SerializeToJSON(logEntry.ReturnValue));
               break;
             ..........
             ..........
             default:
               writer.Write(string.Empty);
               break;
          }
       }
    }
 }

I’ve made the code smaller but you need to check for null references!

I’m using a JSON serialization technique to grab the representation of the method’s return value.

I need to override the Convert method and access state object that is a log4net LoggingEvent object. This object has my logged object from the CallHandler which is a LogEntry object. Based on the Option property of the converter I can choose which property to write.

And finally I can configure my log4net like this

You can see the conversionPattern follows this syntax: %convertername{option}

The post log4net PatternLayout and PatternConverter appeared first on Blog IT.

Custom properties log4net

Ricardo Costa — Mon, 23 Nov 2015 10:20:21 +0000

I had the need to add some custom properties in my log4net messages.

I used the log4net contexts like this:


log4net.ThreadContext.Properties[MessageIdKey] = messageId;

And then updated my rolling file appender:

and my AdoNetAppender:



 
 
 
 
 
 

 ......

The post Custom properties log4net appeared first on Blog IT.