public void ToJson_ValidComplexObject_ReturnsJson()
        {
            var item = Helper.GetComplexFake();

            string result = JSerializer.ToJson(item);

            Assert.IsTrue(result.Length > 0);
        }
Example #2
0
 public GOC()
 {
     _webServiceCache = new WebServiceClientCache();
     _loggerStandard  = new Logger();
     _xSerializer     = new XSerializer();
     _jSerializer     = new JSerializer();
     _csvSerializer   = new CsvSerializer();
     _encoding        = Encoding.Default;
 }
        public void FromJson_ValidComplexJson_ReturnsObject()
        {
            var    item = Helper.GetComplexFake();
            string json = JSerializer.ToJson(item);

            var fromJsonObj = JSerializer.FromJson <ComplexFake>(json);

            Assert.True(fromJsonObj != null);
        }
Example #4
0
        static JSerializer CreateDefault()
        {
            var s = new JSerializer()
            {
                EnabledCamelCaseName = true
            };

            return(s);
        }
Example #5
0
        public async Task Send(IWsMessage message, CancellationToken cancellationToken = default)
        {
            await EnsureSocketConnection();

            var json   = JSerializer.Serialize(message);
            var data   = Encoding.UTF8.GetBytes(json);
            var buffer = new ArraySegment <byte>(data);
            await _socket.SendAsync(buffer, WebSocketMessageType.Text, true, cancellationToken);
        }
Example #6
0
        /// <summary>
        /// 提供一个 <see cref="JSerializer"/>,初始化一个 <see cref="JsonSerializer"/> 类的新实例。
        /// </summary>
        /// <param name="JSerializer"></param>
        public JsonSerializer(JSerializer JSerializer)
        {
            if (JSerializer == null)
            {
                throw new ArgumentNullException(nameof(JSerializer));
            }

            this._serializer = JSerializer;
        }
Example #7
0
        /// <summary>
        /// Envia o Request para o servidor informando o tipo
        /// </summary>
        /// <typeparam name="TResponse">Objeto de retorno a ser deserializado do json</typeparam>
        /// <param name="method">Metodo do Request</param>
        /// <param name="RequestHeader">Cabeçalhos do Request</param>
        /// <param name="body">Conteudo do corpo do request. No caso do POST</param>
        /// <returns></returns>
        private async Task <Response> ExecuteRequestAsync <TResponse>(string method, List <KeyValuePair <string, string> > RequestHeader, object body = null) where TResponse : new()
        {
            HttpResponseMessage response = new HttpResponseMessage(new HttpStatusCode());

            try
            {
                HttpRequestMessage request = new HttpRequestMessage(method: GetMethod(), requestUri: this.EndPoint)
                {
                };

                //Define os headers informados
                client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("image/jpeg"));



                if (body != null)
                {
                    request.Content = (HttpContent)body;
                }

                //foreach (var hdr in RequestHeader)
                //{
                //    request.Headers.TryAddWithoutValidation(hdr.Key, hdr.Value);
                //}

                if (RequestHeader != null)
                {
                    RequestHeader.ForEach(hdr => request.Headers.Add(hdr.Key, hdr.Value));
                }

                //**** Metodo Resposavel por enviar o Request Assincrono
                response = await client.SendAsync(request);

                //Serializa o json retornado
                var ResponseObject = JSerializer.ConvertStringToObject <TResponse>(response.Content.ReadAsStringAsync().Result);

                return(await Task.FromResult(
                           new Response()
                {
                    Status = response.StatusCode,
                    Description = response.ReasonPhrase,
                    Data = ResponseObject,
                    HttpResponse = response
                }));



                HttpMethod GetMethod() => method == "GET" ? HttpMethod.Get : HttpMethod.Post;
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw;
            }
        }
