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", "");
订阅：
博文 (Atom)