/// <summary>
/// Execute Quary
/// </summary>
/// <param name="expression"></param>
/// <returns></returns>
public object Execute(Expression expression)
{
var _expression = new LinqToSql(expression.Type.GetActualType(), this);
_expression.Translate(expression);
return(_dbSchema.Select(expression.Type, _expression.Quary));
}
/// <summary>
/// On cache miss.
/// </summary>
internal protected override void OnCacheMiss(Container container, IQueryable query, string key)
{
// Patch model to include schema information in LinqToSql, this is a requirement for SqlDependency to work.
LinqToSql.AddSchemaToModel(query);
var dependency = new System.Data.SqlClient.SqlDependency();
dependency.OnChange += (sender, args) =>
{
if (args.Info == SqlNotificationInfo.Invalid)
{
var unsupportedQueryHandler = UnsupportedQuery;
if (unsupportedQueryHandler != null)
{
unsupportedQueryHandler(this, new SqlDependencyEventArgs(query));
}
}
else
{
container.Delete(key);
}
OnChangeReceived.Set();
};
CallContext.SetData(CookieName, dependency.Id);
}
public bool CanBeLogged(LinqToSql.Login user, string password, string login)
{
if (user == null) return false;
if (user.User_Login == login && user.Haslo == password) return true;
else return false;
}
private void Window_Loaded(object sender, EventArgs e)
{
var dbConnection = new SqlConnection(@"Server=(local);Database=Books;Integrated Security=true;");
linqToSql = new LinqToSql(dbConnection);
linqToDataset = new LinqToDataset(dbConnection);
temp_controls = new List <Control>();
}
internal SqlQueryable(Expression exp, Transaction.Transaction repository)
{
_repository = repository;
_expression = new LinqToSql(typeof(T), _repository);
if (exp != null)
{
_matches.Add(exp);
}
}
internal SqlQueryable(Transaction.Transaction repository, List <T> items)
{
_repository = repository;
_expression = new LinqToSql(typeof(T), _repository);
if (items == null)
{
return;
}
PartExecuted = true;
items.RemoveAll(x => x == null);
base.AddRange(items);
}
/// <summary>
/// Return the count of the executed quary
/// </summary>
/// <returns></returns>
public int ExecuteCount()
{
_expression.DataBaseTypes = _repository.DataBaseTypes;
foreach (var exp in _matches)
{
_expression.Translate(exp);
}
ParsedLinqToSql = _expression.Count;
_expression = new LinqToSql(typeof(T), _repository);// reset
var cmd = _repository.GetSqlCommand(ParsedLinqToSql);
return(_repository.ExecuteScalar(cmd).ConvertValue <int>());
}
/// <summary>
/// Execute generic quary
/// </summary>
/// <typeparam name="TResult"></typeparam>
/// <param name="expression"></param>
/// <returns></returns>
public TResult Execute <TResult>(Expression expression)
{
var isEnumerable = (typeof(TResult).Name == "IEnumerable`1");
var _expression = new LinqToSql(typeof(TResult).GetActualType(), this);
_expression.Translate(expression);
if (!isEnumerable)
{
return(Select <TResult>(_expression.Quary).First());
}
else
{
return((TResult)_dbSchema.Select(expression.Type, _expression.Quary));
}
}
static void Main(string[] args)
{
List <SampleHarness> harnesses = new List <SampleHarness>();
LinqSamples linqHarness = new LinqSamples();
harnesses.Add(linqHarness);
LinqToSql linqToSqlHarness = new LinqToSql();
harnesses.Add(linqToSqlHarness);
Application.EnableVisualStyles();
using (SampleForm form = new SampleForm("HomeWork", harnesses))
{
form.ShowDialog();
}
}
/// <summary>
/// On init.
/// </summary>
protected internal override void OnInit(Container container, IQueryable query, string key)
{
_connectionString = LinqToSql.GetConnectionString(query) ?? EntityFramework.GetConnectionString(query);
if (_connectionString == null)
{
throw LinqCacheException.ContextIsNotSupported;
}
try
{
System.Data.SqlClient.SqlDependency.Start(_connectionString);
}
catch (InvalidOperationException exception)
{
if (exception.Message == BrokerNotEnabledMessage)
{
throw LinqCacheException.BrokerIsNotEnabled(exception);
}
throw;
}
}
public static void Main(string[] args)
{
var e = new LinqToSql(@"Server=(local);Integrated Security=true");
e.DeleteData();
}