Example #8
0
 public GOCWindows()
 {
     _settingsCache   = new SettingsCache();
     _webServiceCache = new WebServiceClientCache();
     _databaseCache   = new DatabaseCacheWindows();
     _logger          = new LoggerWindows();
     _xSerializer     = new XSerializer();
     _jSerializer     = new JSerializer();
     _csvSerializer   = new CsvSerializer();
     _encoding        = Encoding.Default;
 }
        protected virtual async Task <T> GetResponseItem <T>(string path, HttpResponseMessage response)
        {
            var json = await GetResponseString(response);

            if (response.StatusCode != HttpStatusCode.OK)
            {
                throw new RestServiceException(GetRestServiceExceptionMessage(path, response.StatusCode));
            }

            return(JSerializer.Deserialize <T>(json));
        }
        public async Task Send(IWsMessage message, CancellationToken cancellationToken = default)
        {
            await EnsureSocketConnection();

            await Task.Run(() => _client.Send(JSerializer.Serialize(message)), cancellationToken);

            if (_configuration.ReconnectEnabled && _configuration.ResubscribeOnReconnect)
            {
                _subscriptions.Push(message);
            }
        }
        internal virtual async Task <TO> Post <TI, TO>(string path, TI payload, CancellationToken cancellationToken = default)
        {
            var request = new HttpRequestMessage(HttpMethod.Post, GetRequestUrl(path));

            if (payload != null)
            {
                request.Content = new StringContent(JSerializer.Serialize(payload), Encoding.UTF8, "application/json");
            }

            var client   = EnsureHttpClientCreated();
            var response = await client.SendAsync(request, cancellationToken);

            return(await GetResponseItem <TO>(path, response));
        }
Example #12
0
        // Helper method that recursively convert individual items in the old array
        private static bool AddItemToList(IList oldList, IList newList, Type elementType, JSerializer serializer, bool throwOnError)
        {
            object convertedObject;
            foreach(Object propertyValue in oldList)
            {
                if(!ConvertObjectToTypeMain(propertyValue, elementType, serializer, throwOnError, out convertedObject))
                {
                    return false;
                }

                newList.Add(convertedObject);
            }

            return true;
        }
        internal virtual async Task <T> Post <T>(string path, object payload, IDictionary <string, string> query = null,
                                                 IDictionary <string, string> customHeaders = null, CancellationToken cancellationToken = default)
        {
            var request = new HttpRequestMessage(HttpMethod.Post, BuildUri(path, query));

            if (payload != null)
            {
                var body = JSerializer.Serialize(payload);
                request.Content = new StringContent(body, Encoding.UTF8, "application/json");
            }

            FillRequestHeaders(request, customHeaders);

            using (var response = await _client.SendAsync(request, cancellationToken))
                return(await GetResponseItem <T>(response));
        }
        protected override async Task <T> GetResponseItem <T>(string path, HttpResponseMessage response)
        {
            var json = await GetResponseString(response);

            if (response.StatusCode != HttpStatusCode.OK)
            {
                var errorResponse = JSerializer.Deserialize <ErrorResponse>(json);
                if (errorResponse == null)
                {
                    throw new RestServiceException(GetRestServiceExceptionMessage(path, response.StatusCode));
                }

                throw new RestServiceException(errorResponse.Payload.Message, errorResponse);
            }

            return(JSerializer.Deserialize <T>(json));
        }
Example #15
0
        // Helper method that assigns the propertyValue to object o's member (memberName)
        private static bool AssignToProperty(TypeMapper typeMapper, object propertyValue, object o, string memberName, JSerializer serializer, bool throwOnError)
        {
            var dictionary = o as IDictionary;
            // if o is already an idictionary, assign the value to the dictionary
            if(dictionary != null)
            {
                if(!ConvertObjectToTypeMain(propertyValue, null, serializer, throwOnError, out propertyValue))
                {
                    return false;
                }
                dictionary[memberName] = propertyValue;
                return true;
            }

            typeMapper[memberName]?.SetValue(o, propertyValue, false);

            // not a property , so it is ignored
            return true;
        }
        protected override async Task <T> GetResponseItem <T>(HttpResponseMessage response)
        {
            var content = await response.Content.ReadAsStringAsync();

            if (response.StatusCode != HttpStatusCode.OK)
            {
                var errorResponse = JSerializer.Deserialize <ErrorResponse>(content);
                if (errorResponse == null)
                {
                    throw new RestServiceException(
                              GetRestServiceExceptionMessage(response.RequestMessage.RequestUri.ToString(),
                                                             response.StatusCode, content));
                }

                throw new RestServiceException(errorResponse.Payload.Message, errorResponse);
            }

            return(JSerializer.Deserialize <T>(content));
        }
        static Dictionary <string, string> LoadCookie()
        {
            string content = string.Empty;

            if (File.Exists(CookieName))
            {
                content = File.ReadAllText(CookieName, Encoding.UTF8);
            }

            if (!string.IsNullOrEmpty(content))
            {
                Dictionary <string, string> temp = JSerializer.Deserialize <Dictionary <string, string> >(content);

                if (null != temp)
                {
                    return(temp);
                }
            }

            return(new Dictionary <string, string>());
        }
