xml序列化

最新推荐文章于 2025-08-20 16:02:52 发布

快乐大法师

最新推荐文章于 2025-08-20 16:02:52 发布

阅读量485

点赞数

CC 4.0 BY-SA版权

分类专栏： xml相关文章标签： xml string exception dictionary object null

本文链接：https://blog.youkuaiyun.com/kkxxllasasas/article/details/6206873

xml相关专栏收录该内容

1 篇文章

订阅专栏

FSRItemManage.Save(ddp, "D://a.xml");

HRExcelConfig hl = (HRExcelConfig)FSRItemManage.Load(typeof(HRExcelConfig), configFileName);

    public class FSRItemManage
    {
        /// <summary>
        /// 指定オブジェクトの属性値をxmlファイルに書き込む
        /// </summary>
        /// <param name="obj">指定オブジェクト</param>
        /// <param name="fileName">xmlファイル名称（フルパス）</param>
        /// <returns>
        /// 正常に保存された場合　TRUE
        /// エラー発生の場合　FALSE
        /// </returns>
        public static bool Save(object obj, string fileName)
        {
            try
            {
                MyXmlSerializer.SerializeObject(obj, fileName);
                return true;
            }
            catch (Exception)
            {
                return false;
            }
        }

        /// <summary>
        /// 指定型のオブジェクトの属性値をxmlファイルから読込む
        /// </summary>
        /// <param name="type">オブジェクトの型（Type）</param>
        /// <param name="fileName">xmlファイル名称（フルパス）</param>
        /// <returns></returns>
        public static object Load(Type type, string fileName)
        {
            try
            {
                return MyXmlSerializer.DeserializeObject(type, fileName);
            }
            catch (Exception)
            {
                return null;
            }
        }
    }

public static class MyXmlSerializer //: System.Xml.Serialization.XmlSerializer
{

        /// <summary>
        /// オブジェクトをシリアル化し、XMLファイルに保存する
        /// </summary>
        /// <param name="obj">シリアル化する対象</param>
        /// <param name="fileName">保存先のファイル名</param>
        public static void SerializeObject(object @obj, string @fileName)
        {
            XmlSerializer serializer = null;
            FileStream fs = null;
            try
            {
                //XmlSerializerオブジェクトを作成
                //書き込むオブジェクトの型を指定する
                serializer = new XmlSerializer(@obj.GetType());
                //ファイルを作成
                fs = new FileStream(@fileName, FileMode.Create);
                //シリアル化し、XMLファイルに保存する
                serializer.Serialize(fs, @obj);
            }
            catch (Exception)
            {
            }
            finally
            {
                //閉じる
                fs.Close();
            }
        }

        /// <summary>
        /// ArrayList型を含むクラスのオブジェクトをシリアル化し、XMLファイルに保存する
        /// </summary>
        /// <param name="obj">シリアル化する対象</param>
        /// <param name="fileName">保存先のファイル名</param>
        /// <param name="types">ArrayListに挿入できるオブジェクト型のType配列</param>
        public static void SerializeObject(object @obj, string @fileName, Type[] @types)
        {
            XmlSerializer serializer = null;
            FileStream fs = null;
            try
            {
                //XmlSerializerオブジェクトを作成
                //書き込むオブジェクトの型を指定する
                serializer = new XmlSerializer(@obj.GetType(), @types);
                //ファイルを作成
                fs = new FileStream(@fileName, FileMode.Create);
                //シリアル化し、XMLファイルに保存する
                serializer.Serialize(fs, @obj);
            }
            catch (Exception)
            {
            }
            finally
            {
                //閉じる
                fs.Close();
            }
        }

