Json.NET可以将流序列化/反序列化到流/从流反序列化吗？

uqdfh47h  于 2023-08-08  发布在  .NET
关注(0)|答案(7)|浏览(172)

我听说Json.NET比DataContractJsonSerializer快，想给予看...
但是我在JsonConvert上找不到任何接受流而不是字符串的方法。
例如，为了在WinPhone上反序列化包含JSON的文件，我使用以下代码将文件内容读入字符串，然后反序列化为JSON。在我的（非常特别的）测试中，它似乎比使用DataContractJsonSerializer直接从流反序列化慢4倍……

  1. // DCJS
  2. DataContractJsonSerializer dc = new DataContractJsonSerializer(typeof(Constants));
  3. Constants constants = (Constants)dc.ReadObject(stream);
  5. // JSON.NET
  6. string json = new StreamReader(stream).ReadToEnd();
  7. Constants constants = JsonConvert.DeserializeObject<Constants>(json);

字符串
我做错了吗？

.net

7条答案

按热度按时间
332nm8kg

332nm8kg1#

当前版本的Json.net不允许您使用接受的答案代码。当前的替代方案是：

  1. public static object DeserializeFromStream(Stream stream)
  2. {
  3.     var serializer = new JsonSerializer();
  5.     using (var sr = new StreamReader(stream))
  6.     using (var jsonTextReader = new JsonTextReader(sr))
  7.     {
  8.         return serializer.Deserialize(jsonTextReader);
  9.     }
  10. }

字符串
文件：Deserialize JSON from a file stream

