// <summary>
// Creates a provider that wraps the given provider.
// </summary>
// <param name="internalQuery"> The internal query to wrap. </param>
public DbQueryProvider(IQueryProvider efQueryProvider, RepositoryInternalBase repository)
{
_efQueryProvider = GiveUnderlyingQueryProvider(efQueryProvider);
_repository = repository;
var field_internalContext = _efQueryProvider.GetType().GetField("_internalContext", BindingFlags.Instance | BindingFlags.NonPublic);
var field_internalQuery = _efQueryProvider.GetType().GetField("_internalQuery", BindingFlags.Instance | BindingFlags.NonPublic);
_internalContext = field_internalContext.GetValue(efQueryProvider);
_internalQuery = field_internalQuery.GetValue(efQueryProvider);
}
/// <inheritdoc cref="IQueryableAnalyzer.SupportsLinqToObjects"/>
public bool SupportsLinqToObjects(IQueryable query, IQueryProvider provider = null)
{
Check.NotNull(query, nameof(query));
provider = provider ?? query.Provider;
Type baseType = provider.GetType().GetTypeInfo().BaseType;
#if NET35
bool isLinqToObjects = baseType.FullName.Contains("EnumerableQuery");
#else
bool isLinqToObjects = baseType == typeof(EnumerableQuery);
#endif
if (!isLinqToObjects)
{
// Support for https://github.com/StefH/QueryInterceptor.Core, version 1.0.1 and up
if (baseType.Name == "QueryTranslatorProvider")
{
try
{
PropertyInfo property = baseType.GetProperty("OriginalProvider");
IQueryProvider originalProvider = property.GetValue(provider, null) as IQueryProvider;
return(originalProvider != null && SupportsLinqToObjects(query, originalProvider));
}
catch
{
return(false);
}
}
// Support for https://github.com/scottksmith95/LINQKit ExpandableQuery
if (provider.GetType().GetTypeInfo().Name.StartsWith("ExpandableQuery"))
{
try
{
PropertyInfo property = query.GetType().GetProperty("InnerQuery", BindingFlags.NonPublic | BindingFlags.Instance);
if (property != null)
{
IQueryable innerQuery = property.GetValue(query, null) as IQueryable;
return(innerQuery != null && SupportsLinqToObjects(innerQuery, provider));
}
return(SupportsLinqToObjects(query));
}
catch
{
return(false);
}
}
}
return(isLinqToObjects);
}
IAsyncAdapter CreateAsyncAdapter()
{
if (Sync)
{
return(AsyncOverSyncAdapter.Instance);
}
var providerType = Provider.GetType();
var customAdapter = CustomAsyncAdapters.GetAdapter(providerType);
if (customAdapter != null)
{
return(customAdapter);
}
if (ReflectionAsyncAdapter.SupportsProvider(ProviderInfo))
{
return(new ReflectionAsyncAdapter(ProviderInfo));
}
if (AllowAsyncOverSync)
{
return(AsyncOverSyncAdapter.Instance);
}
throw ProviderNotSupported(providerType);
}
public QueryProviderInfo(IQueryProvider provider)
{
if (provider is EnumerableQuery)
{
IsLinqToObjects = true;
}
else
{
var type = provider.GetType();
var typeName = type.FullName;
if (typeName == "Microsoft.Data.Entity.Query.Internal.EntityQueryProvider" || typeName == "System.Data.Entity.Internal.Linq.DbQueryProvider")
{
IsEFClassic = true;
}
else if (typeName == "Microsoft.EntityFrameworkCore.Query.Internal.EntityQueryProvider")
{
IsEFCore = true;
}
else if (typeName.StartsWith("DevExpress.Xpo.XPQuery"))
{
IsXPO = true;
}
else if (typeName.StartsWith("NHibernate.Linq."))
{
IsNH = true;
}
else if (typeName.StartsWith("System.Data.Linq."))
{
IsL2S = true;
}
Version = type.Assembly.GetName().Version;
}
}
private static bool IsProviderEnumerableQuery(IQueryProvider provider)
{
Type baseType = provider.GetType().GetTypeInfo().BaseType;
#if NET35
bool isLinqToObjects = baseType.FullName.Contains("EnumerableQuery");
#else
bool isLinqToObjects = baseType == typeof(EnumerableQuery);
#endif
if (!isLinqToObjects)
{
// add support for https://github.com/StefH/QueryInterceptor.Core, version 1.0.1 and up
if (baseType.Name == "QueryTranslatorProvider")
{
try
{
PropertyInfo property = baseType.GetProperty("OriginalProvider");
IQueryProvider originalProvider = property.GetValue(provider, null) as IQueryProvider;
return(originalProvider != null && IsProviderEnumerableQuery(originalProvider));
}
catch
{
return(false);
}
}
}
return(isLinqToObjects);
}
public QueryProviderInfo(IQueryProvider provider)
{
if (provider is EnumerableQuery)
{
IsLinqToObjects = true;
}
else
{
var typeInfo = provider.GetType().AssemblyQualifiedName.Split(new[] { ", " }, 4, StringSplitOptions.None);
var typeName = typeInfo[0];
if (typeName == "Microsoft.Data.Entity.Query.Internal.EntityQueryProvider" || typeName == "System.Data.Entity.Internal.Linq.DbQueryProvider")
{
IsEFClassic = true;
}
else if (typeName == "Microsoft.EntityFrameworkCore.Query.Internal.EntityQueryProvider")
{
IsEFCore = true;
}
else if (typeName.StartsWith("DevExpress.Xpo.XPQuery"))
{
IsXPO = true;
}
Version = new Version(typeInfo[2].Substring(8));
}
}
internal static bool IsEntityFramework(IQueryProvider provider) {
var type = provider.GetType().FullName;
return type == "System.Data.Entity.Internal.Linq.DbQueryProvider"
|| type == "Microsoft.EntityFrameworkCore.Query.Internal.EntityQueryProvider"
|| type == "Microsoft.Data.Entity.Query.Internal.EntityQueryProvider";
}
internal static bool IsEntityFramework(IQueryProvider provider)
{
var type = provider.GetType().FullName;
return(type == "System.Data.Entity.Internal.Linq.DbQueryProvider" ||
type == "Microsoft.EntityFrameworkCore.Query.Internal.EntityQueryProvider" ||
type == "Microsoft.Data.Entity.Query.Internal.EntityQueryProvider");
}
internal static DbContext GetDbContext(IQueryProvider provider)
{
var internalContext =
provider.GetType().GetProperty("InternalContext");
var owner = internalContext?.PropertyType.GetProperty("Owner");
return((DbContext)owner?.GetValue(internalContext.GetValue(provider)));
}
public static bool IsEntityFrameworkProvider(this IQueryProvider provider)
{
var name = provider.GetType().FullName;
return(name == "System.Data.Objects.ELinq.ObjectQueryProvider" ||
name == "System.Data.Entity.Core.Objects.ELinq.ObjectQueryProvider" ||
name.StartsWith("LinqKit.ExpandableQueryProvider") ||
name.StartsWith("System.Data.Entity.Internal.Linq"));
}
static async Task <IAsyncQueryProvider> ContinueAsync(IQueryProvider provider, ValueTask <IAsyncQueryProvider> valueTask)
{
var adaptedProvider = await valueTask;
if (null != adaptedProvider)
{
return(adaptedProvider);
}
throw new InvalidOperationException($"{provider.GetType().FullName} cannot be adapted.");
}
IAsyncAdapter CreateAsyncAdapter()
{
if (Sync)
{
return(AsyncOverSyncAdapter.Instance);
}
return(CustomAsyncAdapters.GetAdapter(Provider.GetType())
?? new ReflectionAsyncAdapter(ProviderInfo));
}
/// <summary>
/// Verifica se é um provedor do EntityFramework.
/// </summary>
/// <param name="provider"></param>
/// <returns></returns>
public static bool IsEntityFrameworkProvider(this IQueryProvider provider)
{
string fullName = provider.GetType().FullName;
if ((!(fullName == "System.Data.Objects.ELinq.ObjectQueryProvider") && !(fullName == "System.Data.Entity.Core.Objects.ELinq.ObjectQueryProvider")) && !fullName.StartsWith("LinqKit.ExpandableQueryProvider"))
{
return(fullName.StartsWith("System.Data.Entity.Internal.Linq"));
}
return(true);
}
public QueryProviderInfo(IQueryProvider provider)
{
if (provider is EnumerableQuery)
{
IsLinqToObjects = true;
}
else
{
var type = provider.GetType();
var typeName = type.FullName;
var providerAssembly = type.Assembly;
if (typeName == "Microsoft.Data.Entity.Query.Internal.EntityQueryProvider" || typeName == "System.Data.Entity.Internal.Linq.DbQueryProvider")
{
IsEFClassic = true;
}
else if (typeName == "Microsoft.EntityFrameworkCore.Query.Internal.EntityQueryProvider")
{
IsEFCore = true;
}
else if (typeName.StartsWith("DevExpress.Xpo.XPQuery"))
{
IsXPO = true;
}
else if (typeName.StartsWith("NHibernate.Linq."))
{
IsNH = true;
}
else if (typeName.StartsWith("System.Data.Linq."))
{
IsL2S = true;
}
else if (typeName.StartsWith("MongoDB.Driver.Linq."))
{
IsMongoDB = true;
}
else if (typeName.StartsWith("LinqKit.ExpandableQueryProvider`1"))
{
switch (providerAssembly.GetName().Name)
{
case "LinqKit.Microsoft.EntityFrameworkCore":
IsEFCore = true;
providerAssembly = Assembly.Load("Microsoft.EntityFrameworkCore");
break;
case "LinqKit.EntityFramework":
IsEFClassic = true;
providerAssembly = Assembly.Load("EntityFramework");
break;
}
}
Version = providerAssembly.GetName().Version;
}
}
private bool CheckIfCanUseIdentityPrimaryKey()
{
var hasIdentity = _tableInfo.HasIdentityPrimaryKey;
if (hasIdentity && !_provider.SupportsIdentity())
{
throw new InvalidOperationException(
string.Format(Resources.ProviderDoesNotSupportIdentity, _provider.GetType().Name, typeof(T).Name));
}
return(hasIdentity);
}
internal static bool IsEntityFramework(IQueryProvider provider)
{
switch (provider.GetType().FullName)
{
case "System.Data.Entity.Internal.Linq.DbQueryProvider":
case "Microsoft.Data.Entity.Query.Internal.EntityQueryProvider":
case EF_CORE_PROVIDER_TYPE:
return(true);
}
return(false);
}
static Exception ProviderNotSupported(IQueryProvider provider)
{
var providerType = provider.GetType();
if (providerType.IsGenericType)
{
providerType = providerType.GetGenericTypeDefinition();
}
var message = $"Async operations for the LINQ provider '{providerType.FullName}' are not supported."
+ $" You can implement a custom async adapter ({typeof(IAsyncAdapter).FullName}) and register it via '{typeof(CustomAsyncAdapters).FullName}.{nameof(CustomAsyncAdapters.RegisterAdapter)}'.";
return(new NotSupportedException(message));
}
public void Experiment_For_Filters_2_With_Linq_Conversion()
{
// var sql = string.Format("Select C.firstname, C.lastname From contact Where firstname Like '%ax%' ");
var connectionString = ConfigurationManager.ConnectionStrings["CrmOrganisation"];
var serviceProvider = new CrmServiceProvider(new ExplicitConnectionStringProviderWithFallbackToConfig()
{
OrganisationServiceConnectionString = connectionString.ConnectionString
},
new CrmClientCredentialsProvider());
var orgService = serviceProvider.GetOrganisationService() as CrmOrganizationServiceContext;
using (orgService as IDisposable)
{
var contactsQuery = from c in orgService.CreateQuery("contact")
join a in orgService.CreateQuery("customeraddress") on(Guid) c["contactid"] equals
(Guid) a["parentid"]
where (((string)c["firstname"] == "Max" && (string)c["lastname"] == "Planck") ||
((string)c["firstname"] == "Albert" && (string)c["lastname"] == "Einstein")) ||
(string)a["line1"] == "Line2"
select c;
IQueryProvider queryProvider = contactsQuery.Provider;
MethodInfo translateMethodInfo = queryProvider.GetType().GetMethod("Translate");
QueryExpression query = (QueryExpression)translateMethodInfo.Invoke(queryProvider, new object[] { contactsQuery.Expression });
QueryExpressionToFetchXmlRequest reqConvertToFetchXml = new QueryExpressionToFetchXmlRequest {
Query = query
};
QueryExpressionToFetchXmlResponse respConvertToFetchXml = (QueryExpressionToFetchXmlResponse)orgService.Execute(reqConvertToFetchXml);
System.Diagnostics.Debug.Print(respConvertToFetchXml.FetchXml);
var results = contactsQuery.ToList();
int resultCount = 0;
foreach (var r in results)
{
resultCount++;
// Console.WriteLine(string.Format("{0} {1} {2}", (string)r["firstname"], (string)r["lastname"], (string)r["line1"]));
Console.WriteLine(string.Format("{0} {1}", (string)r["firstname"], (string)r["lastname"]));
}
Console.WriteLine("There were " + resultCount + " results..");
}
}
private static MethodInfo GetMethodExecuteAsync(IQueryProvider queryProvider)
{
const string interfaceName = "IMongoQueryProvider";
const string methodName = "ExecuteAsync";
var type = queryProvider.GetType();
var interf = type.GetInterface(interfaceName);
if (interf == null)
{
throw new ArgumentException($"The query provider must implement the interface {interfaceName}.", nameof(queryProvider));
}
var method = interf.GetMethod(methodName);
return(method);
}
#pragma warning restore IDE0060,IDE0051
#endregion
static ValueTask <IAsyncQueryProvider> GetAsync(this IQueryProvider provider, CancellationToken cancellationToken)
{
if (provider == null)
{
throw new ArgumentNullException(nameof(provider));
}
if (provider is IAsyncQueryProvider asyncProvider)
{
return(new ValueTask <IAsyncQueryProvider>(asyncProvider));
}
var adaptedProvider = AsyncQueryAdapters.AdaptAsync(provider, cancellationToken);
if (adaptedProvider.IsCompletedSuccessfully)
{
if (null == adaptedProvider.Result)
{
throw new InvalidOperationException($"{provider.GetType().FullName} cannot be adapted.");
}
return(adaptedProvider);
}
return(new ValueTask <IAsyncQueryProvider>(ContinueAsync(provider, adaptedProvider)));
public static bool IsLinqToObjectsProvider(this IQueryProvider provider)
{
return(provider.GetType().FullName.Contains("EnumerableQuery"));
}
internal static bool IsXPO(IQueryProvider provider)
{
return(provider.GetType().FullName.StartsWith("DevExpress.Xpo.XPQuery"));
}
public static bool IsEntityFrameworkProvider(this IQueryProvider provider)
{
return(provider.GetType().FullName == "System.Data.Objects.ELinq.ObjectQueryProvider");
}
public static bool IsEntityFrameworkProvider(this IQueryProvider provider)
{
return(provider.GetType().FullName == "System.Data.Objects.ELinq.ObjectQueryProvider" ||
provider.GetType().FullName.StartsWith("System.Data.Entity.Internal.Linq"));
}
public static bool IsQueryTranslatorProvider(this IQueryProvider provider)
{
return(provider.GetType().FullName.Contains("QueryInterceptor.QueryTranslatorProvider"));
}
IAsyncAdapter CreateAdapter()
{
return(CustomAsyncAdapters.GetAdapter(Provider.GetType())
?? new ReflectionAsyncAdapter(ProviderInfo));
}
internal static bool IsEFCore(IQueryProvider provider)
{
return(provider.GetType().FullName == EF_CORE_PROVIDER_TYPE);
}