        /// <summary>
        /// XMLファイルから読み込み、逆シリアル化する
        /// </summary>
        /// <param name="fileName">保存先のファイル名</param>
        /// <param name="type">逆シリアル化されるオブジェクトのType</param>
        /// <returns></returns>
        public static object DeserializeObject(Type @type, string @fileName)
        {
            XmlSerializer serializer = null;
            FileStream fs = null;
            object obj = null;
            try
            {
                //XmlSerializerオブジェクトの作成
                serializer = new XmlSerializer(@type);
                //ファイルを開く
                fs = new FileStream(@fileName, FileMode.Open);
                //XMLファイルから読み込み、逆シリアル化する
                obj = serializer.Deserialize(fs);
                //return
                return obj;
            }
            catch (Exception)
            {
                return null;
            }
            finally
            {
                //閉じる
                fs.Close();
            }
        }
    }

    /// 支持XML序列化的泛型 Dictionary
    /// </summary>
    /// <typeparam name="TKey"></typeparam>
    /// <typeparam name="TValue"></typeparam>
    [XmlRoot("SerializableDictionary")]
    public class SerializableDictionary<TKey, TValue>
        : Dictionary<TKey, TValue>, IXmlSerializable
    {

        #region ?造函数
        public SerializableDictionary()
            : base()
        {
        }
        public SerializableDictionary(IDictionary<TKey, TValue> dictionary)
            : base(dictionary)
        {
        }

        public SerializableDictionary(IEqualityComparer<TKey> comparer)
            : base(comparer)
        {
        }

        public SerializableDictionary(int capacity)
            : base(capacity)
        {
        }
        public SerializableDictionary(int capacity, IEqualityComparer<TKey> comparer)
            : base(capacity, comparer)
        {
        }
        protected SerializableDictionary(SerializationInfo info, StreamingContext context)
            : base(info, context)
        {
        }
        #endregion
        #region IXmlSerializable Members
        public System.Xml.Schema.XmlSchema GetSchema()
        {
            return null;
        }
        /// <summary>
        /// 从?象的 XML 表示形式生成??象
        /// </summary>
        /// <param name="reader"></param>
        public void ReadXml(System.Xml.XmlReader reader)
        {
            XmlSerializer keySerializer = new XmlSerializer(typeof(TKey));
            XmlSerializer valueSerializer = new XmlSerializer(typeof(TValue));
            bool wasEmpty = reader.IsEmptyElement;
            reader.Read();
            if (wasEmpty)
                return;
            while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
            {
                reader.ReadStartElement("item");
                reader.ReadStartElement("key");
                TKey key = (TKey)keySerializer.Deserialize(reader);
                reader.ReadEndElement();
                reader.ReadStartElement("value");
                TValue value = (TValue)valueSerializer.Deserialize(reader);
                reader.ReadEndElement();
                this.Add(key, value);
                reader.ReadEndElement();
                reader.MoveToContent();
            }
            reader.ReadEndElement();
        }

        /**/
        /// <summary>
        /// 将?象???其 XML 表示形式
        /// </summary>
        /// <param name="writer"></param>
        public void WriteXml(System.Xml.XmlWriter writer)
        {
            XmlSerializer keySerializer = new XmlSerializer(typeof(TKey));
            XmlSerializer valueSerializer = new XmlSerializer(typeof(TValue));
            foreach (TKey key in this.Keys)
            {
                writer.WriteStartElement("item");
                writer.WriteStartElement("key");
                keySerializer.Serialize(writer, key);
                writer.WriteEndElement();
                writer.WriteStartElement("value");
                TValue value = this[key];
                valueSerializer.Serialize(writer, value);
                writer.WriteEndElement();
                writer.WriteEndElement();
            }
        }
        #endregion
    }

    [Serializable]
    public class HRItem : ICloneable
    {

        public enum MyXlHAlign
        {
            xlHAlignRight = -4152,
            xlHAlignLeft = -4131,
            xlHAlignJustify = -4130,
            xlHAlignDistributed = -4117,
            xlHAlignCenter = -4108,
            xlHAlignGeneral = 1,
            xlHAlignFill = 5,
            xlHAlignCenterAcrossSelection = 7,
        }

        public enum MyXlVAlign
        {
            xlVAlignTop = -4160,
            xlVAlignJustify = -4130,
            xlVAlignDistributed = -4117,
            xlVAlignCenter = -4108,
            xlVAlignBottom = -4107,
        }

        public enum MyXlLineStyle
        {
            xlLineStyleNone = -4142,
            xlDouble = -4119,
            xlDot = -4118,
            xlDash = -4115,
            xlContinuous = 1,
            xlDashDot = 4,
            xlDashDotDot = 5,
            xlSlantDashDot = 13,
        }

        private string _name = "name";
        /// <summary>
        /// 選択範囲名称
        /// </summary>
        [Browsable(false)]
        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }

        private string _text = "";
        /// <summary>
        /// 選択範囲表示名称
        /// </summary>
        [Browsable(true)]
        [DisplayName("名称")]
        public string Text
        {
            get { return _text; }
            set { _text = value; }
        }

        private string _value = "value";
        /// <summary>
        /// 選択範囲に表示する値（文字列、数値）
        /// </summary>
        [Browsable(true)]
        [DisplayName("値")]
        [Description("選択範囲に表示する値（文字列、数値）")]
        public string Value
        {
            get { return _value; }
            set { _value = value; }
        }

        private string _fontName = "ＭＳＰゴシック";
        /// <summary>
        /// Font名称
        /// </summary>
        [Browsable(true)]
        [DisplayName("Font名称")]
        [Description("Font名称")]
        [ReadOnly(true)]
        public string FontName
        {
            get { return _fontName; }
            set { _fontName = value; }
        }

        private float _fontSize = 12;
        /// <summary>
        /// Fontサイズ
        /// </summary>
        [Browsable(true)]
        [DisplayName("Fontサイズ")]
        [Description("Fontサイズ")]
        public float FontSize
        {
            get { return _fontSize; }
            set { _fontSize = value; }
        }

        private bool _fontBold = false;
        /// <summary>
        /// 文字が太字かどうか
        /// </summary>
        [Browsable(true)]
        [DisplayName("FontBold")]
        [Description("文字が太字かどうか")]
        public bool FontBold
        {
            get { return _fontBold; }
            set { _fontBold = value; }
        }

