I need to store data in this format:
category1 {
"line of text1"
"line of text2"
"line of text3"
...
}
category2 {
"line of text1"
"line of text2"
"line of text3"
...
}
....I also need to be able to add and delete categorys, and "lines of text". I can't seem to figure out how to do it efficiently in xml files.
Jump to PostYou could add however many you wanted... that was just an example. You always rewrite the file so there isn't a big performance hit with I/O if that is your concern. Unless you're appending data to the end of a file then you are effectively erasing it (in 90% of …
using System.Collections.Generic;
using System.IO;
using System.Xml.Serialization;
namespace daniweb
{
public class Categories
{
private List<string> _category1;
private List<string> _category2;
public List<string> Category1
{
get { return _category1; }
set
{
if (value == null) return;
_category1 = value;
}
}
public List<string> Category2
{
get { return _category2; }
set
{
if (value == null) return;
_category2 = value;
}
}
public Categories()
{
_category1 = new List<string>();
_category2 = new List<string>();
}
public void SaveToFile(string FileName)
{
if (File.Exists(FileName))
File.Delete(FileName);
XmlSerializer ser = new XmlSerializer(typeof(Categories));
using (FileStream fs = new FileStream(FileName, FileMode.CreateNew))
{
ser.Serialize(fs, this);
}
}
public static Categories LoadFromFile(string FileName)
{
XmlSerializer ser = new XmlSerializer(typeof(Categories));
Categories result;
using (FileStream fs = new FileStream(FileName, FileMode.Open))
{
result = (Categories)ser.Deserialize(fs);
}
return result;
}
}
}Calling it:
private void button9_Click(object sender, EventArgs e)
{
Categories c = new Categories();
c.Category1.Add("a");
c.Category1.Add("b");
c.Category1.Add("c");
c.SaveToFile(@"C:\test.xml");
}
private void button10_Click(object sender, EventArgs e)
{
Categories c = Categories.LoadFromFile(@"C:\test.xml");
c.Category1.Remove("b");
c.SaveToFile(@"C:\test.xml");
}thanks alot, this is perfect
is there a way to add and delete new categories without creating/deleting a file every time?
correct me if im wrong but doesn't your class only allow 2 categories per file?
You could add however many you wanted... that was just an example. You always rewrite the file so there isn't a big performance hit with I/O if that is your concern. Unless you're appending data to the end of a file then you are effectively erasing it (in 90% of the cases).
Here is an example of a class I serialize with the XmlSerializer :
[Serializable]
public sealed class ChartConfiguration
{
private List<int> _regions;
private List<int> _facilites;
private List<int> _servers;
private List<int> _sensors;
private DateTime _startDate;
private DateTime _endDate;
private RelativeDate _relativeStartDate;
private RelativeDate _relativeEndDate;
private List<DateRange> _dateList;
private List<RelativeDateRange> _relativeDateList;
private bool _useRelativeDates;
private bool _useTrendComparison;
private bool _showMin;
private bool _showMax;
private bool _showAvg;
private bool _showSum;
private bool _showCount;
private bool _showAllPoints;
private bool _useChartTitle;
private bool _showLegend;
private string _chartTitle;
private ChartType _chartType;
private ServerTreeResolution _serverTreeResolution;
private DateTimeMeasurementUnit _dateTimeMeasureUnit;
private List<int> _countGroups;
private List<ChartDataSource> _chartDataSources;
private string _chartXml;
private bool _enableRuntimeHitTesting;
private bool _enableCacheToMemory;
private bool _enableScrolling;
private bool _enableZooming;
private bool _enableThresholdColor;
private decimal _lowThreshold;
private decimal _highThreshold;
private bool _alwaysShowZeroLevel;
private bool _hideSeriesWithNoPoints;
private bool _showThresholdCaptions;
private bool _useHoursOfOperation;
private bool _resolveOverlapping;
private bool _showValueLabel;
private bool _showValueMarker;
private List<SeriesTag> _seriesTags;
private decimal _scaleFactor;
private DepartmentReportList _departments;
private bool _limitServerTreeOnSensorType;
/* -------------------------------------------------------------------- */
public List<int> Regions
{
get { return _regions; }
set
{
if (value == null) return;
_regions = value;
}
}
public List<int> Facilities
{
get { return _facilites; }
set
{
if (value == null) return;
_facilites = value;
}
}
public List<int> Servers
{
get { return _servers; }
set
{
if (value == null) return;
_servers = value;
}
}
public List<int> Sensors
{
get { return _sensors; }
set
{
if (value == null) return;
_sensors = value;
}
}
public DateTime StartDate
{
get { return _startDate; }
set { _startDate = value; }
}
public DateTime EndDate
{
get { return _endDate; }
set { _endDate = value; }
}
public RelativeDate RelativeStartDate
{
get { return _relativeStartDate; }
set { _relativeStartDate = value; }
}
public RelativeDate RelativeEndDate
{
get { return _relativeEndDate; }
set { _relativeEndDate = value; }
}
public List<DateRange> DateList
{
get { return _dateList; }
set
{
if (value == null) return;
_dateList = value;
}
}
public List<RelativeDateRange> RelativeDateList
{
get { return _relativeDateList; }
set
{
if (value == null) return;
_relativeDateList = value;
}
}
public bool UseRelativeDates
{
get { return _useRelativeDates; }
set { _useRelativeDates = value; }
}
public bool UseTrendComparison
{
get { return _useTrendComparison; }
set { _useTrendComparison = value; }
}
public bool ShowMin
{
get { return ((!ShowAllPoints) && _showMin); }
set { _showMin = value; }
}
public bool ShowMax
{
get { return ((!ShowAllPoints) && _showMax); }
set { _showMax = value; }
}
public bool ShowAvg
{
get { return ((!ShowAllPoints) && _showAvg); }
set { _showAvg = value; }
}
public bool ShowAllPoints
{
get { return _showAllPoints; }
set { _showAllPoints = value; }
}
public bool ShowSum
{
get { return ((!ShowAllPoints) && _showSum); }
set { _showSum = value; }
}
public bool ShowCount
{
get { return _showCount; }
set { _showCount = value; }
}
public bool UseChartTitle
{
get { return _useChartTitle; }
set { _useChartTitle = value; }
}
public bool ShowLegend
{
get { return _showLegend; }
set { _showLegend = value; }
}
public string ChartTitle
{
get { return _chartTitle; }
//XMLSerializer changes \r\n to \n. We take out the \r and substitue all \n to \r\n.
set
{
if (value == null)
_chartTitle = null;
else
_chartTitle = value.Replace("\r", string.Empty).Replace("\n", Environment.NewLine);
}
}
public ChartType ChartType
{
get { return _chartType; }
set { _chartType = value; }
}
public ServerTreeResolution ServerTreeResolution
{
get { return _serverTreeResolution; }
set { _serverTreeResolution = value; }
}
public DateTimeMeasurementUnit DateTimeMeasureUnit
{
get { return _dateTimeMeasureUnit; }
set { _dateTimeMeasureUnit = value; }
}
public List<int> CountGroups
{
get { return _countGroups; }
set
{
if (value == null) return;
_countGroups = value;
}
}
public List<ChartDataSource> ChartDataSources
{
get { return _chartDataSources; }
set { _chartDataSources = value; }
}
public string ChartXml
{
get { return _chartXml; }
set { _chartXml = value; }
}
public bool EnableRuntimeHitTesting
{
get { return _enableRuntimeHitTesting; }
set { _enableRuntimeHitTesting = value; }
}
public bool EnableCacheToMemory
{
get { return _enableCacheToMemory; }
set { _enableCacheToMemory = value; }
}
public bool EnableScrolling
{
get { return _enableScrolling; }
set { _enableScrolling = value; }
}
public bool EnableZooming
{
get { return _enableZooming; }
set { _enableZooming = value; }
}
public bool EnableThresholdColor
{
get { return _enableThresholdColor; }
set { _enableThresholdColor = value; }
}
public decimal LowThreshold
{
get { return _lowThreshold; }
set { _lowThreshold = value; }
}
public decimal HighThreshold
{
get { return _highThreshold; }
set { _highThreshold = value; }
}
public bool AlwaysShowZeroLevel
{
get { return _alwaysShowZeroLevel; }
set { _alwaysShowZeroLevel = value; }
}
public bool HideSeriesWithNoPoints
{
get { return _hideSeriesWithNoPoints; }
set { _hideSeriesWithNoPoints = value; }
}
public bool ShowThresholdCaptions
{
get { return _showThresholdCaptions; }
set { _showThresholdCaptions = value; }
}
public bool UseHoursOfOperation
{
get { return _useHoursOfOperation; }
set { _useHoursOfOperation = value; }
}
public bool ResolveOverlapping
{
get { return _resolveOverlapping; }
set { _resolveOverlapping = value; }
}
public bool ShowValueLabel
{
get { return _showValueLabel; }
set { _showValueLabel = value; }
}
public bool ShowValueMarker
{
get { return _showValueMarker; }
set { _showValueMarker = value; }
}
public List<SeriesTag> SeriesTags
{
get { return _seriesTags; }
set { _seriesTags = value; }
}
public decimal ScaleFactor
{
get { return _scaleFactor; }
set { _scaleFactor = value; }
}
public DepartmentReportList Departments
{
get { return _departments; }
set
{
if (value == null) return;
_departments = value;
}
}
public bool LimitServerTreeOnSensorType
{
get { return _limitServerTreeOnSensorType; }
set { _limitServerTreeOnSensorType = value; }
}
/* -------------------------------------------------------------------- */
public ChartConfiguration()
{
_regions = new List<int>();
_facilites = new List<int>();
_servers = new List<int>();
_sensors = new List<int>();
_dateList = new List<DateRange>();
_relativeDateList = new List<RelativeDateRange>();
_countGroups = new List<int>();
_chartDataSources = new List<ChartDataSource>();
_seriesTags = new List<SeriesTag>();
_departments = new DepartmentReportList();
//default values for new fields
_scaleFactor = 1;
_limitServerTreeOnSensorType = true;
_showLegend = true;
}
/* -------------------------------------------------------------------- */
public ChartConfiguration(ChartType chartType)
: this()
{
this.ChartType = chartType;
SetupChartDefaults();
}
/* -------------------------------------------------------------------- */
private void SetupChartDefaults()
{
switch (this.ChartType)
{
case ChartType.Traffic:
this.StartDate = Dates.RelativeDateToAbsolute(RelativeDate.Today);
this.EndDate = Dates.RelativeDateToAbsolute(RelativeDate.Tomorrow);
this.ShowMin = false;
this.ShowMax = false;
this.ShowAvg = false;
this.ShowSum = true;
this.ShowCount = false;
this.ShowAllPoints = false;
this.UseChartTitle = true;
this.ChartTitle = GetDefaultChartTitle();
this.ServerTreeResolution = ServerTreeResolution.Facility;
this.DateTimeMeasureUnit = DateTimeMeasurementUnit.Hour;
this.AlwaysShowZeroLevel = true;
this.UseHoursOfOperation = true;
break;
case ChartType.Temperature:
this.StartDate = Dates.RelativeDateToAbsolute(RelativeDate.Today);
this.EndDate = Dates.RelativeDateToAbsolute(RelativeDate.Tomorrow);
this.ShowMin = false;
this.ShowMax = false;
this.ShowAvg = true;
this.ShowSum = false;
this.ShowCount = false;
this.ShowAllPoints = false;
this.UseChartTitle = true;
this.ChartTitle = GetDefaultChartTitle();
this.ServerTreeResolution = ServerTreeResolution.Sensor;
this.DateTimeMeasureUnit = DateTimeMeasurementUnit.Hour;
this.AlwaysShowZeroLevel = false;
this.UseHoursOfOperation = false;
break;
case ChartType.Humidity:
this.StartDate = Dates.RelativeDateToAbsolute(RelativeDate.Today);
this.EndDate = Dates.RelativeDateToAbsolute(RelativeDate.Tomorrow);
this.ShowMin = false;
this.ShowMax = false;
this.ShowAvg = true;
this.ShowSum = false;
this.ShowCount = false;
this.ShowAllPoints = false;
this.UseChartTitle = true;
this.ChartTitle = GetDefaultChartTitle();
this.ServerTreeResolution = ServerTreeResolution.Sensor;
this.DateTimeMeasureUnit = DateTimeMeasurementUnit.Hour;
this.AlwaysShowZeroLevel = true;
this.UseHoursOfOperation = false;
break;
case ChartType.TempHumid:
this.StartDate = Dates.RelativeDateToAbsolute(RelativeDate.Today);
this.EndDate = Dates.RelativeDateToAbsolute(RelativeDate.Tomorrow);
this.ShowMin = false;
this.ShowMax = false;
this.ShowAvg = true;
this.ShowSum = false;
this.ShowCount = false;
this.ShowAllPoints = false;
this.UseChartTitle = true;
this.ChartTitle = GetDefaultChartTitle();
this.ServerTreeResolution = ServerTreeResolution.Sensor;
this.DateTimeMeasureUnit = DateTimeMeasurementUnit.Hour;
this.AlwaysShowZeroLevel = false;
this.UseHoursOfOperation = false;
break;
case ChartType.Analog:
this.StartDate = Dates.RelativeDateToAbsolute(RelativeDate.Today);
this.EndDate = Dates.RelativeDateToAbsolute(RelativeDate.Tomorrow);
this.ShowMin = false;
this.ShowMax = false;
this.ShowAvg = true;
this.ShowSum = false;
this.ShowCount = false;
this.ShowAllPoints = false;
this.UseChartTitle = true;
this.ChartTitle = GetDefaultChartTitle();
this.ServerTreeResolution = ServerTreeResolution.Sensor;
this.DateTimeMeasureUnit = DateTimeMeasurementUnit.Hour;
this.AlwaysShowZeroLevel = false;
this.UseHoursOfOperation = false;
break;
case ChartType.Occupancy:
this.StartDate = Dates.RelativeDateToAbsolute(RelativeDate.Today);
this.EndDate = Dates.RelativeDateToAbsolute(RelativeDate.Tomorrow);
this.ShowMin = false;
this.ShowMax = true;
this.ShowAvg = true;
this.ShowSum = false;
this.ShowCount = false;
this.ShowAllPoints = false;
this.UseChartTitle = true;
this.ChartTitle = GetDefaultChartTitle();
this.ServerTreeResolution = ServerTreeResolution.Facility;
this.DateTimeMeasureUnit = DateTimeMeasurementUnit.Hour;
this.AlwaysShowZeroLevel = true;
this.UseHoursOfOperation = true;
break;
default:
throw new InvalidOperationException("Unknown chart type");
}
this.EnableCacheToMemory = true;
this.EnableRuntimeHitTesting = false;
this.EnableScrolling = true;
this.EnableZooming = true;
this.HideSeriesWithNoPoints = true;
this.ShowThresholdCaptions = true;
this.RelativeStartDate = RelativeDate.Today;
this.RelativeEndDate = RelativeDate.Tomorrow;
this.ShowValueMarker = true;
this.ShowValueLabel = true;
this.ResolveOverlapping = false;
}
/* -------------------------------------------------------------------- */
private string GetDefaultChartTitle()
{
switch (this.ChartType)
{
case ChartType.Traffic:
return string.Format("Traffic Report" + Environment.NewLine +
"{0} through {1} each {2}",
TitleVariables.StartDate,
TitleVariables.EndDate,
TitleVariables.Measure);
case ChartType.Temperature:
return string.Format("Temperature Report" + Environment.NewLine +
"{0} through {1} each {2}",
TitleVariables.StartDate,
TitleVariables.EndDate,
TitleVariables.Measure);
case ChartType.Humidity:
return string.Format("Humidity Report" + Environment.NewLine +
"{0} through {1} each {2}",
TitleVariables.StartDate,
TitleVariables.EndDate,
TitleVariables.Measure);
case ChartType.TempHumid:
return string.Format("Temperature/Humidity Report" + Environment.NewLine +
"{0:d} through {1} each {2}",
TitleVariables.StartDate,
TitleVariables.EndDate,
TitleVariables.Measure);
case ChartType.Analog:
return string.Format("Analog Report" + Environment.NewLine +
"{0} through {1} each {2}",
TitleVariables.StartDate,
TitleVariables.EndDate,
TitleVariables.Measure);
case ChartType.Occupancy:
return string.Format("Occupancy Report" + Environment.NewLine +
"{0} through {1} each {2}",
TitleVariables.StartDate,
TitleVariables.EndDate,
TitleVariables.Measure);
default:
throw new InvalidOperationException("Unknown Chart Type");
}
}
/* -------------------------------------------------------------------- */
public string GetSubstitutedChartTitle(string title)
{
List<DateRange> lst = GetDateRanges();
DateRange range;
if (lst.Count > 0)
range = lst[0];
else
range = new DateRange(System.Data.SqlTypes.SqlDateTime.MinValue.Value, System.Data.SqlTypes.SqlDateTime.MaxValue.Value);
string result = title;
result = result.Replace(TitleVariables.StartDate, range.StartDate.Date.ToString("d"));
result = result.Replace(TitleVariables.EndDate, range.EndDate.Date.ToString("d"));
result = result.Replace(TitleVariables.Measure, DateTimeMeasureUnit.ToString());
return result;
}
/* -------------------------------------------------------------------- */
public List<DateRange> GetDateRanges()
{
List<DateRange> result = new List<DateRange>();
if (UseRelativeDates)
{
//Relative Dates
if (UseTrendComparison)
{
foreach (RelativeDateRange range in this.RelativeDateList)
{
DateRange dr = new DateRange();
dr.StartDate = Dates.RelativeDateToAbsolute(range.StartDate);
dr.EndDate = Dates.RelativeDateToAbsolute(range.EndDate);
result.Add(dr);
}
}
else
{
DateRange dr = new DateRange();
dr.StartDate = Dates.RelativeDateToAbsolute(this.RelativeStartDate);
dr.EndDate = Dates.RelativeDateToAbsolute(this.RelativeEndDate);
result.Add(dr);
}
}
else
{
//Absolute Dates
if (UseTrendComparison)
{
result.AddRange(this.DateList);
}
else
{
DateRange dr = new DateRange();
dr.StartDate = this.StartDate;
dr.EndDate = this.EndDate;
result.Add(dr);
}
}
return result;
}
/* -------------------------------------------------------------------- */
public static class TitleVariables
{
[
NonSerialized,
XmlIgnore
]
public const string StartDate = @"%BeginDate%";
[
NonSerialized,
XmlIgnore
]
public const string EndDate = @"%EndDate%";
[
NonSerialized,
XmlIgnore
]
public const string Measure = @"%Measure%";
}
/* -------------------------------------------------------------------- */
public SeriesTag FindTag(string SeriesGUID)
{
if (string.IsNullOrEmpty(SeriesGUID))
return null;
foreach (SeriesTag tag in this.SeriesTags)
{
if (string.Compare(tag.SeriesGUID, SeriesGUID, true) == 0)
return tag;
}
return null;
}
/* -------------------------------------------------------------------- */
}You can serialize just about anything you want :)
We're a friendly, industry-focused community of developers, IT pros, digital marketers, and technology enthusiasts meeting, networking, learning, and sharing knowledge.