Die Erste Code-Enumerationen in Lookup-Tabellen

Habe ich in viele Läden, wo Sie lief ein Datenbank-Erste, Modell-Lookup-Tabellen wurden immer erforderlich. Ihre lookup-Tabelle entsprechend Ihrer Enums, so dass Sie gehalten Integrität der Datenbank. Ich 100% Stimmen mit dieser Idee, haben aber festgestellt, dass, wenn es um den Code-First-Modell, diese ist nicht verfügbar, out of the box. Ich habe irgendwo gelesen, dass das EF-Team Hinzugefügt werden kann, die Fähigkeit, dynamisch zu haben Enumerationen, die Hinzugefügt, um Ihr DB (über die Völkerwanderung) in EF7 aber Sie gewarnt, dass es nicht ein Versprechen.

So, wie Sie (wenn überhaupt) bewerkstelligen? Ich werde meine Lösung unten in eine Antwort und freue mich auf Ihr feedback.

Ich bin mit EF 6.1.3 und .NET 4.5.1

Werfen Sie einen Blick auf stackoverflow.com/questions/11167665/...
Ich wusste, dass Sie geplant, es (irgendwann), aber ich wurde krank warten. Ich habe gelesen durch die Kommentare und sah Ihr NuGet-Paket-Post...Schön. Ich werde es in mein Projekt, danke.
Ich mag dein Projekt, es ist schön...hat ein Problem mit ein paar Dinge, wie zum Beispiel Benutzerdefinierte Schemas, aber insgesamt ist es schön. Ich gabelte Sie es und sehen, ob ich helfen kann, mit es.
Vielen Dank, bin froh, dass es dir gefällt. Ich habe ein bisschen mehr hinter auf den Umgang mit Beiträgen, als ich möchte, aber es ist weit von Toten. Würde ich es nennen, mehr "stabil" <grins>
Sie haben pull-Anfrage, dass möglicherweise einige der gleichen Probleme, die ich lief in. Vor allem benutzerdefiniertes schema Verwendung. Ich würde auch hinzufügen, einige Konfigurations-Optionen zu ermöglichen, für die Umsetzung der enum-Tabellen in ein eigenes schema.
Ja das ist eine gute Idee. Die pull-requests müssen einige arbeiten, bevor Sie können gehen, es ist ein Projekt, wo ich bekommen, um meine eigenen standards von dem, was geht für einmal 🙂
Lol ya ich höre Sie auf die Einstellung der eigenen standards.

InformationsquelleAutor Jason H | 2015-07-12

c#entity-framework enums

5

Also ich werde nicht Lügen, meine Lösung ist ein bisschen in die Tiefe, aber ich verwende es jetzt seit einigen Tagen und ich finde es funktioniert genau so, wie ich es brauche.

Let ' s start an der Spitze, meine base Klasse I erstellt:
```
public abstract class LookupTableBase
{
    [Key]
    [DatabaseGenerated(DatabaseGeneratedOption.None)]
    public int Id { get; set; }

    [Required]
    public string Name { get; set; }
}
```
Hier ist ein Beispiel einer meiner lookup-Tabelle Entity-Modellen:
```
///<summary>
///    Lookup Table for Enumeration AddressTypes
///    File Reference: DataAccessLayer/Enumerations/Locators.cs
///    DO NOT USE
///    SHOULD NOT BE AVAILABLE IN ENTITY MODELS
///</summary>
[Table("AddressTypes", Schema = "Lookup")]
public class AddressType : LookupTableBase {}
```
Hier ist das Enum, das geht mit dieser Lookup-Tabelle:
```
public enum AddressTypes
{
    [StringValue("")]
    Unknown = 0,

    [StringValue("Home")]
    Home = 1,

    [StringValue("Mailing")]
    Mailing = 2,

    [StringValue("Business")]
    Business = 3
}
```
Den StringValue Attribut ist ein benutzerdefiniertes Attribut, die ich erstellt (basierend auf den Beispielen, die ich online gefunden), die mir erlauben, zu rufen:
```
AddressTypes.Home.GetStringValue();
```
Wird wieder der string-Wert: Home.

Ich fügen Sie die Lookup-Entity-Modell, um meine DbSets so wird die Tabelle erstellt, aber ich habe nie direkt auf den Lookup Entity-Modelle in meinen anderen Entity-Modellen. Ihr einziger Zweck ist die Erstellung von lookup-Tabellen in der DB, so dass ich kann für Foreign Key-Einschränkungen gegen Sie.
```
public DbSet<AddressType> AddressTypes { get; set; }
```
In meinem OnModelCreating Methode für meine Rahmen, die ich habe, um das hinzufügen das, weil die Daten Anmerkung nicht scheinen zu halten den ganzen Weg durch:
```
modelBuilder.Entity<AddressType>()
            .Property(x => x.Id)
            .HasDatabaseGeneratedOption(DatabaseGeneratedOption.None);
```
In meinem Migration der Konfigurations-Datei, füge ich diese in der Seed-Methode:
```
var addressTypeCount = Enum.GetValues(typeof (AddressTypes)).Length;
var addressTypes = new List<AddressType>();
for (var i = 1; i < addressTypeCount; i++) {
    addressTypes.Add(new AddressType {
                                         Id = i,
                                         Name = ((AddressTypes)i).GetStringValue()
                                     });
}
context.AddressTypes.AddOrUpdate(c => c.Id, addressTypes.ToArray());
context.SaveChanges();
```
Letzten, in der Migration-Datei selbst verschieben ich alle lookup-table creation-Methoden an die Spitze der Liste, jetzt kann ich add Foreign Key-Einschränkungen für eine Tabelle, die Referenzen, enum. In meinem Fall, ich nahm es einen Schritt weiter. Seit der Migration-Klasse ist eine teilweise, erstellte ich eine weitere partielle Klasse zu entsprechen. Zwei Methoden erstellt:
```
public void LookupDataUp()
public void LookupDataDown()
```
In der LookupDataUp Methode, füge ich alle meine custom Foreign-Keys und Indizes und in der LookupDataDown ich Entferne alle meine custom Foreign-Keys und Indizes.

