Entity Framework 4.0 在插入之前自动截断/修剪字符串

Question

假设我有一个表，其中包含描述列 varchar(100)。如果尝试插入超过 100 个字符的字符串，则插入将失败。

实体框架中是否有一种方法可以在插入列之前自动截断或修剪字符串以适合该列？在我的场景中，我真的不在乎字符串是否被截断，我只想插入它而不是仅仅失败并记录错误。

由于模型已经知道长度限制，因此我认为实体框架可能有一种方法可以为我做到这一点。

如果不支持，最好的方法是什么？扩展自动生成的部分类并重写 On*Changed 方法？我不想对长度限制进行硬编码，而是使用实体模型中已定义的长度限制。我怎样才能访问这个？

编辑

我的最终解决方案是实现自动生成实体的 On*Changed 部分方法。

我用了 这个方法从实体实例中获取ObjectContext，然后使用下面的方法提取最大长度，并截断字符串。

Answer 1

这是我的单行解决方案

（调用它是一行，实现多一点）

我从 @elbweb 获取代码并根据我的目的进行调整。就我而言，我正在解析 EDI 文件，其中一些文件具有 15 个不同的层次结构级别，我不想显式指定所有 15 种不同类型 - 我想要一个适用于所有实体类型的单行代码。

虽然有点不同，但现在打电话很方便。这肯定会对性能造成影响，但对我来说是可以接受的。本质上，将其放入 DbContext 类中，然后手动调用它（或者您可以通过覆盖 SaveChanges 来调用它来自动调用它）。

DbContext 中的代码：

public class MyContext : DbContext
{

    ...

    public void TruncateAllStringsOnAllEntitiesToDbSize()
    {
        var objectContext = ((IObjectContextAdapter) this).ObjectContext;

        var stringMaxLengthsFromEdmx =
                objectContext.MetadataWorkspace
                             .GetItems(DataSpace.CSpace)
                             .Where(m => m.BuiltInTypeKind == BuiltInTypeKind.EntityType)
                             .SelectMany(meta => ((EntityType) meta).Properties
                             .Where(p => p.TypeUsage.EdmType.Name == "String"))
                             .Select(d => new
                                          {
                                              MaxLength = d.TypeUsage.Facets["MaxLength"].Value,
                                              PropName = d.Name,
                                              EntityName = d.DeclaringType.Name
                                          })
                             .Where(d => d.MaxLength is int)
                             .Select(d => new {d.PropName, d.EntityName, MaxLength = Convert.ToInt32(d.MaxLength)})
                             .ToList();

        var pendingEntities = ChangeTracker.Entries().Where(e => e.State == EntityState.Added || e.State == EntityState.Modified).Select(x => x.Entity).ToList();
        foreach (var entityObject in pendingEntities)
        {
            var relevantFields = stringMaxLengthsFromEdmx.Where(d => d.EntityName == entityObject.GetType().Name).ToList();

            foreach (var maxLengthString in relevantFields)
            {
                var prop = entityObject.GetType().GetProperty(maxLengthString.PropName);
                if (prop == null) continue;

                var currentValue = prop.GetValue(entityObject);
                var propAsString = currentValue as string;
                if (propAsString != null && propAsString.Length > maxLengthString.MaxLength)
                {
                    prop.SetValue(entityObject, propAsString.Substring(0, maxLengthString.MaxLength));
                }
            }
        }
    }
}

消耗

try
{
    innerContext.TruncateAllStringsOnAllEntitiesToDbSize();
    innerContext.SaveChanges();
}
catch (DbEntityValidationException e)
{
    foreach (var err in e.EntityValidationErrors)
    {
        log.Write($"Entity Validation Errors: {string.Join("\r\n", err.ValidationErrors.Select(v => v.PropertyName + "-" + v.ErrorMessage).ToArray())}");
    }
    throw;
}

在此代码之前，当您尝试插入太大的字符串时，SaveChanges 将触发上面示例中的捕获。添加 TruncateAllStringsOnAllEntitiesToDbSize 行后，现在效果很好！我确信可以进行一些优化，所以请批评/贡献！ :-)

注意：我只在 EF 6.1.3 上尝试过此操作

Answer 2

这将为您提供列的最大长度。

