开发笔记-Mikel-第310页

[转载]string.Format出现异常"输入的字符串格式有误"的解决方法 - 凡夫·俗子 - 博客园

2015-04-16mikel阅读(1605)

[转载]string.Format出现异常”输入的字符串格式有误”的解决方法 – 凡夫·俗子 – 博客园.天在做项目时，碰到一个很奇怪的问题，我使用string.Format居然报“输入的字符串格式有误”的错误，我调了很久，还是不对，不明白错在哪里，后来还是google了一下，原来我在字符串中出现了”{“字符。而”{“字符若出现在string.Format中是必需转义的，也就是要用两个”{{“代表一个”{“，同时双下面把我查找到的解决方法的相关文章一同粘贴出来。

一、转义

C# 中使用类似 {0}, {1:yyyy-MM-dd} 这样的格式占位符，如果被格式化字符串本身包含 { 或者 } 怎么办呢？答案是：用两个 { 或者 }连写表示单个。

例如
string str1 = String.Format(“{{Hello}}, {0}, Now is {{{1:yyyy-MM-dd HH:mm:ss}}}”,
“Jinglecat”,
DateTime.Now); // {Hello}, Jinglecat, Now is {2007-07-18 23:06:35}
string str2 = String.Format(“{Hello}, {0}, Now is {{1:yyyy-MM-dd HH:mm:ss}}”,
“Jinglecat”,
DateTime.Now); // –> System.FormatException: 输入字符串的格式不正确。

事实上，很多情况下带特殊含义的字符都是这样转义的：如，
C# 中，当字符串常量带 @ 前导的时候，用两个 ” 连写表示一个 ” (半角双引号）
string str3 = @”My UserName is “”Jinglecat””.”; // My UserName is “Jinglecat”.
//string str4 = @”My UserName’s “Jinglecat””; // error CS1002: 应输入 ;
//string str5 = @”My UserName’s \”Jinglecat\””; // error CS1002: 应输入 ;
SQL 字符串常量，用两个 ‘ 连写表示一个 ‘ (半角单引号）
DECLARE @str6 varchar(100)
SET @str6 = ‘My UserName is ‘‘Jinglecat’‘.’
PRINT @str6 — My UserName is ‘Jinglecat’.
正则表达式中用，两个 $ 连写表示一个 $ (dollar)
二、String Formatting in C#

基本内容是：可以在 Console.WriteLine（以及 String.Format，它被 Console.WriteLine 调用）中的格式字符串内的括号中放入非索引数字的内容。格式规范的完整形式如下：

{index [, width][:formatstring]}

其中，index 是此格式程序引用的格式字符串之后的参数，从零开始计数；width（如果有的话）是要设置格式的字段的宽度（以空格计）。width 取正数表示结果右对齐，取负数则意味着数字在字段中左对齐。（请参阅下面的前两个示例。）

formatstring 是可选项，其中包含有关设置类型格式的格式说明。如果对象实现 IFormattable，formatstring 就会传递给对象的 Format 方法（在 Beta 2 和后续版本中，该方法的签名变为 ToString(string, IFormatProvider)，但功能不变）。如果对象不实现 IFormattable，就会调用 Object.ToString()，而忽略 formatstring。

另请注意，在 Beta 1 中不区分当前语言的 ToString 在 Beta 2 和后续版本中“将”区分语言。例如，对于用“.”分隔千位，用“,”分隔小数的国家，1,234.56 将会格式化成 1.234,56。如果您需要结果无论在什么语言下都是一样的，就请使用 CultureInfo.InvariantCulture 作为语言。

若要获取有关格式的完整信息，请查阅“.NET 框架开发人员指南”中的格式概述（英文）。

例如：String.Format(“[{0,-10:0##.#0}]”, 14)=”[014.00 ]”;-10表示左对齐，总共占10位，不够了补空字符。

Strings

There really isn’t any formatting within a strong, beyond it’s alignment. Alignment works for any argument being printed in a String.Format call.

Sample	Generates
String.Format(”->{1,10}<-”, “Hello”);	-> Hello<-
String.Format(”->{1,-10}<-”, “Hello”);	->Hello <-

Numbers

Basic number formatting specifiers:

Specifier	Type	Format	Output (Passed Double 1.42)	Output (Passed Int -12400)
c	Currency	{0:c}	$1.42	-$12,400
d	Decimal (Whole number)	{0:d}	System.FormatException	-12400
e	Scientific	{0:e}	1.420000e+000	-1.240000e+004
f	Fixed point	{0:f}	1.42	-12400.00
g	General	{0:g}	1.42	-12400
n	Number with commas for thousands	{0:n}	1.42	-12,400
r	Round trippable	{0:r}	1.42	System.FormatException
x	Hexadecimal	{0:x4}	System.FormatException	cf90

注：{0:n2}表示千位用，隔开小说点后面两位

Custom number formatting:

Specifier	Type	Example	Output (Passed Double 1500.42)	Note
0	Zero placeholder	{0:00.0000}	1500.4200	Pads with zeroes.
#	Digit placeholder	{0:(#).##}	(1500).42
.	Decimal point	{0:0.0}	1500.4
,	Thousand separator	{0:0,0}	1,500	Must be between two zeroes.
,.	Number scaling	{0:0,.}	2	Comma adjacent to Period scales by 1000.
%	Percent	{0:0%}	150042%	Multiplies by 100, adds % sign.
e	Exponent placeholder	{0:00e+0}	15e+2	Many exponent formats available.
;	Group separator	see below

The group separator is especially useful for formatting currency values which require that negative values be enclosed in parentheses. This currency formatting example at the bottom of this document makes it obvious:

注：

如果相应的数字是前导零或尾随零，“#”字符就会替换为空值。无论相应数字的值如何，“0”字符都会被替换为零字符 — 因此，数字将会被零填补。句号（如果有的话）表示小数分隔符的位置。

那么，为什么要同时使用这些字母，比如“###0.##”？如果要设置格式的值恰好为零，“#” 图片字符就被替换为“无”（连零字符也不是）。您可能“总是”希望在小数点的左边至少有一个“0”，否则，如果值为零，字段就没有输出。换言之，仅包含 “#”字符，一个“0”也没有的格式常被认为是一个编程错误。

例如

string.Format(“{0:###.##},14″)=”14”;

string.Format(“{0:0##.#0},14″)=”014.00”

Dates

Note that date formatting is especially dependant on the system’s regional settings; the example strings here are from my local locale.

Specifier	Type	Example (Passed System.DateTime.Now)
d	Short date	10/12/2002
D	Long date	December 10, 2002
t	Short time	10:11 PM
T	Long time	10:11:29 PM
f	Full date & time	December 10, 2002 10:11 PM
F	Full date & time (long)	December 10, 2002 10:11:29 PM
g	Default date & time	10/12/2002 10:11 PM
G	Default date & time (long)	10/12/2002 10:11:29 PM
M	Month day pattern	December 10
r	RFC1123 date string	Tue, 10 Dec 2002 22:11:29 GMT
s	Sortable date string	2002-12-10T22:11:29
u	Universal sortable, local time	2002-12-10 22:13:50Z
U	Universal sortable, GMT	December 11, 2002 3:13:50 AM
Y	Year month pattern	December, 2002

The ‘U’ specifier seems broken; that string certainly isn’t sortable.

Custom date formatting:

Specifier	Type	Example	Example Output
dd	Day	{0:dd}	10
ddd	Day name	{0:ddd}	Tue
dddd	Full day name	{0:dddd}	Tuesday
f, ff, …	Second fractions	{0:fff}	932
gg, …	Era	{0:gg}	A.D.
hh	2 digit hour	{0:hh}	10
HH	2 digit hour, 24hr format	{0:HH}	22
mm	Minute 00-59	{0:mm}	38
MM	Month 01-12	{0:MM}	12
MMM	Month abbreviation	{0:MMM}	Dec
MMMM	Full month name	{0:MMMM}	December
ss	Seconds 00-59	{0:ss}	46
tt	AM or PM	{0:tt}	PM
yy	Year, 2 digits	{0:yy}	02
yyyy	Year	{0:yyyy}	2002
zz	Timezone offset, 2 digits	{0:zz}	-05
zzz	Full timezone offset	{0:zzz}	-05:00
:	Separator	{0:hh:mm:ss}	10:43:20
/	Separator	{0:dd/MM/yyyy}	10/12/2002

Enumerations

Specifier	Type
g	Default (Flag names if available, otherwise decimal)
f	Flags always
d	Integer always
x	Eight digit hex.

Some Useful Examples

String.Format(”{0:$#,##0.00;($#,##0.00);Zero}”, value);

This will output “$1,240.00″ if passed 1243.50. It will output the same format but in parentheses if the number is negative, and will output the string “Zero” if the number is zero.

String.Format(”{0:(###) ###-####}”, 8005551212);

This will output “(800) 555-1212″.

转自：http://blog.zxbc.cn/html/59/959-2512.html

麻雀虽小五脏俱全

2015-04-15mikel阅读(1311)

很多时候，程序员面临的需求就是这么个问题，客户觉得简单的不行的玩意儿，到你那怎么就那么多问题，可现实中的问题不是什么都可以用程序能够办到的，因为整个流程当中变数最大的因素就是人为因素，你想不到的一个很小的问题就会让整个程序陷入混乱之中，所以说很多人都说程序员想得太多了，想得太复杂了。

变化是不可能消除的，但是可以避免影响最大化，健全的程序应该是将变化造成的混乱的机会降到最低，很多时候不得不让人工参与进来，程序本来就是一个矛盾的综合体，想要解放人工又不得不依赖人工处理。

现在互联网变得普及了，人们就认为网络平民化软件也更加智能了，的确这是个发展趋势，人工智能迟早会走进千家万户，机器人也无可避免的会出现来解放人工的重复劳动，但是绝对不会取代人，因为很多时候人是这个变化世界的起因，形形色色的人改变了这个世界也让这个世界充满了变化因素，如果哪天人的行为和思想不变了，那这个世界就是个机器了。

没有不变的需求，所以会有人提出敏捷开发、迭代、重构，这些都是程序员用于适应变化想出的办法，当客户提出一个需求来的时候也就是变化的开始，从每个需求点都可以深挖出更多的需求，当你被缠住的时候你就输了，所以要跳出来看看是不是真的需求，或者需求背后客户想要什么？这样可能会好些，不要拘泥于形式，把握住根本就行了。

[转载]C#读写TxT文件 - 碧风Befeng - 博客园

2015-04-15mikel阅读(1389)

[转载]C#读写TxT文件 – 碧风Befeng – 博客园.

文/嶽永鹏

WPF 中读取和写入TxT 是经常性的操作，本篇将从详细演示WPF如何读取和写入TxT文件。

首先，TxT文件希望逐行读取，并将每行读取到的数据作为一个数组的一个元素，因此需要引入List<string> 数据类型。且看代码：

 public List<string> OpenTxt(TextBox tbx)
        {
            List<string> txt = new List<string>();
            OpenFileDialog openFile = new OpenFileDialog();
            openFile.Filter = "文本文件(*.txt)|*.txt|(*.rtf)|*.rtf";
            if (openFile.ShowDialog() == true)
            {
                tbx.Text = "";
                using (StreamReader sr = new StreamReader(openFile.FileName, Encoding.Default))
                {
                    int lineCount = 0;
                    while (sr.Peek() > 0)
                    {
                        lineCount++;
                        string temp = sr.ReadLine();
                        txt.Add(temp);
                    }
                }

            }
            return txt;
        }

其中

 1  using (StreamReader sr = new StreamReader(openFile.FileName, Encoding.Default))
 2 {
 3         int lineCount = 0;
 4         while (sr.Peek() > 0)
 5               {
 6                     lineCount++;
 7                     string temp = sr.ReadLine();
 8                     txt.Add(temp);
 9                }
10 }

StreamReader 是以流的方式逐行将TxT内容保存到List<string> txt中。

其次，对TxT文件的写入操作，也是将数组List<string> 中的每个元素逐行写入到TxT中，并保存为.txt文件。且看代码：

 1 SaveFileDialog sf = new SaveFileDialog();
 2                 sf.Title = "Save text Files";
 3                 sf.DefaultExt = "txt";
 4                 sf.Filter = "txt files (*.txt)|*.txt|All files (*.*)|*.*";
 5                 sf.FilterIndex = 1;
 6                 sf.RestoreDirectory = true;
 7                 if ((bool)sf.ShowDialog())
 8                 {
 9                     using (FileStream fs = new FileStream(sf.FileName, FileMode.Create))
10                     {
11                         using (StreamWriter sw = new StreamWriter(fs, Encoding.Default))
12                         {
13                             for (int i = 0; i < txt.Count; i++)
14                             {
15                                 sw.WriteLine(txt[i]);
16                             }
17                         }
18                     }
19 
20                 }

而在这之中，相对于读入TxT文件相比，在写的时候，多用到了 FileStream类。

[转载]实现动态的XML文件读写操作(依然带干货) - 悲夢 - 博客园

2015-04-15mikel阅读(1153)

[转载]实现动态的XML文件读写操作(依然带干货) – 悲夢 – 博客园.

前言

最近由于项目需求,需要读写操作XML文件,并且存储的XML文件格式会随着导入的数据不同而随时改变(当然导入的数据还是有一定约束的),这样我们要预先定义好XML文件的格式就不太现实了,如何实现不管导入的数据如何变化,我都能正确的把数据解析出来,这就是要实现的动态的XML文件读写操作！如果大家有更好的方式欢迎交流！

具体实现

本文所实现的读写XML文件是使用序列话的方式,具体博文请参考：http://www.cnblogs.com/fish-li/archive/2013/05/05/3061816.html,当然如果只是序列化操作XML文件的话,只需要看这篇博文,也就不需要这篇文章了！

了解了如何序列化操作XML文件了话,你就会知道,要想写入和读取XML文件,我们就需要定义好一个数据类型(这一点很重要),但是问题就出现了,如果我们在编程时就定义好一个数据类型了,当导入的数据改变了,这个数据类型就不适合了,接下来就来解决这个问题

实现一：根据需求创建动态数据类型

废话先不多说,先上代码,代码说话,往往比语言来的直接也更容易懂

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Reflection;
using System.IO;
using System.Diagnostics;

namespace XMLDemo
{
    public class ReflectClass
    {
        //保存动态生成并编译的类的type对象   
        Type theType = null;
        //保存动态生成类的实例   
        object theClass = null;
        public Assembly DoOperation()
        {
            //未初始化   
            if (theType == null)
            {
                //初始化   
                return GenerateCode();
            }
            return null;
        }
        private Assembly GenerateCode()
        {
            //文件名   
            string fileName = "XmlClass";
            ////从编译好的dll文件load一个Assembly   
            //Assembly a = Assembly.LoadFrom(fileName + ".dll");

            //从编译好的dll文件load一个Assembly
            byte[] filedata = File.ReadAllBytes(fileName + ".dll");
            Assembly a = Assembly.Load(filedata);                      //此方法在使用完dll文件后会自动释放资源
            return a;
        }
        public Assembly DoOperation(List<ExcelData> list)
        {
            //未初始化   
            if (theType == null)
            {
                //初始化   
                return GenerateCode(list);
            }
            return null;
        }
        private Assembly GenerateCode(List<ExcelData> list)
        {
            //文件名   
            string fileName = "XmlClass";
            //打开文件，如果不存在，则创建   
            Stream s = File.Open(fileName + ".cs", FileMode.Create);
            //创建一个StreamWriter来写入数据   
            StreamWriter wrtr = new StreamWriter(s);

            #region 写入动态创建类的源代码 
            wrtr.WriteLine("// 动态创建的XmlClass类文件");

            //类名,此类是为序列化读取XML文件创建的类文件   
            string className = "XmlClass";
            wrtr.WriteLine("using System;");
            wrtr.WriteLine("using System.Xml.Serialization;");
            wrtr.WriteLine("public class {0}", className);
            wrtr.WriteLine("{");
            var ch = (from num in list select num.Mark).Distinct().ToList();
            foreach (var n in ch)
            {
                wrtr.WriteLine("\tpublic " + n + " " + n);
                wrtr.WriteLine("\t{");
                wrtr.WriteLine("\t\tget;set;");
                wrtr.WriteLine("\t}");
            }
            wrtr.WriteLine("}");
            foreach (var n in ch)
            {
                wrtr.WriteLine("public class {0}", n);
                wrtr.WriteLine("{");
                var nlist = from num in list where (num.Mark == n) select num;
                foreach (var m in nlist)
                {
                    wrtr.WriteLine("\tpublic string " + m.Name);
                    wrtr.WriteLine("\t{");
                    wrtr.WriteLine("\t\tget;set;");
                    wrtr.WriteLine("\t}");
                }
                wrtr.WriteLine("}");
            }
            //关闭StreamWriter和文件   
            wrtr.Close();
            s.Close(); 
            #endregion

            //启动进程编译源文件   
            //指定参数   
            ProcessStartInfo psi = new ProcessStartInfo();
            File.Delete(fileName + ".dll");                   //重新导入数据时删除旧的DLL文件
            //启动cmd.exe   
            psi.FileName = "cmd.exe";
            //cmd.exe的参数,/c－close,完成后关闭;后为参数，指定cmd.exe使用csc来编译刚才生成的源文件   
            string compileString = "/c C:\\WINDOWS\\Microsoft.NET\\Framework\\v4.0.30319\\csc.exe /optimize+ /target:library {0}.cs";
            psi.Arguments = String.Format(compileString, fileName);
            //运行时的风格－最小化   
            psi.WindowStyle = ProcessWindowStyle.Minimized;
            //启动进程   
            Process proc = Process.Start(psi);
            //指定当前在此进程退出前等待   
            proc.WaitForExit();
            //从编译好的dll文件load一个Assembly
            byte[] filedata = File.ReadAllBytes(fileName + ".dll");
            Assembly a = Assembly.Load(filedata);                      //此方法在使用完dll文件后会自动释放资源
            //Assembly a = Assembly.LoadFrom(fileName + ".dll");       //这样使用dll文件会一直被占用,不会释放,造成重新生成前无法自动删除
            //删除源文件   
            //File.Delete(fileName + ".cs");
            return a;
        }
    }
}

以上 ReflectClass类帮助我们实现了通过导入的数据来创建一个供我们使用的编译好的类文件,下面主要讲如果通过这个使用这个编译好的dll文件来写入我们的XML文件

写入动态创建类的源代码那一块真是费了我不少脑细胞,感觉跟写模板类似的！(大家如果根据自己需求改写的话,应该就会体会到)

实现二：通过反射得到动态创建的数据类型并序列化写入XML文件

还是先上代码,XMLHelper帮助类可以去上面的连接去下载,也可以在我提供的Demo里下载,我只根据我的需要添加了一个方法,下面我的一个普通帮助类CommonHelper

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;

namespace XMLDemo
{
    public class CommonHelper
    {
        /// <summary>
        /// 写文件
        /// </summary>
        /// <param name="filePath">文件名</param>
        /// <param name="Context">写的内容</param>
        /// <returns>是否成功</returns>
        public static bool FileWriter(string filePath, string Context)
        {
            try
            {
                //打开文件，如果不存在，则创建   
                Stream s = File.Open(filePath, FileMode.Create);
                //创建一个StreamWriter来写入数据   
                StreamWriter wrtr = new StreamWriter(s);
                //写入动态创建类的源代码   
                wrtr.WriteLine(Context);
                wrtr.Close();
                s.Close();
                return true;
            }
            catch (Exception)
            {

                return false;
            }
        }
        /// <summary>
        /// 读文件
        /// </summary>
        /// <param name="filePath">文件名</param>
        /// <returns>返回读的内容</returns>
        public static string FileRead(string filePath)
        {
            try
            {
                //打开文件，如果不存在，则创建   
                Stream s1 = File.Open(filePath, FileMode.Open);
                //创建一个StreamWriter来写入数据   
                StreamReader reader = new StreamReader(s1);
                //写入动态创建类的源代码   
                string xml = reader.ReadToEnd();
                reader.Close();
                s1.Close();
                return xml;
            }
            catch (Exception)
            {
                return null;
            }
        }
        /// <summary>
        /// 根据数据创建类,并得到动态创建类的集合
        /// </summary>
        /// <param name="list">导入的数据集合</param>
        /// <returns>返回类的集合</returns>
        public static List<object> GetXmlClassInstances(List<ExcelData> list)
        {
            List<object> o = new List<object>();
            ReflectClass t = new ReflectClass();
            var assemblys = t.DoOperation(list);
            Type[] types = assemblys.GetExportedTypes();
            foreach (Type type in types)
            {
                o.Add(assemblys.CreateInstance(type.Name));
            }
            return o;
        }
        /// <summary>
        /// 得到动态创建类的集合
        /// </summary>
        /// <returns></returns>
        public static List<object> GetXmlClassInstances()
        {
            List<object> o = new List<object>();
            ReflectClass t = new ReflectClass();
            var assemblys = t.DoOperation();
            Type[] types = assemblys.GetExportedTypes();
            foreach (Type type in types)
            {
                o.Add(assemblys.CreateInstance(type.Name));
            }
            return o;
        }
    }
}

主要是一个GetXmlClassInstances(List<ExcelData> list)：根据数据创建类,并得到动态创建类的集合

一个是GetXmlClassInstances()：得到已经创建好的动态类的集合

下面是一个数据实体类,也就是我们所规范的数据格式

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace XMLDemo
{
    /// <summary>
    /// 数据实体类
    /// </summary>
    public class ExcelData
    {
        /// <summary>
        /// 根节点
        /// </summary>
        public string Mark { get; set; }
        /// <summary>
        /// 子节点
        /// </summary>
        public string Name { get; set; }

        /// <summary>
        /// 子节点对应值
        /// </summary>
        public string Value { get; set; }
    }
}

准备工作就绪后就可以进行XML文件的写入了,依然是废话不多说，上代码：

       private void btnWrite_Click(object sender, EventArgs e)
        {
            List<object> XmlClassInstances = CommonHelper.GetXmlClassInstances(listData);
            if (InsertXmlClass(XmlClassInstances, listData) == false)
            {
                MessageBox.Show("数据导入失败");
                return;
            }
        }
        private bool InsertXmlClass(List<object> o, List<ExcelData> list)
        {
            
            for (int i = 1; i < o.Count; i++)
            {
                //给类的属性赋值
                var nlist = from num in list where (num.Mark == o[i].GetType().Name) select num;
                foreach (var model in nlist)
                {
                    PropertyInfo propinfo = o[i].GetType().GetProperty(model.Name);
                    propinfo.SetValue(o[i], model.Value, null);
                }
            }
            var XmlClass = o[0];               //默认第一个类为主体类,主体类的属性为其他类
            var tt = XmlClass.GetType();
            for (int i = 1; i < o.Count; i++)
            {
                //给主体类的属性赋值
                PropertyInfo propinfo = tt.GetProperty(o[i].GetType().Name);
                propinfo.SetValue(XmlClass, o[i], null);
            }
            //序列化主体类,得到序列化字符串
            string xml = XmlHelper.XmlSerialize(XmlClass, Encoding.UTF8);
            string FilePath = "QMSPlan.XML";
            if (CommonHelper.FileWriter(FilePath, xml) == false)
            {
                return false;
            }
            return true;
        }

上面的代码可能有点绕,大家可以单步调试去理解,当时写的时候崩溃了几次,最后才调试好,不知道有什么更好的写法！

实现三：序列化读出XML文件

感觉用语言都表达不出来,还是直接上代码吧

       private void btnRead_Click(object sender, EventArgs e)
        {
            List<ExcelData> listRead = new List<ExcelData>();
            var XmlClass = GetXmlClass();
            if (XmlClass == null)
            {
                MessageBox.Show("数据读取失败");
                return;
            }
            //获取所有主体类的属性(即所有的子类集合)
            PropertyInfo[] ps = XmlClass.GetType().GetProperties();
            foreach (var n in ps)
            {             
                //得到子类
                var m = n.GetValue(XmlClass, null);
                //获取子类的所有属性                
                PropertyInfo[] x = m.GetType().GetProperties();
                foreach (var y in x)
                {
                    ExcelData model = new ExcelData();
                    model.Mark = m.GetType().Name;
                    model.Name = y.Name;
                    model.Value = y.GetValue(m, null).ToString();
                    listRead.Add(model);
                }                
            }
        }
        private object GetXmlClass()
        {
            List<object> o = CommonHelper.GetXmlClassInstances();
            var XmlClass = o[0];               //默认第一个类为主体类

            string FilePath = "QMSPlan.XML";
            string xml = CommonHelper.FileRead(FilePath);
            if (xml == null)
            {
                return null;
            }
            XmlClass = XmlHelper.XmlDeserialize(XmlClass.GetType(), xml, Encoding.UTF8);
            return XmlClass;
        }

上面大量运用了反射的特性,就是因为实现动态读取数据类型而造成的！

结束语

可能大家看完觉得完全没必要这样做,并且大量这样的操作会影响性能,不过这样做实实在在解决了我项目中的难点,实现了根据导入数据的不同,可以实现正确的XML的读写操作,

总结一下：以上总共有三个知识点的应用

1.动态创建数据类型并在程序中使用

2.序列话读写XML文件

3.利用反射特性实现

最后附上demo下载地址：http://files.cnblogs.com/beimeng/XML.demo.rar

[转载]TreeView的节点遍历 - 部落酋长 - 博客园

2015-04-15mikel阅读(1269)

[转载]TreeView的节点遍历 – 部落酋长 – 博客园.

foreach (TreeNode td in treeView1.Nodes)
                {
                    TreeNode targetNode = SearchNode(td, selectParentNum);
                    if (targetNode != null)
                    {
                        treeView1_AfterSelect(treeView1, new TreeViewEventArgs(targetNode));
                        break;
                    }
                }

/// <summary>
/// 遍历TreeView节点
/// </summary>
/// <param name="td">ParentNode</param>
/// <param name="selectParentNum">条件</param>
/// <returns></returns>

private TreeNode SearchNode(TreeNode td, string selectParentNum)
        {
            if (td.ToolTipText == selectParentNum)
            {
                return td;
            }
            TreeNode targetNode = null;
            foreach (TreeNode childNodes in td.Nodes)
            {
                targetNode = SearchNode(childNodes, selectParentNum);
                if (targetNode != null)
                    break;
            }
            return targetNode;
        }

[转载]ASP.NET MVC 系列：Forms身份验证和基于Role的权限验证 - >>王刚 - 博客园

2015-04-15mikel阅读(1039)

[转载]ASP.NET MVC 系列：Forms身份验证和基于Role的权限验证 – >>王刚 – 博客园.

从Membership到SimpleMembership再到ASP.NET Identity，ASP.NET每一次更换身份验证的组件，都让我更失望。Membership的唯一作用就是你可以参考它的实现，它的数据库创建和扩展方面就真的让人实在无法使用了。

当大家欢呼着让ASP.NET开发走上ASP MVC的正确道路时，身份验证组件却走的更远了：SimpleMembership除了第三方验证的参考价值，它的主键和对领域模型的入侵让它成了摆设，而ASP.NET Identity除了把第三方验证搞的更复杂化外依然没有改进。想起SimpleMembership在code first方面的支持上给我带来的各种麻烦让我现在依然碎碎念。

ASP.NET Identity在Code First这方面虽有改进，但在依赖方面不只是个IdentityUser的继承，竟然还用IdentityDbContext试图搞我的DbContext，你知道我有没有DbContext啊？

幸亏核心都还是基于Cookie的，Forms身份验证也一直可以使用，所以毫不犹豫拿出Forms+FormsAuthentication砍死了SimpleMembership和ASP.NET Identity。这俩货让我这两年赌了无数次，冒着被无数小白和伪实战专家真小白喷的危险我也必须抛弃。还要庆幸权限验证的核心页依然是 IPrincipal，使用自定义的RoleProvider可以将权限验证从这俩鸡肋里拯救出来。

1.配置好Web.config

2.清爽的User和Role

3.只需要将2个方法的RoleProvider

4.IAccountService和IUserRepo只用于演示，依赖注入页简单使用Factory的静态方法。

为了便于演示，使用admin登录的，我们返回admin权限。

5.功能演示：

一想到我没有任何依赖任意测试的Domain Model，只对外接口依赖的Controller，心里真舒坦。登录、退出、admin权限控制，太晚了，不截图了自己跑Demo吧。

Demo：点击下载

如果这篇博客内容对您稍有帮助或略有借鉴，请您推荐它帮助更多的人。

不是一个圈的猪就得想法儿才能往一个圈跳

2015-04-14mikel阅读(1008)

没有万灵的灵药，同样也没有适用任何产品的推广方法，别以为推广网站能行，你推广移动APP就能搞定，不是一个圈的猪就得想法儿才能往一个圈跳！互联网和移动互联网就是两个世界，人们的使用习惯和对待推广的态度截然不同，今天就被弄郁闷了！

信誓旦旦的想推广个APP安装量，觉得自己有那么多会员推推就能上量了，可真不明白咋就不上量呢？！难道真的是都闲麻烦，扫个码都懒得扫？！嗨，真的搞不懂了！

看来想要移动互联网上推广APP还真的不是一时半会儿能整明白的，看来还是自己不行，得学啊！

[转载]ASP.NET MVC使用Bootstrap系统（2）——使用Bootstrap CSS和HTML元素 - 木宛城主 - 博客园

2015-04-14mikel阅读(1198)

[转载]ASP.NET MVC使用Bootstrap系统（2）——使用Bootstrap CSS和HTML元素 – 木宛城主 – 博客园.

阅读目录

Bootstrap提供了一套丰富CSS设置、HTML元素以及高级的栅格系统来帮助开发人员快速布局网页。所有的CSS样式和HTML元素与移动设备优先的流式栅格系统结合，能让开发人员快速轻松的构建直观的界面并且不用担心在较小的设备上响应的具体细节。

开发笔记 第310页

Strings

Numbers

Dates

Enumerations

Some Useful Examples

前言

具体实现

实现一：根据需求创建动态数据类型

实现二：通过反射得到动态创建的数据类型并序列化写入XML文件

实现三：序列化读出XML文件

结束语

Bootstrap 栅格（Grid）系统

栅格参数

Bootstrap HTML元素

Bootstrap Tables（表格）

Bootstrap Tables 其余样式

Bootstrap上下文Table 样式

Bootstrap Buttons

Bootstrap Form（表单）

Bootstrap Image

Bootstrap 验证样式

ASP.NET MVC创建包含Bootstrap样式编辑模板

小结

Bootstrap 导航条

列表组

徽章

媒体对象

页头

路径导航

分页

输入框组

按钮式下拉菜单

警告框

进度条

小结

序言

Data属性 VS 编程API

下拉菜单（dropdown.js）

模态框（modal.js）

标签页（tab.js）

工具提示（tooltip.js）

弹出框（popover.js）

手风琴组件（collapse.js）

旋转木马组件（carousel.js）

小结

热门标签

分类

链接表

开发笔记第310页