Wenn ich Update-Datenbank, die alle meine Tabellen, die verwendet werden, um einige integer-Wert repräsentiert etwas (in diesem Fall ein AddressType), hatte aber keinen wirklichen Wert, jetzt haben Sie einen Wert, die gesehen werden kann durch Verknüpfung mit den lookup-Tabelle.

Ich gebe zu, dies scheint wie eine Menge Arbeit, nur um eine kleine Menge von Daten in der Datenbank, aber jetzt jedes mal wenn ich auf entfernen/ändern/hinzufügen von neuen Elementen zu meinen enum, wird es automatisch betätigt wird, um die DB. Plus wie ich bereits in der obigen Frage, dies schafft Integrität der Datenbank durch die foreign key-Einschränkung auf das 'integer' Feld.
- Ich bin verwirrt, wie das hinzufügen der Lookup Entity-Modell DbSets tatsächlich schafft eine foreign key-Einschränkung? Würden Sie nicht brauchen, um die Referenz der Nachschlage-Entity-Modell aus den Modellen, die Sie haben wollen-Einschränkungen auf? Ich denke, man könnte einen " pseudo-constraint mit dem Modelbuilder, aber es sieht nicht wie Sie das tun. Ich habe laufen in das gleiche Problem wollen-lookup-Tabellen, während auch unter Verwendung von Enumerationen, die in meinem Projekt so, ich hoffe das wird funktionieren, aber wie gesagt ich bin verwirrt über, wie man erstellen Sie die foreign key-Einschränkungen mit den oben genannten Beispiel.
- Sorry, ich schrieb vor langer Zeit, aber wenn ich mich richtig erinnere, habe ich eine neue Klasse-Datei, die ich rief in der Migration-Datei selbst (LookupDataUp und LookupDataDown, beziehungsweise). In dieser Datei habe ich die Fremdschlüssel für die jeweiligen lookup-Tabellen. Ehrlich gesagt, war dies nicht die beste Lösung, die ich kam mit, aber es war das erste. Ich empfehle Tim Abell den NuGet-Paket - (nuget.org/packages/ef-enum-to-lookup), die am Ende mit mehr, als meine Lösung.
- Sagen... for (var i = 1; i < addressTypeCount; i++) { ...überspringt das Letzte element der enum. Sollte es sein... i <= addressTypeCount
- Möchte nur darauf hinweisen, dass mit der Veröffentlichung von EF-Core 2.1 dies ist weniger ein Problem als jetzt können Sie schieben Sie Ihren Enumerationen (als String-Werte) direkt in der DB über ein wenig von Fluent-API von Code.
InformationsquelleAutor Jason H

Wenn Sie nicht auf der Suche zu matschig Ihrem Kontext, aber immer noch wollen, dass Ihr enums in der Datenbank für die Problembehandlung bei & manuelle Abfragen. Es ist auch nicht ideal, aber Sie können eine at-once-migration, wenn Sie es brauchen. Offensichtlich gibt es einige Aufräumarbeiten und Optimierungen durchgeführt werden, die variieren können, je nach Anwendungsfall.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text.RegularExpressions;
using LookupExample.Data;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;

namespace LookupExample.Areas.Admin.Controllers
{
    //[Authorize]
    [Area("Admin")]
    public class SetupController : Controller
    {
        private ApplicationDbContext _db;

        public SetupController(ApplicationDbContext dbContext)
        {
            _db = dbContext;
        }

        public IActionResult Enums()
        {
            var enums = Assembly.GetExecutingAssembly().GetTypes()
                .Where(ttype => ttype.IsEnum && ttype.IsPublic && ttype.Namespace.StartsWith("LookupExample.Models"));

            var dictionary = enums.ToDictionary(EnumTableName, EnumDictionary);

            if (dictionary.Count <= 0) return Json(dictionary);

#pragma warning disable EF1000 //Possible SQL injection vulnerability.
            foreach (var kvp in dictionary)
            {
                var table = kvp.Key;
                var tableSql = $"IF OBJECT_ID('{table}', 'U') IS NOT NULL DROP TABLE {table}; CREATE TABLE {table} ( Id int, Val varchar(255));";
                _db.Database.ExecuteSqlCommand(tableSql);

                if (kvp.Value.Count <= 0) continue;

                var insertSql = $"INSERT INTO {table} (Id, Val) VALUES ( @P0, @P1);";
                foreach (var row in kvp.Value)
                {
                    _db.Database.ExecuteSqlCommand(insertSql, row.Key, row.Value);
                }
            }
#pragma warning restore EF1000 //Possible SQL injection vulnerability.

            return Json(dictionary);
        }

        private string EnumTableName(Type eenum)
        {
            var namespaceModifier = Regex.Replace(Regex.Replace(eenum.Namespace, @"^LookupExample\.Models\.?", ""), @"\.?Enums$", "").Replace(".", "_");
            if (namespaceModifier.Length > 0)
            {
                namespaceModifier = namespaceModifier + "_";
            }
            return "dbo.Enum_" + namespaceModifier + eenum.Name; //TODO enum schema?
        }

        private Dictionary<int, string> EnumDictionary(Type eenum)
        {
            return Enum.GetValues(eenum).Cast<int>().ToDictionary(e => e, e => Enum.GetName(eenum, e));
        }
    }
}

InformationsquelleAutor Nick Kuznia

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.