public ICefValue Serialize(object source, Stack <object> seen, ObjectSerializer objectSerializer)
{
if (!CanHandle(source?.GetType()))
{
throw new InvalidOperationException();
}
using (var value = CefDictionaryValue.Create())
using (var dict = CefDictionaryValue.Create())
{
value.SetString(ObjectSerializer.TypeIdPropertyName, ObjectSerializer.DictionaryTypeId);
foreach (DictionaryEntry dictionaryEntry in (IDictionary)source)
{
var cefValue = objectSerializer.Serialize(dictionaryEntry.Value, seen);
dict.SetValue(dictionaryEntry.Key.ToString(), cefValue);
}
value.SetDictionary(ObjectSerializer.ValuePropertyName, dict);
var result = CefValue.Create();
result.SetDictionary(value);
return(result);
}
}
public static void SetTime <TIndex>(this CefValue @this, DateTime value, TIndex index = default(TIndex))
{
SetTime(_ =>
{
var valueType = @this.GetValueType();
switch (valueType)
{
case CefValueType.List:
using (var listValue = @this.GetList())
{
if (typeof(TIndex) == typeof(int))
{
listValue.SetBinary((int)Convert.ChangeType(index, typeof(int)), _);
}
}
break;
case CefValueType.Dictionary:
using (var dictValue = @this.GetDictionary())
{
if (typeof(TIndex) == typeof(string))
{
dictValue.SetBinary((string)Convert.ChangeType(index, typeof(string)), _);
}
}
break;
default:
@this.SetBinary(_);
break;
}
}, value);
}
public object Deserialize(CefValue value, Type targetType, ObjectSerializer objectSerializer)
{
if (!CanHandle(value, targetType))
{
throw new InvalidOperationException();
}
object result = null;
if (value.IsType(CefTypes.Time) && targetType == typeof(DateTime))
{
result = value.GetTime();
}
else if (targetType == typeof(decimal))
{
var cefValueType = value.GetValueType();
switch (cefValueType)
{
case CefValueType.Int:
result = Convert.ToDecimal(value.GetInt());
break;
case CefValueType.Double:
result = Convert.ToDecimal(value.GetDouble());
break;
}
}
return(result);
}
public CefValue Serialize(object source, HashSet <object> seen, ObjectSerializer objectSerializer)
{
if (!CanHandle(source?.GetType()))
{
throw new InvalidOperationException();
}
var actualSource = (PropertyDescriptor)source;
var result = CefValue.Create();
using (var resultDict = CefDictionaryValue.Create())
using (var value = CefDictionaryValue.Create())
{
resultDict.SetString(ObjectSerializer.TypeIdPropertyName, PropertyDescriptor.TypeId);
value.SetInt64(nameof(actualSource.Id), actualSource.Id);
value.SetString(nameof(PropertyDescriptor.Name), actualSource.Name);
value.SetValue(nameof(PropertyDescriptor.Value),
objectSerializer.Serialize(actualSource.Value, new HashSet <object>()));
resultDict.SetDictionary(ObjectSerializer.ValuePropertyName, value);
result.SetDictionary(resultDict);
}
return(result);
}
public object Deserialize(CefValue value, Type targetType, ObjectSerializer objectSerializer)
{
if (!CanHandle(value, targetType))
{
throw new InvalidOperationException();
}
return(value.Copy());
}
public bool CanHandle(CefValue cefValue, Type targetType)
{
var cefValueType = cefValue.GetValueType();
return((targetType?.IsPrimitive == true && SupportedTypes.Contains(cefValueType)) ||
(cefValueType == CefValueType.Int && targetType == typeof(object)) ||
(cefValueType == CefValueType.Double && targetType == typeof(object)) ||
(cefValueType == CefValueType.Bool && targetType == typeof(object)));
}
public void Complete(CefValue value)
{
Volatile.Write(ref _result, CastToDotnetType(value));
try
{
_event?.Set();
}
catch (ObjectDisposedException) { }
}
internal static CefV8Value CastCefValueToCefV8Value(CefV8Context context, CefValue value, out bool isNew)
{
isNew = true;
if (value is null)
{
return(CefV8Value.CreateNull());
}
if (!value.IsValid)
{
throw new InvalidCastException();
}
CefValueType valueType = value.Type;
switch (valueType)
{
case CefValueType.String:
return(new CefV8Value(value.GetString()));
case CefValueType.Int:
return(new CefV8Value(value.GetInt()));
case CefValueType.Bool:
return(new CefV8Value(value.GetBool()));
case CefValueType.Null:
return(CefV8Value.CreateNull());
case CefValueType.Double:
return(new CefV8Value(value.GetDouble()));
case CefValueType.Binary:
CefBinaryValue v = value.GetBinary();
if (v.Size == 1)
{
return(CefV8Value.CreateUndefined());
}
XrayHandle handle = XrayHandle.FromCfxBinaryValue(v);
if (handle == XrayHandle.Zero)
{
return(context.GetGlobal());
}
isNew = (handle.dataType != XrayDataType.Object && handle.dataType != XrayDataType.Function);
return(handle.ToCefV8Value(context.Frame));
}
throw new NotSupportedException();
}
public object Deserialize(CefValue value, Type targetType, int?index = null, string key = null)
{
var underlyingType = Nullable.GetUnderlyingType(targetType);
if (underlyingType != null)
{
targetType = underlyingType;
}
var deserializer = Deserializers.FirstOrDefault(s => s.CanHandle(value, targetType));
return(deserializer?.Deserialize(value, targetType, this));
}
public CefValue Serialize(object source, HashSet <object> seen, ObjectSerializer objectSerializer)
{
if (!CanHandle(source.GetType()))
{
throw new InvalidOperationException();
}
var result = CefValue.Create();
result.SetString((string)source);
return(result);
}
private static bool IsDictionary(CefValue value)
{
var result = value.GetValueType() == CefValueType.Dictionary;
if (result)
{
using (var dict = value.GetDictionary())
{
result = dict.HasKey(ObjectSerializer.TypeIdPropertyName) &&
dict.GetString(ObjectSerializer.TypeIdPropertyName) == ObjectSerializer.DictionaryTypeId;
}
}
return(result);
}
public object Deserialize(CefValue value, Type targetType, ObjectSerializer objectSerializer)
{
if (!CanHandle(value, targetType))
{
throw new InvalidOperationException();
}
object result = null;
using (var dictVal = value.GetDictionary())
{
var typeId = dictVal.GetString(ObjectSerializer.TypeIdPropertyName);
using (var actualValue = dictVal.GetDictionary(ObjectSerializer.ValuePropertyName))
{
KnownTypes.TryGetValue(typeId, out var type);
if (type != null && (targetType == typeof(object) || targetType.IsAssignableFrom(type)))
{
targetType = type;
}
try
{
result = Activator.CreateInstance(targetType);
var properties = targetType.GetProperties()
.Select(p =>
new { Prop = p, DataMember = p.GetCustomAttribute <DataMemberAttribute>() })
.ToDictionary(k => k.DataMember?.Name ?? k.Prop.Name, v => v.Prop);
var keys = actualValue.GetKeys();
foreach (var dictKey in keys)
{
if (properties.TryGetValue(dictKey, out var matchingProperty))
{
matchingProperty.SetValue(result,
objectSerializer.Deserialize(actualValue.GetValue(dictKey),
matchingProperty.PropertyType));
}
}
}
catch
{
//TODO:logging
}
}
}
return(result);
}
public static long Get(CefV8Context context, XrayObject target, CefListValue args, out CefV8Value value)
{
CefV8Value thisArg = GetSafeThisArg(context, target);
CefValue arg3 = args.GetValue(3);
CefValueType valueType = arg3.Type;
if (valueType == CefValueType.Int)
{
value = thisArg.GetValueByIndex(arg3.GetInt());
return(0);
}
string name = arg3.GetString();
value = thisArg.GetValue(name);
return(0);
}
public object Deserialize(CefValue value, Type targetType, ObjectSerializer objectSerializer)
{
if (!CanHandle(value, targetType))
{
throw new InvalidOperationException();
}
using (var dict = value.GetDictionary())
using (var val = dict.GetDictionary(ObjectSerializer.ValuePropertyName))
{
var id = val.GetInt64(nameof(PropertyDescriptor.Id));
var name = val.GetString(nameof(PropertyDescriptor.Name));
var propValue = val.GetValue(nameof(PropertyDescriptor.Value)).Copy();
return(new CefPropertyDescriptor(id, name, propValue));
}
}
protected override bool Execute(string name, CefV8Value obj, CefV8Value[] arguments, out CefV8Value returnValue, out string exception)
{
exception = null;
returnValue = null;
string paramSampler = arguments[0].GetStringValue();
switch (name)
{
//获取异常信息
case "GetHitchs":
//异常信息
string machineCode = string.Empty;
if (paramSampler == "#1")
{
machineCode = GlobalVars.MachineCode_QZDZYJ_1;
}
else if (paramSampler == "#2")
{
machineCode = GlobalVars.MachineCode_QZDZYJ_2;
}
equInfHitchs = CommonDAO.GetInstance().GetEquInfHitchsByTime(machineCode, DateTime.Now);
returnValue = CefV8Value.CreateString(Newtonsoft.Json.JsonConvert.SerializeObject(equInfHitchs.Select(a => new { MachineCode = a.MachineCode, HitchTime = a.HitchTime.ToString("yyyy-MM-dd HH:mm"), HitchDescribe = a.HitchDescribe })));
break;
case "OpenAutoMaker":
CefProcessMessage OpenAutoMaker = CefProcessMessage.Create("OpenAutoMaker");
int f = 0;
foreach (CefV8Value item in arguments)
{
CefValue model = CefValue.Create();
model.SetString(item.GetStringValue());
OpenAutoMaker.Arguments.SetValue(f, model);
f++;
}
CefV8Context.GetCurrentContext().GetBrowser().SendProcessMessage(CefProcessId.Browser, OpenAutoMaker);
break;
default:
returnValue = null;
break;
}
return(true);
}
public ICefValue Serialize(object obj, Stack <object> seen, ObjectSerializer objectSerializer)
{
var type = obj?.GetType();
if (!CanHandle(type))
{
throw new InvalidOperationException();
}
if (type == typeof(string))
{
var result = CefValue.Create();
result.SetString((string)obj);
return(result);
}
using (var value = CefDictionaryValue.Create())
using (var dict = CefDictionaryValue.Create())
{
value.SetString(ObjectSerializer.TypeIdPropertyName, GetTypeId(type));
var properties = type.GetProperties();
var shouldFilter = type.GetCustomAttribute <DataContractAttribute>() != null;
foreach (var propertyDesc in properties
.Where(p => p.GetIndexParameters().Length <= 0)
.Select(p => new { Property = p, DataMember = p.GetCustomAttribute <DataMemberAttribute>() })
.Where(p => p.DataMember != null || !shouldFilter))
{
var propertyValue = propertyDesc.Property.GetValue(obj);
var name = propertyDesc.DataMember?.Name ?? propertyDesc.Property.Name;
var cefValue = objectSerializer.Serialize(propertyValue, seen);
dict.SetValue(name, cefValue);
}
value.SetDictionary(ObjectSerializer.ValuePropertyName, dict);
var result = CefValue.Create();
result.SetDictionary(value);
return(result);
}
}
public CefValue Serialize(object obj, HashSet <object> seen)
{
CefValue result;
var type = obj?.GetType();
var serializer = Serializers.FirstOrDefault(s => s.CanHandle(type));
if (serializer != null && HandleSeen(seen, obj, type))
{
result = serializer.Serialize(obj, seen, this);
}
else
{
result = CefValue.Create();
result.SetNull();
}
return(result);
}
public object Deserialize(CefValue source, Type targetType, ObjectSerializer objectSerializer)
{
if (!CanHandle(source, targetType))
{
throw new InvalidOperationException();
}
using (var lstVal = source.GetList())
{
var elementType = targetType.GetElementType();
var array = Activator.CreateInstance(targetType, lstVal.Count) as Array;
for (var i = 0; i < lstVal.Count; i++)
{
array.SetValue(objectSerializer.Deserialize(lstVal.GetValue(i), elementType), i);
}
return(array);
}
}
public CefValue Serialize(object source, HashSet <object> seen, ObjectSerializer objectSerializer)
{
if (source is CefValue value)
{
return(value);
}
else if (source is CefDictionaryValue)
{
var result = CefValue.Create();
result.SetDictionary((CefDictionaryValue)source);
return(result);
}
else if (source is CefListValue)
{
var result = CefValue.Create();
result.SetList((CefListValue)source);
return(result);
}
return(null);
}
public CefValue Serialize(object obj, HashSet <object> seen, ObjectSerializer objectSerializer)
{
var type = obj.GetType();
if (!CanHandle(type))
{
throw new InvalidOperationException();
}
var result = CefValue.Create();
if (type == typeof(DateTime))
{
result.SetTime((DateTime)obj);
}
else if (type == typeof(decimal))
{
result.SetDouble(Convert.ToDouble((decimal)obj));
}
return(result);
}
private static object CastToDotnetType(CefValue value)
{
if (value == null)
{
return(null);
}
if (!value.IsValid)
{
throw new InvalidCastException();
}
switch (value.Type)
{
case CefValueType.String:
return(value.GetString());
case CefValueType.Int:
return(value.GetInt());
case CefValueType.Bool:
return(value.GetBool());
case CefValueType.Null:
return(null);
case CefValueType.Double:
return(value.GetDouble());
case CefValueType.Binary:
CefBinaryValue v = value.GetBinary();
if (v.Size == 1)
{
return(V8Undefined.Value);
}
return(XrayHandle.FromCfxBinaryValue(v).ToObject());
}
throw new NotImplementedException();
}
public ICefValue Serialize(object obj, Stack <object> seen)
{
ICefValue result;
var type = obj?.GetType();
var serializer = Serializers.FirstOrDefault(s => s.CanHandle(type));
using (HandleSeen(seen, obj, type, out var canSerialize))
{
if (serializer != null && canSerialize)
{
result = serializer.Serialize(obj, seen, this);
}
else
{
result = CefValue.Create();
result.SetNull();
}
}
return(result);
}
public CefValue Serialize(object obj, HashSet <object> seen, ObjectSerializer objectSerializer)
{
var type = obj?.GetType();
if (!CanHandle(type))
{
throw new InvalidOperationException();
}
var array = (Array)obj;
using (var value = CefListValue.Create())
{
for (var i = 0; i < array.Length; i++)
{
value.SetValue(i, objectSerializer.Serialize(array.GetValue(i), seen));
}
var result = CefValue.Create();
result.SetList(value);
return(result);
}
}
public bool CanHandle(CefValue cefValue, Type targetType)
{
return(targetType == typeof(CefValue));
}
public bool CanHandle(CefValue cefValue, Type targetType)
{
return(cefValue.GetValueType() == CefValueType.List &&
(targetType?.IsArray == true || targetType == typeof(object)));
}
internal unsafe static CefValue CastCefV8ValueToCefValue(CefV8Context context, CefV8Value value, out bool isXray)
{
isXray = false;
if (value == null)
{
return(null);
}
if (!value.IsValid)
{
throw new InvalidCastException();
}
CefValue v;
switch (value.Type)
{
case CefV8ValueType.Undefined:
v = new CefValue();
v.SetBinary(new byte[1]);
return(v);
case CefV8ValueType.Null:
v = new CefValue();
v.SetNull();
return(v);
case CefV8ValueType.Bool:
v = new CefValue();
v.SetBool(value.GetBoolValue());
return(v);
case CefV8ValueType.Int: // TYPE_INT, TYPE_UINT
case CefV8ValueType.UInt:
v = new CefValue();
v.SetInt(value.GetIntValue());
return(v);
case CefV8ValueType.Double:
v = new CefValue();
v.SetDouble(value.GetDoubleValue());
return(v);
case CefV8ValueType.Date:
v = new CefValue();
v.SetBinary(XrayHandle.FromDateTime(value.GetDateValue().ToDateTime()).ToCfxBinaryValue());
return(v);
case CefV8ValueType.String:
v = new CefValue();
if (!value.CopyV8StringToCefValue(v))
{
throw new CefRuntimeException("Can't copy the string.");
}
return(v);
case CefV8ValueType.Object:
isXray = true;
if (value.IsArray) //TYPE_OBJECT (array)
{
throw new NotImplementedException();
}
if (value.IsArrayBuffer) //TYPE_OBJECT (arraybuffer)
{
throw new NotImplementedException();
}
v = new CefValue();
v.SetBinary(XrayObject.Wrap(context, value).CreateHandle().ToCfxBinaryValue());
return(v);
}
throw new NotImplementedException();
}
protected override void OnAccessibilityLocationChange(CefValue value)
{
}
public bool CanHandle(CefValue cefValue, Type targetType)
{
return(cefValue.GetValueType() == CefValueType.String &&
(targetType == typeof(string) || targetType == typeof(object)));
}
public CefPropertyDescriptor(long id, string name, CefValue value)
{
Id = id;
ListValue = value;
Name = name;
}
public bool CanHandle(CefValue cefValue, Type targetType)
{
return(cefValue.GetValueType() == CefValueType.Dictionary && targetType == typeof(PropertyDescriptor));
}