Example #18
0
        private async Task <Response> ExecuteRequestAsync <TResponse>(string method, List <KeyValuePair <string, string> > RequestHeader, object body = null) where TResponse : new()
        {
            try
            {
                IRestRequest request = new RestRequest(EndPoint, GetMethod(), DataFormat.Json);
                IRestResponse <TResponse> response = new RestResponse <TResponse>();

                //Define os cabeçalhos do request, caso tenha
                if (RequestHeader != null)
                {
                    RequestHeader.ForEach(hdr => request.AddHeader(hdr.Key, hdr.Value));
                }
                if (body != null)
                {
                    request.AddParameter("body", body, ParameterType.RequestBody);
                }

                //**** Metodo Resposavel por enviar o Request Assincrono
                response = client.Execute <TResponse>(request);

                var ResponseObject = JSerializer.ConvertStringToObject <TResponse>(response.Content);

                return(await Task.FromResult(
                           new Response()
                {
                    Status = response.StatusCode,
                    Description = response.StatusDescription,
                    Data = ResponseObject,
                    HttpResponse = response
                }));

                //C# 6.0 - Metodo Local. Visivel somente no escopo dessa função
                Method GetMethod() => method == "GET" ? Method.GET : Method.POST;
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw;
            }
        }
        private IWsMessage DeserializeMessage(string message)
        {
            var eventType = JSerializer.Deserialize <WsMessage>(message).Event;

            switch (eventType)
            {
            case EventType.OrderBook:
                return(JSerializer.Deserialize <OrderBookMessage>(message));

            case EventType.Candle:
                return(JSerializer.Deserialize <CandleMessage>(message));

            case EventType.InstrumentInfo:
                return(JSerializer.Deserialize <InstrumentInfoMessage>(message));

            case EventType.Error:
                return(JSerializer.Deserialize <ErrorMessage>(message));

            default:
                throw new ArgumentException(nameof(eventType));
            }
        }
        public void FromJson_Null_Throws()
        {
            string json = null;

            Assert.Throws <ArgumentException>(() => JSerializer.FromJson <SimpleFake>(json));
        }
        public void FromJson_InValidJson_Throws()
        {
            string json = "this is not json";

            Assert.Throws <JsonReaderException>(() => JSerializer.FromJson <SimpleFake>(json));
        }
        public void ToJson_InvalidObject_Throws()
        {
            SimpleFake fake = null;

            Assert.Throws <ArgumentException>(() => JSerializer.ToJson(fake));
        }
 static void SaveCookie()
 {
     File.WriteAllText(CookieName, JSerializer.SerializeToString(mCookie), Encoding.UTF8);
 }
Example #24
0
        public static T FromJson <T>(this string json)
        {
            Check.Argument.IsNotEmpty(json, "json");

            return(JSerializer.Deserialize <T>(json));
        }
Example #25
0
        public static string ToJson <T>(this T instance)
        {
            Check.Argument.IsNotNull(instance, "instance");

            return(JSerializer.Serialize(instance));
        }
Example #26
0
 internal static object ConvertObjectToType(object o, Type type, JSerializer serializer)
 {
     object convertedObject;
     ConvertObjectToTypeMain(o, type, serializer, true, out convertedObject);
     return convertedObject;
 }
