using Newtonsoft.Json;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json.Serialization;
namespace CRUD
{
class Program
{
static void Main(string[] args)
{
ServerDataTest();
//LoadBalancerDataTest();
}
public static void LoadBalancerDataTest()
{
DataManager<ServerKey, LoadBalancerValue> dataManager = new DataManager<ServerKey, LoadBalancerValue>();
dataManager.Insert(
new ServerKey { ServerName = "ServerA" },
new LoadBalancerValue { LoadBalancerPrivateIp = "pri1", LoadBalancerPublicIp = "pub1" });
dataManager.Insert(
new ServerKey { ServerName = "ServerB" },
new LoadBalancerValue { LoadBalancerPrivateIp = "pri2", LoadBalancerPublicIp = "pub2" });
dataManager.Update(
new ServerKey { ServerName = "ServerB" },
new LoadBalancerValue { LoadBalancerPrivateIp = "pri3" });
dataManager.Insert(
new ServerKey { ServerName = "ServerC" },
new LoadBalancerValue { LoadBalancerPrivateIp = "pri3", LoadBalancerPublicIp = "pub3" });
dataManager.Delete(
new ServerKey { ServerName = "ServerA" });
// SerializeObject
string json = dataManager.GetJson();
Console.WriteLine(json);
// DeserializeObject
var tempobject = JsonConvert.DeserializeObject<List<KeyValuePair<ServerKey, LoadBalancerValue>>>(json);
dataManager.Data.Clear();
foreach (var a in tempobject)
{
dataManager.Insert(
new ServerKey { ServerName = a.Key.ServerName },
new LoadBalancerValue {
LoadBalancerPrivateIp = a.Value.LoadBalancerPrivateIp,
LoadBalancerPublicIp = a.Value.LoadBalancerPublicIp });
}
// data confirm
foreach (var a in dataManager.Data)
{
Console.WriteLine($"{a.Key.ServerName}, {a.Value.LoadBalancerPrivateIp}, {a.Value.LoadBalancerPublicIp}");
}
Console.ReadKey();
}
public static void ServerDataTest()
{
DataManager<ServerKey, ServerValue> dataManager = new DataManager<ServerKey, ServerValue>();
dataManager.Insert(
new ServerKey { ServerName = "ServerA" },
new ServerValue { ServerPrivateIp = "pri1", ServerPublicIp = "pub1" });
dataManager.Insert(
new ServerKey { ServerName = "ServerB" },
new ServerValue { ServerPrivateIp = "pri2", ServerPublicIp = "pub2" });
dataManager.Insert(
new ServerKey { ServerName = "ServerB" },
new ServerValue { ServerPrivateIp = "pri3", ServerPublicIp = "pub5" });
dataManager.Update(
new ServerKey { ServerName = "ServerB" },
new ServerValue { ServerPrivateIp = "pri3" });
dataManager.Insert(
new ServerKey { ServerName = "ServerC" },
new ServerValue { ServerPrivateIp = "pri3", ServerPublicIp = "pub3" });
dataManager.Delete(
new ServerKey { ServerName = "ServerA" });
// SerializeObject
string json = dataManager.GetJson();
Console.WriteLine(json);
// DeserializeObject
var tempobject = JsonConvert.DeserializeObject<List<KeyValuePair<ServerKey, ServerValue>>>(json);
dataManager.Data.Clear();
foreach (var a in tempobject)
{
dataManager.Insert(
new ServerKey { ServerName = a.Key.ServerName },
new ServerValue { ServerPrivateIp = a.Value.ServerPrivateIp, ServerPublicIp = a.Value.ServerPublicIp });
}
// data confirm
foreach (var a in dataManager.Data)
{
Console.WriteLine($"{a.Key.ServerName}, {a.Value.ServerPrivateIp}, {a.Value.ServerPublicIp}");
}
ServerValue sv = dataManager.Data[new ServerKey { ServerName = "ServerB" }];
Console.WriteLine($"{sv.ServerPrivateIp}, {sv.ServerPublicIp}");
Console.ReadKey();
}
}
class ServerKey : IEquatable <ServerKey>
{
public string ServerName
{
get; set;
}
public bool Equals(ServerKey other)
{
if (ServerName.Equals(other.ServerName))
return true;
else
return false;
}
public override int GetHashCode()
{
return ServerName.GetHashCode();
// return _X.GetHashCode() ^ _Y.GetHashCode();
}
}
class ServerValue
{
public string ServerPrivateIp { get; set; } = "";
public string ServerPublicIp { get; set; } = "";
}
class LoadBalancerValue
{
public string LoadBalancerPrivateIp { get; set; } = "";
public string LoadBalancerPublicIp { get; set; } = "";
}
class DataManager <K, V>
{
private object lockobj = new object();
public Dictionary<K, V> Data { get; set; } = new Dictionary<K, V>();
public DataManager() { }
public void Insert(K key, V value)
{
lock (lockobj)
{
if (!Data.ContainsKey(key))
Data.Add(key, value);
else
Update(key, value);
}
}
public void Update(K key, V value)
{
lock (lockobj)
{
V oldValue;
if (Data.TryGetValue(key, out oldValue))
{
var newProperies = value.GetType().GetProperties();
foreach (var n in newProperies)
{
var oldProperties = oldValue.GetType().GetProperties();
foreach (var o in oldProperties)
{
if (o.Name == n.Name)
{
string oldPropertyValue = oldValue.GetType().GetProperty(o.Name).GetValue(oldValue, null).ToString();
if (value.GetType().GetProperty(n.Name).GetValue(value, null).Equals(""))
{
value.GetType().GetProperty(n.Name).SetValue(value, oldPropertyValue, null);
}
}
}
}
}
Data[key] = value;
}
}
public void Delete(K key)
{
lock (lockobj)
{
if (Data.ContainsKey(key))
{
Data.Remove(key);
}
}
}
public string GetJson()
{
JsonSerializerSettings settings = new JsonSerializerSettings();
settings.Formatting = Formatting.Indented;
settings.ContractResolver = new DictionaryAsArrayResolver();
return JsonConvert.SerializeObject(Data, settings);
}
}
class DictionaryAsArrayResolver : DefaultContractResolver
{
protected override JsonContract CreateContract(Type objectType)
{
if (objectType.GetInterfaces().Any(i => i == typeof(IDictionary) ||
(i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IDictionary<,>))))
{
return base.CreateArrayContract(objectType);
}
return base.CreateContract(objectType);
}
}
}
