EF Code Firstでの小数精度と位取り


230

私はこのコードファーストアプローチを試していますが、System.Decimal型のプロパティがdecimal(18、0)型のsql列にマップされていることがわかりました。

データベース列の精度を設定するにはどうすればよいですか?


11
1つの方法は[Column(TypeName = "decimal(18,4)")]、10進数のプロパティに属性を使用することです
S.Serpooshan

[Column(TypeName = "decimal(18,4)")]はうまくいきました!!!
ブライアンライス

回答:


257

Dave Van den Eyndeからの回答は現在、古くなっています。EF 4.1以降、2つの重要な変更があります。ModelBuilderクラスはDbModelBuilderになり、次のシグネチャを持つDecimalPropertyConfiguration.HasPrecisionメソッドがあります。

public DecimalPropertyConfiguration HasPrecision(
byte precision,
byte scale )

ここで、precisionは、小数点がどこにあるかに関係なく、dbが格納する合計桁数で、scaleは、格納する小数点以下の桁数です。

したがって、示されているようにプロパティを反復処理する必要はありませんが、

public class EFDbContext : DbContext
{
   protected override void OnModelCreating(System.Data.Entity.DbModelBuilder modelBuilder)
   {
       modelBuilder.Entity<Class>().Property(object => object.property).HasPrecision(12, 10);

       base.OnModelCreating(modelBuilder);
   }
}

DbModelBuilderで問題が発生している場合は、試してくださいSystem.Data.Entity.ModelConfiguration.ModelBuilder modelBuilder
ロイドパウエル

1
電話をかけたことがないことに気づきましたbase.OnModelCreating(modelBuilder);。それは、意図的でしたか、IDEではなくオンラインでコードを入力した犠牲者でしたか?
BenSwayne、2012

1
@BenSwayneスポットをありがとう、これは私の省略であり、意図的なものではありません。回答を編集します。
AlexC、

26
HasPrecision(精度、スケール)への2つの引数は、十分に文書化されていません。精度は、小数点の位置に関係なく、格納される合計桁数です。scaleは、格納する小数点以下の桁数です。
Chris Moschini、

1
1つの場所ですべてのエンティティのすべての10進数プロパティに設定するEF構成はありますか?通常は(19,4)を使用します。これをすべての10進数のプロパティに自動的に適用すると、プロパティの精度を設定することを忘れず、計算で予想される精度を逃すことができます。
Mike de Klerk、2016年

89

すべての精度を設定する場合 decimalsEF6DecimalPropertyConventionは、で使用されているデフォルトの規則を置き換えることができますDbModelBuilder

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
    modelBuilder.Conventions.Remove<DecimalPropertyConvention>();
    modelBuilder.Conventions.Add(new DecimalPropertyConvention(38, 18));
}

デフォルト DecimalPropertyConventionEF6は、decimalプロパティをdecimal(18,2)列にマップします。

個別のプロパティのみに指定された精度を持たせたい場合は、エンティティのプロパティの精度をで設定できますDbModelBuilder

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
    modelBuilder.Entity<MyEntity>().Property(e => e.Value).HasPrecision(38, 18);
}

または、EntityTypeConfiguration<>精度を指定するエンティティのを追加します。

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
    modelBuilder.Configurations.Add(new MyEntityConfiguration());
}

internal class MyEntityConfiguration : EntityTypeConfiguration<MyEntity>
{
    internal MyEntityConfiguration()
    {
        this.Property(e => e.Value).HasPrecision(38, 18);
    }
}

1
私のお気に入りのソリューション。CodeFirstとマイグレーションを使用する場合に最適に機能します。EFは、「10進数」が使用されるすべてのクラスのすべてのプロパティを探し、これらのプロパティのマイグレーションを生成します。すごい!
okieh 2015

75

私はこれのためにカスタム属性を作成する良い時間を過ごしました:

[AttributeUsage(AttributeTargets.Property, Inherited = false, AllowMultiple = false)]
public sealed class DecimalPrecisionAttribute : Attribute
{
    public DecimalPrecisionAttribute(byte precision, byte scale)
    {
        Precision = precision;
        Scale = scale;

    }

    public byte Precision { get; set; }
    public byte Scale { get; set; }

}

このように使う

[DecimalPrecision(20,10)]
public Nullable<decimal> DeliveryPrice { get; set; }

