/// <summary>
/// 在某个DataTable（一般是编号，名称Table）上根据名称寻找编号
/// </summary>
/// <param name="nvName"></param>
/// <param name="name"></param>
/// <returns></returns>
public object FindIdFromName(string nvName, object name)
{
NameValueMapping nv = this[nvName];
object ret = FindColumn2FromColumn1(nvName, nv.DisplayMember, nv.ValueMember, name);
return(ret);
}
/// <summary>
/// 加入一个NameValueMapping
/// </summary>
/// <param name="enumType">类型（必须为Enum类型）</param>
/// <param name="notUseEnum">是否使用Enum（如果为true，则ValueMember用序号，如果为False，则ValueMember用Enum）</param>
/// <returns></returns>
public string Add(Type enumType, bool notUseEnum)
{
if (!enumType.IsEnum)
{
throw new ArgumentException("enumType should be enum, not " + enumType, "enumType");
}
string nvName = TypeToNameValueMappingName(enumType, notUseEnum);
if (m_mappings.ContainsKey(nvName))
{
return(nvName);
}
NameValueMapping nv = new NameValueMapping(nvName, nvName,
new string[] { EnumNameValue.IndexName, EnumNameValue.DescriptionName, EnumNameValue.ValueName, EnumNameValue.ValueTypeName });
if (notUseEnum)
{
nv.ValueMember = EnumNameValue.IndexName;
nv.DisplayMember = EnumNameValue.DescriptionName;
nv.MemberVisible[EnumNameValue.ValueName] = false;
}
else
{
nv.ValueMember = EnumNameValue.ValueName;
nv.DisplayMember = EnumNameValue.DescriptionName;
nv.MemberVisible[EnumNameValue.ValueName] = false;
}
Add(nv);
if (!m_dataSources.ContainsKey(nvName))
{
IList <EnumNameValue> list = Feng.Utils.EnumHelper.EnumToList(enumType);
DataTable dt = new DataTable();
dt.TableName = nvName;
dt.Columns.Add(EnumNameValue.IndexName, typeof(int));
dt.Columns.Add(EnumNameValue.ValueName, typeof(object));
dt.Columns.Add(EnumNameValue.DescriptionName, typeof(string));
dt.Columns.Add(EnumNameValue.ValueTypeName, typeof(Type));
foreach (EnumNameValue e in list)
{
System.Data.DataRow row = dt.NewRow();
row[EnumNameValue.IndexName] = e.Index;
row[EnumNameValue.ValueName] = e.Value;
row[EnumNameValue.DescriptionName] = e.Description;
row[EnumNameValue.ValueTypeName] = e.ValueType;
dt.Rows.Add(row);
}
m_dataSources[nvName] = dt.DefaultView;
this.DefaultDataSet.Tables.Add(dt);
}
return(nvName);
}
/// <summary>
/// 在某个DataTable（一般是编号，名称Table）上根据编号寻找名称
/// </summary>
/// <param name="nvName"></param>
/// <param name="id"></param>
/// <returns></returns>
public string FindNameFromId(string nvName, object id)
{
NameValueMapping nv = this[nvName];
object ret = FindColumn2FromColumn1(nvName, nv.ValueMember, nv.DisplayMember, id);
if (ret != null)
{
return(ret.ToString());
}
else
{
return(null);
}
}
//#region "Special Nv"
//private static Dictionary<string, NameValueMappingCollection> s_specialNameValueMappingCollections;
///// <summary>
///// 不止一个全局的NameValueMappingCollection，可以有各个不同名字的NameValueMappingCollection
///// </summary>
///// <param name="name"></param>
///// <returns></returns>
//public static NameValueMappingCollection GetSpecialNameValueMappingCollections(string name)
//{
// if (s_specialNameValueMappingCollections == null)
// {
// s_specialNameValueMappingCollections = new Dictionary<string, NameValueMappingCollection>();
// }
// if (!s_specialNameValueMappingCollections.ContainsKey(name))
// {
// s_specialNameValueMappingCollections[name] = new NameValueMappingCollection();
// }
// return s_specialNameValueMappingCollections[name];
//}
//#endregion
#region "Collections & Enum"
/// <summary>
/// 加入一个NameValueMapping
/// </summary>
/// <param name="nv">NameValueMapping</param>
public void Add(NameValueMapping nv)
{
if (nv == null)
{
throw new ArgumentNullException("nv");
}
if (m_mappings.ContainsKey(nv.Name))
{
return;
}
m_mappings[nv.Name] = nv;
}
/// <summary>
/// 按照this复制一个NameValueMapping，以给定名字作为名称
/// </summary>
/// <returns></returns>
public object Clone()
{
string[] members = new string[m_memberVisible.Count];
m_memberVisible.Keys.CopyTo(members, 0);
NameValueMapping nv = new NameValueMapping(m_name, m_tableName, members, m_whereQuery);
foreach (KeyValuePair <string, bool> kvp in m_memberVisible)
{
nv.m_memberVisible[kvp.Key] = m_memberVisible[kvp.Key];
}
nv.m_displayMember = this.m_displayMember;
nv.m_valueMember = this.m_valueMember;
return(nv);
}
private string GetFilteredName(string nvName, string filter)
{
NameValueMapping nv = this[nvName];
if (string.IsNullOrEmpty(filter))
{
if (!string.IsNullOrEmpty(nv.ParentName))
{
return(GetFilteredName(nv.ParentName, nv.WhereQuery));
}
else
{
return(nvName);
}
}
else
{
if (!string.IsNullOrEmpty(nv.ParentName))
{
return(GetFilteredName(nv.ParentName, nv.WhereQuery + " AND " + filter));
}
else
{
string newName = nvName + s_filterFlag + filter;
if (!m_mappings.ContainsKey(newName))
{
NameValueMapping newNv = this[nvName].Clone() as NameValueMapping;
newNv.Name = newName;
newNv.ParentName = nvName;
newNv.WhereQuery = filter;
m_mappings[newName] = newNv;
}
return(newName);
}
}
}
/// <summary>
/// 从数据库读入数据（如果已经存在，则刷新）
/// </summary>
/// <param name="reload"></param>
/// <param name="nvName"></param>
/// <param name="dsName"></param>
private void LoadDataFromDB(string dsName, string nvName, bool reload)
{
lock (this)
{
if (string.IsNullOrEmpty(nvName))
{
throw new ArgumentNullException("nvName");
}
NameValueMapping nv = this[nvName];
//string newName = nvName;
if (!string.IsNullOrEmpty(nv.ParentName))
{
//newName = GetFilteredName(nv.ParentName, nv.WhereQuery);
throw new ArgumentException("In LoadDataFromDB nv's Parent Must be null!", "nv");
}
if (nvName.Contains(s_filterFlag))
{
throw new ArgumentException("In LoadDataFromDB nv must not contain s_filterFlag!", "nv");
}
if (!m_loadedTables.ContainsKey(nvName))
{
if (nv.Name.StartsWith(s_enumFlag, StringComparison.Ordinal))
{
return;
}
DataSet ds = null;
if (!string.IsNullOrEmpty(dsName))
{
//if (!reload)
//{
// if (!m_dataSets.ContainsKey(dsName))
// {
// m_dataSets[dsName] = new DataSet();
// }
//}
if (!m_dataSets.ContainsKey(dsName))
{
m_dataSets[dsName] = new DataSet();
}
if (m_dataSets.ContainsKey(dsName))
{
ds = m_dataSets[dsName];
}
}
else
{
ds = this.DefaultDataSet;
}
if (ds == null)
{
return;
}
if (!reload && ds.Tables.Contains(nvName))
{
return;
}
System.ComponentModel.CancelEventArgs e = new System.ComponentModel.CancelEventArgs();
nv.OnDataSourceChanging(e);
if (e.Cancel)
{
return;
}
if (ds.Tables.Contains(nvName))
{
ds.Tables[nvName].Rows.Clear();
}
#if DEBUG
System.Data.DataTable dt = null;
if (nv.Params.Count == 0 && !reload)
{
dt = Cache.TryGetCache <DataTable>(GetCacheKey(nv.Name), new Func <DataTable>(delegate()
{
DbHelper db = null;
if (string.IsNullOrEmpty(nv.DatabaseName))
{
db = DbHelper.Instance;
}
else
{
db = DbHelper.CreateDatabase(nv.DatabaseName);
}
if (db != null)
{
return(db.ExecuteDataTable(nv.SelectCommand));
}
else
{
return(nv.EmptyDataTable);
}
}));
}
else
{
DbHelper db = null;
if (string.IsNullOrEmpty(nv.DatabaseName))
{
db = DbHelper.Instance;
}
else
{
db = DbHelper.CreateDatabase(nv.DatabaseName);
}
if (db != null)
{
dt = db.ExecuteDataTable(nv.SelectCommand);
}
else
{
dt = nv.EmptyDataTable;
}
}
if (dt != null)
{
dt.TableName = nv.Name;
if (ds.Tables.Contains(dt.TableName))
{
foreach (DataRow row in dt.Rows)
{
ds.Tables[dt.TableName].ImportRow(row);
}
}
else
{
ds.Tables.Add(dt);
}
}
#else
if (string.IsNullOrEmpty(nv.DatabaseName))
{
DbHelper.Instance.Database.LoadDataSet(nv.SelectCommand, ds, nv.Name);
}
else
{
DbHelper.CreateDatabase(nv.DatabaseName).Database.LoadDataSet(nv.SelectCommand, ds, nv.Name);
}
#endif
m_loadedTables[nvName] = true;
nv.OnDataSourceChanged(System.EventArgs.Empty);
}
}
}
/// <summary>
/// ����this����һ��NameValueMapping���Ը���������Ϊ����
/// </summary>
/// <returns></returns>
public object Clone()
{
string[] members = new string[m_memberVisible.Count];
m_memberVisible.Keys.CopyTo(members, 0);
NameValueMapping nv = new NameValueMapping(m_name, m_tableName, members, m_whereQuery);
foreach (KeyValuePair<string, bool> kvp in m_memberVisible)
{
nv.m_memberVisible[kvp.Key] = m_memberVisible[kvp.Key];
}
nv.m_displayMember = this.m_displayMember;
nv.m_valueMember = this.m_valueMember;
return nv;
}