Example #27
0
        // Method that converts an IDictionary<string, object> to an object of the right type
        private static bool ConvertDictionaryToObject(IDictionary<string, object> dictionary, Type type, JSerializer serializer, bool throwOnError, out object convertedObject)
        {

            // The target type to instantiate.
            Type targetType = type;
            object s;
            string serverTypeName = null;
            object o = dictionary;

            // Check if __serverType exists in the dictionary, use it as the type.
            if(dictionary.TryGetValue(JSerializer.ServerTypeFieldName, out s))
            {

                // Convert the __serverType value to a string.
                if(!ConvertObjectToTypeMain(s, typeof(String), serializer, throwOnError, out s))
                {
                    convertedObject = false;
                    return false;
                }

                serverTypeName = (string)s;

                if(serverTypeName != null)
                {
                    // If we don't have the JavaScriptTypeResolver, we can't use it
                    if(serializer.TypeResolver != null)
                    {
                        // Get the actual type from the resolver.
                        targetType = serializer.TypeResolver.ResolveType(serverTypeName);

                        // In theory, we should always find the type.  If not, it may be some kind of attack.
                        if(targetType == null)
                        {
                            if(throwOnError)
                            {
                                throw new InvalidOperationException();
                            }

                            convertedObject = null;
                            return false;
                        }
                    }

                    // Remove the serverType from the dictionary, even if the resolver was null
                    dictionary.Remove(JSerializer.ServerTypeFieldName);
                }
            }

            JConverter converter = null;
            if(targetType != null && serializer.ConverterExistsForType(targetType, out converter))
            {
                try
                {
                    convertedObject = converter.Deserialize(dictionary, targetType, serializer);
                    return true;
                }
                catch
                {
                    if(throwOnError)
                    {
                        throw;
                    }

                    convertedObject = null;
                    return false;
                }
            }

            // Instantiate the type if it's coming from the __serverType argument.
            if(serverTypeName != null || IsClientInstantiatableType(targetType, serializer))
            {

                // First instantiate the object based on the type.
                o = Activator.CreateInstance(targetType);
            }

            // Use a different collection to avoid modifying the original during keys enumeration.
            List<String> memberNames = new List<String>(dictionary.Keys);

            // Try to handle the IDictionary<K, V> case
            if(IsGenericDictionary(type))
            {

                Type keyType = type.GetGenericArguments()[0];
                if(keyType != typeof(string) && keyType != typeof(object))
                {
                    if(throwOnError)
                    {
                        throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture, AtlasWeb.JSON_DictionaryTypeNotSupported, type.FullName));
                    }

                    convertedObject = null;
                    return false;
                }

                Type valueType = type.GetGenericArguments()[1];
                IDictionary dict = null;
                if(IsClientInstantiatableType(type, serializer))
                {
                    dict = (IDictionary)Activator.CreateInstance(type);
                }
                else {
                    // Get the strongly typed Dictionary<K, V>
                    Type t = _dictionaryGenericType.MakeGenericType(keyType, valueType);
                    dict = (IDictionary)Activator.CreateInstance(t);
                }

                if(dict != null)
                {
                    foreach(string memberName in memberNames)
                    {
                        object memberObject;
                        if(!ConvertObjectToTypeMain(dictionary[memberName], valueType, serializer, throwOnError, out memberObject))
                        {
                            convertedObject = null;
                            return false;
                        }
                        dict[memberName] = memberObject;
                    }

                    convertedObject = dict;
                    return true;
                }
            }

            // Fail if we know we cannot possibly return the required type.
            if(type != null && !type.IsAssignableFrom(o.GetType()))
            {

                if(!throwOnError)
                {
                    convertedObject = null;
                    return false;
                }

                ConstructorInfo constructorInfo = type.GetConstructor(BindingFlags.Public | BindingFlags.Instance, null, s_emptyTypeArray, null);
                if(constructorInfo == null)
                {
                    throw new MissingMethodException(String.Format(CultureInfo.InvariantCulture, AtlasWeb.JSON_NoConstructor, type.FullName));
                }

                throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture, AtlasWeb.JSON_DeserializerTypeMismatch, type.FullName));
            }
            var typeMapper = TypeMapper.Create(o.GetType());
            foreach(string memberName in memberNames)
            {
                object propertyValue = dictionary[memberName];
                // Assign the value into a property or field of the object
                if(!AssignToProperty(typeMapper, propertyValue, o, memberName, serializer, throwOnError))
                {
                    convertedObject = null;
                    return false;
                }
            }

            convertedObject = o;
            return true;
        }
Example #28
0
 internal static bool TryConvertObjectToType(object o, Type type, JSerializer serializer, out object convertedObject)
 {
     return ConvertObjectToTypeMain(o, type, serializer, false, out convertedObject);
 }
Example #29
0
        // Is this a type for which we want to instantiate based on the client stub
        internal static bool IsClientInstantiatableType(Type t, JSerializer serializer)
        {
            // Abstract classes and interfaces can't be instantiated
            // 
            if(t == null || t.IsAbstract || t.IsInterface || t.IsArray)
                return false;

            // Even though 'object' is instantiatable, it is never useful to do this
            if(t == typeof(object))
                return false;

            // Return true if a converter is registered for the given type, so the converter
            // can generate code on the client to instantiate it.
            JConverter converter = null;
            if(serializer.ConverterExistsForType(t, out converter))
            {
                return true;
            }

            // Value types are okay (i.e. structs);
            if(t.IsValueType)
            {
                return true;
            }

            // Ignore types that don't have a public default ctor
            ConstructorInfo constructorInfo = t.GetConstructor(BindingFlags.Public | BindingFlags.Instance,
                null, s_emptyTypeArray, null);
            if(constructorInfo == null)
                return false;

            return true;
        }
