2013年2月24日星期日

c#操作XML文件封装类



/// <summary>
     /// ***************************
     /// ****操作XML文件封装类 *****
     /// ****  V1.0 12-07-27   *****
     /// ****   狼鹰组织       *****
     /// ****    hyxwill       *****
     /// ***************************
     /// </summary>
     public sealed class ReadWriteXML
     {
         public bool QueryFolderIt(string path, string xmlName)
         {
             try
             {
                 FileInfo fi = new FileInfo(string.Concat(@"", path, xmlName));
                 return fi.Exists;
             }
             catch (Exception)
             {
                 return false;
             }
         }
         //是新建还是插入,自动判断
         public void ICAutoXML(string path, string xmlName, string value)
         {
           
             if (QueryFolderIt(string.Concat(@"", path), xmlName))
             {
                 InsertXML(string.Concat(@"",path), xmlName, value);
             }
             else
                 CreateXML(string.Concat(@"", path), xmlName, value);
         }
         public void CreateXML(string path, string xmlName, string value)
         {
             try
             {
                 XmlDocument xmlDoc = new XmlDocument();
                 //建立Xml的定义声明
                 XmlDeclaration dec = xmlDoc.CreateXmlDeclaration("1.0", "GB2312", null);
                 xmlDoc.AppendChild(dec);
                 //创建根节点
                 XmlElement root = xmlDoc.CreateElement("BGHelper");
                 xmlDoc.AppendChild(root);
                 //创建根节点的子节点Book
                 XmlNode User = xmlDoc.CreateElement("User");
                 //创建Book的子节点
                 XmlElement Name = xmlDoc.CreateElement("Name");
                 Name.InnerText = value;
                 User.AppendChild(Name);
                 //将Book添加到根节点上
                 root.AppendChild(User);
                 //保存文档(如果已经存在该文件,则更新之;如果没有,则创建该文件)
                 xmlDoc.Save(string.Concat(@"", path, xmlName));
             }
             catch
             {
                 throw;
             }
         }
         public void InsertXML(string path, string xmlName, string value)
         {
             try
             {
                 XmlDocument xmlDoc = new XmlDocument();
                 xmlDoc.Load(string.Concat(@"", path, xmlName));
                 XmlNode root = xmlDoc.SelectSingleNode("BGHelper");
                 XmlElement User = xmlDoc.CreateElement("User");
                 XmlElement Name = xmlDoc.CreateElement("Name");
                 Name.InnerText = value;
                 User.AppendChild(Name);
                 root.AppendChild(User);
                 xmlDoc.Save(string.Concat(@"", path, xmlName));
             }
             catch
             {
                 throw;
             }
         }
         public void UpdateXML(string path, string xmlName, string operValue, string newValue)
         {
             try
             {
                 XmlDocument xmlDoc = new XmlDocument();
                 xmlDoc.Load(string.Concat(@"", path, xmlName));
                 //获取Books节点的所有子节点
                 XmlNodeList list = xmlDoc.SelectSingleNode("BGHelper").ChildNodes;//User
                 bool breakAll = false;
                 //遍历所有子节点
                 foreach (XmlNode node in list)
                 {
                     if (breakAll) break;
                     //将子节点类型转换为XmlElement类型
                     XmlElement xe = (XmlElement)node;
                     foreach (XmlNode nd in xe.ChildNodes)
                     {
                         XmlElement x = (XmlElement)nd;
                         if (x.Name == "Name")
                         {
                             if (x.InnerText == operValue)
                             {
                                 x.InnerText = newValue;
                                 breakAll = true;
                                 break;
                             }
                         }
                     }
                 }
                 //保存
                 xmlDoc.Save(string.Concat(@"", path, xmlName));
             }
             catch
             {
                 throw;
             }
         }
         //删除
         public void DeleteXML(string path, string xmlName, string operValue)
         {
             try
             {
                 XmlDocument xmlDoc = new XmlDocument();
                 xmlDoc.Load(string.Concat(@"", path, xmlName));
                 //获取Books节点的所有子节点
                 XmlNodeList list = xmlDoc.SelectSingleNode("BGHelper").ChildNodes;//User
                 bool breakAll = false;
                 //遍历所有子节点
                 foreach (XmlNode node in list)
                 {
                     if (breakAll)
                         break;
                     //将子节点类型转换为XmlElement类型
                     XmlElement xe = (XmlElement)node;
                     foreach (XmlNode xn in node.ChildNodes)
                     {
                         XmlElement x = (XmlElement)xn;
                         if (x.Name == "Name")
                         {
                             if (x.InnerText == operValue)
                             {
                                 xe.RemoveAll();
                                 breakAll = true;
                                 break;
                             }
                         }
                     }
                 }
                 //保存
                 xmlDoc.Save(string.Concat(@"", path, xmlName));
             }
             catch
             {
                 throw;
             }
         }
         //所有
         public string ReadString(string path, string xmlName)
         {
             XmlTextReader reader = null;
             try
             {
                 reader = new XmlTextReader(string.Concat(@"", path, xmlName));
                 string str = string.Empty;
                 while (reader.Read())
                 {
                     if (reader.NodeType == XmlNodeType.Element)
                     {
                         if (reader.LocalName.Equals("Name"))
                         {
                             str += reader.ReadString() + ",";
                         }
                     }
                 }
                 if (str != string.Empty && str.Length > 0)
                     str = str.Substring(0, str.Length - 1);
                 return (str);
             }
             catch
             {
                 throw;
             }
             finally
             {
                 if (reader != null)
                 {
                     reader.Close();
                     reader = null;
                 }
             }
         }
         //所有
         public List<string> ReadStrings(string path, string xmlName)
         {
             XmlTextReader reader = null;
             try
             {
                 reader = new XmlTextReader(string.Concat(@"", path, xmlName));
                 List<string> str = new List<string>();// string.Empty;
                 string reads = "";
                 while (reader.Read())
                 {
                     if (reader.NodeType == XmlNodeType.Element)
                     {
                         if (reader.LocalName.Equals("Name"))
                         {
                             reads = reader.ReadString();
                             if (reads != "")
                                 str.Add(reads);
                         }
                     }
                 }
                 return (str);
             }
             catch
             {
                 throw;
             }
             finally
             {
                 if (reader != null)
                 {
                     reader.Close();
                     reader = null;
                 }
             }
         }
         //所有,自定义,适用于单节点多子节点
         public List<Entity.ListEntity> ReadStrings(string path, string xmlName, string[] xmlnodes)
         {
             XmlTextReader reader = null;
             try
             {
                 reader = new XmlTextReader(string.Concat(@"", path, xmlName));
                 List<Entity.ListEntity> str = new List<Entity.ListEntity>();// string.Empty;
                 Entity.ListEntity le = null;
                 while (reader.Read())
                 {
                     if (reader.NodeType == XmlNodeType.Element)
                     {
                         foreach(string nodes in xmlnodes)
                             if (reader.LocalName.Equals(nodes))
                             {
                                 le = new Entity.ListEntity();
                                 le.IDName = nodes;
                                 le.LEValue = reader.ReadString();
                                 str.Add(le);//str.Add(reader.ReadString());
                             }
                     }
                 }
                 return (str);
             }
             catch
             {
                 //throw;
                 return null;
             }
             finally
             {
                 if (reader != null)
                 {
                     reader.Close();
                     reader = null;
                 }
             }
         }
         public void ICAutoXML(string path, string xmlName,string nodesName, Entity.ListEntity[] value)
         {

             if (QueryFolderIt(string.Concat(@"", path), xmlName))
             {
                 InsertXML(string.Concat(@"", path),nodesName, xmlName, value);
             }
             else
                 CreateXML(string.Concat(@"", path),nodesName, xmlName, value);
         }
         //删除还是新建
         public void DCAutoXML(string path, string xmlName, string nodesName, Entity.ListEntity[] value)
         {

             if (QueryFolderIt(string.Concat(@"", path), xmlName))
             {
                 new Folder().DeleteFile(string.Concat(@"", path,"//", xmlName));
                 CreateXML(string.Concat(@"", path), xmlName,nodesName, value);
             }
             else
                 CreateXML(string.Concat(@"", path), xmlName,nodesName, value);
         }
         public void CreateXML(string path, string xmlName, string nodesName, Entity.ListEntity[] value)
         {
             try
             {
                 XmlDocument xmlDoc = new XmlDocument();
                 //建立Xml的定义声明
                 XmlDeclaration dec = xmlDoc.CreateXmlDeclaration("1.0", "GB2312", null);
                 xmlDoc.AppendChild(dec);
                 //创建根节点
                 XmlElement root = xmlDoc.CreateElement("BGHelper");
                 xmlDoc.AppendChild(root);
                 //创建根节点的子节点Book
                 XmlNode User = xmlDoc.CreateElement(nodesName);
                 for (int i = 0; i < value.Length; i++)
                 {
                     if (value[i].IDName != null&&value[i].LEValue!=null)
                     {
                         //创建Book的子节点
                         XmlElement Name = xmlDoc.CreateElement(value[i].IDName);
                         Name.InnerText = value[i].LEValue.ToString();
                         User.AppendChild(Name);
                     }
                 }
                 //将Book添加到根节点上
                 root.AppendChild(User);
                 //保存文档(如果已经存在该文件,则更新之;如果没有,则创建该文件)
                 xmlDoc.Save(string.Concat(@"", path, xmlName));
             }
             catch
             {
                 //throw;
             }
         }
         public void InsertXML(string path, string xmlName,string nodesName, Entity.ListEntity[] value)
         {
             try
             {
                 XmlDocument xmlDoc = new XmlDocument();
                 xmlDoc.Load(string.Concat(@"", path, xmlName));
                 XmlNode root = xmlDoc.SelectSingleNode("BGHelper");
                 XmlElement User = xmlDoc.CreateElement(nodesName);
                 for (int i = 0; i < value.Length; i++)
                 {
                     XmlElement Name = xmlDoc.CreateElement(value[i].IDName);
                     Name.InnerText = value[i].LEValue.ToString();
                     User.AppendChild(Name);
                 }
                 root.AppendChild(User);
                 xmlDoc.Save(string.Concat(@"", path, xmlName));
             }
             catch
             {
                 throw;
             }
         }
         //适用于单节点多子节点
         public void UpdateXML(string path, string xmlName,string nodesName, Entity.ListEntity[] operValue, Entity.ListEntity[] newValue)
         {
             try
             {
                 XmlDocument xmlDoc = new XmlDocument();
                 xmlDoc.Load(string.Concat(@"", path, xmlName));
                 //获取Books节点的所有子节点
                 XmlNodeList list = xmlDoc.SelectSingleNode(string.Concat("BGHelper//",nodesName)).ChildNodes;//User
                 bool breakAll = false;
                 //遍历所有子节点
                 foreach (XmlNode node in list)
                 {
                     if (breakAll) break;
                     //将子节点类型转换为XmlElement类型
                     XmlElement xe = (XmlElement)node;
                     foreach (XmlNode nd in xe.ChildNodes)
                     {
                         XmlElement x = (XmlElement)nd;
                         for (int i = 0; i < operValue.Length; i++)
                         {
                             if (x.Name == operValue[i].IDName)
                             {
                                     x.InnerText = newValue[i].LEValue.ToString();
                                     breakAll = true;
                                     break;                              
                             }
                         }
                     }
                 }
                 //保存
                 xmlDoc.Save(string.Concat(@"", path, xmlName));
             }
             catch
             {
                 throw;
             }
         }
         //删除  适用于单节点多子节点
         public void DeleteXML(string path, string xmlName, string nodesName, string operValue)
         {
             try
             {
                 XmlDocument xmlDoc = new XmlDocument();
                 xmlDoc.Load(string.Concat(@"", path, xmlName));
                 //获取Books节点的所有子节点
                 XmlNodeList list = xmlDoc.SelectSingleNode(string.Concat("BGHelper//", nodesName)).ChildNodes;//User
                 bool breakAll = false;
                 //遍历所有子节点
                 foreach (XmlNode node in list)
                 {
                     if (breakAll)
                         break;
                     //将子节点类型转换为XmlElement类型
                     XmlElement xe = (XmlElement)node;
                     foreach (XmlNode xn in node.ChildNodes)
                     {
                         XmlElement x = (XmlElement)xn;
                         if (x.Name == "Name")
                         {
                             xe.RemoveAll();
                             breakAll = true;
                             break;
                         }
                     }
                 }
                 //保存
                 xmlDoc.Save(string.Concat(@"", path, xmlName));
             }
             catch
             {
                 throw;
             }
         }
         //直写  keyName元素名   keyValue值
         public void WriteXML(string path, string xmlName, List<string> keyName, List<string> keyValue)
         {
             try
             {
                 XmlTextWriter writer = new XmlTextWriter(string.Concat(@"", path, xmlName), null);
                 writer.Formatting = Formatting.Indented;
                 writer.Indentation = 6;
                 writer.WriteStartDocument();
                 writer.WriteStartElement("BGHelper");
                 writer.WriteStartElement("User");
                 for (int i = 0; i < keyName.Count; i++)
                 {
                     writer.WriteElementString(keyName[i], keyValue[i]);
                     writer.WriteEndElement();
                 }
                 writer.WriteEndElement();
                 writer.WriteEndElement();
                 writer.WriteEndDocument();
                 writer.Close();
             }
             catch
             {

                 throw;
             }
         }
     }

