public void Deserialize_BadJson_Throws() { var json = @" { 'instanceId':'localhost:foo', 'hostName':'localhost', 'app':'FOO', 'ipAddr':'192.168.56.1', "; Stream stream = TestHelpers.StringToStream(json); var ex = Assert.Throws <JsonSerializationException>(() => JsonSerialization.Deserialize <JsonInstanceInfo>(stream)); }
public void serialize_fixtures() { var library = FixtureLibrary.CreateForAppDomain(CellHandling.Basic()); // CreateLocation // AddressVerification var fixtureModels = library.Models.GetAll().ToArray(); var json = JsonSerialization.ToJson(fixtureModels); var models = JsonSerialization.Deserialize <FixtureModel[]>(json); models.Each(x => Debug.WriteLine(x.key)); }
public void round_trip_serialization() { theResult.MarkMatched("1"); theResult.MarkExtra(new StepValues("foo")); theResult.MarkMissing("bar"); theResult.MarkWrongOrder(Guid.NewGuid().ToString(), 1); var json = JsonSerialization.ToJson(theResult); var newResult = JsonSerialization.Deserialize <SetVerificationResult>(json); newResult.matches.Single().ShouldBe("1"); newResult.extras.Count().ShouldBe(1); newResult.missing.Single().ShouldBe("bar"); newResult.wrongOrdered.Count().ShouldBe(1); }
internal static Project Open(FileInfo projectFile) { var project = new Project { Settings = JsonSerialization.Deserialize <ProjectSettings>(projectFile.FullName) }; project.Guid = new Guid(projectFile.ToAssetGuid()); // Patch up any guid references if they are missing. if (Guid.Empty == project.Settings.Configuration) { project.Settings.Configuration = new Guid(AssetDatabaseUtility.GetAssetGuid(projectFile.ChangeExtension(k_ConfigurationFileExtension))); } if (Guid.Empty == project.Settings.MainAsmdef) { project.Settings.MainAsmdef = new Guid(AssetDatabaseUtility.GetAssetGuid(projectFile.ChangeExtension(k_AssemblyDefinitionFileExtension))); } if (!DomainReload.IsDomainReloading) { var entityManager = project.EntityManager; var configFile = project.GetConfigurationFile(); if (configFile.Exists) { project.PersistenceManager.LoadScene(entityManager, configFile.FullName); // Hack: remove scene guid/instance id var configEntity = project.WorldManager.GetConfigEntity(); entityManager.RemoveComponent <SceneGuid>(configEntity); entityManager.RemoveComponent <SceneInstanceId>(configEntity); } else { var configEntity = project.WorldManager.CreateEntity(project.ArchetypeManager.Config); entityManager.SetComponentData(configEntity, DisplayInfo.Default); } } s_Projects.Add(project); ProjectOpened(project); DomainCache.CacheIncludedAssemblies(project); return(project); }
public void SerializeDeserializeTestPersonProper() { var person = RandomData.GenerateRefPerson <PersonProper>(); //Serialize var json = JsonSerialization.Serialize(person); //For debugging //JsonSerialization.SerializeToFile(person, @"C:\dotNetTips.com\DebugOutput\PersonProper.json"); Assert.IsTrue(string.IsNullOrEmpty(json) is false); //Deserialize var serializedPerson = JsonSerialization.Deserialize <PersonProper>(Resources.JsonPersonProper); Assert.IsNotNull(serializedPerson); }
private IDictionary <string, EmbeddedSpec> readSpecs() { var dict = new Dictionary <string, EmbeddedSpec>(); var fileSystem = new FileSystem(); fileSystem.FindFiles(_settings.Root, FileSet.Deep("*.specs.json")).Each(file => { var json = fileSystem.ReadStringFromFile(file); var response = JsonSerialization.Deserialize <BatchRunResponse>(json); var fixtures = new Dictionary <string, FixtureModel>(); response.fixtures.Each(x => fixtures.Add(x.key, x)); response.records.Each(rec => dict.Add(rec.specification.path, new EmbeddedSpec(fixtures, rec))); }); return(dict); }
public void LoadSettings(string serial) { try { string json = File.ReadAllText(FilePath); dynamic data = JsonSerialization.Deserialize(json); DeviceName = (string)data.deviceName; } catch { } if (String.IsNullOrWhiteSpace(DeviceName)) { DeviceName = serial.ToUpper(); SaveSettings(); } }
public static async Task <EventsData> LoadEvensAsync(this IDynamoDBContext connection, Guid correlationId, IEnumerable <Type> knownTypes, DynamoDBOperationConfig configuration) { var data = await GetEventsAsync(connection, correlationId, configuration); var events = new List <object>(); if (data is null) { return new EventsData { Events = events, LastVersion = null } } ; events.AddRange(data.Events.SelectMany(@event => JsonSerialization.Deserialize(@event, knownTypes))); return(new EventsData { Events = events, LastVersion = data.Version }); }
public static async Task <AggregatedEvents> LoadEventsAsync(this IDynamoDBContext context, Guid aggregateId, IEnumerable <Type> knownTypes, DynamoDbEventStoreOptions options) { var data = await context.GetEventsAsync(aggregateId, options); var events = new List <object>(); if (data is null) { return new AggregatedEvents { Events = events, LastVersion = null } } ; events.AddRange(data.SelectMany(@event => JsonSerialization.Deserialize(@event, knownTypes))); return(new AggregatedEvents { Events = events, LastVersion = data.Max(model => model.Version), AggregateId = aggregateId.ToString() }); }
public static DatabaseSettings GetDatabaseSettings() { DatabaseSettings settings; var jsonString = UnityEditor.EditorPrefs.GetString(EditorPrefsKey); if (!String.IsNullOrEmpty(jsonString)) { settings = (DatabaseSettings)JsonSerialization.Deserialize(typeof(DatabaseSettings), jsonString); } else { settings = ScriptableObject.CreateInstance <DatabaseSettings>(); settings.liveReload = true; settings.databaseFolder = DefaultFolder; settings.databaseName = DefaultName; settings.savePath = DefaultPath; settings.ViewingDatabase = DefaultName; } return(settings); }
public static PacketData FromJson(string json) { dynamic data = JsonSerialization.Deserialize(json); string serial = (string)data.serial; string name = (string)data.name; string version = (string)data.version; int httpPort = (int)data.httpPort; TimeSpan runningTime = TimeSpan.FromSeconds((int)data.runningSecs); string serviceState = (string)data.serviceState ?? "Unknown"; List <Interface> interfaces = new List <Interface>(); foreach (dynamic i in data.interfaces) { string iName = (string)i.name; string iPhysical = (string)i.physical; string iInternat = (string)i.internet; interfaces.Add(new Interface(iName, iPhysical, iInternat)); } return(new PacketData(serial, name, version, httpPort, runningTime, serviceState, interfaces)); }
/// <summary> /// Loads entries file. /// </summary> private static List <Entry> LoadEntriesFile() { try { if (!File.Exists(EntriesFile)) { Console.WriteLine($"Entries file {EntriesFile} does not exist"); Console.Write("Continue and create a new one? [Y/N] : "); string input = Console.ReadLine().Trim().ToUpper(); if (input != "Y") { throw new Exception("Quitting program"); } return(new List <Entry>()); } Console.WriteLine($"Loading file {EntriesFile}"); string json = File.ReadAllText(EntriesFile); dynamic data = JsonSerialization.Deserialize(json); List <Entry> entries = new List <Entry>(); foreach (dynamic e in data.entries) { string ip = (string)e.ip; string host = (string)e.host; string mac = (string)e.mac; entries.Add(new Entry(ip, host, mac)); } entries = entries.OrderBy(e => e.SortIP).ToList(); return(entries); } catch (Exception ex) { throw new Exception($"Unable to load file {EntriesFile}", ex); } }
public static TResult FromJson <TResult>([NotNull] this string json) { return(JsonSerialization.Deserialize <TResult>(json.ArgumentNotNullOrEmpty())); }
protected JObject Decode(byte[] message) => JsonSerialization.Deserialize(Encoding.UTF8.GetString(message));
/// <summary> /// Clone using JSON, can just use CreateInstance<>()? /// </summary> /// <returns>The cloned Template</returns> public Template Clone() { string json = JsonSerialization.Serialize(this.GetType(), this); return((Template)JsonSerialization.Deserialize(this.GetType(), json)); }
public void HandleJson(string json, IApplication app) { var message = JsonSerialization.Deserialize <T>(json); HandleMessage(message, app); }
public void Deserialize04() { var result = JsonSerialization.Deserialize <PersonRecord>(Resources.PersonProperJson); base.Consumer.Consume(result); }
private void Export(AssetInfo asset, Entity entity, BuildPipeline.BuildContext context) { // Get asset exporter var assetExporter = m_AssetExporters.Values.FirstOrDefault(x => x.CanExport(asset.Object)); if (assetExporter == null) { return; // Assets without asset exporter do not need to export anything } // Get asset path var assetPath = UnityEditor.AssetDatabase.GetAssetPath(asset.Object); if (string.IsNullOrEmpty(assetPath)) { assetPath = string.Empty; } // Compute asset export file path Assert.IsTrue(EntityManager.HasComponent <EntityGuid>(entity)); var assetGuid = WorldManager.GetEntityGuid(entity); var outputFile = context.DataDirectory.GetFile(assetGuid.ToString("N")); // Compute asset export hash var exportHash = assetExporter.GetExportHash(asset.Object); if (exportHash == Guid.Empty) { throw new InvalidOperationException($"{assetExporter.GetType().FullName} did not provide a valid asset export hash."); } // Retrieve exported files from manifest IEnumerable <FileInfo> exportedFiles = null; var manifestFile = new FileInfo(outputFile.FullName + ".manifest"); if (manifestFile.Exists) { try { var manifest = JsonSerialization.Deserialize <BuildManifest.Entry>(manifestFile.FullName); if (manifest != null && manifest.AssetPath == assetPath && manifest.AssetGuid == assetGuid && manifest.ExportVersion == assetExporter.ExportVersion && manifest.ExportHash == exportHash) { // Verify that all files exists var files = manifest.ExportedFiles.Select(x => new FileInfo(x)); if (files.Where(file => file.Exists).Count() == manifest.ExportedFiles.Count) { exportedFiles = files; } } } catch (InvalidJsonException) { // Manifest file couldn't be read, format might have changed } } // Export asset if export files are not found var didExport = false; if (exportedFiles == null) { exportedFiles = assetExporter.Export(outputFile, asset.Object); didExport = exportedFiles != null && exportedFiles.Count() > 0; } // Update manifest var entry = context.Manifest.Add(assetGuid, assetPath, exportedFiles, assetExporter.ExportVersion, exportHash); if (entry != null && didExport) { manifestFile.WriteAllText(JsonSerialization.Serialize(entry)); } }
public void HandleJson(string json) { var message = JsonSerialization.Deserialize <T>(json); HandleMessage(message); }
/// <summary> /// Load Database From a Text Asset /// </summary> /// <param name="json"></param> /// <returns></returns> public static Database Load(TextAsset json) { return((Database)JsonSerialization.Deserialize(typeof(Database), json.text)); }
/// <summary> /// 将JSON字符串反序列化为对象 /// </summary> /// <typeparam name="T"></typeparam> /// <param name="jsonString"></param> /// <returns></returns> public static T ToJsonObject <T>(this string jsonString) { return(JsonSerialization.Deserialize <T>(jsonString)); }