public int? GetColumnMaxLength(ObjectContext context, string entityTypeName, string columnName)
    {
        int? result = null;

        Type entType = Type.GetType(entityTypeName);
        var q = from meta in context.MetadataWorkspace.GetItems(DataSpace.CSpace)
                          .Where(m => m.BuiltInTypeKind == BuiltInTypeKind.EntityType)
                from p in (meta as EntityType).Properties
                .Where(p => p.Name == columnName
                            && p.TypeUsage.EdmType.Name == "String")
                select p;

        var queryResult = q.Where(p =>
        {
            bool match = p.DeclaringType.Name == entityTypeName;
            if (!match && entType != null)
            {
                //Is a fully qualified name....
                match = entType.Name == p.DeclaringType.Name;
            }

            return match;

        }).Select(sel => sel.TypeUsage.Facets["MaxLength"].Value);
        if (queryResult.Any())
        {
            result = Convert.ToInt32(queryResult.First());
        }

        return result;
    }

Answer 3

我从理查德的答案中获取了一些逻辑，并将其转化为一种方法，用于根据实体框架对象的最大长度（如果它们受到限制）截断所有字符串。

public static void TruncateStringsInEFObject<T>(List<T> entityObjects, ObjectContext context)
{
    var stringMaxLengthsFromEdmx = context.MetadataWorkspace.GetItems(DataSpace.CSpace)
        .Where(m => m.BuiltInTypeKind == BuiltInTypeKind.EntityType)
        .SelectMany(meta => (meta as EntityType).Properties
            .Where(p => p.TypeUsage.EdmType.Name == "String"
                        && p.DeclaringType.Name == typeof(T).Name))
        .Select(d => new {MaxLength = d.TypeUsage.Facets["MaxLength"].Value, d.Name})
        .Where(d => d.MaxLength is int)
        .Select(d => new {d.Name, MaxLength = Convert.ToInt32(d.MaxLength)})
        .ToList();

    foreach (var maxLengthString in stringMaxLengthsFromEdmx)
    {
        var prop = typeof(T).GetProperty(maxLengthString.Name);
        if (prop == null) continue;

        foreach (var entityObject in entityObjects)
        {
            var currentValue = prop.GetValue(entityObject);
            var propAsString = currentValue as string;
            if (propAsString != null && propAsString.Length > maxLengthString.MaxLength)
            {
                prop.SetValue(entityObject, propAsString.Substring(0, maxLengthString.MaxLength));
            }
        }
    }

Answer 4

我使用了稍微不同的策略，但也利用了 On*Changed 方法。我正在使用 EF 使用的 .tt 文件的精简版本生成部分类。相关部分是生成属性的地方。最大长度可用，可用于截断字符串。

 foreach (EdmProperty property in 
         entity.Properties.Where(p => p.DeclaringType == entity 
         && p.TypeUsage.EdmType is PrimitiveType))
 {

        /// If this is a string implements its OnChanged method
        if (property.TypeUsage.ToString() != "Edm.String") continue;

        int maxLength = 0;

        if (property.TypeUsage.Facets["MaxLength"].Value == null) continue;

        if (!Int32.TryParse(property.TypeUsage.Facets["MaxLength"].Value.ToString(), 
            out maxLength)) continue;

        if (maxLength == 0) continue;
        // Implement the On*Changed method

        #>
        partial void On<#= property.Name#>Changed() {
            <#=code.FieldName(property)#> =#=code.FieldName(property)#>.Substring(0,<#= maxLength #>);

        } 
        <#
    } 

Answer 5

此方法使用对象属性的属性，因此它适用于 EF 或其他场景。如果属性具有“StringLength”属性，它将被截断。

// Truncate any string that is too long.
var entry = new MyObject(); // Entity Framework object
entry.GetType().GetProperties().ToList().ForEach(p =>
{
    foreach (StringLengthAttribute attribute in p.GetCustomAttributes(true)
        .Where(a => a is StringLengthAttribute).Cast<StringLengthAttribute>())
    {
        string value = (p.GetValue(entry) ?? "").ToString();
        if (value.Length > attribute.MaximumLength)
        {
            // oops. Its too Long, so truncate it.
            p.SetValue(entry, value.Substring(0, attribute.MaximumLength));
        }
    }
});

使用此示例属性测试正确（由于 StringLength）

[Required]
[StringLength(6)] // only 6, for testing
public string Message { get; set; }

Answer 6

我将针对这个问题提出一个独特的解决方案。

在我的用例中，我希望更好地控制自动截断哪些字段。

因此，我创建了一个属性来注释我想要截断的实体属性：

/// <summary>
/// Indicates that the assigned string should be automatically truncated to the 
/// max length of the database column as specified by 
/// <see cref="System.ComponentModel.DataAnnotations.MaxLengthAttribute"/>
/// </summary>
public class AutoTruncateAttribute : Attribute { }

