public override bool CanConvert(Type objectType)
{
if (objectType == null)
{
return(false);
}
bool isKVPObject = false;
if (typeof(IChoKeyValueType).IsAssignableFrom(objectType))
{
isKVPObject = true;
}
else
{
var isKVPAttrDefined = ChoTypeDescriptor.GetTypeAttribute <ChoKeyValueTypeAttribute>(objectType) != null;
if (isKVPAttrDefined)
{
var kP = ChoTypeDescriptor.GetProperties <ChoKeyAttribute>(objectType).FirstOrDefault();
var vP = ChoTypeDescriptor.GetProperties <ChoValueAttribute>(objectType).FirstOrDefault();
if (kP != null && vP != null)
{
isKVPObject = true;
}
}
}
return(isKVPObject);
}
protected override void Init(Type recordType)
{
base.Init(recordType);
if (recordType == null)
{
return;
}
var pd = ChoTypeDescriptor.GetTypeAttribute <ChoJSONPathAttribute>(recordType);
if (pd != null)
{
JSONPath = pd.JSONPath;
AllowComplexJSONPath = pd.AllowComplexJSONPath;
}
ChoJSONRecordObjectAttribute recObjAttr = ChoType.GetAttribute <ChoJSONRecordObjectAttribute>(recordType);
if (recObjAttr != null)
{
}
if (JSONRecordFieldConfigurations.Count == 0)
{
MapRecordFields(); // DiscoverRecordFields(recordType, false);
}
}
public static void Add(string name, JsonConverter converter)
{
ChoGuard.ArgumentNotNullOrEmpty(name, nameof(name));
if (converter == null)
{
return;
}
lock (_padLock)
{
if (!_convertersCache.ContainsKey(name))
{
_convertersCache.Add(name, converter);
}
else
{
_convertersCache[name] = converter;
}
var dna = ChoTypeDescriptor.GetTypeAttribute <DisplayNameAttribute>(converter.GetType());
if (dna != null && !dna.DisplayName.IsNullOrWhiteSpace())
{
if (!_convertersCache.ContainsKey(dna.DisplayName))
{
_convertersCache.Add(dna.DisplayName, converter);
}
else
{
_convertersCache[dna.DisplayName] = converter;
}
}
}
}
protected void LoadKnownTypes(Type recordType)
{
if (_knownTypeInitialized)
{
return;
}
_knownTypeInitialized = true;
if (recordType == null)
{
return;
}
if (_knownTypes == null)
{
_knownTypes = new Dictionary <string, Type>(StringComparer.InvariantCultureIgnoreCase);
}
_knownTypes = ChoTypeDescriptor.GetTypeAttributes <ChoKnownTypeAttribute>(recordType).Where(a => a.Type != null && !a.Value.IsNullOrWhiteSpace())
.GroupBy(kvp => kvp.Value)
.ToDictionary(kvp => kvp.Key, kvp => kvp.First().Type, _knownTypes.Comparer == null ? StringComparer.InvariantCultureIgnoreCase : _knownTypes.Comparer);
var kta = ChoTypeDescriptor.GetTypeAttribute <ChoKnownTypeDiscriminatorAttribute>(recordType);
if (kta != null && !kta.Discriminator.IsNullOrWhiteSpace())
{
KnownTypeDiscriminator = kta.Discriminator.Trim();
}
}
public static void Init()
{
if (_isInit)
{
return;
}
lock (_padLock)
{
if (_isInit)
{
return;
}
try
{
//IsInitialized = true;
Dictionary <string, JsonConverter> dict = _convertersCache;
var convs = ChoType.GetAllTypes().Where(t => typeof(JsonConverter).IsAssignableFrom(t) && !t.IsGenericType && ChoType.HasDefaultConstructor(t))
.Distinct().ToArray();
foreach (var c in convs)
{
var dad = ChoTypeDescriptor.GetTypeAttribute <ChoDisableAutoDiscoverabilityAttribute>(c);
if (dad != null && dad.Flag)
{
continue;
}
if (dict.ContainsKey(c.Name))
{
continue;
}
try
{
dict.Add(c.Name, Activator.CreateInstance(c) as JsonConverter);
var dna = ChoTypeDescriptor.GetTypeAttribute <DisplayNameAttribute>(c);
if (dna != null && !dna.DisplayName.IsNullOrWhiteSpace())
{
if (!dict.ContainsKey(dna.DisplayName))
{
dict.Add(dna.DisplayName, Activator.CreateInstance(c) as JsonConverter);
}
}
}
catch { }
}
}
catch
{
}
_isInit = true;
}
}
protected void Init(Type baseType)
{
string knownTypeDiscriminator = null;
Dictionary <string, Type> knownTypes;
knownTypes = ChoTypeDescriptor.GetTypeAttributes <ChoKnownTypeAttribute>(baseType).Where(a => a.Type != null && !a.Value.IsNullOrWhiteSpace())
.GroupBy(kvp => kvp.Value)
.ToDictionary(kvp => kvp.Key, kvp => kvp.First().Type, StringComparer.InvariantCultureIgnoreCase);
var kta = ChoTypeDescriptor.GetTypeAttribute <ChoKnownTypeDiscriminatorAttribute>(baseType);
if (kta != null && !kta.Discriminator.IsNullOrWhiteSpace())
{
knownTypeDiscriminator = kta.Discriminator.Trim();
}
Init(baseType, knownTypeDiscriminator, knownTypes, null);
}
public static bool IsKeyValueType(this Type type)
{
bool isKVPObject = false;
if (typeof(IChoKeyValueType).IsAssignableFrom(type))
{
isKVPObject = true;
}
else
{
var isKVPAttrDefined = ChoTypeDescriptor.GetTypeAttribute <ChoKeyValueTypeAttribute>(type) != null;
if (isKVPAttrDefined)
{
var kP = ChoTypeDescriptor.GetProperties <ChoKeyAttribute>(type).FirstOrDefault();
var vP = ChoTypeDescriptor.GetProperties <ChoValueAttribute>(type).FirstOrDefault();
if (kP != null && vP != null)
{
isKVPObject = true;
}
}
}
return(isKVPObject);
}
public static JToken SerializeToJToken(this JsonSerializer serializer, object value, Formatting?formatting = null, JsonSerializerSettings settings = null,
bool dontUseConverter = false, bool enableXmlAttributePrefix = false)
{
JsonConverter conv = null;
if (!dontUseConverter)
{
Type vt = value != null?value.GetType() : typeof(object);
var convName = GetTypeConverterName(vt);
conv = serializer.Converters.Where(c => c.GetType().Name == convName || (c.GetType().IsGenericType&& c.GetType().GetGenericArguments()[0] == vt)).FirstOrDefault();
if (conv == null && ChoJSONConvertersCache.IsInitialized)
{
if (ChoJSONConvertersCache.Contains(convName))
{
conv = ChoJSONConvertersCache.Get(convName);
}
else if (ChoJSONConvertersCache.Contains(vt))
{
conv = ChoJSONConvertersCache.Get(vt);
}
}
}
if (value != null)
{
if (!value.GetType().IsSimple())
{
bool disableImplcityOp = false;
if (ChoTypeDescriptor.GetTypeAttribute <ChoTurnOffImplicitOpsAttribute>(value.GetType()) != null)
{
disableImplcityOp = ChoTypeDescriptor.GetTypeAttribute <ChoTurnOffImplicitOpsAttribute>(value.GetType()).Flag;
}
if (!disableImplcityOp)
{
Type to = null;
if (value.GetType().CanCastToPrimitiveType(out to))
{
value = ChoConvert.ConvertTo(value, to);
}
else if (value.GetType().GetImplicitTypeCastBackOps().Any())
{
var castTypes = value.GetType().GetImplicitTypeCastBackOps();
foreach (var ct in castTypes)
{
try
{
value = ChoConvert.ConvertTo(value, ct);
break;
}
catch { }
}
}
}
}
}
JToken t = null;
if (settings != null)
{
if (conv != null)
{
settings.Converters.Add(conv);
}
}
if (formatting == null)
{
formatting = serializer.Formatting;
}
if (settings != null && settings.Context.Context == null && enableXmlAttributePrefix)
{
settings.Context = new System.Runtime.Serialization.StreamingContext(System.Runtime.Serialization.StreamingContextStates.All, new ChoDynamicObject());
dynamic ctx = settings.Context.Context;
ctx.EnableXmlAttributePrefix = enableXmlAttributePrefix;
}
if (conv != null)
{
t = JToken.Parse(JsonConvert.SerializeObject(value, formatting.Value, conv));
}
else if (settings != null)
{
t = JToken.Parse(JsonConvert.SerializeObject(value, formatting.Value, settings));
}
else
{
t = JToken.FromObject(value, serializer);
}
return(t);
}