そして魔法はモデルの作成時に反射して起こります

protected override void OnModelCreating(System.Data.Entity.ModelConfiguration.ModelBuilder modelBuilder)
{
    foreach (Type classType in from t in Assembly.GetAssembly(typeof(DecimalPrecisionAttribute)).GetTypes()
                                   where t.IsClass && t.Namespace == "YOURMODELNAMESPACE"
                                   select t)
     {
         foreach (var propAttr in classType.GetProperties(BindingFlags.Public | BindingFlags.Instance).Where(p => p.GetCustomAttribute<DecimalPrecisionAttribute>() != null).Select(
                p => new { prop = p, attr = p.GetCustomAttribute<DecimalPrecisionAttribute>(true) }))
         {

             var entityConfig = modelBuilder.GetType().GetMethod("Entity").MakeGenericMethod(classType).Invoke(modelBuilder, null);
             ParameterExpression param = ParameterExpression.Parameter(classType, "c");
             Expression property = Expression.Property(param, propAttr.prop.Name);
             LambdaExpression lambdaExpression = Expression.Lambda(property, true,
                                                                      new ParameterExpression[]
                                                                          {param});
             DecimalPropertyConfiguration decimalConfig;
             if (propAttr.prop.PropertyType.IsGenericType && propAttr.prop.PropertyType.GetGenericTypeDefinition() == typeof(Nullable<>))
             {
                 MethodInfo methodInfo = entityConfig.GetType().GetMethods().Where(p => p.Name == "Property").ToList()[7];
                 decimalConfig = methodInfo.Invoke(entityConfig, new[] { lambdaExpression }) as DecimalPropertyConfiguration;
             }
             else
             {
                 MethodInfo methodInfo = entityConfig.GetType().GetMethods().Where(p => p.Name == "Property").ToList()[6];
                 decimalConfig = methodInfo.Invoke(entityConfig, new[] { lambdaExpression }) as DecimalPropertyConfiguration;
             }

             decimalConfig.HasPrecision(propAttr.attr.Precision, propAttr.attr.Scale);
        }
    }
}

最初の部分は、モデル内のすべてのクラスを取得することです(私のカスタム属性はそのアセンブリで定義されているため、モデルを使用してアセンブリを取得するために使用しました)

2番目のforeachは、カスタム属性を持つそのクラスのすべてのプロパティと属性自体を取得するので、精度とスケールデータを取得できます

その後私は電話しなければなりません

modelBuilder.Entity<MODEL_CLASS>().Property(c=> c.PROPERTY_NAME).HasPrecision(PRECISION,SCALE);

したがって、リフレクションによってmodelBuilder.Entity()を呼び出し、それをentityConfig変数に格納してから、「c => c.PROPERTY_NAME」ラムダ式を作成します

その後、小数がnull可能である場合、

Property(Expression<Func<TStructuralType, decimal?>> propertyExpression) 

メソッド(私はこれを配列内の位置で呼びます、それは私が知っている理想的ではありません、どんな助けも大いに感謝されます)

そしてそれがnullableではない場合、私は

Property(Expression<Func<TStructuralType, decimal>> propertyExpression)

方法。

DecimalPropertyConfigurationを使用して、HasPrecisionメソッドを呼び出します。


3
これをありがとう。何千ものラムダ式を生成する必要がなくなりました。
ショーン

1
これは非常に機能し、非常にきれいです!EF 5の場合、System.Data.Entity.ModelConfiguration.ModelBuilderをSystem.Data.Entity.DbModelBuilderに変更しました
コリン

3
MethodInfo methodInfo = entityConfig.GetType().GetMethod("Property", new[] { lambdaExpression.GetType() });正しいオーバーロードを取得するために使用します。これまでのところ機能しているようです。
fscan 14

3
これをライブラリにまとめ、DbContextからの呼び出しを簡単にしました:github.com/richardlawley/EntityFrameworkAttributeConfig(nugetからも入手可能)
Richard

リチャード、私はあなたのプロジェクトのアイデアが好きですが、EF6を必要とするものはありますか?EF5互換のバージョンがあった場合に使用し、自分のバージョンのODP.NETで使用できるようにします。
Patrick Szalapski、2014

50

DecimalPrecisonAttributeKinSlayerUY のfrom を使用して、EF6で属性を持つ個々のプロパティを処理する規則を作成できます(この回答DecimalPropertyConvention同様の設定を行うと、すべての10進数のプロパティに影響します)。