C# 嵌入式资源


1、手动嵌入式资源
右键工程-添加-现有项-图片或者文本
点击图片或者文本-生成操作-嵌入的资源 //这一步非常重要
这样添加的图片或者文本就打包到exe中
可以这样访问:
Assembly assembly = GetType().Assembly;
System.IO.Stream streamSmall = assembly.GetManifestResourceStream("WindowsFormsApplication1.event.jpg");
//当作为一个资源被嵌入后,资源的完整名称会由项目的默认命名空间与文件名组成
Bitmap BackgroundImg = new Bitmap(streamSmall);
pictureBox1.Image = BackgroundImg;

Assembly assembly = GetType().Assembly;
System.IO.Stream streamSmall = assembly.GetManifestResourceStream("WindowsFormsApplication1.NewFolder1.TextFile1.txt");
StreamReader sr = new StreamReader(streamSmall);
string text = sr.ReadToEnd();
MessageBox.Show(text);

2、手动非嵌入式资源
右键工程-添加-现有项-图片或者文本
点击图片或者文本-生成操作-内容  //如果不进行任何操作,默认就是非嵌入式资源
这样添加的图片或者文本就打包到exe中
可以这样访问:
通过绝对路径和相对路径作为外部资源访问

/////////////////////////////////////////////
3、.net提供的访问嵌入式资源
Resources.resx,Form1.resx怎么使用?  //只需要添加,不用任何操作,默认就是嵌入式资源
每创建一个窗体就会自动生成一个.resx文件,可以在这个文件中加入字符串、图像、图标、文件等。
项目编译时,生成exe文件,这些图像、图标、文件等都会被写入 exe 文件中。