Example #30
0
        private static bool ConvertObjectToTypeMain(object o, Type type, JSerializer serializer, bool throwOnError, out object convertedObject)
        {
            // If it's null, there is nothing to convert
            if(o == null)
            {
                // need to special case Char, as we convert \0 to null
                if(type == typeof(char))
                {
                    convertedObject = '\0';
                    return true;
                }
                // Throw if its a value type and not a nullable
                if(IsNonNullableValueType(type))
                {
                    if(throwOnError)
                    {
                        throw new InvalidOperationException(AtlasWeb.JSON_ValueTypeCannotBeNull);
                    }
                    else {
                        convertedObject = null;
                        return false;
                    }
                }

                convertedObject = null;
                return true;
            }

            // simply return the current object if the current type is same as return type.
            if(o.GetType() == type)
            {
                convertedObject = o;
                return true;
            }

            // otherwise use the converters to convert object into target type.
            return ConvertObjectToTypeInternal(o, type, serializer, throwOnError, out convertedObject);
        }
Example #31
0
        // Method that converts client array to the request type. It handles the following cases:
        // 1. type is not passed in - An ArrayList will be returned.
        // 2. type is an array - An array of the right type will be returned.
        // 3. type is an abstract collection interface, e.g. IEnumerable, ICollection -
        //    An ArrayList will be returned.
        // 4. type is an generic abstract collection interface, e.g. IEnumerable<T> -
        //    An List<T> will be returned.
        // 5. type is a concrete type that implements IList -
        //    The type will be instantiated and returned.
        // Otherwise we throw InvalidOperationException.
        private static bool ConvertListToObject(IList list, Type type, JSerializer serializer, bool throwOnError, out IList convertedList)
        {

            // Add the items into an ArrayList then convert to custom type when
            // 1. Type is null or typeof(Object)
            // 2. Type is an Array, in which case we call ArrayList.ToArray(type) or
            // 3. Type is already an ArrayList
            if(type == null || type == typeof(Object) || IsArrayListCompatible(type))
            {
                Type elementType = typeof(Object);
                if(type != null && type != typeof(Object))
                {
                    elementType = type.GetElementType();
                }

                ArrayList newList = new ArrayList();

                // Add the items to the new List and recursive into each item.
                if(!AddItemToList(list, newList, elementType, serializer, throwOnError))
                {
                    convertedList = null;
                    return false;
                }

                if(type == typeof(ArrayList) || type == typeof(IEnumerable) || type == typeof(IList) || type == typeof(ICollection))
                {
                    convertedList = newList;
                    return true;
                }

                convertedList = newList.ToArray(elementType);
                return true;
            }
            // Add the items into an List<T> then convert to the custom generic type when
            // 1. Type is a generic collection type
            // 2. Type only has one generic parameter, eg. List<string> vs MyCustom<T, V>
            // 3. Type implements IEnumerable<T>
            else if(type.IsGenericType &&
                type.GetGenericArguments().Length == 1)
            {

                // gets the T of List<T> as the elementType
                Type elementType = type.GetGenericArguments()[0];

                // Get the strongly typed IEnumerable<T>
                Type strongTypedEnumerable = _enumerableGenericType.MakeGenericType(elementType);

                // Make sure the custom type can be assigned to IEnumerable<T>
                if(strongTypedEnumerable.IsAssignableFrom(type))
                {

                    // Get the strongly typed List<T>
                    Type t = _listGenericType.MakeGenericType(elementType);

                    // Create the List<T> instance or a MyList<T>
                    IList newList = null;
                    if(IsClientInstantiatableType(type, serializer) && typeof(IList).IsAssignableFrom(type))
                    {
                        newList = (IList)Activator.CreateInstance(type);
                    }
                    else {
                        // If this is MyList<T> and we can't assign to it, throw
                        if(t.IsAssignableFrom(type))
                        {
                            if(throwOnError)
                            {
                                throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture, AtlasWeb.JSON_CannotCreateListType, type.FullName));
                            }
                            else {
                                convertedList = null;
                                return false;
                            }
                        }
                        newList = (IList)Activator.CreateInstance(t);
                    }

                    // Add the items to the new List and recursive into each item.
                    if(!AddItemToList(list, newList, elementType, serializer, throwOnError))
                    {
                        convertedList = null;
                        return false;
                    }

                    convertedList = newList;
                    return true;
                }
            }
            // If the custom type implements IList and it's instantiable. Use that type.
            else if(IsClientInstantiatableType(type, serializer) && typeof(IList).IsAssignableFrom(type))
            {
                IList newList = (IList)Activator.CreateInstance(type);

                // Add the items to the new List and recursive into each item.
                if(!AddItemToList(list, newList, null, serializer, throwOnError))
                {
                    convertedList = null;
                    return false;
                }

                convertedList = newList;
                return true;
            }

            if(throwOnError)
            {
                throw new InvalidOperationException(String.Format(
                    CultureInfo.CurrentCulture, AtlasWeb.JSON_ArrayTypeNotSupported, type.FullName));
            }
            else {
                convertedList = null;
                return false;
            }
        }