public class TestEntity
{
    [MaxLength(10), AutoTruncate]
    public string SomeProperty { get; set; }
}

接下来，我需要一种实际截断实体的方法。我希望在保存实体时作为预处理步骤自动发生此操作。

因此，我重写了 DbContext.SaveAs() 方法，并为截断功能添加了一个存根方法：

public class DbContext
{
    public DbContext() : base("name=DbContext") { }

    public DbSet<TestEntity> TestEntities { get; set; }

    public override int SaveChanges()
    {
        PreProcessEntities();
        return base.SaveChanges();
    }

    public override Task<int> SaveChangesAsync()
    {
        PreProcessEntities();
        return base.SaveChangesAsync();
    }

    public override Task<int> SaveChangesAsync(CancellationToken cancellationToken)
    {
        PreProcessEntities();
        return base.SaveChangesAsync(cancellationToken);
    }

    /// <summary>Process entities before save</summary>
    public void PreProcessEntities()
    {
        // my pre-processing functionality will go here...
    }
}

我可以在此时停止，只需复制其他答案中的代码并将其粘贴到 >PreProcessEntities() 方法。例如，我可以循环遍历添加和修改的实体，获取实体类型，使用 AutoTruncate 和 MaxLength 属性查找属性，然后根据需要截断属性值。

但！这种方法存在一些问题。

• 缺乏添加额外预处理的灵活性。
  例如，就我而言，我还希望一些包含数值的字符串属性以不同的方式格式化。
• 每次运行 SaveAs() 时循环遍历所有实体和属性并查找这些属性必然会带来明显的性能影响。

所以我想知道是否可以缓存每个实体类型要执行的操作。事实证明...有:)。它需要一些代码，但很容易遵循和实现。

首先，我需要一个线程安全的单例来缓存每个实体的操作。然后我想要一个可以分析实体类及其属性的类或方法。分析结果将是在保存到数据库之前应用于该类型实例的操作列表。

我创建了三个类/接口：

• IEntityProcessor 是一个接受实体并对其执行某些操作的接口
• AutoTruncateProcessor 实现 IEntityProcessor 并截断实体的属性已标记有 AutoTruncate 和 MaxLength
• EntityProcessorChecker 分析实体的某些属性，例如 AutoTruncate 并生成一个列表IEntityProcessor 实例。
• EntityProcessorCache 为每个实体维护一个 IEntityProcessor 的线程安全缓存。

命名不是我的强项，但希望你能明白。

