public void FromJSON(JsonTextReader reader)
{
Dictionary.Clear();
if (reader.MoveToContent() && reader.TokenClass == JsonTokenClass.Array)
{
reader.ReadToken(JsonTokenClass.Array);
while(reader.TokenClass == JsonTokenClass.Object)
{
reader.ReadToken(JsonTokenClass.Object);
//read the 'key'
reader.ReadMember();
string key = reader.ReadString();
string type = null;
string stringValue = null;
object value = null;
//read the 'type'
reader.ReadMember();
if (reader.TokenClass == JsonTokenClass.Null)
{
reader.ReadNull();
//read the value (should be NULL)
reader.ReadMember();
if (reader.TokenClass == JsonTokenClass.Null)
{
reader.ReadNull();
}
else
{
stringValue = reader.ReadString();
}
}
else
{
//read the type
type = reader.ReadString();
//read the 'value'
reader.ReadMember();
stringValue = reader.ReadString();
}
if (!string.IsNullOrEmpty(type) && !string.IsNullOrEmpty(stringValue))
{
Type t = Type.GetType(type);
TypeConverter typeConverter = TypeDescriptor.GetConverter(t);
value = typeConverter.ConvertFromString(stringValue);
}
Dictionary.Add(key, value);
reader.ReadToken(JsonTokenClass.EndObject);
}
reader.ReadToken(JsonTokenClass.EndArray);
}
}
public void Complex()
{
const string input = @"{'menu': {
'header': 'SVG Viewer',
'items': [
{'id': 'Open'},
{'id': 'OpenNew', 'label': 'Open New'},
null,
{'id': 'ZoomIn', 'label': 'Zoom In'},
{'id': 'ZoomOut', 'label': 'Zoom Out'},
{'id': 'OriginalView', 'label': 'Original View'},
null,
{'id': 'Quality'},
{'id': 'Pause'},
{'id': 'Mute'},
null,
{'id': 'Find', 'label': 'Find...'},
{'id': 'FindAgain', 'label': 'Find Again'},
{'id': 'Copy'},
{'id': 'CopyAgain', 'label': 'Copy Again'},
{'id': 'CopySVG', 'label': 'Copy SVG'},
{'id': 'ViewSVG', 'label': 'View SVG'},
{'id': 'ViewSource', 'label': 'View Source'},
{'id': 'SaveAs', 'label': 'Save As'},
null,
{'id': 'Help'},
{'id': 'About', 'label': 'About Adobe CVG Viewer...'}
]
}}";
JsonTextReader reader = new JsonTextReader(new StringReader(input));
JsonTextWriter writer = new JsonTextWriter();
JsonRecorder.Record(reader).Playback(writer);
Assert.AreEqual("{\"menu\":{\"header\":\"SVG Viewer\",\"items\":[{\"id\":\"Open\"},{\"id\":\"OpenNew\",\"label\":\"Open New\"},null,{\"id\":\"ZoomIn\",\"label\":\"Zoom In\"},{\"id\":\"ZoomOut\",\"label\":\"Zoom Out\"},{\"id\":\"OriginalView\",\"label\":\"Original View\"},null,{\"id\":\"Quality\"},{\"id\":\"Pause\"},{\"id\":\"Mute\"},null,{\"id\":\"Find\",\"label\":\"Find...\"},{\"id\":\"FindAgain\",\"label\":\"Find Again\"},{\"id\":\"Copy\"},{\"id\":\"CopyAgain\",\"label\":\"Copy Again\"},{\"id\":\"CopySVG\",\"label\":\"Copy SVG\"},{\"id\":\"ViewSVG\",\"label\":\"View SVG\"},{\"id\":\"ViewSource\",\"label\":\"View Source\"},{\"id\":\"SaveAs\",\"label\":\"Save As\"},null,{\"id\":\"Help\"},{\"id\":\"About\",\"label\":\"About Adobe CVG Viewer...\"}]}}", writer.ToString());
}
public object Parse(TextReader reader)
{
if (reader == null)
throw new ArgumentNullException("reader");
JsonReader jsonReader = new JsonTextReader(reader);
return Parse(jsonReader);
}
public static Geometry Read(TextReader reader)
{
if (reader == null)
throw new ArgumentNullException("writer", "A valid text reader object is required.");
JsonTextReader jreader = new JsonTextReader(reader);
return Read(jreader);
}
/// <summary>
/// 输入string
/// 输出json
/// </summary>
/// <param name="strJsonText">要输出的json串</param>
public static void writeStringtoJson(String strJsonText)
{
JsonReader reader = new JsonTextReader(new StringReader(strJsonText));
JsonObject jsonObj = new JsonObject();
jsonObj.Import(reader);
HttpContext.Current.Response.Write(jsonObj);
HttpContext.Current.Response.End();
}
public static void JayrockReaderStrings ()
{
for (int i = 0; i < Common.Iterations; i++) {
StringReader sr = new StringReader (Common.JsonStrings);
JsonReader reader = new JsonTextReader (sr);
while (reader.Read ());
}
}
private static void PrettyColorPrint(string path, TextWriter output, JsonPalette palette)
{
Debug.Assert(output != null);
using (TextReader input = path.Equals("-") ? Console.In : new StreamReader(path))
using (JsonTextReader reader = new JsonTextReader(input))
using (JsonTextWriter writer = new JsonTextWriter(output))
{
writer.PrettyPrint = true;
JsonColorWriter colorWriter = new JsonColorWriter(writer, palette);
colorWriter.WriteFromReader(reader);
output.WriteLine();
}
}
public static string PretifyJson(this string text)
{
var input = new StringReader(text);
var output = new StringWriter();
using (var reader = new JsonTextReader(input))
using (var writer = new JsonTextWriter(output))
{
writer.PrettyPrint = true;
writer.WriteFromReader(reader);
}
return output.ToString();
}
/// <summary>
/// ������еĸ�������
/// </summary>
public static void AddGridViewPropoter(GridView gridList, string josinString)
{
if (gridList.Rows.Count > 0)
{
Jayrock.Json.JsonReader reader = new Jayrock.Json.JsonTextReader(new System.IO.StringReader(@josinString));
JsonObject jsonObj = new JsonObject();
jsonObj.Import(reader);
JsonArray rowPro = (JsonArray)jsonObj["RowPro"];
JsonArray colPro = (JsonArray)jsonObj["ColPro"];
JsonObject item = null;
for (int i = 0; i < gridList.Rows.Count; i++)
{
gridList.Rows[i].Attributes.Add("id", "div" + i);
//���������
item = rowPro.GetObject(0);
for (int k = 0; k < item.GetNamesArray().Count; k++)
{
string n = item.GetNamesArray()[k].ToString();
gridList.Rows[i].Attributes.Add(n, string.Format(item[n].ToString(),i));
}
for (int j = 0; j < gridList.Rows[i].Cells.Count; j++)
{
gridList.Rows[i].Cells[j].Attributes.Add("id", "div_" + i + "_" + j);
//��ӵ�Ԫ������
item = null;
item = colPro.GetObject(0);
for (int k = 0; k < item.GetNamesArray().Count; k++)
{
string n = item.GetNamesArray()[k].ToString();
gridList.Rows[i].Cells[j].Attributes.Add(n,string.Format(item[n].ToString(),i,j));
}
}
}
}
}
public static void JayrockReaderLastProperty ()
{
for (int i = 0; i < Common.Iterations; i++) {
bool found = false;
StringReader sr = new StringReader (Common.JsonText);
JsonReader reader = new JsonTextReader (sr);
while (reader.Read ()) {
if (reader.TokenClass == JsonTokenClass.Member &&
reader.Text == "LastProperty") {
found = true;
break;
}
}
if (! found)
Console.WriteLine ("LastProperty not found!");
}
}
public void FromJSON(Jayrock.Json.JsonTextReader jreader)
{
if (jreader == null)
{
throw new ArgumentNullException("jreader", "A valid JSON reader object is required.");
}
if (jreader.MoveToContent() && jreader.TokenClass == JsonTokenClass.Object)
{
jreader.ReadToken(JsonTokenClass.Object);
//Read the 'FeatureCollection' as the type
jreader.ReadMember(); //reads 'type'
jreader.ReadString(); //reads 'FeatureCollection'
//Read the features
jreader.ReadMember();
jreader.ReadToken(JsonTokenClass.Array);
while (jreader.TokenClass == JsonTokenClass.Object)
{
MemFeature feature = CreateFeature();
GeoJSONReader.ReadGISFeature(feature, jreader);
Add(feature);
}
jreader.ReadToken(JsonTokenClass.EndArray);
//Read the layer name
jreader.ReadMember();
_layerName = jreader.ReadString();
//Read the key field
jreader.ReadMember();
_keyFieldName = jreader.ReadString();
jreader.ReadToken(JsonTokenClass.EndObject);
}
}
private static GeometryCollection ReadGeometryCollection(JsonTextReader jreader)
{
if (jreader == null)
throw new ArgumentNullException("reader", "A valid JSON reader object is required.");
GeometryCollection geometries = null;
if (jreader.TokenClass == JsonTokenClass.Array)
{
jreader.ReadToken(JsonTokenClass.Array);
List<Geometry> list = new List<Geometry>();
while (jreader.TokenClass == JsonTokenClass.Object)
{
Geometry geometry = Read(jreader);
list.Add(geometry);
}
jreader.ReadToken(JsonTokenClass.EndArray);
geometries = new GeometryCollection(list.ToArray());
}
return geometries;
}
private static Polygon ReadPolygon(JsonTextReader jreader)
{
if (jreader == null)
throw new ArgumentNullException("reader", "A valid JSON reader object is required.");
Polygon area = null;
if (jreader.TokenClass == JsonTokenClass.Array)
{
jreader.ReadToken(JsonTokenClass.Array);
//Read the outer shell
LinearRing shell = null;
if (jreader.TokenClass == JsonTokenClass.Array)
{
Coordinate[] coordinates = new Coordinate[] { };
Read(ref coordinates, jreader);
shell = new LinearRing(coordinates);
}
//Read all the holes
List<LinearRing> list = new List<LinearRing>();
while (jreader.TokenClass == JsonTokenClass.Array)
{
Coordinate[] coordinates = new Coordinate[] { };
Read(ref coordinates, jreader);
LinearRing hole = new LinearRing(coordinates);
list.Add(hole);
}
jreader.ReadToken(JsonTokenClass.EndArray);
//An outer shell was found so a polygon can be created
if (shell != null)
{
if (list.Count > 0)
area = new Polygon(shell, list.ToArray());
else
area = new Polygon(shell);
}
}
return area;
}
private static Polygon ReadPolygon(TextReader reader)
{
if (reader == null)
throw new ArgumentNullException("reader", "A valid text reader object is required.");
JsonTextReader jreader = new JsonTextReader(reader);
return ReadPolygon(jreader);
}
private static MultiPoint ReadMultiPoint(ref MultiPoint points, TextReader reader)
{
if (reader == null)
throw new ArgumentNullException("reader", "A valid text reader object is required.");
JsonTextReader jreader = new JsonTextReader(reader);
return ReadMultiPoint(jreader);
}
private static Point ReadPoint(JsonTextReader jreader)
{
if (jreader == null)
throw new ArgumentNullException("reader", "A valid JSON reader object is required.");
Point point = null;
if (jreader.TokenClass == JsonTokenClass.Array)
{
jreader.ReadToken(JsonTokenClass.Array);
double x = Convert.ToDouble(jreader.ReadNumber());
double y = Convert.ToDouble(jreader.ReadNumber());
double z = double.NaN;
if (jreader.TokenClass == JsonTokenClass.Number)
z = Convert.ToDouble(jreader.ReadNumber());
jreader.ReadToken(JsonTokenClass.EndArray);
point = new Point(x, y, z);
}
return point;
}
private static MultiLineString ReadMultiLineString(TextReader reader)
{
if (reader == null)
throw new ArgumentNullException("reader", "A valid text reader object is required.");
JsonTextReader jreader = new JsonTextReader(reader);
return ReadMultiLineString(jreader);
}
private static MultiPoint ReadMultiPoint(JsonTextReader jreader)
{
if (jreader == null)
throw new ArgumentNullException("reader", "A valid JSON reader object is required.");
MultiPoint points = null;
if (jreader.TokenClass == JsonTokenClass.Array)
{
jreader.ReadToken(JsonTokenClass.Array);
List<Point> list = new List<Point>();
while (jreader.TokenClass == JsonTokenClass.Array)
{
Coordinate item = new Coordinate();
Read(ref item, jreader);
list.Add(new Point(item));
}
jreader.ReadToken(JsonTokenClass.EndArray);
points = new MultiPoint(list.ToArray());
}
return points;
}
public static IAttributesTable ReadAttributesTable(TextReader reader)
{
if (reader == null)
throw new ArgumentNullException("reader", "A valid text reader object is required.");
JsonTextReader jreader = new JsonTextReader(reader);
return ReadAttributesTable(jreader);
}
private static MultiLineString ReadMultiLineString(JsonTextReader jreader)
{
if (jreader == null)
throw new ArgumentNullException("reader", "A valid JSON reader object is required.");
MultiLineString lines = null;
if (jreader.TokenClass == JsonTokenClass.Array)
{
jreader.ReadToken(JsonTokenClass.Array);
List<LineString> list = new List<LineString>();
while (jreader.TokenClass == JsonTokenClass.Array)
{
list.Add(ReadLineString(jreader));
}
jreader.ReadToken(JsonTokenClass.EndArray);
lines = new MultiLineString(list.ToArray());
}
return lines;
}
public static void ReadGISFeature(IGISFeature feature, TextReader reader)
{
if (feature == null)
throw new ArgumentNullException("feature", "A valid feature reference is required.");
if (reader == null)
throw new ArgumentNullException("reader", "A valid reader object is required.");
JsonTextReader jreader = new JsonTextReader(reader);
ReadGISFeature(feature, jreader);
}
public static void Read(ref Coordinate coordinate, JsonTextReader jreader)
{
if (coordinate == null)
throw new ArgumentNullException("coordinate", "A valid coordinate reference is required.");
if (jreader == null)
throw new ArgumentNullException("jreader", "A valid JSON reader object is required.");
if (jreader.MoveToContent() && jreader.TokenClass == JsonTokenClass.Array)
{
jreader.ReadToken(JsonTokenClass.Array);
coordinate.X = Convert.ToDouble(jreader.ReadNumber());
coordinate.Y = Convert.ToDouble(jreader.ReadNumber());
coordinate.Z = double.NaN;
if (jreader.TokenClass == JsonTokenClass.Number)
coordinate.Z = Convert.ToDouble(jreader.ReadNumber());
jreader.ReadToken(JsonTokenClass.EndArray);
}
}
public static Feature ReadFeature(JsonTextReader jreader)
{
if (jreader == null)
throw new ArgumentNullException("jreader", "A valid JSON reader object is required.");
Feature feature = new Feature();
if (jreader.MoveToContent() && jreader.TokenClass == JsonTokenClass.Object)
{
jreader.ReadToken(JsonTokenClass.Object);
//Read the 'Feature' as the type
jreader.ReadMember(); //reads 'type'
jreader.ReadString(); //reads 'Feature'
//Read the 'geometry'
jreader.ReadMember(); //reads 'geometry'
feature.Geometry = Read(jreader); //reads the geometry value
//Read the 'properties'
jreader.ReadMember(); //reads 'properties'
feature.Attributes = ReadAttributesTable(jreader);
jreader.ReadToken(JsonTokenClass.EndObject);
}
return feature;
}
void socket_OnNotifyMulticastSocketListener(object sender, NotifyMulticastSocketListenerEventArgs e)
{
if (e.Type != MulticastSocketMessageType.MessageReceived)
{
if (e.Type == MulticastSocketMessageType.SendException)
{
logger.Error(String.Format("Error Sending Message: {0}", e.NewObject));
}
else if (e.Type == MulticastSocketMessageType.ReceiveException)
{
logger.Error(String.Format("Error Receiving Message: {0}", e.NewObject));
}
return;
}
bool enteredGate = false;
try
{
String sMessage = GetMessageAsString((byte[])e.NewObject);
JsonReader reader = new JsonTextReader(new StringReader(sMessage));
TransportMessage tMessage = null;
lock (importLock)
{
//Console.WriteLine("Importing message {0}", e.Consecutive);
//This is a method called from different threads -- This way we make only one import at a time.
tMessage = JsonImportContext.Import<TransportMessage>(reader);
}
GateKeeperMethod(e.Consecutive);
enteredGate = true;
try
{
//1- Notifies the PreDelivery listener
if (PreDeliveryListener != null)
PreDeliveryListener.MessageReceived(tMessage, sMessage);
//2- Notifies the actual target
var listeners = TransportListeners.Where(tmp => tmp.MessageType == tMessage.MessageType);
foreach (var listener in listeners)
listener.MessageReceived(tMessage, sMessage);
}
catch (Exception ex)
{
logger.Error(String.Format("Error Processing Received Message: {0}", ex.Message));
}
}
catch (Exception ex)
{
logger.Error(String.Format("Error Processing Received Message: {0}", ex.Message));
}
//It's only called if the thread actually entered the gate. If it didn't, it would wake up another thread that should
// still be waiting
if (enteredGate)
NudgeGate();
}
public static void ReadGISAttributes(IGISAttributes attributes, JsonTextReader jreader)
{
if (attributes == null)
throw new ArgumentNullException("attributes", "A valid attributes reference is required.");
if (jreader == null)
throw new ArgumentNullException("jreader", "A valid JSON reader object is required.");
if (jreader.MoveToContent() && jreader.TokenClass == JsonTokenClass.Object)
{
jreader.ReadToken(JsonTokenClass.Object);
while (jreader.TokenClass == JsonTokenClass.Member)
{
string key = jreader.ReadMember();
string value = jreader.ReadString();
attributes.SetValue(key, value);
}
jreader.ReadToken(JsonTokenClass.EndObject);
}
}
public static IEnumerable<Feature> ReadFeatureCollection(TextReader reader)
{
if (reader == null)
throw new ArgumentNullException("reader", "A valid text reader object is required.");
JsonTextReader jreader = new JsonTextReader(reader);
return ReadFeatureCollection(jreader);
}
public static IEnumerable<Feature> ReadFeatureCollection(JsonTextReader jreader)
{
if (jreader == null)
throw new ArgumentNullException("jreader", "A valid JSON reader object is required.");
List<Feature> features = new List<Feature>();
if (jreader.MoveToContent() && jreader.TokenClass == JsonTokenClass.Object)
{
jreader.ReadToken(JsonTokenClass.Object);
//Read the 'FeatureCollection' as the type
jreader.ReadMember(); //reads 'type'
jreader.ReadString(); //reads 'FeatureCollection'
//Read the 'features' property
jreader.ReadMember(); //reads 'features'
if (jreader.TokenClass == JsonTokenClass.Array)
{
jreader.ReadToken(JsonTokenClass.Array);
while (jreader.TokenClass == JsonTokenClass.Object)
{
features.Add(ReadFeature(jreader));
}
jreader.ReadToken(JsonTokenClass.EndArray);
}
jreader.ReadToken(JsonTokenClass.EndObject);
return features;
}
return null;
}
public static void ReadGISAttributes(IGISAttributes attributes, TextReader reader)
{
if (attributes == null)
throw new ArgumentNullException("attributes", "A valid attributes reference is required.");
if (reader == null)
throw new ArgumentNullException("reader", "A valid reader object is required.");
JsonTextReader jreader = new JsonTextReader(reader);
ReadGISAttributes(attributes, jreader);
}
private static LineString ReadLineString(JsonTextReader jreader)
{
if (jreader == null)
throw new ArgumentNullException("reader", "A valid JSON reader object is required.");
LineString line = null;
if (jreader.TokenClass == JsonTokenClass.Array)
{
jreader.ReadToken(JsonTokenClass.Array);
List<Coordinate> list = new List<Coordinate>();
while (jreader.TokenClass == JsonTokenClass.Array)
{
Coordinate item = new Coordinate();
Read(ref item, jreader);
list.Add(item);
}
jreader.ReadToken(JsonTokenClass.EndArray);
line = new LineString(list.ToArray());
}
return line;
}
protected virtual object ParseRequest(TextReader input)
{
if (input == null)
throw new ArgumentNullException("input");
JsonReader reader = (JsonReader) _serviceProvider.GetService(typeof(JsonReader));
if (reader == null)
reader = new JsonTextReader(input);
ImportContext importContext = new ImportContext();
JsonObject request = new JsonObject();
Method method = null;
JsonReader paramsReader = null;
object args = null;
reader.ReadToken(JsonTokenClass.Object);
while (reader.TokenClass != JsonTokenClass.EndObject)
{
string memberName = reader.ReadMember();
switch (memberName)
{
case "id" :
{
request["id"] = importContext.Import(reader);
break;
}
case "method" :
{
string methodName = reader.ReadString();
request["method"] = methodName;
method = _service.GetClass().GetMethodByName(methodName);
if (paramsReader != null)
{
//
// If the parameters were already read in and
// buffer, then deserialize them now that we know
// the method we're dealing with.
//
args = ReadParameters(method, paramsReader, importContext);
paramsReader = null;
}
break;
}
case "params" :
{
//
// Is the method already known? If so, then we can
// deserialize the parameters right away. Otherwise
// we record them until hopefully the method is
// encountered.
//
if (method != null)
{
args = ReadParameters(method, reader, importContext);
}
else
{
JsonRecorder recorder = new JsonRecorder();
recorder.WriteFromReader(reader);
paramsReader = recorder.CreatePlayer();
}
break;
}
default:
{
reader.Skip();
break;
}
}
}
reader.Read();
if (args != null)
request["params"] = args;
return request;
}
public static void ReadGISFeature(IGISFeature feature, JsonTextReader jreader)
{
if (feature == null)
throw new ArgumentNullException("feature", "A valid feature reference is required.");
if (jreader == null)
throw new ArgumentNullException("jreader", "A valid JSON reader object is required.");
if (jreader.MoveToContent() && jreader.TokenClass == JsonTokenClass.Object)
{
jreader.ReadToken(JsonTokenClass.Object);
//Read the 'Feature' as the type
jreader.ReadMember(); //reads 'type'
jreader.ReadString(); //reads 'Feature'
//Read the 'geometry'
jreader.ReadMember(); //reads 'geometry'
feature.Shape = Read(jreader); //reads the geometry value
//Read the 'properties'
jreader.ReadMember(); //reads 'properties'
ReadGISAttributes(feature.Attributes, jreader);
jreader.ReadToken(JsonTokenClass.EndObject);
}
}