[AttributeUsage(AttributeTargets.Property, Inherited = false, AllowMultiple = false)]
public sealed class DecimalPrecisionAttribute : Attribute
{
    public DecimalPrecisionAttribute(byte precision, byte scale)
    {
        Precision = precision;
        Scale = scale;
    }
    public byte Precision { get; set; }
    public byte Scale { get; set; }
}

public class DecimalPrecisionAttributeConvention
    : PrimitivePropertyAttributeConfigurationConvention<DecimalPrecisionAttribute>
{
    public override void Apply(ConventionPrimitivePropertyConfiguration configuration, DecimalPrecisionAttribute attribute)
    {
        if (attribute.Precision < 1 || attribute.Precision > 38)
        {
            throw new InvalidOperationException("Precision must be between 1 and 38.");
        }

        if (attribute.Scale > attribute.Precision)
        {
            throw new InvalidOperationException("Scale must be between 0 and the Precision value.");
        }

        configuration.HasPrecision(attribute.Precision, attribute.Scale);
    }
}

次にあなたのDbContext

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
    modelBuilder.Conventions.Add(new DecimalPrecisionAttributeConvention());
}

@MichaelEdenfield実際、EF6にはこれらのいずれもありません。それで、なぜ私が2つの答えを追加したのか、これとあなたが言及したもう1つの答えです。これは、モデルのすべての10進数プロパティに影響を与えるのではなく、1つの10進数プロパティに設定できる属性です。
kjbartel

悪いことに、両方を書いたことに気づかなかった:\
Michael Edenfield

1
bounds-checkを実行する場合はPrecision、上限を28に設定することをお勧めします(つまり> 28、条件に応じて)。MSDNのドキュメントによると、System.Decimal表現できるのは最大28〜29桁の精度(msdn.microsoft.com/en-us/library/364x0z75.aspx)のみです。また、属性はScaleとして宣言されbyteているため、前提条件attribute.Scale < 0は不要です。
NathanAldenSr 2015

2
@kjbartel一部のデータベースプロバイダーが28を超える精度をサポートしていることは事実です。ただし、MSDNによると、System.Decimalそうではありません。したがって、上限の前提条件を28よりも大きい値に設定しても意味がありません。System.Decimal明らかに、それほど大きな数を表すことはできません。また、この属性はSQL Server以外のデータプロバイダーにも役立ちます。たとえば、PostgreSQLのnumeric型は最大131072桁の精度をサポートしています。
NathanAldenSr 2015

1
@NathanAldenSr言ったように、データベースは固定小数点 10進数(msdn)を使用しますが、System.Decimalは浮動小数点です。それらは完全に異なります。たとえば、decimal(38,9)列があると幸せな保持になりますSystem.Decimal.MaxValueが、decimal(28,9)列は保持されません。唯一の28に精度を制限する理由はありません
kjbartel

47

どうやら、DbContext.OnModelCreating()メソッドをオーバーライドして、次のように精度を構成できます。

protected override void OnModelCreating(System.Data.Entity.ModelConfiguration.ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Product>().Property(product => product.Price).Precision = 10;
    modelBuilder.Entity<Product>().Property(product => product.Price).Scale = 2;
}

しかし、これはすべての価格関連のプロパティで実行する必要がある場合、かなり退屈なコードなので、これを思いつきました。

    protected override void OnModelCreating(System.Data.Entity.ModelConfiguration.ModelBuilder modelBuilder)
    {
        var properties = new[]
        {
            modelBuilder.Entity<Product>().Property(product => product.Price),
            modelBuilder.Entity<Order>().Property(order => order.OrderTotal),
            modelBuilder.Entity<OrderDetail>().Property(detail => detail.Total),
            modelBuilder.Entity<Option>().Property(option => option.Price)
        };

        properties.ToList().ForEach(property =>
        {
            property.Precision = 10;
            property.Scale = 2;
        });

        base.OnModelCreating(modelBuilder);
    }

基本実装が何もしない場合でも、メソッドをオーバーライドするときに基本メソッドを呼び出すことをお勧めします。

更新:この記事も非常に役に立ちました。


10
おかげで、これは正しい方向に私を向けました。CTP5では構文が変更され、同じステートメントで精度とスケールを追加できるようになりました。
2011年

