diff --git a/NzbDrone.Common/NzbDrone.Common.csproj b/NzbDrone.Common/NzbDrone.Common.csproj
index c504c91cd..956b4825b 100644
--- a/NzbDrone.Common/NzbDrone.Common.csproj
+++ b/NzbDrone.Common/NzbDrone.Common.csproj
@@ -38,8 +38,8 @@
..\Libraries\Exceptioneer.WindowsFormsClient.dll
-
- ..\packages\Exceptron.Driver.0.1.0.8\lib\net20\Exceptron.Driver.dll
+
+ ..\packages\Exceptron.Driver.0.1.0.15\lib\net20\Exceptron.Driver.dll
..\packages\Newtonsoft.Json.4.5.4\lib\net40\Newtonsoft.Json.dll
diff --git a/NzbDrone.Common/ReportingService.cs b/NzbDrone.Common/ReportingService.cs
index 7308e3912..5133a717a 100644
--- a/NzbDrone.Common/ReportingService.cs
+++ b/NzbDrone.Common/ReportingService.cs
@@ -65,7 +65,7 @@ namespace NzbDrone.Common
var exceptionData = new ExceptionData();
exceptionData.Exception = logEvent.Exception;
- exceptionData.Location = logEvent.LoggerName;
+ exceptionData.Component = logEvent.LoggerName;
exceptionData.Message = logEvent.FormattedMessage;
exceptionData.UserId = EnvironmentProvider.UGuid.ToString().Replace("-", string.Empty);
@@ -89,7 +89,7 @@ namespace NzbDrone.Common
public static void SetupExceptronDriver()
{
- ExceptronDriver = new ExceptionClient("CB230C312E5C4FF38B4FB9644B05E60E")
+ ExceptronDriver = new ExceptionClient("CB230C312E5C4FF38B4FB9644B05E60G")
{
ApplicationVersion = new EnvironmentProvider().Version.ToString()
};
diff --git a/NzbDrone.Common/packages.config b/NzbDrone.Common/packages.config
index 96bcd338f..26739f2cd 100644
--- a/NzbDrone.Common/packages.config
+++ b/NzbDrone.Common/packages.config
@@ -1,6 +1,6 @@
-
+
\ No newline at end of file
diff --git a/packages/Exceptron.Driver.0.1.0.15/Exceptron.Driver.0.1.0.15.nupkg b/packages/Exceptron.Driver.0.1.0.15/Exceptron.Driver.0.1.0.15.nupkg
new file mode 100644
index 000000000..b85bf8f9c
Binary files /dev/null and b/packages/Exceptron.Driver.0.1.0.15/Exceptron.Driver.0.1.0.15.nupkg differ
diff --git a/packages/Exceptron.Driver.0.1.0.15/lib/net20/Exceptron.Driver.dll b/packages/Exceptron.Driver.0.1.0.15/lib/net20/Exceptron.Driver.dll
new file mode 100644
index 000000000..3ba56fc05
Binary files /dev/null and b/packages/Exceptron.Driver.0.1.0.15/lib/net20/Exceptron.Driver.dll differ
diff --git a/packages/Exceptron.Driver.0.1.0.15/lib/net20/Exceptron.Driver.pdb b/packages/Exceptron.Driver.0.1.0.15/lib/net20/Exceptron.Driver.pdb
new file mode 100644
index 000000000..d8d8258d3
Binary files /dev/null and b/packages/Exceptron.Driver.0.1.0.15/lib/net20/Exceptron.Driver.pdb differ
diff --git a/packages/Exceptron.Driver.0.1.0.15/src/ExceptionClient.cs b/packages/Exceptron.Driver.0.1.0.15/src/ExceptionClient.cs
new file mode 100644
index 000000000..e44d90230
--- /dev/null
+++ b/packages/Exceptron.Driver.0.1.0.15/src/ExceptionClient.cs
@@ -0,0 +1,127 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Reflection;
+using System.Threading;
+using Exceptron.Driver.Message;
+using Exceptron.Driver.fastJSON;
+
+namespace Exceptron.Driver
+{
+ public class ExceptionClient
+ {
+ public readonly string DriverVersion = Assembly.GetExecutingAssembly().GetName().Version.ToString();
+ public readonly string DriverName = "Official .NET";
+
+ private readonly string _appId;
+
+ public bool ThrowsExceptions { get; set; }
+ public string Enviroment { get; set; }
+ public string ApplicationVersion { get; set; }
+
+ internal RestClient RestClient { get; set; }
+ internal string ServerUrl { get; set; }
+
+
+ public ExceptionClient(string appId)
+ {
+ _appId = appId;
+
+ ServerUrl = "http://localhost:57674/v1a/";
+
+
+
+ RestClient = new RestClient();
+ }
+
+
+ internal static List ConvertToFrames(Exception exception)
+ {
+ if (exception == null) return null;
+
+ var stackTrace = new StackTrace(exception, true);
+
+ var frames = stackTrace.GetFrames();
+
+ if (frames == null) return null;
+
+ var result = new List();
+
+ for (int index = 0; index < frames.Length; index++)
+ {
+ var frame = frames[index];
+ var method = frame.GetMethod();
+ var declaringType = method.DeclaringType;
+
+ var currentFrame = new Frame
+ {
+ i = index,
+ fn = frame.GetFileName(),
+ ln = frame.GetFileLineNumber(),
+ m = method.ToString(),
+ };
+
+
+ currentFrame.m = currentFrame.m.Substring(currentFrame.m.IndexOf(' ')).Trim();
+
+
+ if (declaringType != null)
+ {
+ currentFrame.c = declaringType.FullName;
+ }
+
+ result.Add(currentFrame);
+ }
+
+
+ return result;
+ }
+
+ public string SubmitException(ExceptionData exceptionData)
+ {
+ try
+ {
+ VerifyErrorData(exceptionData);
+
+ var report = new ExceptionReport();
+
+ report.ap = _appId;
+ report.dn = DriverName;
+ report.dv = DriverVersion;
+ report.aver = ApplicationVersion;
+
+ report.ext = exceptionData.Exception.GetType().FullName;
+ report.exm = exceptionData.Exception.Message;
+ report.stk = ConvertToFrames(exceptionData.Exception);
+
+ report.cmp = exceptionData.Component;
+ report.uid = exceptionData.UserId;
+ report.env = Enviroment;
+ report.msg = exceptionData.Message;
+ report.cul = Thread.CurrentThread.CurrentCulture.Name;
+ report.os = Environment.OSVersion.VersionString;
+
+ var messageString = JSON.Instance.ToJSON(report);
+ var response = RestClient.Put(ServerUrl, messageString);
+ return response;
+ }
+ catch (Exception e)
+ {
+ Trace.WriteLine("Unable to submit exception to exceptron. ", e.ToString());
+
+ if (ThrowsExceptions) throw;
+ return null;
+ }
+ }
+
+ private void VerifyErrorData(ExceptionData exceptionData)
+ {
+ if (exceptionData == null)
+ throw new ArgumentNullException("exceptionData");
+
+ if (exceptionData.Exception == null)
+ throw new ArgumentException("ExceptionData.Exception Cannot be null.", "exceptionData");
+ }
+
+ }
+}
diff --git a/packages/Exceptron.Driver.0.1.0.15/src/ExceptionData.cs b/packages/Exceptron.Driver.0.1.0.15/src/ExceptionData.cs
new file mode 100644
index 000000000..a627ea9ae
--- /dev/null
+++ b/packages/Exceptron.Driver.0.1.0.15/src/ExceptionData.cs
@@ -0,0 +1,12 @@
+using System;
+
+namespace Exceptron.Driver
+{
+ public class ExceptionData
+ {
+ public Exception Exception { get; set; }
+ public string Component { get; set; }
+ public string UserId { get; set; }
+ public string Message { get; set; }
+ }
+}
\ No newline at end of file
diff --git a/packages/Exceptron.Driver.0.1.0.15/src/Message/ExceptionReport.cs b/packages/Exceptron.Driver.0.1.0.15/src/Message/ExceptionReport.cs
new file mode 100644
index 000000000..a83675f64
--- /dev/null
+++ b/packages/Exceptron.Driver.0.1.0.15/src/Message/ExceptionReport.cs
@@ -0,0 +1,76 @@
+using System.Collections.Generic;
+using System.ComponentModel;
+
+namespace Exceptron.Driver.Message
+{
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ internal class ExceptionReport
+ {
+ ///
+ /// API key
+ ///
+ public string ap { get; set; }
+
+ ///
+ /// Application Version
+ ///
+ public string aver { get; set; }
+
+ ///
+ /// User or Instance ID
+ ///
+ public string uid { get; set; }
+
+ ///
+ /// Type of exception
+ ///
+ public string ext { get; set; }
+
+ ///
+ /// Exception message
+ ///
+ public string exm { get; set; }
+
+ ///
+ /// List of frames that make up the StackTrace of the exception
+ ///
+ public List stk { get; set; }
+
+ ///
+ /// Component that experienced this exception
+ ///
+ public string cmp { get; set; }
+
+ ///
+ /// Environment that this exception occurred in.
+ ///
+ /// Dev, Stage, Production
+ public string env { get; set; }
+
+ ///
+ /// Message that was logged along with the exception.
+ ///
+ public string msg { get; set; }
+
+ ///
+ /// User's culture in
+ ///
+ /// http://msdn.microsoft.com/en-us/library/system.globalization.cultureinfo.name.aspx
+ public string cul { get; set; }
+
+ ///
+ /// OS Version
+ ///
+ public string os { get; set; }
+
+ ///
+ /// Name of the driver that generated and is sending this message
+ ///
+ public string dn { get; set; }
+
+ ///
+ /// Version of the driver that generated and is sending this message
+ ///
+ public string dv { get; set; }
+ }
+}
\ No newline at end of file
diff --git a/packages/Exceptron.Driver.0.1.0.15/src/Message/Frame.cs b/packages/Exceptron.Driver.0.1.0.15/src/Message/Frame.cs
new file mode 100644
index 000000000..9d1bab7e4
--- /dev/null
+++ b/packages/Exceptron.Driver.0.1.0.15/src/Message/Frame.cs
@@ -0,0 +1,33 @@
+using System.ComponentModel;
+
+namespace Exceptron.Driver.Message
+{
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ internal class Frame
+ {
+ ///
+ /// Order of current frame
+ ///
+ public int i { get; set; }
+
+ ///
+ /// Line number of the current frame
+ ///
+ public int ln { get; set; }
+
+ ///
+ /// File name of the current frame
+ ///
+ public string fn { get; set; }
+
+ ///
+ /// Method name for current frame
+ ///
+ public string m { get; set; }
+
+ ///
+ /// Class name for current frame
+ ///
+ public string c { get; set; }
+ }
+}
\ No newline at end of file
diff --git a/packages/Exceptron.Driver.0.1.0.15/src/Properties/AssemblyInfo.cs b/packages/Exceptron.Driver.0.1.0.15/src/Properties/AssemblyInfo.cs
new file mode 100644
index 000000000..c4773ddad
--- /dev/null
+++ b/packages/Exceptron.Driver.0.1.0.15/src/Properties/AssemblyInfo.cs
@@ -0,0 +1,38 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("Exceptron.Driver")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("Exceptron.Driver")]
+[assembly: AssemblyCopyright("Copyright © 2012")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible
+// to COM components. If you need to access a type in this assembly from
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("a463887e-594f-4733-b227-a79f4ffb2158")]
+
+// Version information for an assembly consists of the following four values:
+//
+// Major Version
+// Minor Version
+// Build Number
+// Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]
+[assembly: InternalsVisibleTo("Exceptron.Driver.Tests")]
+[assembly: InternalsVisibleTo("Exceptron.Api.v1a.Tests")]
diff --git a/packages/Exceptron.Driver.0.1.0.15/src/RestClient.cs b/packages/Exceptron.Driver.0.1.0.15/src/RestClient.cs
new file mode 100644
index 000000000..3d8fe436c
--- /dev/null
+++ b/packages/Exceptron.Driver.0.1.0.15/src/RestClient.cs
@@ -0,0 +1,41 @@
+using System;
+using System.IO;
+using System.Net;
+using System.Text;
+
+namespace Exceptron.Driver
+{
+ internal class RestClient
+ {
+ internal virtual string Put(string url, string content)
+ {
+ byte[] bytes = Encoding.UTF8.GetBytes(content);
+ var request = (HttpWebRequest)WebRequest.Create(url);
+ request.Method = "PUT";
+ request.ContentType = "application/json";
+ request.ContentLength = bytes.Length;
+ request.Accept = "application/json";
+
+ var dataStream = request.GetRequestStream();
+ dataStream.Write(bytes, 0, bytes.Length);
+ dataStream.Close();
+
+ WebResponse webResponse;
+
+ try
+ {
+ webResponse = request.GetResponse();
+ }
+ catch (WebException ex)
+ {
+ webResponse = ex.Response;
+ }
+
+ var responseStream = new StreamReader(webResponse.GetResponseStream(), Encoding.GetEncoding(1252));
+
+ var responseString = responseStream.ReadToEnd();
+
+ return responseString;
+ }
+ }
+}
diff --git a/packages/Exceptron.Driver.0.1.0.15/src/fastJSON/Getters.cs b/packages/Exceptron.Driver.0.1.0.15/src/fastJSON/Getters.cs
new file mode 100644
index 000000000..5263a13bc
--- /dev/null
+++ b/packages/Exceptron.Driver.0.1.0.15/src/fastJSON/Getters.cs
@@ -0,0 +1,21 @@
+//http://fastjson.codeplex.com/
+
+using System;
+using System.Collections.Generic;
+using Exceptron.Driver.fastJSON;
+
+namespace Exceptron.Driver.fastJSON
+{
+ internal class Getters
+ {
+ public string Name;
+ public JSON.GenericGetter Getter;
+ public Type propertyType;
+ }
+
+ internal class DatasetSchema
+ {
+ public List Info { get; set; }
+ public string Name { get; set; }
+ }
+}
diff --git a/packages/Exceptron.Driver.0.1.0.15/src/fastJSON/JSON.cs b/packages/Exceptron.Driver.0.1.0.15/src/fastJSON/JSON.cs
new file mode 100644
index 000000000..09a6b317e
--- /dev/null
+++ b/packages/Exceptron.Driver.0.1.0.15/src/fastJSON/JSON.cs
@@ -0,0 +1,910 @@
+//http://fastjson.codeplex.com/
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Data;
+using System.Globalization;
+using System.IO;
+using System.Reflection;
+using System.Reflection.Emit;
+using Exceptron.Driver.fastJSON;
+
+namespace Exceptron.Driver.fastJSON
+{
+ internal delegate string Serialize(object data);
+ internal delegate object Deserialize(string data);
+
+ internal class JSON
+ {
+ public readonly static JSON Instance = new JSON();
+
+ private JSON()
+ {
+ UseSerializerExtension = false;
+ SerializeNullValues = false;
+ UseOptimizedDatasetSchema = false;
+ UsingGlobalTypes = false;
+ }
+ public bool UseOptimizedDatasetSchema = true;
+ public bool UseFastGuid = true;
+ public bool UseSerializerExtension = true;
+ public bool IndentOutput = false;
+ public bool SerializeNullValues = true;
+ public bool UseUTCDateTime = false;
+ public bool ShowReadOnlyProperties = false;
+ public bool UsingGlobalTypes = true;
+
+ public string ToJSON(object obj)
+ {
+ return ToJSON(obj, UseSerializerExtension, UseFastGuid, UseOptimizedDatasetSchema, SerializeNullValues);
+ }
+
+ public string ToJSON(object obj,
+ bool enableSerializerExtensions)
+ {
+ return ToJSON(obj, enableSerializerExtensions, UseFastGuid, UseOptimizedDatasetSchema, SerializeNullValues);
+ }
+
+ public string ToJSON(object obj,
+ bool enableSerializerExtensions,
+ bool enableFastGuid)
+ {
+ return ToJSON(obj, enableSerializerExtensions, enableFastGuid, UseOptimizedDatasetSchema, SerializeNullValues);
+ }
+
+ public string ToJSON(object obj,
+ bool enableSerializerExtensions,
+ bool enableFastGuid,
+ bool enableOptimizedDatasetSchema,
+ bool serializeNullValues)
+ {
+ return new JSONSerializer(enableOptimizedDatasetSchema, enableFastGuid, enableSerializerExtensions, serializeNullValues, IndentOutput).ConvertToJSON(obj);
+ }
+
+ public object Parse(string json)
+ {
+ return new JsonParser(json).Decode();
+ }
+
+ public T ToObject(string json)
+ {
+ return (T)ToObject(json, typeof(T));
+ }
+
+ public object ToObject(string json)
+ {
+ return ToObject(json, null);
+ }
+
+ public object ToObject(string json, Type type)
+ {
+ Dictionary ht = new JsonParser(json).Decode() as Dictionary;
+ if (ht == null) return null;
+ return ParseDictionary(ht, null, type);
+ }
+
+#if CUSTOMTYPE
+ internal SafeDictionary _customSerializer = new SafeDictionary();
+ internal SafeDictionary _customDeserializer = new SafeDictionary();
+
+ public void RegisterCustomType(Type type, Serialize serializer, Deserialize deserializer)
+ {
+ if (type != null && serializer != null && deserializer != null)
+ {
+ _customSerializer.Add(type, serializer);
+ _customDeserializer.Add(type, deserializer);
+ // reset property cache
+ _propertycache = new SafeDictionary>();
+ }
+ }
+
+ internal bool IsTypeRegistered(Type t)
+ {
+ Serialize s;
+ return _customSerializer.TryGetValue(t, out s);
+ }
+#endif
+
+ #region [ PROPERTY GET SET CACHE ]
+ SafeDictionary _tyname = new SafeDictionary();
+ internal string GetTypeAssemblyName(Type t)
+ {
+ string val = "";
+ if (_tyname.TryGetValue(t, out val))
+ return val;
+ else
+ {
+ string s = t.AssemblyQualifiedName;
+ _tyname.Add(t, s);
+ return s;
+ }
+ }
+
+ SafeDictionary _typecache = new SafeDictionary();
+ private Type GetTypeFromCache(string typename)
+ {
+ Type val = null;
+ if (_typecache.TryGetValue(typename, out val))
+ return val;
+ else
+ {
+ Type t = Type.GetType(typename);
+ _typecache.Add(typename, t);
+ return t;
+ }
+ }
+
+ SafeDictionary _constrcache = new SafeDictionary();
+ private delegate object CreateObject();
+ private object FastCreateInstance(Type objtype)
+ {
+ try
+ {
+ CreateObject c = null;
+ if (_constrcache.TryGetValue(objtype, out c))
+ {
+ return c();
+ }
+ else
+ {
+ DynamicMethod dynMethod = new DynamicMethod("_", objtype, null, true);
+ ILGenerator ilGen = dynMethod.GetILGenerator();
+
+ ilGen.Emit(OpCodes.Newobj, objtype.GetConstructor(Type.EmptyTypes));
+ ilGen.Emit(OpCodes.Ret);
+ c = (CreateObject)dynMethod.CreateDelegate(typeof(CreateObject));
+ _constrcache.Add(objtype, c);
+ return c();
+ }
+ }
+ catch (Exception exc)
+ {
+ throw new Exception(string.Format("Failed to fast create instance for type '{0}' from assemebly '{1}'",
+ objtype.FullName, objtype.AssemblyQualifiedName), exc);
+ }
+ }
+
+ private struct myPropInfo
+ {
+ public bool filled;
+ public Type pt;
+ public Type bt;
+ public Type changeType;
+ public bool isDictionary;
+ public bool isValueType;
+ public bool isGenericType;
+ public bool isArray;
+ public bool isByteArray;
+ public bool isGuid;
+#if !SILVERLIGHT
+ public bool isDataSet;
+ public bool isDataTable;
+ public bool isHashtable;
+#endif
+ public GenericSetter setter;
+ public bool isEnum;
+ public bool isDateTime;
+ public Type[] GenericTypes;
+ public bool isInt;
+ public bool isLong;
+ public bool isString;
+ public bool isBool;
+ public bool isClass;
+ public GenericGetter getter;
+ public bool isStringDictionary;
+ public string Name;
+#if CUSTOMTYPE
+ public bool isCustomType;
+#endif
+ public bool CanWrite;
+ }
+
+ SafeDictionary> _propertycache = new SafeDictionary>();
+ private SafeDictionary Getproperties(Type type, string typename)
+ {
+ SafeDictionary sd = null;
+ if (_propertycache.TryGetValue(typename, out sd))
+ {
+ return sd;
+ }
+ else
+ {
+ sd = new SafeDictionary();
+ PropertyInfo[] pr = type.GetProperties(BindingFlags.Public | BindingFlags.Instance);
+ foreach (PropertyInfo p in pr)
+ {
+ myPropInfo d = CreateMyProp(p.PropertyType, p.Name);
+ d.CanWrite = p.CanWrite;
+ d.setter = CreateSetMethod(p);
+ d.getter = CreateGetMethod(p);
+ sd.Add(p.Name, d);
+ }
+ FieldInfo[] fi = type.GetFields(BindingFlags.Public | BindingFlags.Instance);
+ foreach (FieldInfo f in fi)
+ {
+ myPropInfo d = CreateMyProp(f.FieldType, f.Name);
+ d.setter = CreateSetField(type, f);
+ d.getter = CreateGetField(type, f);
+ sd.Add(f.Name, d);
+ }
+
+ _propertycache.Add(typename, sd);
+ return sd;
+ }
+ }
+
+ private myPropInfo CreateMyProp(Type t, string name)
+ {
+ myPropInfo d = new myPropInfo();
+ d.filled = true;
+ d.CanWrite = true;
+ d.pt = t;
+ d.Name = name;
+ d.isDictionary = t.Name.Contains("Dictionary");
+ if (d.isDictionary)
+ d.GenericTypes = t.GetGenericArguments();
+ d.isValueType = t.IsValueType;
+ d.isGenericType = t.IsGenericType;
+ d.isArray = t.IsArray;
+ if (d.isArray)
+ d.bt = t.GetElementType();
+ if (d.isGenericType)
+ d.bt = t.GetGenericArguments()[0];
+ d.isByteArray = t == typeof(byte[]);
+ d.isGuid = (t == typeof(Guid) || t == typeof(Guid?));
+#if !SILVERLIGHT
+ d.isHashtable = t == typeof(Hashtable);
+ d.isDataSet = t == typeof(DataSet);
+ d.isDataTable = t == typeof(DataTable);
+#endif
+
+ d.changeType = GetChangeType(t);
+ d.isEnum = t.IsEnum;
+ d.isDateTime = t == typeof(DateTime) || t == typeof(DateTime?);
+ d.isInt = t == typeof(int) || t == typeof(int?);
+ d.isLong = t == typeof(long) || t == typeof(long?);
+ d.isString = t == typeof(string);
+ d.isBool = t == typeof(bool) || t == typeof(bool?);
+ d.isClass = t.IsClass;
+
+ if (d.isDictionary && d.GenericTypes.Length > 0 && d.GenericTypes[0] == typeof(string))
+ d.isStringDictionary = true;
+
+#if CUSTOMTYPE
+ if (IsTypeRegistered(t))
+ d.isCustomType = true;
+#endif
+ return d;
+ }
+
+ private delegate void GenericSetter(object target, object value);
+
+ private static GenericSetter CreateSetMethod(PropertyInfo propertyInfo)
+ {
+ MethodInfo setMethod = propertyInfo.GetSetMethod();
+ if (setMethod == null)
+ return null;
+
+ Type[] arguments = new Type[2];
+ arguments[0] = arguments[1] = typeof(object);
+
+ DynamicMethod setter = new DynamicMethod("_", typeof(void), arguments, true);
+ ILGenerator il = setter.GetILGenerator();
+ il.Emit(OpCodes.Ldarg_0);
+ il.Emit(OpCodes.Castclass, propertyInfo.DeclaringType);
+ il.Emit(OpCodes.Ldarg_1);
+
+ if (propertyInfo.PropertyType.IsClass)
+ il.Emit(OpCodes.Castclass, propertyInfo.PropertyType);
+ else
+ il.Emit(OpCodes.Unbox_Any, propertyInfo.PropertyType);
+
+ il.EmitCall(OpCodes.Callvirt, setMethod, null);
+ il.Emit(OpCodes.Ret);
+
+ return (GenericSetter)setter.CreateDelegate(typeof(GenericSetter));
+ }
+
+ internal delegate object GenericGetter(object obj);
+
+ private static GenericGetter CreateGetField(Type type, FieldInfo fieldInfo)
+ {
+ DynamicMethod dynamicGet = new DynamicMethod("_", typeof(object), new Type[] { typeof(object) }, type, true);
+ ILGenerator il = dynamicGet.GetILGenerator();
+
+ il.Emit(OpCodes.Ldarg_0);
+ il.Emit(OpCodes.Ldfld, fieldInfo);
+ if (fieldInfo.FieldType.IsValueType)
+ il.Emit(OpCodes.Box, fieldInfo.FieldType);
+ il.Emit(OpCodes.Ret);
+
+ return (GenericGetter)dynamicGet.CreateDelegate(typeof(GenericGetter));
+ }
+
+ private static GenericSetter CreateSetField(Type type, FieldInfo fieldInfo)
+ {
+ Type[] arguments = new Type[2];
+ arguments[0] = arguments[1] = typeof(object);
+
+ DynamicMethod dynamicSet = new DynamicMethod("_", typeof(void), arguments, type, true);
+ ILGenerator il = dynamicSet.GetILGenerator();
+
+ il.Emit(OpCodes.Ldarg_0);
+ il.Emit(OpCodes.Ldarg_1);
+ if (fieldInfo.FieldType.IsValueType)
+ il.Emit(OpCodes.Unbox_Any, fieldInfo.FieldType);
+ il.Emit(OpCodes.Stfld, fieldInfo);
+ il.Emit(OpCodes.Ret);
+
+ return (GenericSetter)dynamicSet.CreateDelegate(typeof(GenericSetter));
+ }
+
+ private GenericGetter CreateGetMethod(PropertyInfo propertyInfo)
+ {
+ MethodInfo getMethod = propertyInfo.GetGetMethod();
+ if (getMethod == null)
+ return null;
+
+ Type[] arguments = new Type[1];
+ arguments[0] = typeof(object);
+
+ DynamicMethod getter = new DynamicMethod("_", typeof(object), arguments, true);
+ ILGenerator il = getter.GetILGenerator();
+ il.Emit(OpCodes.Ldarg_0);
+ il.Emit(OpCodes.Castclass, propertyInfo.DeclaringType);
+ il.EmitCall(OpCodes.Callvirt, getMethod, null);
+
+ if (!propertyInfo.PropertyType.IsClass)
+ il.Emit(OpCodes.Box, propertyInfo.PropertyType);
+
+ il.Emit(OpCodes.Ret);
+
+ return (GenericGetter)getter.CreateDelegate(typeof(GenericGetter));
+ }
+
+ readonly SafeDictionary> _getterscache = new SafeDictionary>();
+ internal List GetGetters(Type type)
+ {
+ List val = null;
+ if (_getterscache.TryGetValue(type, out val))
+ return val;
+
+ PropertyInfo[] props = type.GetProperties(BindingFlags.Public | BindingFlags.Instance);
+ List getters = new List();
+ foreach (PropertyInfo p in props)
+ {
+ if (!p.CanWrite && ShowReadOnlyProperties == false) continue;
+
+ object[] att = p.GetCustomAttributes(typeof(System.Xml.Serialization.XmlIgnoreAttribute), false);
+ if (att != null && att.Length > 0)
+ continue;
+
+ JSON.GenericGetter g = CreateGetMethod(p);
+ if (g != null)
+ {
+ Getters gg = new Getters();
+ gg.Name = p.Name;
+ gg.Getter = g;
+ gg.propertyType = p.PropertyType;
+ getters.Add(gg);
+ }
+ }
+
+ FieldInfo[] fi = type.GetFields(BindingFlags.Instance | BindingFlags.Public);
+ foreach (var f in fi)
+ {
+ object[] att = f.GetCustomAttributes(typeof(System.Xml.Serialization.XmlIgnoreAttribute), false);
+ if (att != null && att.Length > 0)
+ continue;
+
+ JSON.GenericGetter g = CreateGetField(type, f);
+ if (g != null)
+ {
+ Getters gg = new Getters();
+ gg.Name = f.Name;
+ gg.Getter = g;
+ gg.propertyType = f.FieldType;
+ getters.Add(gg);
+ }
+ }
+
+ _getterscache.Add(type, getters);
+ return getters;
+ }
+
+ private object ChangeType(object value, Type conversionType)
+ {
+ if (conversionType == typeof(int))
+ return (int)CreateLong((string)value);
+
+ else if (conversionType == typeof(long))
+ return CreateLong((string)value);
+
+ else if (conversionType == typeof(string))
+ return (string)value;
+
+ else if (conversionType == typeof(Guid))
+ return CreateGuid((string)value);
+
+ else if (conversionType.IsEnum)
+ return CreateEnum(conversionType, (string)value);
+
+ return Convert.ChangeType(value, conversionType, CultureInfo.InvariantCulture);
+ }
+ #endregion
+
+
+ private object ParseDictionary(Dictionary d, Dictionary globaltypes, Type type)
+ {
+ object tn = "";
+ if (d.TryGetValue("$types", out tn))
+ {
+ UsingGlobalTypes = true;
+ globaltypes = new Dictionary();
+ foreach (var kv in (Dictionary)tn)
+ {
+ globaltypes.Add((string)kv.Value, kv.Key);
+ }
+ }
+
+ bool found = d.TryGetValue("$type", out tn);
+#if !SILVERLIGHT
+ if (found == false && type == typeof(System.Object))
+ {
+ return CreateDataset(d, globaltypes);
+ }
+#endif
+ if (found)
+ {
+ if (UsingGlobalTypes)
+ {
+ object tname = "";
+ if (globaltypes.TryGetValue((string)tn, out tname))
+ tn = tname;
+ }
+ type = GetTypeFromCache((string)tn);
+ }
+
+ if (type == null)
+ throw new Exception("Cannot determine type");
+
+ string typename = type.FullName;
+ object o = FastCreateInstance(type);
+ SafeDictionary props = Getproperties(type, typename);
+ foreach (string name in d.Keys)
+ {
+ if (name == "$map")
+ {
+ ProcessMap(o, props, (Dictionary)d[name]);
+ continue;
+ }
+ myPropInfo pi;
+ if (props.TryGetValue(name, out pi) == false)
+ continue;
+ if (pi.filled == true)
+ {
+ object v = d[name];
+
+ if (v != null)
+ {
+ object oset = null;
+
+ if (pi.isInt)
+ oset = (int)CreateLong((string)v);
+#if CUSTOMTYPE
+ else if (pi.isCustomType)
+ oset = CreateCustom((string)v, pi.pt);
+#endif
+ else if (pi.isLong)
+ oset = CreateLong((string)v);
+
+ else if (pi.isString)
+ oset = (string)v;
+
+ else if (pi.isBool)
+ oset = (bool)v;
+
+ else if (pi.isGenericType && pi.isValueType == false && pi.isDictionary == false)
+#if SILVERLIGHT
+ oset = CreateGenericList((List