/// <summary> /// This API supports the Entity Framework Core infrastructure and is not intended to be used /// directly from your code. This API may change or be removed in future releases. /// </summary> protected override Expression VisitMethodCall(MethodCallExpression node) { var newExpression = (MethodCallExpression)base.VisitMethodCall(node); _queryModelVisitor.BindMethodCallExpression( node, (property, querySource) => { if (querySource != null) { DemoteQuerySource(querySource); } }); if (AnonymousObject.IsGetValueExpression(node, out var querySourceReferenceExpression)) { DemoteQuerySource(querySourceReferenceExpression.ReferencedQuerySource); } foreach (var subQueryExpression in newExpression.Arguments.OfType <SubQueryExpression>()) { if (subQueryExpression.QueryModel.ResultOperators.LastOrDefault() is IQuerySource querySourceResultOperator) { PromoteQuerySource(querySourceResultOperator); } else if (subQueryExpression.QueryModel.SelectClause.Selector is QuerySourceReferenceExpression qsre) { PromoteQuerySource(qsre.ReferencedQuerySource); } } return(newExpression); }
// public IActionResult Create([Bind("ParentAnonymousObjectId,Id")] AnonymousObject anonymousObject) public IActionResult Create([Bind("Properties, ParentAnonymousObjectId, NestedObjects")] AnonymousObject anonymousObject) { if (anonymousObject == null) { return(this.BadRequest()); } if (this.ModelState.IsValid) { anonymousObject.ParentAnonymousObjectId = this.ValidateAnonymousObjectId(anonymousObject.ParentAnonymousObjectId); for (int i = anonymousObject.Properties.Count - 1; i >= 0; i--) { KeyValuePair pair = anonymousObject.Properties[i]; if (string.IsNullOrWhiteSpace(pair.Key) || string.IsNullOrWhiteSpace(pair.Value)) { anonymousObject.Properties.Remove(pair); } } this._repository.AddAnonymousObject(anonymousObject); return(this.RedirectToAction(nameof(this.Index))); } return(this.View(anonymousObject)); }
public void CanCastToAnyInterface() { var subject = new AnonymousObject(new ByRefValue("object@10000", Array.Empty <string>())); var result = subject.UnsafeCast <IManagedInterface>(); Assert.IsType <ManagedInterfaceProxy>(result); }
public void DeleteAnonymousObject(AnonymousObject anonToDelete) { this._context.AnonymousObjects.Remove(anonToDelete); this._context.SaveChanges(); this.UpdateIndicesWithDocumentId(anonToDelete.Id); }
/// <summary> /// Visits a method call expression. /// </summary> /// <param name="methodCallExpression"> The expression to visit. </param> /// <returns> /// An Expression. /// </returns> protected override Expression VisitMethodCall(MethodCallExpression methodCallExpression) { Check.NotNull(methodCallExpression, nameof(methodCallExpression)); var operand = Visit(methodCallExpression.Object); if (operand != null || methodCallExpression.Object == null) { var arguments = methodCallExpression.Arguments .Where( e => !(e.RemoveConvert() is QuerySourceReferenceExpression) && !IsNonTranslatableSubquery(e.RemoveConvert())) .Select( e => (e.RemoveConvert() as ConstantExpression)?.Value is Array || e.RemoveConvert().Type == typeof(DbFunctions) ? e : Visit(e)) .Where(e => e != null) .ToArray(); if (arguments.Length == methodCallExpression.Arguments.Count) { var boundExpression = operand != null ? Expression.Call(operand, methodCallExpression.Method, arguments) : Expression.Call(methodCallExpression.Method, arguments); var translatedExpression = _methodCallTranslator.Translate(boundExpression, _queryModelVisitor.QueryCompilationContext.Model); if (translatedExpression != null) { return(translatedExpression); } } } if (AnonymousObject.IsGetValueExpression(methodCallExpression, out var querySourceReferenceExpression)) { var selectExpression = _queryModelVisitor.TryGetQuery(querySourceReferenceExpression.ReferencedQuerySource); if (selectExpression != null) { var projectionIndex = (int)((ConstantExpression)methodCallExpression.Arguments.Single()).Value; return(selectExpression.BindSubqueryProjectionIndex( projectionIndex, querySourceReferenceExpression.ReferencedQuerySource)); } } return(TryBindMemberOrMethodToSelectExpression( methodCallExpression, (expression, visitor, binder) => visitor.BindMethodCallExpression(expression, binder)) ?? _queryModelVisitor.BindLocalMethodCallExpression(methodCallExpression) ?? _queryModelVisitor.BindMethodToOuterQueryParameter(methodCallExpression)); }
public void ConvertingAnonymousObjectToDictionary() { var anonymous = new { test = "test", test2 = "test2" }; var result = AnonymousObject.ToDictionary(anonymous); result["test"].Should().Be("test"); result["test2"].Should().Be("test2"); }
/// <summary> /// Converts an <see langword="object"/> into a target <see cref="Type"/>. /// </summary> /// <param name="wantedType">Target <see cref="Type"/>.</param> /// <param name="objectToConvert"><see langword="object"/> to convert.</param> /// <returns>Returns the converted <see langword="object"/>.</returns> public static object ConvertFromSerializable(Type wantedType, object objectToConvert) { if (objectToConvert == null) { return(null); } if (wantedType.IsIGrouping() && objectToConvert is InterLinqGroupingBase) { Type[] genericType = objectToConvert.GetType().GetGenericArguments(); MethodInfo method = typeof(TypeConverter).GetMethod("ConvertFromInterLinqGrouping", BindingFlags.NonPublic | BindingFlags.Static).MakeGenericMethod(genericType); return(method.Invoke(null, new[] { wantedType, objectToConvert })); } Type wantedElementType = InterLinqTypeSystem.FindIEnumerable(wantedType); if (wantedElementType != null && wantedElementType.GetGenericArguments()[0].IsAnonymous()) { Type typeOfObject = objectToConvert.GetType(); Type elementType = InterLinqTypeSystem.FindIEnumerable(typeOfObject); if (elementType != null && elementType.GetGenericArguments()[0] == typeof(AnonymousObject)) { MethodInfo method = typeof(TypeConverter).GetMethod("ConvertFromSerializableCollection", BindingFlags.NonPublic | BindingFlags.Static).MakeGenericMethod(wantedElementType.GetGenericArguments()[0]); return(method.Invoke(null, new[] { objectToConvert })); } } if (wantedType.IsAnonymous() && objectToConvert is AnonymousObject) { AnonymousObject dynamicObject = (AnonymousObject)objectToConvert; List <object> properties = new List <object>(); ConstructorInfo[] constructors = wantedType.GetConstructors(); if (constructors.Length != 1) { throw new Exception("Usualy, anonymous types have just one constructor."); } ConstructorInfo constructor = constructors[0]; foreach (ParameterInfo parameter in constructor.GetParameters()) { object propertyValue = null; bool propertyHasBeenSet = false; foreach (AnonymousProperty dynProperty in dynamicObject.Properties) { if (dynProperty.Name == parameter.Name) { propertyValue = dynProperty.Value; propertyHasBeenSet = true; break; } } if (!propertyHasBeenSet) { throw new Exception(string.Format("Property {0} could not be found in the dynamic object.", parameter.Name)); } properties.Add(ConvertFromSerializable(parameter.ParameterType, propertyValue)); } return(constructor.Invoke(properties.ToArray())); } return(objectToConvert); }
public void UpdateAnonymousObject(AnonymousObject anonToUpdate) { AnonymousObject anonToRemove = this._context.AnonymousObjects.FirstOrDefault(i => i.Id.Equals(anonToUpdate.Id)); this.DeleteAnonymousObject(anonToRemove); this.AddAnonymousObject(anonToUpdate); }
public static List <Index> CrawlAnonymousObject(this AnonymousObject anon, List <Index> currentIndices = null) { if (currentIndices == null) { currentIndices = new List <Index>(); } return(anon.CrawlAnonymousObject(out _, currentIndices)); }
public static InstanceCount CreateInstanceCount(Index index, AnonymousObject anon, int count) { InstanceCount newInstanceCount = new InstanceCount() { DocumentId = anon.Id, Count = count, }; newInstanceCount.Id = GenerateInstanceCountId(newInstanceCount, index); return(newInstanceCount); }
// ObjectTemplate private static string SpyCallback(HtmlHelper html, ModelMetadata metadata, string htmlFieldName, string templateName, DataBoundControlMode mode, object additionalViewData) { return(String.Format("Model = {0}, ModelType = {1}, PropertyName = {2}, HtmlFieldName = {3}, TemplateName = {4}, Mode = {5}, AdditionalViewData = {6}", metadata.Model ?? "(null)", metadata.ModelType == null ? "(null)" : metadata.ModelType.FullName, metadata.PropertyName ?? "(null)", htmlFieldName == String.Empty ? "(empty)" : htmlFieldName ?? "(null)", templateName ?? "(null)", mode, AnonymousObject.Inspect(additionalViewData))); }
// CollectionTemplate private static string CollectionSpyCallback(HtmlHelper html, ModelMetadata metadata, string htmlFieldName, string templateName, DataBoundControlMode mode, object additionalViewData) { return(String.Format(Environment.NewLine + "Model = {0}, ModelType = {1}, PropertyName = {2}, HtmlFieldName = {3}, TemplateName = {4}, Mode = {5}, TemplateInfo.HtmlFieldPrefix = {6}, AdditionalViewData = {7}", metadata.Model ?? "(null)", metadata.ModelType == null ? "(null)" : metadata.ModelType.FullName, metadata.PropertyName ?? "(null)", htmlFieldName == String.Empty ? "(empty)" : htmlFieldName ?? "(null)", templateName ?? "(null)", mode, html.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix, AnonymousObject.Inspect(additionalViewData))); }
public IActionResult CreateAnonymousObject([FromBody] JObject anonymousObjectJson) { if (anonymousObjectJson == null) { return(this.BadRequest()); } AnonymousObject anon = DeserializeAnonymousObjectJson(anonymousObjectJson); AnonymousObject anonToReturn = this._documentRepository.AddAnonymousObject(anon); return(this.Created("GetAnonymousObject", anonToReturn)); }
private static void CrawlAnonymousObjectForIndices(this AnonymousObject anon, List <Index> indices) { indices.AddFieldIndices(anon, "Id", anon.Id.ToString()); foreach (KeyValuePair pair in anon.Properties) { indices.AddFieldIndices(anon, pair.Key, pair.Value); } foreach (AnonymousObject nestedObject in anon.NestedObjects) { nestedObject.CrawlAnonymousObjectForIndices(indices); } }
public static List <Index> CrawlAnonymousObject( this AnonymousObject anon, out List <Index> indicesToUpdate, List <Index> currentIndices = null) { if (currentIndices == null) { currentIndices = new List <Index>(); } List <Index> indicesToAdd = new List <Index>(); anon.CrawlAnonymousObjectForIndices(indicesToAdd); return(CombineIndices(currentIndices, indicesToAdd, out indicesToUpdate)); }
public IActionResult GetAnonymousObject(Guid anonymousObjectId) { if (anonymousObjectId == Guid.Empty) { return(this.BadRequest()); } AnonymousObject anon = this._documentRepository.GetAnonymousObject(anonymousObjectId); if (anon == null) { return(this.NotFound()); } return(this.Ok(anon)); }
// GET: AnonymousObjects/Edit/5 public IActionResult Edit(Guid?id) { if (id == null) { return(this.NotFound()); } AnonymousObject anonymousObject = this._repository.GetAnonymousObject((Guid)id); if (anonymousObject == null) { return(this.NotFound()); } return(this.View(anonymousObject)); }
public IActionResult Edit(Guid id, [Bind("Properties, ParentAnonymousObjectId, NestedObjects, Id")] AnonymousObject anonymousObject) { if (id != anonymousObject.Id) { return(this.NotFound()); } if (this.ModelState.IsValid) { try { if (!this._repository.AnonymousObjectExists(anonymousObject.Id)) { return(this.NotFound()); } anonymousObject.ParentAnonymousObjectId = this.ValidateAnonymousObjectId(anonymousObject.ParentAnonymousObjectId); for (int i = anonymousObject.Properties.Count - 1; i >= 0; i--) { KeyValuePair pair = anonymousObject.Properties[i]; if (string.IsNullOrWhiteSpace(pair.Key) || string.IsNullOrWhiteSpace(pair.Value)) { anonymousObject.Properties.Remove(pair); } } this._repository.UpdateAnonymousObject(anonymousObject); } catch (DbUpdateConcurrencyException) { if (!this._repository.AnonymousObjectExists(anonymousObject.Id)) { return(this.NotFound()); } else { throw; } } return(this.RedirectToAction(nameof(this.Index))); } return(this.View(anonymousObject)); }
public AnonymousObject AddAnonymousObject(AnonymousObject anonymousObject) { if (anonymousObject.Id == default) { anonymousObject.Id = Guid.NewGuid(); } this._context.AnonymousObjects.Add(anonymousObject); this._context.SaveChanges(); List <Index> indices = anonymousObject.CrawlAnonymousObject(out List <Index> indicesToRemove, this.GetAllIndices().ToList()); this.RemoveIndices(indicesToRemove); this.AddIndices(indices); return(anonymousObject); }
/// <summary> /// Creates the starting AnonymousObjects for the database. /// </summary> /// <returns>Returns the starting AnonymousObjects for the database.</returns> public static List <AnonymousObject> GenerateStartingAnons() { List <AnonymousObject> startingAnons = new List <AnonymousObject>(); AnonymousObject anon1 = new AnonymousObject(); startingAnons.Add(anon1); anon1.Properties.Add(new Entities.KeyValuePair() { Key = "key1", Value = "value1", }); anon1.Properties.Add(new Entities.KeyValuePair() { Key = "name", Value = "anon1", }); return(startingAnons); }
public static AnonymousObject DeserializeAnonymousObjectJson(JObject anonymousObjectJson) { AnonymousObject anon = new AnonymousObject(); foreach (KeyValuePair <string, JToken> pair in anonymousObjectJson) { string key = pair.Key; if (pair.Value.Type == JTokenType.String) { string value = (string)((JValue)pair.Value).Value; anon.Add(key, value); } else if (pair.Value.Type == JTokenType.Object) { anon.Add(DeserializeAnonymousObjectJson((JObject)pair.Value)); } } return(anon); }
public static async Task PrepareAsync(this IEventPublisher eventPublisher, string routeKey, object content, object metaData, IDbConnection dbConnection, IDbTransaction dbTransaction, string exchange = "default.exchange@feiniubus", object args = null) { var message = new DefaultMessage(content); var anonyObj = new AnonymousObject(metaData); var anonyMembers = anonyObj.GetProperties().Where(member => member.MemberType == System.Reflection.MemberTypes.Property) .Select(member => new { MemberName = member.MemberName, Value = anonyObj.GetValue(member.DeclaringType, member.MemberName) }); if (anonyMembers.Any()) { var md = new MetaData(); foreach (var member in anonyMembers) { md.Set(member.MemberName, member.Value.ToString()); } message.MetaData.Contact(md); } await eventPublisher.PrepareAsync(new EventDescriptor(routeKey, message, exchange, args), dbConnection, dbTransaction); }
public static void AddFieldIndices( this List <Index> indices, AnonymousObject anon, string fieldName, string fieldValueString) { string[] fieldValues = fieldValueString.ParseField(); IDictionary <string, int> fieldValueCounts = AggregateFieldValueCounts(fieldValues); foreach (string fieldValue in fieldValueCounts.Keys) { Index newIndexToAdd = IndexExtensions.CreateNewIndex(fieldName, fieldValue); fieldValueCounts.TryGetValue(fieldValue, out int fieldValueCount); newIndexToAdd.InstanceCounts.Add( InstanceCountExtensions.CreateInstanceCount(newIndexToAdd, anon, fieldValueCount)); indices.Add(newIndexToAdd); } }
public static AnonymousObject MapDocumentToAnonymousObject(this Document document) { AnonymousObject anon = new AnonymousObject { Id = document.Id }; foreach (string fieldName in FieldsToIndex.Keys) { if (fieldName != "id") { FieldsToIndex.TryGetValue(fieldName, out Func <Document, string> accessor); anon.Properties.Add(new Entities.KeyValuePair() { Key = fieldName, Value = accessor(document), }); } } return(anon); }
/*private static object ConvertFromInterLinqGrouping<TKey, TElement>(Type wantedType, InterLinqGrouping<TKey, TElement> grouping) * { * Type[] genericArguments = wantedType.GetGenericArguments(); * object key = ConvertFromSerializable(genericArguments[0], grouping.Key); * * MethodInfo method = typeof(TypeConverter).GetMethod("ConvertFromSerializableCollection", BindingFlags.NonPublic | BindingFlags.Static).MakeGenericMethod(genericArguments[1]); * object elements = method.Invoke(null, new object[] { grouping }); * * //object elements = ConvertFromSerializableCollection<TElement>( typeof( IEnumerable<> ).MakeGenericType( genericArguments[1] ), ); * Type elementType = InterLinqTypeSystem.FindIEnumerable(elements.GetType()); * if (elementType == null) * { * throw new Exception("ElementType could not be found."); * } * Type[] genericTypes = new[] { key.GetType(), elementType.GetGenericArguments()[0] }; * InterLinqGroupingBase newGrouping = (InterLinqGroupingBase)Activator.CreateInstance(typeof(InterLinqGrouping<,>).MakeGenericType(genericTypes)); * newGrouping.SetKey(key); * newGrouping.SetElements(elements); * return newGrouping; * }*/ /* /// <summary> * /// Converts each element of an <see cref="IEnumerable"/> * /// into a target <see cref="Type"/>. * /// </summary> * /// <typeparam name="T">Target <see cref="Type"/>.</typeparam> * /// <param name="enumerable"><see cref="IEnumerable"/>.</param> * /// <returns>Returns the converted <see cref="IEnumerable"/>.</returns> * private static IEnumerable ConvertFromSerializableCollection<T>(IEnumerable enumerable) * { * Type enumerableType = typeof(List<>).MakeGenericType(typeof(T)); * IEnumerable newList = (IEnumerable)Activator.CreateInstance(enumerableType); * MethodInfo addMethod = enumerableType.GetMethod("Add"); * foreach (object item in enumerable) * { * addMethod.Invoke(newList, new[] { ConvertFromSerializable(typeof(T), item) }); * } * return newList; * }*/ #endregion #region Convert C# Anonymous Type to AnonymousObject /// <summary> /// Converts an object to an <see cref="AnonymousObject"/> /// or an <see cref="IEnumerable{AnonymousObject}"/>. /// </summary> /// <param name="objectToConvert"><see langword="object"/> to convert.</param> /// <returns>Returns the converted <see langword="object"/>.</returns> public static object ConvertToSerializable(object objectToConvert) { if (objectToConvert == null) { return(null); } Type typeOfObject = objectToConvert.GetType(); Type elementType = InterLinqTypeSystem.FindIEnumerable(typeOfObject); // Handle "IGrouping<TKey, TElement>" if (typeOfObject.IsIGrouping()) { Type[] genericType = typeOfObject.GetGenericArguments(); MethodInfo method = typeof(TypeConverter).GetMethod("ConvertToInterLinqGrouping", BindingFlags.NonPublic | BindingFlags.Static).MakeGenericMethod(genericType); return(method.Invoke(null, new[] { objectToConvert })); } // Handle "IEnumerable<AnonymousType>" / "IEnumerator<T>" if (elementType != null && elementType.GetGenericArguments()[0].IsAnonymous() || typeOfObject.IsEnumerator()) { // ReSharper disable PossibleNullReferenceException MethodInfo method = typeof(TypeConverter).GetMethod("ConvertToSerializableCollection", BindingFlags.NonPublic | BindingFlags.Static).MakeGenericMethod(elementType.GetGenericArguments()[0]); // ReSharper restore PossibleNullReferenceException return(method.Invoke(null, new[] { objectToConvert })); } // Handle "AnonymousType" if (typeOfObject.IsAnonymous()) { AnonymousObject newObject = new AnonymousObject(); foreach (PropertyInfo property in typeOfObject.GetProperties(BindingFlags.Instance | BindingFlags.GetProperty | BindingFlags.Public)) { object objectValue = ConvertToSerializable(property.GetValue(objectToConvert, new object[] { })); newObject.Properties.Add(new AnonymousProperty(property.Name, objectValue)); } return(newObject); } return(objectToConvert); }
private IRTRequest HandleResult <T>(Object[] args, IDictionary <String, T> requestMap, String resultKey) where T : IRTRequest { if (args == null || args.Length < 1) { Log.log(Backendless.BACKENDLESSLOG, "subscription result is null or empty"); return(null); } AnonymousObject result = (AnonymousObject)WeborbSerializationHelper.Deserialize((byte[])args[0]); String id = WeborbSerializationHelper.AsString(result, "id"); Log.log(Backendless.BACKENDLESSLOG, String.Format("Got result for subscription {0}", id)); IRTRequest request = requestMap[id]; if (request == null) { Log.log(Backendless.BACKENDLESSLOG, String.Format("There is no handler for subscription {0}", id)); return(null); } Object error = WeborbSerializationHelper.AsObject(result, "error"); if (error != null) { Log.log(Backendless.BACKENDLESSLOG, String.Format("got error {0}", error)); BackendlessFault fault = new BackendlessFault(error.ToString()); request.Callback.errorHandler(fault); return(request); } IAdaptingType data = WeborbSerializationHelper.AsAdaptingType(result, resultKey); request.Callback.responseHandler(data); return(request); }
// GET: AnonymousObjects/Details/5 public IActionResult Details(Guid?id) { if (id == null) { return(this.NotFound()); } AnonymousObject anonymousObject = this._repository.GetAnonymousObject((Guid)id); if (anonymousObject == null) { if (this._repository.DocumentExists((Guid)id)) { return(this.RedirectToAction("Details", "Documents", new { Id = id, })); } return(this.NotFound()); } return(this.View(anonymousObject)); }
internal static IAdaptingType AsAdaptingType(IAdaptingType obj, String key) { AnonymousObject anonymousObject = Cast(obj); return((IAdaptingType)anonymousObject.Properties[key]); }
public SearchEngineMng(string currentUserIp, HttpContext context, string action) { _currentUserIp = currentUserIp; this.context = context; currentR = context.Request; currentS = context.Server; mngInfo = new TimeZoneManager(currentUserIp); string sLangId = context.Request.QueryString["li"]; if (string.IsNullOrEmpty(sLangId)) { isValid = false; errorMessage = "You forgot langid (querystring li)"; } // Convert langid querystring to int32 if (!Int32.TryParse(sLangId, out currentLangId)) { isValid = false; errorMessage = "Problem with converting langauge ID (querystring li)"; } if (context.Session["usi"] == null || action == "1") { // Create user default information usi.UserID = (Guid)ANOProfile.GetCookieValues(currentUserIp, context).UserID; usi.UserIpAddress = currentUserIp; #region Set ints data (Get data by QueryStrings) var dataConvertToInts = new { clanSkillID = (string)currentR.QueryString["cs"], clanContinentID = (string)currentR.QueryString["cct"], clanCountryID = (string)currentR.QueryString["cc"], searchContinentID = (string)currentR.QueryString["sct"], searchCountryID = (string)currentR.QueryString["sc"], searchGameID = (string)currentR.QueryString["sg"], searchGameModeID = (string)currentR.QueryString["sgt"], searchXvs = (string)currentR.QueryString["sxv"], searchvsX = (string)currentR.QueryString["svx"] }.ToAnonymousObjectCollection(); int MaxIntValue = int.MaxValue; var intdata = new { clanSkillID = (int?)null, clanContinentID = (int)MaxIntValue, clanCountryID = (int)MaxIntValue, searchContinentID = (int)MaxIntValue, searchCountryID = (int?)null, searchGameID = (int)MaxIntValue, searchGameModeID = (int?)null, searchXvs = (int?)null, searchvsX = (int?)null, searchYearFrom = (int)MaxIntValue, searchDayFrom = (int)MaxIntValue, searchMonthFrom = (int)MaxIntValue, searchHourFrom = (int)MaxIntValue, searchMinutesFrom = (int)MaxIntValue, }.ToAnonymousObjectCollection(); #endregion #region validate and convert properties to ints for (int i = 0; i < dataConvertToInts.Count; i++) { AnonymousObject o = dataConvertToInts.GetAnonymousObject(i); if (!string.IsNullOrEmpty(o.GetValue <string>())) { int result; if (int.TryParse(o.GetValue <string>(), out result)) { intdata.GetAnonymousObject(o.KeyName).SetValue(result); } } if (intdata.GetAnonymousObject(o.KeyName).GetValue_UnknownObject() != null && Convert.ToInt32(intdata.GetAnonymousObject(o.KeyName).GetValue_UnknownObject()) == MaxIntValue) { isValid = false; errorMessage = "'" + o.KeyName + "' much be more than empty"; } } #endregion #region Set strings data (convert to HtmlEncode strings) var stringData = new { ClanName = (string)currentS.HtmlEncode(currentS.UrlDecode(currentR.QueryString["cn"])), SearchMap = (string)currentS.HtmlEncode(currentS.UrlDecode(currentR.QueryString["sm"])), }; #endregion #region Set datetime data (Replace + and . (This chars is used to avoid problems)) if (string.IsNullOrEmpty(currentR.QueryString["sfd"])) { isValid = false; errorMessage = "'SearchMatchStart' much be more than empty"; } else { var datetimeData = new { SearchMatchStart = (DateTime)DateTime.ParseExact(currentS.UrlDecode(currentR.QueryString["sfd"]), "dd-MM-yyyy HH:mm:ss", new DateTimeFormatInfo()) }; #endregion // Edit/Create user search information usi.ClanName = stringData.ClanName; usi.ClanSkillID = intdata.GetAnonymousObject("clanSkillID").GetValue <int?>(); usi.ClanContinentID = intdata.GetAnonymousObject("clanContinentID").GetValue <int>(); usi.ClanCountryID = intdata.GetAnonymousObject("clanCountryID").GetValue <int>(); usi.SearchContinentID = intdata.GetAnonymousObject("searchContinentID").GetValue <int>(); usi.SearchCountryID = intdata.GetAnonymousObject("searchCountryID").GetValue <int?>(); usi.SearchGameID = intdata.GetAnonymousObject("searchGameID").GetValue <int>(); usi.SearchGameModeID = intdata.GetAnonymousObject("searchGameModeID").GetValue <int?>(); usi.SearchMap = stringData.SearchMap; usi.SearchXvs = intdata.GetAnonymousObject("searchXvs").GetValue <int>(); usi.SearchvsX = intdata.GetAnonymousObject("searchvsX").GetValue <int>(); usi.SearchMatchStart = new TimeZoneManager(currentUserIp).ConvertDateTimeToUtc(datetimeData.SearchMatchStart); userOption = SearchWar.SearchEngine.SearchEngine.UserSearchOption.CreateUserSearch; context.Session["usi"] = usi; } } else { usi = (UserSearchInfo)context.Session["usi"]; } if (isValid == true) { LangaugeSystem ls = new LangaugeSystem(); string getLang = ls.GetLang(Convert.ToInt32(sLangId)).LangShortname; Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture(getLang); Thread.CurrentThread.CurrentUICulture = new CultureInfo(getLang); } }
/// <summary> /// Converts an object to an <see cref="AnonymousObject"/> /// or an <see cref="IEnumerable{AnonymousObject}"/>. /// </summary> /// <param name="objectToConvert"><see langword="object"/> to convert.</param> /// <returns>Returns the converted <see langword="object"/>.</returns> public static object ConvertToSerializable(object objectToConvert) { if (objectToConvert == null) { return(null); } Type typeOfObject = objectToConvert.GetType(); Type elementType = InterLinqTypeSystem.FindIEnumerable(typeOfObject); // Handle "IGrouping<TKey, TElement>" if (typeOfObject.IsIGrouping()) { #if !NETFX_CORE Type[] genericType = typeOfObject.GetGenericArguments(); #else Type[] genericType = typeOfObject.GetTypeInfo().GenericTypeArguments; #endif #if !SILVERLIGHT MethodInfo method = typeof(TypeConverter).GetMethod("ConvertToInterLinqGrouping", BindingFlags.NonPublic | BindingFlags.Static).MakeGenericMethod(genericType); #else #if !NETFX_CORE MethodInfo method = typeof(TypeConverter).GetMethod("ConvertToInterLinqGrouping", BindingFlags.Public | BindingFlags.Static).MakeGenericMethod(genericType); #else MethodInfo method = typeof(TypeConverter).GetTypeInfo().GetDeclaredMethod("ConvertToInterLinqGrouping").MakeGenericMethod(genericType); #endif #endif return(method.Invoke(null, new[] { objectToConvert })); } // Handle "IGrouping<TKey, TElement>[]" if (typeOfObject.IsIGroupingArray()) { #if !NETFX_CORE Type[] genericType = typeOfObject.GetGenericArguments(); #else Type[] genericType = typeOfObject.GetTypeInfo().GenericTypeArguments; #endif #if !SILVERLIGHT MethodInfo method = typeof(TypeConverter).GetMethod("ConvertToInterLinqGroupingArray", BindingFlags.NonPublic | BindingFlags.Static).MakeGenericMethod(genericType); #else #if !NETFX_CORE MethodInfo method = typeof(TypeConverter).GetMethod("ConvertToInterLinqGroupingArray", BindingFlags.Public | BindingFlags.Static).MakeGenericMethod(genericType); #else MethodInfo method = typeof(TypeConverter).GetTypeInfo().GetDeclaredMethod("ConvertToInterLinqGroupingArray").MakeGenericMethod(genericType); #endif #endif return(method.Invoke(null, new[] { objectToConvert })); } // Handle "IEnumerable<AnonymousType>" / "IEnumerator<T>" #if !NETFX_CORE if (elementType != null && elementType.GetGenericArguments()[0].IsAnonymous() || typeOfObject.IsEnumerator()) #else if (elementType != null && elementType.GetTypeInfo().GenericTypeArguments[0].IsAnonymous() || typeOfObject.IsEnumerator()) #endif { #if !SILVERLIGHT MethodInfo method = typeof(TypeConverter).GetMethod("ConvertToSerializableCollection", BindingFlags.NonPublic | BindingFlags.Static).MakeGenericMethod(elementType.GetGenericArguments()[0]); #else #if !NETFX_CORE MethodInfo method = typeof(TypeConverter).GetMethod("ConvertToSerializableCollection", BindingFlags.Public | BindingFlags.Static).MakeGenericMethod(elementType.GetGenericArguments()[0]); #else MethodInfo method = typeof(TypeConverter).GetTypeInfo().GetDeclaredMethod("ConvertToSerializableCollection").MakeGenericMethod(elementType.GetTypeInfo().GenericTypeArguments[0]); #endif #endif return(method.Invoke(null, new[] { objectToConvert })); } // Handle "AnonymousType" if (typeOfObject.IsAnonymous()) { AnonymousObject newObject = new AnonymousObject(); #if !NETFX_CORE foreach (PropertyInfo property in typeOfObject.GetProperties(BindingFlags.Instance | BindingFlags.GetProperty | BindingFlags.Public)) #else foreach (PropertyInfo property in typeOfObject.GetTypeInfo().DeclaredProperties) #endif { object objectValue = ConvertToSerializable(property.GetValue(objectToConvert, new object[] { })); newObject.Properties.Add(new AnonymousProperty(property.Name, objectValue)); } return(newObject); } return(objectToConvert); }