2
それでも、すべての小数に設定できるある種の「デフォルト」があると便利ではないでしょうか。
Dave Van den Eynde、2011年

3
電話base.OnModelCreating(modelBuilder);は必要ないと思います。VSのDbContextメタデータから: The default implementation of this method does nothing, but it can be overridden in a derived class such that the model can be further configured before it is locked down.
Matt Jenkins、

@マット:それはいいですが、実装者として私はこれについて気にする必要はなく、常にベースを呼び出します。
Dave Van den Eynde、2011

@ Daveと@Matt:baseを呼び出すことが「重要」であるコメントがありました。これは良い習慣ですが、EFソースに空の実装がある場合、それが重要であると主張するのは誤解を招きます。そのため、人々は基地が何をしているのか疑問に思います。私がチェックするためにef5.0に逆コンパイルした重要なものにとても興味を持っていました。そこには何もありません。だからちょうど良い習慣です。
phil soady 2013年


22
[Column(TypeName = "decimal(18,2)")]

これは、ここで説明するように、EF Coreコードの最初の移行で機能します


1
これをモデルに追加するだけで取得できますThe store type 'decimal(18,2)' could not be found in the SqlServer provider manifest
Savage

@Savageは、データベースプロバイダーまたはデータベースのバージョンに問題があるようです
Elnoor '

@Elnoor Savageは正しいです。これはEF Migrations 6.xでエラーをスローします。レガシーの非コアバージョンは、Column属性を介した精度/スケールの指定をサポートしておらず、DataType属性を使用する場合は何もしません(デフォルトは18,2)。EF 6.xの属性を介して機能させるには、ModelBuilderに独自の拡張機能を実装する必要があります。
Chris Moschini

1
@ChrisMoschini、私はEF Coreに言及して私の答えを変更しました。ありがとう
Elnoor

14

このコード行は、同じことを達成するためのより簡単な方法である可能性があります。

 public class ProductConfiguration : EntityTypeConfiguration<Product>
    {
        public ProductConfiguration()
        {
            this.Property(m => m.Price).HasPrecision(10, 2);
        }
    }

9

-EF COREの場合-System.ComponentModel.DataAnnotations使用。

使用 [ColumnTypeName = "decimal精度スケール")]

精度 = 使用される文字の総数

スケール = ドットの後の総数。(混乱しやすい)

public class Blog
{
    public int BlogId { get; set; }
    [Column(TypeName = "varchar(200)")]
    public string Url { get; set; }
    [Column(TypeName = "decimal(5, 2)")]
    public decimal Rating { get; set; }
}

詳細はこちら:https : //docs.microsoft.com/en-us/ef/core/modeling/relational/data-types


3

EF6で

modelBuilder.Properties()
    .Where(x => x.GetCustomAttributes(false).OfType<DecimalPrecisionAttribute>().Any())
    .Configure(c => {
        var attr = (DecimalPrecisionAttribute)c.ClrPropertyInfo.GetCustomAttributes(typeof (DecimalPrecisionAttribute), true).FirstOrDefault();

        c.HasPrecision(attr.Precision, attr.Scale);
    });

この回答は、属性を定義する別の回答へのアップグレードのようです。これをその回答に編集してください
Rhys Bevilaqua

3

次のように、OnModelCreating関数のContextクラスの規則を使用してこれを行うようにEFにいつでも指示できます。

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
    // <... other configurations ...>
    // modelBuilder.Conventions.Remove<PluralizingTableNameConvention>();
    // modelBuilder.Conventions.Remove<ManyToManyCascadeDeleteConvention>();
    // modelBuilder.Conventions.Remove<OneToManyCascadeDeleteConvention>();

    // Configure Decimal to always have a precision of 18 and a scale of 4
    modelBuilder.Conventions.Remove<DecimalPropertyConvention>();
    modelBuilder.Conventions.Add(new DecimalPropertyConvention(18, 4));

    base.OnModelCreating(modelBuilder);
}

これは、Code First EF fyiにのみ適用され、dbにマップされるすべての10進数タイプに適用されます。


Remove<DecimalPropertyConvention>();前に来るまでそれは働いていませんでしたAdd(new DecimalPropertyConvention(18, 4));。自動的に上書きされるだけではないのはおかしいと思います。
Mike de Klerk、2016年

2

