protected void UpdateEntitiesIdentity <T>(IList <T> entities, IList <T> entitiesWithOutputIdentity)
{
if (BulkConfig.PreserveInsertOrder) // Updates PK in entityList
{
var accessor = TypeAccessor.Create(typeof(T), true);
for (int i = 0; i < NumberOfEntities; i++)
{
accessor[entities[i], PrimaryKeys[0]] = accessor[entitiesWithOutputIdentity[i], PrimaryKeys[0]];
}
}
else // Clears entityList and then refills it with loaded entites from Db
{
entities.Clear();
((List <T>)entities).AddRange(entitiesWithOutputIdentity);
}
}
public object GetValue <T>(T instanceOfObject) where T : class
{
if (instanceOfObject is IDynamicMetaObjectProvider dynamicInstance)
{
var helper = new DynamicObjectHelper();
helper.TryGetMember(dynamicInstance, Name, out var value);
return(value);
}
if (PropertyInfo != null) // SUPPORT FOR IOS
{
return(PropertyInfo.GetValue(instanceOfObject));
}
var accessor = TypeAccessor.Create(instanceOfObject.GetType(), true);
return(accessor[instanceOfObject, Name]);
}
public void AndThen_AutoMapper_knows_how_to_map_the_nonEntity_source_to_destination_for_From_Types()
{
foreach (var destination in _mapFromTypes)
{
var source = destination.GetInterfaces()
.Single(x => x.Name == "IMapFrom`1")
.GetGenericArguments()[0];
// Entities cannot be created using FastMember CreateNew so are skipped
if (TypeAccessor.Create(source).CreateNewSupported)
{
var instance = TypeAccessor.Create(source).CreateNew();
SUT.Map(instance, source, destination);
}
}
}
public void BasicReadTest_FieldsOnStruct()
{
var now = DateTime.Now;
var obj = new FieldsOnStruct()
{
A = 123, B = "abc", C = now, D = null
};
var access = TypeAccessor.Create(typeof(FieldsOnStruct));
Assert.AreEqual(123, access[obj, "A"]);
Assert.AreEqual("abc", access[obj, "B"]);
Assert.AreEqual(now, access[obj, "C"]);
Assert.AreEqual(null, access[obj, "D"]);
}
public void BasicReadTest_PropsOnClass()
{
var now = DateTime.Now;
var obj = new PropsOnClass()
{
A = 123, B = "abc", C = now, D = null
};
var access = TypeAccessor.Create(typeof(PropsOnClass));
Assert.Equal(123, access[obj, "A"]);
Assert.Equal("abc", access[obj, "B"]);
Assert.Equal(now, access[obj, "C"]);
Assert.Null(access[obj, "D"]);
}
public void CannotGenerateForStringNoneEquals()
{
var type = typeof(ComparisonStringDto);
var accessor = TypeAccessor.Create(type);
var members = accessor.GetMembers();
_tableStorageComparisonString.CanHandle(
new QueryParameter {
ContextValue = new ContextValue {
Values = new List <object> {
"abc"
}
}, MemberModel = new ModelMember(type, accessor, members.Single(), false)
});
string.IsNullOrEmpty(_tableStorageComparisonString.Generate()).ShouldBe(true);
}
private QueryStep QuerySource(Action <QueryExecutionContext> mapper)
{
var queryStep = _source.NewQueryStep();
var type = typeof(TSource);
var typeAccessor = TypeAccessor.Create(type);
var members = typeAccessor.GetMembers().ToList();
// TODO: Support multiple keys
var idMember = members.Single(x => x.GetAttribute(typeof(KeyAttribute), false) != null);
queryStep.QueryParameters.Add(new QueryParameter
{
MemberModel = new ModelMember(type, typeAccessor, idMember, false),
Rule = new ContextValueSetRule {
ForceCreateContextValueIfNull = true
}
});
queryStep.InMemoryFilterQueryParameters = GetInMemoryFilterQueryParameters();
queryStep.StepMapper = (ctx) =>
{
var connectionEdges = ctx.Context.GetQueryResults <ConnectionEdge>();
if (mapper != null)
{
var items = connectionEdges.Select(x => JsonConvert.DeserializeObject(
x.MetaValue, Type.GetType(x.MetaType))).ToList();
if (ctx.QueryStep.InMemoryFilterQueryParameters != null &&
ctx.QueryStep.InMemoryFilterQueryParameters.Count > 0)
{
items = _inMemoryComparerProvider.Query(ctx.QueryStep.InMemoryFilterQueryParameters, items);
var metaValues = items.Select(JsonConvert.SerializeObject).ToList();
connectionEdges = connectionEdges.Where(c => metaValues.Contains(c.MetaValue)).ToList();
}
// Override result.
ctx.Context.SetQueryResult(items);
mapper(ctx.Context);
}
return(connectionEdges.Select(x => (object)x.SourceId).ToList());
};
return(queryStep);
}
private async Task ProcessListAsync(List <object> items, MutationActions action, IGraphRequestContext context, bool forceHandle)
{
var typeAccessor = TypeAccessor.Create(items.First().GetType());
var listMembers = typeAccessor.GetMembers().Where(x => x.IsList());
var connectionEdgeMembers = typeAccessor.GetMembers().Where(x => x.GetAttribute(typeof(ConnectionEdgeDestinationAttribute), false) != null);
foreach (var x in _modelTransformers)
{
if (forceHandle || x.CanHandle(action))
{
foreach (var item in items)
{
await x.TransformAsync(item, typeAccessor, context);
foreach (var member in listMembers)
{
var value = typeAccessor[item, member.Name];
if (value != null)
{
List <object> memberItems = new List <object>();
var list = (IList)value;
foreach (var item1 in list)
{
memberItems.Add(item1);
}
if (memberItems.Count > 0)
{
await ProcessListAsync(memberItems, action, context, true);
}
}
}
foreach (var member in connectionEdgeMembers)
{
var value = typeAccessor[item, member.Name];
if (value != null)
{
await ProcessListAsync(new List <object> {
value
}, action, context, true);
}
}
}
}
}
}
private void SubscribeToEntityQueues()
{
//Add message handlers for all request types and entity types
foreach (var requestType in EntityTypes.EntityRequestTypes)
{
//This is where we store the handlers to pass to busManager
HandlerManager handlerManager = new HandlerManager();
//Do one queue/request type at a time
string requestQueue = null;
foreach (var entityType in EntityTypes.EntityBaseTypes)
{
//Get onRequest method (below) with appropriate request and entity type
var entityRequestType = requestType.MakeGenericType(entityType);
var onRequestMethod = GenericHelpers.GetMethodExt(this.GetType(), "OnRequest", typeof(void), new Type[] { requestType, typeof(MessageReceivedInfo) });
var onRequestMethodTyped = onRequestMethod.MakeGenericMethod(entityType);
//Create action delegate from typed onRequest method
var actionType = typeof(Action <,>).MakeGenericType(entityRequestType, typeof(MessageReceivedInfo));
var action = Delegate.CreateDelegate(actionType, this, onRequestMethodTyped);
//Instantiate a request of appropriate type to get at its request queue
if (requestQueue == null)
{
var requestAccessor = TypeAccessor.Create(entityRequestType);
var request = requestAccessor.CreateNew();
requestQueue = (string)requestAccessor[request, "RequestQueue"];
}
//Create QueueMessageHandler of approriate type and pass in action and queueName
var queueMessageHandlerType = typeof(QueueMessageHandler <>).MakeGenericType(entityRequestType);
var accessor = TypeAccessor.Create(queueMessageHandlerType);
var queueMessageHandler = accessor.CreateNew();
accessor[queueMessageHandler, "Handler"] = action;
accessor[queueMessageHandler, "QueueName"] = requestQueue;
//Get AddHandler method from handlerManager to add appropriate request type
var addHandlerMethod = GenericHelpers.GetMethodExt(handlerManager.GetType(), "AddHandler", typeof(void), new Type[] { queueMessageHandlerType });
var addHandlerMethodTyped = addHandlerMethod.MakeGenericMethod(entityRequestType);
addHandlerMethodTyped.Invoke(handlerManager, new object[] { queueMessageHandler });
}
//Subscribe with our filled up handlerManager
_busManager.Subscribe(_busManager.TopicExchange, requestQueue, handlerManager);
}
}
public static void RegisterDatabaseObject <TDto, TDb, TPk>(ContainerBuilder containerBuilder, bool isStatic)
where TDb : class
where TPk : struct
{
containerBuilder.RegisterType <Dao <TDb, TDto, TPk> >().As <IDao <IDto> >().As <IDao <TDto, TPk> >().SingleInstance();
if (!isStatic)
{
return;
}
var staticMetaDataAttribute = typeof(TDto).GetCustomAttribute <StaticMetaDataAttribute>();
containerBuilder.Register(c =>
{
var dic = c.Resolve <IDictionary <Type, Dictionary <string, Dictionary <RegionType, II18NDto> > > >();
var items = c.Resolve <IDao <TDto, TPk> >().LoadAll().ToList();
var props = StaticDtoExtension.GetI18NProperties(typeof(TDto));
if (props.Count > 0)
{
var regions = Enum.GetValues(typeof(RegionType));
var accessors = TypeAccessor.Create(typeof(TDto));
Parallel.ForEach(items, s => ((IStaticDto)s !).InjectI18N(props, dic, regions, accessors));
}
if ((items.Count != 0) || (staticMetaDataAttribute == null) ||
(staticMetaDataAttribute.EmptyMessage == LogLanguageKey.UNKNOWN))
{
if ((staticMetaDataAttribute != null) &&
(staticMetaDataAttribute.LoadedMessage != LogLanguageKey.UNKNOWN))
{
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 <TDto> >()
.SingleInstance()
.AutoActivate();
}
public bool CreateInstance(tbl.DynamicTable table)
{
var type = _typeDynamicExtensions.GetType(table.Name);
var accessor = TypeAccessor.Create(type);
var obj = Activator.CreateInstance(type);
accessor[obj, "Id"] = new Random().Next(0, 1000000000);
var _tableProperties = JsonConvert.DeserializeObject <List <TableProperty> >(table.TableProperty);
foreach (var item in _tableProperties)
{
accessor[obj, item.Name] = null;
}
_context.Add(obj);
_context.Set(type);
return(true);
}
public static void Merge <T>(DbContext context, IList <T> entities, TableInfo tableInfo, OperationType operationType) where T : class
{
tableInfo.InsertToTempTable = true;
tableInfo.CheckHasIdentity(context);
context.Database.ExecuteSqlCommand(SqlQueryBuilder.CreateTableCopy(tableInfo.FullTableName, tableInfo.FullTempTableName));
if (tableInfo.BulkConfig.SetOutputIdentity)
{
context.Database.ExecuteSqlCommand(SqlQueryBuilder.CreateTableCopy(tableInfo.FullTableName, tableInfo.FullTempOutputTableName));
}
try
{
SqlBulkOperation.Insert <T>(context, entities, tableInfo);
context.Database.ExecuteSqlCommand(SqlQueryBuilder.MergeTable(tableInfo, operationType));
context.Database.ExecuteSqlCommand(SqlQueryBuilder.DropTable(tableInfo.FullTempTableName));
if (tableInfo.BulkConfig.SetOutputIdentity)
{
var entitiesWithOutputIdentity = context.Set <T>().FromSql(SqlQueryBuilder.SelectFromTable(tableInfo.FullTempOutputTableName, tableInfo.PrimaryKeyFormated)).ToList();
if (tableInfo.BulkConfig.PreserveInsertOrder) // Updates PK in entityList
{
Type type = typeof(T);
var accessor = TypeAccessor.Create(type);
for (int i = 0; i < tableInfo.NumberOfEntities; i++)
{
accessor[entities[i], tableInfo.PrimaryKey] = accessor[entitiesWithOutputIdentity[i], tableInfo.PrimaryKey];
}
}
else // Clears entityList and then refill it with loaded entites from Db
{
entities.Clear();
((List <T>)entities).AddRange(entitiesWithOutputIdentity);
}
context.Database.ExecuteSqlCommand(SqlQueryBuilder.DropTable(tableInfo.FullTempOutputTableName));
}
}
catch (Exception ex)
{
if (tableInfo.BulkConfig.SetOutputIdentity)
{
context.Database.ExecuteSqlCommand(SqlQueryBuilder.DropTable(tableInfo.FullTempOutputTableName));
}
context.Database.ExecuteSqlCommand(SqlQueryBuilder.DropTable(tableInfo.FullTempTableName));
throw ex;
}
}
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="reader"></param>
/// <param name="type">Null Value Will Be Converted To Null Or DBNull</param>
/// <returns></returns>
public static T MapToType <T>(this DataRow row) where T : class
{
var accessor = TypeAccessor.Create(typeof(T), true);
var listOfProps = accessor.GetMembers().ToList();
var obj = TypeExtension.New <T> .Instance();
listOfProps.ForEach(delegate(Member member)
{
if (listOfProps.Contains(row[$"{member.Name}"]))
{
accessor[obj, member.Name] = row[$"{member.Name}"];
}
});
return(obj);
}
public DocumentDbRepositoryQueryTests()
{
Expression <Func <DocumentDbFoo3, string> > expression = x => x.Category;
"DocumentDbRepositoryQueryTests instantiated and loading config.".Log();
var configurations = GetBaseConfigurations <DocumentDbFoo3>((MemberExpression)expression.Body);
"Configuring DocumentDbRepository.".Log();
DocumentDbRepository.Configure(typeof(DocumentDbFoo3), configurations);
"Creating DocumentDbRepositoryQueryTests accessor type.".Log();
_accessor = TypeAccessor.Create(_type);
_members = _accessor.GetMembers();
"DocumentDbRepositoryQueryTests constructor.".Log();
}
public static RouteValueDictionary PropertiesToRouteValueDictionary([CanBeNull] this object obj,
Func <PropertyInfo, bool> filter = null,
bool shouldUseDataMember = false)
{
var res = new RouteValueDictionary();
if (obj == null)
{
return(res);
}
var object_type = obj.GetType();
var type_accessor = TypeAccessor.Create(object_type);
var type_info = GetTypeInfo(object_type);
foreach (var member in type_accessor.GetMembers())
{
if (!type_info.Properties.TryGetValue(member.Name, out var property))
{
continue;
}
if (filter != null && !filter(property))
{
continue;
}
var value = type_accessor[obj, member.Name];
if (type_info.PropertiesCustomFormat.TryGetValue(member.Name, out var display_format_attribute))
{
value = FormatValue(value, display_format_attribute);
}
if (shouldUseDataMember && TryGetDataMemberAttr(type_info, member.Name, out var data_member_attribute))
{
res.Add(data_member_attribute.Name, value);
}
else
{
res.Add(member.Name, value);
}
}
return(res);
}
private async Task <object> GetValue(
TypeAccessor edgeObjectTypeAccessor,
ConnectionEdge connectionEdge,
IGraphRequestContext graphRequestContext,
List <ConnectionEdgeDestinationFilter> connectionEdgeDestinationFilters,
QueryExecutionContext queryExecutionContext)
{
var member = edgeObjectTypeAccessor.GetMembers().Single(x => x.Name == connectionEdge.MetaFieldName);
var destTypeAccessor = TypeAccessor.Create(member.Type);
var destQueryMember = destTypeAccessor.GetMembers().Single(m => m.GetAttribute(typeof(KeyAttribute), true) != null);
var qp = new QueryStep();
qp.QueryParameters.Add(new QueryParameter
{
ContextValue = new ContextValue {
Comparison = Comparisons.Equal, Values = new List <object> {
connectionEdge.DestinationId
}
},
MemberModel = new ModelMember(member.Type, destTypeAccessor, destQueryMember, false)
});
if (connectionEdgeDestinationFilters != null)
{
connectionEdgeDestinationFilters.Where(x => x.Type == member.Type.AssemblyQualifiedName)
.ToList().ForEach(connectionEdgeDestinationFilter =>
{
qp.QueryParameters.Add(new QueryParameter
{
ContextValue = new ContextValue {
Comparison = Comparisons.Equal, Values = connectionEdgeDestinationFilter.Mapper(queryExecutionContext)
},
MemberModel = connectionEdgeDestinationFilter.ModelMember
});
});
}
var entities = (await _graphQlRepositoryProvider.QueryAsync(EntityQueryName, qp, graphRequestContext)).ToList();
if (entities.Count > 1)
{
throw new InvalidOperationException(MultipleEntitiesDetectedError);
}
return(entities.SingleOrDefault());
}
public static object GetResult(this Task task)
{
try
{
task.Wait();
return(TypeAccessor.Create(task.GetType())[task, "Result"]);
}
catch (TypeAccessException)
{
return(null); //return null for void Task's
}
catch (Exception ex)
{
throw ex.UnwrapIfSingleException();
}
}
protected void UpdateEntitiesIdentity <T>(IList <T> entities, IList <T> entitiesWithOutputIdentity)
{
if (BulkConfig.PreserveInsertOrder) // Updates PK in entityList
{
var accessor = TypeAccessor.Create(typeof(T), true);
string identityPropertyName = PropertyColumnNamesDict.SingleOrDefault(a => a.Value == IdentityColumnName).Key;
for (int i = 0; i < NumberOfEntities; i++)
{
accessor[entities[i], identityPropertyName] = accessor[entitiesWithOutputIdentity[i], identityPropertyName];
}
}
else // Clears entityList and then refills it with loaded entites from Db
{
entities.Clear();
((List <T>)entities).AddRange(entitiesWithOutputIdentity);
}
}
private static string WithFastMember(object obj, string name)
{
name = name.TrimStart('@');
var accessor = TypeAccessor.Create(obj.GetType());
var hasProp = accessor
.GetMembers()
.Any(m => m.Name == name);
if (!hasProp)
{
return(null);
}
var val = accessor[obj, name];
var result = ConvertResult(val);
return(result);
}
static Program()
{
testUri = new TestUri("SomeHost");
@object = testUri;
@class = testUri.GetType();
property = @class.GetProperty(propertyName, bindingFlags);
// Using FastMember - https://github.com/mgravell/fast-member
accessor = TypeAccessor.Create(@class, allowNonPublicAccessors: allowNonPublicFieldAccess);
flashReflectionType = ReflectionCache.Instance.GetReflectionType <TestUri>();
flashProperty = flashReflectionType.Properties[propertyName];
if (flashProperty == null)
{
throw new NullReferenceException("Flash property is null");
}
expressionTreeGetter = CompiledTreePropertyInfo.GetValueGetter <TestUri>(property);
expressionTreeSetter = CompiledTreePropertyInfo.GetValueSetter <TestUri>(property);
var funcType = typeof(Func <TestUri, string>);
getDelegate = (Func <TestUri, string>)Delegate.CreateDelegate(funcType, property.GetMethod);
getDelegateDynamic = Delegate.CreateDelegate(funcType, property.GetMethod);
var actionType = typeof(Action <TestUri, string>);
setDelegate = (Action <TestUri, string>)Delegate.CreateDelegate(actionType, property.SetMethod);
setDelegateDynamic = Delegate.CreateDelegate(actionType, property.SetMethod);
var setterEmiter = Emit <Action <TestUri, string> >
.NewDynamicMethod("SetTestUriProperty")
.LoadArgument(0)
.LoadArgument(1)
.Call(property.SetMethod)
.Return();
setter = setterEmiter.CreateDelegate();
var getterEmiter = Emit <Func <TestUri, string> >
.NewDynamicMethod("GetTestUriProperty")
.LoadArgument(0)
.Call(property.GetMethod)
.Return();
getter = getterEmiter.CreateDelegate();
}
public void TestGetMembersOnInheritedInterface()
{
var access = TypeAccessor.Create(typeof(IPropsOnInheritedInterface));
Assert.True(access.GetMembersSupported);
var members = access.GetMembers();
Assert.Equal(8, members.Count);
Assert.Equal("A", members[0].Name);
Assert.Equal("B", members[1].Name);
Assert.Equal("C", members[2].Name);
Assert.Equal("D", members[3].Name);
Assert.Equal("I", members[4].Name);
Assert.Equal("J", members[5].Name);
Assert.Equal("K", members[6].Name);
Assert.Equal("L", members[7].Name);
}
public T HashObjGet <T>(string hashKey, T model)
where T : class
{
EnsureKey(hashKey);
EnsureNotNull(nameof(model), model);
var hashValues = _db.HashGetAll(hashKey);
var obj = Activator.CreateInstance <T>();
var acc = TypeAccessor.Create(typeof(T));
foreach (var val in hashValues)
{
acc[obj, val.Name] = val.Value;
}
return(obj);
}
public static void SetMember <T> (this object obj, string memberPath, T value)
{
string[] memberNames = memberPath.Split('.');
string memberName = null;
object _obj = obj;
for (int i = 0; i < memberNames.Length; i++)
{
memberName = memberNames[i];
ObjectAccessor objectAccessor = ObjectAccessor.Create(obj);
_obj = obj;
obj = objectAccessor[memberName];
}
TypeAccessor typeAccessor = TypeAccessor.Create(_obj.GetType());
typeAccessor[_obj, memberName] = value;
}
private List <QueryParameter> GetQueryParameters <T>()
{
var accessor = TypeAccessor.Create(typeof(ConnectionEdge));
var member = accessor.GetMembers().Single(x => x.Name == "SourceType");
return(new List <QueryParameter> {
new QueryParameter
{
ContextValue = new ContextValue {
Comparison = Comparisons.Equal, Values = new List <object> {
typeof(T).AssemblyQualifiedName
}
},
MemberModel = new ModelMember(member.Type, accessor, member, false)
}
});
}
static T ToObject <T>(this IDataRecord r) where T : new()
{
var indexMembers = new Dictionary <string, Member>();
T obj = new T();
var accessor = TypeAccessor.Create(typeof(T));
var members = accessor.GetMembers();
foreach (var item in members)
{
indexMembers.Add(item.Name, item);
}
for (int i = 0; i < r.FieldCount; i++)
{
var name = r.GetName(i);
if (r.GetName(i).Equals("Amendment"))
{
//var k = 10;
}
if (indexMembers.ContainsKey(name))
{
var PropertyType = indexMembers[name].Type;
if (PropertyType == r[i].GetType())
{
accessor[obj, name] = r[i];
}
else
{
if (PropertyType.GenericTypeArguments.Contains(r[i].GetType()))
{
accessor[obj, name] = r[i];
}
else
{
var c = TypeDescriptor.GetConverter(r[i]);
if (c.CanConvertTo(PropertyType))
{
accessor[obj, name] = c.ConvertTo(r[i], PropertyType);
}
}
}
}
}
return(obj);
}
private IEnumerable <TEntity> MapResponse(LogAnalyticsResponse response) // TODO: move to seperate mapper
{
// Response Mapping ====================================
if (response?.Tables.IsNullOrEmpty() == false)
{
var accessors = TypeAccessor.Create(typeof(TEntity));
var table = response.Tables[0];
var keys = table.Columns.Safe().Select(c => c
.ColumnName.Safe().Replace("LogProperties_", string.Empty).SliceTillLast("_")).ToList();
if (!table.Rows.IsNullOrEmpty())
{
foreach (var values in table.Rows)
{
var result = Factory <TEntity> .Create();
var properties = new DataDictionary();
foreach (var key in keys.Ignore(new[] { "TenantId", "SourceSystem", "TimeGenerated", "ConnectionId" }))
{
var value = values[keys.IndexOf(key)];
if (value != null && !string.IsNullOrEmpty(value.ToString()))
{
properties.AddOrUpdate(key, value);
}
}
// dynamicly map all specified properties defined in entityMaps
foreach (var item in this.entityMap)
{
try
{
accessors[result, item.EntityProperty] = properties.TryGetValue(item.DtoProperty);
//properties.Remove(item.TargetProperty); // TODO: remove only if no further mappings based on TargetProperty
}
catch (System.ArgumentOutOfRangeException)
{
// target property not found, fastmember cannot set it
}
}
yield return(result);
}
}
}
}
/// <summary>
///This method loads navigation properties where we find a foreign key set but with a null value in the actual navigation property.
///This happens after an update as we are only setting the foreign key id, and returning the same entity.
/// </summary>
/// <typeparam name="T2">The type of entities</typeparam>
/// <param name="items">The entity or entities to process</param>
/// <returns></returns>
public List <T2> RefreshEntities <T2>(List <T2> items) where T2 : EntityBase
{
//Loop through entities fields and load navigation properties if we have an ID set with no related object field
TypeAccessor accessor = TypeAccessor.Create(typeof(T2));
var memberSet = accessor.GetMembers();
ObjectContext objectContext = ((IObjectContextAdapter)DataContext).ObjectContext;
ObjectSet <T2> set = objectContext.CreateObjectSet <T2>();
var foreignKeys = set.EntitySet.ElementType.NavigationProperties.SelectMany(n => n.GetDependentProperties());
var navProperties = set.EntitySet.ElementType.NavigationProperties.Select(np => np.Name);
foreach (var item in items)
{
foreach (var foreignKey in foreignKeys)
{
var foreignKeyField = foreignKey.Name;
var navProp = set.EntitySet.ElementType.NavigationProperties.SingleOrDefault(np => np.GetDependentProperties().Contains(foreignKey));
if (navProp == null)
{
continue;
}
var navPropField = navProp.Name;
var foreignKeyVal = accessor[item, foreignKeyField];
var isForeignKeyNull = IsNullEquivalent(memberSet.SingleOrDefault(member => member.Name == foreignKeyField), foreignKeyVal);
var navPropVal = accessor[item, navPropField];
if (!isForeignKeyNull && navPropVal == null)
{
var entityBaseItem = (item as EntityBase);
//If the item was unchanged we'll need to attach it first
if (entityBaseItem.State == ObjectState.Unchanged)
{
set.Attach(item);
}
DataContext.Entry(item).Reference(navPropField).Load();
}
}
}
return(items);
}
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="type"></param>
/// <param name="includeNonPublicAccessor"></param>
/// <returns>A List Of Advance Members Of T</returns>
public static List <MemberWrapper> GetMemberWrappers(Type type, bool includeNonPublicAccessor)
{
type.IsNullThrow(nameof(type));
// ReSharper disable once AssignNullToNotNullAttribute
var key = $"{type.FullName}{includeNonPublicAccessor}";
lock (Lock)
{
// https://stackoverflow.com/questions/9382681/what-is-more-efficient-dictionary-trygetvalue-or-containskeyitem
var membersAlreadyExist = Lookup.TryGetValue(key, out var cachedMembers);
if (membersAlreadyExist)
{
return(cachedMembers);
}
var list = new List <MemberWrapper>()
{
};
if (UseRuntimeReflection)
{
type.GetProperties().ForEach(delegate(PropertyInfo property)
{
var advance = new MemberWrapper(property)
{
};
list.Add(advance);
});
}
else
{
var accessor = TypeAccessor.Create(type, includeNonPublicAccessor);
var set = accessor.GetMembers();
for (var index = 0; index < set.Count; index++)
{
var member = set[index];
var advance = new MemberWrapper(member)
{
};
list.Add(advance);
}
}
Lookup.Add(key, list);
return(list);
}
}
public void TestCtor()
{
var accessor = TypeAccessor.Create(typeof(HasNoDefaultCtor));
Assert.False(accessor.CreateNewSupported);
accessor = TypeAccessor.Create(typeof(IsAbstract));
Assert.False(accessor.CreateNewSupported);
Assert.NotEqual("DynamicAccessor", accessor.GetType().Name);
Assert.NotEqual("DelegateAccessor", accessor.GetType().Name);
accessor = TypeAccessor.Create(typeof(HasDefaultCtor));
Assert.True(accessor.CreateNewSupported);
object obj = accessor.CreateNew();
Assert.IsType <HasDefaultCtor>(obj);
}
public void BasicWriteTest_PropsOnClass()
{
var now = DateTime.Now;
var obj = new PropsOnClass();
var access = TypeAccessor.Create(typeof(PropsOnClass));
access[obj, "A"] = 123;
access[obj, "B"] = "abc";
access[obj, "C"] = now;
access[obj, "D"] = null;
Assert.Equal(123, obj.A);
Assert.Equal("abc", obj.B);
Assert.Equal(now, obj.C);
Assert.Equal(null, obj.D);
}
