public async Task InvokeAsync(HttpContext context) #endif { if (context.Request.Method.Equals(HttpMethods.Get, StringComparison.Ordinal) && context.IsValidPath(_path)) { context.Response.ContentType = "application/graphql"; context.Response.Headers.Add( "Content-Disposition", new[] { "attachment; filename=\"schema.graphql\"" }); using (var streamWriter = new StreamWriter( context.Response.Body)) { SchemaSerializer.Serialize( _queryExecutor.Schema, streamWriter); await streamWriter.FlushAsync(); } } else { await Next.Invoke(context); } }
public Dictionary <string, object> GetMeta() { var schema = SchemaGenerator.GenerateFromType <Note>(); using var ms = new MemoryStream(); var writer = new Utf8JsonWriter(ms); var serializerOptions = new JsonSerializerOptions() { WriteIndented = true, PropertyNamingPolicy = JsonNamingPolicy.CamelCase, DictionaryKeyPolicy = JsonNamingPolicy.CamelCase }; SchemaSerializer.Serialize(schema, writer, serializerOptions); writer.Flush(); ms.Position = 0; using var sr = new StreamReader(ms); var serializedSchema = sr.ReadToEnd(); return(new Dictionary <string, object> { ["schema"] = serializedSchema }); }
public void AddSchema_2() { // arrange Schema customerSchema = Schema.Create( CustomerSchemaFactory.ConfigureSchema); Schema contractSchema = Schema.Create( ContractSchemaFactory.ConfigureSchema); var builder = new MockStitchingBuilder(); // act builder.AddSchema("customer", customerSchema) .AddSchema("contract", contractSchema); // assert var services = new EmptyServiceProvider(); var merger = new SchemaMerger(); foreach (KeyValuePair <NameString, ExecutorFactory> item in builder.Executors) { ISchema schema = item.Value.Invoke(services).Schema; merger.AddSchema(item.Key, SchemaSerializer.SerializeSchema(schema)); } SchemaSyntaxSerializer.Serialize(merger.Merge()).MatchSnapshot(); }
static SerializerFactory() { _autoSerializer = new AutoSerializer(); _booleanSerializer = new BooleanSerializer(); _enumNameSerializer = new EnumNameSerializer(); _enumValueSerializer = new EnumValueSerializer(); _jsonSerializableSerializer = new JsonSerializableSerializer(); _numericSerializer = new NumericSerializer(); _registeredObjectSerializer = new RegisteredObjectSerializer(); _stringSerializer = new StringSerializer(); _schemaSerializer = new SchemaSerializer(); _uriSerializer = new UriSerializer(); _library = new Dictionary <Type, ISerializer> { { typeof(sbyte), _numericSerializer }, { typeof(byte), _numericSerializer }, { typeof(char), _numericSerializer }, { typeof(short), _numericSerializer }, { typeof(ushort), _numericSerializer }, { typeof(int), _numericSerializer }, { typeof(uint), _numericSerializer }, { typeof(long), _numericSerializer }, { typeof(ulong), _numericSerializer }, { typeof(float), _numericSerializer }, { typeof(double), _numericSerializer }, { typeof(decimal), _numericSerializer }, { typeof(bool), _booleanSerializer }, { typeof(string), _stringSerializer }, { typeof(Uri), _uriSerializer } }; }
public async Task InvokeAsync(HttpContext context) #endif { if (context.Request.Method.Equals( HttpMethods.Get, StringComparison.Ordinal) && context.IsValidPath(_path)) { context.Response.ContentType = ContentType.GraphQL; context.Response.Headers.Add( "Content-Disposition", new[] { "attachment; filename=\"schema.graphql\"" }); using (var memoryStream = new MemoryStream()) { using (var streamWriter = new StreamWriter(memoryStream)) { SchemaSerializer.Serialize( _queryExecutor.Schema, streamWriter); await streamWriter.FlushAsync().ConfigureAwait(false); memoryStream.Seek(0, SeekOrigin.Begin); await memoryStream.CopyToAsync(context.Response.Body).ConfigureAwait(false); } } } else { await Next.Invoke(context).ConfigureAwait(false); } }
public Task ExecuteAsync( ControllerActionDescriptor action, Utf8JsonWriter writer, JsonSerializerOptions options) { var namingPolicy = options.PropertyNamingPolicy; writer.WriteStartObject(); writer.WriteString(namingPolicy.ConvertName("type"), "object"); writer.WriteStartObject(namingPolicy.ConvertName("properties")); writer.WriteStartObject(namingPolicy.ConvertName("api")); writer.WriteString(namingPolicy.ConvertName("type"), "object"); writer.WriteStartObject(namingPolicy.ConvertName("properties")); writer.WriteStartObject(namingPolicy.ConvertName("title")); writer.WriteString(namingPolicy.ConvertName("type"), "string"); writer.WriteEndObject(); writer.WriteEndObject(); writer.WriteEndObject(); writer.WriteStartObject(namingPolicy.ConvertName("resources")); writer.WriteString(namingPolicy.ConvertName("type"), "object"); writer.WriteBoolean(namingPolicy.ConvertName("additionalProperties"), false); writer.WriteEndObject(); writer.WriteEndObject(); var returnType = action.MethodInfo.GetCustomAttribute <ReturnsAttribute>()?.ReturnType ?? typeof(object); var links = Links.ForType(FSharpFunc <Type, InputJsonSchema> .FromConverter(SchemaGenerator.getInputSchema), returnType); SchemaSerializer.writeLinks(links).Invoke(Tuple.Create(writer, options)); writer.WriteEndObject(); return(Task.CompletedTask); }
private static void AddSchemasFromExecutors( IDictionary <NameString, DocumentNode> schemas, IEnumerable <IRemoteExecutorAccessor> accessors) { foreach (IRemoteExecutorAccessor accessor in accessors) { schemas[accessor.SchemaName] = SchemaSerializer.SerializeSchema( accessor.Executor.Schema); } }
static void Main(string[] args) { // {"@context":"https://schema.org","@type":"CustomType","Name":"Hello World"} var inputObj = new CustomType { Name = "Hello World" }; var json = SchemaSerializer.SerializeObject(inputObj); var outputObj = SchemaSerializer.DeserializeObject <CustomType>(json); }
public void SchemaSerializerTestStruct1() { var Serializer = new SchemaSerializer<TestDataStruct>(); Assert.AreEqual("{\r\n\"data1\" : { \"type\" : \"System.Int32\", \"position\": \"0\", \"size\": \"4\" },\r\n\"data2\" : { \"type\" : \"System.Int64\", \"position\": \"5\", \"size\": \"8\" },\r\n\"data3\" : { \"type\" : \"System.String\", \"position\": \"12\", \"size\": \"50\" },\r\n\"data4\" : { \"type\" : \"System.Byte[]\", \"position\": \"62\", \"size\": \"30\" }\r\n}\r\n", Serializer.Schema); Assert.AreEqual(96, Serializer.StructSize); var x1 = Serializer.Serialize(new TestDataStruct() { data1 = 1024, data2 = -1024 }); Assert.AreEqual(96, x1.Length); Assert.AreEqual("000400000000FCFFFFFFFFFFFF0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", BitConverter.ToString(x1).Replace("-","")); var x2 = Serializer.Serialize(new TestDataStruct() { data1 = Int32.MaxValue, data2 = -13 }); Assert.AreEqual(96, x2.Length); Assert.AreEqual("FFFFFF7F00F3FFFFFFFFFFFFFF0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", BitConverter.ToString(x2).Replace("-", "")); }
private void WriteIntrospectionResponse(ControllerActionDescriptor action, Utf8JsonWriter writer, JsonSerializerOptions options) { var returnType = action.MethodInfo.GetCustomAttribute <ReturnsAttribute>()?.ReturnType ?? typeof(object); var links = Links.ForType(FSharpFunc <Type, InputJsonSchema> .FromConverter(SchemaGenerator.getInputSchema), returnType); writer.WriteStartObject(); writer.WritePropertyName("data"); writer.WriteStartObject(); SchemaSerializer.writeLinks(links).Invoke(Tuple.Create(writer, options)); writer.WriteEndObject(); writer.WriteStartObject("meta"); writer.WriteEndObject(); writer.WriteEndObject(); }
public static void StartStructSer() { var structser = new SchemaSerializer<Data>(); var StructSize = structser.StructSize; Byte[] x1 = null; var sw = new Stopwatch(); sw.Start(); for (var i=0;i<100000;i++) x1 = structser.SerializeCached(new Data() { data1 = 12, data2 = -12 }, ClearCache: false); sw.Stop(); Console.WriteLine(sw.ElapsedMilliseconds); var x2 = structser.Serialize(new Data() { data1 = 1024, data2 = -1024 }); var x3 = structser.Serialize(new Data() { data1 = 80000, data2 = -80000 }); var x4 = structser.Serialize(new Data() { data1 = Int32.MaxValue, data2 = -13 }); var x5 = structser.Serialize(new Data() { data1 = Int32.MinValue, data2 = -13 }); }
static void Main(string[] args) { Console.WriteLine(args[0]); using (FileStream zipToOpen = new FileStream(@args[0], FileMode.Open)) { var recipes = RecipeKeeperImporter.GetSchemaRecipes(zipToOpen); string recipesJsonStr = SchemaSerializer.SerializeObject(recipes); // FIXME: line andings are currently not write correct to file // correct the line endings for host OS //recipesJsonStr = Regex.Replace(recipesJsonStr, @"\\r\\n?|\\n", Environment.NewLine); File.WriteAllText("recipes.json", recipesJsonStr, Encoding.UTF8); Console.WriteLine(recipesJsonStr); } Console.WriteLine("Import completed!"); }
public Task ExecuteAsync( ControllerActionDescriptor action, Utf8JsonWriter writer, JsonSerializerOptions options) { var method = action.MethodInfo; var returnType = method.GetCustomAttribute <ReturnsAttribute>()?.ReturnType; if (returnType != null) { var wrapperType = typeof(MicrotypeContainerWrapper <>).MakeGenericType(returnType); var schema = SchemaGenerator.GenerateFromType(wrapperType); SchemaSerializer.Serialize(schema, writer, options); } else { writer.WriteStartObject(); writer.WriteEndObject(); } return(Task.CompletedTask); }
private async Task HandleRequestAsync(HttpContext context) { IRequestExecutor requestExecutor = await GetExecutorAsync(context.RequestAborted); string fileName = requestExecutor.Schema.Name.IsEmpty || requestExecutor.Schema.Name.Equals(Schema.DefaultName) ? "schema.graphql" : requestExecutor.Schema.Name + ".schema.graphql"; context.Response.ContentType = ContentType.GraphQL; context.Response.Headers.Add( "Content-Disposition", new[] { $"attachment; filename=\"{fileName}\"" }); await SchemaSerializer.SerializeAsync( requestExecutor.Schema, context.Response.Body, indented : true, context.RequestAborted) .ConfigureAwait(false); }
private async Task HandleRequestAsync(HttpContext context) { IRequestExecutor requestExecutor = await GetExecutorAsync(context.RequestAborted); string fileName = requestExecutor.Schema.Name.IsEmpty || requestExecutor.Schema.Name.Equals(Schema.DefaultName) ? "schema.graphql" : requestExecutor.Schema.Name + ".schema.graphql"; context.Response.ContentType = ContentType.GraphQL; context.Response.Headers.Add( "Content-Disposition", new[] { $"attachment; filename=\"{fileName}\"" }); await using var memoryStream = new MemoryStream(); await using var streamWriter = new StreamWriter(memoryStream); SchemaSerializer.Serialize(requestExecutor.Schema, streamWriter); await streamWriter.FlushAsync().ConfigureAwait(false); memoryStream.Seek(0, SeekOrigin.Begin); await memoryStream.CopyToAsync(context.Response.Body).ConfigureAwait(false); }
public void FromDiskTest() { var provider = new SchemaSerializer().ReadFromDisk(@"c:\testdata.txt"); Assert.NotNull(provider); }
private static T DeserializeObject <T>(string json) where T : IValues => SchemaSerializer.DeserializeObject <TestModel <T> >(json).Property;
private static string SerializeObject <T>(T value) where T : IValues => SchemaSerializer.SerializeObject(new TestModel <T> { Property = value });
public DocumentNode ToDocument(bool includeSpecScalars = false) => SchemaSerializer.SerializeSchema(this, includeSpecScalars);
public string Print() => SchemaSerializer.Serialize(this);