使用する

System.ComponentModel.DataAnnotations;

あなたは単にあなたのモデルにその属性を置くことができます:

[DataType("decimal(18,5)")]

1
これは、読みやすさとシンプルさのための最も簡単な実装です。私見
ランサム

11
パーmsdn.microsoft.com/en-us/library/jj591583(v=vs.113).aspx、この答えは事実間違っています。「列のTypeName属性とDataType DataAnnotationを混同しないでください。DataTypeはUIに使用される注釈であり、Code Firstでは無視されます。」
speckledcarp

2
私はちょうどそれをテストし、上記のように言ったまで、私はこれがCodeFirstのために仕事をしませんし、データベースに移行されませんので、あまり考え@ransems
RoLYroLLs

1

詳細については、MSDN-Entity Data Modelのファセットをご覧ください。 http://msdn.microsoft.com/en-us/library/ee382834.aspx 完全推奨。


それは素晴らしいことですが、それはコードファーストとどのように関連していますか?
Dave Van den Eynde、2011年

それは便利ですが、それでもDecimalの[Precision]属性を指定することはできません。そこで、@ KinSlayerUYが提供するソリューションを使用しました。
コリン

1

EntityFrameworkCore 3.1.3の実際:

OnModelCreatingのソリューション:

var fixDecimalDatas = new List<Tuple<Type, Type, string>>();
foreach (var entityType in builder.Model.GetEntityTypes())
{
    foreach (var property in entityType.GetProperties())
    {
        if (Type.GetTypeCode(property.ClrType) == TypeCode.Decimal)
        {
            fixDecimalDatas.Add(new Tuple<Type, Type, string>(entityType.ClrType, property.ClrType, property.GetColumnName()));
        }
    }
}

foreach (var item in fixDecimalDatas)
{
    builder.Entity(item.Item1).Property(item.Item2, item.Item3).HasColumnType("decimal(18,4)");
}

//custom decimal nullable:
builder.Entity<SomePerfectEntity>().Property(x => x.IsBeautiful).HasColumnType("decimal(18,4)");

0

KinSlayerUYのカスタム属性はうまく機能しましたが、ComplexTypesに問題がありました。それらは属性コードのエンティティとしてマップされていたため、ComplexTypeとしてマップできませんでした。

したがって、これを可能にするためにコードを拡張しました。

public static void OnModelCreating(DbModelBuilder modelBuilder)
    {
        foreach (Type classType in from t in Assembly.GetAssembly(typeof(DecimalPrecisionAttribute)).GetTypes()
                                   where t.IsClass && t.Namespace == "FA.f1rstval.Data"
                                   select t)
        {
            foreach (var propAttr in classType.GetProperties(BindingFlags.Public | BindingFlags.Instance).Where(p => p.GetCustomAttribute<DecimalPrecisionAttribute>() != null).Select(
                   p => new { prop = p, attr = p.GetCustomAttribute<DecimalPrecisionAttribute>(true) }))
            {

                ParameterExpression param = ParameterExpression.Parameter(classType, "c");
                Expression property = Expression.Property(param, propAttr.prop.Name);
                LambdaExpression lambdaExpression = Expression.Lambda(property, true,
                                                                         new ParameterExpression[] { param });
                DecimalPropertyConfiguration decimalConfig;
                int MethodNum;
                if (propAttr.prop.PropertyType.IsGenericType && propAttr.prop.PropertyType.GetGenericTypeDefinition() == typeof(Nullable<>))
                {
                    MethodNum = 7;
                }
                else
                {
                    MethodNum = 6;
                }

                //check if complextype
                if (classType.GetCustomAttribute<ComplexTypeAttribute>() != null)
                {
                    var complexConfig = modelBuilder.GetType().GetMethod("ComplexType").MakeGenericMethod(classType).Invoke(modelBuilder, null);
                    MethodInfo methodInfo = complexConfig.GetType().GetMethods().Where(p => p.Name == "Property").ToList()[MethodNum];
                    decimalConfig = methodInfo.Invoke(complexConfig, new[] { lambdaExpression }) as DecimalPropertyConfiguration;
                }
                else
                {
                    var entityConfig = modelBuilder.GetType().GetMethod("Entity").MakeGenericMethod(classType).Invoke(modelBuilder, null);
                    MethodInfo methodInfo = entityConfig.GetType().GetMethods().Where(p => p.Name == "Property").ToList()[MethodNum];
                    decimalConfig = methodInfo.Invoke(entityConfig, new[] { lambdaExpression }) as DecimalPropertyConfiguration;
                }

                decimalConfig.HasPrecision(propAttr.attr.Precision, propAttr.attr.Scale);
            }
        }
    }