每一个窗体都有一个资源文件,并且项目有一个共用的资源文件,最好使用这个共用的资源文件,查看项目属性里,选中资源,
就可以加入自己要的资源 添加资源 - 添加现有文件,就可以反图片资源放进入。

读取这个图片资源,如已经加入了一个 a.bmp 图像,名称是 Pic

Bitmap bitmap = 项目的名称空间.Properties.Resources.Pic;
这就可能用了这个资源了。

具体的类位于,Properties目录中的 Resources.resx 文件中,打开看下就明白了。

资源文件也可以自己创建,像创建类一个。
这种嵌入式资源访问方式是.net内部提供的方式,与访问app.config方式类似,都是.net内部提供,当然也可以使用1自己手动创建

C#读写INI配置文件




  INI就是扩展名为"INI"的文件,其实他本身是个文本文件,可以用记事本打工,主要存放的是用户所做的选择或系统的各种参数。

  INI文件其实并不是普通的文本文件.它有自己的结构.由若干段落(SECTION)组成,在每个带括号的标题下面,是若干个以单个单词开头的关键字(KEYWORD)和一个等号,等号右边就是关键字的值(VALUE).例如:
[Section1]
    KeyWord1 = Value1
    KeyWord2 = Value2
    ...
[Section2]
    KeyWord3 = Value3
    KeyWord4 = Value4

  C#命名空间中没有直接读写INI的类,当然如果你把INT当成文本文件用System.IO类来读写算我没说.

  我现在介绍的是系统处理INI的方法.

  虽然C#中没有,但是在"kernel32.dll"这个文件中有Win32的API函数--WritePrivateProfileString()和GetPrivateProfileString()