//private Font _font;

        //[Browsable(true)]
        //[DisplayName("Font")]
        //[System.Xml.Serialization.XmlIgnoreAttribute]
        //public Font Font
        //{
        //    get
        //    {
        //        if (_fontBold)
        //        {
        //            _font = new Font(_fontName, _fontSize, FontStyle.Bold);
        //        }
        //        else
        //        {
        //            _font = new Font(_fontName, _fontSize, FontStyle.Regular);
        //        }
        //        return _font;
        //    }
        //    set
        //    {
        //        _font = value;
        //        _fontBold = _font.Bold;
        //        _fontSize = _font.Size;
        //        _fontName = _font.Name;
        //    }
        //}

        private int _fontColor = 0;
        /// <summary>
        /// 文字の色
        /// </summary>
        [Browsable(false)]
        public int FontColor
        {
            get { return _fontColor; }
            set { _fontColor = value; }
        }

private Color _fontColor1;

        [Browsable(true)]
        [DisplayName("文字色")]
        [Description("文字の色")]
        [System.Xml.Serialization.XmlIgnoreAttribute]
        public Color FontColor1
        {
            get
            {
                _fontColor1 = Color.FromArgb(_fontColor);
                return _fontColor1;
            }
            set
            {
                _fontColor1 = value;
                _fontColor = _fontColor1.ToArgb();
            }
        }

        private int _cell1X = 0;
        /// <summary>
        /// 選択範囲のセルX（左上のセル）
        /// </summary>
        [Browsable(true)]
        [DisplayName("Cell1 X")]
        [Description("選択範囲のセルX（左上のセル）")]
        public int Cell1X
        {
            get { return _cell1X; }
            set { _cell1X = value; }
        }

        private int _cell1Y = 0;
        /// <summary>
        /// 選択範囲のセルY（左上のセル）
        /// </summary>
        [Browsable(true)]
        [DisplayName("Cell1 Y")]
        [Description("選択範囲のセルY（左上のセル）")]
        public int Cell1Y
        {
            get { return _cell1Y; }
            set { _cell1Y = value; }
        }

        private int _cell2X = 0;
        /// <summary>
        /// 選択範囲のセルX（右下のセル）
        /// </summary>
        [Browsable(true)]
        [DisplayName("Cell2 X")]
        [Description("選択範囲のセルX（右下のセル）")]
        public int Cell2X
        {
            get { return _cell2X; }
            set { _cell2X = value; }
        }

        private int _cell2Y = 0;
        /// <summary>
        /// 選択範囲のセルY（右下のセル）
        /// </summary>
        [Browsable(true)]
        [DisplayName("Cell2 Y")]
        [Description("選択範囲のセルY（右下のセル）")]
        public int Cell2Y
        {
            get { return _cell2Y; }
            set { _cell2Y = value; }
        }

        private bool _merge = true;
        /// <summary>
        /// 選択範囲を結合するかどうか
        /// </summary>
        [Browsable(true)]
        [DisplayName("結合")]
        [Description("選択範囲を結合するかどうか")]
        public bool Merge
        {
            get { return _merge; }
            set { _merge = value; }
        }

        private double _columnWidth = 0;
        /// <summary>
        /// 列の幅
        /// </summary>
        [Browsable(true)]
        [DisplayName("列の幅")]
        [Description("列の幅")]
        public double ColumnWidth
        {
            get { return _columnWidth; }
            set { _columnWidth = value; }
        }

        private double _rowHeight = 0;
        /// <summary>
        /// 行の高さ
        /// </summary>
        [Browsable(true)]
        [DisplayName("行の高さ")]
        [Description("行の高さ")]
        public double RowHeight
        {
            get { return _rowHeight; }
            set { _rowHeight = value; }
        }

        private int _backColor = 0;
        /// <summary>
        /// 選択範囲の背景色
        /// </summary>
        ///
        [Browsable(false)]
        public int BackColor
        {
            get
            {
                return _backColor;
            }
            set
            {
                _backColor = value;
            }
        }

