void EnsureMapper(TypeAccessor typeAccessor) { if (_typeAccessor != typeAccessor) { _typeAccessor = typeAccessor; _mapFieldAttributes = null; } }
protected object[] GetMapFieldAttributes(TypeAccessor typeAccessor) { lock (_sync) { EnsureMapper(typeAccessor); return _mapFieldAttributes ?? (_mapFieldAttributes = TypeHelper.GetAttributes(typeAccessor.Type, typeof (MapFieldAttribute))); } }
public object CreateInstance(TypeAccessor typeAccessor, InitContext context) { int id = context.DataSource.GetInt32(context.SourceObject, context.DataSource.GetOrdinal("PersonId")); context.ObjectMapper = context.MappingSchema.GetObjectMapper(Factory.GetType(id)); return context.ObjectMapper.TypeAccessor.CreateInstance(context); }
object[] GetNonUpdatableAttributes(TypeAccessor typeAccessor) { lock (_sync) { EnsureMapper(typeAccessor); return _nonUpdatableAttributes ?? (_nonUpdatableAttributes = TypeHelper.GetAttributes(typeAccessor.Type, typeof(NonUpdatableAttribute))); } }
/// <summary> /// Initializes a new instance of the <see cref="DynamicProxy"/> class. /// </summary> /// <param name="wrapped">The wrapped object.</param> /// <param name="safeMode">if set to <c>true</c>, return null when name not found.</param> public DynamicProxy(object wrapped, bool safeMode) { if (wrapped == null) throw new ArgumentNullException("wrapped"); _wrapped = wrapped; SafeMode = safeMode; Type type = _wrapped.GetType(); _typeAccessor = TypeAccessor.GetAccessor(type); }
public object Get(INXmlElementReader nodeReader) { var typeName = nodeReader.Attributes.Get("type"); var type = typeFinder.GetType(typeName); var typeAccessor = new TypeAccessor(type.GetTargetType(), docObjectRepository); var instance = typeAccessor.GetInstance(); readObjects.Add(nodeReader.Attributes.GetInteger("ID"), instance); ((IBaseTypeMembersReader) this).ReadMembers(instance, nodeReader, type); return instance; }
public object /*[a]*/CreateInstance(TypeAccessor typeAccessor, InitContext context)/*[/a]*/ { // Get the object type indicator field. // object objectType = context.DataSource.GetValue(context.SourceObject, "PersonType"); // Target ObjectMapper must be changed in order to provide correct mapping. // switch ((string)objectType) { case "D": /*[a]*/context.ObjectMapper = ObjectMapper<Doctor>. Instance;/*[/a]*/ break; case "P": /*[a]*/context.ObjectMapper = ObjectMapper<Patient>.Instance;/*[/a]*/ break; } // Create an object instance. // Do not call ObjectMapper.CreateInstance as it will lead to infinite recursion. // return context.ObjectMapper./*[a]*/TypeAccessor/*[/a]*/.CreateInstance(context); }
public void Write(object owningObject, ISerialiserNode parentNode, Type type) { var typeAccessor = new TypeAccessor(type, null); var memberInfos = typeAccessor.GetMembers(); foreach (var memberInfo in memberInfos) { if (memberInfo.GetCustomAttributes(typeof (NSerializerIgnoreAttribute), false).Length != 1) { foreach (var writer in writers) { if (writer.CanWrite(owningObject, memberInfo)) { writer.Write(owningObject, parentNode, memberInfo); break; } } } } }
public object CreateInstance(TypeAccessor typeAccessor, InitContext context) { Type t = typeAccessor.Type; ConstructorInfo[] ctis = t.GetConstructors(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic); ConstructorInfo constructor = ctis[0]; foreach (ConstructorInfo ci in ctis) { if (constructor.GetParameters().Length < ci.GetParameters().Length) constructor = ci; } ParameterInfo[] pis = constructor.GetParameters(); object[] param = new object[pis.Length]; for(int i = 0; i < pis.Length; i++) { ParameterInfo pi = pis[i]; Type pType = pi.ParameterType; string pName = pi.Name; int ordinal = context.DataSource.GetOrdinal(pName); if (ordinal >= 0) { param[i] = context.MappingSchema.ConvertChangeType( context.DataSource.GetValue(context.SourceObject, ordinal), pType); } else param[i] = context.MappingSchema.GetDefaultValue(pType); } context.StopMapping = true; return constructor.Invoke(param); }
private static void RegisterDto(ContainerBuilder containerBuilder) { containerBuilder.Register(c => c.Resolve <IEnumerable <IDao <IDto> > >().OfType <IDao <II18NDto> >().ToDictionary( x => x.GetType().GetGenericArguments()[1], y => y.LoadAll().GroupBy(x => x !.Key ?? "") .ToDictionary(x => x.Key, x => x.ToList().ToDictionary(o => o !.RegionType, o => o !)))) .AsImplementedInterfaces() .SingleInstance() .AutoActivate(); var registerDatabaseObject = typeof(Startup).GetMethod(nameof(RegisterDatabaseObject)); var assemblyDto = typeof(IStaticDto).Assembly.GetTypes(); var assemblyDb = typeof(Account).Assembly.GetTypes(); assemblyDto.Where(p => typeof(IDto).IsAssignableFrom(p) && (!p.Name.Contains("InstanceDto") || p.Name.Contains("Inventory")) && p.IsClass) .ToList() .ForEach(t => { var type = assemblyDb.First(tgo => string.Compare(t.Name, $"{tgo.Name}Dto", StringComparison.OrdinalIgnoreCase) == 0); var typepk = type.GetProperties() .Where(s => new NosCoreContext(new DbContextOptionsBuilder <NosCoreContext>().UseInMemoryDatabase( Guid.NewGuid().ToString()).Options).Model.FindEntityType(type) .FindPrimaryKey().Properties.Select(x => x.Name) .Contains(s.Name) ).ToArray()[0]; registerDatabaseObject?.MakeGenericMethod(t, type, typepk !.PropertyType) .Invoke(null, new object?[] { containerBuilder }); }); containerBuilder.RegisterType <Dao <ItemInstance, IItemInstanceDto?, Guid> >().As <IDao <IItemInstanceDto?, Guid> >().SingleInstance(); containerBuilder.Register(c => { var dic = c.Resolve <IDictionary <Type, Dictionary <string, Dictionary <RegionType, II18NDto> > > >(); var items = c.Resolve <IDao <ItemDto, short> >().LoadAll().ToList(); var props = StaticDtoExtension.GetI18NProperties(typeof(ItemDto)); var regions = Enum.GetValues(typeof(RegionType)); var accessors = TypeAccessor.Create(typeof(ItemDto)); Parallel.ForEach(items, s => s.InjectI18N(props, dic, regions, accessors)); var staticMetaDataAttribute = typeof(ItemDto).GetCustomAttribute <StaticMetaDataAttribute>(); if ((items.Count != 0) || (staticMetaDataAttribute == null) || (staticMetaDataAttribute.EmptyMessage == LogLanguageKey.UNKNOWN)) { if ((items.Count != 0) && (staticMetaDataAttribute != null)) { c.Resolve <ILogger>().Information( LogLanguage.Instance.GetMessageFromKey(staticMetaDataAttribute.LoadedMessage), items.Count); } } else { c.Resolve <ILogger>() .Error(LogLanguage.Instance.GetMessageFromKey(staticMetaDataAttribute.EmptyMessage)); } return(items); }) .As <List <ItemDto> >() .SingleInstance() .AutoActivate(); }
/// <summary> /// Initializes a new instance of the <see cref="ClassMapping"/> class. /// </summary> /// <param name="typeAccessor">The type accessor.</param> public ClassMapping(TypeAccessor typeAccessor) : this() { TypeAccessor = typeAccessor; }
public override void EnsureMapper(TypeAccessor typeAccessor, MappingSchema mappingSchema, EnsureMapperHandler handler) { base.EnsureMapper(typeAccessor, mappingSchema, handler); }
private static TypeAccessor GetAccessor(Type type) { return(Accessors.GetOrAdd(type, TypeAccessor.Create(type))); }
string FormatObject(object obj, MemberSet members, TypeAccessor accessor) { return($"{{ {string.Join(", ", members.Select(m => $"{m.Name} = {FormatValue(accessor[obj, m.Name], null)}"))} }}"); }
private async Task QueryAndPopulateEdgeConnections( List <SelectValue> selections, List <object> results, IGraphRequestContext graphRequestContext, List <ConnectionEdgeDestinationFilter> connectionEdgeDestinationFilters, QueryExecutionContext queryExecutionContext) { var edgeQueryParameters = _connectionEdgeResolver.ListConnectionEdgeQueryParameter(results) .Where(x => selections.Any(y => y.FieldName.ToLower() == x.SourceFieldName.ToLower())).ToList(); if (edgeQueryParameters.Count > 0) { var connectionEdges = (await GetConnectionEdgeRepository().QueryAsync <ConnectionEdge>( ConnectionEdgeQueryName, edgeQueryParameters.ToQueryParameters(), null, graphRequestContext)).ToList(); if (connectionEdges.Count > 0) { var accessor = TypeAccessor.Create(results.First().GetType()); var dictionary = new Dictionary <string, object>(); results.ForEach(item => dictionary.Add(accessor.GetKey(item), item)); foreach (var connectionEdge in connectionEdges) { if (!dictionary.ContainsKey(connectionEdge.SourceId)) { throw new InvalidOperationException($"{connectionEdge.SourceId} is invalid."); } var sourceObject = dictionary[connectionEdge.SourceId]; var edgeObject = DeserializeObject(connectionEdge.MetaValue, connectionEdge.MetaType); var member = accessor.GetMembers().Single(x => x.Name == connectionEdge.SourceFieldName); if (member.IsList()) { member.CreateNewListIfNullThenAddItemToList(accessor, sourceObject, edgeObject); } else { accessor[sourceObject, connectionEdge.SourceFieldName] = edgeObject; } var selection = selections.SingleOrDefault(s => s.FieldName.ToLower() == connectionEdge.SourceFieldName.ToLower()); if (selection != null) { var edgeObjectType = edgeObject.GetType(); var edgeObjectTypeAccessor = TypeAccessor.Create(edgeObjectType); var entity = await GetValue(edgeObjectTypeAccessor, connectionEdge, graphRequestContext, connectionEdgeDestinationFilters, queryExecutionContext); if (entity == null) { _logger.LogWarning($"The following connection edge did not yield a record: {JsonConvert.SerializeObject(connectionEdge)}"); continue; } edgeObjectTypeAccessor[edgeObject, connectionEdge.MetaFieldName] = entity; var matchingFieldName = connectionEdge.MetaFieldName.ToLower(); var matchingSelections = selections.Where(x => x.SelectValues.Any(y => y.FieldName.ToLower() == matchingFieldName)); foreach (var matchingSelection in matchingSelections) { var selectionWithSelects = matchingSelection.SelectValues.Single(x => x.FieldName.ToLower() == matchingFieldName) .SelectValues.Where(x => x.SelectValues.Count > 0).ToList(); if (selectionWithSelects.Count > 0) { await QueryAndPopulateEdgeConnections(selectionWithSelects, new List <object> { entity }, graphRequestContext, connectionEdgeDestinationFilters, queryExecutionContext); } } } } } } }
public object CreateInstance(TypeAccessor typeAccessor) { return(typeAccessor.CreateInstance()); }
public void NullArgTest() { TypeAccessor.CreateInstance(typeof(NullArgObject)); }
protected override void CreateSettings() { settings = TypeAccessor <ClientParameters> .CreateInstanceEx(); }
public static string GetUniquePropertyValues <T>(T entity, List <string> propertiesNames, TypeAccessor accessor) { string result = String.Empty; foreach (var propertyName in propertiesNames) { result += accessor[entity, propertyName]; } return(result); }
public void Packaging_DependencyCheck_LoggingDependencies() { PackagingTest(() => { var logger = new StringBuilder(); var loggers = new[] { new PackagingTestLogger(logger) }; var loggerAcc = new TypeAccessor(typeof(SenseNet.Packaging.Logger)); loggerAcc.SetStaticField("_loggers", loggers); using (new Swindler <IPackagingLogger[]>(loggers, () => (IPackagingLogger[])loggerAcc.GetStaticField("_loggers"), value => loggerAcc.SetStaticField("_loggers", loggers))) { for (var i = 0; i < 9; i++) { ExecutePhases($@"<?xml version='1.0' encoding='utf-8'?> <Package type='Install'> <Id>Component{i + 1}</Id> <ReleaseDate>2017-01-01</ReleaseDate> <Version>{i + 1}.0</Version> </Package>"); } logger.Clear(); // action ExecutePhases(@"<?xml version='1.0' encoding='utf-8'?> <Package type='Install'> <Id>MyCompany.MyComponent</Id> <ReleaseDate>2017-01-02</ReleaseDate> <Version>1.2</Version> <Dependencies> <Dependency id='Component1' version= '1.0' /> <Dependency id='Component2' minVersion= '1.0' /> <Dependency id='Component3' maxVersion= '9.0' /> <Dependency id='Component4' minVersionExclusive='1.0' /> <Dependency id='Component5' maxVersionExclusive='9.0' /> <Dependency id='Component6' minVersion= '1.0' maxVersion= '10.0' /> <Dependency id='Component7' minVersion= '1.0' maxVersionExclusive='10.0' /> <Dependency id='Component8' minVersionExclusive='1.0' maxVersion= '10.0' /> <Dependency id='Component9' minVersionExclusive='1.0' maxVersionExclusive='10.0' /> </Dependencies> </Package>"); // check var log = logger.ToString(); var relevantLines = new List <string>(); using (var reader = new StringReader(log)) { string line; while ((line = reader.ReadLine()) != null) { line = line.Trim(); if (line.StartsWith("Component") && !line.StartsWith("ComponentId")) { relevantLines.Add(line); } } } Assert.AreEqual("Component1: 1.0 = 1.0 (current)", relevantLines[0]); Assert.AreEqual("Component2: 1.0 <= 2.0 (current)", relevantLines[1]); Assert.AreEqual("Component3: 3.0 (current) <= 9.0", relevantLines[2]); Assert.AreEqual("Component4: 1.0 < 4.0 (current)", relevantLines[3]); Assert.AreEqual("Component5: 5.0 (current) <= 9.0", relevantLines[4]); Assert.AreEqual("Component6: 1.0 <= 6.0 (current) <= 10.0", relevantLines[5]); Assert.AreEqual("Component7: 1.0 <= 7.0 (current) <= 10.0", relevantLines[6]); Assert.AreEqual("Component8: 1.0 < 8.0 (current) < 10.0", relevantLines[7]); Assert.AreEqual("Component9: 1.0 < 9.0 (current) < 10.0", relevantLines[8]); } }); }
public static string GetMemberStringValue <T>(this T item, string memberName) { var f = TypeAccessor.Create(typeof(T)); return(f[item, memberName] as string); }
public static string GetKey <T>(this T item) { var f = TypeAccessor.Create(typeof(T)); return(f.GetKey(item)); }
static SummaryIndexValues() { CachedSelectors = ReflectionExtensions.GetGetters <SummaryIndexValues, object>(); CachedSetter = TypeAccessor.Create(typeof(SummaryIndexValues)); }
protected static List<string> GetPrimaryKeyFields(MappingSchema schema, TypeAccessor ta, TypeExtension tex) { var mdp = schema.MetadataProvider; var keys = new List<string>(); foreach (MemberAccessor sma in ta) { bool isSetFlag; mdp.GetPrimaryKeyOrder(ta.Type, tex, sma, out isSetFlag); if (isSetFlag) { var name = mdp.GetFieldName(tex, sma, out isSetFlag); keys.Add(name); } } return keys; }
internal static T As <S, T>(this S item, TypeMemberIndex sourceIndexMembers, TypeMemberIndex targetIndexMembers, TypeAccessor sourceAccessor, TypeAccessor targetAccessor) where T : new() { T targetItem = new T(); foreach (var targetFieldName in targetIndexMembers.Keys) { try { if (sourceIndexMembers.ContainsKey(targetFieldName)) { var sourcePropertyType = sourceIndexMembers[targetFieldName].Type; sourcePropertyType = ((sourcePropertyType.Name.Contains("Nullable")) ? sourcePropertyType.GenericTypeArguments.First() : sourcePropertyType); var targetPropertyType = targetIndexMembers[targetFieldName].Type; var isTargetNullable = targetPropertyType.Name.Contains("Nullable"); targetPropertyType = ((isTargetNullable) ? targetPropertyType.GenericTypeArguments.First() : targetPropertyType); object sourceValue = sourceAccessor[item, targetFieldName]; var bForceSpecified = false; if (sourceValue != null) { if ((targetPropertyType.Name.Equals("DateTime")) && (sourceValue.Equals(DateTime.Parse("1/1/0001 12:00:00 AM")))) { sourceValue = null; } else if ((targetPropertyType.Name.Equals("DateTime")) && (sourceValue.Equals(DateTime.MaxValue))) { sourceValue = null; bForceSpecified = true; } else if ((sourcePropertyType.IsEnum) && (targetPropertyType.Name.Contains("String"))) { sourceValue = sourceValue?.ToString(); } else if ((sourcePropertyType.Name.Contains("String")) && (targetPropertyType.IsEnum)) { sourceValue = Enum.Parse(targetPropertyType, sourceValue?.ToString()); } } if ((sourceValue == null) || (sourceValue.Equals("DBNull"))) { if ((targetPropertyType.Name.Equals("DateTime") && (!isTargetNullable))) { targetAccessor[targetItem, targetFieldName] = DateTime.Parse("1/1/0001 12:00:00 AM"); } else { if (isTargetNullable) { targetAccessor[targetItem, targetFieldName] = null; } } } else if ((targetPropertyType.FullName == sourcePropertyType.FullName) || (targetPropertyType.Name.Equals(sourceValue.GetType().Name))) { targetAccessor[targetItem, targetFieldName] = sourceValue; } else { if (targetPropertyType.GenericTypeArguments.Contains(targetPropertyType)) { targetAccessor[targetItem, targetFieldName] = sourceValue; } else { var c = TypeDescriptor.GetConverter(targetPropertyType); if (c.CanConvertTo(targetPropertyType)) { targetAccessor[targetItem, targetFieldName] = c.ConvertTo(sourceValue, targetPropertyType); } else { try { targetAccessor[targetItem, targetFieldName] = System.Convert.ChangeType(sourceValue, targetPropertyType); } catch (System.Exception ex) { throw new System.Exception(string.Format("Could not convert field {0} of type {1} to {2}", targetFieldName, sourceIndexMembers[targetFieldName].Type.Name, targetPropertyType.Name), ex); } } } } if (targetIndexMembers.ContainsKey(targetFieldName + "Specified")) { try { targetAccessor[targetItem, targetFieldName + "Specified"] = ((sourceValue != null) || bForceSpecified); } catch (Exception ex) { var message = string.Format("Unable to set {0}Specified as {1}. {2}", targetFieldName + "Specified", targetPropertyType.Name, ex.Message); throw new Exception(message, ex); } } } } catch (Exception exField) { var message = string.Format("Unable to set {0}. {1}", targetFieldName, exField.Message); throw new Exception(message, exField); } } return(targetItem); }
public static A CreateInstance() { return(TypeAccessor <A> .CreateInstance()); }
internal static T As <S, T>(this S item) where T : new() { return(item.As <S, T>(typeof(S).Members(), typeof(T).Members(), TypeAccessor.Create(typeof(S)), TypeAccessor.Create(typeof(T)))); }
public ValueAccessor(Type type) { _accessor = TypeAccessor.Create(type); _relatedProperties = new HashSet <string>(type.GetProperties().Select(i => i.Name)); }
internal static T[] AsArray <S, T>(this List <S> sourceList) where T : new() { var returnList = new List <T>(); foreach (var item in sourceList) { returnList.Add(item.As <S, T>(typeof(S).Members(), typeof(T).Members(), TypeAccessor.Create(typeof(S)), TypeAccessor.Create(typeof(T)))); } return(returnList.ToArray()); }
private static async Task MergeAsync <T>(DbContext context, Type type, IList <T> entities, TableInfo tableInfo, OperationType operationType, Action <decimal> progress, CancellationToken cancellationToken) where T : class { string providerName = context.Database.ProviderName; // -- SQL Server -- if (providerName.EndsWith(DbServer.SqlServer.ToString())) { tableInfo.InsertToTempTable = true; await tableInfo.CheckHasIdentityAsync(context, cancellationToken).ConfigureAwait(false); var dropTempTableIfExists = tableInfo.BulkConfig.UseTempDB; if (dropTempTableIfExists) { await context.Database.ExecuteSqlRawAsync(SqlQueryBuilder.DropTable(tableInfo.FullTempTableName, tableInfo.BulkConfig.UseTempDB)).ConfigureAwait(false); } await context.Database.ExecuteSqlRawAsync(SqlQueryBuilder.CreateTableCopy(tableInfo.FullTableName, tableInfo.FullTempTableName, tableInfo), cancellationToken).ConfigureAwait(false); if (tableInfo.CreatedOutputTable) { await context.Database.ExecuteSqlRawAsync(SqlQueryBuilder.CreateTableCopy(tableInfo.FullTableName, tableInfo.FullTempOutputTableName, tableInfo, true), cancellationToken).ConfigureAwait(false); if (tableInfo.TimeStampColumnName != null) { await context.Database.ExecuteSqlRawAsync(SqlQueryBuilder.AddColumn(tableInfo.FullTempOutputTableName, tableInfo.TimeStampColumnName, tableInfo.TimeStampOutColumnType), cancellationToken).ConfigureAwait(false); } } bool keepIdentity = tableInfo.BulkConfig.SqlBulkCopyOptions.HasFlag(SqlBulkCopyOptions.KeepIdentity); try { await InsertAsync(context, type, entities, tableInfo, progress, cancellationToken).ConfigureAwait(false); if (keepIdentity && tableInfo.HasIdentity) { await context.Database.OpenConnectionAsync(cancellationToken).ConfigureAwait(false); await context.Database.ExecuteSqlRawAsync(SqlQueryBuilder.SetIdentityInsert(tableInfo.FullTableName, true), cancellationToken).ConfigureAwait(false); } await context.Database.ExecuteSqlRawAsync(SqlQueryBuilder.MergeTable(tableInfo, operationType), cancellationToken).ConfigureAwait(false); if (tableInfo.CreatedOutputTable) { await tableInfo.LoadOutputDataAsync(context, type, entities, cancellationToken).ConfigureAwait(false); } } finally { if (!tableInfo.BulkConfig.UseTempDB) { if (tableInfo.CreatedOutputTable) { await context.Database.ExecuteSqlRawAsync(SqlQueryBuilder.DropTable(tableInfo.FullTempOutputTableName, tableInfo.BulkConfig.UseTempDB), cancellationToken).ConfigureAwait(false); } await context.Database.ExecuteSqlRawAsync(SqlQueryBuilder.DropTable(tableInfo.FullTempTableName, tableInfo.BulkConfig.UseTempDB), cancellationToken).ConfigureAwait(false); } if (keepIdentity && tableInfo.HasIdentity) { await context.Database.ExecuteSqlRawAsync(SqlQueryBuilder.SetIdentityInsert(tableInfo.FullTableName, false), cancellationToken).ConfigureAwait(false); context.Database.CloseConnection(); } } } // -- SQLite -- else if (providerName.EndsWith(DbServer.Sqlite.ToString())) { var connection = await OpenAndGetSqliteConnectionAsync(context, tableInfo.BulkConfig, cancellationToken).ConfigureAwait(false); var transaction = tableInfo.BulkConfig.SqliteTransaction ?? connection.BeginTransaction(); try { var command = GetSqliteCommand(context, type, entities, tableInfo, connection, transaction); var typeAccessor = TypeAccessor.Create(type, true); int rowsCopied = 0; foreach (var item in entities) { LoadSqliteValues(tableInfo, typeAccessor, item, command); await command.ExecuteNonQueryAsync(cancellationToken).ConfigureAwait(false); SetProgress(ref rowsCopied, entities.Count, tableInfo.BulkConfig, progress); } if (operationType != OperationType.Delete && tableInfo.BulkConfig.SetOutputIdentity && tableInfo.IdentityColumnName != null) { command.CommandText = SqlQueryBuilderSqlite.SelectLastInsertRowId(); long lastRowIdScalar = (long)await command.ExecuteScalarAsync(cancellationToken).ConfigureAwait(false); var identityPropertyInteger = false; var accessor = TypeAccessor.Create(type, true); string identityPropertyName = tableInfo.PropertyColumnNamesDict.SingleOrDefault(a => a.Value == tableInfo.IdentityColumnName).Key; if (accessor.GetMembers().FirstOrDefault(x => x.Name == identityPropertyName)?.Type == typeof(int)) { identityPropertyInteger = true; } for (int i = entities.Count - 1; i >= 0; i--) { if (identityPropertyInteger) { accessor[entities[i], identityPropertyName] = (int)lastRowIdScalar; } else { accessor[entities[i], identityPropertyName] = lastRowIdScalar; } lastRowIdScalar--; } } } finally { if (tableInfo.BulkConfig.SqliteTransaction == null) { transaction.Commit(); transaction.Dispose(); } if (tableInfo.BulkConfig.SqliteConnection == null) { connection.Close(); } } } else { throw new SqlProviderNotSupportedException(providerName); } }
public override void EnsureMapper(TypeAccessor typeAccessor, MappingSchema mappingSchema, EnsureMapperHandler handler) { foreach (var p in _list) p.EnsureMapper(typeAccessor, mappingSchema, handler); }
private static async Task InsertAsync <T>(DbContext context, Type type, IList <T> entities, TableInfo tableInfo, Action <decimal> progress, CancellationToken cancellationToken) { string providerName = context.Database.ProviderName; // "Microsoft.EntityFrameworkCore.*****" // -- SQL Server -- if (providerName.EndsWith(DbServer.SqlServer.ToString())) { var connection = await OpenAndGetSqlConnectionAsync(context, tableInfo.BulkConfig, cancellationToken).ConfigureAwait(false); var transaction = context.Database.CurrentTransaction; try { using (var sqlBulkCopy = GetSqlBulkCopy((SqlConnection)connection, transaction, tableInfo.BulkConfig)) { bool useFastMember = tableInfo.HasOwnedTypes == false && tableInfo.ColumnNameContainsSquareBracket == false && tableInfo.ShadowProperties.Count == 0 && !tableInfo.ConvertibleProperties.Any() && !tableInfo.HasAbstractList && !tableInfo.BulkConfig.UseOnlyDataTable; bool setColumnMapping = useFastMember; tableInfo.SetSqlBulkCopyConfig(sqlBulkCopy, entities, setColumnMapping, progress); try { if (useFastMember) { using (var reader = ObjectReaderEx.Create(type, entities, tableInfo.ShadowProperties, tableInfo.ConvertibleProperties, context, tableInfo.PropertyColumnNamesDict.Keys.ToArray())) { await sqlBulkCopy.WriteToServerAsync(reader, cancellationToken).ConfigureAwait(false); } } else { var dataTable = GetDataTable(context, type, entities, sqlBulkCopy, tableInfo); await sqlBulkCopy.WriteToServerAsync(dataTable, cancellationToken).ConfigureAwait(false); } } catch (InvalidOperationException ex) { if (ex.Message.Contains(ColumnMappingExceptionMessage)) { if (!await tableInfo.CheckTableExistAsync(context, tableInfo, cancellationToken).ConfigureAwait(false)) { await context.Database.ExecuteSqlRawAsync(SqlQueryBuilder.CreateTableCopy(tableInfo.FullTableName, tableInfo.FullTempTableName, tableInfo), cancellationToken).ConfigureAwait(false); await context.Database.ExecuteSqlRawAsync(SqlQueryBuilder.DropTable(tableInfo.FullTempTableName, tableInfo.BulkConfig.UseTempDB), cancellationToken).ConfigureAwait(false); } } throw ex; } } } finally { if (transaction == null) { connection.Close(); } } } // -- SQLite -- else if (providerName.EndsWith(DbServer.Sqlite.ToString())) { var connection = await OpenAndGetSqliteConnectionAsync(context, tableInfo.BulkConfig, cancellationToken).ConfigureAwait(false); var transaction = tableInfo.BulkConfig.SqliteTransaction ?? connection.BeginTransaction(); try { var command = GetSqliteCommand(context, type, entities, tableInfo, connection, transaction); var typeAccessor = TypeAccessor.Create(type, true); int rowsCopied = 0; foreach (var item in entities) { LoadSqliteValues(tableInfo, typeAccessor, item, command); await command.ExecuteNonQueryAsync(cancellationToken).ConfigureAwait(false); SetProgress(ref rowsCopied, entities.Count, tableInfo.BulkConfig, progress); } } finally { if (tableInfo.BulkConfig.SqliteTransaction == null) { transaction.Commit(); transaction.Dispose(); } if (tableInfo.BulkConfig.SqliteConnection == null) { connection.Close(); } } } else { throw new SqlProviderNotSupportedException(providerName); } }
public void DefCtorTest1() { DefCtorObject1 o = (DefCtorObject1)TypeAccessor.CreateInstance(typeof(DefCtorObject1)); Assert.AreEqual(10, o.Value); }
object IObjectFactory.CreateInstance(TypeAccessor typeAccessor, InitContext context) { return new TestObject(53); }
public object CreateInstance(TypeAccessor typeAccessor) { return typeAccessor.CreateInstance(); }
object GetObject(object o) { var obj = MemberAccessor.GetValue(o); if (_createInstance && obj == null) { if (_typeAccessor == null) _typeAccessor = TypeAccessor.GetAccessor(MemberAccessor.Type); obj = _typeAccessor.CreateInstanceEx(); MemberAccessor.SetValue(o, obj); } return obj; }
private static void Insert <T>(DbContext context, Type type, IList <T> entities, TableInfo tableInfo, Action <decimal> progress) { string providerName = context.Database.ProviderName; // "Microsoft.EntityFrameworkCore.*****" // -- SQL Server -- if (providerName.EndsWith(DbServer.SqlServer.ToString())) { var connection = OpenAndGetSqlConnection(context, tableInfo.BulkConfig); var transaction = context.Database.CurrentTransaction; try { using (var sqlBulkCopy = GetSqlBulkCopy((SqlConnection)connection, transaction, tableInfo.BulkConfig)) { bool useFastMember = tableInfo.HasOwnedTypes == false && // With OwnedTypes DataTable is used since library FastMember can not (https://github.com/mgravell/fast-member/issues/21) tableInfo.ColumnNameContainsSquareBracket == false && // FastMember does not support escaped columnNames ] -> ]] tableInfo.ShadowProperties.Count == 0 && // With Shadow prop. Discriminator (TPH inheritance) also not used because FastMember is slow for Update (https://github.com/borisdj/EFCore.BulkExtensions/pull/17) !tableInfo.ConvertibleProperties.Any() && // With ConvertibleProperties FastMember is slow as well !tableInfo.HasAbstractList && // AbstractList not working with FastMember !tableInfo.BulkConfig.UseOnlyDataTable; bool setColumnMapping = useFastMember; tableInfo.SetSqlBulkCopyConfig(sqlBulkCopy, entities, setColumnMapping, progress); try { if (useFastMember) { using (var reader = ObjectReaderEx.Create(type, entities, tableInfo.ShadowProperties, tableInfo.ConvertibleProperties, context, tableInfo.PropertyColumnNamesDict.Keys.ToArray())) { sqlBulkCopy.WriteToServer(reader); } } else { var dataTable = GetDataTable(context, type, entities, sqlBulkCopy, tableInfo); sqlBulkCopy.WriteToServer(dataTable); } } catch (InvalidOperationException ex) { if (ex.Message.Contains(ColumnMappingExceptionMessage)) { if (!tableInfo.CheckTableExist(context, tableInfo)) { context.Database.ExecuteSqlRaw(SqlQueryBuilder.CreateTableCopy(tableInfo.FullTableName, tableInfo.FullTempTableName, tableInfo)); // Will throw Exception specify missing db column: Invalid column name '' context.Database.ExecuteSqlRaw(SqlQueryBuilder.DropTable(tableInfo.FullTempTableName, tableInfo.BulkConfig.UseTempDB)); } } throw ex; } } } finally { if (transaction == null) { connection.Close(); } } } // -- SQLite -- else if (providerName.EndsWith(DbServer.Sqlite.ToString())) { var connection = OpenAndGetSqliteConnection(context, tableInfo.BulkConfig); var transaction = tableInfo.BulkConfig.SqliteTransaction ?? connection.BeginTransaction(); try { var command = GetSqliteCommand(context, type, entities, tableInfo, connection, transaction); var typeAccessor = TypeAccessor.Create(type, true); int rowsCopied = 0; foreach (var item in entities) { LoadSqliteValues(tableInfo, typeAccessor, item, command); command.ExecuteNonQuery(); SetProgress(ref rowsCopied, entities.Count, tableInfo.BulkConfig, progress); } } finally { if (tableInfo.BulkConfig.SqliteTransaction == null) { transaction.Commit(); transaction.Dispose(); } if (tableInfo.BulkConfig.SqliteConnection == null) { connection.Close(); } } } else { throw new SqlProviderNotSupportedException(providerName); } }
protected Message ExecuteMessage(Message message, RequestAttributes requestAttributes, IRequest httpReq, IResponse httpRes) { var soapFeature = requestAttributes.ToSoapFeature(); HostContext.AppHost.AssertFeatures(soapFeature); if (httpReq == null) { httpReq = HostContext.GetCurrentRequest(); } if (httpRes == null && httpReq != null) { httpRes = httpReq.Response; } if (httpReq == null) { throw new ArgumentNullException("httpReq"); } if (httpRes == null) { throw new ArgumentNullException("httpRes"); } httpReq.UseBufferedStream = true; var requestMsg = message ?? GetRequestMessageFromStream(httpReq.InputStream); var soapAction = httpReq.GetHeader(HttpHeaders.SOAPAction) ?? GetAction(requestMsg); if (soapAction != null) { httpReq.OperationName = soapAction.Trim('"'); } if (HostContext.ApplyCustomHandlerRequestFilters(httpReq, httpRes)) { return(PrepareEmptyResponse(message, httpReq)); } string requestXml = GetRequestXml(requestMsg); var requestType = GetRequestType(requestMsg, requestXml); httpReq.OperationName = requestType.GetOperationName(); if (!HostContext.Metadata.CanAccess(requestAttributes, soapFeature.ToFormat(), requestType.GetOperationName())) { throw HostContext.UnauthorizedAccess(requestAttributes); } try { var useXmlSerializerRequest = requestType.HasAttribute <XmlSerializerFormatAttribute>(); var request = useXmlSerializerRequest ? XmlSerializableSerializer.Instance.DeserializeFromString(requestXml, requestType) : Serialization.DataContractSerializer.Instance.DeserializeFromString(requestXml, requestType); httpReq.Dto = request; var requiresSoapMessage = request as IRequiresSoapMessage; if (requiresSoapMessage != null) { requiresSoapMessage.Message = requestMsg; } httpReq.SetItem("SoapMessage", requestMsg); httpRes.ContentType = GetSoapContentType(httpReq.ContentType); var hasRequestFilters = HostContext.GlobalRequestFilters.Count > 0 || FilterAttributeCache.GetRequestFilterAttributes(request.GetType()).Any(); if (hasRequestFilters && HostContext.ApplyRequestFilters(httpReq, httpRes, request)) { return(EmptyResponse(requestMsg, requestType)); } httpReq.RequestAttributes |= requestAttributes; var response = ExecuteService(request, httpReq); var taskResponse = response as Task; if (taskResponse != null) { taskResponse.Wait(); response = TypeAccessor.Create(taskResponse.GetType())[taskResponse, "Result"]; } var hasResponseFilters = HostContext.GlobalResponseFilters.Count > 0 || FilterAttributeCache.GetResponseFilterAttributes(response.GetType()).Any(); if (hasResponseFilters && HostContext.ApplyResponseFilters(httpReq, httpRes, response)) { return(EmptyResponse(requestMsg, requestType)); } var httpResult = response as IHttpResult; if (httpResult != null) { response = httpResult.Response; } var noMsgAction = requestMsg.Headers.Action == null; var responseMsg = CreateResponseMessage(response, requestMsg.Version, requestType, noMsgAction); if (httpResult != null) { SetErrorStatusIfAny(httpReq.Response, responseMsg, httpResult.Status); } return(responseMsg); } catch (Exception ex) { throw new SerializationException("3) Error trying to deserialize requestType: " + requestType + ", xml body: " + requestXml, ex); } }
public void InitCtorTest2() { InitCtorObject2 o = (InitCtorObject2)TypeAccessor.CreateInstance(typeof(InitCtorObject2)); Assert.AreEqual(10, o.Value); }
private IMapper GetObjectMapper(IObjectMapper mapper, ref int startIndex, TypeAccessor akTypeAccessor) { //Todo: Remove this Call! _extension = TypeExtension.GetTypeExtension(mapper.PropertyType /*_typeAccessor.OriginalType*/, MappingSchema.Extensions); Type mapperType = mapper.PropertyType; var objectMappers = new List<IObjectMapper>(); TableDescription tableDescription = GetTableDescription(mapperType); lock (SetterHandlersLock) { if (!SettersHandlers.ContainsKey(mapperType)) SettersHandlers.Add(mapperType, new Dictionary<string, SetHandler>()); if (!GettersHandlers.ContainsKey(mapperType)) GettersHandlers.Add(mapperType, new Dictionary<string, GetHandler>()); } PropertyInfo[] properties = mapperType.GetProperties(); MemberAccessor primaryKeyMemberAccessor = null; foreach (MemberAccessor ma in akTypeAccessor) { // Setters lock (SetterHandlersLock) { if (!SettersHandlers[mapper.PropertyType].ContainsKey(ma.Name)) { SettersHandlers[mapper.PropertyType].Add(ma.Name, ma.SetValue); } } if (GetPrimaryKey(ma) != null) { primaryKeyMemberAccessor = ma; lock (SetterHandlersLock) { if (!GettersHandlers[mapperType].ContainsKey(ma.Name)) { GettersHandlers[mapperType].Add(ma.Name, ma.GetValue); } } mapper.PrimaryKeyValueGetters.Add(GettersHandlers[mapperType][ma.Name]); mapper.PrimaryKeyNames.Add(ma.Name); if (mapper.Association != null && (mapper.Association.OtherKey == null || mapper.Association.OtherKey.Length == 0)) { mapper.Association.OtherKey = new[] {ma.Name}; } } } if (primaryKeyMemberAccessor == null) throw new Exception("PrimaryKey attribute not found on type: " + mapperType); foreach (PropertyInfo prop in properties) { var ma = akTypeAccessor.First(x => x.Name == prop.Name); // Check if the accessor is an association var association = GetAssociation(ma); if (association != null) { // Getters for IObjectMapper lock (SetterHandlersLock) if (!GettersHandlers[mapperType].ContainsKey(prop.Name)) { GettersHandlers[mapperType].Add(prop.Name, ma.GetValue); } bool isCollection = prop.PropertyType.GetInterfaces().ToList().Contains(typeof (IList)); IObjectMapper propertiesMapping; if (!isCollection) { // TODO Generate this instance using the CreateObjectMapperInstance method of fullMappingSchema // _db.MappingSchema.CreateObjectMapperInstance(prop.PropertyType) propertiesMapping = new FullObjectMapper(_db, _ignoreLazyLoad, _factoryType) { PropertyType = prop.PropertyType, IsNullable = association.CanBeNull, Getter = GettersHandlers[mapperType][prop.Name], }; } else { Type listElementType = GetGenericType(prop.PropertyType); TableDescription colElementTableDescription = GetTableDescription(listElementType); // TODO Generate this instance using the CreateObjectMapperInstance method of fullMappingSchema propertiesMapping = new CollectionFullObjectMapper(_db, _factoryType) { PropertyType = listElementType, Getter = GettersHandlers[mapperType][prop.Name], TableName = colElementTableDescription.TableName, PropertyCollectionType = prop.PropertyType, }; if (mapper is FullObjectMapper) ((FullObjectMapper) mapper).ColParent = true; } if (association.ThisKey == null || association.ThisKey.Length == 0) association.ThisKey = new[] {primaryKeyMemberAccessor.Name}; bool isLazy = false; if (!_ignoreLazyLoad) { var lazy = GetLazyInstance(ma); // prop.GetCustomAttributes(typeof(LazyInstanceAttribute), true); if (lazy) { isLazy = true; mapper.ContainsLazyChild = true; // Getters lock (SetterHandlersLock) if (!GettersHandlers[mapperType].ContainsKey(primaryKeyMemberAccessor.Name)) { GettersHandlers[mapperType].Add(primaryKeyMemberAccessor.Name, primaryKeyMemberAccessor.GetValue); } } } propertiesMapping.Association = association; propertiesMapping.PropertyName = prop.Name; propertiesMapping.IsLazy = isLazy; propertiesMapping.Setter = SettersHandlers[mapperType][prop.Name]; if (propertiesMapping.IsLazy) { propertiesMapping.ParentKeyGetter = GettersHandlers[mapperType][primaryKeyMemberAccessor.Name]; } objectMappers.Add(propertiesMapping); } else { var mapIgnore = GetMapIgnore(ma); if (mapIgnore) continue; var mapField = GetMapField(ma); string columnName = mapField != null ? mapField.MapName : prop.Name; var map = new ValueMapper { PropertyName = prop.Name, PropertyType = prop.PropertyType, DataReaderIndex = startIndex, Setter = SettersHandlers[mapperType][prop.Name], TableName = tableDescription.TableName, ColumnName = columnName, }; var mapColumnName = map.GetColumnName(columnName); map.ColumnAlias = columnName == mapColumnName ? null : mapColumnName; mapper.PropertiesMapping.Add(map); var pkField = GetPrimaryKey(ma); if (pkField != null) mapper.DataReaderIndex = startIndex; startIndex++; } } foreach (IObjectMapper objMap in objectMappers) { #region Check mapping recursion IObjectMapper cel = mapper; while (cel != null) { if (mapper.PropertyType == objMap.PropertyType) continue; cel = (IObjectMapper) cel.ParentMapping; } #endregion objMap.ParentMapping = mapper; mapper.PropertiesMapping.Add(GetObjectMapper(objMap, ref startIndex, MappingSchema.GetObjectMapper(objMap.PropertyType).TypeAccessor)); } return mapper; }
public override Expression BuildExpression(Expression expression, int level, bool enforceServerSide) { if (_isObject) { if (expression == null) { var type = _methodCall.Method.GetGenericArguments()[0]; var nctor = (NewExpression)Expression.Find(e => e is NewExpression ne && e.Type == type && ne.Arguments?.Count > 0); Expression expr; if (nctor != null) { var members = nctor.Members .Select(m => m is MethodInfo info ? info.GetPropertyInfo() : m) .ToList(); expr = Expression.New( nctor.Constructor, members.Select(m => Expression.PropertyOrField(_unionParameter, m.Name)), members); var ex = Builder.BuildExpression(this, expr, enforceServerSide); return(ex); } var isNew = Expression.Find(e => e is NewExpression && e.Type == type) != null; if (isNew) { var ta = TypeAccessor.GetAccessor(type); expr = Expression.MemberInit( Expression.New(ta.Type), _members.Select(m => Expression.Bind(m.Value.MemberExpression.Member, m.Value.MemberExpression))); var ex = Builder.BuildExpression(this, expr, enforceServerSide); return(ex); } else { var tableContext = new TableBuilder.TableContext(Builder, new BuildInfo(Parent, Expression, new SelectQuery()), type); var ex = tableContext.BuildExpression(null, 0, enforceServerSide); return(ex); } } if (level == 0 || level == 1) { var levelExpression = expression.GetLevelExpression(Builder.MappingSchema, 1); if (ReferenceEquals(expression, levelExpression) && !IsExpression(expression, 1, RequestFor.Object).Result) { var idx = ConvertToIndex(expression, level, ConvertFlags.Field); var n = idx[0].Index; if (Parent != null) { n = Parent.ConvertToParentIndex(n, this); } return(Builder.BuildSql(expression.Type, n)); } } } var ret = _sequence1.BuildExpression(expression, level, enforceServerSide); //if (level == 1) // _sequence2.BuildExpression(expression, level); return(ret); }
public object CreateInstance(TypeAccessor typeAccessor, InitContext context) { if (context == null) throw new Exception("InitContext is null while mapping from DataReader!"); return typeAccessor.CreateInstance(); }
public virtual void Init(MappingSchema mappingSchema, Type type) { if (type == null) { throw new ArgumentNullException("type"); } _typeAccessor = TypeAccessor.GetAccessor(type); _mappingSchema = mappingSchema; _extension = TypeExtension.GetTypeExtension(_typeAccessor.OriginalType, mappingSchema.Extensions); _inheritanceMapping.AddRange(GetInheritanceMapping()); foreach (MemberAccessor ma in _typeAccessor) { var a = GetAssociation(ma); if (a != null) { _associations.Add(a); continue; } if (GetMapIgnore(ma)) { continue; } var mapFieldAttr = GetMapField(ma); // ma.GetAttribute<MapFieldAttribute>(); if (mapFieldAttr == null || (mapFieldAttr.OrigName == null && mapFieldAttr.Format == null)) { var mi = new MapMemberInfo(); var dbTypeAttribute = GetDbType(ma); // ma.GetAttribute<DbTypeAttribute>(); if (dbTypeAttribute != null) { mi.DbType = dbTypeAttribute.DbType; mi.IsDbTypeSet = true; if (dbTypeAttribute.Size != null) { mi.DbSize = dbTypeAttribute.Size.Value; mi.IsDbSizeSet = true; } } mi.MemberAccessor = ma; mi.Type = ma.Type; mi.MappingSchema = mappingSchema; mi.MemberExtension = _extension[ma.Name]; mi.Name = GetFieldName(ma); mi.MemberName = ma.Name; mi.Storage = GetFieldStorage(ma); mi.IsInheritanceDiscriminator = GetInheritanceDiscriminator(ma); mi.Trimmable = GetTrimmable(ma); mi.SqlIgnore = GetSqlIgnore(ma); mi.MapValues = GetMapValues(ma); mi.DefaultValue = GetDefaultValue(ma); mi.Nullable = GetNullable(ma); mi.NullValue = GetNullValue(ma, mi.Nullable); Add(CreateMemberMapper(mi)); } else if (mapFieldAttr.OrigName != null) { EnsureMapper(mapFieldAttr.MapName, ma.Name + "." + mapFieldAttr.OrigName); } else //if (mapFieldAttr.Format != null) { foreach (MemberMapper inner in _mappingSchema.GetObjectMapper(ma.Type)) { EnsureMapper(string.Format(mapFieldAttr.Format, inner.Name), ma.Name + "." + inner.MemberName); } } } foreach (var ae in _extension.Attributes["MapField"]) { var mapName = (string)ae["MapName"]; var origName = (string)ae["OrigName"]; if (mapName == null || origName == null) { throw new MappingException(string.Format( "Type '{0}' has invalid extension. MapField MapName='{1}' OrigName='{2}'.", type.FullName, mapName, origName)); } EnsureMapper(mapName, origName); } MetadataProvider.EnsureMapper(TypeAccessor, MappingSchema, EnsureMapper); }
public SortMemberComparer(TypeAccessor typeAccessor, ListSortDirection direction, string[] memberNames) { _typeAccessor = typeAccessor; _direction = direction; _memberNames = memberNames; _members = new MemberAccessor[memberNames.Length]; _member = _members[0] = _typeAccessor[memberNames[0]]; if (_member == null) throw new InvalidOperationException( string.Format("Field '{0}.{1}' not found.", _typeAccessor.OriginalType.Name, _memberNames[0])); }
public static string GetUniquePropertyValues(object entity, List <string> propertiesNames, TypeAccessor accessor) { StringBuilder result = new StringBuilder(1024); foreach (var propertyName in propertiesNames) { result.Append(accessor[entity, propertyName]); } return(result.ToString()); }
public override void EnsureMapper(TypeAccessor typeAccessor, MappingSchema mappingSchema, EnsureMapperHandler handler) { foreach (MapFieldAttribute attr in GetMapFieldAttributes(typeAccessor)) { if (attr.OrigName != null) handler(attr.MapName, attr.OrigName); else { var ma = typeAccessor[attr.MapName]; foreach (MemberMapper inner in mappingSchema.GetObjectMapper(ma.Type)) handler(string.Format(attr.Format, inner.Name), ma.Name + "." + inner.MemberName); } } }
/// <summary> /// Strings to type. /// </summary> /// <param name="strType">Type of the string.</param> /// <param name="typeConfig">The type configuration.</param> /// <param name="ctorFn">The ctor function.</param> /// <param name="typeAccessors">The type accessors.</param> /// <returns>System.Object.</returns> internal static object StringToType(ReadOnlySpan <char> strType, TypeConfig typeConfig, EmptyCtorDelegate ctorFn, KeyValuePair <string, TypeAccessor>[] typeAccessors) { var index = 0; var type = typeConfig.Type; if (strType.IsEmpty) { return(null); } //if (!Serializer.EatMapStartChar(strType, ref index)) if (strType[index++] != JsWriter.MapStartChar) { throw DeserializeTypeRef.CreateSerializationError(type, strType.ToString()); } if (JsonTypeSerializer.IsEmptyMap(strType)) { return(ctorFn()); } var config = JsConfig.GetConfig(); object instance = null; var lenient = config.PropertyConvention == PropertyConvention.Lenient || config.TextCase == TextCase.SnakeCase; var strTypeLength = strType.Length; while (index < strTypeLength) { var propertyName = Serializer.EatMapKey(strType, ref index).Trim(); //Serializer.EatMapKeySeperator(strType, ref index); index++; var propertyValueStr = Serializer.EatValue(strType, ref index); var possibleTypeInfo = propertyValueStr != null && propertyValueStr.Length > 1; if (possibleTypeInfo && propertyName.Equals(typeAttr.Span, StringComparison.OrdinalIgnoreCase)) { var explicitTypeName = Serializer.ParseString(propertyValueStr); var explicitType = config.TypeFinder(explicitTypeName); if (explicitType == null || explicitType.IsInterface || explicitType.IsAbstract) { Tracer.Instance.WriteWarning("Could not find type: " + propertyValueStr.ToString()); } else if (!type.IsAssignableFrom(explicitType)) { Tracer.Instance.WriteWarning("Could not assign type: " + propertyValueStr.ToString()); } else { JsWriter.AssertAllowedRuntimeType(explicitType); instance = explicitType.CreateInstance(); } if (instance != null) { //If __type info doesn't match, ignore it. if (!type.IsInstanceOfType(instance)) { instance = null; } else { var derivedType = instance.GetType(); if (derivedType != type) { var map = DeserializeTypeRef.GetCachedTypeAccessors(derivedType, Serializer); if (map != null) { typeAccessors = map; } } } } //Serializer.EatItemSeperatorOrMapEndChar(strType, ref index); if (index != strType.Length) { index++; } continue; } instance ??= ctorFn(); var typeAccessor = typeAccessors.Get(propertyName, lenient); var propType = possibleTypeInfo && propertyValueStr[0] == '_' ? TypeAccessor.ExtractType(Serializer, propertyValueStr) : null; if (propType != null) { try { if (typeAccessor != null) { var parseFn = Serializer.GetParseStringSpanFn(propType); var propertyValue = parseFn(propertyValueStr); if (typeConfig.OnDeserializing != null) { propertyValue = typeConfig.OnDeserializing(instance, propertyName.ToString(), propertyValue); } typeAccessor.SetProperty(instance, propertyValue); } //Serializer.EatItemSeperatorOrMapEndChar(strType, ref index); if (index != strType.Length) { index++; } continue; } catch (Exception e) { config.OnDeserializationError?.Invoke(instance, propType, propertyName.ToString(), propertyValueStr.ToString(), e); if (config.ThrowOnError) { throw DeserializeTypeRef.GetSerializationException(propertyName.ToString(), propertyValueStr.ToString(), propType, e); } else { Tracer.Instance.WriteWarning("WARN: failed to set dynamic property {0} with: {1}", propertyName.ToString(), propertyValueStr.ToString()); } } } if (typeAccessor is { GetProperty : { }, SetProperty : { } })
public override Expression BuildExpression(Expression expression, int level) { if (_isObject) { if (expression == null) { var type = _methodCall.Method.GetGenericArguments()[0]; var nctor = (NewExpression)Expression.Find(e => { if (e.NodeType == ExpressionType.New && e.Type == type) { var ne = (NewExpression)e; return(ne.Arguments != null && ne.Arguments.Count > 0); } return(false); }); Expression expr; if (nctor != null) { var members = nctor.Members .Select(m => m is MethodInfo ? ((MethodInfo)m).GetPropertyInfo() : m) .ToList(); expr = Expression.New( nctor.Constructor, members .Select(m => Expression.PropertyOrField(_unionParameter, m.Name)) .Cast <Expression>(), members); } else { var ta = TypeAccessor.GetAccessor(type); expr = Expression.MemberInit( Expression.New(ta.Type), _members .Select(m => Expression.Bind(m.Value.MemberExpression.Member, m.Value.MemberExpression)) .Cast <MemberBinding>()); } var ex = Builder.BuildExpression(this, expr); return(ex); } if (level == 0 || level == 1) { var levelExpression = expression.GetLevelExpression(Builder.MappingSchema, 1); if (ReferenceEquals(expression, levelExpression) && !IsExpression(expression, 1, RequestFor.Object).Result) { var idx = ConvertToIndex(expression, level, ConvertFlags.Field); var n = idx[0].Index; if (Parent != null) { n = Parent.ConvertToParentIndex(n, this); } return(Builder.BuildSql(expression.Type, n)); } } } var ret = _sequence1.BuildExpression(expression, level); //if (level == 1) // _sequence2.BuildExpression(expression, level); return(ret); }
public static string SerializeProperties <T>(IEnumerable <string> properties, T entity, TypeAccessor accessor = null) { var result = new StringBuilder(); accessor = accessor ?? TypeAccessor.Create(typeof(T)); foreach (var prop in properties) { result.Append($"{prop}='{accessor[entity, prop]}', "); } result.ReplaceLastOccurrence(",", string.Empty); return(result.ToString()); }
public virtual void EnsureMapper(TypeAccessor typeAccessor, MappingSchema mappingSchema, EnsureMapperHandler handler) { }
protected EngineSerializer(T obj) { Obj = obj; Accessor = TypeAccessor.Create(typeof(T), true); }