首先，我将向您展示`DbContext.PreProcessEntities() 的实现。

这可以使用泛型来实现，也可以不使用泛型来实现。

第一种方法不使用泛型。缺点是我们正在访问添加或修改的每个实体的缓存。这可能会增加对性能的影响。

// without generics 
public void PreProcessEntities()
{
    var entities = ChangeTracker.Entries<T>()
        .Where(e => e.State == EntityState.Added || e.State == EntityState.Modified)
        .ToList();

    foreach (var entity in entities)
    {
        // drawback: access cache for every entity
        var processors = EntityProcessorCache.GetProcessors(entity);
        foreach (var processor in processors)
        {
            processor.Process(entity.Entity);
        }
    }
}

第二种方法使用泛型。缺点是我们需要使用显式类型显式调用泛型方法。也许有一种方法可以使用反射来解决这个问题。好处是每种类型只能访问缓存一次，如果没有操作则可以提前退出。

// using generics
public void PreProcessEntities()
{
    // drawback: we need to remember to explicitly add new entity types here,
    // or find a dynamic solution using reflection
    PreProcessEntities<TestEntity>();
}

public void PreProcessEntities<T>() where T : class
{
    // benefit: access cache at the start
    var processors = EntityProcessorCache.GetProcessors<T>();

    if (!processors.Any()) return; // benefit: early exit

    // benefit: only processing entities of the given type
    var entities = ChangeTracker.Entries<T>()
        .Where(e => e.State == EntityState.Added || e.State == EntityState.Modified)
        .ToList();

    foreach (var entity in entities)
    {
        foreach (var processor in processors)
        {
            processor.Process(entity.Entity);
        }
    }
}

最后，这里是 IEntityProcessor、AutoTruncateProcessor、EntityProcessorChecker 和 EntityProcessorCache 的实现。

public interface IEntityProcessor
{
    void Process(object entity);
}

public class AutoTruncateProcessor : IEntityProcessor
{
    IDictionary<System.Reflection.PropertyInfo, int> PropertyMaxLengths { get; }

    public AutoTruncateProcessor(List<System.Reflection.PropertyInfo> autoTruncateProperties)
    {
        PropertyMaxLengths = new Dictionary<System.Reflection.PropertyInfo, int>();

        // pre-compute values for the properties that should be truncated
        foreach (var property in autoTruncateProperties)
        {
            var customAttributes = property.GetCustomAttributes(true);
            var maxLengthAttribute = customAttributes.FirstOrDefault(a => a is MaxLengthAttribute) as MaxLengthAttribute;
            var maxLength = maxLengthAttribute?.Length;
            if (maxLength.HasValue) PropertyMaxLengths.Add(property, maxLength.Value);
        }
    }

    public void Process(object entity)
    {
        // use the pre-compute values to process entity
        foreach (var kv in PropertyMaxLengths)
        {
            var property = kv.Key;
            var maxLength = kv.Value;
            var currentValue = property.GetValue(entity) as string;

            // exit early
            if (string.IsNullOrEmpty(currentValue )) return;
            if (currentValue .Length < maxLength) return;

            var newValue = str.Substring(0, maxLength);
            property.SetValue(entity, newValue);
        }
    }
}

EntityProcessorChecker 会检查给定类型的属性，并在找到匹配的属性时实例化 IEntityProcessor 的子类。您可以在此处根据自己的应用程序需求自定义功能。在我的实现中，我想查找 AutoTruncate 和 NumberFormat 属性。

public class EntityProcessorChecker
{
    IList<IEntityProcessor> Processors { get; }

    public EntityProcessorChecker(Type type)
    {
        Processors = new List<IEntityProcessor>();

        var properties = type.GetProperties();

        // get properties where there is an AutoTruncateAttribute
        var autoTruncateProperties = properties.Where(p => p.GetCustomAttributes(true).Any(a => a is AutoTruncateAttribute)).ToList();
        if (autoTruncateProperties.Any()) Processors.Add(new AutoTruncateProcessor(autoTruncateProperties));

        // get properties where there is a number formatter
        var formatterProperties = properties.Where(p => p.GetCustomAttributes(true).Any(a => a is NumberFormatAttribute)).ToList();
        // TODO: add this processor
    }

    public IList<IEntityProcessor> GetProcessors() => Processors;
}

// Some people may want a generic version of this class
public class EntityProcessorChecker<T> : EntityProcessorChecker
{
    public EntityProcessorChecker() : base(typeof(T)) { }
}

EntityProcessorCache 意味着我们不需要持续分析实体类型来了解我们需要在其实例上执行的操作。这是一个优化步骤。单例设计的灵感来自于这篇文章。

// sealed so that we can ensure it remains a singleton
public sealed class EntityProcessorCache
{
    // private concurrent dictionary for thread safety
    private static readonly ConcurrentDictionary<Type, IList<IEntityProcessor>> Cache = new ConcurrentDictionary<Type, IList<IEntityProcessor>>();

    // a lock for when we intend to write to the cache
    private static readonly object CacheWriteLock = new object();

    // Explicit static constructor to tell C# compiler
    // not to mark type as `beforefieldinit`
    static EntityProcessorCache() { }

    // the only way to access the cache
    public static IList<IEntityProcessor> GetProcessors(Type type)
    {
        // return early if cache is populated
        if (Cache.ContainsKey(type)) return Cache[type];

        // lock cache writing writing
        lock (CacheWriteLock)
        {
            // another caller may have locked before this call
            // return early if cache is now populated
            if (Cache.ContainsKey(type)) return Cache[type];

            // analyse the type and cache the list of `IEntityProcessor`
            var checker = new EntityProcessorChecker(type);
            var processors = checker.GetProcessors();
            Cache[type] = processors;

            return processors;
        }
    }

    // alternatively, pass in a typed instance
    public static IList<IEntityProcessor> GetProcessors(object obj) => GetProcessors(obj.GetType());

    // alternatively, use generics
    public static IList<IEntityProcessor> GetProcessors<T>() => GetProcessors(typeof(T));
}

哇，有很多代码和解释！

希望您能看到这种方法的一些好处。

我喜欢的是，我可以快速轻松地创建新属性来标记我的实体属性，并使用处理器在保存之前修改我的实体。

当然，还有很大的改进空间：

EntityProcessorChecker 可能应该进行重构，以使分析过程在查看实体时更加可扩展且更加明显。定义和检查新属性并创建相应的处理器应该很容易。

EntityProcessorCache 的设计方式与 DbContext 在 .Net Framework 中的构建方式有关。在 .Net Core 中，我认为我们可以使用内置的 DI 系统来创建和管理单例实例。只要 DbContext 能够访问它，我就假设缓存将通过构造函数传入。