Simplified Azure Storage Client in .NET Core
Tags: azure, csharp, dotnet, performance
Published: 2021-03-19 08:00:01

I have created "Simplified Azure Storage Client in .NET Core". I was originally thinking to just create a RESTful client at first, and then decided to make it more powerful by enabling it to communicate with Azure Storage and Redis Cache. 


All tools are wrapped into single class "Restme()" to keep everything simple. The class will automatically identify whether it's used as HTTP Client, Azure Storage Client or Redis Cache Client.


Since they are all about requesting and saving data, it is going to play a major role when it comes to saving time and space.



###Code:


<pre>

//HTTP Restful client (sudo code)  
// Get data  
rest.Get(requestUrl);  
// Save data  
rest.Add(paramKey, paramValue);  
rest.Post(requestUrl, data);  
// Delete data  
rest.Delete(requestUrl);
  
//Azure Storage or Redis ache sudo-code  
// Get data  
rest.Get<Stream>("/container/filePath");  
rest.Get("/container/jsonData");  
rest.Get<myObject>("/container/filePath");  
  
// Save data  
rest.Post<myObject>("/container/filePath", myObject);  
// Delete data  
rest.Delete("/container/filePath");   

</pre>

### Example:

#### 1. Use it as a basic RESTful HTTP Client:

<pre>
//direct string JSON return    
var rest = new Restme(new Uri("http://freegeoip.net"));  
var result1 = rest.Get("/json/github.com");  
  
//automatic Generic cast    
var result2 = rest.Get < MyObject > ("/json/github.com");  
var resultAsync2 = await rest.GetAsync << MyObjecT > ("/json/github.com");  
  
//add parameters (Parameters get automatically converted into query string or post form fields)    
rest.add("q", "github.com");  
var result3 = rest.Get < MyObject > ("/json");  
var resultAsync3 = await rest.GetAsync < MyObjecT > ("/json");  
  
//supports POST, DELETE, PUT etc.    
var rest2 = new Restme(new Uri("http://example.com"));  
rest2.Add("Username", "abc@def.com");  
rest2.Add("Birthday", DateTime.UtcNow);  
rest2.Post < MyObject > ("/someurl");  
  
rest3.PostAsync < MyObject > ("/asyncexample");  
  
  
//supports direct object submission    
var myObject = new MyObject()  
{  
    Username = "abc@def.com",  
        Birthday = DateTime.UtcNow  
};  
var rest3 = new Restme(new Uri("http://example.com"));  
rest3.Add(myObject);  
rest3.Post < ExpectedResultObject > ("/directObjectPost");  
</pre>

#### 2. Use it as an Azure Storage Client:

<pre>
//get blob stream directly      
var blobStorageConnectionString = "{Your Storage Account Connection String}";  
  
  
var rest = new Restme(blobStorageConnetionString);  
  
  
rest.CreateAzureBlobContainerIfNotExists = true; //do this only if you want to auto create the container        
  
  
//NOTE 1: first segment of the path should always be your container name      
  
  
//NOTE 3: Type T: if it is a type of Stream it will be stored as original Stream as Azure Blob, otherwise it is always saved into JSON format as Azure Blob      
  
  
//NOTE 2: use a type of Stream if you want the original value retrieved from the blob      
  
  
rest.Get < Stream > ("/myContainer/myfilePath");  
  
rest.GetAsync < Stream > ("/myContainer/myfilePath");  
  
  
//NOTE: only blob items saved in JSON format is suppported      
  
  
rest.Get < ObjectType > ("/myContainer/myfileObjectInJSONFileFormat");  
  
rest.GetAsync < ObjectType > ("/myContainer/myfileObjectInJSONFileFormat");  
</pre>


#### 3. Use it as a Redis Cache Client:

<pre>
var redisConnectionString = "{Your Redis Cache Connection String}";    
var rest = new Restme(redisConnectionString);    
    
//get cache data (support Generic cast)    
var cacheResult = rest.Get("home:testKey");    
var cacheResult2 = rest.Get<bool>("home:testKey2");    
var cacheResult3 = rest.Get<ObjectType>("home:testKey3");    
    
//set cache data    
rest.Post("home:testKey","value");    
rest.Post<bool>("home:testKey2",true);    
    
var myObject = new ObjectType();  //will be serialized into JSON format and stored as string on redis server    
rest.Post<ObjectType>("home:testKey3", myObject);  
</pre>


###Advantages:

1. The main goal is to increase productivity and keep code simplicity. 
2. Currently it includes: RESTful HTTP Client, Azure Storage Client, Redis Cache Client.
3. Simple methods and flexible calls
4. Uses Newtonsoft JSON and allows custom serilization
5. Async support
6. HTTP Client:
   - Parameters get automatically converted into query string or post form fields
   - Supports GET, POST, PUT, DELETE
   - Bearer Authentication and custom headers
7. Azure Storage Client:
   - Simplified call stack
8. Redis Cache Client
   - Simplified call stack (Currently only support Azure Redis Cache, you can modify the source code to support other Redis Servers as well)


#### Check out the full code here:

{% github https://github.com/PranamBhat/AzureDotNet %}