public void SetSerializerData(SerializerData data)
{
if (_extendedAttributes == null || _extendedAttributes.Count == 0)
{
_extendedAttributes = Serializer.ConvertToNameValueCollection(data.Keys, data.Values);
}
if (_extendedAttributes == null)
{
_extendedAttributes = new NameValueCollection();
}
}
public SerializerData GetSerializerData()
{
var data = new SerializerData();
string keys = null;
string values = null;
Serializer.ConvertFromNameValueCollection(_extendedAttributes, ref keys, ref values);
data.Keys = keys;
data.Values = values;
return(data);
}
public static Assembly GenerateSerializer(Type[] types, XmlMapping[] mappings, CompilerParameters parameters)
{
GenerationBatch batch = new GenerationBatch();
batch.Maps = mappings;
batch.Datas = new SerializerData [mappings.Length];
for (int n = 0; n < mappings.Length; n++)
{
SerializerData data = new SerializerData();
data.Batch = batch;
batch.Datas [n] = data;
}
return(GenerateSerializers(batch, parameters));
}
public static CorporationInfo PopulateCorporationInfo(IDataReader reader)
{
CorporationInfo entity = new CorporationInfo()
{
ID = (int)reader["ID"],
Name = reader["Name"] as string,
Sort = DataConvert.SafeInt(reader["Sort"])
};
SerializerData data = new SerializerData();
data.Keys = reader["PropertyNames"] as string;
data.Values = reader["PropertyValues"] as string;
entity.SetSerializerData(data);
return(entity);
}
void CheckGeneratedTypes(XmlMapping typeMapping)
{
lock (this)
{
if (serializerData == null)
{
lock (serializerTypes)
{
serializerData = (SerializerData)serializerTypes [typeMapping.Source];
if (serializerData == null)
{
serializerData = new SerializerData();
serializerTypes [typeMapping.Source] = serializerData;
}
}
}
}
bool generate = false;
lock (serializerData)
{
if (serializerData.UsageCount >= generationThreshold && !serializerData.Generated)
{
serializerData.Generated = generate = true;
}
serializerData.UsageCount++;
}
if (generate)
{
if (serializerData.Batch != null)
{
GenerateSerializersAsync(serializerData.Batch);
}
else
{
GenerationBatch batch = new GenerationBatch();
batch.Maps = new XmlMapping[] { typeMapping };
batch.Datas = new SerializerData[] { serializerData };
GenerateSerializersAsync(batch);
}
}
}
public void SetReadValues(SerializerData data)
{
#if !__MOBILE__
// Copy zoom limits into the new graphics object
//@Yeti: the zoom limits should really be stored somewhere else,
// like the renderer
var zoomRange = _Graphics.ValueRange((int)GraphicsSetting.Zoom);
#endif
data.ReadValue(out _General, "General");
data.ReadValue(out _Graphics, "Graphics");
data.ReadValue(out _Audio, "Audio");
data.ReadValue(out _Controls, "Controls");
#if !__MOBILE__
_Graphics.SetZoomLimits(zoomRange.Minimum, zoomRange.Maximum);
#endif
}
public static XmlSerializer [] FromMappings(XmlMapping [] mappings)
{
XmlSerializer[] sers = new XmlSerializer [mappings.Length];
SerializerData[] datas = new SerializerData [mappings.Length];
GenerationBatch batch = new GenerationBatch();
batch.Maps = mappings;
batch.Datas = datas;
for (int n = 0; n < mappings.Length; n++)
{
if (mappings[n] != null)
{
SerializerData data = new SerializerData();
data.Batch = batch;
sers[n] = new XmlSerializer(mappings[n], data);
datas[n] = data;
}
}
return(sers);
}
/// <summary>
/// 填充后台用户实体类
/// </summary>
/// <param name="reader">记录集</param>
/// <returns>实体类</returns>
protected AdminInfo PopulateAdmin(IDataReader reader)
{
AdminInfo admin = new AdminInfo();
admin.ID = (int)reader["ID"];
admin.Administrator = DataConvert.SafeBool(reader["Administrator"]);
admin.LastLoginIP = reader["LastLoginIP"] as string;
admin.LastLoginTime = reader["LastLoginTime"] as DateTime?;
admin.Password = reader["Password"] as string;
admin.UserName = reader["UserName"] as string;
admin.UserRole = (UserRoleType)(Int16)reader["UserRole"];
admin.PowerGroupID = DataConvert.SafeInt(reader["PowerGroupID"]);
admin.PowerGroupName = reader["PowerGroupName"] as string;
admin.GroupPower = reader["GroupPower"] as string;
SerializerData data = new SerializerData();
data.Keys = reader["PropertyNames"] as string;
data.Values = reader["PropertyValues"] as string;
admin.SetSerializerData(data);
return(admin);
}
/// <summary>
/// 创建或更新文章
/// </summary>
/// <param name="article"></param>
/// <param name="action"></param>
/// <param name="status"></param>
/// <returns></returns>
public override Article CreateUpdateArticle(Article article, DataProviderAction action, out DataActionStatus status)
{
SerializerData data = article.GetSerializerData();
ELParameter[] parms = new ELParameter[]
{
action == DataProviderAction.Create ?
new ELParameter("@ArticleID", DbType.Int32, 4, ParameterDirection.Output) :
new ELParameter("@ArticleID", DbType.Int32, article.ID),
new ELParameter("@Action", DbType.Int32, action),
new ELParameter("@ArticleTitle", DbType.String, article.Title),
new ELParameter("@CategoryID", DbType.Int32, article.Category),
new ELParameter("@ArticleStatus", DbType.Int32, article.Status),
new ELParameter("@HitTimes", DbType.Int32, article.HitTimes),
new ELParameter("@ArticleSubtitle", DbType.String, article.SubTitle),
new ELParameter("@ArticleAbstract", DbType.String, article.Abstract),
new ELParameter("@ArticleContent", DbType.String, article.Content),
new ELParameter("@ArticleDate", DbType.DateTime, article.Date == null ? (object)DBNull.Value : (object)article.Date),
new ELParameter("@ArticleCopyFrom", DbType.String, article.CopyFrom),
new ELParameter("@ArticleAuthor", DbType.String, article.Author),
new ELParameter("@ArticleKeywords", DbType.String, article.Keywords),
new ELParameter("@ArticleImageID", DbType.Int32, article.Image),
new ELParameter("@DisplayOrder", DbType.Int32, article.DisplayOrder),
new ELParameter("@ArticleMemo", DbType.String, article.ArticleMemo),
new ELParameter("@User", DbType.Int32, GlobalSettings.GetCurrentUser().UserID),
new ELParameter("@PropertyNames", DbType.String, data.Keys),
new ELParameter("@PropertyValues", DbType.String, data.Values),
};
status = (DataActionStatus)Convert.ToInt32(DataHelper.ExecuteScalar(CommandType.StoredProcedure, "sp_Article_CreateUpdate", parms));
if (status == DataActionStatus.Success && action == DataProviderAction.Create)
{
article.ID = Convert.ToInt32(parms[0].Value);
}
return(article);
}
void CheckGeneratedTypes (XmlMapping typeMapping)
{
lock (this)
{
if (serializerData == null)
{
lock (serializerTypes)
{
serializerData = (SerializerData) serializerTypes [typeMapping.Source];
if (serializerData == null) {
serializerData = new SerializerData();
serializerTypes [typeMapping.Source] = serializerData;
}
}
}
}
/*
Brubbel:
we have problems using the generator.
if we do not generate it no problems where there any more.
The problems are that the compiled generator does not work or
the compiler returns an error.
Since we do not generate any more, we never had problems with
serialization and deserialization of objects.
Since we have libjit the generator is no longer needed.
Please be careful if U want to enable this.
*/
#if USE_GENERATOR
bool generate = false;
lock (serializerData)
{
generate = (++serializerData.UsageCount == generationThreshold);
}
if (generate)
{
if (serializerData.Batch != null)
GenerateSerializers (serializerData.Batch);
else
{
GenerationBatch batch = new GenerationBatch ();
batch.Maps = new XmlMapping[] {typeMapping};
batch.Datas = new SerializerData[] {serializerData};
GenerateSerializers (batch);
}
}
#endif
}
static Assembly GenerateSerializers(GenerationBatch batch, CompilerParameters cp)
{
DateTime tim = DateTime.Now;
XmlMapping[] maps = batch.Maps;
if (cp == null)
{
cp = new CompilerParameters();
cp.IncludeDebugInformation = false;
cp.GenerateInMemory = true;
cp.TempFiles.KeepFiles = !deleteTempFiles;
}
string file = cp.TempFiles.AddExtension("cs");
StreamWriter sw = new StreamWriter(file);
if (!deleteTempFiles)
{
Console.WriteLine("Generating " + file);
}
SerializationCodeGenerator gen = new SerializationCodeGenerator(maps);
try
{
gen.GenerateSerializers(sw);
}
catch (Exception ex)
{
Console.WriteLine("Serializer could not be generated");
Console.WriteLine(ex);
cp.TempFiles.Delete();
return(null);
}
sw.Close();
CSharpCodeProvider provider = new CSharpCodeProvider();
ICodeCompiler comp = provider.CreateCompiler();
cp.GenerateExecutable = false;
foreach (Type rtype in gen.ReferencedTypes)
{
string path = new Uri(rtype.Assembly.CodeBase).LocalPath;
if (!cp.ReferencedAssemblies.Contains(path))
{
cp.ReferencedAssemblies.Add(path);
}
}
if (!cp.ReferencedAssemblies.Contains("System.dll"))
{
cp.ReferencedAssemblies.Add("System.dll");
}
if (!cp.ReferencedAssemblies.Contains("System.Xml"))
{
cp.ReferencedAssemblies.Add("System.Xml");
}
if (!cp.ReferencedAssemblies.Contains("System.Data"))
{
cp.ReferencedAssemblies.Add("System.Data");
}
CompilerResults res = comp.CompileAssemblyFromFile(cp, file);
if (res.Errors.HasErrors || res.CompiledAssembly == null)
{
Console.WriteLine("Error while compiling generated serializer");
foreach (CompilerError error in res.Errors)
{
Console.WriteLine(error);
}
cp.TempFiles.Delete();
return(null);
}
GenerationResult[] results = gen.GenerationResults;
for (int n = 0; n < results.Length; n++)
{
GenerationResult gres = results[n];
SerializerData sd = batch.Datas [n];
lock (sd)
{
sd.WriterType = res.CompiledAssembly.GetType(gres.Namespace + "." + gres.WriterClassName);
sd.ReaderType = res.CompiledAssembly.GetType(gres.Namespace + "." + gres.ReaderClassName);
sd.WriterMethod = sd.WriterType.GetMethod(gres.WriteMethodName);
sd.ReaderMethod = sd.ReaderType.GetMethod(gres.ReadMethodName);
sd.Batch = null;
}
}
cp.TempFiles.Delete();
if (!deleteTempFiles)
{
Console.WriteLine("Generation finished - " + (DateTime.Now - tim).TotalMilliseconds + " ms");
}
return(res.CompiledAssembly);
}
public static Assembly GenerateSerializer (Type[] types, XmlMapping[] mappings, CompilerParameters parameters)
{
GenerationBatch batch = new GenerationBatch ();
batch.Maps = mappings;
batch.Datas = new SerializerData [mappings.Length];
for (int n=0; n<mappings.Length; n++) {
SerializerData data = new SerializerData ();
data.Batch = batch;
batch.Datas [n] = data;
}
return GenerateSerializers (batch, parameters);
}
public void UpdateReadValues(Version v, SerializerData data)
{
}
public void SetReadValues(SerializerData data)
{
data.ReadValue(out _KeyboardConfig, "KeyboardConfig");
}
public void SetReadValues(SerializerData data)
{
data.ReadValue(out _Metrics, "Metrics");
data.ReadValue(out _CheckForUpdates, "CheckForUpdates");
}
internal XmlSerializer (XmlMapping mapping, SerializerData data)
{
typeMapping = mapping;
serializerData = data;
}
public static XmlSerializer [] FromMappings (XmlMapping [] mappings)
{
XmlSerializer[] sers = new XmlSerializer [mappings.Length];
SerializerData[] datas = new SerializerData [mappings.Length];
GenerationBatch batch = new GenerationBatch ();
batch.Maps = mappings;
batch.Datas = datas;
for (int n=0; n<mappings.Length; n++)
{
if (mappings[n] != null)
{
SerializerData data = new SerializerData ();
data.Batch = batch;
sers[n] = new XmlSerializer (mappings[n], data);
datas[n] = data;
}
}
return sers;
}
public static List <NavigationItem> GetDataSource(IArea site, MenuType type, string key)
{
JContext jc = JContext.Current;
List <NavigationItem> list = new List <NavigationItem>();
int index = jc.Navigation.Index;
int subIndex = jc.Navigation.SubIndex;
int subsubIndex = jc.Navigation.SubsubIndex;
Dictionary <int, NavigationItem> Items = UrlMappingModule.Instance.Provider.GetMenuItemsBySite(site);
string currentSiteKey = jc.Area.AreaKey;
// set menu index of root site
if (site.AreaKey != currentSiteKey)
{
foreach (var k in Items.Keys)
{
if (string.Equals(Items[k].Name, currentSiteKey, StringComparison.InvariantCultureIgnoreCase))
{
index = k;
}
foreach (var k2 in Items[k].Children.Keys)
{
if (string.Equals(Items[k].Children[k2].Name, currentSiteKey, StringComparison.InvariantCultureIgnoreCase))
{
index = k;
subIndex = k2;
}
}
}
}
List <int> keys;
int key_index;
switch (type)
{
case MenuType.TopLevel:
keys = new List <int>(Items.Keys);
foreach (int i in Items.Keys)
{
NavigationItem item = Items[i].Clone() as NavigationItem;
item.Selected = index == i;
item.Url = GetUrl(site, item.Url);
key_index = keys.IndexOf(i);
item.IsFirst = key_index == 0 || Items[keys[key_index - 1]].IsSeparator;
item.IsLast = key_index == Items.Count - 1 || Items[keys[key_index + 1]].IsSeparator;
list.Add(item);
}
break;
case MenuType.SubLevel:
if (Items.ContainsKey(index))
{
Dictionary <int, NavigationItem> subItems = Items[index].Children;
keys = new List <int>(subItems.Keys);
foreach (int j in subItems.Keys)
{
NavigationItem subItem = subItems[j].Clone() as NavigationItem;
subItem.Selected = subIndex == j;
subItem.Url = GetUrl(site, subItem.Url);
subItem.SubItems = new List <NavigationItem>();
key_index = keys.IndexOf(j);
subItem.IsFirst = key_index == 0 || subItems[keys[key_index - 1]].IsSeparator;
subItem.IsLast = key_index == subItems.Count - 1 || subItems[keys[key_index + 1]].IsSeparator;
Dictionary <int, NavigationItem> subsub = Items[index].Children[j].Children;
List <int> subsub_keys = new List <int>(subsub.Keys);
foreach (int k in subsub.Keys)
{
NavigationItem subsubItem = subsub[k].Clone() as NavigationItem;
subsubItem.Selected = subItem.Selected && subsubIndex == k;
subsubItem.Url = GetUrl(site, subsubItem.Url);
key_index = subsub_keys.IndexOf(k);
subsubItem.IsFirst = key_index == 0 || subsub[subsub_keys[key_index - 1]].IsSeparator;
subsubItem.IsLast = key_index == subsub.Count - 1 || subsub[subsub_keys[key_index + 1]].IsSeparator;
subItem.SubItems.Add(subsubItem);
}
list.Add(subItem);
}
}
break;
case MenuType.SubsubLevel:
if (Items.ContainsKey(index) && Items[index].Children.ContainsKey(subIndex))
{
Dictionary <int, NavigationItem> subsub = Items[index].Children[subIndex].Children;
List <int> subsub_keys = new List <int>(subsub.Keys);
foreach (int k in subsub.Keys)
{
NavigationItem subsubItem = subsub[k].Clone() as NavigationItem;
subsubItem.Selected = subsubIndex == k;
subsubItem.Url = GetUrl(site, subsubItem.Url);
key_index = subsub_keys.IndexOf(k);
subsubItem.IsFirst = key_index == 0 || subsub[subsub_keys[key_index - 1]].IsSeparator;
subsubItem.IsLast = key_index == subsub.Count - 1 || subsub[subsub_keys[key_index + 1]].IsSeparator;
list.Add(subsubItem);
}
}
break;
case MenuType.Cascade:
keys = new List <int>(Items.Keys);
foreach (int i in keys)
{
NavigationItem item = Items[i].Clone() as NavigationItem;
item.Selected = index == i;
item.Url = GetUrl(site, item.Url);
item.SubItems = new List <NavigationItem>();
key_index = keys.IndexOf(i);
item.IsFirst = key_index == 0 || Items[keys[key_index - 1]].IsSeparator;
item.IsLast = key_index == Items.Count - 1 || Items[keys[key_index + 1]].IsSeparator;
Dictionary <int, NavigationItem> sub = Items[i].Children;
List <int> sub_keys = new List <int>(sub.Keys);
foreach (int j in sub.Keys)
{
NavigationItem subItem = sub[j].Clone() as NavigationItem;
subItem.Selected = item.Selected && subIndex == j;
subItem.Url = GetUrl(site, subItem.Url);
subItem.SubItems = new List <NavigationItem>();
key_index = sub_keys.IndexOf(j);
subItem.IsFirst = key_index == 0 || sub[sub_keys[key_index - 1]].IsSeparator;
subItem.IsLast = key_index == sub.Count - 1 || sub[sub_keys[key_index + 1]].IsSeparator;
Dictionary <int, NavigationItem> subsub = Items[i].Children[j].Children;
List <int> subsub_keys = new List <int>(subsub.Keys);
foreach (int k in subsub.Keys)
{
NavigationItem subsubItem = subsub[k].Clone() as NavigationItem;
subsubItem.Selected = subItem.Selected && subsubIndex == k;
subsubItem.Url = GetUrl(site, subsubItem.Url);
key_index = subsub_keys.IndexOf(k);
subsubItem.IsFirst = key_index == 0 || subsub[subsub_keys[key_index - 1]].IsSeparator;
subsubItem.IsLast = key_index == subsub.Count - 1 || subsub[subsub_keys[key_index + 1]].IsSeparator;
subItem.SubItems.Add(subsubItem);
}
item.SubItems.Add(subItem);
}
list.Add(item);
}
break;
case MenuType.Self:
List <UrlMappingItem> items = UrlMappingModule.Instance.Provider.UrlMappings.FindAll(delegate(UrlMappingItem item)
{
if (StringUtil.HasText(key))
{
return(item.Index == index && item.SubIndex == subIndex && item["key"] == key);
}
else
{
return(item.Index == index && item.SubIndex == subIndex);
}
});
items.Sort();
foreach (UrlMappingItem i in items)
{
SerializerData sd = i.GetSerializerData();
NavigationItem nav = new NavigationItem()
{
Selected = (i.SelfIndex == JContext.Current.Navigation.Url.SelfIndex),
Url = StringUtil.CombinUrl(site.VirtualPath, i.UrlTemplate.Replace("[page]", "1")),
Title = i.Title
};
nav.SetSerializerData(sd);
list.Add(nav);
}
break;
default:
break;
}
FilterEventArgs e = new FilterEventArgs();
e.Type = type;
e.Items = list;
e.Site = site;
OnBeforeFilter(e);
return(e.Items);
}
void CheckGeneratedTypes (XmlMapping typeMapping)
{
lock (this)
{
if (serializerData == null)
{
lock (serializerTypes)
{
serializerData = (SerializerData) serializerTypes [typeMapping.Source];
if (serializerData == null) {
serializerData = new SerializerData();
serializerTypes [typeMapping.Source] = serializerData;
}
}
}
}
bool generate = false;
lock (serializerData)
{
if (serializerData.UsageCount >= generationThreshold && !serializerData.Generated)
serializerData.Generated = generate = true;
serializerData.UsageCount++;
}
if (generate)
{
if (serializerData.Batch != null)
GenerateSerializersAsync (serializerData.Batch);
else
{
GenerationBatch batch = new GenerationBatch ();
batch.Maps = new XmlMapping[] {typeMapping};
batch.Datas = new SerializerData[] {serializerData};
GenerateSerializersAsync (batch);
}
}
}
internal XmlSerializer(XmlMapping mapping, SerializerData data)
{
typeMapping = mapping;
serializerData = data;
}
