public static string Serialize(ReleaseChangeSet changeSet)
{
return(TypeSerializer.SerializeToString(changeSet));
}
public static string ToString(INameValueCollection nvc)
{
var map = ToDictionary(nvc);
return(TypeSerializer.SerializeToString(map));
}
public static GetMemberDelegate CreateTypeConverter(Type fromType, Type toType)
{
if (fromType == toType)
{
return(null);
}
var converter = AutoMappingUtils.GetConverter(fromType, toType);
if (converter != null)
{
return(converter);
}
if (fromType == typeof(string))
{
return(fromValue => TypeSerializer.DeserializeFromString((string)fromValue, toType));
}
if (toType == typeof(string))
{
return(o => TypeSerializer.SerializeToString(o).StripQuotes());
}
var underlyingToType = Nullable.GetUnderlyingType(toType) ?? toType;
var underlyingFromType = Nullable.GetUnderlyingType(fromType) ?? fromType;
if (underlyingToType.IsEnum)
{
if (underlyingFromType.IsEnum || fromType == typeof(string))
{
return(fromValue => Enum.Parse(underlyingToType, fromValue.ToString(), ignoreCase: true));
}
if (underlyingFromType.IsIntegerType())
{
return(fromValue => Enum.ToObject(underlyingToType, fromValue));
}
}
else if (underlyingFromType.IsEnum)
{
if (underlyingToType.IsIntegerType())
{
return(fromValue => Convert.ChangeType(fromValue, underlyingToType, null));
}
}
else if (typeof(IEnumerable).IsAssignableFrom(fromType))
{
return(fromValue =>
{
var listResult = TranslateListWithElements.TryTranslateCollections(
fromType, underlyingToType, fromValue);
return listResult ?? fromValue;
});
}
else if (underlyingToType.IsValueType)
{
return(fromValue => AutoMappingUtils.ChangeValueType(fromValue, underlyingToType));
}
else
{
return(fromValue =>
{
if (fromValue == null)
{
return fromValue;
}
var toValue = toType.CreateInstance();
toValue.PopulateWith(fromValue);
return toValue;
});
}
return(null);
}
public void DateTimeKind_Does_Not_Change_With_SkipDateTimeConversion_true()
{
JsConfig.DateHandler = DateHandler.ISO8601;
JsConfig.SkipDateTimeConversion = true;
string serilizedResult;
TestObject deserilizedResult;
var testObject = new TestObject
{
Date = new DateTime(2013, 1, 1, 0, 0, 1, DateTimeKind.Utc)
};
serilizedResult = TypeSerializer.SerializeToString <TestObject>(testObject);
deserilizedResult = TypeSerializer.DeserializeFromString <TestObject>(serilizedResult);
Assert.AreEqual(deserilizedResult.Date, testObject.Date);
Assert.AreEqual(DateTimeKind.Utc, deserilizedResult.Date.Kind);
using (JsConfig.With(skipDateTimeConversion: false))
{
Assert.AreEqual(DateTimeKind.Local, TypeSerializer.DeserializeFromString <TestObject>(TypeSerializer.SerializeToString <TestObject>(testObject)).Date.Kind);
}
testObject = new TestObject
{
Date = new DateTime(2013, 1, 1, 0, 0, 0, DateTimeKind.Utc)
};
serilizedResult = TypeSerializer.SerializeToString <TestObject>(testObject);
deserilizedResult = TypeSerializer.DeserializeFromString <TestObject>(serilizedResult);
Assert.AreEqual(deserilizedResult.Date, testObject.Date);
Assert.AreEqual(DateTimeKind.Utc, deserilizedResult.Date.Kind);
using (JsConfig.With(skipDateTimeConversion: false))
{
Assert.AreEqual(DateTimeKind.Local, TypeSerializer.DeserializeFromString <TestObject>(TypeSerializer.SerializeToString <TestObject>(testObject)).Date.Kind);
}
using (JsConfig.With(alwaysUseUtc: true, skipDateTimeConversion: false)) //It will work now
{
Assert.AreEqual(DateTimeKind.Utc, TypeSerializer.DeserializeFromString <TestObject>(TypeSerializer.SerializeToString <TestObject>(testObject)).Date.Kind);
}
//make sure it still keeps local local
testObject = new TestObject
{
Date = new DateTime(2013, 1, 2, 0, 2, 0, DateTimeKind.Local)
};
serilizedResult = TypeSerializer.SerializeToString <TestObject>(testObject);
deserilizedResult = TypeSerializer.DeserializeFromString <TestObject>(serilizedResult);
Assert.AreEqual(deserilizedResult.Date, testObject.Date);
Assert.AreEqual(DateTimeKind.Local, deserilizedResult.Date.Kind);
using (JsConfig.With(alwaysUseUtc: true))
{
Assert.AreEqual(DateTimeKind.Local, TypeSerializer.DeserializeFromString <TestObject>(TypeSerializer.SerializeToString <TestObject>(testObject)).Date.Kind);
}
using (JsConfig.With(alwaysUseUtc: true, skipDateTimeConversion: false))
{
Assert.AreEqual(DateTimeKind.Utc, TypeSerializer.DeserializeFromString <TestObject>(TypeSerializer.SerializeToString <TestObject>(testObject)).Date.Kind);
}
testObject = new TestObject
{
Date = new DateTime(2013, 1, 2, 0, 2, 0, DateTimeKind.Unspecified)
};
serilizedResult = TypeSerializer.SerializeToString <TestObject>(testObject);
deserilizedResult = TypeSerializer.DeserializeFromString <TestObject>(serilizedResult);
Assert.AreEqual(deserilizedResult.Date, testObject.Date);
Assert.AreEqual(DateTimeKind.Unspecified, deserilizedResult.Date.Kind);
using (JsConfig.With(alwaysUseUtc: true))
{
Assert.AreEqual(DateTimeKind.Unspecified, TypeSerializer.DeserializeFromString <TestObject>(TypeSerializer.SerializeToString <TestObject>(testObject)).Date.Kind);
}
using (JsConfig.With(alwaysUseUtc: true, skipDateTimeConversion: false))
{
Assert.AreEqual(DateTimeKind.Utc, TypeSerializer.DeserializeFromString <TestObject>(TypeSerializer.SerializeToString <TestObject>(testObject)).Date.Kind);
}
using (JsConfig.With(skipDateTimeConversion: false))
{
serilizedResult = TypeSerializer.SerializeToString <TestObject>(testObject);
deserilizedResult = TypeSerializer.DeserializeFromString <TestObject>(serilizedResult);
Assert.AreEqual(DateTimeKind.Local, deserilizedResult.Date.Kind);
}
}
public void Populate(object to, object from,
Func <PropertyInfo, bool> propertyInfoPredicate,
Func <object, Type, bool> valuePredicate)
{
foreach (var assignmentEntry in AssignmentMemberMap)
{
var assignmentMember = assignmentEntry.Value;
var fromMember = assignmentEntry.Value.From;
var toMember = assignmentEntry.Value.To;
if (fromMember.PropertyInfo != null && propertyInfoPredicate != null)
{
if (!propertyInfoPredicate(fromMember.PropertyInfo))
{
continue;
}
}
try
{
var fromValue = assignmentMember.GetValueFn(from);
if (valuePredicate != null)
{
if (!valuePredicate(fromValue, fromMember.PropertyInfo.PropertyType))
{
continue;
}
}
if (fromMember.Type != toMember.Type)
{
if (fromMember.Type == typeof(string))
{
fromValue = TypeSerializer.DeserializeFromString((string)fromValue, toMember.Type);
}
else if (toMember.Type == typeof(string))
{
fromValue = TypeSerializer.SerializeToString(fromValue);
}
else if (toMember.Type.IsGeneric() &&
toMember.Type.GenericTypeDefinition() == typeof(Nullable <>))
{
Type genericArg = toMember.Type.GenericTypeArguments()[0];
if (genericArg.IsEnum())
{
fromValue = Enum.ToObject(genericArg, fromValue);
}
}
else
{
var listResult = TranslateListWithElements.TryTranslateToGenericICollection(
fromMember.Type, toMember.Type, fromValue);
if (listResult != null)
{
fromValue = listResult;
}
}
}
var setterFn = assignmentMember.SetValueFn;
setterFn(to, fromValue);
}
catch (Exception ex)
{
Log.Warn(string.Format("Error trying to set properties {0}.{1} > {2}.{3}",
FromType.FullName, fromMember.Type.Name,
ToType.FullName, toMember.Type.Name), ex);
}
}
}
public void ProcessRequest(HttpContext context)
{
var request = context.Request;
var response = context.Response;
var httpReq = new HttpRequestWrapper("NotFoundHttpHandler", request);
if (!request.IsLocal)
{
ProcessRequest(httpReq, new HttpResponseWrapper(response), null);
return;
}
Log.ErrorFormat("{0} Request not found: {1}", request.UserHostAddress, request.RawUrl);
var sb = new StringBuilder();
sb.AppendLine("Handler for Request not found: \n\n");
sb.AppendLine("Request.ApplicationPath: " + request.ApplicationPath);
sb.AppendLine("Request.CurrentExecutionFilePath: " + request.CurrentExecutionFilePath);
sb.AppendLine("Request.FilePath: " + request.FilePath);
sb.AppendLine("Request.HttpMethod: " + request.HttpMethod);
sb.AppendLine("Request.MapPath('~'): " + request.MapPath("~"));
sb.AppendLine("Request.Path: " + request.Path);
sb.AppendLine("Request.PathInfo: " + request.PathInfo);
sb.AppendLine("Request.ResolvedPathInfo: " + httpReq.PathInfo);
sb.AppendLine("Request.PhysicalPath: " + request.PhysicalPath);
sb.AppendLine("Request.PhysicalApplicationPath: " + request.PhysicalApplicationPath);
sb.AppendLine("Request.QueryString: " + request.QueryString);
sb.AppendLine("Request.RawUrl: " + request.RawUrl);
try
{
sb.AppendLine("Request.Url.AbsoluteUri: " + request.Url.AbsoluteUri);
sb.AppendLine("Request.Url.AbsolutePath: " + request.Url.AbsolutePath);
sb.AppendLine("Request.Url.Fragment: " + request.Url.Fragment);
sb.AppendLine("Request.Url.Host: " + request.Url.Host);
sb.AppendLine("Request.Url.LocalPath: " + request.Url.LocalPath);
sb.AppendLine("Request.Url.Port: " + request.Url.Port);
sb.AppendLine("Request.Url.Query: " + request.Url.Query);
sb.AppendLine("Request.Url.Scheme: " + request.Url.Scheme);
sb.AppendLine("Request.Url.Segments: " + request.Url.Segments);
}
catch (Exception ex)
{
sb.AppendLine("Request.Url ERROR: " + ex.Message);
}
if (IsIntegratedPipeline.HasValue)
{
sb.AppendLine("App.IsIntegratedPipeline: " + IsIntegratedPipeline);
}
if (!WebHostPhysicalPath.IsNullOrEmpty())
{
sb.AppendLine("App.WebHostPhysicalPath: " + WebHostPhysicalPath);
}
if (!WebHostRootFileNames.IsEmpty())
{
sb.AppendLine("App.WebHostRootFileNames: " + TypeSerializer.SerializeToString(WebHostRootFileNames));
}
if (!ApplicationBaseUrl.IsNullOrEmpty())
{
sb.AppendLine("App.ApplicationBaseUrl: " + ApplicationBaseUrl);
}
if (!DefaultRootFileName.IsNullOrEmpty())
{
sb.AppendLine("App.DefaultRootFileName: " + DefaultRootFileName);
}
if (!DefaultHandler.IsNullOrEmpty())
{
sb.AppendLine("App.DefaultHandler: " + DefaultHandler);
}
if (!ServiceStackHttpHandlerFactory.DebugLastHandlerArgs.IsNullOrEmpty())
{
sb.AppendLine("App.DebugLastHandlerArgs: " + ServiceStackHttpHandlerFactory.DebugLastHandlerArgs);
}
response.ContentType = "text/plain";
response.StatusCode = 404;
response.Write(sb.ToString());
//Apache+mod_mono doesn't like this
//response.OutputStream.Flush();
//response.Close();
}
public void DeleteRelatedEntity <TChild>(object parentId, object childId)
{
var childRefKey = GetChildReferenceSetKey <TChild>(parentId);
client.RemoveItemFromSet(childRefKey, TypeSerializer.SerializeToString(childId));
}
public static void LogRequest(this IHttpResponse response, IHttpRequest request, int?statusCode = null)
{
try
{
if (!EndpointHost.Config.MetadataMap[request.ServicePath].LogCommonRequestInfo)
{
return;
}
Dictionary <string, string> additionalInfo = new Dictionary <string, string>()
{
{ "ClientIP", request.RemoteIp },
{ "AbsolutePath", request.GetAbsolutePath() },
{ "HostAddress", request.GetUrlHostName() },
{ "ResponseStatus", (statusCode ?? (response.StatusCode <= 0 ? 200 : response.StatusCode)).ToString() }
};
string requestType = EndpointHost.Config.MetadataMap[request.ServicePath].FullServiceName;
if (!string.IsNullOrWhiteSpace(request.OperationName))
{
requestType += "." + request.OperationName;
}
additionalInfo["RequestType"] = requestType;
string appId = request.Headers[ServiceUtils.AppIdHttpHeaderKey];
if (!string.IsNullOrWhiteSpace(appId))
{
additionalInfo["ClientAppId"] = appId;
}
if (request.RequestObject != null && request.RequestObject is IHasMobileRequestHead)
{
IHasMobileRequestHead h5Request = request.RequestObject as IHasMobileRequestHead;
if (h5Request.head != null)
{
Dictionary <string, string> extension = null;
if (EndpointHost.Config.MetadataMap[request.ServicePath].LogH5HeadExtensionData)
{
extension = new Dictionary <string, string>();
foreach (ExtensionFieldType item in h5Request.head.extension)
{
if (!string.IsNullOrWhiteSpace(item.name) &&
item.name != ServiceUtils.MobileUserIdExtensionKey && item.name != ServiceUtils.MobileAuthTokenExtensionKey)
{
extension[item.name] = item.value;
}
}
if (extension.Count == 0)
{
extension = null;
}
}
additionalInfo["H5Head"] = TypeSerializer.SerializeToString(
new
{
ClientID = h5Request.head.cid,
ClientToken = h5Request.head.ctok,
ClientVersion = h5Request.head.cver,
SystemCode = h5Request.head.syscode,
SourceID = h5Request.head.sid,
Language = h5Request.head.lang,
Extension = extension
});
}
}
}
catch { }
}
/// <summary>Runs this object.</summary>
public override void Run()
{
TypeSerializer.SerializeToString(customer);
}
internal static void LogError(string title, IHttpRequest httpRequest, Exception ex, string errorCode, LogLevel logLevel)
{
if (httpRequest == null)
{
return;
}
ServiceMetadata metadata = EndpointHost.Config.MetadataMap[httpRequest.ServicePath];
Dictionary <string, string> additionalExceptionInfo = new Dictionary <string, string>()
{
{ "Operation", metadata.FullServiceName + "." + httpRequest.OperationName }
};
string clientAppId = httpRequest.GetClientAppId();
if (!string.IsNullOrWhiteSpace(clientAppId))
{
additionalExceptionInfo.Add("ClientAppId", clientAppId);
}
if (!string.IsNullOrWhiteSpace(errorCode))
{
additionalExceptionInfo.Add("ErrorCode", errorCode);
}
if (metadata.LogErrorWithRequestInfo)
{
try
{
try
{
var requestInfo = RequestInfoHandler.GetRequestInfo(httpRequest);
additionalExceptionInfo["RequestInfo"] = TypeSerializer.SerializeToString(requestInfo);
}
catch
{
Dictionary <string, string> requestInfo = new Dictionary <string, string>()
{
{ "Url", httpRequest.RawUrl },
{ "PathInfo", httpRequest.PathInfo },
{ "QueryString", TypeSerializer.SerializeToString(httpRequest.QueryString) },
{ "Headers", TypeSerializer.SerializeToString(httpRequest.Headers) },
{ "FormData", TypeSerializer.SerializeToString(httpRequest.FormData) }
};
additionalExceptionInfo["RequestInfo"] = TypeSerializer.SerializeToString(requestInfo);
}
}
catch
{
}
if (httpRequest.RequestObject != null && !(httpRequest.RequestObject is RequestInfoResponse))
{
additionalExceptionInfo["RequestObject"] = TypeSerializer.SerializeToString(httpRequest.RequestObject);
}
}
switch (logLevel)
{
case LogLevel.DEBUG:
if (ex != null)
{
Log.Error(title, ex, additionalExceptionInfo);
}
else
{
Log.Error(title, string.Empty, additionalExceptionInfo);
}
break;
case LogLevel.INFO:
if (ex != null)
{
Log.Info(title, ex, additionalExceptionInfo);
}
else
{
Log.Info(title, string.Empty, additionalExceptionInfo);
}
break;
case LogLevel.WARN:
if (ex != null)
{
Log.Warn(title, ex, additionalExceptionInfo);
}
else
{
Log.Warn(title, string.Empty, additionalExceptionInfo);
}
break;
case LogLevel.ERROR:
if (ex != null)
{
Log.Error(title, ex, additionalExceptionInfo);
}
else
{
Log.Error(title, string.Empty, additionalExceptionInfo);
}
break;
case LogLevel.FATAL:
if (ex != null)
{
Log.Fatal(title, ex, additionalExceptionInfo);
}
else
{
Log.Fatal(title, string.Empty, additionalExceptionInfo);
}
break;
}
}
internal static void LogError(string title, IHttpRequest httpRequest, ResponseStatusType responseStatus, string errorCode, LogLevel logLevel)
{
if (httpRequest == null)
{
return;
}
ServiceMetadata metadata = EndpointHost.Config.MetadataMap[httpRequest.ServicePath];
Dictionary <string, string> additionalExceptionInfo = new Dictionary <string, string>()
{
{ "Version", ServiceUtils.SOA2VersionCatName },
{ "Operation", metadata.FullServiceName + "." + httpRequest.OperationName }
};
string clientAppId = httpRequest.GetClientAppId();
if (!string.IsNullOrWhiteSpace(clientAppId))
{
additionalExceptionInfo.Add("ClientAppId", clientAppId);
}
if (!string.IsNullOrWhiteSpace(errorCode))
{
additionalExceptionInfo.Add("ErrorCode", errorCode);
}
if (metadata.LogErrorWithRequestInfo)
{
try
{
try
{
var requestInfo = RequestInfoHandler.GetRequestInfo(httpRequest);
additionalExceptionInfo["RequestInfo"] = TypeSerializer.SerializeToString(requestInfo);
}
catch
{
Dictionary <string, string> requestInfo = new Dictionary <string, string>()
{
{ "Url", httpRequest.RawUrl },
{ "PathInfo", httpRequest.PathInfo },
{ "QueryString", TypeSerializer.SerializeToString(httpRequest.QueryString) },
{ "Headers", TypeSerializer.SerializeToString(httpRequest.Headers) },
{ "FormData", TypeSerializer.SerializeToString(httpRequest.FormData) }
};
additionalExceptionInfo["RequestInfo"] = TypeSerializer.SerializeToString(requestInfo);
}
}
catch
{
}
if (httpRequest.RequestObject != null && !(httpRequest.RequestObject is RequestInfoResponse))
{
additionalExceptionInfo["RequestObject"] = TypeSerializer.SerializeToString(httpRequest.RequestObject);
}
}
string message = string.Empty;
if (responseStatus != null)
{
additionalExceptionInfo["ResponseStatus"] = TypeSerializer.SerializeToString(responseStatus);
if (responseStatus.Errors != null && responseStatus.Errors.Count > 0 && responseStatus.Errors[0] != null)
{
message = string.Format("ErrorCode: {0}, Message: {1}", responseStatus.Errors[0].ErrorCode, responseStatus.Errors[0].Message);
}
}
switch (logLevel)
{
case LogLevel.DEBUG:
Log.Debug(title, message, additionalExceptionInfo);
break;
case LogLevel.INFO:
Log.Info(title, message, additionalExceptionInfo);
break;
case LogLevel.WARN:
Log.Warn(title, message, additionalExceptionInfo);
break;
case LogLevel.ERROR:
Log.Error(title, message, additionalExceptionInfo);
break;
case LogLevel.FATAL:
Log.Fatal(title, message, additionalExceptionInfo);
break;
}
}
public void Populate(object to, object from,
Func <PropertyInfo, bool> propertyInfoPredicate,
Func <object, bool> valuePredicate)
{
foreach (var propertyEntry in PropertyInfoMap)
{
var fromPropertyInfo = propertyEntry.Key;
var toPropertyInfo = propertyEntry.Value;
if (propertyInfoPredicate != null)
{
if (!propertyInfoPredicate(fromPropertyInfo))
{
continue;
}
}
try
{
var fromValue = fromPropertyInfo.GetValue(from, new object[] { });
if (valuePredicate != null)
{
if (!valuePredicate(fromValue))
{
continue;
}
}
if (fromPropertyInfo.PropertyType != toPropertyInfo.PropertyType)
{
if (fromPropertyInfo.PropertyType == typeof(string))
{
fromValue = TypeSerializer.DeserializeFromString((string)fromValue,
toPropertyInfo.PropertyType);
}
else if (toPropertyInfo.PropertyType == typeof(string))
{
fromValue = TypeSerializer.SerializeToString(fromValue);
}
else
{
var listResult = TranslateListWithElements.TryTranslateToGenericICollection(
fromPropertyInfo.PropertyType, toPropertyInfo.PropertyType, fromValue);
if (listResult != null)
{
fromValue = listResult;
}
}
}
var toSetMetodInfo = toPropertyInfo.GetSetMethod();
toSetMetodInfo.Invoke(to, new[] { fromValue });
}
catch (Exception ex)
{
Log.Error(string.Format("Error trying to set properties {0}.{1} > {2}.{3}",
FromType.FullName, fromPropertyInfo.Name,
ToType.FullName, toPropertyInfo.Name), ex);
}
}
foreach (var fieldEntry in FieldInfoMap)
{
var fromFieldInfo = fieldEntry.Key;
var toFieldInfo = fieldEntry.Value;
try
{
var fromValue = fromFieldInfo.GetValue(from);
toFieldInfo.SetValue(to, fromValue);
}
catch (Exception ex)
{
Log.Error(string.Format("Error trying to set fields {0}.{1} > {2}.{3}",
FromType.FullName, fromFieldInfo.Name,
ToType.FullName, toFieldInfo.Name), ex);
}
}
}
public static string GenerateHash(this object obj)
{
using var md5Hash = MD5.Create();
return(GetMd5Hash(md5Hash, TypeSerializer.SerializeToString(obj)));
}
public static bool VerifyMd5Hash(this object obj, string hash)
{
using var md5Hash = MD5.Create();
return(0 == StringComparer.OrdinalIgnoreCase.Compare(GetMd5Hash(md5Hash, TypeSerializer.SerializeToString(obj)), hash));
}
public static ResponseStatus CreateResponseStatus(Exception ex, object request = null, bool debugMode = false)
{
var e = ex.UnwrapIfSingleException();
var responseStatus = (e is IResponseStatusConvertible customStatus
? customStatus.ToResponseStatus()
: null) ?? ResponseStatusUtils.CreateResponseStatus(e.GetType().Name, e.Message);
if (responseStatus == null)
{
return(null);
}
if (debugMode)
{
#if !NETSTANDARD2_0
if (ex is System.Web.HttpCompileException compileEx && compileEx.Results.Errors.HasErrors)
{
responseStatus.Errors ??= new List <ResponseError>();
foreach (var err in compileEx.Results.Errors)
{
responseStatus.Errors.Add(new ResponseError {
Message = err.ToString()
});
}
}
#endif
// View stack trace in tests and on the client
var sb = StringBuilderCache.Allocate();
if (request != null)
{
try
{
var str = $"[{request.GetType().GetOperationName()}: {DateTime.UtcNow}]:\n[REQUEST: {TypeSerializer.SerializeToString(request)}]";
sb.AppendLine(str);
}
catch (Exception requestEx)
{
sb.AppendLine($"[{request.GetType().GetOperationName()}: {DateTime.UtcNow}]:\n[REQUEST: {requestEx.Message}]");
}
}
sb.AppendLine(e.ToString());
var innerMessages = new List <string>();
var innerEx = e.InnerException;
while (innerEx != null)
{
sb.AppendLine("");
sb.AppendLine(innerEx.ToString());
innerMessages.Add(innerEx.Message);
innerEx = innerEx.InnerException;
}
responseStatus.StackTrace = StringBuilderCache.ReturnAndFree(sb);
if (innerMessages.Count > 0)
{
responseStatus.Meta ??= new Dictionary <string, string>();
responseStatus.Meta["InnerMessages"] = innerMessages.Join("\n");
}
}
return(responseStatus);
}
protected void SerializeDto <T>(T dto)
{
TestResults = new List <SerializersBenchmarkEntry>();
FixtureTestResults.Add(TestResults);
this.ModelName = typeof(T).IsGenericType &&
typeof(T).GetGenericTypeDefinition() == typeof(List <>)
? typeof(T).GetGenericArguments()[0].Name
: typeof(T).Name;
if (!OnlyRunServiceStackSerializers)
{
var dtoMsXml = DataContractSerializer.Instance.Parse(dto);
RecordRunResults("Microsoft DataContractSerializer", dtoMsXml,
() => DataContractSerializer.Instance.Parse(dto),
() => DataContractDeserializer.Instance.Parse <T>(dtoMsXml)
);
var dtoMsJson = JsonDataContractSerializer.Instance.Parse(dto);
RecordRunResults("Microsoft JsonDataContractSerializer", dtoMsJson,
() => JsonDataContractSerializer.Instance.Parse(dto),
() => JsonDataContractDeserializer.Instance.Parse <T>(dtoMsJson)
);
if (this.MultipleIterations.Sum() <= 10)
{
//To slow to include, up to 280x slower than ProtoBuf
var js = new JavaScriptSerializer();
var dtoJs = js.Serialize(dto);
RecordRunResults("Microsoft JavaScriptSerializer", dtoJs,
() => js.Serialize(dto),
() => js.Deserialize <T>(dtoJs)
);
//Can't import complex types, e.g. Lists, etc
//var jayRockString = Jayrock.Json.Conversion.JsonConvert.ExportToString(dto);
//RecordRunResults("JayRock JsonConvert", jayRockString,
// () => Jayrock.Json.Conversion.JsonConvert.ExportToString(dto),
// () => Jayrock.Json.Conversion.JsonConvert.Import(typeof(T), jayRockString)
//);
}
var msBytes = BinaryFormatterSerializer.Instance.Serialize(dto);
RecordRunResults("Microsoft BinaryFormatter", msBytes,
() => BinaryFormatterSerializer.Instance.Serialize(dto),
() => BinaryFormatterDeserializer.Instance.Deserialize <T>(msBytes)
);
var dtoJsonNet = JsonConvert.SerializeObject(dto);
RecordRunResults("NewtonSoft.Json", dtoJsonNet,
() => JsonConvert.SerializeObject(dto),
() => JsonConvert.DeserializeObject <T>(dtoJsonNet)
);
//var dtoLitJson = JsonMapper.ToJson(dto);
//RecordRunResults("LitJson", dtoJsonNet,
// () => JsonMapper.ToJson(dto),
// () => JsonMapper.ToObject<T>(dtoLitJson)
//);
var dtoProtoBuf = ProtoBufToBytes(dto);
RecordRunResults("ProtoBuf.net", dtoProtoBuf,
() => ProtoBufToBytes(dto),
() => ProtoBufFromBytes <T>(dtoProtoBuf)
);
}
var dtoJsv = TypeSerializer.SerializeToString(dto);
RecordRunResults("ServiceStack TypeSerializer", dtoJsv,
() => TypeSerializer.SerializeToString(dto),
() => TypeSerializer.DeserializeFromString <T>(dtoJsv)
);
var dtoJson = ServiceStack.Text.JsonSerializer.SerializeToString(dto);
RecordRunResults("ServiceStack JsonSerializer", dtoJson,
() => ServiceStack.Text.JsonSerializer.SerializeToString(dto),
() => ServiceStack.Text.JsonSerializer.DeserializeFromString <T>(dtoJson)
);
//Propietary library, not freely available.
//var dtoPlatformText = TextSerializer.SerializeToString(dto);
//RecordRunResults("Platform TextSerializer", dtoPlatformText,
// () => TextSerializer.SerializeToString(dto),
// () => TextSerializer.DeserializeFromString<T>(dtoPlatformText)
//);
CalculateBestTimes(TestResults);
}
public string SerializeToString <TFrom>(TFrom @from)
{
return(TypeSerializer.SerializeToString(@from));
}
public void Populate(object to, object from,
Func <PropertyInfo, bool> propertyInfoPredicate,
Func <object, bool> valuePredicate)
{
foreach (var propertyEntry in PropertyInfoMap)
{
var fromPropertyInfo = propertyEntry.Key;
var toPropertyInfo = propertyEntry.Value;
if (propertyInfoPredicate != null)
{
if (!propertyInfoPredicate(fromPropertyInfo))
{
continue;
}
}
try
{
var getterFn = PropertyGetters.GetOrAdd(fromPropertyInfo.Name,
fromPropertyInfo.GetPropertyGetterFn());
var fromValue = getterFn(from);
if (valuePredicate != null)
{
if (!valuePredicate(fromValue))
{
continue;
}
}
if (fromPropertyInfo.PropertyType != toPropertyInfo.PropertyType)
{
if (fromPropertyInfo.PropertyType == typeof(string))
{
fromValue = TypeSerializer.DeserializeFromString((string)fromValue,
toPropertyInfo.PropertyType);
}
else if (toPropertyInfo.PropertyType == typeof(string))
{
fromValue = TypeSerializer.SerializeToString(fromValue);
}
else if (toPropertyInfo.PropertyType.IsGenericType &&
toPropertyInfo.PropertyType.GetGenericTypeDefinition() == typeof(Nullable <>))
{
Type genericArg = toPropertyInfo.PropertyType.GetGenericArguments()[0];
if (genericArg.IsEnum)
{
fromValue = Enum.ToObject(genericArg, fromValue);
}
}
else
{
var listResult = TranslateListWithElements.TryTranslateToGenericICollection(
fromPropertyInfo.PropertyType, toPropertyInfo.PropertyType, fromValue);
if (listResult != null)
{
fromValue = listResult;
}
}
}
var setterFn = PropertySetters.GetOrAdd(toPropertyInfo.Name,
toPropertyInfo.GetPropertySetterFn());
setterFn(to, fromValue);
}
catch (Exception ex)
{
Log.Warn(string.Format("Error trying to set properties {0}.{1} > {2}.{3}",
FromType.FullName, fromPropertyInfo.Name,
ToType.FullName, toPropertyInfo.Name), ex);
}
}
foreach (var fieldEntry in FieldInfoMap)
{
var fromFieldInfo = fieldEntry.Key;
var toFieldInfo = fieldEntry.Value;
try
{
var fromValue = fromFieldInfo.GetValue(from);
toFieldInfo.SetValue(to, fromValue);
}
catch (Exception ex)
{
Log.Warn(string.Format("Error trying to set fields {0}.{1} > {2}.{3}",
FromType.FullName, fromFieldInfo.Name,
ToType.FullName, toFieldInfo.Name), ex);
}
}
}
public override void ProcessRequest(HttpContextBase context)
{
var request = context.Request;
var response = context.Response;
var httpReq = context.ToRequest(GetType().GetOperationName());
if (!request.IsLocal)
{
ProcessRequestAsync(httpReq, httpReq.Response, null);
return;
}
Log.ErrorFormat("{0} Request not found: {1}", request.UserHostAddress, request.RawUrl);
var sb = new StringBuilder();
sb.AppendLine("Handler for Request not found: \n\n");
sb.AppendLine("Request.ApplicationPath: " + request.ApplicationPath);
sb.AppendLine("Request.CurrentExecutionFilePath: " + request.CurrentExecutionFilePath);
sb.AppendLine("Request.FilePath: " + request.FilePath);
sb.AppendLine("Request.HttpMethod: " + request.HttpMethod);
sb.AppendLine("Request.MapPath('~'): " + request.MapPath("~"));
sb.AppendLine("Request.Path: " + request.Path);
sb.AppendLine("Request.PathInfo: " + request.PathInfo);
sb.AppendLine("Request.ResolvedPathInfo: " + httpReq.PathInfo);
sb.AppendLine("Request.PhysicalPath: " + request.PhysicalPath);
sb.AppendLine("Request.PhysicalApplicationPath: " + request.PhysicalApplicationPath);
sb.AppendLine("Request.QueryString: " + request.QueryString);
sb.AppendLine("Request.RawUrl: " + request.RawUrl);
try
{
sb.AppendLine("Request.Url.AbsoluteUri: " + request.Url.AbsoluteUri);
sb.AppendLine("Request.Url.AbsolutePath: " + request.Url.AbsolutePath);
sb.AppendLine("Request.Url.Fragment: " + request.Url.Fragment);
sb.AppendLine("Request.Url.Host: " + request.Url.Host);
sb.AppendLine("Request.Url.LocalPath: " + request.Url.LocalPath);
sb.AppendLine("Request.Url.Port: " + request.Url.Port);
sb.AppendLine("Request.Url.Query: " + request.Url.Query);
sb.AppendLine("Request.Url.Scheme: " + request.Url.Scheme);
sb.AppendLine("Request.Url.Segments: " + request.Url.Segments);
}
catch (Exception ex)
{
sb.AppendLine("Request.Url ERROR: " + ex.Message);
}
if (IsIntegratedPipeline.HasValue)
{
sb.AppendLine("App.IsIntegratedPipeline: " + IsIntegratedPipeline);
}
if (!WebHostPhysicalPath.IsNullOrEmpty())
{
sb.AppendLine("App.WebHostPhysicalPath: " + WebHostPhysicalPath);
}
if (!WebHostRootFileNames.IsEmpty())
{
sb.AppendLine("App.WebHostRootFileNames: " + TypeSerializer.SerializeToString(WebHostRootFileNames));
}
if (!WebHostUrl.IsNullOrEmpty())
{
sb.AppendLine("App.ApplicationBaseUrl: " + WebHostUrl);
}
if (!DefaultRootFileName.IsNullOrEmpty())
{
sb.AppendLine("App.DefaultRootFileName: " + DefaultRootFileName);
}
if (!DefaultHandler.IsNullOrEmpty())
{
sb.AppendLine("App.DefaultHandler: " + DefaultHandler);
}
if (!HttpHandlerFactory.DebugLastHandlerArgs.IsNullOrEmpty())
{
sb.AppendLine("App.DebugLastHandlerArgs: " + HttpHandlerFactory.DebugLastHandlerArgs);
}
response.ContentType = "text/plain";
response.StatusCode = 404;
response.EndHttpHandlerRequest(skipClose: true, afterHeaders: r => r.Write(sb.ToString()));
}
public string SerializeToString(IRequest req, object response)
{
var contentType = req.ResponseContentType;
StreamSerializerDelegate responseStreamWriter;
if (this.ContentTypeSerializers.TryGetValue(contentType, out responseStreamWriter) ||
this.ContentTypeSerializers.TryGetValue(ContentFormat.GetRealContentType(contentType), out responseStreamWriter))
{
using (var ms = new MemoryStream())
{
responseStreamWriter(req, response, ms);
ms.Position = 0;
var result = new StreamReader(ms, UTF8EncodingWithoutBom).ReadToEnd();
return(result);
}
}
ResponseSerializerDelegate responseWriter;
if (this.ContentTypeResponseSerializers.TryGetValue(contentType, out responseWriter) ||
this.ContentTypeResponseSerializers.TryGetValue(ContentFormat.GetRealContentType(contentType), out responseWriter))
{
using (var ms = new MemoryStream())
{
var httpRes = new HttpResponseStreamWrapper(ms)
{
KeepOpen = true, //Don't let view engines close the OutputStream
};
responseWriter(req, response, httpRes);
var bytes = ms.ToArray();
var result = bytes.FromUtf8Bytes();
httpRes.ForceClose(); //Manually close the OutputStream
return(result);
}
}
var contentTypeAttr = ContentFormat.GetEndpointAttributes(contentType);
switch (contentTypeAttr)
{
case RequestAttributes.Xml:
return(XmlSerializer.SerializeToString(response));
case RequestAttributes.Json:
return(JsonDataContractSerializer.Instance.SerializeToString(response));
case RequestAttributes.Jsv:
return(TypeSerializer.SerializeToString(response));
case RequestAttributes.Soap11:
return(SoapHandler.SerializeSoap11ToBytes(req, response).FromUtf8Bytes());
case RequestAttributes.Soap12:
return(SoapHandler.SerializeSoap12ToBytes(req, response).FromUtf8Bytes());
}
throw new NotSupportedException("ContentType not supported: " + contentType);
}
public static string ToJsv <T>(this T obj)
{
return(TypeSerializer.SerializeToString(obj));
}
public void JsvSerializerHonorsIgnoreMemberAttribute()
{
DoIgnoreMemberTest(r => TypeSerializer.SerializeToString(r),
s => TypeSerializer.DeserializeFromString <RequestWithIgnoredMembers>(s));
}
public void DateTime_Is_Serialized_As_Utc_and_Deserialized_as_local()
{
var testObject = new TestObject
{
Date = new DateTime(2013, 1, 1, 0, 0, 1, DateTimeKind.Utc)
};
Assert.AreEqual(DateTimeKind.Local, TypeSerializer.DeserializeFromString <TestObject>(TypeSerializer.SerializeToString <TestObject>(testObject)).Date.Kind);
//Can change default behavior with config
using (JsConfig.With(alwaysUseUtc: true))
{
Assert.AreEqual(DateTimeKind.Utc, TypeSerializer.DeserializeFromString <TestObject>(TypeSerializer.SerializeToString <TestObject>(testObject)).Date.Kind);
}
testObject = new TestObject
{
Date = new DateTime(2013, 1, 1, 0, 0, 0, DateTimeKind.Utc)
};
Assert.AreEqual(DateTimeKind.Local, TypeSerializer.DeserializeFromString <TestObject>(TypeSerializer.SerializeToString <TestObject>(testObject)).Date.Kind);
//Can change default behavior with config
using (JsConfig.With(alwaysUseUtc: true))
{
Assert.AreEqual(DateTimeKind.Utc, TypeSerializer.DeserializeFromString <TestObject>(TypeSerializer.SerializeToString <TestObject>(testObject)).Date.Kind);
}
}
public static string CoerceString(object o)
{
return TypeSerializer.SerializeToString(o);
}
public void onBeforeTestFixture()
{
var results = 100.Times(x => ModelWithFieldsOfDifferentTypes.Create(x));
testData = TypeSerializer.SerializeToString(results);
}
public string BuildSerialisedString()
{
return(TypeSerializer.SerializeToString(this));
}
public void onBeforeTestFixture()
{
NorthwindData.LoadData(false);
testData = TypeSerializer.SerializeToString(NorthwindData.Customers);
}
private TResponse Invoke <TResponse>(ClientExecutionContext context)
{
Stopwatch stopwatch = null;
Stopwatch remoteCallStopwatch = null;
try
{
stopwatch = new Stopwatch();
stopwatch.Start();
ApplyRequestFilters(ServiceName, ServiceNamespace, context.Operation, context.Request);
HttpWebRequest webRequest = PrepareWebRequest(context);
remoteCallStopwatch = new Stopwatch();
remoteCallStopwatch.Start();
TResponse response;
using (WebResponse webResponse = Invoke(context, webRequest))
{
remoteCallStopwatch.Stop();
context.Metrics.ResponseSize = webResponse.ContentLength < 0 ? 0 : webResponse.ContentLength;
response = HandleResponse <TResponse>(context, webResponse);
}
ApplyResponseFilters(ServiceName, ServiceNamespace, context.Operation, context.Response);
context.IsSuccess = true;
return(response);
}
catch (CServiceException cex)
{
Dictionary <string, string> additionalInfo = GetClientInfo(context);
additionalInfo["ErrorCode"] = "FXD301004";
if (LogErrorWithRequestInfo)
{
additionalInfo["RequestObject"] = TypeSerializer.SerializeToString(context.Request);
}
LogCServiceException(GetLogTitle(InternalServiceUtils.ServiceErrorTitle), cex, additionalInfo);
throw;
}
catch (WebException ex)
{
WebException subClassedException = HandleWebException(context, (WebException)ex);
LogGeneralException(context, subClassedException);
if (ex == subClassedException)
{
throw;
}
throw subClassedException;
}
catch (Exception ex)
{
LogGeneralException(context, ex);
throw;
}
finally
{
if (remoteCallStopwatch != null)
{
if (remoteCallStopwatch.IsRunning)
{
remoteCallStopwatch.Stop();
}
context.Metrics.ExecutionTime = remoteCallStopwatch.ElapsedMilliseconds;
}
stopwatch.Stop();
context.Metrics.TotalTime = stopwatch.ElapsedMilliseconds;
ResetCurrentRequestTimeoutSetting();
}
}