NHibernate Mapping à System.Drawing.Color

Question

Est-il possible de faire une sorte de conversion de type et de mapper directement à System.Drawing.Color? Je stocke les couleurs en tant que valeurs html/css. c'est-à-dire #ffffff. Je ne veux pas avoir à créer un type personnalisé qui implémente IUserType, c'est juste un wrapper pour System.Drawing.Color.

Answer 1

Essayez ceci pour la taille. Un type d'utilisateur NHibernate ne remplace pas le type que vous voulez exposer, il fournit simplement le mécanisme pour mapper automatiquement du type de base de données stocké au type .NET (ici, de la chaîne à la couleur et vice versa).

public class ColorUserType : IUserType 
{ 
    public bool Equals(object x, object y) 
    { 
     if (ReferenceEquals(x, y)) return true; 
     if (x == null || y == null) return false; 
     return x.Equals(y); 
    } 

    public int GetHashCode(object x) 
    { 
     return x == null ? typeof(Color).GetHashCode() + 473 : x.GetHashCode(); 
    } 

    public object NullSafeGet(IDataReader rs, string[] names, object owner) 
    { 
     var obj = NHibernateUtil.String.NullSafeGet(rs, names[0]); 
     if (obj == null) return null; 
     var colorString = (string)obj; 
     return ColorTranslator.FromHtml(colorString); 
    } 

    public void NullSafeSet(IDbCommand cmd, object value, int index) 
    { 
     if (value == null) 
     { 
      ((IDataParameter)cmd.Parameters[index]).Value = DBNull.Value; 
     } 
     else 
     { 
      ((IDataParameter)cmd.Parameters[index]).Value = ColorTranslator.ToHtml((Color)value); 
     } 

    } 

    public object DeepCopy(object value) 
    { 
     return value; 
    } 

    public object Replace(object original, object target, object owner) 
    { 
     return original; 
    } 

    public object Assemble(object cached, object owner) 
    { 
     return cached; 
    } 

    public object Disassemble(object value) 
    { 
     return value; 
    } 

    public SqlType[] SqlTypes 
    { 
     get { return new[] {new SqlType(DbType.StringFixedLength)}; } 
    } 

    public Type ReturnedType 
    { 
     get { return typeof(Color); } 
    } 

    public bool IsMutable 
    { 
     get { return true; } 
    } 
} 

Le mapping suivant devrait alors travailler:

<property 
    name="Color" 
    column="hex_color" 
    type="YourNamespace.ColorUserType, YourAssembly" /> 

Pour être complet, et grâce à Josh pour cela, si vous utilisez FluentNHibernate, vous pouvez mapper comme ceci:

Map(m => m.Color).CustomTypeIs<ColorUserType>(); 

Answer 2

je le ferais comme ceci:

Je voudrais créer une propriété de chaîne privée ou d'un champ dans ma classe, et la carte de cette propriété/champ à la colonne que vous utilisez pour stocker la couleur dans votre base de données.

Ensuite, je créerais une propriété publique dans ma classe, qui retourne une couleur, et dans le getter de cette propriété, je convertir la chaîne qui est stockée dans le domaine privé/propriété à une couleur, et dans la setter, je définirais le champ/propriété string à la valeur qui correspond à la valeur de couleur qui a été donnée.

public class MyEntity 
{ 

    private string htmlColorString; 

    public Color TheColor 
    { 
     get { return System.Drawing.ColorTranslator.FromHtml (htmlColorString); } 
     set 
     { 
       htmlColorString = System.Drawing.ColorTranslator.ToHtml(value); 
     } 
    } 

} 

Answer 3

Je voudrais aller à l'approche de la mise en œuvre de Frederik et faire la conversion comme suit:

hex Convertir en RVB - chaque paire de valeurs hexagonales est l'une des composantes RVB - # 23FF00 signifie R = 23 , G = FF, B = 00.

Cela vous donnera la valeur int pour chacune des composantes RVB, une fois que vous faites une chaîne analyse syntaxique sur votre valeur hexadécimale:

int.Parse("FF", System.Globalization.NumberStyles.AllowHexSpecifier); 

Après cela, il suffit d'appeler Color.FromArgb() statique et vous Je vais avoir votre couleur.

Answer 4

Je prendrais les 15 minutes pour écrire une implémentation IUserType pour convertir directement vers/depuis la propriété de couleur afin que vous n'ayez pas de propriétés magiques.

Voir http://www.lostechies.com/blogs/rhouston/archive/2008/03/23/mapping-strings-to-booleans-using-nhibernate-s-iusertype.aspx

Cela a aussi l'avantage que vous pouvez utiliser votre propriété de couleur dans HQL ou Linq, que vous ne seriez pas en mesure de le faire avec des propriétés magiques, mais avec une couleur ce ne peut pas être un problème.