Example #32
0
        // Helper method that converts the object to the corresponding type using converters.
        // Items in IDictionary<string, object> and ArrayList needs to be converted as well.
        // Note this method does not invoke the custom converter for deserialization.
        private static bool ConvertObjectToTypeInternal(object o, Type type, JSerializer serializer, bool throwOnError, out object convertedObject)
        {

            // First checks if the object is an IDictionary<string, object>
            IDictionary<string, object> dictionary = o as IDictionary<string, object>;
            if(dictionary != null)
            {
                return ConvertDictionaryToObject(dictionary, type, serializer, throwOnError, out convertedObject);
            }

            // If it is an IList try to convert it to the requested type.
            IList list = o as IList;
            if(list != null)
            {
                IList convertedList;
                if(ConvertListToObject(list, type, serializer, throwOnError, out convertedList))
                {
                    convertedObject = convertedList;
                    return true;
                }
                else {
                    convertedObject = null;
                    return false;
                }
            }

            // simply return the current object if
            // 1) the caller does not specify the return type.
            // 2) if the current type is same as return type.
            if(type == null || o.GetType() == type)
            {
                convertedObject = o;
                return true;
            }

            // Otherwise use the type converter to convert the string to the target type.
            TypeConverter converter = TypeDescriptor.GetConverter(type);

            // Use the memberType's converter to directly conver if supported.
            if(converter.CanConvertFrom(o.GetType()))
            {
                try
                {
                    convertedObject = converter.ConvertFrom(null, CultureInfo.InvariantCulture, o);
                    return true;
                }
                catch
                {
                    if(throwOnError)
                    {
                        throw;
                    }
                    else {
                        convertedObject = null;
                        return false;
                    }
                }
            }

            // Otherwise if the target type can be converted from a string
            // 1. first use the propertyValue's converter to convert object to string,
            // 2. then use the target converter to convert the string to target type.
            if(converter.CanConvertFrom(typeof(String)))
            {

                try
                {
                    string s;
                    if(o is DateTime)
                    {
                        // when converting from DateTime it is important to use the 'u' format
                        // so it contains the 'Z' indicating that it is UTC time.
                        // If converting to DateTimeOffset this ensures the value is correct, since otherwise
                        // the deafult offset would be assumed, which is the server's timezone.
                        s = ((DateTime)o).ToUniversalTime().ToString("u", CultureInfo.InvariantCulture);
                    }
                    else {
                        TypeConverter propertyConverter = TypeDescriptor.GetConverter(o);
                        s = propertyConverter.ConvertToInvariantString(o);
                    }
                    convertedObject = converter.ConvertFromInvariantString(s);
                    return true;
                }
                catch
                {
                    if(throwOnError)
                    {
                        throw;
                    }
                    else {
                        convertedObject = null;
                        return false;
                    }
                }
            }

            // We can't convert object o to the target type, but perhaps o can be
            // assigned directly to type?
            if(type.IsAssignableFrom(o.GetType()))
            {
                convertedObject = o;
                return true;
            }

            // Nothing works
            if(throwOnError)
            {
                throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, AtlasWeb.JSON_CannotConvertObjectToType, o.GetType(), type));
            }
            else {
                convertedObject = null;
                return false;
            }
        }