mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
Adding reference source for System.Data System.Data.DataSetExtensions System.Data.Entity System.Data.Entity.Design System.Data.Linq System.Data.SqlXml System.ServiceModel System.ServiceModel.Activation System.ServiceModel.Activities System.ServiceModel.Channels System.ServiceModel.Discovery System.ServiceModel.Internals System.ServiceModel.Routing System.ServiceModel.WasHosting System.ServiceModel.Web System.Web System.Web.ApplicationServices System.Web.DynamicData System.Web.Entity System.Web.Entity.Design System.Web.Extensions System.Web.Mobile System.Web.Routing System.Web.Services System.Xml System.Xml.Linq
612 lines
26 KiB
C#
612 lines
26 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Collections.ObjectModel;
|
|
using System.Linq.Expressions;
|
|
using System.Reflection;
|
|
using System.Text;
|
|
using System.Linq;
|
|
using System.Runtime.CompilerServices;
|
|
|
|
namespace System.Data.Linq {
|
|
using System.Data.Linq.Mapping;
|
|
using System.Data.Linq.Provider;
|
|
|
|
internal class CommonDataServices : IDataServices {
|
|
DataContext context;
|
|
MetaModel metaModel;
|
|
IdentityManager identifier;
|
|
ChangeTracker tracker;
|
|
ChangeDirector director;
|
|
bool hasCachedObjects;
|
|
Dictionary<MetaDataMember, IDeferredSourceFactory> factoryMap;
|
|
|
|
internal CommonDataServices(DataContext context, MetaModel model) {
|
|
this.context = context;
|
|
this.metaModel = model;
|
|
bool asReadOnly = !context.ObjectTrackingEnabled;
|
|
this.identifier = IdentityManager.CreateIdentityManager(asReadOnly);
|
|
this.tracker = ChangeTracker.CreateChangeTracker(this, asReadOnly);
|
|
this.director = ChangeDirector.CreateChangeDirector(context);
|
|
this.factoryMap = new Dictionary<MetaDataMember, IDeferredSourceFactory>();
|
|
}
|
|
|
|
public DataContext Context {
|
|
get { return this.context; }
|
|
}
|
|
|
|
public MetaModel Model {
|
|
get { return this.metaModel; }
|
|
}
|
|
|
|
internal void SetModel(MetaModel model) {
|
|
this.metaModel = model;
|
|
}
|
|
|
|
internal IdentityManager IdentityManager {
|
|
get { return this.identifier; }
|
|
}
|
|
|
|
internal ChangeTracker ChangeTracker {
|
|
get { return this.tracker; }
|
|
}
|
|
|
|
internal ChangeDirector ChangeDirector {
|
|
get { return this.director; }
|
|
}
|
|
|
|
internal IEnumerable<RelatedItem> GetParents(MetaType type, object item) {
|
|
return this.GetRelations(type, item, true);
|
|
}
|
|
|
|
internal IEnumerable<RelatedItem> GetChildren(MetaType type, object item) {
|
|
return this.GetRelations(type, item, false);
|
|
}
|
|
|
|
private IEnumerable<RelatedItem> GetRelations(MetaType type, object item, bool isForeignKey) {
|
|
foreach (MetaDataMember mm in type.PersistentDataMembers) {
|
|
if (mm.IsAssociation) {
|
|
MetaType otherType = mm.Association.OtherType;
|
|
if (mm.Association.IsForeignKey == isForeignKey) {
|
|
object value = null;
|
|
if (mm.IsDeferred) {
|
|
value = mm.DeferredValueAccessor.GetBoxedValue(item);
|
|
}
|
|
else {
|
|
value = mm.StorageAccessor.GetBoxedValue(item);
|
|
}
|
|
if (value != null) {
|
|
if (mm.Association.IsMany) {
|
|
IEnumerable list = (IEnumerable)value;
|
|
foreach (object otherItem in list) {
|
|
yield return new RelatedItem(otherType.GetInheritanceType(otherItem.GetType()), otherItem);
|
|
}
|
|
}
|
|
else {
|
|
yield return new RelatedItem(otherType.GetInheritanceType(value.GetType()), value);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
internal void ResetServices() {
|
|
hasCachedObjects = false;
|
|
bool asReadOnly = !context.ObjectTrackingEnabled;
|
|
this.identifier = IdentityManager.CreateIdentityManager(asReadOnly);
|
|
this.tracker = ChangeTracker.CreateChangeTracker(this, asReadOnly);
|
|
this.factoryMap = new Dictionary<MetaDataMember, IDeferredSourceFactory>();
|
|
}
|
|
|
|
internal static object[] GetKeyValues(MetaType type, object instance) {
|
|
List<object> keyValues = new List<object>();
|
|
foreach (MetaDataMember mm in type.IdentityMembers) {
|
|
keyValues.Add(mm.MemberAccessor.GetBoxedValue(instance));
|
|
}
|
|
return keyValues.ToArray();
|
|
}
|
|
|
|
internal static object[] GetForeignKeyValues(MetaAssociation association, object instance) {
|
|
List<object> keyValues = new List<object>();
|
|
foreach(MetaDataMember mm in association.ThisKey) {
|
|
keyValues.Add(mm.MemberAccessor.GetBoxedValue(instance));
|
|
}
|
|
return keyValues.ToArray();
|
|
}
|
|
|
|
internal object GetCachedObject(MetaType type, object[] keyValues) {
|
|
if( type == null ) {
|
|
throw Error.ArgumentNull("type");
|
|
}
|
|
if (!type.IsEntity) {
|
|
return null;
|
|
}
|
|
return this.identifier.Find(type, keyValues);
|
|
}
|
|
|
|
internal object GetCachedObjectLike(MetaType type, object instance) {
|
|
if( type == null ) {
|
|
throw Error.ArgumentNull("type");
|
|
}
|
|
if (!type.IsEntity) {
|
|
return null;
|
|
}
|
|
return this.identifier.FindLike(type, instance);
|
|
}
|
|
|
|
public bool IsCachedObject(MetaType type, object instance) {
|
|
if( type == null ) {
|
|
throw Error.ArgumentNull("type");
|
|
}
|
|
if (!type.IsEntity) {
|
|
return false;
|
|
}
|
|
return this.identifier.FindLike(type, instance) == instance;
|
|
}
|
|
|
|
public object InsertLookupCachedObject(MetaType type, object instance) {
|
|
if( type == null ) {
|
|
throw Error.ArgumentNull("type");
|
|
}
|
|
hasCachedObjects = true; // flag that we have cached objects
|
|
if (!type.IsEntity) {
|
|
return instance;
|
|
}
|
|
return this.identifier.InsertLookup(type, instance);
|
|
}
|
|
|
|
public bool RemoveCachedObjectLike(MetaType type, object instance) {
|
|
if (type == null) {
|
|
throw Error.ArgumentNull("type");
|
|
}
|
|
if (!type.IsEntity) {
|
|
return false;
|
|
}
|
|
return this.identifier.RemoveLike(type, instance);
|
|
}
|
|
|
|
public void OnEntityMaterialized(MetaType type, object instance) {
|
|
if (type == null) {
|
|
throw Error.ArgumentNull("type");
|
|
}
|
|
this.tracker.FastTrack(instance);
|
|
|
|
if (type.HasAnyLoadMethod) {
|
|
SendOnLoaded(type, instance);
|
|
}
|
|
}
|
|
|
|
private static void SendOnLoaded(MetaType type, object item) {
|
|
if (type != null) {
|
|
SendOnLoaded(type.InheritanceBase, item);
|
|
|
|
if (type.OnLoadedMethod != null) {
|
|
try {
|
|
type.OnLoadedMethod.Invoke(item, new object[] { });
|
|
} catch (TargetInvocationException tie) {
|
|
if (tie.InnerException != null) {
|
|
throw tie.InnerException;
|
|
}
|
|
|
|
throw;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Returns a query for the entity indicated by the specified key.
|
|
/// </summary>
|
|
internal Expression GetObjectQuery(MetaType type, object[] keyValues) {
|
|
if (type == null) {
|
|
throw Error.ArgumentNull("type");
|
|
}
|
|
if (keyValues == null) {
|
|
throw Error.ArgumentNull("keyValues");
|
|
}
|
|
return this.GetObjectQuery(type, BuildKeyExpressions(keyValues, type.IdentityMembers));
|
|
}
|
|
|
|
internal Expression GetObjectQuery(MetaType type, Expression[] keyValues) {
|
|
ITable table = this.context.GetTable(type.InheritanceRoot.Type);
|
|
ParameterExpression serverItem = Expression.Parameter(table.ElementType, "p");
|
|
|
|
// create a where expression including all the identity members
|
|
Expression whereExpression = null;
|
|
for (int i = 0, n = type.IdentityMembers.Count; i < n; i++) {
|
|
MetaDataMember metaMember = type.IdentityMembers[i];
|
|
Expression memberExpression = (metaMember.Member is FieldInfo)
|
|
? Expression.Field(serverItem, (FieldInfo)metaMember.Member)
|
|
: Expression.Property(serverItem, (PropertyInfo)metaMember.Member);
|
|
Expression memberEqualityExpression = Expression.Equal(memberExpression, keyValues[i]);
|
|
whereExpression = (whereExpression != null)
|
|
? Expression.And(whereExpression, memberEqualityExpression)
|
|
: memberEqualityExpression;
|
|
}
|
|
return Expression.Call(typeof(Queryable), "Where", new Type[] { table.ElementType }, table.Expression, Expression.Lambda(whereExpression, serverItem));
|
|
}
|
|
|
|
internal Expression GetDataMemberQuery(MetaDataMember member, Expression[] keyValues) {
|
|
if (member == null)
|
|
throw Error.ArgumentNull("member");
|
|
if (keyValues == null)
|
|
throw Error.ArgumentNull("keyValues");
|
|
if (member.IsAssociation) {
|
|
MetaAssociation association = member.Association;
|
|
Type rootType = association.ThisMember.DeclaringType.InheritanceRoot.Type;
|
|
Expression thisSource = Expression.Constant(context.GetTable(rootType));
|
|
if (rootType != association.ThisMember.DeclaringType.Type) {
|
|
thisSource = Expression.Call(typeof(Enumerable), "Cast", new Type[] { association.ThisMember.DeclaringType.Type }, thisSource);
|
|
}
|
|
Expression thisInstance = Expression.Call(typeof(Enumerable), "FirstOrDefault", new Type[] { association.ThisMember.DeclaringType.Type },
|
|
System.Data.Linq.SqlClient.Translator.WhereClauseFromSourceAndKeys(thisSource, association.ThisKey.ToArray(), keyValues)
|
|
);
|
|
Expression otherSource = Expression.Constant(context.GetTable(association.OtherType.InheritanceRoot.Type));
|
|
if (association.OtherType.Type!=association.OtherType.InheritanceRoot.Type) {
|
|
otherSource = Expression.Call(typeof(Enumerable), "Cast", new Type[] { association.OtherType.Type }, otherSource);
|
|
}
|
|
Expression expr = System.Data.Linq.SqlClient.Translator.TranslateAssociation(
|
|
this.context, association, otherSource, keyValues, thisInstance
|
|
);
|
|
return expr;
|
|
}
|
|
else {
|
|
Expression query = this.GetObjectQuery(member.DeclaringType, keyValues);
|
|
Type elementType = System.Data.Linq.SqlClient.TypeSystem.GetElementType(query.Type);
|
|
ParameterExpression p = Expression.Parameter(elementType, "p");
|
|
Expression e = p;
|
|
if (elementType != member.DeclaringType.Type)
|
|
e = Expression.Convert(e, member.DeclaringType.Type);
|
|
Expression mem = (member.Member is PropertyInfo)
|
|
? Expression.Property(e, (PropertyInfo)member.Member)
|
|
: Expression.Field(e, (FieldInfo)member.Member);
|
|
LambdaExpression selector = Expression.Lambda(mem, p);
|
|
return Expression.Call(typeof(Queryable), "Select", new Type[] { elementType, selector.Body.Type }, query, selector);
|
|
}
|
|
}
|
|
|
|
private static Expression[] BuildKeyExpressions(object[] keyValues, ReadOnlyCollection<MetaDataMember> keyMembers) {
|
|
Expression[] keyValueExpressions = new Expression[keyValues.Length];
|
|
for (int i = 0, n = keyMembers.Count; i < n; i++) {
|
|
MetaDataMember metaMember = keyMembers[i];
|
|
Expression keyValueExpression = Expression.Constant(keyValues[i], metaMember.Type);
|
|
keyValueExpressions[i] = keyValueExpression;
|
|
}
|
|
return keyValueExpressions;
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
|
|
public IDeferredSourceFactory GetDeferredSourceFactory(MetaDataMember member) {
|
|
if (member == null) {
|
|
throw Error.ArgumentNull("member");
|
|
}
|
|
IDeferredSourceFactory factory;
|
|
if (this.factoryMap.TryGetValue(member, out factory)) {
|
|
return factory;
|
|
}
|
|
Type elemType = member.IsAssociation && member.Association.IsMany
|
|
? System.Data.Linq.SqlClient.TypeSystem.GetElementType(member.Type)
|
|
: member.Type;
|
|
factory = (IDeferredSourceFactory) Activator.CreateInstance(
|
|
typeof(DeferredSourceFactory<>).MakeGenericType(elemType),
|
|
BindingFlags.Instance | BindingFlags.NonPublic, null,
|
|
new object[] { member, this }, null
|
|
);
|
|
this.factoryMap.Add(member, factory);
|
|
return factory;
|
|
}
|
|
|
|
class DeferredSourceFactory<T> : IDeferredSourceFactory {
|
|
MetaDataMember member;
|
|
CommonDataServices services;
|
|
ICompiledQuery query;
|
|
bool refersToPrimaryKey;
|
|
T[] empty;
|
|
|
|
internal DeferredSourceFactory(MetaDataMember member, CommonDataServices services) {
|
|
this.member = member;
|
|
this.services = services;
|
|
this.refersToPrimaryKey = this.member.IsAssociation && this.member.Association.OtherKeyIsPrimaryKey;
|
|
this.empty = new T[] { };
|
|
}
|
|
|
|
public IEnumerable CreateDeferredSource(object instance) {
|
|
if (instance == null)
|
|
throw Error.ArgumentNull("instance");
|
|
return new DeferredSource(this, instance);
|
|
}
|
|
|
|
public IEnumerable CreateDeferredSource(object[] keyValues) {
|
|
if (keyValues == null)
|
|
throw Error.ArgumentNull("keyValues");
|
|
return new DeferredSource(this, keyValues);
|
|
}
|
|
|
|
private IEnumerator<T> Execute(object instance) {
|
|
ReadOnlyCollection<MetaDataMember> keys = null;
|
|
if (this.member.IsAssociation) {
|
|
keys = this.member.Association.ThisKey;
|
|
}
|
|
else {
|
|
keys = this.member.DeclaringType.IdentityMembers;
|
|
}
|
|
object[] keyValues = new object[keys.Count];
|
|
for (int i = 0, n = keys.Count; i < n; i++) {
|
|
object value = keys[i].StorageAccessor.GetBoxedValue(instance);
|
|
keyValues[i] = value;
|
|
}
|
|
|
|
if (this.HasNullForeignKey(keyValues)) {
|
|
return ((IEnumerable<T>)this.empty).GetEnumerator();
|
|
}
|
|
|
|
T cached;
|
|
if (this.TryGetCachedObject(keyValues, out cached)) {
|
|
return ((IEnumerable<T>)(new T[] { cached })).GetEnumerator();
|
|
}
|
|
|
|
if (this.member.LoadMethod != null) {
|
|
try {
|
|
object result = this.member.LoadMethod.Invoke(this.services.Context, new object[] { instance });
|
|
if (typeof(T).IsAssignableFrom(this.member.LoadMethod.ReturnType)) {
|
|
return ((IEnumerable<T>)new T[] { (T)result }).GetEnumerator();
|
|
}
|
|
else {
|
|
return ((IEnumerable<T>)result).GetEnumerator();
|
|
}
|
|
}
|
|
catch (TargetInvocationException tie) {
|
|
if (tie.InnerException != null) {
|
|
throw tie.InnerException;
|
|
}
|
|
throw;
|
|
}
|
|
}
|
|
else {
|
|
return this.ExecuteKeyQuery(keyValues);
|
|
}
|
|
}
|
|
|
|
private IEnumerator<T> ExecuteKeys(object[] keyValues) {
|
|
if (this.HasNullForeignKey(keyValues)) {
|
|
return ((IEnumerable<T>)this.empty).GetEnumerator();
|
|
}
|
|
|
|
T cached;
|
|
if (this.TryGetCachedObject(keyValues, out cached)) {
|
|
return ((IEnumerable<T>)(new T[] { cached })).GetEnumerator();
|
|
}
|
|
|
|
return this.ExecuteKeyQuery(keyValues);
|
|
}
|
|
|
|
private bool HasNullForeignKey(object[] keyValues) {
|
|
if (this.refersToPrimaryKey) {
|
|
bool keyHasNull = false;
|
|
for (int i = 0, n = keyValues.Length; i < n; i++) {
|
|
keyHasNull |= keyValues[i] == null;
|
|
}
|
|
if (keyHasNull) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private bool TryGetCachedObject(object[] keyValues, out T cached) {
|
|
cached = default(T);
|
|
if (this.refersToPrimaryKey) {
|
|
// look to see if we already have this object in the identity cache
|
|
MetaType mt = this.member.IsAssociation ? this.member.Association.OtherType : this.member.DeclaringType;
|
|
object obj = this.services.GetCachedObject(mt, keyValues);
|
|
if (obj != null) {
|
|
cached = (T)obj;
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private IEnumerator<T> ExecuteKeyQuery(object[] keyValues) {
|
|
if (this.query == null) {
|
|
ParameterExpression p = Expression.Parameter(typeof(object[]), "keys");
|
|
Expression[] keyExprs = new Expression[keyValues.Length];
|
|
ReadOnlyCollection<MetaDataMember> members = this.member.IsAssociation ? this.member.Association.OtherKey : this.member.DeclaringType.IdentityMembers;
|
|
for (int i = 0, n = keyValues.Length; i < n; i++) {
|
|
MetaDataMember mm = members[i];
|
|
keyExprs[i] = Expression.Convert(
|
|
#pragma warning disable 618 // Disable the 'obsolete' warning
|
|
Expression.ArrayIndex(p, Expression.Constant(i)),
|
|
#pragma warning restore 618
|
|
mm.Type
|
|
);
|
|
}
|
|
Expression q = this.services.GetDataMemberQuery(this.member, keyExprs);
|
|
LambdaExpression lambda = Expression.Lambda(q, p);
|
|
this.query = this.services.Context.Provider.Compile(lambda);
|
|
}
|
|
return ((IEnumerable<T>)this.query.Execute(this.services.Context.Provider, new object[] { keyValues }).ReturnValue).GetEnumerator();
|
|
}
|
|
|
|
class DeferredSource : IEnumerable<T>, IEnumerable {
|
|
DeferredSourceFactory<T> factory;
|
|
object instance;
|
|
|
|
internal DeferredSource(DeferredSourceFactory<T> factory, object instance) {
|
|
this.factory = factory;
|
|
this.instance = instance;
|
|
}
|
|
|
|
public IEnumerator<T> GetEnumerator() {
|
|
object[] keyValues = this.instance as object[];
|
|
if (keyValues != null) {
|
|
return this.factory.ExecuteKeys(keyValues);
|
|
}
|
|
return this.factory.Execute(this.instance);
|
|
}
|
|
|
|
IEnumerator IEnumerable.GetEnumerator() {
|
|
return this.GetEnumerator();
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns true if any objects have been added to the identity cache. If
|
|
/// object tracking is disabled, this still returns true if any attempts
|
|
/// where made to cache an object. Thus regardless of object tracking mode,
|
|
/// this can be used as an indicator as to whether any result returning queries
|
|
/// have been executed.
|
|
/// </summary>
|
|
internal bool HasCachedObjects {
|
|
get {
|
|
return this.hasCachedObjects;
|
|
}
|
|
}
|
|
|
|
public object GetCachedObject(Expression query) {
|
|
if (query == null)
|
|
return null;
|
|
MethodCallExpression mc = query as MethodCallExpression;
|
|
if (mc == null || mc.Arguments.Count < 1 || mc.Arguments.Count > 2)
|
|
return null;
|
|
if (mc.Method.DeclaringType != typeof(Queryable)) {
|
|
return null;
|
|
}
|
|
switch (mc.Method.Name) {
|
|
case "Where":
|
|
case "First":
|
|
case "FirstOrDefault":
|
|
case "Single":
|
|
case "SingleOrDefault":
|
|
break;
|
|
default:
|
|
return null;
|
|
}
|
|
if (mc.Arguments.Count == 1) {
|
|
// If it is something like
|
|
// context.Customers.Where(c => c.ID = 123).First()
|
|
// then it is equivalent of
|
|
// context.Customers.First(c => c.ID = 123)
|
|
// hence reduce to context.Customers.Where(c => c.ID = 123) and process the remaining query
|
|
return GetCachedObject(mc.Arguments[0]);
|
|
}
|
|
UnaryExpression quote = mc.Arguments[1] as UnaryExpression;
|
|
if (quote == null || quote.NodeType != ExpressionType.Quote)
|
|
return null;
|
|
LambdaExpression pred = quote.Operand as LambdaExpression;
|
|
if (pred == null)
|
|
return null;
|
|
ConstantExpression cex = mc.Arguments[0] as ConstantExpression;
|
|
if (cex == null)
|
|
return null;
|
|
ITable t = cex.Value as ITable;
|
|
if (t == null)
|
|
return null;
|
|
Type elementType = System.Data.Linq.SqlClient.TypeSystem.GetElementType(query.Type);
|
|
if (elementType != t.ElementType)
|
|
return null;
|
|
MetaTable metaTable = this.metaModel.GetTable(t.ElementType);
|
|
object[] keyValues = this.GetKeyValues(metaTable.RowType, pred);
|
|
if (keyValues != null) {
|
|
return this.GetCachedObject(metaTable.RowType, keyValues);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
internal object[] GetKeyValues(MetaType type, LambdaExpression predicate) {
|
|
if (predicate == null)
|
|
throw Error.ArgumentNull("predicate");
|
|
if (predicate.Parameters.Count != 1)
|
|
return null;
|
|
Dictionary<MetaDataMember, object> keys = new Dictionary<MetaDataMember, object>();
|
|
if (this.GetKeysFromPredicate(type, keys, predicate.Body)
|
|
&& keys.Count == type.IdentityMembers.Count) {
|
|
object[] values = keys.OrderBy(kv => kv.Key.Ordinal).Select(kv => kv.Value).ToArray();
|
|
return values;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private bool GetKeysFromPredicate(MetaType type, Dictionary<MetaDataMember, object> keys, Expression expr) {
|
|
BinaryExpression bex = expr as BinaryExpression;
|
|
if (bex == null) {
|
|
MethodCallExpression mex = expr as MethodCallExpression;
|
|
if (mex != null && mex.Method.Name == "op_Equality" && mex.Arguments.Count == 2) {
|
|
bex = Expression.Equal(mex.Arguments[0], mex.Arguments[1]);
|
|
}
|
|
else {
|
|
return false;
|
|
}
|
|
}
|
|
switch (bex.NodeType) {
|
|
case ExpressionType.And:
|
|
return this.GetKeysFromPredicate(type, keys, bex.Left) &&
|
|
this.GetKeysFromPredicate(type, keys, bex.Right);
|
|
case ExpressionType.Equal:
|
|
return GetKeyFromPredicate(type, keys, bex.Left, bex.Right) ||
|
|
GetKeyFromPredicate(type, keys, bex.Right, bex.Left);
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
private static bool GetKeyFromPredicate(MetaType type, Dictionary<MetaDataMember, object> keys, Expression mex, Expression vex) {
|
|
MemberExpression memex = mex as MemberExpression;
|
|
if (memex == null || memex.Expression == null ||
|
|
memex.Expression.NodeType != ExpressionType.Parameter || memex.Expression.Type != type.Type) {
|
|
return false;
|
|
}
|
|
if (!type.Type.IsAssignableFrom(memex.Member.ReflectedType) && !memex.Member.ReflectedType.IsAssignableFrom(type.Type)) {
|
|
return false;
|
|
}
|
|
MetaDataMember mm = type.GetDataMember(memex.Member);
|
|
if (!mm.IsPrimaryKey) {
|
|
return false;
|
|
}
|
|
if (keys.ContainsKey(mm)) {
|
|
return false;
|
|
}
|
|
ConstantExpression cex = vex as ConstantExpression;
|
|
if (cex != null) {
|
|
keys.Add(mm, cex.Value);
|
|
return true;
|
|
}
|
|
InvocationExpression ie = vex as InvocationExpression;
|
|
if (ie != null && ie.Arguments != null && ie.Arguments.Count == 0) {
|
|
ConstantExpression ce = ie.Expression as ConstantExpression;
|
|
if (ce != null) {
|
|
keys.Add(mm, ((Delegate)ce.Value).DynamicInvoke(new object[] {}));
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Either returns the object from cache if it is in cache, or
|
|
/// queries for it.
|
|
/// </summary>
|
|
internal object GetObjectByKey(MetaType type, object[] keyValues) {
|
|
// first check the cache
|
|
object target = GetCachedObject(type, keyValues);
|
|
if (target == null) {
|
|
// no cached value, so query for it
|
|
target = ((IEnumerable)this.context.Provider.Execute(this.GetObjectQuery(type, keyValues)).ReturnValue).OfType<object>().SingleOrDefault();
|
|
}
|
|
return target;
|
|
}
|
|
}
|
|
|
|
internal struct RelatedItem {
|
|
internal MetaType Type;
|
|
internal object Item;
|
|
internal RelatedItem(MetaType type, object item) {
|
|
this.Type = type;
|
|
this.Item = item;
|
|
}
|
|
}
|
|
}
|