我尝试在C#标识符中输入非ASCII字符，程序编译和运行都很好（至少乍一看是这样）。更准确地说，我在枚举类型中使用克罗地亚变音字符（čćđšž）。我真的需要使用这些特殊字符，因为我将字符串枚举映射为NHibernate中的值对象。如果在向用户显示外观时必须避免使用这些标准字符，那将非常丑陋。在大规模使用枚举之前，我真的需要知道是否存在任何含义（潜在问题）与此类编程技术有关（特别是在NHibernate方面）。或者，如果您有更好的处理方式，请告诉我。
此外，使用于重构、SVN等工具是否存在任何问题？
根据C#语言规范:
C#程序由一个或多个源文件组成，正式称为编译单元(§9.1)。源文件是Unicode字符的有序序列。源文件通常与文件系统中的文件一一对应，但不需要强制执行此对应关系。为了实现最大的可移植性，建议使用UTF-8编码对文件进行编码。
public class EnumToSpecialStringType<TEnum> : IUserType
{
#region IUserType Members
/// <summary>
/// Reconstruct an object from the cacheable representation. At the very least this
/// method should perform a deep copy if the type is mutable. (optional operation)
/// </summary>
/// <param name="cached">the object to be cached</param>
/// <param name="owner">the owner of the cached object</param>
/// <returns>a reconstructed object from the cachable representation</returns>
public object Assemble(object cached, object owner)
{
return DeepCopy(cached);
}
/// <summary>
/// Return a deep copy of the persistent state, stopping at entities and at collections.
/// </summary>
/// <param name="value">generally a collection element or entity field</param>
/// <returns>a copy</returns>
public object DeepCopy(object value)
{
return value;
}
/// <summary>
/// Transform the object into its cacheable representation. At the very least this
/// method should perform a deep copy if the type is mutable. That may not be enough
/// for some implementations, however; for example, associations must be cached as
/// identifier values. (optional operation)
/// </summary>
/// <param name="value">the object to be cached</param>
/// <returns>a cacheable representation of the object</returns>
public object Disassemble(object value)
{
return DeepCopy(value);
}
/// <summary>
/// Compare two instances of the class mapped by this type for persistent "equality"
/// ie. equality of persistent state
/// </summary>
/// <param name="x"/>
/// <param name="y"/>
/// <returns/>
public new bool Equals(object x, object y)
{
if (ReferenceEquals(x, y)) return true;
if (x == null || y == null) return false;
return x.Equals(y);
}
/// <summary>
/// Get a hashcode for the instance, consistent with persistence "equality"
/// </summary>
public int GetHashCode(object x)
{
return x.GetHashCode();
}
/// <summary>
/// Are objects of this type mutable?
/// </summary>
public bool IsMutable
{
get { return false; }
}
/// <summary>
/// Retrieve an instance of the mapped class from a ADO.NET resultset.
/// Implementors should handle possibility of null values.
/// </summary>
/// <param name="rs">a IDataReader</param>
/// <param name="names">column names</param>
/// <param name="owner">the containing entity</param>
/// <returns/>
/// <exception cref="HibernateException">HibernateException</exception>
public object NullSafeGet(IDataReader rs, string[] names, object owner)
{
var value = NHibernateUtil.String.NullSafeGet(rs, names[0]) as string;
// Put you special conversion here (string -> enum)
var converted = SpecialConversion(value);
return converted;
}
/// <summary>
/// Write an instance of the mapped class to a prepared statement.
/// Implementors should handle possibility of null values.
/// A multi-column type should be written to parameters starting from index.
/// </summary>
/// <param name="cmd">a IDbCommand</param>
/// <param name="value">the object to write</param>
/// <param name="index">command parameter index</param>
/// <exception cref="HibernateException">HibernateException</exception>
public void NullSafeSet(IDbCommand cmd, object value, int index)
{
var parameter = (IDataParameter)cmd.Parameters[index];
// Do conversion from your enum to database string value
var converted = SpecialConversion(value);
parameter.Value = converted;
}
/// <summary>
/// During merge, replace the existing (<paramref name="target"/>) value in the entity
/// we are merging to with a new (<paramref name="original"/>) value from the detached
/// entity we are merging. For immutable objects, or null values, it is safe to simply
/// return the first parameter. For mutable objects, it is safe to return a copy of the
/// first parameter. For objects with component values, it might make sense to
/// recursively replace component values.
/// </summary>
/// <param name="original">the value from the detached entity being merged</param>
/// <param name="target">the value in the managed entity</param>
/// <param name="owner">the managed entity</param>
/// <returns>the value to be merged</returns>
public object Replace(object original, object target, object owner)
{
return original;
}
/// <summary>
/// The type returned by <c>NullSafeGet()</c>
/// </summary>
public Type ReturnedType
{
get
{
return typeof(TEnum);
}
}
/// <summary>
/// The SQL types for the columns mapped by this type.
/// </summary>
public SqlType[] SqlTypes
{
get
{
return new[] { new SqlType(DbType.String) };
}
}
#endregion
}
我使用流畅的NHibernate，映射此自定义用户类型的方式如下：
Map(x => x.PropertyName, "ColumnName").CustomType<EnumToSpecialStringType<EnumType>>();
我这里只是写一些示例来展示如何进行映射。
考虑你的枚举，其中所有值都包含非ASCII字符：
public enum MyEnum
{
NonAsciiName1,
NonAsciiName2,
NonAsciiName3,
}
public enum MyEnum
{
AsciiName1,
AsciiName2,
AsciiName3,
}
public static class MyEnumExtensions
{
static readonly Dictionary<MyEnum, string> map = new Dictionary<MyEnum, string>
{
{ MyEnum.AsciiName1, "NonAsciiName1" },
{ MyEnum.AsciiName2, "NonAsciiName2" },
{ MyEnum.AsciiName3, "NonAsciiName3" },
};
public static string GetValue(this MyEnum key)
{
return map[key];
}
}
那么你的代码需要进行小改动才能使用这个功能：
// you probably had something like:
var myEnumValue = MyEnum.NonAsciiName1;
var value = myEnumValue.ToString();
// now becomes:
var myEnumValue = MyEnum.AsciiName1;
var value = myEnumValue.GetValue();
using System.ComponentModel;
public enum MyEnum
{
[DescriptionAttribute("NonAsciiName1")] AsciiName1,
[DescriptionAttribute("NonAsciiName2")] AsciiName2,
[DescriptionAttribute("NonAsciiName3")] AsciiName3,
}
public static class MyEnumExtensions
{
public static string GetValue(this MyEnum key)
{
return typeof(MyEnum).GetField(key.ToString())
.GetCustomAttributes(typeof(DescriptionAttribute), false)
.Cast<DescriptionAttribute>()
.Single()
.Description;
}
}
是的，我认为这是一个缺陷。
向用户显示查找结果并保留数据库中可能（唯一）的项列表最好分开保存，特别是如果您的应用程序未来将支持其他语言。
这不是很面向对象，您可以在代码中拥有一个类，该类是您的枚举和相应语言值之间的直接映射，例如在 nhibernate 映射中：
<class name="DropDown" table="DropDown_Language">
<!-- map onto the ENUMeration -->
<id name="UniqueID" column="Id" type="Int32" >
<generator class="identity" />
</id>
<property name="DropDownType" column="DropDownTypeId" type="DropDownType, Domain"/>
<property name="Language" column="LanguageId" type="LanguageReferenceType, "/>
<property name="DropDownTypeDescription" column="DropDownTypeDescription" type="string"/>
</class>