2

データ アクセスにリフレクションと GetCustomAttributes を使用しているため、パフォーマンスの問題があります。パフォーマンス プロファイラーが検出しました。次のような拡張メソッドがあります。

public static class DataRowExtensions
{
    /// <summary>
    /// Maps DataRow objecto to entity T depending on the defined attributes. 
    /// </summary>
    /// <typeparam name="T">Entity to map.</typeparam>
    /// <param name="rowInstance">DataRow instance.</param>
    /// <returns>Instance to created entity.</returns>
    public static T MapRow<T>(this DataRow rowInstance) where T : class, new()
    {
        //Create T item
        T instance = new T();

        IEnumerable<PropertyInfo> properties = typeof(T).GetProperties();
        MappingAttribute map;
        DataColumn column;

        foreach (PropertyInfo item in properties)
        {
            //check if custom attribute exist in this property
            object[] definedAttributes = item.GetCustomAttributes(typeof(MappingAttribute), false);

            // Tiene atributos
            if (definedAttributes != null && definedAttributes.Length == 1)
            {
                //recover first attribute
                map = definedAttributes.First() as MappingAttribute;

                column = rowInstance.Table.Columns.OfType<DataColumn>()
                                          .Where(c => c.ColumnName == map.ColumnName)
                                          .SingleOrDefault();

                if (column != null)
                {
                    object dbValue = rowInstance[column.ColumnName];
                    object valueToSet = null;

                    if (dbValue == DBNull.Value)//if value is null
                        valueToSet = map.DefaultValue;
                    else
                        valueToSet = dbValue;

                    //Set value in property 
                    setValue<T>(instance, item, valueToSet);
                }
            }
        }

        return instance;
    }

    /// <summary>
    /// Set "item" property.
    /// </summary>
    /// <typeparam name="T">Return entity type</typeparam>
    /// <param name="instance">T type instance</param>
    /// <param name="item">Property name to return value</param>
    /// <param name="valueToSet">Value to set to the property</param>
    private static void setValue<T>(T instance, PropertyInfo item, object valueToSet) where T : class, new()
    {
        if (valueToSet == null)
        {
            CultureInfo ci = CultureInfo.InvariantCulture;

            if (item.PropertyType.IsSubclassOf(typeof(System.ValueType)))
            {
                //if is a value type and is nullable
                if (item.PropertyType.FullName.Contains("System.Nullable"))
                {
                    item.SetValue(instance, null, BindingFlags.Public, null, null, ci);
                }
                else
                {
                    item.SetValue(instance, Activator.CreateInstance(item.PropertyType, null), BindingFlags.Public, null, null, ci);
                }
            }
            else //property type is reference type
            {
                item.SetValue(instance, null, BindingFlags.Public, null, null, ci);
            }
        }
        else // set not null value
        {
            //if is a value type and is nullable
            if (item.PropertyType.FullName.Contains("System.Nullable"))
            {
                item.SetValue(instance, Convert.ChangeType(valueToSet, Nullable.GetUnderlyingType(item.PropertyType)), null);
            }
            else
            {
                item.SetValue(instance, Convert.ChangeType(valueToSet, item.PropertyType), null);
            }
        }
    }
}

ここで行うことは、本質的に、ドメイン エンティティをデータベース フィールドにマップし、データ ヘルパーがテーブルを自動的に攻撃することです。これらのエンティティの 1 つの例は次のとおりです。

public class ComboBox
    {
    /// <summary>
    /// Represents a ComboBox item.
    /// </summary>
    [Mapping("CODE", DefaultValue = 0, DBType = DbParametersTypes.Varchar2, IsKey = true, IdentifierFK = "")]
    public string Code { get; set; }

    /// <summary>
    /// Represents Text.
    /// </summary>
    [Mapping("DESCRIPTION", DefaultValue = "", DBType = DbParametersTypes.Varchar2, IsKey = false, IdentifierFK = "")]
    public string Description { get; set; }

    }

そして、私が使用する属性クラス:

public sealed class MappingAttribute : Attribute
    {
        public string ColumnName { get; set; }

        public object DefaultValue { get; set; }

        public DbParametersTypes DBType { get; set; }

        public bool IsKey { get; set; }

        public string IdentifierFK { get; set; }

        public bool IsParameter { get; set; } 

        public MappingAttribute(string columnName)
        {
            if (String.IsNullOrEmpty(columnName))
                throw new ArgumentNullException("columnName");

            ColumnName = columnName;
        }               
    }

ここで、改善の可能性は式ツリーである可能性があると読みましたが、まず、私は式ツリーの専門家ではありません。次に、これを .NET 3.5 で解決する必要があります... (サンプルでは .NET 4 または 4.5使用されている...）

¿提案?

前もって感謝します。

4

1 に答える 1

4 
public static class DataRowExtensions
{
    /// <summary>
    /// Maps DataRow objecto to entity T depending on the defined attributes. 
    /// </summary>
    /// <typeparam name="T">Entity to map.</typeparam>
    /// <param name="rowInstance">DataRow instance.</param>
    /// <returns>Instance to created entity.</returns>
    public static T MapRow<T>( this DataRow rowInstance ) where T : class, new()
    {
        //Create T item
        var instance = new T();
        Mapper<T>.MapRow( instance, rowInstance );
        return instance;
    }

    #region Nested type: Mapper

    private static class Mapper<T>
        where T : class
    {
        private static readonly ItemMapper[] __mappers;

        static Mapper()
        {
            __mappers = typeof (T)
                .GetProperties()
                .Where( p => p.IsDefined( typeof (MappingAttribute), false ) )
                .Select( p => new
                {
                    Property = p,
                    Attribute = p
                                  .GetCustomAttributes( typeof (MappingAttribute), false )
                                  .Cast<MappingAttribute>()
                                  .FirstOrDefault()
                } )
                .Select( m => new ItemMapper( m.Property, m.Attribute ) )
                .ToArray();
        }

        public static void MapRow( T instance, DataRow row )
        {
            foreach ( var mapper in __mappers )
            {
                mapper.MapRow( instance, row );
            }
        }

        #region Nested type: ItemMapper

        private sealed class ItemMapper
        {
            private readonly MappingAttribute _attribute;
            private readonly PropertyInfo _property;

            public ItemMapper( PropertyInfo property, MappingAttribute attribute )
            {
                _property = property;
                _attribute = attribute;
            }

            public void MapRow( T instance, DataRow rowInstance )
            {
                //TODO: Implement this with the code already provided
            }
        }

        #endregion
    }

    #endregion
}

特定の に対して拡張メソッドが初めて呼び出されると<T>、静的コンストラクターが実行され、アタッチMapperされている各プロパティのインスタンスがキャッシュされます。MappingAttributeその後の呼び出しごとに、キャッシュされたマッパーを使用して実際のコピーを行います。

Mapper抽象化して、 のブランチごとに異なるサブクラスを使用することもできますsetValue<T>()。そうすれば、あなたの反省のほとんどは一度だけ起こります。

于 2012-10-16T13:30:55.143 に答える