赞(0）分享  回复(0）举报  2023-08-08
zz2j4svz

zz2j4svz2#

  1. public static void Serialize(object value, Stream s)
  2. {
  3.     using (StreamWriter writer = new StreamWriter(s))
  4.     using (JsonTextWriter jsonWriter = new JsonTextWriter(writer))
  5.     {
  6.         JsonSerializer ser = new JsonSerializer();
  7.         ser.Serialize(jsonWriter, value);
  8.         jsonWriter.Flush();
  9.     }
  10. }
  12. public static T Deserialize<T>(Stream s)
  13. {
  14.     using (StreamReader reader = new StreamReader(s))
  15.     using (JsonTextReader jsonReader = new JsonTextReader(reader))
  16.     {
  17.         JsonSerializer ser = new JsonSerializer();
  18.         return ser.Deserialize<T>(jsonReader);
  19.     }
  20. }

字符串

展开查看全部
赞(0）分享  回复(0）举报  2023-08-08
f4t66c6m

f4t66c6m3#

**更新：**在当前版本中不再有效，正确答案见below（无需投票否决，在旧版本中正确）。

将JsonTextReader类与StreamReader一起使用，或者使用直接接受StreamReader的JsonSerializer重载：

  1. var serializer = new JsonSerializer();
  2. serializer.Deserialize(streamReader);

字符串

赞(0）分享  回复(0）举报  2023-08-08
blmhpbnm

blmhpbnm4#

我写了一个扩展类来帮助我从JSON源（字符串、流、文件）反序列化。

  1. public static class JsonHelpers
  2. {
  3.     public static T CreateFromJsonStream<T>(this Stream stream)
  4.     {
  5.         JsonSerializer serializer = new JsonSerializer();
  6.         T data;
  7.         using (StreamReader streamReader = new StreamReader(stream))
  8.         {
  9.             data = (T)serializer.Deserialize(streamReader, typeof(T));
  10.         }
  11.         return data;
  12.     }
  14.     public static T CreateFromJsonString<T>(this String json)
  15.     {
  16.         T data;
  17.         using (MemoryStream stream = new MemoryStream(System.Text.Encoding.Default.GetBytes(json)))
  18.         {
  19.             data = CreateFromJsonStream<T>(stream);
  20.         }
  21.         return data;
  22.     }
  24.     public static T CreateFromJsonFile<T>(this String fileName)
  25.     {
  26.         T data;
  27.         using (FileStream fileStream = new FileStream(fileName, FileMode.Open))
  28.         {
  29.             data = CreateFromJsonStream<T>(fileStream);
  30.         }
  31.         return data;
  32.     }
  33. }

字符串
现在反序列化就像写代码一样简单：

  1. MyType obj1 = aStream.CreateFromJsonStream<MyType>();
  2. MyType obj2 = "{\"key\":\"value\"}".CreateFromJsonString<MyType>();
  3. MyType obj3 = "data.json".CreateFromJsonFile<MyType>();

型
希望它能帮助别人。

展开查看全部
赞(0）分享  回复(0）举报  2023-08-08
cczfrluj

cczfrluj5#

我在寻找一种方法来将一个开放的对象列表流到System.IO.Stream上，并从另一端读取它们，而无需在发送之前缓冲整个列表。（具体来说，我正在通过Web API从MongoDB流式传输持久化对象。
@Paul Tyng和@Rivers非常出色地回答了最初的问题，我用他们的答案为我的问题建立了一个概念证明。我决定在这里发布我的测试控制台应用程序，以防其他人也面临同样的问题。

  1. using System;
  2. using System.Diagnostics;
  3. using System.IO;
  4. using System.IO.Pipes;
  5. using System.Threading;
  6. using System.Threading.Tasks;
  7. using Newtonsoft.Json;
  9. namespace TestJsonStream {
  10.     class Program {
  11.         static void Main(string[] args) {
  12.             using(var writeStream = new AnonymousPipeServerStream(PipeDirection.Out, HandleInheritability.None)) {
  13.                 string pipeHandle = writeStream.GetClientHandleAsString();
  14.                 var writeTask = Task.Run(() => {
  15.                     using(var sw = new StreamWriter(writeStream))
  16.                     using(var writer = new JsonTextWriter(sw)) {
  17.                         var ser = new JsonSerializer();
  18.                         writer.WriteStartArray();
  19.                         for(int i = 0; i < 25; i++) {
  20.                             ser.Serialize(writer, new DataItem { Item = i });
  21.                             writer.Flush();
  22.                             Thread.Sleep(500);
  23.                         }
  24.                         writer.WriteEnd();
  25.                         writer.Flush();
  26.                     }
  27.                 });
  28.                 var readTask = Task.Run(() => {
  29.                     var sw = new Stopwatch();
  30.                     sw.Start();
  31.                     using(var readStream = new AnonymousPipeClientStream(pipeHandle))
  32.                     using(var sr = new StreamReader(readStream))
  33.                     using(var reader = new JsonTextReader(sr)) {
  34.                         var ser = new JsonSerializer();
  35.                         if(!reader.Read() || reader.TokenType != JsonToken.StartArray) {
  36.                             throw new Exception("Expected start of array");
  37.                         }
  38.                         while(reader.Read()) {
  39.                             if(reader.TokenType == JsonToken.EndArray) break;
  40.                             var item = ser.Deserialize<DataItem>(reader);
  41.                             Console.WriteLine("[{0}] Received item: {1}", sw.Elapsed, item);
  42.                         }
  43.                     }
  44.                 });
  45.                 Task.WaitAll(writeTask, readTask);
  46.                 writeStream.DisposeLocalCopyOfClientHandle();
  47.             }
  48.         }
  50.         class DataItem {
  51.             public int Item { get; set; }
  52.             public override string ToString() {
  53.                 return string.Format("{{ Item = {0} }}", Item);
  54.             }
  55.         }
  56.     }
  57. }

字符串
请注意，当AnonymousPipeServerStream被释放时，您可能会收到一个异常，我忽略了它，因为它与手头的问题无关。

展开查看全部
赞(0）分享  回复(0）举报  2023-08-08
2guxujil

2guxujil6#

另一个选择是在Json中阅读，在JsonConvert类上使用DeserializeObject：

  1. using (StreamReader streamReader = new StreamReader("example.json"))
  2.             {
  3.                 string json = streamReader.ReadToEnd();
  4.                 ObjectType object = JsonConvert.DeserializeObject<ObjectType>(json);
  5.             }

字符串

赞(0）分享  回复(0）举报  2023-08-08
p4tfgftt

p4tfgftt7#

当内存不足时，另一个方便的选择是定期刷新

  1. /// <summary>serialize the value in the stream.</summary>
  2. /// <typeparam name="T">the type to serialize</typeparam>
  3. /// <param name="stream">The stream.</param>
  4. /// <param name="value">The value.</param>
  5. /// <param name="settings">The json settings to use.</param>
  6. /// <param name="bufferSize"></param>
  7. /// <param name="leaveOpen"></param>
  8. public static void JsonSerialize<T>(this Stream stream,[DisallowNull] T value, [DisallowNull] JsonSerializerSettings settings, int bufferSize=1024, bool leaveOpen=false)
  9. {
  10.     using (var writer = new StreamWriter(stream,encoding: System.Text.Encoding.UTF32,bufferSize,leaveOpen))
  11.     using (var jsonWriter = new JsonTextWriter(writer))
  12.     {
  13.         var ser = JsonSerializer.Create( settings );
  14.         ser.Serialize(jsonWriter, value);
  15.         jsonWriter.Flush();
  16.     }
  17. }
  19. /// <summary>serialize the value in the stream asynchronously.</summary>
  20. /// <typeparam name="T"></typeparam>
  21. /// <param name="stream">The stream.</param>
  22. /// <param name="value">The value.</param>
  23. /// <param name="settings">The settings.</param>
  24. /// <param name="bufferSize">The buffer size, in bytes, set -1 to not flush till done</param>
  25. /// <param name="leaveOpen"> true to leave the stream open </param>
  26. /// <param name="cancellationToken">Propagates notification that operations should be canceled.</param>
  27. public static Task JsonSerializeAsync<T>(this Stream stream,[DisallowNull] T value, [DisallowNull] JsonSerializerSettings settings, int bufferSize=1024, bool leaveOpen=false, CancellationToken cancellationToken=default)
  28. {
  29.     using (var writer = new StreamWriter(stream,encoding: System.Text.Encoding.UTF32,bufferSize: bufferSize,leaveOpen: leaveOpen))
  30.     using (var jsonWriter = new JsonTextWriter(writer))
  31.     {
  32.         var ser = JsonSerializer.Create( settings );
  33.         ser.Serialize(jsonWriter, value);
  34.         return  jsonWriter.Flush();
  35.     }
  36.     //jsonWriter.FlushAsnc with my version gives an error on the stream
  37.     return Task.CompletedTask;
  38. }

字符串
你可以这样测试/使用它：

  1. [TestMethod()]
  2. public void WriteFileIntoJsonTest()
  3. {
  4.     var file = new FileInfo(Path.GetTempFileName());
  5.     try
  6.     {
  7.         var list = new HashSet<Guid>();
  8.         for (int i = 0; i < 100; i++)
  9.         {
  10.             list.Add(Guid.NewGuid());
  11.         }
  12.         file.JsonSerialize(list);
  14.         var sr = file.IsValidJson<List<Guid>>(out var result);
  15.         Assert.IsTrue(sr);
  16.         Assert.AreEqual<int>(list.Count, result.Count);
  17.         foreach (var item in result)
  18.         {
  19.             Assert.IsFalse(list.Add(item), $"The GUID {item} should already exist in the hash set");
  20.         }
  21.     }
  22.     finally
  23.     {
  24.         file.Refresh();
  25.         file.Delete();
  26.     }
  27. }

型
你需要创建扩展方法，这里是整个集合：

  1. public static class JsonStreamReaderExt
  2.     {
  3.        static JsonSerializerSettings _settings ;
  4.         static JsonStreamReaderExt()
  5.         {
  6.             _settings = JsonConvert.DefaultSettings?.Invoke() ?? new JsonSerializerSettings();
  7.             _settings.ConstructorHandling = ConstructorHandling.AllowNonPublicDefaultConstructor;
  8.             _settings.DateTimeZoneHandling = DateTimeZoneHandling.Utc;
  9.             _settings.DateFormatHandling = DateFormatHandling.IsoDateFormat ;
  10.         }
  12.     /// <summary>
  13.     /// serialize the value in the stream.
  14.     /// </summary>
  15.     /// <typeparam name="T"></typeparam>
  16.     /// <param name="stream">The stream.</param>
  17.     /// <param name="value">The value.</param>
  18.     public static void JsonSerialize<T>(this Stream stream,[DisallowNull] T value)
  19.     {
  20.         stream.JsonSerialize(value,_settings);
  21.     }
  23.     /// <summary>
  24.     /// serialize the value in the file .
  25.     /// </summary>
  26.     /// <typeparam name="T"></typeparam>
  27.     /// <param name="file">The file.</param>
  28.     /// <param name="value">The value.</param>
  29.     public static void JsonSerialize<T>(this FileInfo file,[DisallowNull] T value)
  30.     {
  31.         if (string.IsNullOrEmpty(file.DirectoryName)==true && Directory.Exists(file.DirectoryName) == false)
  32.         { 
  33.             Directory.CreateDirectory(file.FullName);
  34.         }
  35.         
  36.         using var s = file.OpenWrite();
  37.         s.JsonSerialize(value, _settings);
  39.         file.Refresh();
  40.     }
  42.     /// <summary>
  43.     /// serialize the value in the file .
  44.     /// </summary>
  45.     /// <typeparam name="T"></typeparam>
  46.     /// <param name="file">The file.</param>
  47.     /// <param name="value">The value.</param>
  48.     /// <param name="settings">the json settings to use</param>
  49.     public static void JsonSerialize<T>(this FileInfo file, [DisallowNull] T value, [DisallowNull] JsonSerializerSettings settings)
  50.     {
  51.         if (string.IsNullOrEmpty(file.DirectoryName) == true && Directory.Exists(file.DirectoryName) == false)
  52.         {
  53.             Directory.CreateDirectory(file.FullName);
  54.         }
  56.         using var s = file.OpenWrite();
  57.         s.JsonSerialize(value, settings);
  59.         file.Refresh();
  60.     }
  62.     /// <summary>
  63.     /// serialize the value in the file .
  64.     /// </summary>
  65.     /// <remarks>File will be refreshed to contain the new meta data</remarks>
  66.     /// <typeparam name="T">the type to serialize</typeparam>
  67.     /// <param name="file">The file.</param>
  68.     /// <param name="value">The value.</param>        
  69.     /// <param name="cancellationToken">Propagates notification that operations should be canceled.</param>
  70.     public static async Task JsonSerializeAsync<T>(this FileInfo file, [DisallowNull] T value, CancellationToken cancellationToken = default)
  71.     {
  72.         if (string.IsNullOrEmpty(file.DirectoryName) == true && Directory.Exists(file.DirectoryName) == false)
  73.         {
  74.             Directory.CreateDirectory(file.FullName);
  75.         }
  77.         using (var stream = file.OpenWrite())
  78.         {
  79.             await stream.JsonSerializeAsync(value, _settings,bufferSize:1024,leaveOpen:false, cancellationToken).ConfigureAwait(false);
  80.         }
  81.         file.Refresh();
  82.     }
  83.     /// <summary>
  84.     /// serialize the value in the file .
  85.     /// </summary>
  86.     /// <remarks>File will be refreshed to contain the new meta data</remarks>
  87.     /// <typeparam name="T">the type to serialize</typeparam>
  88.     /// <param name="file">The file to create or overwrite.</param>
  89.     /// <param name="value">The value.</param>
  90.     /// <param name="settings">the json settings to use</param>
  91.     /// <param name="cancellationToken">Propagates notification that operations should be canceled.</param>
  92.     public static async Task JsonSerializeAsync<T>(this FileInfo file, [DisallowNull] T value, [DisallowNull] JsonSerializerSettings settings, CancellationToken cancellationToken=default)
  93.     {
  94.         if (string.IsNullOrEmpty(file.DirectoryName) == true && Directory.Exists(file.DirectoryName) == false)
  95.         {
  96.             Directory.CreateDirectory(file.FullName);
  97.         }
  99.         using (var stream = file.OpenWrite())
  100.         {
  101.             await stream.JsonSerializeAsync(value, settings,bufferSize:1024,leaveOpen:false, cancellationToken).ConfigureAwait(false);
  102.         }
  103.         file.Refresh();
  104.     }
  106.     /// <summary>serialize the value in the stream.</summary>
  107.     /// <typeparam name="T">the type to serialize</typeparam>
  108.     /// <param name="stream">The stream.</param>
  109.     /// <param name="value">The value.</param>
  110.     /// <param name="settings">The json settings to use.</param>
  111.     /// <param name="bufferSize">The buffer size, in bytes, set -1 to not flush till done</param>
  112.     /// <param name="leaveOpen"> true to leave the stream open </param>
  113.     public static void JsonSerialize<T>(this Stream stream,[DisallowNull] T value, [DisallowNull] JsonSerializerSettings settings, int bufferSize=1024, bool leaveOpen=false)
  114.     {
  115.         using (var writer = new StreamWriter(stream,encoding: System.Text.Encoding.UTF32,bufferSize,leaveOpen))
  116.         using (var jsonWriter = new JsonTextWriter(writer))
  117.         {
  118.             var ser = JsonSerializer.Create( settings );
  119.             ser.Serialize(jsonWriter, value);
  120.             jsonWriter.Flush();
  121.         }
  122.     }
  124.     /// <summary>serialize the value in the stream asynchronously.</summary>
  125.     /// <typeparam name="T"></typeparam>
  126.     /// <param name="stream">The stream.</param>
  127.     /// <param name="value">The value.</param>
  128.     /// <param name="settings">The settings.</param>
  129.     /// <param name="bufferSize">The buffer size, in bytes, set -1 to not flush till done</param>
  130.     /// <param name="leaveOpen"> true to leave the stream open </param>
  131.     /// <param name="cancellationToken">Propagates notification that operations should be canceled.</param>
  132.     public static Task JsonSerializeAsync<T>(this Stream stream,[DisallowNull] T value, [DisallowNull] JsonSerializerSettings settings, int bufferSize=1024, bool leaveOpen=false, CancellationToken cancellationToken=default)
  133.     {
  134.         using (var writer = new StreamWriter(stream,encoding: System.Text.Encoding.UTF32,bufferSize: bufferSize,leaveOpen: leaveOpen))
  135.         using (var jsonWriter = new JsonTextWriter(writer))
  136.         {
  137.             var ser = JsonSerializer.Create( settings );
  138.             ser.Serialize(jsonWriter, value);
  139.             jsonWriter.Flush();
  140.         }
  141.         return Task.CompletedTask;
  142.        
  143.     }
  146.     /// <summary>
  147.     /// Determines whether [is valid json] [the specified result].
  148.     /// </summary>
  149.     /// <typeparam name="T"></typeparam>
  150.     /// <param name="stream">The stream.</param>
  151.     /// <param name="result">The result.</param>
  152.     /// <returns><c>true</c> if [is valid json] [the specified result]; otherwise, <c>false</c>.</returns>
  153.     public static bool IsValidJson<T>(this Stream stream, [NotNullWhen(true)] out T? result)
  154.     {
  155.         if (stream is null)
  156.         {
  157.             throw new ArgumentNullException(nameof(stream));
  158.         }
  160.         if (stream.Position != 0)
  161.         {
  162.             stream.Seek(0, SeekOrigin.Begin);
  163.         }
  164.         JsonSerializerSettings settings = (JsonConvert.DefaultSettings?.Invoke()) ?? new JsonSerializerSettings() { DateTimeZoneHandling = DateTimeZoneHandling.Utc, DateFormatHandling = DateFormatHandling.IsoDateFormat };
  165.         settings.ConstructorHandling = ConstructorHandling.AllowNonPublicDefaultConstructor;
  166.         using (var reader = new StreamReader(stream))
  167.         using (var jsonReader = new JsonTextReader(reader))
  168.         {
  169.             var ser = JsonSerializer.Create(settings);
  170.             try
  171.             {
  172.                 result = ser.Deserialize<T>(jsonReader);
  173.             }
  174.             catch { result = default; }
  175.         }
  176.         return result is not null;
  177.     }
  178.     /// <summary>
  179.     /// Determines whether [is valid json] [the specified settings].
  180.     /// </summary>
  181.     /// <typeparam name="T"></typeparam>
  182.     /// <param name="stream">The stream.</param>
  183.     /// <param name="settings">The settings.</param>
  184.     /// <param name="result">The result.</param>
  185.     /// <returns><c>true</c> if [is valid json] [the specified settings]; otherwise, <c>false</c>.</returns>
  186.     public static bool IsValidJson<T>(this Stream stream, JsonSerializerSettings settings, [NotNullWhen(true)] out T? result)
  187.     {
  188.         if (stream is null)
  189.         {
  190.             throw new ArgumentNullException(nameof(stream));
  191.         }
  193.         if (settings is null)
  194.         {
  195.             throw new ArgumentNullException(nameof(settings));
  196.         }
  198.         if (stream.Position != 0)
  199.         {
  200.             stream.Seek(0, SeekOrigin.Begin);
  201.         }
  202.         using (var reader = new StreamReader(stream))
  203.         using (var jsonReader = new JsonTextReader(reader))
  204.         {
  205.             var ser = JsonSerializer.Create(settings);
  206.             try
  207.             {
  208.                 result = ser.Deserialize<T>(jsonReader);
  209.             }
  210.             catch { result = default; }
  211.         }
  212.         return result is not null;
  213.     }
  214.     /// <summary>
  215.     /// Determines whether file contains valid json using the specified settings and reads it into the output.
  216.     /// </summary>
  217.     /// <typeparam name="T">Type to convert into</typeparam>
  218.     /// <param name="file">The file.</param>
  219.     /// <param name="settings">The settings.</param>
  220.     /// <param name="result">The result.</param>
  221.     /// <returns><c>true</c> if [is valid json] [the specified settings]; otherwise, <c>false</c>.</returns>
  222.     /// <exception cref="System.ArgumentNullException">file</exception>
  223.     /// <exception cref="System.ArgumentNullException"></exception>
  224.     /// <exception cref="System.ArgumentNullException">settings</exception>
  225.     /// <exception cref="System.IO.FileNotFoundException">File could not be accessed</exception>
  226.     public static bool IsValidJson<T>(this FileInfo file, JsonSerializerSettings settings, [NotNullWhen(true)] out T? result)
  227.     {
  228.         if (file is null)
  229.         {
  230.             throw new ArgumentNullException(nameof(file));
  231.         }
  232.         if (File.Exists(file.FullName) == false)
  233.         { 
  234.             throw new FileNotFoundException("File could not be accessed",fileName: file.FullName);
  235.         }
  237.         using var stream = file.OpenRead();
  239.         if (stream is null)
  240.         {
  241.             throw new ArgumentNullException(message:"Could not open the file and access the underlying file stream",paramName: nameof(file));
  242.         }
  245.         if (settings is null)
  246.         {
  247.             throw new ArgumentNullException(nameof(settings));
  248.         }
  250.         using (var reader = new StreamReader(stream))
  251.         using (var jsonReader = new JsonTextReader(reader))
  252.         {
  253.             var ser = JsonSerializer.Create(settings);
  254.             try
  255.             {
  256.                 result = ser.Deserialize<T>(jsonReader);
  257.             }
  258.             catch { result = default; }
  259.         }
  260.         return result is not null;
  261.     }
  262.     /// <summary>
  263.     /// Determines whether file contains valid json using the specified settings and reads it into the output.
  264.     /// </summary>
  265.     /// <typeparam name="T">Type to convert into</typeparam>
  266.     /// <param name="file">The file.</param>
  267.     /// <param name="result">The result.</param>
  268.     /// <returns><c>true</c> if [is valid json] [the specified result]; otherwise, <c>false</c>.</returns>
  269.     /// <exception cref="System.ArgumentNullException">file</exception>
  270.     /// <exception cref="System.IO.FileNotFoundException">File could not be accessed</exception>
  271.     public static bool IsValidJson<T>(this FileInfo file, [NotNullWhen(true)] out T? result)
  272.     {
  273.         if (file is null)
  274.         {
  275.             throw new ArgumentNullException(nameof(file));
  276.         }
  277.         if (File.Exists(file.FullName) == false)
  278.         { 
  279.             throw new FileNotFoundException("File could not be accessed",fileName: file.FullName);
  280.         }
  282.         JsonSerializerSettings settings =( JsonConvert.DefaultSettings?.Invoke()) ?? new JsonSerializerSettings() { DateTimeZoneHandling= DateTimeZoneHandling.Utc, DateFormatHandling= DateFormatHandling.IsoDateFormat };
  283.         settings.ConstructorHandling = ConstructorHandling.AllowNonPublicDefaultConstructor;
  284.         return file.IsValidJson<T>(settings,out result);
  286.     }
  288. }

型

展开查看全部
赞(0）分享  回复(0）举报  2023-08-08
我来回答

相关问题

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新问答

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com