public static object DeserializePayloadUsingSpecificSerializer(
this DescribedSerialization describedSerialization,
IDeserialize deserializer,
IDecompress decompressor = null,
TypeMatchStrategy typeMatchStrategy = TypeMatchStrategy.NamespaceAndName,
MultipleMatchStrategy multipleMatchStrategy = MultipleMatchStrategy.ThrowOnMultiple)
{
new { describedSerialization }.Must().NotBeNull();
new { deserializer }.Must().NotBeNull();
var localDecompressor = decompressor ?? new NullCompressor();
var targetType = describedSerialization.PayloadTypeRepresentation.ResolveFromLoadedTypes(typeMatchStrategy, multipleMatchStrategy);
object ret;
switch (describedSerialization.SerializationDescription.SerializationFormat)
{
case SerializationFormat.Binary:
var rawBytes = Convert.FromBase64String(describedSerialization.SerializedPayload);
var decompressedBytes = localDecompressor.DecompressBytes(rawBytes);
ret = deserializer.Deserialize(decompressedBytes, targetType);
break;
case SerializationFormat.String:
ret = deserializer.Deserialize(describedSerialization.SerializedPayload, targetType);
break;
default: throw new NotSupportedException(Invariant($"{nameof(SerializationFormat)} - {describedSerialization.SerializationDescription.SerializationFormat} is not supported."));
}
return(ret);
}
public void OnEditDeserialize(IDeserialize objDeserialize)
{
assemblyMetadata = (AssemblyMetadata)objDeserialize.Deserialize();
pathVariable = objDeserialize.ToString();
HierarchicalAreas.Clear();
TreeViewLoaded(assemblyMetadata);
MessageBox.Show(objDeserialize.ToString());
}
public static T DeserializePayloadUsingSpecificSerializer <T>(
this DescribedSerializationBase describedSerializationBase,
IDeserialize deserializer,
AssemblyMatchStrategy assemblyMatchStrategy = AssemblyMatchStrategy.AnySingleVersion)
{
var result = (T)DeserializePayloadUsingSpecificSerializer(describedSerializationBase, deserializer, assemblyMatchStrategy);
return(result);
}
/// <inheritdoc cref="IDeserializeAsync{T}.DeserializeAsync(Stream, CancellationToken)"/>
public static ValueTask <T> DeserializeAsync <T>(this IDeserialize <T> deserializer, Stream source, CancellationToken cancellationToken = default)
{
if (deserializer is null)
{
throw new ArgumentNullException(nameof(deserializer));
}
return(deserializer is IDeserializeAsync <T> d
? d.DeserializeAsync(source, cancellationToken)
: DefaultMethods.DeserializeAsync(deserializer, source));
}
private void deserializeAttribute(Newtonsoft.Json.Linq.JObject data, string v)
{
Newtonsoft.Json.Linq.JObject dict = data[v] as Newtonsoft.Json.Linq.JObject;
string classType = (string)dict["type"];
classType = classType.Substring(classType.IndexOf("::") + 2);
//UnityEngine.Debug.LogFormat("classType{0}", classType);
System.Type ct = System.Type.GetType(classType, true);
IDeserialize o = (IDeserialize)Activator.CreateInstance(ct);
//需要用到反射，但是private数据会获取不到，所以改成public
this.GetType().GetField(v).SetValue(this, o);
o.deserialize(dict);
}
/// <summary>
/// Deserializes a stream to the specified type.
/// </summary>
public static async ValueTask <T> DeserializeAsync <T>(IDeserialize deserializer, Stream source)
{
if (deserializer is null)
{
throw new ArgumentNullException(nameof(deserializer));
}
if (source is null)
{
throw new ArgumentNullException(nameof(source));
}
string text;
using (var reader = new StreamReader(source))
text = await reader.ReadToEndAsync().ConfigureAwait(false);
return(deserializer.Deserialize <T>(text));
}
public SellOrderFactory()
{
directoryPath = new DirectoryPathConfig();
fileManager = new FileManager();
processorFilesRequest = new ProcessorFilesRequest(directoryPath, fileManager);
serialize = new JsonSerialize();
deserialize = new JsonDeserialize();
processorFilesResponse = new ProcessorFilesResponse(directoryPath, fileManager, serialize);
mapProcessFile = new MapProcessFile(directoryPath, fileManager, deserialize);
processSellOrder = new ProcessSellOrder();
validateSellOrderBusinessRules = new ValidateSellOrderBusinessRules();
executionSellOrder = new ExecutionSellOrder(processSellOrder, validateSellOrderBusinessRules);
handleSellOrder = new HandleSellOrder(processorFilesRequest, processorFilesResponse, mapProcessFile, executionSellOrder);
}
public static object DeserializePayloadUsingSpecificSerializer(
this DescribedSerializationBase describedSerializationBase,
IDeserialize deserializer,
AssemblyMatchStrategy assemblyMatchStrategy = AssemblyMatchStrategy.AnySingleVersion)
{
if (describedSerializationBase == null)
{
throw new ArgumentNullException(nameof(describedSerializationBase));
}
if (deserializer == null)
{
throw new ArgumentNullException(nameof(deserializer));
}
var targetType = describedSerializationBase.PayloadTypeRepresentation.ResolveFromLoadedTypes(assemblyMatchStrategy);
object result;
var serializationFormat = describedSerializationBase.GetSerializationFormat();
switch (serializationFormat)
{
case SerializationFormat.Binary:
var describedSerializationBinary = (BinaryDescribedSerialization)describedSerializationBase;
var serializedBytes = describedSerializationBinary.SerializedPayload;
result = serializedBytes == null ? null : deserializer.Deserialize(serializedBytes, targetType);
break;
case SerializationFormat.String:
var describedSerializationString = (StringDescribedSerialization)describedSerializationBase;
var serializedString = describedSerializationString.SerializedPayload;
result = serializedString == null ? null : deserializer.Deserialize(serializedString, targetType);
break;
default:
throw new NotSupportedException(Invariant($"{nameof(SerializationFormat)} - {serializationFormat} is not supported."));
}
return(result);
}
public static async Task <IWhatsAppApi <T> > Deserialize <T>(this IDeserialize <T> self, Task <string> json) where T : class, IDeserialize <T>, new()
{
if (self is null)
{
Error = new JsonError {
IsError = true, CodeOfError = 4, TextError = "WhatsAppMessage is null"
};
var result = new DeserializeMessage <T> {
Result = new T(), Error = Error
};
return(result);
}
var jsonMessage = await json;
if (string.IsNullOrEmpty(jsonMessage))
{
self.Deserialize.Error = new JsonError {
IsError = true, CodeOfError = 0, TextError = "Json file is empty"
};
return(self.Deserialize);
}
try
{
self.Deserialize.Result = JsonConvert.DeserializeObject <T>(jsonMessage, Settings);
self.Deserialize.Error = Error;
}
catch (JsonException)
{
self.Deserialize.Result = (T)self;
self.Deserialize.Error = new JsonError {
IsError = true, CodeOfError = 1, TextError = "Json file is broken"
};
}
self.Deserialize.Result.DateTime = DateTime.Now;
return(self.Deserialize);
}
private async Task LoadConfigForType <T>(ILog log, IDeserialize serializer, IConfiguration configuration, string appDataSubFolderName, Func <T, Task> foundItems)
{
if (foundItems == null)
{
return;
}
var configFolder = System.IO.Path.Combine(configuration.AppDataDirectory.FullName, appDataSubFolderName);
if (!System.IO.Directory.Exists(configFolder))
{
System.IO.Directory.CreateDirectory(configFolder);
}
foreach (var file in System.IO.Directory.GetFiles(configFolder))
{
try
{
if (System.IO.File.Exists(file))
{
var json = System.IO.File.ReadAllText(file);
if (!string.IsNullOrEmpty(json))
{
var items = serializer.Deserialize <T>(json);
if (items != null)
{
await foundItems(items);
}
}
}
}
catch (Exception e)
{
log.Error(e, "Could not load config from file:{0}", file);
}
}
}
public TransportFactory(IDeserialize serializer, IDIContainer container)
{
_serializer = serializer;
_container = container;
}
public SocketProtocol(ISerialize serialize, IDeserialize deserialize, ICrypto crypto)
{
Serialize = serialize;
Deserialize = deserialize;
Crypto = crypto;
}
public MapProcessFile(IDirectoryPathConfig directoryPathConfig, IFileManager fileManager, IDeserialize deserialize)
{
this.directoryPathConfig = directoryPathConfig;
this.fileManager = fileManager;
this.deserialize = deserialize;
}
public DataLayer(IDeserialize serializer_)
{
this.serializer = serializer_;
}
public DefaultHttpProtocol(ISerialize serialize, IDeserialize deserialize, ICrypto crypto) : base(serialize, deserialize, crypto)
{
}
public Service(IServiceSecurity serviceSecurity, IDeserialize deserialize, ISerialize serialize)
{
this.serviceSecurity = serviceSecurity;
this.deserialize = deserialize;
this.serialize = serialize;
}
public static bool Load(IDeserialize deserializer, ref ObservableModelData obj)
{
return(deserializer.Deserialize(ref obj));
}