0

@ Mark007、タイプ選択基準を変更して、DbContextのDbSet <>プロパティを追加しました。与えられた名前空間に、モデル定義の一部であってはならないクラスや、エンティティではないクラスがある場合があるので、これはより安全だと思います。または、エンティティを別の名前空間または別のアセンブリに常駐させて、1つのコンテキストにまとめることもできます。

また、可能性は低いですが、メソッド定義の順序に依存するのは安全ではないと思うので、パラメーターリストを使用してそれらを引き出す方が良いです。(.GetTypeMethods()は、新しいTypeInfoパラダイムで機能するように構築した拡張メソッドであり、メソッドを探すときにクラス階層をフラット化できます)。

OnModelCreatingはこのメソッドにデリゲートすることに注意してください。

    private void OnModelCreatingSetDecimalPrecisionFromAttribute(DbModelBuilder modelBuilder)
    {
        foreach (var iSetProp in this.GetType().GetTypeProperties(true))
        {
            if (iSetProp.PropertyType.IsGenericType
                    && (iSetProp.PropertyType.GetGenericTypeDefinition() == typeof(IDbSet<>) || iSetProp.PropertyType.GetGenericTypeDefinition() == typeof(DbSet<>)))
            {
                var entityType = iSetProp.PropertyType.GetGenericArguments()[0];

                foreach (var propAttr in entityType
                                        .GetProperties(BindingFlags.Public | BindingFlags.Instance)
                                        .Select(p => new { prop = p, attr = p.GetCustomAttribute<DecimalPrecisionAttribute>(true) })
                                        .Where(propAttr => propAttr.attr != null))
                {
                    var entityTypeConfigMethod = modelBuilder.GetType().GetTypeInfo().DeclaredMethods.First(m => m.Name == "Entity");
                    var entityTypeConfig = entityTypeConfigMethod.MakeGenericMethod(entityType).Invoke(modelBuilder, null);

                    var param = ParameterExpression.Parameter(entityType, "c");
                    var lambdaExpression = Expression.Lambda(Expression.Property(param, propAttr.prop.Name), true, new ParameterExpression[] { param });

                    var propertyConfigMethod =
                        entityTypeConfig.GetType()
                            .GetTypeMethods(true, false)
                            .First(m =>
                            {
                                if (m.Name != "Property")
                                    return false;

                                var methodParams = m.GetParameters();

                                return methodParams.Length == 1 && methodParams[0].ParameterType == lambdaExpression.GetType();
                            }
                            );

                    var decimalConfig = propertyConfigMethod.Invoke(entityTypeConfig, new[] { lambdaExpression }) as DecimalPropertyConfiguration;

                    decimalConfig.HasPrecision(propAttr.attr.Precision, propAttr.attr.Scale);
                }
            }
        }
    }



    public static IEnumerable<MethodInfo> GetTypeMethods(this Type typeToQuery, bool flattenHierarchy, bool? staticMembers)
    {
        var typeInfo = typeToQuery.GetTypeInfo();

        foreach (var iField in typeInfo.DeclaredMethods.Where(fi => staticMembers == null || fi.IsStatic == staticMembers))
            yield return iField;

        //this bit is just for StaticFields so we pass flag to flattenHierarchy and for the purpose of recursion, restrictStatic = false
        if (flattenHierarchy == true)
        {
            var baseType = typeInfo.BaseType;

            if ((baseType != null) && (baseType != typeof(object)))
            {
                foreach (var iField in baseType.GetTypeMethods(true, staticMembers))
                    yield return iField;
            }
        }
    }

このアプローチではComplexTypeを処理しないことに気づきました。後で修正します。
Eniola 2014年

しかし、ブライアンによって提案された解決策はシンプルでエレガントで機能します。パフォーマンスについては明確な説明はしませんが、非常に大きなモデル(200以上のオーダー)でパフォーマンスを向上させるよりも、すでに反映されているPropertyInfoをオフにすると、パフォーマンスが向上します。
Eniola 2014年
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.