/// <summary>
 /// Read the entity properties
 /// </summary>
 /// <param name="properties"></param>
 /// <param name="operationContext"></param>
 public void ReadEntity(IDictionary <string, EntityProperty> properties, OperationContext operationContext)
 {
     TableEntity.ReadUserObject(this, properties, operationContext);
 }
Пример #2
0
        /// <inheritdoc />
        public void ReadEntity(IDictionary <string, EntityProperty> properties, OperationContext operationContext)
        {
            _value = new T();

            // DEBUG
            if (_value.GetType() == typeof(POCO.RecordAssociationKeyPhraseCount))
            {
                bool isDebug = true;
            }

            TableEntity.ReadUserObject(Value, properties, operationContext);

            var additionalMappings = GetAdditionPropertyMappings(Value, properties);

            if (additionalMappings.Count > 0)
            {
                // Populate the properties missing from ReadUserObject
                foreach (var additionalMapping in additionalMappings)
                {
                    // FIX for PartitionKey and RowKey in the user object
                    if (properties.ContainsKey(additionalMapping.Name) == false &&
                        (additionalMapping.Name != "PartitionKey" &&
                         additionalMapping.Name != "RowKey"))
                    {
                        // We will let the object assign its default value for that property
                        continue;
                    }

                    switch (additionalMapping.Name)
                    {
                    case "PartitionKey":
                        additionalMapping.SetValue(Value, this.PartitionKey);
                        break;

                    case "RowKey":
                        additionalMapping.SetValue(Value, this.RowKey);
                        break;

                    default:
                        var propertyValue = properties[additionalMapping.Name];
                        var converter     = TypeDescriptor.GetConverter(additionalMapping.PropertyType);
                        // NOT WORKING EITHER var convertedValue = converter.ConvertFrom(propertyValue.PropertyAsObject);
                        switch (propertyValue.PropertyType)
                        {
                        case EdmType.DateTime:
                            if (additionalMapping.SetMethod != null)
                            {
                                additionalMapping.SetValue(Value, propertyValue.DateTime);
                            }
                            break;

                        case EdmType.Double:
                            if (additionalMapping.SetMethod != null)
                            {
                                additionalMapping.SetValue(Value, propertyValue.DoubleValue);
                            }
                            break;

                        case EdmType.Int32:
                            if (additionalMapping.SetMethod != null)
                            {
                                additionalMapping.SetValue(Value, propertyValue.Int32Value);
                            }
                            break;

                        case EdmType.Int64:
                            if (additionalMapping.SetMethod != null)
                            {
                                additionalMapping.SetValue(Value, propertyValue.Int64Value);
                            }
                            break;

                        case EdmType.Boolean:
                            if (additionalMapping.SetMethod != null)
                            {
                                additionalMapping.SetValue(Value, propertyValue.BooleanValue);
                            }
                            break;

                        case EdmType.String:
                            if (additionalMapping.PropertyType == typeof(DateTime))
                            {
                                DateTime convertedDateTime;
                                bool     isConvereted = DateTime.TryParse(propertyValue.StringValue, out convertedDateTime);
                                if (isConvereted)
                                {
                                    if (additionalMapping.SetMethod != null)
                                    {
                                        additionalMapping.SetValue(Value, convertedDateTime);
                                    }
                                }
                                else
                                {
                                    var convertedDateTimeValue = converter.ConvertFromInvariantString(propertyValue.StringValue);
                                    if (additionalMapping.SetMethod != null)
                                    {
                                        additionalMapping.SetValue(Value, convertedDateTimeValue);
                                    }
                                }
                            }
                            else
                            {
                                var convertedStringValue = converter.ConvertFromInvariantString(propertyValue.StringValue);
                                if (additionalMapping.SetMethod != null)
                                {
                                    additionalMapping.SetValue(Value, convertedStringValue);
                                }
                            }
                            break;

                        default:
                            var convertedValue = converter.ConvertFromInvariantString(propertyValue.StringValue);
                            if (additionalMapping.SetMethod != null)
                            {
                                additionalMapping.SetValue(Value, convertedValue);
                            }
                            break;
                        }

                        break;
                    }
                }
            }


            ReadValues(properties, operationContext);
        }