什么数据结构适合于此

本文关键字：适合于 数据结构 什么 | 更新日期: 2023-09-27 18:18:39

在代码中我想这样做:

item.Stage = Stage.Values.ONE;

其中Stage. values . one表示某个预定义的Stage: 

public class Stage
{
    [Key]
    public virtual int StageId { get; set; }
    public string Name { get; set; }
    public TimeSpan Span { get; set; }
}

我正在处理EF CodeFirst…我有很多阶段要定义。我不确定是否应该将数据存储在数据库中，或者在dbContext中，或者什么，但我正在寻找最简单的实现。

我试过了:

我尝试了以下方法(定义两个常量):

public class Stage
{
    [Key]
    public virtual int StageId { get; set; }
    public string Name { get; set; }
    public TimeSpan Span { get; set; }
    public static class Values
    {
        public static readonly Stage ONE = new Stage()
            {
                StageId = 0,
                Name = "ONE",
                Span = new TimeSpan(0, 0, 0)
            };
        public static readonly Stage TWO = new Stage()
        {
            StageId = 1,
            Name = "TWO",
            Span = new TimeSpan(0, 0, 10)
        };
}

但是每当我创建一个具有Stage的实体的新实例时，一个新的Stage被添加到db中。我只需要几个固定的阶段。

舞台使用:

public class Side
{
    public Side()
    {
        Stage = Stage.Values.ONE;  // Adds new Stage to DB, when it should be a reference to the one I defined above
    }
    public virtual Stage Stage { get; set; }
}

什么数据结构适合于此

它看起来有点像enum，我以前已经使用过几次"扩展enum"模式，并取得了一些成功。因为您在代码中引用这些值，所以将它们也存储在数据库中可能没有意义，但如果需要的话，可以这样做。

这里详细描述了该技术:http://lostechies.com/jimmybogard/2008/08/12/enumeration-classes/

基本上，你创建一个基类，它提供了许多类似于enum的服务，然后创建你的"枚举类"，你继承它，并提供一堆静态实例，调用构造函数，无论你需要多少属性。

为了避免链接错误，这里是要使用的基类(只需将整个类放入您的项目中)，并向下滚动查看您自己的代码。

public abstract class Enumeration : IComparable
{
    private readonly int _value;
    private readonly string _displayName;
    protected Enumeration()
    {
    }
    protected Enumeration(int value, string displayName)
    {
        _value = value;
        _displayName = displayName;
    }
    public int Value
    {
        get { return _value; }
    }
    public string DisplayName
    {
        get { return _displayName; }
    }
    public override string ToString()
    {
        return DisplayName;
    }
    public static IEnumerable<T> GetAll<T>() where T : Enumeration, new()
    {
        var type = typeof(T);
        var fields = type.GetFields(BindingFlags.Public | BindingFlags.Static | BindingFlags.DeclaredOnly);
        foreach (var info in fields)
        {
            var instance = new T();
            var locatedValue = info.GetValue(instance) as T;
            if (locatedValue != null)
            {
                yield return locatedValue;
            }
        }
    }
    public override bool Equals(object obj)
    {
        var otherValue = obj as Enumeration;
        if (otherValue == null)
        {
            return false;
        }
        var typeMatches = GetType().Equals(obj.GetType());
        var valueMatches = _value.Equals(otherValue.Value);
        return typeMatches && valueMatches;
    }
    public override int GetHashCode()
    {
        return _value.GetHashCode();
    }
    public static int AbsoluteDifference(Enumeration firstValue, Enumeration secondValue)
    {
        var absoluteDifference = Math.Abs(firstValue.Value - secondValue.Value);
        return absoluteDifference;
    }
    public static T FromValue<T>(int value) where T : Enumeration, new()
    {
        var matchingItem = parse<T, int>(value, "value", item => item.Value == value);
        return matchingItem;
    }
    public static T FromDisplayName<T>(string displayName) where T : Enumeration, new()
    {
        var matchingItem = parse<T, string>(displayName, "display name", item => item.DisplayName == displayName);
        return matchingItem;
    }
    private static T parse<T, K>(K value, string description, Func<T, bool> predicate) where T : Enumeration, new()
    {
        var matchingItem = GetAll<T>().FirstOrDefault(predicate);
        if (matchingItem == null)
        {
            var message = string.Format("'{0}' is not a valid {1} in {2}", value, description, typeof(T));
            throw new ApplicationException(message);
        }
        return matchingItem;
    }
    public int CompareTo(object other)
    {
        return Value.CompareTo(((Enumeration)other).Value);
    }
}
现在你的代码看起来像这样: 
public class Stage : Enumeration
{
    public TimeSpan TimeSpan { get; private set; }
    public static readonly Stage One
        = new Stage (1, "Stage one", new TimeSpan(5));
    public static readonly Stage Two
        = new Stage (2, "Stage two", new TimeSpan(10));
    public static readonly Stage Three
        = new Stage (3, "Stage three", new TimeSpan(15));
    private EmployeeType() { }
    private EmployeeType(int value, string displayName, TimeSpan span) : base(value, displayName) 
    { 
        TimeSpan = span;
    }
}

设置好之后，就可以在数据库中存储. value了。恐怕我没有在EF中做过，但在nHibernate中，告诉属性只存储"是相当直接的。您可以在加载该值时通过调用:

将其重新连接起来。
Stage.FromValue<Stage>(intValue);

将Stage作为您的实体的属性，按您的方式使用它并添加

Ignore(x => x.Stage)

到您的映射。这将在映射到数据库时忽略此属性。

编辑:我误解了问题。

如果你只需要数据库中不同的阶段，你应该把阶段放在它们自己的带有ID的表中，并通过一个关系引用那个ID。每个实体都有一个额外的引用，你必须为它们定义关系。

这是你要找的吗?

相关文章：