private Color _backColor1;

        [Browsable(true)]
        [DisplayName("背景色")]
        [Description("背景色")]
        [System.Xml.Serialization.XmlIgnoreAttribute]
        public Color BackColor1
        {
            get
            {
                _backColor1 = Color.FromArgb(_backColor);
                return _backColor1;
            }
            set
            {
                _backColor1 = value;
                _backColor = _backColor1.ToArgb();
            }
        }

        private MyXlHAlign _horizontalAlignment = MyXlHAlign.xlHAlignLeft; //"xlHAlignLeft";
        /// <summary>
        /// 左右揃え
        /// public enum XlHAlign
        /// {
        ///     xlHAlignRight = -4152,
        ///     xlHAlignLeft = -4131,
        ///     xlHAlignJustify = -4130,
        ///     xlHAlignDistributed = -4117,
        ///     xlHAlignCenter = -4108,
        ///     xlHAlignGeneral = 1,
        ///     xlHAlignFill = 5,
        ///     xlHAlignCenterAcrossSelection = 7,
        /// }
        /// </summary>
        [Browsable(true)]
        [DisplayName("水平揃え")]
        [Description("水平文字列揃え")]
        public MyXlHAlign HorizontalAlignment
        {
            get { return _horizontalAlignment; }
            set { _horizontalAlignment = value; }
        }

        private MyXlVAlign _verticalAlignment = MyXlVAlign.xlVAlignCenter;//"xlVAlignCenter";
        /// <summary>
        /// 上下揃え
        ///public enum XlVAlign
        ///{
        ///    xlVAlignTop = -4160,
        ///    xlVAlignJustify = -4130,
        ///    xlVAlignDistributed = -4117,
        ///    xlVAlignCenter = -4108,
        ///    xlVAlignBottom = -4107,
        ///}
        /// </summary>
        [Browsable(true)]
        [DisplayName("垂直列揃え")]
        [Description("水平文字列揃え")]
        public MyXlVAlign VerticalAlignment
        {
            get { return _verticalAlignment; }
            set { _verticalAlignment = value; }
        }

        private bool _wrapText = false;
        /// <summary>
        /// 文字列が折り返されるかどうか
        /// </summary>
        [Browsable(true)]
        [DisplayName("折り返え")]
        [Description("文字列が折り返されるかどうか")]
        public bool WrapText
        {
            get { return _wrapText; }
            set { _wrapText = value; }
        }

        private MyXlLineStyle _topLineStyle = MyXlLineStyle.xlContinuous; //"";
        /// <summary>
        ///public enum XlLineStyle
        ///{
        ///xlLineStyleNone = -4142,
        ///xlDouble = -4119,
        ///xlDot = -4118,
        ///xlDash = -4115,
        ///xlContinuous = 1,
        ///xlDashDot = 4,
        ///xlDashDotDot = 5,
        ///xlSlantDashDot = 13,
        ///}
        /// </summary>
        [Browsable(true)]
        [DisplayName("上罫線")]
        [Description("上罫線")]
        public MyXlLineStyle TopLineStyle
        {
            get { return _topLineStyle; }
            set { _topLineStyle = value; }
        }

        private MyXlLineStyle _rightLineStyle = MyXlLineStyle.xlContinuous; //"";
        [Browsable(true)]
        [DisplayName("右罫線")]
        [Description("右罫線")]
        public MyXlLineStyle RightLineStyle
        {
            get { return _rightLineStyle; }
            set { _rightLineStyle = value; }
        }

        private MyXlLineStyle _bottomLineStyle = MyXlLineStyle.xlContinuous; //"";
        [Browsable(true)]
        [DisplayName("下罫線")]
        [Description("下罫線")]
        public MyXlLineStyle BottomLineStyle
        {
            get { return _bottomLineStyle; }
            set { _bottomLineStyle = value; }
        }

        private MyXlLineStyle _leftLineStyle = MyXlLineStyle.xlContinuous; //"";
        [Browsable(true)]
        [DisplayName("左罫線")]
        [Description("左罫線")]
        public MyXlLineStyle LeftLineStyle
        {
            get { return _leftLineStyle; }
            set { _leftLineStyle = value; }
        }

        private string _description = "";
        [Browsable(true)]
        [DisplayName("説明")]
        [Description("説明")]
        public string Description
        {
            get { return _description; }
            set { _description = value; }
        }

#region ICloneable メンバ

        public object Clone()
        {
            return MemberwiseClone();
        }

#endregion

}