public void Load(ZipArchive iArchive)
{
JObject pJOtImages = null;
ZipArchiveEntry pZAEImages = iArchive.GetEntry("images.json");
if (pZAEImages != null)
{
using (Stream pStmImages = pZAEImages.Open())
{
using (StreamReader pSRrReader = new StreamReader(pStmImages, Encoding.UTF8, false, 1024, true))
{
using (JsonTextReader pJTRReader = new JsonTextReader(pSRrReader))
{
pJOtImages = JObject.Load(pJTRReader);
}
}
}
}
JArray pJAyImages = pJOtImages["images"].Value<JArray>(); ;
foreach(JObject curImage in pJAyImages)
{
ProjectImage pPIeImage = ProjectImage.FromJSON(curImage);
ZipArchiveEntry pZAEImage = iArchive.GetEntry(pPIeImage.ID);
if (pZAEImage != null)
{
using (Stream pStmImage = pZAEImage.Open())
{
pPIeImage.Image = Image.FromStream(pStmImage);
cDicImages.Add(pPIeImage.ID, pPIeImage);
}
}
}
}
public void ReadJsonWithInnerObjectTest()
{
const string json = "{\"properties\":{\"test1\":\"value1\",\"test2\": { \"innertest1\":\"innervalue1\" }}}";
AttributesTableConverter target = new AttributesTableConverter();
using (JsonTextReader reader = new JsonTextReader(new StringReader(json)))
{
JsonSerializer serializer = new JsonSerializer();
// read start object token and prepare the next token
reader.Read();
reader.Read();
AttributesTable result =
(AttributesTable)
target.ReadJson(reader, typeof(AttributesTable), new AttributesTable(), serializer);
Assert.IsFalse(reader.Read()); // read the end of object and ensure there are no more tokens available
Assert.IsNotNull(result);
Assert.AreEqual(2, result.Count);
Assert.AreEqual("value1", result["test1"]);
Assert.IsNotNull(result["test2"]);
Assert.IsInstanceOf<IAttributesTable>(result["test2"]);
IAttributesTable inner = (IAttributesTable)result["test2"];
Assert.AreEqual(1, inner.Count);
Assert.AreEqual("innervalue1", inner["innertest1"]);
}
}
/// <summary>
/// Нажатие по кнопке "Открыть файл"
/// </summary>
private void OpenFileToolStripMenuItem_Click(object sender, EventArgs e)
{
var serializer = new Newtonsoft.Json.JsonSerializer();
serializer.NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore;
serializer.TypeNameHandling = Newtonsoft.Json.TypeNameHandling.Auto;
serializer.Formatting = Newtonsoft.Json.Formatting.Indented;
var OpenFileDialog = new OpenFileDialog();
if (OpenFileDialog.ShowDialog() == DialogResult.Cancel)
{
return;
}
var fileName = OpenFileDialog.FileName;
using (StreamReader streamreader = new StreamReader(fileName))
{
using (Newtonsoft.Json.JsonReader jReader = new Newtonsoft.Json.JsonTextReader(streamreader))
{
ListFigures.list = serializer.Deserialize <List <IFigure> >(jReader);
for (int i = 0; i < ListFigures.list.Count; i++)
{
var figure = ListFigures.list[i];
var row = _table.NewRow();
row[0] = figure.Name;
row[1] = figure.X;
row[2] = figure.Y;
row[3] = figure.CalculationArea();
_table.Rows.Add(row);
}
}
}
}
protected override object DeserializeObject(ArraySegment <byte> value)
{
using (var ms = new MemoryStream(value.Array, value.Offset, value.Count, writable: false))
using (var tr = new StreamReader(ms))
using (var jr = new Newtonsoft.Json.JsonTextReader(tr))
{
jr.Read();
if (jr.TokenType == JsonToken.StartArray)
{
// read type
var typeName = jr.ReadAsString();
var type = readCache.GetOrAdd(typeName, x => Type.GetType(x, throwOnError: true)); // Get type or Register type
// read object
jr.Read();
var deserializedValue = jsonSerializer.Deserialize(jr, type);
return(deserializedValue);
}
else
{
throw new InvalidDataException("JsonTranscoder only supports [\"TypeName\", object]");
}
}
}
public void FloatParseHandling()
{
string json = "[1.0,1,9.9,1E-06]";
JsonTextReader reader = new JsonTextReader(new StringReader(json));
reader.FloatParseHandling = Json.FloatParseHandling.Decimal;
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.StartArray, reader.TokenType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(1.0m, reader.Value);
Assert.AreEqual(typeof(decimal), reader.ValueType);
Assert.AreEqual(JsonToken.Float, reader.TokenType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(1L, reader.Value);
Assert.AreEqual(typeof(long), reader.ValueType);
Assert.AreEqual(JsonToken.Integer, reader.TokenType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(9.9m, reader.Value);
Assert.AreEqual(typeof(decimal), reader.ValueType);
Assert.AreEqual(JsonToken.Float, reader.TokenType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(Convert.ToDecimal(1E-06), reader.Value);
Assert.AreEqual(typeof(decimal), reader.ValueType);
Assert.AreEqual(JsonToken.Float, reader.TokenType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.EndArray, reader.TokenType);
}
public void RunBenchmark(PocoSerializationFormat serializationFormat)
{
Newtonsoft.Json.JsonReader reader;
switch (serializationFormat)
{
case PocoSerializationFormat.Text:
reader = new CosmosDBToNewtonsoftReader(
Cosmos.Json.JsonReader.Create(
this.peoplePayload.Text));
break;
case PocoSerializationFormat.NewtonsoftText:
if (!MemoryMarshal.TryGetArray(this.peoplePayload.Text, out ArraySegment <byte> segment))
{
throw new InvalidOperationException("Failed to get segment");
}
reader = new Newtonsoft.Json.JsonTextReader(
new StreamReader(
new MemoryStream(segment.Array, index: segment.Offset, count: segment.Count)));
break;
case PocoSerializationFormat.Binary:
reader = new CosmosDBToNewtonsoftReader(
Cosmos.Json.JsonReader.Create(
this.peoplePayload.Binary));
break;
default:
throw new ArgumentOutOfRangeException(serializationFormat.ToString());
}
Newtonsoft.Json.JsonSerializer serializer = new Newtonsoft.Json.JsonSerializer();
_ = serializer.Deserialize <List <Person> >(reader);
}
public void ConstructorTest()
{
string repositoryName = "Mvc3Application";
string appName = "ConstructorTest";
using (var repo = Git.CreateLocalRepository(repositoryName))
{
ApplicationManager.Run(appName, appManager =>
{
using (HttpClient client = HttpClientHelper.CreateClient(appManager.ServiceUrl, appManager.DeploymentManager.Credentials))
{
HttpResponseMessage response = client.GetAsync("diagnostics/settings").Result.EnsureSuccessful();
using (var reader = new JsonTextReader(new StreamReader(response.Content.ReadAsStreamAsync().Result)))
{
JObject json = (JObject)JToken.ReadFrom(reader);
Assert.Equal(0, json.Count);
}
}
using (HttpClient client = HttpClientHelper.CreateClient(appManager.ServiceUrl, appManager.DeploymentManager.Credentials))
{
var ex = Assert.Throws<HttpRequestException>(() => client.GetAsync("diagnostics/settings/trace_level").Result.EnsureSuccessful());
Assert.Contains("404", ex.Message);
}
});
}
}
public static List<Redirect> ReadRedirects(HttpContext context)
{
if (RedirectHandler.Redirects == null)
{
string path = WebConfigurationManager.AppSettings["redirects"] ?? "~/App_Data/redirects.json";
path = context.Server.MapPath(path);
List<Redirect> newRedirects = new List<Redirect>();
using (TextReader file = File.OpenText(path))
using (JsonTextReader reader = new JsonTextReader(file))
{
string from = null;
while (reader.Read())
{
if (reader.TokenType == JsonToken.PropertyName)
{
from = ((string)reader.Value).ToLowerInvariant();
}
else if (reader.TokenType == JsonToken.String)
{
newRedirects.Add(new Redirect() { From = from, To = ((string)reader.Value).ToLowerInvariant() });
}
}
}
RedirectHandler.Redirects = newRedirects;
}
return RedirectHandler.Redirects;
}
protected override void HandleLoadedProperty (JsonTextReader reader, string propertyName, object readValue) {
base.HandleLoadedProperty (reader, propertyName, readValue);
switch(propertyName) {
case "AimRotation": aimRotation = LoadManager.LoadQuaternion(reader); break;
default: break;
}
}
public void YahooFinance()
{
string input = @"{
""matches"" : [
{""t"":""C"", ""n"":""Citigroup Inc."", ""e"":""NYSE"", ""id"":""662713""}
,{""t"":""CHL"", ""n"":""China Mobile Ltd. (ADR)"", ""e"":""NYSE"", ""id"":""660998""}
,{""t"":""PTR"", ""n"":""PetroChina Company Limited (ADR)"", ""e"":""NYSE"", ""id"":""664536""}
,{""t"":""RIO"", ""n"":""Companhia Vale do Rio Doce (ADR)"", ""e"":""NYSE"", ""id"":""671472""}
,{""t"":""RIOPR"", ""n"":""Companhia Vale do Rio Doce (ADR)"", ""e"":""NYSE"", ""id"":""3512643""}
,{""t"":""CSCO"", ""n"":""Cisco Systems, Inc."", ""e"":""NASDAQ"", ""id"":""99624""}
,{""t"":""CVX"", ""n"":""Chevron Corporation"", ""e"":""NYSE"", ""id"":""667226""}
,{""t"":""TM"", ""n"":""Toyota Motor Corporation (ADR)"", ""e"":""NYSE"", ""id"":""655880""}
,{""t"":""JPM"", ""n"":""JPMorgan Chase \\x26 Co."", ""e"":""NYSE"", ""id"":""665639""}
,{""t"":""COP"", ""n"":""ConocoPhillips"", ""e"":""NYSE"", ""id"":""1691168""}
,{""t"":""LFC"", ""n"":""China Life Insurance Company Ltd. (ADR)"", ""e"":""NYSE"", ""id"":""688679""}
,{""t"":""NOK"", ""n"":""Nokia Corporation (ADR)"", ""e"":""NYSE"", ""id"":""657729""}
,{""t"":""KO"", ""n"":""The Coca-Cola Company"", ""e"":""NYSE"", ""id"":""6550""}
,{""t"":""VZ"", ""n"":""Verizon Communications Inc."", ""e"":""NYSE"", ""id"":""664887""}
,{""t"":""AMX"", ""n"":""America Movil S.A.B de C.V. (ADR)"", ""e"":""NYSE"", ""id"":""665834""}],
""all"" : false
}
";
using (JsonReader jsonReader = new JsonTextReader(new StringReader(input)))
{
while (jsonReader.Read())
{
Console.WriteLine(jsonReader.Value);
}
}
}
public T Deserialize <T>(TextReader reader)
{
using (var jsonReader = new NewtonsoftJson.JsonTextReader(reader))
{
return(internalSerializer.Deserialize <T>(jsonReader));
}
}
public object Deserialize(TextReader reader, Type objectType)
{
using (var jsonReader = new NewtonsoftJson.JsonTextReader(reader))
{
return(internalSerializer.Deserialize(jsonReader, objectType));
}
}
protected virtual async System.Threading.Tasks.Task <ObjectResponseResult <T> > ReadObjectResponseAsync <T>(System.Net.Http.HttpResponseMessage response, System.Collections.Generic.IReadOnlyDictionary <string, System.Collections.Generic.IEnumerable <string> > headers)
{
if (response == null || response.Content == null)
{
return(new ObjectResponseResult <T>(default(T), string.Empty));
}
try
{
using (var responseStream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false))
using (var streamReader = new System.IO.StreamReader(responseStream))
using (var jsonTextReader = new Newtonsoft.Json.JsonTextReader(streamReader))
{
var serializer = Newtonsoft.Json.JsonSerializer.Create(_settings.Value);
var typedBody = serializer.Deserialize <T>(jsonTextReader);
return(new ObjectResponseResult <T>(typedBody, string.Empty));
}
}
catch (JsonException exception)
{
var message = "Could not deserialize the response body stream as " + typeof(T).FullName + ".";
throw new ApiException(message, (int)response.StatusCode, string.Empty, headers, exception);
}
}
public static Quaternion LoadQuaternion(JsonTextReader reader)
{
Quaternion rotation = new Quaternion(0, 0, 0, 0);
if (reader == null) return rotation;
string currVal = "";
while (reader.Read())
{
if (reader.Value != null)
{
if (reader.TokenType == JsonToken.PropertyName) currVal = (string)reader.Value;
else
{
switch (currVal)
{
case "x": rotation.x = (float)(double)reader.Value; break;
case "y": rotation.y = (float)(double)reader.Value; break;
case "z": rotation.z = (float)(double)reader.Value; break;
case "w": rotation.w = (float)(double)reader.Value; break;
default: break;
}
}
}
else if (reader.TokenType == JsonToken.EndObject) return rotation;
}
return rotation;
}
public RequestForm makeRequestForm(JObject json)
{
string currManagerName = (string)json["current"]["bazookaInfo"]["managerId"];
string futureManagerName = (string)json["future"]["bazookaInfo"]["managerId"];
int managerID = GetIDFromName(currManagerName);
int f_managerID = GetIDFromName(futureManagerName);
json["current"]["bazookaInfo"]["managerId"] = managerID;
json["current"]["ultiproInfo"]["supervisor"] = managerID;
json["future"]["bazookaInfo"]["managerId"] = f_managerID;
json["future"]["ultiproInfo"]["supervisor"] = f_managerID;
UserController uc = new UserController();
string[] name = uc.GetUserName().Split('.');
string creatorName = name[0] + " " + name[1];
int creatorID = GetIDFromName(creatorName);
RequestForm obj = null;
using (var sr = new StringReader(json.ToString()))
using (var jr = new JsonTextReader(sr))
{
var js = new JsonSerializer();
obj = (RequestForm)js.Deserialize<RequestForm>(jr);
}
obj.EmployeeId = GetIDFromName((string)json["name"]);
obj.CreatedByID = creatorID;
obj.Current.BazookaInfo.SecurityItemRights = "";
obj.ReviewInfo.FilesToBeRemovedFrom = "(" + obj.Current.BazookaInfo.Group + ")" + currManagerName.Replace(" ", ".")+" "+obj.ReviewInfo.FilesToBeRemovedFrom;
obj.ReviewInfo.FilesToBeAddedTo = "(" + obj.Future.BazookaInfo.Group + ")" + futureManagerName.Replace(" ", ".")+" "+obj.ReviewInfo.FilesToBeAddedTo;
return obj;
}
private void LoadJsonFilesIfNeeded()
{
if (_environmentDeployInfosByName != null)
{
return;
}
_environmentDeployInfosByName = new Dictionary<string, EnvironmentDeployInfo>();
var jsonSerializer = new JsonSerializer();
foreach (string jsonFilePath in Directory.GetFiles(_configurationFilesDirPath, "*.json", SearchOption.TopDirectoryOnly))
{
EnvironmentDeployInfoJson environmentDeployInfoJson = null;
using (FileStream fileStream = File.OpenRead(jsonFilePath))
using(var streamReader = new StreamReader(fileStream))
using (var jsonReader = new JsonTextReader(streamReader))
{
environmentDeployInfoJson = jsonSerializer.Deserialize<EnvironmentDeployInfoJson>(jsonReader);
}
if (environmentDeployInfoJson != null)
{
EnvironmentDeployInfo environmentDeployInfo = ConvertToDomain(environmentDeployInfoJson);
_environmentDeployInfosByName.Add(environmentDeployInfo.TargetEnvironment, environmentDeployInfo);
}
}
}
public static RuntimeGraph ReadRuntimeGraph(TextReader textReader)
{
using (var jsonReader = new JsonTextReader(textReader))
{
return ReadRuntimeGraph(JToken.Load(jsonReader));
}
}
public IStorageProviderConfig GetConfig(string name) {
if (String.IsNullOrWhiteSpace(name)) throw new ArgumentNullException(nameof(name));
using (var configStream = fs.File.OpenRead(this.configFilePath)) {
using (var streamReader = new StreamReader(configStream)) {
using (var jsonReader = new JsonTextReader(streamReader)) {
var config = JToken.Load(jsonReader, new JsonLoadSettings {
CommentHandling = CommentHandling.Ignore,
LineInfoHandling = LineInfoHandling.Ignore
});
var namedConfig = config[name];
if (namedConfig == null) {
return null;
}
string type = namedConfig.Value<string>(TypeKey);
if (String.IsNullOrWhiteSpace(type)) {
return null;
}
var converter = converterFactory.GetConverter(type);
var providerConfig = converter.ToConfig(namedConfig[ConfigKey]);
return providerConfig;
}
}
}
}
/// <summary>
/// Parses the json string and returns a Dictionary of verification pairs
/// </summary>
/// <param name="verificationFormatJSON"></param>
/// <returns></returns>
public static Dictionary<string, object> BuildVerifyDictionary(string verificationFormatJSON)
{
bool isStringValid = ValidateJsonString(verificationFormatJSON);
// Immediately fail if the string format is not valid
Validity.Assert(isStringValid);
Dictionary<string, object> verification = new Dictionary<string, object>();
JsonTextReader reader = new JsonTextReader(new StringReader(verificationFormatJSON));
while (reader.Read())
{
// Start of new item
if (reader.TokenType == JsonToken.StartObject)
{
// Start of new entry
// Ignore and move to the entry pair
}
else if (reader.TokenType == JsonToken.PropertyName)
{
KeyValuePair<string, object> pair = GetVerifyPair(reader);
if (verification.ContainsKey(pair.Key))
{
verification[pair.Key] = pair.Value;
}
else
{
verification.Add(pair.Key, pair.Value);
}
}
}
return verification;
}
public object Deserialize(Stream body, Type messageType)
{
var streamReader = new StreamReader(body);
var reader = new JsonTextReader(streamReader);
var serializer = new JsonSerializer();
return serializer.Deserialize(reader, messageType);
}
private void ParseCoordinate(JsonTextReader reader)
{
if (!reader.Read() || reader.TokenType != JsonToken.StartObject)
throw new InvalidOperationException();
var allCoord = new List<Tuple<int, System.Drawing.PointF[]>>();
while (reader.Read() && reader.TokenType != JsonToken.EndObject) {
if (reader.TokenType != JsonToken.PropertyName) throw new InvalidOperationException();
var key = Convert.ToInt32(reader.Value);
if (!reader.Read() || reader.TokenType != JsonToken.StartArray) throw new InvalidOperationException();
var coordinates = new List<System.Drawing.PointF>();
while (reader.Read() && reader.TokenType != JsonToken.EndArray) {
if (reader.TokenType != JsonToken.StartArray) throw new InvalidOperationException();
if (!reader.Read() || reader.TokenType != JsonToken.String) throw new InvalidOperationException();
var x = float.Parse((string)reader.Value);
if (!reader.Read() || reader.TokenType != JsonToken.String) throw new InvalidOperationException();
var y = float.Parse((string)reader.Value);
if (!reader.Read() || reader.TokenType != JsonToken.EndArray) throw new InvalidOperationException();
coordinates.Add(new System.Drawing.PointF(x, y));
}
allCoord.Add(Tuple.Create(key, coordinates.ToArray()));
}
_Coordinates = allCoord.ToArray();
}
public static DateTimeOffset? ParseDateTimeOffset(JToken value)
{
var jValue = value as JValue;
if (jValue != null)
{
if (jValue.Value == null)
return null;
if (jValue.Value is DateTimeOffset)
return jValue.Value<DateTimeOffset>();
}
var rawValue = value.AsString();
if (string.IsNullOrWhiteSpace(rawValue))
return null;
rawValue = rawValue.Replace("NeoDate", "Date");
if (!DateRegex.IsMatch(rawValue))
{
DateTimeOffset parsed;
if (!DateTimeOffset.TryParse(rawValue, out parsed))
return null;
}
var text = string.Format("{{\"a\":\"{0}\"}}", rawValue);
var reader = new JsonTextReader(new StringReader(text)) {DateParseHandling = DateParseHandling.DateTimeOffset};
reader.Read(); // JsonToken.StartObject
reader.Read(); // JsonToken.PropertyName
return reader.ReadAsDateTimeOffset();
}
public void Deserialize(Stream stream)
{
Debug.Assert(_serializer != null);
Debug.Assert(stream != null);
JsonReader reader = new JsonTextReader(new StreamReader(stream));
_serializer.Deserialize(reader);
}
public override Task<object> ReadFromStreamAsync(Type type, Stream readStream, System.Net.Http.HttpContent content, IFormatterLogger formatterLogger)
{
var task = Task<object>.Factory.StartNew(() =>
{
var ser = JsonNetExtensions.GetJsonSerializer();
using (var sr = new StreamReader(readStream))
{
using (var jreader = new JsonTextReader(sr))
{
ser.Converters.Add(new IsoDateTimeConverter());
return ser.Deserialize(jreader, type);
}
}
/*
var sr = new StreamReader(stream);
var jreader = new JsonTextReader(sr);
var ser = new JsonSerializer();
ser.Converters.Add(new IsoDateTimeConverter());
object val = ser.Deserialize(jreader, type);
return val;*/
});
return task;
}
public virtual T ReadJSONResponse <T>(HttpWebResponse resp)
{
using (var rs = Duplicati.Library.Utility.AsyncHttpRequest.TrySetTimeout(resp.GetResponseStream()))
using (var tr = new System.IO.StreamReader(rs))
using (var jr = new Newtonsoft.Json.JsonTextReader(tr))
return(new Newtonsoft.Json.JsonSerializer().Deserialize <T>(jr));
}
private void openFileToolStripMenuItem_Click(object sender, EventArgs e)
{
var serializer = new Newtonsoft.Json.JsonSerializer();
serializer.NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore;
serializer.TypeNameHandling = Newtonsoft.Json.TypeNameHandling.Auto;
serializer.Formatting = Newtonsoft.Json.Formatting.Indented;
var OpenFileDialog = new OpenFileDialog();
if (OpenFileDialog.ShowDialog() == DialogResult.Cancel)
{
return;
}
var fileName = OpenFileDialog.FileName;
using (StreamReader streamreader = new StreamReader(fileName))
{
using (Newtonsoft.Json.JsonReader jReader = new Newtonsoft.Json.JsonTextReader(streamreader))
{
ListCatalog.list = serializer.Deserialize <List <ICatalogue> >(jReader);
for (int i = 0; i < ListCatalog.list.Count; i++)
{
var catalog = ListCatalog.list[i];
var row = _datatable.NewRow();
row[0] = catalog.Name;
row[1] = catalog.YearPublishing;
row[2] = catalog.GetDescription();
_datatable.Rows.Add(row);
}
}
}
}
/// <summary>
/// Parses the text representing a JSON object
/// into an instance of the type specified.
/// </summary>
public static object FromJson(this Stream stream, Type entityType, JsonNet.JsonSerializerSettings settings)
{
_ = stream ?? throw new ArgumentNullException(nameof(stream));
if (!stream.CanRead)
{
throw new NotSupportedException($"{nameof(stream)} is not readable.");
}
if (stream.CanSeek)
{
stream.Position = 0;
}
try
{
var serializer = JsonNet.JsonSerializer.Create(settings);
using var streamReader = new StreamReader(stream, leaveOpen: true);
using var jsonReader = new JsonNet.JsonTextReader(streamReader);
return(serializer.Deserialize(jsonReader, entityType));
}
catch
{
return(null);
}
finally
{
if (stream.CanSeek)
{
stream.Position = 0;
}
}
}
public static void Load()
{
players.Clear();
string filename = "SavedGames" + Path.DirectorySeparatorChar + "Players.json";
if (File.Exists(filename))
{
//read contents of file
string input;
using (StreamReader sr = new StreamReader(filename))
{
input = sr.ReadToEnd();
}
if (input != null)
{
//parse contents of file
using (JsonTextReader reader = new JsonTextReader(new StringReader(input)))
{
while (reader.Read())
{
if (reader.Value != null)
{
if (reader.TokenType == JsonToken.PropertyName)
{
if ((string)reader.Value == "Players") LoadPlayers(reader);
}
}
}
}
}
}
}
/// <summary>
/// 指定の物を追加する
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private async Task <PersonView> Post(PersonView person)
{
//最新IDにする
person.id = maxId();
var js = new Newtonsoft.Json.JsonSerializer();
var sw = new System.IO.StringWriter();
js.Serialize(sw, person);
var hc = new HttpClient();
hc.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
var json = sw.ToString();
var cont = new StringContent(json, Encoding.UTF8, "application/json");
var res = await hc.PostAsync(common.GetURL() + "people", cont);
var str = await res.Content.ReadAsStringAsync();
testMess.Text = str;
var jr = new Newtonsoft.Json.JsonTextReader(new System.IO.StringReader(str));
var item = js.Deserialize <PersonView>(jr);
return(item);
}
static void Main(string[] args)
{
var reader = new StreamReader("testfile.json");
reader.ReadLine();
JsonTextReader rd = new Newtonsoft.Json.JsonTextReader(reader);
var stream = new StringWriter();
JsonTextWriter writer = new JsonTextWriter(stream);
while (rd.Read())
{
Console.WriteLine(rd.TokenType + "\t" + rd.Value);
if (rd.TokenType == JsonToken.PropertyName)
{
var value = rd.Value.ToString();
if (value == "Chunks" || value == "SoundIntervals")
{
rd.Skip();
continue;
}
}
writer.WriteToken(rd, false);
}
writer.Close();
Console.WriteLine(stream.GetStringBuilder().ToString());
}
public void Parse()
{
if (_IsParsed) return;
var json = Encoding.UTF8.GetString(this.data);
using (var strReader = new System.IO.StringReader(json)) {
using (var r = new JsonTextReader(strReader)) {
while (r.Read()) {
if (r.TokenType == JsonToken.PropertyName) {
switch (r.Value.ToString()) {
case "region":
ParseRegions(r);
break;
case "nonpop":
_NonPops = r.ReadInt32Array();
break;
case "item":
_Items = r.ReadInt32Array();
break;
case "instance_contents":
_InstanceContents = r.ReadInt32Array();
break;
default:
Console.Error.WriteLine("Unknown 'BNpcName' data key: {0}", r.Value);
throw new NotSupportedException();
}
}
}
}
}
_IsParsed = true;
}
public void Parse()
{
if (_IsParsed)
return;
var json = Encoding.UTF8.GetString(this.data);
using (var strReader = new System.IO.StringReader(json)) {
using (var r = new JsonTextReader(strReader)) {
while (r.Read()) {
if (r.TokenType == JsonToken.PropertyName) {
switch (r.Value.ToString()) {
case "client_quest":
_AsQuestClient = r.ReadInt32Array();
break;
case "coordinate":
ParseCoordinate(r);
break;
case "quest":
_Quests = r.ReadInt32Array();
break;
case "shop":
ParseShops(r);
break;
default:
Console.Error.WriteLine("Unknown 'ENpcResident' data key: {0}", r.Value);
throw new NotSupportedException();
}
}
}
}
}
_IsParsed = true;
}
//public JsonFormatter()
//{
// SupportedMediaTypes.Add(new MediaTypeHeaderValue("text/json"));
// SupportedMediaTypes.Add(new MediaTypeHeaderValue("application/json"));
//}
public override Task<object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger)
{
var task = new TaskCompletionSource<object>();
using (var ms = new MemoryStream())
{
readStream.CopyTo(ms);
//ms.Seek(0, SeekOrigin.Begin);
//var result = JsonSchemaValidator.Instance().Validate(ms, type);
//if (!string.IsNullOrWhiteSpace(result))
// task.SetResult(result);
//else
{
ms.Seek(0, SeekOrigin.Begin);
using (var reader = new JsonTextReader(new StreamReader(ms)))
{
var serializer = new JsonSerializer();
task.SetResult(serializer.Deserialize(reader, type));
}
}
}
return task.Task;
}
public T ReadJSONResponse <T>(HttpWebResponse resp)
{
using (var rs = resp.GetResponseStream())
using (var tr = new System.IO.StreamReader(rs))
using (var jr = new Newtonsoft.Json.JsonTextReader(tr))
return(new Newtonsoft.Json.JsonSerializer().Deserialize <T>(jr));
}
public void ReadBigInteger()
{
string json = @"{
ParentId: 1,
ChildId: 333333333333333333333333333333333333333,
}";
JsonTextReader jsonTextReader = new JsonTextReader(new StringReader(json));
Assert.IsTrue(jsonTextReader.Read());
Assert.AreEqual(JsonToken.StartObject, jsonTextReader.TokenType);
Assert.IsTrue(jsonTextReader.Read());
Assert.AreEqual(JsonToken.PropertyName, jsonTextReader.TokenType);
Assert.IsTrue(jsonTextReader.Read());
Assert.AreEqual(JsonToken.Integer, jsonTextReader.TokenType);
Assert.IsTrue(jsonTextReader.Read());
Assert.AreEqual(JsonToken.PropertyName, jsonTextReader.TokenType);
Assert.IsTrue(jsonTextReader.Read());
Assert.AreEqual(JsonToken.Integer, jsonTextReader.TokenType);
Assert.AreEqual(typeof(BigInteger), jsonTextReader.ValueType);
Assert.AreEqual(BigInteger.Parse("333333333333333333333333333333333333333"), jsonTextReader.Value);
Assert.IsTrue(jsonTextReader.Read());
Assert.AreEqual(JsonToken.EndObject, jsonTextReader.TokenType);
Assert.IsFalse(jsonTextReader.Read());
JObject o = JObject.Parse(json);
var i = (BigInteger)((JValue)o["ChildId"]).Value;
Assert.AreEqual(BigInteger.Parse("333333333333333333333333333333333333333"), i);
}
ConsumeContext IMessageDeserializer.Deserialize(ReceiveContext receiveContext)
{
try
{
var messageEncoding = GetMessageEncoding(receiveContext);
MessageEnvelope envelope;
using (var body = receiveContext.GetBody())
using (var reader = new StreamReader(body, messageEncoding, false, 1024, true))
using (var jsonReader = new JsonTextReader(reader))
{
envelope = _deserializer.Deserialize<MessageEnvelope>(jsonReader);
}
return new JsonConsumeContext(_deserializer, _objectTypeDeserializer, _sendEndpointProvider, _publishEndpointProvider, receiveContext, envelope);
}
catch (JsonSerializationException ex)
{
throw new SerializationException("A JSON serialization exception occurred while deserializing the message envelope", ex);
}
catch (SerializationException)
{
throw;
}
catch (Exception ex)
{
throw new SerializationException("An exception occurred while deserializing the message envelope", ex);
}
}
public IEnumerable <Document> GetResponseDocuments()
{
if (Enabled == false)
{
return(Array.Empty <Document>());
}
var files = Directory.GetFiles(BaseCachePath, "*.meta");
List <Document> documents = new List <Document>(files.Length * 2);
foreach (var path in files)
{
bool encrypted = path.EndsWith(".e.meta");
//deserialize the document meta data
using (var fs = File.OpenRead(path))
using (StreamReader reader = encrypted ? new StreamReader(CreateDecryptionStream(fs)) : new StreamReader(fs))
using (var json = new Newtonsoft.Json.JsonTextReader(reader))
{
var serializer = new Newtonsoft.Json.JsonSerializer();
serializer.Converters.Add(new DocumentCreationConverter());
var doc = serializer.Deserialize <Document>(json);
documents.Add(doc);
}
}
return(documents);
}
public static StreamMetadata FromJsonBytes(byte[] json)
{
using (var reader = new JsonTextReader(new StreamReader(new MemoryStream(json))))
{
return FromJsonReader(reader);
}
}
public static void LoadGame(string filename)
{
char separator = Path.DirectorySeparatorChar;
string path = "SavedGames" + separator + PlayerManager.GetPlayerName() + separator + filename + ".json";
if(!File.Exists(path)) {
Debug.Log("Unable to find " + path + ". Loading will crash, so aborting.");
return;
}
string input;
using(StreamReader sr = new StreamReader(path)) {
input = sr.ReadToEnd();
}
if(input != null) {
//parse contents of file
using(JsonTextReader reader = new JsonTextReader(new StringReader(input))) {
while(reader.Read()) {
if(reader.Value!=null) {
if(reader.TokenType == JsonToken.PropertyName) {
string property = (string)reader.Value;
switch(property) {
case "Sun": LoadLighting(reader); break;
case "Ground": LoadTerrain(reader); break;
case "Camera": LoadCamera(reader); break;
case "Resources": LoadResources(reader); break;
case "Players": LoadPlayers(reader); break;
default: break;
}
}
}
}
}
}
}
private async Task ParseStepsAsync(
Stream stream,
RecipeDescriptor descriptor,
Func<RecipeDescriptor, RecipeStepDescriptor, Task> stepActionAsync)
{
var serializer = new JsonSerializer();
StreamReader streamReader = new StreamReader(stream);
JsonTextReader reader = new JsonTextReader(streamReader);
// Go to Steps, then iterate.
while (reader.Read())
{
if (reader.Path == "steps" && reader.TokenType == JsonToken.StartArray)
{
int stepId = 0;
while (reader.Read() && reader.Depth > 1)
{
if (reader.Depth == 2)
{
var child = JToken.Load(reader);
await stepActionAsync(descriptor, new RecipeStepDescriptor
{
Id = (stepId++).ToString(CultureInfo.InvariantCulture),
RecipeName = descriptor.Name,
Name = child.Value<string>("name"),
Step = child
});
}
}
}
}
}
public static ObservableCollection<MediaFile> GetMedia()
{
if (File.Exists(libraryCachePath))
{
using (var file = File.OpenRead(libraryCachePath))
using (var sr = new StreamReader(file))
using (var jtr = new JsonTextReader(sr))
{
return new ObservableCollection<MediaFile>(serializer.Deserialize<List<MediaFile>>(jtr));
}
}
else
{
var library = RefreshLibrary();
if (!Directory.Exists(Path.GetDirectoryName(libraryCachePath)))
{
Directory.CreateDirectory(Path.GetDirectoryName(libraryCachePath));
}
using (var file = File.Open(libraryCachePath, FileMode.Create))
using (var sw = new StreamWriter(file))
using (var jtr = new JsonTextWriter(sw))
{
serializer.Serialize(jtr, library);
}
return new ObservableCollection<MediaFile>(library);
}
}
private XmlNode DeserializeXmlNode(string json, string deserializeRootElementName)
{
JsonTextReader reader;
reader = new JsonTextReader(new StringReader(json));
reader.Read();
XmlNodeConverter converter = new XmlNodeConverter();
if (deserializeRootElementName != null)
converter.DeserializeRootElementName = deserializeRootElementName;
XmlNode node = (XmlNode)converter.ReadJson(reader, typeof (XmlDocument), null, new JsonSerializer());
#if !NET20
string xmlText = node.OuterXml;
reader = new JsonTextReader(new StringReader(json));
reader.Read();
XDocument d = (XDocument) converter.ReadJson(reader, typeof (XDocument), null, new JsonSerializer());
string linqXmlText = d.ToString(SaveOptions.DisableFormatting);
if (d.Declaration != null)
linqXmlText = d.Declaration + linqXmlText;
Assert.AreEqual(xmlText, linqXmlText);
#endif
return node;
}
public static Color LoadColor(JsonTextReader reader)
{
if (reader == null) return new Color(0, 0, 0, 0);
Color color = new Color(0, 0, 0, 0);
string currVal = "";
while (reader.Read())
{
if (reader.Value != null)
{
if (reader.TokenType == JsonToken.PropertyName) currVal = (string)reader.Value;
else
{
switch (currVal)
{
case "r": color.r = (float)(double)reader.Value; break;
case "g": color.g = (float)(double)reader.Value; break;
case "b": color.b = (float)(double)reader.Value; break;
case "a": color.a = (float)(double)reader.Value; break;
default: break;
}
}
}
else if (reader.TokenType == JsonToken.EndObject) return color;
}
return color;
}
public object Deserialize(string json)
{
using (var reader = new System.IO.StringReader(json))
using (var jsonReader = new NewtonsoftJson.JsonTextReader(reader))
{
return(internalSerializer.Deserialize(jsonReader));
}
}
public override void WriteRawJsonToken(
JsonTokenType jsonTokenType,
ReadOnlySpan <byte> rawJsonToken)
{
string rawJson = Encoding.UTF8.GetString(rawJsonToken);
Newtonsoft.Json.JsonTextReader jsonTextReader = new Newtonsoft.Json.JsonTextReader(new StringReader(rawJson))
{
DateParseHandling = DateParseHandling.None,
};
while (jsonTextReader.Read())
{
if (jsonTokenType == JsonTokenType.FieldName)
{
this.writer.WritePropertyName(jsonTextReader.Value as string);
}
else
{
switch (jsonTextReader.TokenType)
{
case Newtonsoft.Json.JsonToken.StartObject:
this.writer.WriteStartObject();
break;
case Newtonsoft.Json.JsonToken.StartArray:
this.writer.WriteStartArray();
break;
case Newtonsoft.Json.JsonToken.PropertyName:
this.writer.WritePropertyName(jsonTextReader.Value as string);
break;
case Newtonsoft.Json.JsonToken.Integer:
case Newtonsoft.Json.JsonToken.Float:
case Newtonsoft.Json.JsonToken.String:
case Newtonsoft.Json.JsonToken.Boolean:
this.writer.WriteValue(jsonTextReader.Value);
break;
case Newtonsoft.Json.JsonToken.Null:
this.writer.WriteNull();
break;
case Newtonsoft.Json.JsonToken.EndObject:
this.writer.WriteEndObject();
break;
case Newtonsoft.Json.JsonToken.EndArray:
this.writer.WriteEndArray();
break;
default:
throw new ArgumentOutOfRangeException($"Unknown {nameof(JsonToken)}: {jsonTextReader.TokenType}.");
}
}
}
}
public void DeserializeRequest(Message message, object[] parameters)
{
object bodyFormatProperty;
if (!message.Properties.TryGetValue(WebBodyFormatMessageProperty.Name, out bodyFormatProperty) ||
(bodyFormatProperty as WebBodyFormatMessageProperty).Format != WebContentFormat.Raw)
{
throw new InvalidOperationException("Incoming messages must have a body format of Raw. Is a ContentTypeMapper set on the WebHttpBinding?");
}
var bodyReader = message.GetReaderAtBodyContents();
bodyReader.ReadStartElement("Binary");
var rawBody = bodyReader.ReadContentAsBase64();
var ms = new MemoryStream(rawBody);
var sr = new StreamReader(ms);
var serializer = CreateJsonSerializer(); // new JsonSerializer();
if (parameters.Length == 1)
{
// single parameter, assuming bare
parameters[0] = serializer.Deserialize(sr, _operation.Messages[0].Body.Parts[0].Type);
}
else
{
// multiple parameter, needs to be wrapped
JsonReader reader = new Newtonsoft.Json.JsonTextReader(sr);
reader.Read();
if (reader.TokenType != Newtonsoft.Json.JsonToken.StartObject)
{
throw new InvalidOperationException("Input needs to be wrapped in an object");
}
reader.Read();
while (reader.TokenType == Newtonsoft.Json.JsonToken.PropertyName)
{
var parameterName = reader.Value as string;
reader.Read();
if (_parameterNames.ContainsKey(parameterName))
{
var parameterIndex = _parameterNames[parameterName];
parameters[parameterIndex] = serializer.Deserialize(reader, _operation.Messages[0].Body.Parts[parameterIndex].Type);
}
else
{
reader.Skip();
}
reader.Read();
}
reader.Close();
}
sr.Close();
ms.Close();
}
internal T Load(string identifier, Type objtype)
{
var path = Path.Combine(this.Location, identifier);
using (var jw = new Newtonsoft.Json.JsonTextReader(new System.IO.StreamReader(path)))
{
var serializer = Newtonsoft.Json.JsonSerializer.Create();
return((T)serializer.Deserialize(jw, objtype));
}
}
public T Deserialize <T>(Stream stream) where T : class
{
using (var sr = new StreamReader(stream))
{
using (var jsonTextReader = new Newtonsoft.Json.JsonTextReader(sr))
{
var serializer = new Newtonsoft.Json.JsonSerializer();
return(serializer.Deserialize <T>(jsonTextReader));
}
}
}
private List <SelectListItem> LoadCountries()
{
var fileInfo = _environment.ContentRootFileProvider.GetFileInfo("countries.json");
using (var stream = fileInfo.CreateReadStream())
using (var streamReader = new StreamReader(stream))
using (var jsonTextReader = new Newtonsoft.Json.JsonTextReader(streamReader))
{
var serializer = new JsonSerializer();
return(serializer.Deserialize <List <SelectListItem> >(jsonTextReader));
}
}
private static SalahTimeEntity ReadJsonFile()
{
SalahTimeEntity salahTimeEntity = new SalahTimeEntity("First", "Active");
try
{
string currentFile = new Uri(Assembly.GetExecutingAssembly().CodeBase).LocalPath;
Console.WriteLine(currentFile);
string dir = new FileInfo(currentFile).Directory.Parent.FullName;
string pathToJson = Path.Combine(dir, "SalahTime.json");
Console.WriteLine(pathToJson);
using (StreamReader file = File.OpenText(@pathToJson))
using (Newtonsoft.Json.JsonTextReader reader = new Newtonsoft.Json.JsonTextReader(file))
{
JArray jsonResponse = null;
try
{
jsonResponse = (JArray)JToken.ReadFrom(reader);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Console.WriteLine(ex.StackTrace);
// jsonResponse = (JArray)JToken.Parse(ResourceReader.GetEmbeddedResourceString(Assembly.GetExecutingAssembly(), "TestData.json"));
}
//List<SalahTimeEntity> testDataList = new List<SalahTimeEntity>();
//foreach (var item in jsonResponse)
//{
// JObject jData = (JObject)item;
// //SalahTimeEntity rowsResult = JsonConvert.DeserializeObject<SalahTimeEntity>(jData.ToString());
// //testDataList.Add(rowsResult);
// salahTimeEntity.JsonForm = jData.ToString();
//}
salahTimeEntity.JsonForm = jsonResponse.ToString();
}
return(salahTimeEntity);
}
catch (Exception ex)
{
//Console.WriteLine(ex.Message);
//Console.WriteLine(ex.StackTrace);
return(null);
}
}
private void ParseResponse(int service, string file, Stream stream)
{
object result;
try
{
using (stream)
{
StreamReader networkReader = new StreamReader(stream);
string responseTxt = networkReader.ReadToEnd();
Type type = GetJsonType(service);
if (responseTxt.StartsWith("{ \"error\""))
{
type = typeof(ErrorEventArgs);
}
if (type == null)
{
result = responseTxt;
}
else
{
Newtonsoft.Json.JsonSerializer serializer = new Newtonsoft.Json.JsonSerializer();
serializer.Converters.Add(new MySquare.FourSquare.NotificationConverter());
serializer.Converters.Add(new MySquare.Service.DateTimeConverter());
//Newtonsoft.Json.JsonReader reader = new Newtonsoft.Json.JsonTextReader(new StreamReader(stream));
Newtonsoft.Json.JsonReader reader = new Newtonsoft.Json.JsonTextReader(new StringReader(responseTxt));
result = serializer.Deserialize(reader, type);
}
if (responseTxt.StartsWith("{ \"error\""))
{
((ErrorEventArgs)result).Exception = ((ErrorEventArgs)result).Exception;
}
}
}
catch (Exception ex)
{
OnError(new ErrorEventArgs(new Exception(
string.Format("Request on {0} failed.", file), ex)));
return;
}
if (result != null)
{
OnResult(result, service);
}
else
{
OnError(new ErrorEventArgs(new Exception("Invalid response.")));
}
}
private async Task <T> DeserializeStream <T>(RequestExecutionContext context, Stream stream)
{
await using var memoryStream = new MemoryStream();
await stream.CopyToAsync(memoryStream, context.HttpContext.RequestAborted);
memoryStream.Position = 0;
using var streamReader = new StreamReader(memoryStream);
using var jsonReader = new Json.JsonTextReader(streamReader);
return(JsonSerializer.Deserialize <T>(jsonReader));
}
public static string JsonPrettify(string json)
{
using (var stringReader = new StringReader(json))
using (var stringWriter = new StringWriter())
{
var jsonReader = new Newtonsoft.Json.JsonTextReader(stringReader);
var jsonWriter = new Newtonsoft.Json.JsonTextWriter(stringWriter)
{
Formatting = Newtonsoft.Json.Formatting.Indented
};
jsonWriter.WriteToken(jsonReader);
return(stringWriter.ToString());
}
}
public async Task StartJobAsync()
{
using (var syncStartItem = await Web.PostAsync("Start", NullPostContent).ConfigureAwait(false))
{
syncStartItem.EnsureSuccessStatusCode();
using (var stream = await syncStartItem.Content.ReadAsStreamAsync())
using (var reader = new Newtonsoft.Json.JsonTextReader(new System.IO.StreamReader(stream)))
{
var serializer = new Newtonsoft.Json.JsonSerializer();
var obj = serializer.Deserialize <StartSyncJobResponse>(reader);
SyncID = obj.id;
}
}
}
public static T DeserializeJsonFromStream <T>(Stream stream)
{
if (stream == null || stream.CanRead == false)
{
return(default(T));
}
using (var sr = new StreamReader(stream))
using (var jtr = new Newtonsoft.Json.JsonTextReader(sr))
{
var js = new Newtonsoft.Json.JsonSerializer();
var searchResult = js.Deserialize <T>(jtr);
return(searchResult);
}
}
private void SendMail()
{
MailSecrets mailSecret = null;
using (var stream = _assembly.GetManifestResourceStream("FindIpAddress.mail_secrets.json"))
{
Json.JsonSerializer serializer = new Json.JsonSerializer();
System.IO.StreamReader streamReader = new System.IO.StreamReader(stream);
Json.JsonTextReader reader = new Json.JsonTextReader(streamReader);
mailSecret = serializer.Deserialize <MailSecrets>(reader);
}
var fromAddress = new MailAddress(mailSecret.Email, mailSecret.Name);
var toAddress = new MailAddress(mailSecret.Email, mailSecret.Name);
const string subject = "Adresse";
string body = CheckIpAddress();
using (var smtp = new SmtpClient())
{
smtp.Host = "smtp.gmail.com";
smtp.Port = 587;
smtp.EnableSsl = true;
smtp.DeliveryMethod = SmtpDeliveryMethod.Network;
smtp.UseDefaultCredentials = false;
smtp.Timeout = 10000;
smtp.Credentials = new NetworkCredential(fromAddress.Address, mailSecret.Password);
using (var message = new MailMessage(fromAddress, toAddress))
{
message.Subject = subject;
message.Body = body;
message.IsBodyHtml = true;
try
{
smtp.Send(message);
if (this.currentWindowState == System.Windows.WindowState.Normal)
{
MessageBox.Show("eMail sent", "", MessageBoxButton.OK, MessageBoxImage.Information);
}
}
catch (Exception ep)
{
MessageBox.Show("Exception Occured:" + ep.Message, "Send Mail Error", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
}
}
//private void ViewData()
//{
// HttpWebRequest req = common.connectionGet("people");
// HttpWebResponse res = (HttpWebResponse)req.GetResponse();
// List<PersonView> result;
// using (res)
// {
// using (var resStream = res.GetResponseStream())
// {
// StreamReader sr = new StreamReader(resStream);
// string str = sr.ReadToEnd();
// result = JsonConvert.DeserializeObject<List<PersonView>>(str.ToString());
// }
// }
// ViewGrid.DataContext = common.ConvertToDataTable(result);
//}
//private void PostData(PersonView data)
//{
// HttpWebRequest req = common.connectionPost("people");
// using (var streamWriter = new StreamWriter(req.GetRequestStream()))
// {
// string json = Newtonsoft.Json.JsonConvert.SerializeObject(data);
// streamWriter.Write(json);
// }
// HttpWebResponse res = (HttpWebResponse)req.GetResponse();
// List<PersonView> result = new List<PersonView>();
// using (res)
// {
// using (var resStream = res.GetResponseStream())
// {
// StreamReader sr = new StreamReader(resStream);
// string str = sr.ReadToEnd();
// var r = JsonConvert.DeserializeObject<PersonView>(str.ToString());
// result.Add(r);
// }
// }
// ViewGrid.DataContext = common.ConvertToDataTable(result);
//}
//
//private void PostDataList(List<PersonView> data)
//{
// HttpWebRequest req = common.connectionPost("people");
// using (var streamWriter = new StreamWriter(req.GetRequestStream()))
// {
// string json = Newtonsoft.Json.JsonConvert.SerializeObject(data);
// streamWriter.Write(json);
// }
// HttpWebResponse res = (HttpWebResponse)req.GetResponse();
// List<PersonView> result = new List<PersonView>();
// using (res)
// {
// using (var resStream = res.GetResponseStream())
// {
// StreamReader sr = new StreamReader(resStream);
// string str = sr.ReadToEnd();
// var r = JsonConvert.DeserializeObject<PersonView>(str.ToString());
// result.Add(r);
// }
// }
// ViewGrid.DataContext = common.ConvertToDataTable(result);
//}
//private void Button_Click(object sender, RoutedEventArgs e)
//{
// DataTable table = ViewGrid.DataContext as DataTable;
// DataTable list = table.GetChanges();
// foreach (PersonView item in list.Rows)
// {
// PostData(item);
// }
//}
#endregion
#region API処理
private async void GetUserList()
{
var hc = new HttpClient();
hc.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
var res = await hc.GetAsync(common.GetURL() + "people");
var str = await res.Content.ReadAsStringAsync();
testMess.Text = str;
var js = new Newtonsoft.Json.JsonSerializer();
var jr = new Newtonsoft.Json.JsonTextReader(new System.IO.StringReader(str));
var items = js.Deserialize <List <PersonView> >(jr);
ViewGrid.ItemsSource = items;
}
private IEnumerator TestRequest(string token)
{
var uri = "http://cad.onshape.com/api/documents";
UnityWebRequest www = UnityWebRequest.Get(uri);
www.SetRequestHeader("Authorization", "Bearer " + token);
yield return(www.SendWebRequest());
if (www.isNetworkError || www.isHttpError)
{
Debug.LogError(www.error);
yield return(null);
}
else
{
Debug.Log(www.downloadHandler.text);
}
try
{
TextReader sr = new StringReader(www.downloadHandler.text);
var reader = new Newtonsoft.Json.JsonTextReader(sr);
var ser = Newtonsoft.Json.JsonSerializer.Create();
var docs = ser.Deserialize <IO.Swagger.Model.DocumentsGetDocumentsResponse200>(reader);
var txt = "";
foreach (var doc in docs.Items)
{
txt += doc.Name + "(Modified by : " + doc.ModifiedBy.Name + " - Created by : " + doc.CreatedBy.Name + ")\r\n";
}
Text.text = txt;
Debug.Log(docs);
}
catch (Exception ex)
{
Debug.LogError(ex);
}
}
public static List <IFigures> Deserilization(string filename)
{
var serializer = new Newtonsoft.Json.JsonSerializer
{
TypeNameHandling = Newtonsoft.Json.TypeNameHandling.Auto
};
List <IFigures> _figure = null;
using (StreamReader streamReader = new StreamReader(filename))
{
using (Newtonsoft.Json.JsonReader jreader = new Newtonsoft.Json.JsonTextReader(streamReader))
{
_figure = serializer.Deserialize <List <IFigures> >(jreader);
}
}
return(_figure);
}
protected System.Collections.Generic.IEnumerable <JsonLogEntry> GetEntries()
{
Newtonsoft.Json.JsonSerializer oJsonSerializer = new Newtonsoft.Json.JsonSerializer();
foreach (System.Tuple <string, System.IO.Stream> st in StreamFactory.GetStreams(From, this.Recurse))
{
this.StreamLineNumber = 0;
this.CurrentStreamName = st.Item1;
this.RecordIndex = 0;
using (AdvancedTextReader srdr = new AdvancedTextReader(st.Item2, this.TextReaderOptions))
{
using (var m_JsonReader = new Newtonsoft.Json.JsonTextReader(srdr)
{
SupportMultipleContent = true
})
{
bool bStartRead = string.IsNullOrEmpty(JsonPropertyToRead);
while (m_JsonReader.Read())
{
if (!bStartRead && !(m_JsonReader.TokenType == JsonToken.PropertyName && m_JsonReader.Value == JsonPropertyToRead))
{
continue;
}
else
{
bStartRead = true;
}
if (m_JsonReader.TokenType == JsonToken.StartObject)
{
// Additional fields
this.StreamLineNumber = m_JsonReader.LineNumber;
this.RecordIndex += 1;
// Deserialize entries and yield
JsonLogEntry le = oJsonSerializer.Deserialize <JsonLogEntry>(m_JsonReader);
yield return(le);
}
}
}
}
}
}