private EntityProperty CreateEntityPropertyWithNullValue(EdmType edmType) { switch (edmType) { case EdmType.String: return(EntityProperty.GeneratePropertyForString(null)); case EdmType.Binary: return(EntityProperty.GeneratePropertyForByteArray(null)); case EdmType.Boolean: return(EntityProperty.GeneratePropertyForBool(null)); case EdmType.DateTime: return(EntityProperty.GeneratePropertyForDateTimeOffset(null)); case EdmType.Double: return(EntityProperty.GeneratePropertyForDouble(null)); case EdmType.Guid: return(EntityProperty.GeneratePropertyForGuid(null)); case EdmType.Int32: return(EntityProperty.GeneratePropertyForInt(null)); case EdmType.Int64: return(EntityProperty.GeneratePropertyForLong(null)); default: throw new InvalidOperationException("Unexpected EdmType"); } }
private async Task <List <TableOperation> > BuildTableOperationUpsert(T entity) { var entityId = EntityDefinition.GetIdValues(entity); var serializedField = EntityProperty.GeneratePropertyForByteArray(BSonConvert.SerializeObject(entity)); var fields = GetEntityFilterableFields(entity).ToList(); var record = GenerateRecordMainPartition(entity, serializedField, fields); List <TableOperation> operations = new List <TableOperation> { TableOperation.InsertOrReplace(record) }; operations.AddRange(GeneratePersistPartitionData(entity, serializedField, fields) .Select(TableOperation.InsertOrReplace)); var idValue = string.Join(StorageQueryBuilder.PARTITION_FIELD_SEPARATOR, entityId.Select(StorageQueryBuilder.NormalizeStringValue)); var old = await GetById(StorageQueryBuilder.GetTableKeyNormalizedValue(idValue)).ConfigureAwait(false); if (old != null) { var oldFields = GetEntityFilterableFields(old); IEnumerable <TableOperation> deleteOperations = GeneratePersistPartitionData(old, null, oldFields) .Select(TableOperation.Delete) .Where(d => !operations.Any(o => o.Entity.PartitionKey == d.Entity.PartitionKey && o.Entity.RowKey == d.Entity.RowKey)) .ToList(); operations.AddRange(deleteOperations); } return(operations); }
private async Task <List <TableOperation> > BuildTableOperationUpdate(T entity) { var entityIdValues = EntityDefinition.GetIdValues(entity); var idString = string.Join(StorageQueryBuilder.PARTITION_FIELD_SEPARATOR, entityIdValues.Select(StorageQueryBuilder.NormalizeStringValue)); var serializedField = EntityProperty.GeneratePropertyForByteArray(BSonConvert.SerializeObject(entity)); var fields = GetEntityFilterableFields(entity); var record = GenerateRecordMainPartition(entity, serializedField, fields); List <TableOperation> operations = new List <TableOperation> { TableOperation.Replace(record) }; var old = await GetById(idString).ConfigureAwait(false); if (old != null) { var oldFields = GetEntityFilterableFields(old); operations.AddRange(GeneratePersistPartitionData(old, null, oldFields).Select(TableOperation.Delete)); } return(operations); }
private static EntityProperty CreateEntityProperty(JsonSerializer serializer, JProperty property) { if (property != null) { return(null !); } var list = JObject.Parse(property !.Value.ToString()).Properties().ToList(); var edmType = (EdmType)Enum.Parse(typeof(EdmType), list[1].Value.ToString(), true); EntityProperty entityProperty; switch ((int)edmType) { case 0: entityProperty = EntityProperty.GeneratePropertyForString(list[0].Value.ToObject <string>(serializer)); break; case 1: entityProperty = EntityProperty.GeneratePropertyForByteArray(list[0].Value.ToObject <byte[]>(serializer)); break; case 2: entityProperty = EntityProperty.GeneratePropertyForBool(list[0].Value.ToObject <bool>(serializer)); break; case 3: entityProperty = EntityProperty.GeneratePropertyForDateTimeOffset(list[0].Value .ToObject <DateTimeOffset>(serializer)); break; case 4: entityProperty = EntityProperty.GeneratePropertyForDouble(list[0].Value.ToObject <double>(serializer)); break; case 5: entityProperty = EntityProperty.GeneratePropertyForGuid(list[0].Value.ToObject <Guid>(serializer)); break; case 6: entityProperty = EntityProperty.GeneratePropertyForInt(list[0].Value.ToObject <int>(serializer)); break; case 7: entityProperty = EntityProperty.GeneratePropertyForLong(list[0].Value.ToObject <long>(serializer)); break; default: throw new NotSupportedException($"Unsupported EntityProperty.PropertyType:{edmType} detected during deserialization"); } return(entityProperty); }
private void WriteSchema(CloudTable table) { DeleteSchema(table); DynamicTableEntity schema = new DynamicTableEntity(SCHEMA_CONSTANT_STRING, DateTime.UtcNow.ToString("s")); var hashData = ComputeDefinitionHash(); var serializedField = EntityProperty.GeneratePropertyForByteArray(hashData); schema.Properties.Add("Content", serializedField); table.Execute(TableOperation.InsertOrReplace(schema)); }
public IDictionary <string, EntityProperty> WriteEntity(OperationContext operationContext) { var dict = new Dictionary <string, EntityProperty> { [PayloadKeyName] = EntityProperty.GeneratePropertyForByteArray(Payload), [ManifestKeyName] = EntityProperty.GeneratePropertyForString(Manifest), [SeqNoKeyName] = EntityProperty.GeneratePropertyForLong(SeqNo) }; return(dict); }
private static EntityProperty CreateEntityProperty( JsonSerializer serializer, JProperty property) { if (property == null) { return((EntityProperty)null); } List <JProperty> list = JObject.Parse(((object)property.Value).ToString()).Properties().ToList <JProperty>(); EdmType edmType = (EdmType)Enum.Parse(typeof(EdmType), ((object)list[1].Value).ToString(), true); EntityProperty entityProperty; switch ((int)edmType) { case 0: entityProperty = EntityProperty.GeneratePropertyForString((string)list[0].Value.ToObject <string>(serializer)); break; case 1: entityProperty = EntityProperty.GeneratePropertyForByteArray((byte[])list[0].Value.ToObject <byte[]>(serializer)); break; case 2: entityProperty = EntityProperty.GeneratePropertyForBool(new bool?((bool)list[0].Value.ToObject <bool>(serializer))); break; case 3: entityProperty = EntityProperty.GeneratePropertyForDateTimeOffset(new DateTimeOffset?((DateTimeOffset)list[0].Value.ToObject <DateTimeOffset>(serializer))); break; case 4: entityProperty = EntityProperty.GeneratePropertyForDouble(new double?((double)list[0].Value.ToObject <double>(serializer))); break; case 5: entityProperty = EntityProperty.GeneratePropertyForGuid(new Guid?((Guid)list[0].Value.ToObject <Guid>(serializer))); break; case 6: entityProperty = EntityProperty.GeneratePropertyForInt(new int?((int)list[0].Value.ToObject <int>(serializer))); break; case 7: entityProperty = EntityProperty.GeneratePropertyForLong(new long?((long)list[0].Value.ToObject <long>(serializer))); break; default: throw new NotSupportedException(string.Format((IFormatProvider)CultureInfo.InvariantCulture, "Unsupported EntityProperty.PropertyType:{0} detected during deserialization.", (object)edmType)); } return(entityProperty); }
public IDictionary <string, EntityProperty> WriteEntity(OperationContext operationContext) { //Azure Lib calls this when it wants to transform this entity to a writeable one var dic = new Dictionary <string, EntityProperty>(); foreach (KeyValuePair <string, DynamicValue> cell in _row) { EntityProperty ep; Type t = cell.Value.OriginalType; if (t == typeof(bool)) { ep = EntityProperty.GeneratePropertyForBool(cell.Value); } else if (t == typeof(DateTime) || t == typeof(DateTimeOffset)) { ep = EntityProperty.GeneratePropertyForDateTimeOffset(((DateTime)cell.Value).ToUniversalTime()); } else if (t == typeof(int)) { ep = EntityProperty.GeneratePropertyForInt(cell.Value); } else if (t == typeof(long)) { ep = EntityProperty.GeneratePropertyForLong(cell.Value); } else if (t == typeof(double)) { ep = EntityProperty.GeneratePropertyForDouble(cell.Value); } else if (t == typeof(Guid)) { ep = EntityProperty.GeneratePropertyForGuid(cell.Value); } else if (t == typeof(byte[])) { ep = EntityProperty.GeneratePropertyForByteArray(cell.Value); } else { ep = EntityProperty.GeneratePropertyForString(cell.Value); } dic[cell.Key] = ep; } return(dic); }
/// <summary> /// Function member to validate field type. /// </summary> /// <param name="value">The value.</param> /// <returns>EntityProperty converted from object</returns> /// <exception cref="System.ArgumentException">Type not supported</exception> public static EntityProperty WriteEntityProperty(object value) { ////******************* WCF Data Services type ************************/ ////Edm.Binary -> byte[], An array of bytes up to 64 KB in size. ////Edm.Boolean -> bool, A Boolean value. ////Edm.DateTime -> DateTime, A 64-bit value expressed as Coordinated Universal Time (UTC). ////The supported DateTime range begins from 12:00 midnight, January 1, 1601 A.D. (C.E.), UTC. The range ends at December 31, 9999. ////Edm.Double -> double, A 64-bit floating point value. ////Edm.Guid -> Guid, A 128-bit globally unique identifier. ////Edm.Int32 -> Int32 or int, A 32-bit integer. ////Edm.Int64 -> Int64 or long, A 64-bit integer. ////Edm.String -> String, A UTF-16-encoded value. String values may be up to 64 KB in size. Type type = value.GetType(); switch (type.Name) { // WCF Data Services type case "Byte[]": return(EntityProperty.GeneratePropertyForByteArray((byte[])value)); case "Boolean": return(EntityProperty.GeneratePropertyForBool((bool)value)); case "DateTime": return(EntityProperty.GeneratePropertyForDateTimeOffset(new DateTimeOffset((DateTime)value))); case "DateTimeOffset": return(EntityProperty.GeneratePropertyForDateTimeOffset((DateTimeOffset)value)); case "Double": return(EntityProperty.GeneratePropertyForDouble((double)value)); case "Guid": return(EntityProperty.GeneratePropertyForGuid((Guid)value)); case "Int32": return(EntityProperty.GeneratePropertyForInt((int)value)); case "Int64": return(EntityProperty.GeneratePropertyForLong((long)value)); case "String": return(EntityProperty.GeneratePropertyForString((string)value)); default: throw new ArgumentException(string.Format("Type \"{0}\" is not supported.", type.FullName)); } }
public IDictionary <string, EntityProperty> WriteEntity(OperationContext operationContext) { var dict = new Dictionary <string, EntityProperty> { [ManifestKeyName] = EntityProperty.GeneratePropertyForString(Manifest), [PayloadKeyName] = EntityProperty.GeneratePropertyForByteArray(Payload), [UtcTicksKeyName] = EntityProperty.GeneratePropertyForLong(UtcTicks), [IdxPartitionKeyKeyName] = EntityProperty.GeneratePropertyForString(IdxPartitionKey), [IdxRowKeyKeyName] = EntityProperty.GeneratePropertyForString(IdxRowKey), [IdxTagKeyName] = EntityProperty.GeneratePropertyForString(IdxTag) }; return(dict); }
public static DynamicTableEntity ToEntity( this EventBase @event, string partitionkey, long eventVersion) { Ensure.ArgumentNotNull(@event, nameof(@event)); var dte = new DynamicTableEntity(partitionkey, eventVersion.FormatLong()); dte.Properties = new Dictionary <string, EntityProperty>(); dte.Properties.Add(StorageConstants.EventStore.EventType, EntityProperty.GeneratePropertyForString(@event.GetType().AssemblyQualifiedName)); var bytes = Encoding.Default.GetBytes(JsonConvert.SerializeObject(@event)); // var compressed = Brotli.CompressBuffer(bytes, 0, bytes.Length); dte.Properties.Add(StorageConstants.EventStore.EventData, EntityProperty.GeneratePropertyForByteArray(bytes)); return(dte); }
private List <TableOperation> BuildTableOperationInsert(T entity) { List <KeyValuePair <string, EntityProperty> > fields = GetEntityFilterableFields(entity).ToList(); EntityProperty serializedField = EntityProperty.GeneratePropertyForByteArray(BSonConvert.SerializeObject(entity)); var record = GenerateRecordMainPartition(entity, serializedField, fields); List <TableOperation> operations = new List <TableOperation> { TableOperation.Insert(record) }; foreach (var partitionRecord in GeneratePersistPartitionData(entity, serializedField, fields)) { operations.Add(TableOperation.Insert(partitionRecord)); } return(operations); }
protected EntityProperty GenerateProperty(EdmType propertyValueType, object propertyValueStr) { EntityProperty propertyValue; switch (propertyValueType) { case EdmType.String: propertyValue = EntityProperty.GeneratePropertyForString((string)propertyValueStr); break; case EdmType.Binary: propertyValue = EntityProperty.GeneratePropertyForByteArray(Convert.FromBase64String(propertyValueStr.ToString())); break; case EdmType.Boolean: propertyValue = EntityProperty.GeneratePropertyForBool(Convert.ToBoolean(propertyValueStr)); break; case EdmType.DateTime: propertyValue = EntityProperty.GeneratePropertyForDateTimeOffset((DateTime)propertyValueStr); break; case EdmType.Double: propertyValue = EntityProperty.GeneratePropertyForDouble(Convert.ToDouble(propertyValueStr)); break; case EdmType.Guid: propertyValue = EntityProperty.GeneratePropertyForGuid(Guid.Parse(propertyValueStr.ToString())); break; case EdmType.Int32: propertyValue = EntityProperty.GeneratePropertyForInt(Convert.ToInt32(propertyValueStr)); break; case EdmType.Int64: propertyValue = EntityProperty.GeneratePropertyForLong(Convert.ToInt64(propertyValueStr)); break; default: throw new ArgumentException($"Can't create table property with Type {string.Join(", ", propertyValueType)} and value {propertyValueStr}"); } return(propertyValue); }
/// <summary> /// Save the DTT square to batch. /// </summary> /// <param name="tableName">Name of the table.</param> /// <param name="square">The square.</param> private void SaveDTTSquareToBatch(string tableName, DTTSquare square) { try { byte[] block = new byte[square.DttValues.Length * sizeof(int)]; Buffer.BlockCopy(square.DttValues, 0, block, 0, block.Length); var stream = new MemoryStream(); using (Stream ds = new GZipStream(stream, CompressionMode.Compress)) { ds.Write(block, 0, square.DttValues.Count() * sizeof(int)); } byte[] compressed = stream.ToArray(); DynamicTableEntity entity = new DynamicTableEntity(); entity.Properties.Add("DataRecord", EntityProperty.GeneratePropertyForByteArray(compressed)); entity.Properties.Add("Easting", EntityProperty.GeneratePropertyForInt(square.Easting)); entity.Properties.Add("Northing", EntityProperty.GeneratePropertyForInt(square.Northing)); entity.RowKey = square.Northing.ToString().PadLeft(7, '0'); entity.PartitionKey = square.Easting.ToString().PadLeft(7, '0'); if (!batches.ContainsKey(entity.PartitionKey)) { batches[entity.PartitionKey] = new TableBatchOperation(); } TableBatchOperation batchOperations = batches[entity.PartitionKey]; batchOperations.Add(TableOperation.Insert(entity)); if (batchOperations.Count >= 50) { this.FlushBatch(tableName, batchOperations); batchOperations.Clear(); } } catch (Exception ex) { this.Logger.Log(TraceEventType.Error, LoggingMessageId.DttSyncGenericMessage, string.Format("Exception Occured in Table: {0}, Exception :{1}", tableName, ex.ToString())); } }
public void TableBatchEntityOver1MBShouldThrow() { TableBatchOperation batch = new TableBatchOperation(); string pk = Guid.NewGuid().ToString(); DynamicReplicatedTableEntity ent = GenerateRandomEnitity(pk); ent.Properties.Add("binary", EntityProperty.GeneratePropertyForByteArray(new byte[1024 * 1024])); batch.Insert(ent); OperationContext opContext = new OperationContext(); try { this.repTable.ExecuteBatch(batch, null, opContext); Assert.Fail(); } catch (StorageException) { TestHelper.ValidateResponse(opContext, 2, (int)HttpStatusCode.BadRequest, new string[] { "EntityTooLarge" }, "The entity is larger than the maximum allowed size (1MB)."); } }
public void TableBatchOver4MBShouldThrow() { TableBatchOperation batch = new TableBatchOperation(); string pk = Guid.NewGuid().ToString(); for (int m = 0; m < 65; m++) { DynamicReplicatedTableEntity ent = GenerateRandomEnitity(pk); // Maximum Entity size is 64KB ent.Properties.Add("binary", EntityProperty.GeneratePropertyForByteArray(new byte[64 * 1024])); batch.Insert(ent); } OperationContext opContext = new OperationContext(); try { this.repTable.ExecuteBatch(batch, null, opContext); Assert.Fail(); } catch (StorageException) { // // ###XXX: NEW SOURCE CODES: The commented out codes were the original codes // //TestHelper.ValidateResponse(opContext, 1, (int)HttpStatusCode.BadRequest, new string[] { "ContentLengthExceeded" }, "The content length for the requested operation has exceeded the limit (4MB)."); TestHelper.ValidateResponse( opContext, 2, (int)HttpStatusCode.RequestEntityTooLarge, new string[] { "RequestBodyTooLarge" }, "The request body is too large and exceeds the maximum permissible limit" ); } }
static List <PropertyConverter> GetPropertyConvertersForType(Type type) { var propertyConverters = new List <PropertyConverter>(); BindingFlags flags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly; // Loop through the type hierarchy to find all [DataMember] attributes which belong to [DataContract] classes. while (type != null && type.GetCustomAttribute <DataContractAttribute>() != null) { foreach (MemberInfo member in type.GetMembers(flags)) { DataMemberAttribute dataMember = member.GetCustomAttribute <DataMemberAttribute>(); if (dataMember == null) { continue; } PropertyInfo property = member as PropertyInfo; FieldInfo field = member as FieldInfo; if (property == null && field == null) { throw new InvalidDataContractException("Only fields and properties can be marked as [DataMember]."); } else if (property != null && (!property.CanWrite || !property.CanRead)) { throw new InvalidDataContractException("[DataMember] properties must be both readable and writeable."); } // Timestamp is a reserved property name in Table Storage, so the name needs to be changed. string propertyName = dataMember.Name ?? member.Name; if (string.Equals(propertyName, "Timestamp", StringComparison.OrdinalIgnoreCase)) { propertyName = "_Timestamp"; } Func <object, EntityProperty> getEntityPropertyFunc; Action <object, EntityProperty> setObjectPropertyFunc; Type memberValueType = property != null ? property.PropertyType : field.FieldType; if (typeof(string).IsAssignableFrom(memberValueType)) { if (property != null) { getEntityPropertyFunc = o => EntityProperty.GeneratePropertyForString((string)property.GetValue(o)); setObjectPropertyFunc = (o, e) => property.SetValue(o, e.StringValue); } else { getEntityPropertyFunc = o => EntityProperty.GeneratePropertyForString((string)field.GetValue(o)); setObjectPropertyFunc = (o, e) => field.SetValue(o, e.StringValue); } } else if (memberValueType.IsEnum) { // Enums are serialized as strings for readability. if (property != null) { getEntityPropertyFunc = o => EntityProperty.GeneratePropertyForString(property.GetValue(o).ToString()); setObjectPropertyFunc = (o, e) => property.SetValue(o, Enum.Parse(memberValueType, e.StringValue)); } else { getEntityPropertyFunc = o => EntityProperty.GeneratePropertyForString(field.GetValue(o).ToString()); setObjectPropertyFunc = (o, e) => field.SetValue(o, Enum.Parse(memberValueType, e.StringValue)); } } else if (typeof(int?).IsAssignableFrom(memberValueType)) { if (property != null) { getEntityPropertyFunc = o => EntityProperty.GeneratePropertyForInt((int?)property.GetValue(o)); setObjectPropertyFunc = (o, e) => property.SetValue(o, e.Int32Value); } else { getEntityPropertyFunc = o => EntityProperty.GeneratePropertyForInt((int?)field.GetValue(o)); setObjectPropertyFunc = (o, e) => field.SetValue(o, e.Int32Value); } } else if (typeof(long?).IsAssignableFrom(memberValueType)) { if (property != null) { getEntityPropertyFunc = o => EntityProperty.GeneratePropertyForLong((long?)property.GetValue(o)); setObjectPropertyFunc = (o, e) => property.SetValue(o, e.Int64Value); } else { getEntityPropertyFunc = o => EntityProperty.GeneratePropertyForLong((long?)field.GetValue(o)); setObjectPropertyFunc = (o, e) => field.SetValue(o, e.Int64Value); } } else if (typeof(bool?).IsAssignableFrom(memberValueType)) { if (property != null) { getEntityPropertyFunc = o => EntityProperty.GeneratePropertyForBool((bool?)property.GetValue(o)); setObjectPropertyFunc = (o, e) => property.SetValue(o, e.BooleanValue); } else { getEntityPropertyFunc = o => EntityProperty.GeneratePropertyForBool((bool?)field.GetValue(o)); setObjectPropertyFunc = (o, e) => field.SetValue(o, e.BooleanValue); } } else if (typeof(DateTime?).IsAssignableFrom(memberValueType)) { if (property != null) { getEntityPropertyFunc = o => EntityProperty.GeneratePropertyForDateTimeOffset((DateTime?)property.GetValue(o)); setObjectPropertyFunc = (o, e) => property.SetValue(o, e.DateTime); } else { getEntityPropertyFunc = o => EntityProperty.GeneratePropertyForDateTimeOffset((DateTime?)field.GetValue(o)); setObjectPropertyFunc = (o, e) => field.SetValue(o, e.DateTime); } } else if (typeof(DateTimeOffset?).IsAssignableFrom(memberValueType)) { if (property != null) { getEntityPropertyFunc = o => EntityProperty.GeneratePropertyForDateTimeOffset((DateTimeOffset?)property.GetValue(o)); setObjectPropertyFunc = (o, e) => property.SetValue(o, e.DateTimeOffsetValue); } else { getEntityPropertyFunc = o => EntityProperty.GeneratePropertyForDateTimeOffset((DateTimeOffset?)field.GetValue(o)); setObjectPropertyFunc = (o, e) => field.SetValue(o, e.DateTimeOffsetValue); } } else if (typeof(Guid?).IsAssignableFrom(memberValueType)) { if (property != null) { getEntityPropertyFunc = o => EntityProperty.GeneratePropertyForGuid((Guid?)property.GetValue(o)); setObjectPropertyFunc = (o, e) => property.SetValue(o, e.GuidValue); } else { getEntityPropertyFunc = o => EntityProperty.GeneratePropertyForGuid((Guid?)field.GetValue(o)); setObjectPropertyFunc = (o, e) => field.SetValue(o, e.GuidValue); } } else if (typeof(double?).IsAssignableFrom(memberValueType)) { if (property != null) { getEntityPropertyFunc = o => EntityProperty.GeneratePropertyForDouble((double?)property.GetValue(o)); setObjectPropertyFunc = (o, e) => property.SetValue(o, e.DoubleValue); } else { getEntityPropertyFunc = o => EntityProperty.GeneratePropertyForDouble((double?)field.GetValue(o)); setObjectPropertyFunc = (o, e) => field.SetValue(o, e.DoubleValue); } } else if (typeof(byte[]).IsAssignableFrom(memberValueType)) { if (property != null) { getEntityPropertyFunc = o => EntityProperty.GeneratePropertyForByteArray((byte[])property.GetValue(o)); setObjectPropertyFunc = (o, e) => property.SetValue(o, e.BinaryValue); } else { getEntityPropertyFunc = o => EntityProperty.GeneratePropertyForByteArray((byte[])field.GetValue(o)); setObjectPropertyFunc = (o, e) => field.SetValue(o, e.BinaryValue); } } else // assume a serializeable object { getEntityPropertyFunc = o => { object value = property != null?property.GetValue(o) : field.GetValue(o); string json = value != null?JsonConvert.SerializeObject(value) : null; return(EntityProperty.GeneratePropertyForString(json)); }; setObjectPropertyFunc = (o, e) => { string json = e.StringValue; object value = json != null?JsonConvert.DeserializeObject(json, memberValueType) : null; if (property != null) { property.SetValue(o, value); } else { field.SetValue(o, value); } }; } propertyConverters.Add(new PropertyConverter(propertyName, getEntityPropertyFunc, setObjectPropertyFunc)); } type = type.BaseType; } return(propertyConverters); }
public override IDictionary <string, EntityProperty> WriteEntity(OperationContext operationContext) { var properties = new Dictionary <string, EntityProperty>(); foreach (var getter in Getters) { var value = getter.Value.Item2(Entity); if (value == null) { continue; } var type = getter.Value.Item1; EntityProperty entityProperty = null; if (type == typeof(bool) || type == typeof(bool?)) { entityProperty = EntityProperty.GeneratePropertyForBool((bool?)value); } else if (type == typeof(int) || type == typeof(int?)) { entityProperty = EntityProperty.GeneratePropertyForInt((int?)value); } else if (type == typeof(long) || type == typeof(long?)) { entityProperty = EntityProperty.GeneratePropertyForLong((long?)value); } else if (type == typeof(double) || type == typeof(double?)) { entityProperty = EntityProperty.GeneratePropertyForDouble((double?)value); } else if (type == typeof(float) || type == typeof(float?)) { entityProperty = EntityProperty.GeneratePropertyForDouble((float?)value); } else if (type == typeof(DateTime) || type == typeof(DateTime?)) { entityProperty = EntityProperty.GeneratePropertyForDateTimeOffset((DateTime?)value); } else if (type == typeof(DateTimeOffset) || type == typeof(DateTimeOffset?)) { entityProperty = EntityProperty.GeneratePropertyForDateTimeOffset((DateTimeOffset?)value); } else if (type == typeof(Guid) || type == typeof(Guid?)) { entityProperty = EntityProperty.GeneratePropertyForGuid((Guid?)value); } else if (type == typeof(byte[])) { entityProperty = EntityProperty.GeneratePropertyForByteArray(value as byte[]); } else if (type == typeof(string)) { entityProperty = EntityProperty.GeneratePropertyForString(value as string); } if (entityProperty != null) { properties[getter.Key] = entityProperty; } } return(properties); }