C#声明INI文件的写操作函数WritePrivateProfileString():
[DllImport( "kernel32" )]
  private static extern long WritePrivateProfileString ( string section ,string key , string val
, string filePath ) ;
  参数说明:section:INI文件中的段落;key:INI文件中的关键字;val:INI文件中关键字的数值;filePath:INI文件的完整的路径和名称。
  C#申明INI文件的读操作函数GetPrivateProfileString():
[DllImport("kernel32")]
 private static extern int GetPrivateProfileString ( string section ,
  string key , string def , StringBuilder retVal ,
  int size , string filePath ) ;
参数说明:section:INI文件中的段落名称;key:INI文件中的关键字;def:无法读取时候时候的缺省数值;retVal:读取数值;size:数值的大小;filePath:INI文件的完整路径和名称。

下面是一个读写INI文件的类:
public class INIClass
{
 public string inipath;
 [DllImport("kernel32")]
 private static extern long WritePrivateProfileString(string section,string key,string val,string filePath);
 [DllImport("kernel32")]
 private static extern int GetPrivateProfileString(string section,string key,string def,StringBuilder retVal,int size,string filePath);
 /// <summary>
 /// 构造方法
 /// </summary>
 /// <param name="INIPath">文件路径</param>
 public INIClass(string INIPath)
 {
  inipath = INIPath;
 }
 /// <summary>
 /// 写入INI文件
 /// </summary>
 /// <param name="Section">项目名称(如 [TypeName] )</param>
 /// <param name="Key">键</param>
 /// <param name="Value">值</param>
 public void IniWriteValue(string Section,string Key,string Value)
 {
  WritePrivateProfileString(Section,Key,Value,this.inipath);
 }
 /// <summary>
 /// 读出INI文件
 /// </summary>
 /// <param name="Section">项目名称(如 [TypeName] )</param>
 /// <param name="Key">键</param>
 public string IniReadValue(string Section,string Key)
 {
  StringBuilder temp = new StringBuilder(500);
  int i = GetPrivateProfileString(Section,Key,"",temp,500,this.inipath);
  return temp.ToString();
 }
 /// <summary>
 /// 验证文件是否存在
 /// </summary>
 /// <returns>布尔值</returns>
 public bool ExistINIFile()
 {
  return File.Exists(inipath);
 }
}
来源:http://www.cnblogs.com/zzyyll2/archive/2007/11/06/950584.html

