public static bool TryGetValue <T>(this IUserConfiguration config, Type section, string key, out T value) { #pragma warning disable CS0612 // 'ConfigurationItem'은(는) 사용되지 않습니다. var configItem = new ConfigurationItem(section.Name, key); #pragma warning restore CS0612 // 'ConfigurationItem'은(는) 사용되지 않습니다. if (config.Contains(configItem) == true) { try { if (ConfigurationBase.CanSupportType(typeof(T)) == true) { value = (T)config[configItem]; return(true); } else { var text = (string)config[configItem]; value = XmlSerializerUtility.ReadString <T>(text.Decrypt()); return(true); } } catch { } } value = default; return(false); }
protected override void Ondeserializing(SerializationInfo info) { base.Ondeserializing(info); var tablesRevisionXml = info.GetValue(TablesRevisionKey, typeof(string)) as string; var tablesRevision = XmlSerializerUtility.ReadString(tablesRevisionXml, typeof(List <SerializableKeyValuePair <string, long> >)); if (tablesRevision != null && tablesRevision is List <SerializableKeyValuePair <string, long> > tables) { foreach (var table in tables) { if (table.Key != null && this.dataSet.Tables.Contains(table.Key)) { this.dataSet.Tables[table.Key].UpdateRevision(table.Value); } } } var typesRevisionXml = info.GetValue(TypesRevisionKey, typeof(string)) as string; var typesRevision = XmlSerializerUtility.ReadString(typesRevisionXml, typeof(List <SerializableKeyValuePair <string, long> >)); if (typesRevision != null && typesRevision is List <SerializableKeyValuePair <string, long> > types) { foreach (var type in types) { if (type.Key != null && this.dataSet.Types.Contains(type.Key)) { this.dataSet.Types[type.Key].UpdateRevision(type.Value); } } } }
protected override void OnSerializaing(SerializationInfo info, StreamingContext context) { base.OnSerializaing(info, context); info.AddValue(TablesRevisionKey, GetTablesRevisionXml()); info.AddValue(TypesRevisionKey, GetTypesRevisionXml()); string GetTablesRevisionXml() { var list = new List <SerializableKeyValuePair <string, long> >(); if (this.Source is CremaDataSet dataSet) { foreach (var table in dataSet.Tables) { list.Add(new SerializableKeyValuePair <string, long>(table.Name, table.Revision)); } } return(XmlSerializerUtility.GetString(list)); } string GetTypesRevisionXml() { var list = new List <SerializableKeyValuePair <string, long> >(); if (this.Source is CremaDataSet dataSet) { foreach (var type in dataSet.Types) { list.Add(new SerializableKeyValuePair <string, long>(type.Name, type.Revision)); } } return(XmlSerializerUtility.GetString(list)); } }
private void InitializeUsers(SerializationInfo info) { DomainUserInfo[] FindUsersValue() { var enumerator = info.GetEnumerator(); while (enumerator.MoveNext()) { var item = enumerator.Current; if (item.Name == usersKey) { return(XmlSerializerUtility.ReadString <DomainUserInfo[]>(item.Value as string)); } } return(null); } var users = FindUsersValue(); if (users == null) { return; } foreach (var item in users) { this.users.Add(new DomainUser(this, item.UserID, item.UserName, item.AccessType)); } }
private void Deserialize(XmlReader reader, IDictionary <string, object> properties) { reader.ReadStartElement(); reader.MoveToContent(); while (reader.NodeType == XmlNodeType.Element) { if (reader.IsEmptyElement == false) { var name = reader.GetAttribute("name"); var type = reader.GetAttribute("type"); try { var runtimeType = Type.GetType(type); reader.ReadStartElement(); var value = XmlSerializerUtility.Read(reader, runtimeType); reader.ReadEndElement(); properties.Add(name, value); } catch { reader.Skip(); } } else { reader.Skip(); } reader.MoveToContent(); } }
public void Post(DomainActionBase action) { if (this.isEnabled == false) { return; } var message = string.Empty; this.current = action; action.ID = this.id++; var s = XmlSerializerUtility.GetSerializer(action.GetType()); var ns = new XmlSerializerNamespaces(); ns.Add(string.Empty, string.Empty); ns.Add("fn", action.GetType().AssemblyQualifiedName); using (var sw = new Utf8StringWriter()) using (var writer = XmlWriter.Create(sw, writerSettings)) { DataContractSerializerUtility.Write(writer, action); writer.Close(); message = sw.ToString(); } this.postedWriter.WriteLine(message); }
protected override byte[] SerializeSource(object source) { if (this.data == null) { var xml = XmlSerializerUtility.GetString(source); this.data = Encoding.UTF8.GetBytes(xml.Compress()); } return(this.data); }
protected override void OnInitialize(byte[] data) { base.OnInitialize(data); var xml = Encoding.UTF8.GetString(data).Decompress(); this.TemplateSource = XmlSerializerUtility.ReadString <CremaTemplate>(xml); this.view = this.TemplateSource.View; }
protected override void OnInitialize(DomainMetaData metaData) { base.OnInitialize(metaData); var xml = Encoding.UTF8.GetString(metaData.Data).Decompress(); this.template = XmlSerializerUtility.ReadString <CremaTemplate>(xml); this.view = this.template.View; }
void IXmlSerializable.WriteXml(XmlWriter writer) { writer.WriteAttributeString("Name", this.TargetTable.Name); writer.WriteAttributeString("CategoryPath", this.TargetTable.CategoryPath); writer.WriteAttributeString("BaseNamespace", this.TargetTable.DataSet.Namespace); this.template.WriteXml(writer, XmlWriteMode.DiffGram); this.TargetTable.DataSet.WriteXmlSchema(writer); this.TargetTable.DataSet.WriteXml(writer); XmlSerializerUtility.Write(writer, this.Types); }
protected override void DerializeSource(byte[] data) { var xml = Encoding.UTF8.GetString(data).Decompress(); this.dataSet = XmlSerializerUtility.ReadString <CremaDataSet>(xml); foreach (var item in this.dataSet.Tables) { var view = item.AsDataView(); this.views.Add(item.TableName, view); } }
private void Serialize(XmlWriter writer, IReadOnlyDictionary <string, object> properties) { writer.WriteStartElement(SerializableElement); foreach (var item in properties) { writer.WriteStartElement("item"); writer.WriteAttributeString("name", item.Key); writer.WriteAttributeString("type", item.Value.GetType().AssemblyQualifiedName); XmlSerializerUtility.Write(writer, item.Value); writer.WriteEndElement(); } writer.WriteEndElement(); }
protected virtual void OnSerializaing(SerializationInfo info, StreamingContext context) { info.AddValue(typeof(DomainInfo).Name, base.DomainInfo); info.AddValue(dataKey, this.SerializeSource()); info.AddValue(usersKey, GetUsersXml()); string GetUsersXml() { var query = from DomainUser item in this.Users select item.DomainUserInfo; var userInfos = query.ToArray(); return(XmlSerializerUtility.GetString(userInfos)); } }
public static void SetValue <T>(this IUserConfiguration config, Type section, string key, T value) { #pragma warning disable CS0612 // 'ConfigurationItem'은(는) 사용되지 않습니다. var configItem = new ConfigurationItem(section.Name, key); #pragma warning restore CS0612 // 'ConfigurationItem'은(는) 사용되지 않습니다. if (ConfigurationBase.CanSupportType(typeof(T)) == true) { config[configItem] = value; } else { config[configItem] = XmlSerializerUtility.GetString(value).Encrypt(); } }
protected override void OnInitialize(DomainMetaData metaData) { base.OnInitialize(metaData); var text = Encoding.UTF8.GetString(metaData.Data).Decompress(); var index = text.IndexOf(";"); var path = text.Remove(index); var itemName = new ItemName(path); var xml = text.Substring(index + 1); var dataSet = XmlSerializerUtility.ReadString <CremaDataSet>(xml); this.dataType = dataSet.Types[itemName.Name]; this.view = this.dataType.AsDataView(); }
public static ResXInfo GetSettings(this Solution solution) { var fullName = solution.GetFullName(); var xmlPath = fullName + ".cremaresx"; if (File.Exists(xmlPath) == true) { if (XmlSerializerUtility.Read(xmlPath, typeof(ResXInfo)) is ResXInfo obj) { return(obj); } } throw new InvalidOperationException(); }
protected override byte[] SerializeSource(object source) { if (this.data == null) { if (source is CremaDataType dataType) { var text = dataType.Path + ";" + XmlSerializerUtility.GetString(dataType.DataSet); this.data = Encoding.UTF8.GetBytes(text.Compress()); } else { throw new NotImplementedException(); } } return(this.data); }
public static string Serialize(object obj, TextSerializerType type) { if (type == TextSerializerType.Yaml) { return(yamlSerializer.Serialize(obj)); } else if (type == TextSerializerType.Json) { return(JsonConvert.SerializeObject(obj, Formatting.Indented)); } else if (type == TextSerializerType.Xml) { return(XmlSerializerUtility.GetString(obj, true)); } throw new NotImplementedException(); }
public static ConnectionItem LoadConnection(string dbcFile) { if (System.IO.File.Exists(dbcFile)) { try { ConnectionItem ci = XmlSerializerUtility.LoadFromXmlFile <ConnectionItem>(dbcFile); ci.SetLoaded(); return(ci); } catch (Exception err) { FormLog.NotifyException(true, err, "Invalid connection file [{0}]", dbcFile); } } return(null); }
public void OnChangeWithinMethod(bool withinmethod) { if (_writer == null) { _writer = XmlSerializerUtility.GetWriter(_reader) as XmlObjectWriter; } if (_writer != null && _xmlNode != null) { if (withinmethod) { _xmlNodeChanged = _xmlNode.OwnerDocument.CreateElement(_xmlNode.Name); _writer.WriteObjectToNode(_xmlNodeChanged, this); } else { _writer.WriteObjectToNode(_xmlNode, this); } } }
public void MergeFromFile() { string f = GetConnectionFilename(this.ConnectionGuid); if (System.IO.File.Exists(f)) { ConnectionItem ci = XmlSerializerUtility.LoadFromXmlFile <ConnectionItem>(f); if (ci != null) { ci.SetDataFolder(); if (!string.IsNullOrEmpty(ci._name)) { _name = ci._name; } if (ci._cnn != null) { _cnn = ci._cnn; } } } }
public void UpdateXmlNode(XmlObjectWriter writer) { if (_xmlNode != null) { if (writer != null) { writer.WriteObjectToNode(_xmlNode, this); } else { if (_writer == null) { _writer = XmlSerializerUtility.GetWriter(_reader) as XmlObjectWriter; } if (_writer != null) { _writer.WriteObjectToNode(_xmlNode, this); } } } }
public void XmlSerializing() { var table = this.dataSet.Tables.Random(item => item.TemplatedParent == null); var template1 = new CremaTemplate(table); //CremaRandomUtility.RandomTask(template1, 30); var xml1 = XmlSerializerUtility.GetString(template1, true); var template2 = XmlSerializerUtility.ReadString <CremaTemplate>(xml1); var xml2 = XmlSerializerUtility.GetString(template2, true); try { Assert.AreEqual(xml1, xml2); } catch { File.WriteAllText(Path.Combine(Directory.GetCurrentDirectory(), template1.TableName + "_template1" + CremaSchema.SchemaExtension), xml1); File.WriteAllText(Path.Combine(Directory.GetCurrentDirectory(), template2.TableName + "_template2" + CremaSchema.SchemaExtension), xml2); throw; } }
void IXmlSerializable.ReadXml(XmlReader reader) { var dataSet = new CremaDataSet(); var name = reader.GetAttribute("Name"); var categoryPath = reader.GetAttribute(nameof(CategoryPath)); var baseNamespace = reader.GetAttribute("BaseNamespace"); dataSet.Namespace = baseNamespace; reader.ReadStartElement(); reader.MoveToContent(); this.template.TargetTable = null; this.template.OmitSignatureDate = true; this.template.ReadXml(reader); this.template.OmitSignatureDate = false; reader.MoveToContent(); dataSet.ReadXmlSchema(reader); reader.MoveToContent(); dataSet.ReadXml(reader); reader.MoveToContent(); this.template.InternalTypes = XmlSerializerUtility.Read <string[]>(reader); reader.MoveToContent(); reader.ReadEndElement(); this.template.InternalTargetTable = (InternalDataTable)dataSet.Tables[name, categoryPath]; foreach (var item in this.template.Rows) { if (item is InternalTemplateColumn rowItem) { if (rowItem.RowState == DataRowState.Deleted) { continue; } rowItem.TargetColumn = (InternalDataColumn)this.template.InternalTargetTable.Columns[rowItem.ColumnName]; } } }