/// <summary>
/// Get the skip query.
/// </summary>
/// <returns>The skip query string.</returns>
public string GetSkipQuery()
{
// Select the skip type.
switch (typeof(T).Name.ToLower())
{
case "system.boolean":
case "boolean":
case "bool":
return(TableQuery.GenerateFilterConditionForBool(
_skipPropertyName, QueryComparisons.GreaterThanOrEqual,
(Boolean)Convert.ChangeType(_skipValue, typeof(Boolean))));
case "system.byte[]":
case "byte[]":
return(TableQuery.GenerateFilterConditionForBinary(
_skipPropertyName, QueryComparisons.GreaterThanOrEqual,
(Byte[])Convert.ChangeType(_skipValue, typeof(Byte[]))));
case "system.datetimeoffset":
case "datetimeoffset":
return(TableQuery.GenerateFilterConditionForDate(
_skipPropertyName, QueryComparisons.GreaterThanOrEqual,
(DateTimeOffset)Convert.ChangeType(_skipValue, typeof(DateTimeOffset))));
case "system.double":
case "double":
return(TableQuery.GenerateFilterConditionForDouble(
_skipPropertyName, QueryComparisons.GreaterThanOrEqual,
(Double)Convert.ChangeType(_skipValue, typeof(Double))));
case "system.guid":
case "guid":
return(TableQuery.GenerateFilterConditionForGuid(
_skipPropertyName, QueryComparisons.GreaterThanOrEqual,
(Guid)Convert.ChangeType(_skipValue, typeof(Guid))));
case "system.int32":
case "int32":
case "int":
return(TableQuery.GenerateFilterConditionForInt(
_skipPropertyName, QueryComparisons.GreaterThanOrEqual,
(Int32)Convert.ChangeType(_skipValue, typeof(Int32))));
case "system.int64":
case "int64":
case "long":
return(TableQuery.GenerateFilterConditionForLong(
_skipPropertyName, QueryComparisons.GreaterThanOrEqual,
(Int64)Convert.ChangeType(_skipValue, typeof(Int64))));
case "system.string":
case "string":
return(TableQuery.GenerateFilterCondition(
_skipPropertyName, QueryComparisons.GreaterThanOrEqual,
(String)Convert.ChangeType(_skipValue, typeof(String))));
default:
throw new Exception("The skip value type is not supported.");
}
}
/// <summary>
/// Get async.
/// </summary>
/// <typeparam name="ST">The skip type.</typeparam>
/// <param name="value">The value.</param>
/// <param name="propertyName">The property name.</param>
/// <param name="operation">The operation.</param>
/// <param name="take">The number of items to return.</param>
/// <param name="skip">The number of items to skip.</param>
/// <returns>The array or items.</returns>
public async Task <T[]> GetAsync <ST>(byte[] value, string propertyName = "PartitionKey",
string operation = QueryComparisons.Equal, int take = 100, SkipCount <ST> skip = null)
{
TableQuery <T> scanQuery = null;
if (skip == null)
{
// Create the query.
scanQuery = new TableQuery <T>().Where
(TableQuery.GenerateFilterConditionForBinary(propertyName, operation, value));
}
else
{
// Create the query.
scanQuery = new TableQuery <T>().Where
(TableQuery.CombineFilters(
TableQuery.GenerateFilterConditionForBinary(propertyName, operation, value),
TableOperators.And,
skip.GetSkipQuery()
));
}
// Return the array
return(await ScanAsyncEx(scanQuery, take));
}
/// <summary>
/// Shortcut method that queries the table based on a given PartitionKey and given property with
/// the same property name. Handles the continuation token scenario as well. Overloaded to accept
/// all appropriate table entity types.
/// </summary>
/// <param name="partitionKey"></param>
/// <param name="propertyName"></param>
/// <param name="property"></param>
/// <returns></returns>
public IEnumerable <TAzureTableEntity> WherePropertyEquals(string partitionKey, string propertyName, byte[] property)
{
var propertyFilter = TableQuery.GenerateFilterConditionForBinary(propertyName, QueryComparisons.Equal, property);
var query = PartitionKeyAndPropertyFilterQuery(partitionKey, propertyFilter);
return(RunQuerySegment(query));
}
/// <summary>
/// Async shortcut method that queries the table based on a given PartitionKey and given property with
/// the same property name. Handles the continuation token scenario as well. Overloaded to accept
/// all appropriate table entity types.
/// </summary>
/// <param name="partitionKey"></param>
/// <param name="propertyName"></param>
/// <param name="property"></param>
/// <returns></returns>
public async Task <List <TAzureTableEntity> > WherePropertyEqualsAsync(string partitionKey, string propertyName, byte[] property)
{
var propertyFilter = TableQuery.GenerateFilterConditionForBinary(propertyName, QueryComparisons.Equal, property);
var query = PartitionKeyAndPropertyFilterQuery(partitionKey, propertyFilter);
return(await RunQuerySegmentAsync(query).ConfigureAwait(false));
}
public static string Column(string columnName, byte[] value, ColumnOperator op = ColumnOperator.Equal)
{
return(TableQuery.GenerateFilterConditionForBinary(
columnName,
ToQueryComparison(op),
value));
}
/// <summary>
/// Get async.
/// </summary>
/// <param name="value">The value.</param>
/// <param name="propertyName">The property name.</param>
/// <param name="operation">The operation.</param>
/// <param name="take">The number of items to return.</param>
/// <returns>The array or items.</returns>
public async Task <T[]> GetAsync(byte[] value, string propertyName = "PartitionKey",
string operation = QueryComparisons.Equal, int take = 100)
{
// Create the query.
TableQuery <T> scanQuery = new TableQuery <T>().Where
(TableQuery.GenerateFilterConditionForBinary(propertyName, operation, value));
// Return the array
return(await ScanAsyncEx(scanQuery, take));
}
DictionaryTableEntity GetDictionaryTableEntity(Type type, string property, object value)
{
var tableName = type.Name;
var table = client.GetTableReference(tableName);
TableQuery <DictionaryTableEntity> query;
var propertyInfo = type.GetProperty(property);
if (propertyInfo.PropertyType == typeof(byte[]))
{
query = new TableQuery <DictionaryTableEntity>().Where(TableQuery.GenerateFilterConditionForBinary(property, QueryComparisons.Equal, (byte[])value));
}
else if (propertyInfo.PropertyType == typeof(bool))
{
query = new TableQuery <DictionaryTableEntity>().Where(TableQuery.GenerateFilterConditionForBool(property, QueryComparisons.Equal, (bool)value));
}
else if (propertyInfo.PropertyType == typeof(DateTime))
{
query = new TableQuery <DictionaryTableEntity>().Where(TableQuery.GenerateFilterConditionForDate(property, QueryComparisons.Equal, (DateTime)value));
}
else if (propertyInfo.PropertyType == typeof(Guid))
{
query = new TableQuery <DictionaryTableEntity>().Where(TableQuery.GenerateFilterConditionForGuid(property, QueryComparisons.Equal, (Guid)value));
}
else if (propertyInfo.PropertyType == typeof(Int32))
{
query = new TableQuery <DictionaryTableEntity>().Where(TableQuery.GenerateFilterConditionForInt(property, QueryComparisons.Equal, (int)value));
}
else if (propertyInfo.PropertyType == typeof(Int64))
{
query = new TableQuery <DictionaryTableEntity>().Where(TableQuery.GenerateFilterConditionForLong(property, QueryComparisons.Equal, (long)value));
}
else if (propertyInfo.PropertyType == typeof(Double))
{
query = new TableQuery <DictionaryTableEntity>().Where(TableQuery.GenerateFilterConditionForDouble(property, QueryComparisons.Equal, (double)value));
}
else if (propertyInfo.PropertyType == typeof(string))
{
query = new TableQuery <DictionaryTableEntity>().Where(TableQuery.GenerateFilterCondition(property, QueryComparisons.Equal, (string)value));
}
else
{
throw new NotSupportedException(
string.Format("The property type '{0}' is not supported in windows azure table storage",
propertyInfo.PropertyType.Name));
}
var tableEntity = table.ExecuteQuery(query).SafeFirstOrDefault();
return(tableEntity);
}
public static TableQuery <DictionaryTableEntity> BuildWherePropertyQuery(Type type, string property, object value)
{
TableQuery <DictionaryTableEntity> query;
var propertyInfo = type.GetProperty(property);
if (propertyInfo == null)
{
return(null);
}
if (propertyInfo.PropertyType == typeof(byte[]))
{
query = new TableQuery <DictionaryTableEntity>().Where(TableQuery.GenerateFilterConditionForBinary(property, QueryComparisons.Equal, (byte[])value));
}
else if (propertyInfo.PropertyType == typeof(bool))
{
query = new TableQuery <DictionaryTableEntity>().Where(TableQuery.GenerateFilterConditionForBool(property, QueryComparisons.Equal, (bool)value));
}
else if (propertyInfo.PropertyType == typeof(DateTime))
{
query = new TableQuery <DictionaryTableEntity>().Where(TableQuery.GenerateFilterConditionForDate(property, QueryComparisons.Equal, (DateTime)value));
}
else if (propertyInfo.PropertyType == typeof(Guid))
{
query = new TableQuery <DictionaryTableEntity>().Where(TableQuery.GenerateFilterConditionForGuid(property, QueryComparisons.Equal, (Guid)value));
}
else if (propertyInfo.PropertyType == typeof(int))
{
query = new TableQuery <DictionaryTableEntity>().Where(TableQuery.GenerateFilterConditionForInt(property, QueryComparisons.Equal, (int)value));
}
else if (propertyInfo.PropertyType == typeof(long))
{
query = new TableQuery <DictionaryTableEntity>().Where(TableQuery.GenerateFilterConditionForLong(property, QueryComparisons.Equal, (long)value));
}
else if (propertyInfo.PropertyType == typeof(double))
{
query = new TableQuery <DictionaryTableEntity>().Where(TableQuery.GenerateFilterConditionForDouble(property, QueryComparisons.Equal, (double)value));
}
else if (propertyInfo.PropertyType == typeof(string))
{
query = new TableQuery <DictionaryTableEntity>().Where(TableQuery.GenerateFilterCondition(property, QueryComparisons.Equal, (string)value));
}
else
{
throw new NotSupportedException($"The property type '{propertyInfo.PropertyType.Name}' is not supported in Azure Table Storage");
}
return(query);
}
protected override string ExpressionFilterConverter(IFilterExpression <T> expression)
{
if (expression.PropertyType == typeof(byte[]))
{
return(TableQuery.GenerateFilterConditionForBinary(expression.PropertyName, GetInstruction(expression.Comparator), (byte[])expression.PropertyValue));
}
if (expression.PropertyType == typeof(bool) || expression.PropertyType == typeof(bool?))
{
return(TableQuery.GenerateFilterConditionForBool(expression.PropertyName, GetInstruction(expression.Comparator), (bool)expression.PropertyValue));
}
if (expression.PropertyType == typeof(DateTime) || expression.PropertyType == typeof(DateTime?))
{
return(TableQuery.GenerateFilterConditionForDate(expression.PropertyName, GetInstruction(expression.Comparator), (DateTime)expression.PropertyValue));
}
if (expression.PropertyType == typeof(DateTimeOffset) || expression.PropertyType == typeof(DateTimeOffset?))
{
return(TableQuery.GenerateFilterConditionForDate(expression.PropertyName, GetInstruction(expression.Comparator), (DateTimeOffset)expression.PropertyValue));
}
if (expression.PropertyType == typeof(double) || expression.PropertyType == typeof(double?))
{
return(TableQuery.GenerateFilterConditionForDouble(expression.PropertyName, GetInstruction(expression.Comparator), (double)expression.PropertyValue));
}
if (expression.PropertyType == typeof(Guid) || expression.PropertyType == typeof(Guid?))
{
return(TableQuery.GenerateFilterConditionForGuid(expression.PropertyName, GetInstruction(expression.Comparator), (Guid)expression.PropertyValue));
}
if (expression.PropertyType == typeof(int) || expression.PropertyType == typeof(int?))
{
return(TableQuery.GenerateFilterConditionForInt(expression.PropertyName, GetInstruction(expression.Comparator), (int)expression.PropertyValue));
}
if (expression.PropertyType == typeof(long) || expression.PropertyType == typeof(long?))
{
return(TableQuery.GenerateFilterConditionForLong(expression.PropertyName, GetInstruction(expression.Comparator), (long)expression.PropertyValue));
}
return(TableQuery.GenerateFilterCondition(expression.PropertyName, GetInstruction(expression.Comparator), expression.PropertyValue?.ToString() ?? string.Empty));
}
public string GenerateFilter(string propertyName, object propertyValue, string operatorString)
{
var propertyType = propertyValue.GetType();
if (propertyType == typeof(string))
{
return(TableQuery.GenerateFilterCondition(propertyName, operatorString, propertyValue as string));
}
if (propertyType == typeof(DateTime))
{
return(TableQuery.GenerateFilterConditionForDate(propertyName, operatorString, (DateTime)propertyValue));
}
if (propertyType == typeof(bool))
{
return(TableQuery.GenerateFilterConditionForBool(propertyName, operatorString, (bool)propertyValue));
}
if (propertyType == typeof(double))
{
return(TableQuery.GenerateFilterConditionForDouble(propertyName, operatorString, (double)propertyValue));
}
if (propertyType == typeof(int))
{
return(TableQuery.GenerateFilterConditionForInt(propertyName, operatorString, (int)propertyValue));
}
if (propertyType == typeof(long))
{
return(TableQuery.GenerateFilterConditionForLong(propertyName, operatorString, (long)propertyValue));
}
if (propertyType == typeof(Guid))
{
return(TableQuery.GenerateFilterConditionForGuid(propertyName, operatorString, (Guid)propertyValue));
}
return(propertyType == typeof(byte[]) ?
TableQuery.GenerateFilterConditionForBinary(propertyName, operatorString, (byte[])propertyValue) :
TableQuery.GenerateFilterCondition(propertyName, operatorString, propertyValue.ToString()));
}
static string GenerateFilterCondition(BinaryExpression binary)
{
var left = binary.Left as MemberExpression;
if (left == null)
{
throw new InvalidOperationException();
}
var op = ToComparisonOperator(binary.NodeType);
var rightValue = binary.Right.Invoke();
return
(left.Type == typeof(byte[]) ? TableQuery.GenerateFilterConditionForBinary(left.Member.Name, op, (byte[])rightValue) :
left.Type == typeof(bool) ? TableQuery.GenerateFilterConditionForBool(left.Member.Name, op, (bool)rightValue) :
left.Type == typeof(DateTime) ? TableQuery.GenerateFilterConditionForDate(left.Member.Name, op, (DateTime)rightValue) :
left.Type == typeof(DateTimeOffset) ? TableQuery.GenerateFilterConditionForDate(left.Member.Name, op, (DateTimeOffset)rightValue) :
left.Type == typeof(double) ? TableQuery.GenerateFilterConditionForDouble(left.Member.Name, op, (double)rightValue) :
left.Type == typeof(Guid) ? TableQuery.GenerateFilterConditionForGuid(left.Member.Name, op, (Guid)rightValue) :
left.Type == typeof(int) ? TableQuery.GenerateFilterConditionForInt(left.Member.Name, op, (int)rightValue) :
left.Type == typeof(long) ? TableQuery.GenerateFilterConditionForLong(left.Member.Name, op, (long)rightValue) :
TableQuery.GenerateFilterCondition(left.Member.Name, op, rightValue.To <string>()));
}
static AzureConditionBuilderExtention()
{
ToAzureType = new Dictionary <Type, Func <object, string> >();
ToAzureType[typeof(string)] = (x) => TableQuery.GenerateFilterCondition("", "", x.ToString());
ToAzureType[typeof(bool)] = (x) => TableQuery.GenerateFilterConditionForBool("", "", (bool)x);
ToAzureType[typeof(DateTime)] = (x) => TableQuery.GenerateFilterConditionForDate("", "", ((DateTime)x));
ToAzureType[typeof(double)] = (x) => TableQuery.GenerateFilterConditionForDouble("", "", (double)x);
ToAzureType[typeof(Guid)] = (x) => TableQuery.GenerateFilterConditionForGuid("", "", (Guid)x);
ToAzureType[typeof(int)] = (x) => TableQuery.GenerateFilterConditionForInt("", "", (int)x);
ToAzureType[typeof(long)] = (x) => TableQuery.GenerateFilterConditionForLong("", "", (long)x);
ToAzureType[typeof(byte[])] = (x) => TableQuery.GenerateFilterConditionForBinary("", "", (byte[])x);
ToAzureCondition = new Dictionary <string, string>();
ToAzureCondition["=="] = QueryComparisons.Equal;
ToAzureCondition[">"] = QueryComparisons.GreaterThan;
ToAzureCondition[">="] = QueryComparisons.GreaterThanOrEqual;
ToAzureCondition["<"] = QueryComparisons.LessThan;
ToAzureCondition["<="] = QueryComparisons.LessThanOrEqual;
ToAzureCondition["!="] = QueryComparisons.NotEqual;
ToAzureCondition["AndAlso"] = TableOperators.And;
ToAzureCondition["OrElse"] = TableOperators.Or;
ToAzureCondition["Not"] = TableOperators.Not;
}
public void TableGenericQueryOnSupportedTypes()
{
// 1. Filter on String
ExecuteQueryAndAssertResults(this.currentTable,
TableQuery.GenerateFilterCondition("String", QueryComparisons.GreaterThanOrEqual, "0050"), Midpoint);
// 2. Filter on Guid
ExecuteQueryAndAssertResults(this.currentTable,
TableQuery.GenerateFilterConditionForGuid("Guid", QueryComparisons.Equal, this.middleRef.Guid), 1);
// 3. Filter on Long
ExecuteQueryAndAssertResults(this.currentTable,
TableQuery.GenerateFilterConditionForLong("Int64", QueryComparisons.GreaterThanOrEqual,
this.middleRef.LongPrimitive), Midpoint);
ExecuteQueryAndAssertResults(this.currentTable, TableQuery.GenerateFilterConditionForLong("LongPrimitive",
QueryComparisons.GreaterThanOrEqual, this.middleRef.LongPrimitive), Midpoint);
// 4. Filter on Double
ExecuteQueryAndAssertResults(this.currentTable,
TableQuery.GenerateFilterConditionForDouble("Double", QueryComparisons.GreaterThanOrEqual,
this.middleRef.Double), Midpoint);
ExecuteQueryAndAssertResults(this.currentTable, TableQuery.GenerateFilterConditionForDouble("DoublePrimitive",
QueryComparisons.GreaterThanOrEqual, this.middleRef.DoublePrimitive), Midpoint);
// 5. Filter on Integer
ExecuteQueryAndAssertResults(this.currentTable,
TableQuery.GenerateFilterConditionForInt("Int32", QueryComparisons.GreaterThanOrEqual,
this.middleRef.Int32), Midpoint);
ExecuteQueryAndAssertResults(this.currentTable, TableQuery.GenerateFilterConditionForInt("IntegerPrimitive",
QueryComparisons.GreaterThanOrEqual, middleRef.IntegerPrimitive), Midpoint);
// 6. Filter on Date
ExecuteQueryAndAssertResults(this.currentTable,
TableQuery.GenerateFilterConditionForDate("DateTimeOffset", QueryComparisons.GreaterThanOrEqual,
this.middleRef.DateTimeOffset), Midpoint);
// 7. Filter on Boolean
ExecuteQueryAndAssertResults(this.currentTable,
TableQuery.GenerateFilterConditionForBool("Bool", QueryComparisons.Equal, this.middleRef.Bool), Midpoint);
ExecuteQueryAndAssertResults(this.currentTable,
TableQuery.GenerateFilterConditionForBool("BoolPrimitive", QueryComparisons.Equal, this.middleRef.BoolPrimitive),
Midpoint);
// 8. Filter on Binary
ExecuteQueryAndAssertResults(this.currentTable,
TableQuery.GenerateFilterConditionForBinary("Binary", QueryComparisons.Equal, this.middleRef.Binary), 1);
ExecuteQueryAndAssertResults(this.currentTable,
TableQuery.GenerateFilterConditionForBinary("BinaryPrimitive", QueryComparisons.Equal,
middleRef.BinaryPrimitive), 1);
// 9. Filter on Binary GTE
ExecuteQueryAndAssertResults(this.currentTable,
TableQuery.GenerateFilterConditionForBinary("Binary", QueryComparisons.GreaterThanOrEqual,
this.middleRef.Binary), Midpoint);
ExecuteQueryAndAssertResults(this.currentTable, TableQuery.GenerateFilterConditionForBinary("BinaryPrimitive",
QueryComparisons.GreaterThanOrEqual, this.middleRef.BinaryPrimitive), Midpoint);
// 10. Complex Filter on Binary GTE
ExecuteQueryAndAssertResults(this.currentTable, TableQuery.CombineFilters(
TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal,
this.middleRef.PartitionKey),
TableOperators.And,
TableQuery.GenerateFilterConditionForBinary("Binary", QueryComparisons.GreaterThanOrEqual,
this.middleRef.Binary)), Midpoint);
ExecuteQueryAndAssertResults(this.currentTable, TableQuery.GenerateFilterConditionForBinary("BinaryPrimitive",
QueryComparisons.GreaterThanOrEqual, this.middleRef.BinaryPrimitive), Midpoint);
}
public static string FilterString(string propertyName, string queryComparison, object value)
{
var filterString = "";
var val = "";
if (value != null)
{
val = value.GetType().ToString().Replace("System.", "");
}
switch (val)
{
//case "":
// filterString = TableQuery.GenerateFilterCondition(property, queryComparison, "");
// break;
case "Byte[]":
filterString = TableQuery.GenerateFilterConditionForBinary(propertyName, queryComparison, (byte[])value);
break;
case "Boolean":
filterString = TableQuery.GenerateFilterConditionForBool(propertyName, queryComparison, (bool)value);
break;
case "DateTime":
filterString = TableQuery.GenerateFilterConditionForDate(propertyName, queryComparison, (DateTime)value);
break;
case "Double":
filterString = TableQuery.GenerateFilterConditionForDouble(propertyName, queryComparison, (double)value);
break;
case "Guid":
filterString = TableQuery.GenerateFilterConditionForGuid(propertyName, queryComparison, (Guid)value);
break;
case "Int32":
filterString = TableQuery.GenerateFilterConditionForInt(propertyName, queryComparison, (int)value);
break;
case "Int64":
filterString = TableQuery.GenerateFilterConditionForLong(propertyName, queryComparison, (long)value);
break;
default:
//if (Utils.IsRowKey(property))
// filterString = TableQuery.GenerateFilterCondition("RowKey", queryComparison, (String)value);
//else
//if (Utils.IsPartitionKey(property))
// filterString = TableQuery.GenerateFilterCondition("PartitionKey", queryComparison, (String)value);
//else
filterString = TableQuery.GenerateFilterCondition(propertyName, queryComparison, (String)value);
break;
}
//Event("Type Not Handled error on QueryOn");
return(filterString);
}
T ISagaPersister.Get <T>(string property, object value)
{
var type = typeof(T);
var tableName = type.Name;
var table = client.GetTableReference(tableName);
TableQuery <DictionaryTableEntity> query;
var propertyInfo = type.GetProperty(property);
if (propertyInfo.PropertyType == typeof(byte[]))
{
query = new TableQuery <DictionaryTableEntity>().Where(TableQuery.GenerateFilterConditionForBinary(property, QueryComparisons.Equal, (byte[])value));
}
else if (propertyInfo.PropertyType == typeof(bool))
{
query = new TableQuery <DictionaryTableEntity>().Where(TableQuery.GenerateFilterConditionForBool(property, QueryComparisons.Equal, (bool)value));
}
else if (propertyInfo.PropertyType == typeof(DateTime))
{
query = new TableQuery <DictionaryTableEntity>().Where(TableQuery.GenerateFilterConditionForDate(property, QueryComparisons.Equal, (DateTime)value));
}
else if (propertyInfo.PropertyType == typeof(Guid))
{
query = new TableQuery <DictionaryTableEntity>().Where(TableQuery.GenerateFilterConditionForGuid(property, QueryComparisons.Equal, (Guid)value));
}
else if (propertyInfo.PropertyType == typeof(Int32))
{
query = new TableQuery <DictionaryTableEntity>().Where(TableQuery.GenerateFilterConditionForInt(property, QueryComparisons.Equal, (int)value));
}
else if (propertyInfo.PropertyType == typeof(Int64))
{
query = new TableQuery <DictionaryTableEntity>().Where(TableQuery.GenerateFilterConditionForLong(property, QueryComparisons.Equal, (long)value));
}
else if (propertyInfo.PropertyType == typeof(Double))
{
query = new TableQuery <DictionaryTableEntity>().Where(TableQuery.GenerateFilterConditionForDouble(property, QueryComparisons.Equal, (double)value));
}
else if (propertyInfo.PropertyType == typeof(string))
{
query = new TableQuery <DictionaryTableEntity>().Where(TableQuery.GenerateFilterCondition(property, QueryComparisons.Equal, (string)value));
}
else
{
throw new NotSupportedException(
string.Format("The property type '{0}' is not supported in windows azure table storage",
propertyInfo.PropertyType.Name));
}
try
{
return(ToEntity <T>(table.ExecuteQuery(query).FirstOrDefault()));
}
catch (WebException ex)
{
// occurs when table has not yet been created, but already looking for absence of instance
if (ex.Status == WebExceptionStatus.ProtocolError && ex.Response != null)
{
var response = (HttpWebResponse)ex.Response;
if (response.StatusCode == HttpStatusCode.NotFound)
{
return(default(T));
}
}
throw;
}
}
public override string ToString()
{
var filterOperation = QueryComparisons.Equal;
switch (Operator)
{
case QueryFilterOperator.Equal:
filterOperation = QueryComparisons.Equal;
break;
case QueryFilterOperator.NotEqual:
filterOperation = QueryComparisons.NotEqual;
break;
case QueryFilterOperator.Lower:
filterOperation = QueryComparisons.LessThan;
break;
case QueryFilterOperator.Greater:
filterOperation = QueryComparisons.GreaterThan;
break;
case QueryFilterOperator.LowerEqual:
filterOperation = QueryComparisons.LessThanOrEqual;
break;
case QueryFilterOperator.GreaterEqual:
filterOperation = QueryComparisons.GreaterThanOrEqual;
break;
}
if (Value is string)
{
return(TableQuery.GenerateFilterCondition(Property, filterOperation, (string)Value));
}
if (Value is bool)
{
return(TableQuery.GenerateFilterConditionForBool(Property, filterOperation, (bool)Value));
}
if (Value is byte[])
{
return(TableQuery.GenerateFilterConditionForBinary(Property, filterOperation, (byte[])Value));
}
if (Value is DateTimeOffset)
{
return(TableQuery.GenerateFilterConditionForDate(Property, filterOperation, (DateTimeOffset)Value));
}
if (Value is double)
{
return(TableQuery.GenerateFilterConditionForDouble(Property, filterOperation, (double)Value));
}
if (Value is Guid)
{
return(TableQuery.GenerateFilterConditionForGuid(Property, filterOperation, (Guid)Value));
}
if (Value is int)
{
return(TableQuery.GenerateFilterConditionForInt(Property, filterOperation, (int)Value));
}
if (Value is long)
{
return(TableQuery.GenerateFilterConditionForLong(Property, filterOperation, (long)Value));
}
throw new NotSupportedException($"QueryFilter of Type \"{Value?.GetType().FullName}\" is not supported.");
}