c#软件配置文件读写方式总结(一)


网址: http://www.cnphp.info/csharp-application-config-methods-part1.html
一般在软件与用户的交互过程中,很产生多个参数;这些参数需要在用户关闭软件后保存下来。传统的Windows程序使用ini文件来记录这些参数。
Ini文件的格式

[section1]
Key1=value
Key2=value

[sectionX]
Key3=value
Key4=value

在c#中,我们可以调用这些API来完成自定义用户配置文件的读写;也可以通过分析文本文件的方式来读写。

第一种方式:调用Windows API读写ini文件
在kernel32.dll中有一下几个常用的ini文件的操作函数,下面是它们在c#中封送的格式

        [System.Security.SuppressUnmanagedCodeSecurity]
        private static class NativeMethods{
            [DllImport("kernel32.dll", CharSet = CharSet.Auto)]
            public static extern int GetPrivateProfileSectionNames(IntPtr lpszReturnBuffer, uint nSize, string lpFileName);
            [DllImport("kernel32.dll", CharSet = CharSet.Auto)]
            public static extern uint GetPrivateProfileString(string lpAppName,string lpKeyName, string lpDefault, StringBuilder lpReturnedString,
int nSize, string lpFileName);
            [DllImport("kernel32.dll", CharSet = CharSet.Auto)]
            public static extern uint GetPrivateProfileString(string lpAppName,
string lpKeyName, string lpDefault, [In, Out] char[] lpReturnedString,int nSize,
string lpFileName);
            [DllImport("kernel32.dll", CharSet = CharSet.Auto)]
            public static extern int GetPrivateProfileString(string lpAppName, string lpKeyName, string lpDefault, IntPtr lpReturnedString, uint nSize,string lpFileName);
            [DllImport("kernel32.dll", CharSet = CharSet.Auto)]
            public static extern int GetPrivateProfileInt(string lpAppName,string lpKeyName, int lpDefault, string lpFileName);
            [DllImport("kernel32.dll", CharSet = CharSet.Auto)]
            public static extern int GetPrivateProfileSection(string lpAppName, IntPtr lpReturnedString, uint nSize, string lpFileName);
            [DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
            public static extern bool WritePrivateProfileString(string lpAppName, string lpKeyName, string lpString, string lpFileName); }
具体的使用方法笔者也不在这里一一赘述了,感兴趣的朋友可以自行翻阅下API手册。
第二种方式:文本分析读写ini文件
这种方法很常用,读取ini文件后逐行分析,笔者在这里给出加载ini文件的代码。默认将分析结果保存在一个Dictionary>的泛型里。Item是自定义的一个结构变量。

public struct Item
{
    public string Field { get; set; } //键
    public object Value { get; set; }  //值
}

        public void Load(string iniFile)
        {
            // 读取文件,剔除空行和注释行
            var rawFileData =               System.IO.File.ReadAllLines(iniFile).Where(line=> !line.Equals(string.Empty) && !line.StartsWith(";"));
            // 定义一个[section]结
            var currentSection = string.Empty;
            // 读取每行
            foreach (var line in rawFileData)
            {
                // 查找section
                if (line.StartsWith("[")) {
                    currentSection = line.TrimStart('[').TrimEnd(']');
                    if (!SectionExists(currentSection)) Add(currentSection);
                }
                else{
                    // 查找key=value键值对
                    var lineData = line.Split('=');
                    for (var i = 0; i < lineData.Count(); i++)
                        lineData[i] = lineData[i].Trim();
                    // Try some conversions to store the item as their natural format.
                    bool boolTest;
                    decimal numTest;
                    // 分析值的类型为布尔量还是数字量
                    if(Boolean.TryParse(lineData[1], out boolTest)){
                        this[currentSection].Add(new Item { Field = lineData[0], Value = boolTest });
//继续
                        continue;

                    }
                    // 分析数字量
                    if (Decimal.TryParse(lineData[1], out numTest)){
                        this[currentSection].Add(new Item { Field = lineData[0], Value = numTest });
                        // 继续
                        continue;
                    }
                    // 默认为值类型为字符串
                    this[currentSection].Add(new Item { Field = lineData[0], Value = lineData[1] });
                }
            }
        }

C# 读取保存App.config配置文件的完整源码参考




   最近出差在北京做一个小项目,项目里需要读取配置文件的小功能,觉得挺有参考意义的就把代码发上来给大家参考一下。我们选择了直接用微软的读取配置文件的方法。


这个是程序的运行设计效果,就是把这些参数可以进行灵活设置,灵活保存设置状态。

程序编译后自动会产生相应的配置文件,是跟项目的名称一样的配置文件。

读取配置文件及保存配置的具体代码参考如下,希望能给你节省一些时间,直接复制粘贴这个代码就可以用了:


//------------------------------------------------------------
// All Rights Reserved , Copyright (C) 2010 , CDPF , Ltd.
//------------------------------------------------------------

using System;
using System.Configuration;
using System.Windows.Forms;
using Utilities;

namespace DirectSeeding
{
    /// <summary>
    ///    FrmConfig
    /// 读取配置文件
    ///
    /// 修改纪录
    ///
    ///        2011.01.14 版本:   1.0 JiRiGaLa 完善程序的注释等、从新整理代码。
    ///  
    /// 版本:1.0
    ///
    /// <author>
    ///        <name>JiRiGaLa</name>
    ///        <date>2011.01.14</date>
    /// </author>
    /// </summary>
    public partial class FrmConfig : Form
    {
        public FrmConfig()
        {
            InitializeComponent();
        }

        /// <summary>
        /// 读取配置文件
        /// </summary>
        private void GetConfig()
        {
            this.txtWriteFileName.Text = ConfigurationManager.AppSettings["WriteFileName"];
            this.txtWritePath.Text = ConfigurationManager.AppSettings["WritePath"].Replace("|", Environment.NewLine);
            this.txtPostMessageURL.Text = ConfigurationManager.AppSettings["PostMessageURL"];
            this.txtLeasedLineURL.Text = ConfigurationManager.AppSettings["LeasedLineURL"];
        }

        private void FrmDirectSeeding_Load(object sender, EventArgs e)
        {
            this.GetConfig();
        }

        /// <summary>
        /// 保存配置文件
        /// </summary>
        private void SaveConfig()
        {
            // 写入参数设置
            Configuration configuration = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
            configuration.AppSettings.Settings["WriteFileName"].Value = this.txtWriteFileName.Text;
            configuration.AppSettings.Settings["WritePath"].Value = this.txtWritePath.Text.Trim().Replace(Environment.NewLine, "|");
            configuration.AppSettings.Settings["PostMessageURL"].Value = this.txtPostMessageURL.Text;
            configuration.AppSettings.Settings["LeasedLineURL"].Value = this.txtLeasedLineURL.Text;
            configuration.Save();

            // 重新读取参数
            ConfigurationManager.RefreshSection("appSettings");
            WriteFile.WriteFileName = ConfigurationManager.AppSettings["WriteFileName"];
            WriteFile.WritePath = ConfigurationManager.AppSettings["WritePath"].Split('|');
            PostMessage.PostMessageURL = ConfigurationManager.AppSettings["PostMessageURL"];
            // PostMessage.LeasedLineURL = ConfigurationManager.AppSettings["LeasedLineURL"];
        }

        private void btnSavaConfig_Click(object sender, EventArgs e)
        {
            // 保存设置
            SaveConfig();
        }
    }
}





将权限管理、工作流管理做到我能力的极致,一个人只能做好那么很少的几件事情。

如何用c#读写配置文件


读配置很简单,可以用ConfigurationManager.AppSettings[key] 来读出,
可是写配置文件时,如果写成这样
ConfigurationManager.AppSettings[key] = "111";
总是提示只读,那么该怎么办呢?

[c-sharp] view plaincopy
using System;
using System.Collections.Generic;
using System.Text;
using System.Configuration;
 
namespace BQKJ.Common
{
    /// <summary>
    /// 对exe.Config文件中的appSettings段进行读写配置操作
    /// 注意:调试时,写操作将写在vhost.exe.config文件中
    /// </summary>
    public class ConfigAppSettings
    {
        /// <summary>
        /// 写入值
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        public static void SetValue(string key, string value)
        {
            //增加的内容写在appSettings段下 <add key="RegCode" value="0"/>
            System.Configuration.Configuration config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
            if (config.AppSettings.Settings[key] == null)
            {
                config.AppSettings.Settings.Add(key, value);
            }
            else
            {
                config.AppSettings.Settings[key].Value = value;
            }
            config.Save(ConfigurationSaveMode.Modified);
            ConfigurationManager.RefreshSection("appSettings");//重新加载新的配置文件  
        }
 
        /// <summary>
        /// 读取指定key的值
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public static string GetValue(string key)
        {  
            System.Configuration.Configuration config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
            if (config.AppSettings.Settings[key] == null)
                return "";
            else
                return config.AppSettings.Settings[key].Value;
        }
 
    }
}


其实也很简单,用这两个封装过的方法就可以了。
需要注意的是,在IDE调试时,写入的配置文件其实是写在了.vshost.exe.config文件中,所以你在.exe.config中是看不到的。只有直接运行exe文件时,才会正确写入到.exe.config中。
分享到:
上一篇:SQL日期格式化应用大全

C# 开机启动




C# winform程序设置开机启动,当读取配置文件,或者加载图片如果设置的是相对路径时,开机启动时会出现问题(直接运程程序是没问题的)。这是因为开机启动的程序要使用绝对路径,相对路径不行。我们可以通过Application .StartupPath属性经过处理得到文件的绝对路径问题就解决了。

C# 通过读写注册表来设置开机启动想方法很简单,网上很多:


        /// <summary>
        /// 开机启动项
        /// </summary>
        /// <param name="Started">是否启动</param>
        /// <param name="name">启动值的名称</param>
        /// <param name="path">启动程序的路径</param>
        public void RunWhenStart(bool Started, string name, string path)
        {
            RegistryKey HKLM = Registry.LocalMachine;
            RegistryKey Run = HKLM.CreateSubKey(@"SOFTWARE/Microsoft/Windows/CurrentVersion/Run");
            if (Started == true)
            {
                try
                {
                    Run.SetValue(name, path);
                    HKLM.Close();
                }
                catch//没有权限会异常
                {}
            }
            else
            {
                try
                {
                    Run.DeleteValue(name);
                    HKLM.Close();
                }
                catch//没有权限会异常
                {}
            }
        }
或者直接:
//添加启动
RegistryKey ms_run = Registry.LocalMachine.OpenSubKey("SOFTWARE//Microsoft//Windows//CurrentVersion//Run", true);
                    ms_run.SetValue("mistysoft", Application.ExecutablePath.ToString());
//删除启动(设为控,注册表项还在)
RegistryKey ms_run = Registry.LocalMachine.OpenSubKey("SOFTWARE//Microsoft//Windows//CurrentVersion//Run", true);
ms_run.SetValue("mistysoft", "");

收藏 请教C# Process启动CMD命令


回复次数:5