anmei1912
anmei1912

.net 反射访问私有变量和私有方法 如何创建C# Closure ? C# 批量生成随机密码，必须包含数字和字母，并用加密算法加密 C#中的foreach和yield 数组为什么可以使用lin...

以下为本次实践代码：

复制代码 
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleTest
{
    class Program
    {
        static void Main(string[] args)
        {
            //反射读取类私有属性
            Person per = new Person("ismallboy", "20102100104");
            Type t = per.GetType();
            //获取私有方法
            MethodInfo method = t.GetMethod("GetStuInfo", BindingFlags.NonPublic | BindingFlags.Instance);
            //访问无参数私有方法
            string strTest = method.Invoke(per, null).ToString();
            //访问有参数私有方法
            MethodInfo method2 = t.GetMethod("GetValue", BindingFlags.NonPublic | BindingFlags.Instance);
            object[] par = new object[2];
            par[0] = "ismallboy";
            par[1] = 2;
            string strTest2 = method2.Invoke(per, par).ToString();

            //获取私有字段
            PropertyInfo field = t.GetProperty("Name", BindingFlags.NonPublic | BindingFlags.Instance);
            //访问私有字段值
            string value = field.GetValue(per).ToString();
            //设置私有字段值
            field.SetValue(per, "new Name");
            value = field.GetValue(per).ToString();
        }
    }

    /// 
    /// 个人信息
    /// 
    class Person
    {
        private string Name { get; set; }
        private string StuNo { get; set; }

        public Person(string name, string stuNo)
        {
            this.Name = name;
            this.StuNo = stuNo;
        }

        private string GetStuInfo()
        {
            return this.Name;
        }

        private string GetValue(string str, int n)
        {
            return str + n.ToString();
        }
    }
}
复制代码

如果使用dynamic的话，也可以如下：

复制代码 
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleTest
{
    class Program
    {
        static void Main(string[] args)
        {
            //反射读取类私有属性
            dynamic per = new Person("ismallboy", "20102100104");
            Type t = per.GetType();
            //获取私有方法
            MethodInfo method = t.GetMethod("GetStuInfo", BindingFlags.NonPublic | BindingFlags.Instance);
            //访问无参数私有方法
            string strTest = method.Invoke(per, null);
            //访问有参数私有方法
            MethodInfo method2 = t.GetMethod("GetValue", BindingFlags.NonPublic | BindingFlags.Instance);
            object[] par = new object[2];
            par[0] = "ismallboy";
            par[1] = 2;
            string strTest2 = method2.Invoke(per, par);

            //获取私有字段
            PropertyInfo field = t.GetProperty("Name", BindingFlags.NonPublic | BindingFlags.Instance);
            //访问私有字段值
            string value = field.GetValue(per);
            //设置私有字段值
            field.SetValue(per, "new Name");
            value = field.GetValue(per);
        }
    }

    /// 
    /// 个人信息
    /// 
    class Person
    {
        private string Name { get; set; }
        private string StuNo { get; set; }

        public Person(string name, string stuNo)
        {
            this.Name = name;
            this.StuNo = stuNo;
        }

        private string GetStuInfo()
        {
            return this.Name;
        }

        private string GetValue(string str, int n)
        {
            return str + n.ToString();
        }
    }
}
复制代码

 .net 反射访问私有变量和私有方法 如何创建C# Closure ? C# 批量生成随机密码，必须包含数字和字母，并用加密算法加密 C#中的foreach和yield 数组为什么可以使用lin..._第1张图片

 

 

JavaScript中一个重要的概念就是闭包，闭包在JavaScript中有大量的应用，但是你知道么？C#也可以创建Closure。下面就介绍一下如何在C#中创建神奇的闭包。

　　在这之前，我们必须先知道如何在C#中定义函数

  //函数定义，参数为string，返回为string
 Func myFunc = delegate(string msg)
 {
       return "Msg:" + msg;
 };

利用Lambda表达式也可以简化上述的代码，但是效果一样：

  //Lambda
 Func myFuncSame = msg => "Msg:" + msg;

定义好函数后，可以进行调用：

  //函数调用
  string message= myFuncSame("Hello world");

定义一个带外部变量（相对于内嵌函数而言）的嵌套函数，外部函数将内部嵌套的函数进行返回：

复制代码 
public static Func Func()
 {
     var myVar = 1;
     Func inc = delegate(int var1)
     {
         //myVar能够记录上一次调用后的状态（值）
         myVar = myVar + 1;
         return var1 + myVar;
     };
     return inc;
 }
复制代码

C# Closure调用如下所示：

复制代码 
static void CsharpClosures()
 {
     var inc = Func();
     Console.WriteLine(inc(5));//7
     Console.WriteLine(inc(6));//9
 }
复制代码

当第二次调用inc(6)时，此时函数内变量myVar并未像第一次调用函数时进行重新初始化（var myVar=1），而是保留了第一次运算的值,即 2，因此inc(6)返回的结果为（2+1+6）=9.

 

要求：密码必须包含数字和字母

思路：1.列出数字和字符。 组成字符串 ：chars

        2.利用randrom.Next(int i)返回一个小于所指定最大值的非负随机数。

        3. 随机取不小于chars长度的随机数a,取字符串chars的第a位字符。

        4.循环 8次，得到8位密码

        5.循环N次，批量得到密码。

代码实现如下 Main函数：

复制代码 
static void Main(string[] args)
        {
            string chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
            Random randrom = new Random((int)DateTime.Now.Ticks);
            string path1 = @"C:\Users\lenovo\Desktop\pws.txt";
            for (int j = 0; j < 10000;j++ )
            {
                string str = "";
                for (int i = 0; i < 8; i++)
                {
                    str += chars[randrom.Next(chars.Length)];//randrom.Next(int i)返回一个小于所指定最大值的非负随机数
                }
                if (IsNumber(str))//判断是否全是数字
                    continue;
                if (IsLetter(str))//判断是否全是字母
                    continue;
                File.AppendAllText(path1, str);
                string pws = Md5(str,32);//MD5加密
                File.AppendAllText(path1, "," + pws + "\r\n");
            }
            Console.WriteLine("ok");
            Console.Read();
        }
复制代码

巧用String.trim 函数，判断是否全是数字，全是字母。

说明：string.trim   从 String 对象移除前导空白字符和尾随空白字符。

返回：一个字符串副本，其中从该字符串的开头和末尾移除了所有空白字符。

有一个重载：string.Trim(params char[] trimChars)   

//从当前System.string对象移除数组中指定的一组字符的所有前导匹配项和尾部匹配项

 trimChars：要删除的字符数组

方法实现如下代码：

复制代码 
        //判断是否全是数字
        static bool IsNumber(string str)
        {
            if (str.Trim("0123456789".ToCharArray()) == "")
                return true;
            return false;
        }
        //判断是否全是字母
        static bool IsLetter(string str)
        {
           if (str.Trim("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".ToCharArray()) == "")
               return true;
           return false;
        }
复制代码

 用MD5加密，算法代码实现如下：

复制代码 
/// 
        /// MD5加密
        /// 
        /// 加密字元
        /// 加密位数16/32
        /// 
        public static string Md5(string str, int code)
        {
            string strEncrypt = string.Empty;

            MD5 md5 = new MD5CryptoServiceProvider();
            byte[] fromData = Encoding.GetEncoding("GB2312").GetBytes(str);
            byte[] targetData = md5.ComputeHash(fromData);
            for (int i = 0; i < targetData.Length; i++)
            {
                strEncrypt += targetData[i].ToString("X2");
            }
            if (code == 16)
            {
                strEncrypt = strEncrypt.Substring(8, 16);
            }
            return strEncrypt;
        }
复制代码

生成批量密码，和加密后的密码如下图：

.net 反射访问私有变量和私有方法 如何创建C# Closure ? C# 批量生成随机密码，必须包含数字和字母，并用加密算法加密 C#中的foreach和yield 数组为什么可以使用lin..._第2张图片

 

1. foreach

C#编译器会把foreach语句转换为IEnumerable接口的方法和属性。

foreach (Person p in persons)
 {
     Console.WriteLine(p);
 }

foreach语句会解析为下面的代码段。

调用GetEnumerator（）方法，获得数组的一个枚举

在while循环中，只要MoveNext（）返回true，就一直循环下去

用Current属性访问数组中的元素

复制代码 
IEnumerator enumerator = persons. GetEnumerator();
 while (enumerator.MoveNext())
 {
    Person p = (Person) enumerator.Current;
    Console.WriteLine(p);
}
复制代码

2. yield语句

yield语句的两种形式：

yield return ;
yield break;

使用一个yield return语句返回集合的一个元素

包含yield语句的方法或属性是迭代器。迭代器必须满足以下要求

a. 返回类型必须是IEnumerable、IEnumerable、IEnumerator或 IEnumerator。

b. 它不能有任何ref或out参数

yield return语句不能位于try-catch快。yield return语句可以位于try-finally的try块

复制代码 
try
              {
                  // ERROR: Cannot yield a value in the boday of a try block with a catch clause
                 yield return "test";
              }
             catch
             { }
 
              try
             {
                 // 
                 yield return "test again";
             }
             finally
             { }
 
             try
             { }
             finally
             { 
                 // ERROR: Cannot yield in the body of a finally clause
                yield return ""; 
             }
复制代码

yield break语句可以位于try块或catch块，但是不能位于finally块

下面的例子是用yield return语句实现一个简单集合的代码，以及用foreach语句迭代集合

复制代码 
using System;
using System.Collections.Generic;

namespace ConsoleApplication6
{
    class Program
    {
        static void Main(string[] args)
        {
            HelloCollection helloCollection = new HelloCollection();
            foreach (string s in helloCollection)
            {
                Console.WriteLine(s);
                Console.ReadLine();
            }
        }
    }

    public class HelloCollection
    {
        
        public IEnumerator GetEnumerator()
        {
            // yield return语句返回集合的一个元素，并移动到下一个元素上；yield break可以停止迭代
            yield return "Hello";
            yield return "World";
        }
    }
}
复制代码

使用yield return语句实现以不同方式迭代集合的类：

复制代码 
using System;
using System.Collections.Generic;

namespace ConsoleApplication8
{
    class Program
    {
        static void Main(string[] args)
        {
            MusicTitles titles = new MusicTitles();
            foreach (string title in titles)
            {
                Console.WriteLine(title);
            }
            Console.WriteLine();

            foreach (string title in titles.Reverse())
            {
                Console.WriteLine(title);
            }
            Console.WriteLine();

            foreach (string title in titles.Subset(2, 2))
            {
                Console.WriteLine(title);
                Console.ReadLine();
            }
        }
    }

    public class MusicTitles
    {
        string[] names = { "a", "b", "c", "d" };
        public IEnumerator GetEnumerator()
        {
            for (int i = 0; i < 4; i++)
            {
                yield return names[i];
            }
        }

        public IEnumerable Reverse()
        {
            for (int i = 3; i >= 0; i--)
            {
                yield return names[i];
            }
        }

        public IEnumerable Subset(int index, int length)
        {
            for (int i = index; i < index + length; i++)
            {
                yield return names[i];
            }
        }
    }
}
复制代码

 

 

问题引出

　　这视乎是个完全不必要进行讨论的话题，因为linq（这里具体是linq to objects）本来就是针对集合类型的，数组类型作为集合类型的一种当然可以使用了。不过我还是想写一下，这个问题源于qq群里一位朋友的提问：.net的数组类型都隐式继承了Array类，该类是一个抽象类，并且实现了IEnumerable、ICollection、IList接口。但linq的方法都是针对实现了IEnumerable泛型接口的，Array类并没有实现这些泛型接口，为什么可以使用这些方法呢？

　　linq to objects的本质是通过扩展方法来实现集合的查询，这些扩展方法定义在一个Enumerable的静态类中。Enumerable类下的所有扩展方法的第一个参数都是IEnumerable 类型，表示它可以通过IEnumerable类型进行调用。

浅析数组类型

1. 所有数组类型都隐式派生自Array

　　当我们定义一个FileStream[] 数组时，CLR会为当前的AppDomain创建一个FileStream[] 类型，该类型派生自 Array。所以数组是引用类型，在堆中分配内存空间。Array类是一个抽象类，定义了许多关于常用的实例方法和静态方法，供所有的数组类型使用。例如常见的:Length属性，CopyTo方法等等。

2. 所有的数组类型都隐式实现了IEnumerable接口

　　就如上面所所的，这是一个理所当然的问题，为了提高开发效率，数组类型理应可以使用linq进行查询。但由于数组可以是多维数组或者非0基数组，所以Array类并没有实现IEnumerable、ICollection、IList 这几个泛型接口，而只是实现了非泛型版本的。实际上，CLR会自动为一维的数组类型实现这些泛型接口（指定T类型参数的具体类型），并且还会为它们的父类实现。例如我们定义一个FileStream[] 数组类型，那么CLR会为我们创建如下的层次类型结构:

  　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

由于CLR的隐式实现，才使我们可以将一维数组类型应用在需要IEnumerable泛型接口的地方。

　　按照上面的说法，我们可以将FileStream[] 类型的对象传递给如下的方法：

　　void F1(IEnumerable oEnumerable);

　　void F2(ICollection sCollection);

　　void F3(IList fList);

　　这是对于引用类型而言的，如果是值类型，则不为会它的基类实现这些接口。例如DateTimel类型(基类包括ValueType和Object)，DateTime[]数组类型不能传递给上面的F1方法，这是因为值类型的数组的内存布局与引用类型的数组不同。

 

具名参数 和 可选参数 是 C# framework 4.0 出来的新特性。

一. 常规方法定义及调用

复制代码 
public void Demo1(string x, int y)
{ 
      //do something...
}


public void Main()
{
      //调用
       Demo1("similar", 22);
}
复制代码

调用时，参数顺序(类型)必须与声明一致，且不可省略。

 

 

二. 可选参数的声明及调用

可选参数分为两种情况： 1. 部分参数可选；   2. 全部参数都是可选

复制代码 
//部分可选(x为必选，y为可选)
public void Demo2(string x, int y = 5)
{
      //do something...
}


public void Main()
{
       //调用
       Demo2("similar");       // y不传入实参时，y使用默认值5
       Demo2("similar", 10);   // y传入实参，则使用实参10
}
复制代码

注： 当参数为部分可选时， 可选参数  的声明必须定义在 不可选参数 的后面（如上： y 的声明在 x 之后），不然会出现如下错误提示：

.net 反射访问私有变量和私有方法 如何创建C# Closure ? C# 批量生成随机密码，必须包含数字和字母，并用加密算法加密 C#中的foreach和yield 数组为什么可以使用lin..._第3张图片

复制代码 
//全部可选(x,y 均为可选参数)
public void Demo3(string x = "demo", int y = 5)
{
       //do something...
}

public void Main()
{
       //调用
       Demo3();               // x,y不传入实参时，x,y使用默认值 "demo",5
       Demo3("similar");      // y不传入实参时，y使用默认值5
       Demo3("similar", 10);  // x,y都传入实参
}
复制代码

分先后。

       b. 参数声明定义可以无顺序，但调用时必须与声明时的一致。

上面的调用只写的3种，其实还有一种，就是 x 使用默认值，y 传入实参，即 ：  Demo3(10);

但这样调用会报错，因为Demo3的第一个参数是 string 类型，错误消息如图：

.net 反射访问私有变量和私有方法 如何创建C# Closure ? C# 批量生成随机密码，必须包含数字和字母，并用加密算法加密 C#中的foreach和yield 数组为什么可以使用lin..._第4张图片

但是现在我只想传入y， 不想传入 x ,该怎么办呢，那么就要用到 C#的 具名参数。

 

 

三. 具名参数

具名参数的使用主要是体现在函数调用的时候。

复制代码 
public void Main()
{
       //调用
       Demo3();                // x,y不传入实参时，x,y使用默认值 "demo",5
       Demo3("similar");       // y不传入实参时，y使用默认值5
       Demo3("similar", 10);   // x,y都传入实参


       // 具名参数的使用
       Demo3(y:10);
}
复制代码

通过具名参数，我们可以指定特定参数的值，这里我们通过 Demo3(y:10)就可以解决我们上面遇到的问题(x使用默认值，y使用实参)。

 

注： 当使用 具名参数时，调用方法可以不用管参数的声明顺序，即如下调用方式也是可以的：

在调用含有可选参数的方法时，vs中会有智能提示，提示哪些是可以选参数及其默认值，中括号表示可选[]：

 

具名参数 和 可选参数 是 C# framework 4.0 出来的新特性。

一. 常规方法定义及调用

复制代码 
public void Demo1(string x, int y)
{ 
      //do something...
}


public void Main()
{
      //调用
       Demo1("similar", 22);
}
复制代码

调用时，参数顺序(类型)必须与声明一致，且不可省略。

 

 

二. 可选参数的声明及调用

可选参数分为两种情况： 1. 部分参数可选；   2. 全部参数都是可选

复制代码 
//部分可选(x为必选，y为可选)
public void Demo2(string x, int y = 5)
{
      //do something...
}


public void Main()
{
       //调用
       Demo2("similar");       // y不传入实参时，y使用默认值5
       Demo2("similar", 10);   // y传入实参，则使用实参10
}
复制代码

注： 当参数为部分可选时， 可选参数  的声明必须定义在 不可选参数 的后面（如上： y 的声明在 x 之后），不然会出现如下错误提示：

.net 反射访问私有变量和私有方法 如何创建C# Closure ? C# 批量生成随机密码，必须包含数字和字母，并用加密算法加密 C#中的foreach和yield 数组为什么可以使用lin..._第5张图片

复制代码 
//全部可选(x,y 均为可选参数)
public void Demo3(string x = "demo", int y = 5)
{
       //do something...
}

public void Main()
{
       //调用
       Demo3();               // x,y不传入实参时，x,y使用默认值 "demo",5
       Demo3("similar");      // y不传入实参时，y使用默认值5
       Demo3("similar", 10);  // x,y都传入实参
}
复制代码

分先后。

       b. 参数声明定义可以无顺序，但调用时必须与声明时的一致。

上面的调用只写的3种，其实还有一种，就是 x 使用默认值，y 传入实参，即 ：  Demo3(10);

但这样调用会报错，因为Demo3的第一个参数是 string 类型，错误消息如图：

.net 反射访问私有变量和私有方法 如何创建C# Closure ? C# 批量生成随机密码，必须包含数字和字母，并用加密算法加密 C#中的foreach和yield 数组为什么可以使用lin..._第6张图片

但是现在我只想传入y， 不想传入 x ,该怎么办呢，那么就要用到 C#的 具名参数。

 

 

三. 具名参数

具名参数的使用主要是体现在函数调用的时候。

复制代码 
public void Main()
{
       //调用
       Demo3();                // x,y不传入实参时，x,y使用默认值 "demo",5
       Demo3("similar");       // y不传入实参时，y使用默认值5
       Demo3("similar", 10);   // x,y都传入实参


       // 具名参数的使用
       Demo3(y:10);
}
复制代码

通过具名参数，我们可以指定特定参数的值，这里我们通过 Demo3(y:10)就可以解决我们上面遇到的问题(x使用默认值，y使用实参)。

 

注： 当使用 具名参数时，调用方法可以不用管参数的声明顺序，即如下调用方式也是可以的：

在调用含有可选参数的方法时，vs中会有智能提示，提示哪些是可以选参数及其默认值，中括号表示可选[]：

 

接口定义了一系列的行为规范，为类型定义一种Can-Do的功能。例如，实现IEnumerable接口定义了GetEnumerator方法，用于获取一个枚举数，该枚举数支持在集合上进行迭代，也就是我们常说的foreach。接口只是定义行为，具体的实现需要由具体类型负责，实现接口的方法又分为隐式实现与显示实现。

一、隐式/显示实现接口方法

　　简单的说，我们平时“默认”使用的都是隐式的实现方式。例如：

复制代码 
interface ILog
{
    void Log();
}
 
public class FileLogger : ILog
{
    public void Log()
    {
        Console.WriteLine("记录到文件！");
    }
}
复制代码

隐式实现很简单，通常我们约定接口命名以 I 开头，方便阅读。接口内的方法不需要用public，编译器会自动加上。类型中实现接口的方法只能是public，也可以定义成虚方法，由子类重写。现在看显示实现的方式：

复制代码 
public class EventLogger : ILog
{
    void ILog.Log()
    {
        Console.WriteLine("记录到系统事件！");
    }
}
复制代码

与上面不同的是，方法用了ILog指明，而且没有（也不能有）public或者private修饰符。

　　除了语法上的不同，调用方式也不同，显示实现只能用接口类型的变量来调用，如：

复制代码 
FileLogger fileLogger = new FileLogger();
fileLogger.Log(); //正确
EventLogger eventLogger = new EventLogger();           
eventLogger.Log(); //报错
ILog log = new EventLogger();
log.Log(); //正确
复制代码

二、何时使用

　　1. c#允许实现多个接口，如果多个接口定义了相同的方法，可以用显示实现的方式加以区分，例如：

复制代码 
 
public class EmailLogger : ILog, ISendable
{
    void ILog.Log()
    {
        Console.WriteLine("ILog");
    }
 
    void ISendable.Log()
    {
        Console.WriteLine("ISendable");
    }
}
复制代码

　2. 增强编译时的类型安全和避免值类型装箱

　　有了泛型，我们自然可以做到编译时的类型安全和避免值类型装箱的操作。但有时候可能没有对应的泛型版本。例如：IComparable(这里只是举例，实际有IComparable)。如：

复制代码 
interface IComparable
{
    int CompareTo(object obj);
}
 
struct ValueType : IComparable
{
    private int x;
    public ValueType(int x)
    {
        this.x = x;
    }
 
    public int CompareTo(object obj)
    {
        return this.x - ((ValueType)obj).x;
    }
} 

　　 //调用：
    
ValueType vt1 = new ValueType(1);
ValueType vt2 = new ValueType(2);
Console.WriteLine(vt1.CompareTo(vt2));
复制代码

由于形参是object，上面的CompareTo会发生装箱；而且无法获得编译时的类型安全，例如我们可以随便传一个string，编译不会报错，等到运行时才抛出InvalidCastException。使用显示实现接口的方式，如：

复制代码 
public int CompareTo(ValueType vt)
{
    return this.x - vt.x;
}
 
int IComparable.CompareTo(object obj)
{
    return CompareTo((ValueType)obj);
}
复制代码

再次执行上面的代码，就不会发生装箱操作，而且可以获得编译时的类型安全了。但是如果我们用接口变量调用，就会再次发生装箱并丧失编译时的类型安全检测能力

IComparable vt1 = new ValueType(1); //装箱
ValueType vt2 = new ValueType(2);
Console.WriteLine(vt1.CompareTo(vt2)); //再次装箱

三、缺点

　　1. 显示实现只能用接口类型变量调用，会给人的感觉是某类型实现了该接口却无法调用接口中的方法。特别是写成类库给别人调用时，显示实现的接口方法在vs中按f12都不会显示出来。（这点有人在csdn提问过，为什么某个类型可以不用实现接口方法）

　　2. 对于值类型，要调用显示实现的方法，会发生装箱操作。

　　3. 无法被子类继承使用。

 

对异步CTP感兴趣有很多原因。异步CTP使异步编程比以前更加容易了。它虽然没有Rx强大，但是更容易学。异步CTP介绍了两个新的关键字，async和await。异步方法（或Lambda表达式）必须返回void，Task或Task。这篇文章不是介绍异步CTP的，因为网上有很多这样的文章。这篇文章的目的是把程序员开始使用Async CTP遇到的一些常见问题集中起来。

推断返回类型

当从异步方法返回一个值的时候，此方法体直接返回这个值，但该方法本身被声明为返回一个Task。当声明一个返回甲类型的方法却必须返回一个乙类型时，就有点“断连”了。

复制代码 
// 实际语法
public async Task GetValue()
{
  await TaskEx.Delay(100);
  return 13; //返回类型是 "int", 而不是"Task"
}
复制代码

问题来了：为什么我不能这么写？

复制代码 
// 假想语法
public async int GetValue()
{
  await TaskEx.Delay(100);
  return 13; // 返回类型是 "int"
}
复制代码
思考：该方法如何如何照顾调用者呢？异步方法必须返回一个实际结果类型Task的值。因此，GetValue方法会出现返回Task的智能提示（在对象浏览器，Reflector等中也是这样的）。
 
在设计之初，推断返回类型已经被考虑到了，但该设计团队已经推断出在异步方法中保持这种“断连”比在代码基上扩大这种“断连”更好。如今这种“断连”仍存在，但比以前更小了。该设计团队的共识是一致的方法签名更佳。
思考：async void 和async Task有什么区别？
一个async Task方法就像任何其他的异步操作一样，只是没有返回值。一个async void方法扮演一种高级操作。async Task方法可能被组合进其他使用using await的异步方法。async void方法可能被用作一个事件句柄。async void方法也有其他重要的属性：在ASP.NET上下文中，它通知web服务器直到它返回，页面才完成。
 
推断返回类型会移除async void 和async Task间的区别：要么所有的异步方法是async void（阻止可组合性），要么都是async Task（阻止它们来自事件句柄，同时对ASP.NET要有一个可选择的方案）。

 异步返回

 
在方法声明返回类型和方法体返回的类型之间仍有“断连”。该设计团队的另一个建议是：给return添加一个关键字来指示return返回的值，但这个也确实没有返回什么，如下所示：
复制代码 
// 假想语法
public async Task GetValue()
{
  await TaskEx.Delay(100);
  async return 13; // "async return" 意味着值被包装在Task中
}
复制代码
思考：将大量的代码从同步转为异步。

async return关键字也被考虑到了，但并没有足够的说服力。当把一些同步代码转成异步代码时，这尤其正确。强制人们给每个return语句添加asynchronous就好像是“不必要的忙碌”。比较而言，习惯于“断连”更容易。

推断“async”

async关键字必须用在使用了await关键字的方法上。然而，如果把async用在了一个没有使用await的方法上，也会收到一个警告。

问题：为什么async不能根据await的存在推断出来？

复制代码 
//假想语法
public Task GetValue()
{
  // "await" 的存在暗示这是一个 "async" 方法.
  await TaskEx.Delay(100);
  return 13;
}
复制代码

思考：向后兼容性和代码可读性

单字的await关键字具有太大的打破变化。在异步方法上的多字await（如await for）或一个关键字之间的选择，只是在那个方法内部启用await关键字。很明显，使用async标记方法让人类和计算机分析起来更容易，因此设计团队决定使用async/await对。

推断“await”

问题：既然显示包括async有意义（看上面）,为什么await不能根据async的存在推断出来呢？

复制代码 
// 假想语法
public async Task GetValue()
{
  // 暗示有"await",因为这是一个 "async" 方法.
  TaskEx.Delay(100);
  return 13;
}
复制代码

思考：异步操作的并行组合。

乍一看，推断await推断似乎简化了基本的异步操作。只要所有的等待可以按序列（如一个操作等待，然后另一个，再然后另一个）完成，这个就能很好的工作。然而，当有人考虑并行组合的时候，它崩溃了。

异步CTP中的并行组合使用TaskEx.WhenAny 和TaskEx.WhenAll方法。这有一个简单的例子，这个方法立即开始了两个操作，并且等待它们完成。

复制代码 
// 实际语法
public async Task GetValue()
{
  // 异步检索两个部分的值
  // 注意此时它们是没有等待的“not await”
  Task part1 = GetValuePart1();
  Task part2 = GetValuePart2();

  // 等待它们的值到达。
  await TaskEx.WhenAll(part1, part2);

  // 计算我们的结果
  int value1 = await part1; // 实际上没有等待
  int value2 = await part2; //实际上没有等待
  return value1 + value2;
}
复制代码

为了处理并行组合，我们必须有能力说我们将不会await一个表达式。

 

 

一、创建线程

　　在整个系列文章中，我们主要使用Visual Studio 2015作为线程编程的主要工具。在C#语言中创建、使用线程只需要按以下步骤编写即可：

1、启动Visual Studio 2016，新建一个控制台应用程序。

2、确保该控制台程序使用.NET Framework 4.6或以上版本。然而在该篇中的所有示例使用较低版本可以正常工作。

3、双击打开该控制台应用程序中的“Program.cs”文件，在其中编写如下代码：

复制代码 
using System;
  using System.Threading;
  using static System.Console;
  
  namespace Recipe01
  {
      class Program
      {
          static void PrintNumbers()
         {
             WriteLine("Starting...");
             for (int i = 1; i < 10; i++)
             {
                 WriteLine(i);
             }
         }
 
         static void Main(string[] args)
         {
            Thread t = new Thread(PrintNumbers);
             t.Start();
             PrintNumbers();
         }
     }
 }
复制代码

　　在第2行代码处，我们导入了System.Threading命名空间，该命名空间包含了我们编写多线程程序所需要的所有类型。

　　在第3行代码处，我们使用了C# 6.0的using static特性，使用了该特性之后，在代码中允许我们在使用System.Console类型的静态方法的时候不需要指定其类型名。

　　在第9~16行代码处，我们定义了一个名为“PrintNumbers”的方法，该方法将在“Main”方法和线程中进行调用。

　　在第20行代码处，我们创建了一个线程来运行“PrintNumbers”方法，当我们初始化一个线程时，一个“ThreadStart”或“ParameterizedThreadStart”委托的实例被传递给线程的构造方法。

　　在第21行代码处，我们启动线程。

　　在第22行代码处，我们在“Main”方法中调用“PrintNumbers”方法。

4、运行该控制台应用程序，运行效果（每次运行效果可能不同）如下图所示：

.net 反射访问私有变量和私有方法 如何创建C# Closure ? C# 批量生成随机密码，必须包含数字和字母，并用加密算法加密 C#中的foreach和yield 数组为什么可以使用lin..._第7张图片

二、中止线程

 　　在这一节，我们将让线程等待一些时间，在等待的这段时间内，该线程不会消耗操作系统的资源。编写步骤如下：

1、使用Visual Studio 2015创建一个新的控制台应用程序。

2、双击打开“Program.cs”文件，编写代码如下所示：

复制代码 
using System;
  using System.Threading;
  using static System.Console;
  
  namespace Recipe01
  {
      class Program
      {
          static void PrintNumbers()
        {
             WriteLine("Starting...");
             for (int i = 1; i < 10; i++)
             {
                 WriteLine(i);
             }
         }
 
         static void Main(string[] args)
         {
             Thread t = new Thread(PrintNumbers);
             t.Start();
             PrintNumbers();
         }
     }
 }
复制代码

3、运行该控制台应用程序，运行效果（每次运行效果可能不同）如下图所示：

.net 反射访问私有变量和私有方法 如何创建C# Closure ? C# 批量生成随机密码，必须包含数字和字母，并用加密算法加密 C#中的foreach和yield 数组为什么可以使用lin..._第8张图片

三、线程等待

 　　在这一节中，我们将讲述如何在一个线程执行完毕后，再执行剩余的代码，要完成这个工作，我们不能使用Thread.Sleep方法，因为我们不知道另一个线程精确的执行时间。要使一个线程等待另一个线程执行完毕后再进行其他工作，只需要按下列步骤编写代码即可：

1、使用Visual Studio 2015创建一个新的控制台应用程序。

2、双击打开“Program.cs”文件，编写如下代码：

复制代码 
using System;
  using System.Threading;
  using static System.Console;
  using static System.Threading.Thread;
  
  namespace Recipe03
  {
      class Program
      {
        static void PrintNumbersWithDelay()
         {
             WriteLine("Starting...");
 
           for(int i = 1; i < 10; i++)
             {
                 Sleep(TimeSpan.FromSeconds(2));
                 WriteLine(i);
             }
         }

         static void Main(string[] args)
        {
             WriteLine("Starting...");
           Thread t = new Thread(PrintNumbersWithDelay);
          t.Start();
             t.Join();
             WriteLine("Thread completed");
         }
    }
}
复制代码

3、运行该控制台应用程序，运行效果如下图所示：

.net 反射访问私有变量和私有方法 如何创建C# Closure ? C# 批量生成随机密码，必须包含数字和字母，并用加密算法加密 C#中的foreach和yield 数组为什么可以使用lin..._第9张图片

　在第26行代码处，我们在“Main”方法中调用调用“t.Join”方法，该方法允许我们等待线程t执行完毕后，再执行“Main”方法中剩余的代码。有了该技术，我们可以同步两个线程的执行步骤。第一个线程等待第二个线程执行完毕后，再进行其他的工作，在第一个线程等待期间，第一个线程的状态为“bolcked”状态，和我们调用Thread.Sleep的状态一样。

四、终止线程

　　在这一节中，我们将讲述如何终止另一个线程的执行。步骤如下：

1、使用Visual Studio 2015创建一个新的控制台应用程序。

2、双击打开“Program.cs”文件，编写如下代码：

复制代码 
 using System;
 using System.Threading;
  using static System.Console;
  using static System.Threading.Thread;
  
  namespace Recipe04
  {
      class Program
      {
         static void PrintNumbers()
         {
             WriteLine("Starting...");
 
             for (int i = 1; i < 10; i++)
             {
                 WriteLine(i);
             }
         }
 
         static void PrintNumbersWithDelay()
         {
             WriteLine("Starting...");
             for (int i = 1; i < 10; i++)
             {
                 Sleep(TimeSpan.FromSeconds(2));
                 WriteLine(i);
             }
         }
 
         static void Main(string[] args)
         {
             WriteLine("Starting program...");
             Thread t = new Thread(PrintNumbersWithDelay);
             t.Start();
             Thread.Sleep(TimeSpan.FromSeconds(6));
             t.Abort();
             WriteLine("A thread has been aborted");
             t = new Thread(PrintNumbers);
             t.Start();
             PrintNumbers();
         }
     }
 }
复制代码

3、运行该控制台应用程序，运行效果（每次运行效果可能不同）如下图所示：

.net 反射访问私有变量和私有方法 如何创建C# Closure ? C# 批量生成随机密码，必须包含数字和字母，并用加密算法加密 C#中的foreach和yield 数组为什么可以使用lin..._第10张图片

 

 

在对Bitmap图片操作的时候，有时需要用到获取或设置像素颜色方法：GetPixel 和 SetPixel，

如果直接对这两个方法进行操作的话速度很慢，这里我们可以通过把数据提取出来操作，然后操作完在复制回去可以加快访问速度

其实对Bitmap的访问还有两种方式，一种是内存法，一种是指针法

1、内存法

　　这里定义一个类LockBitmap，通过把Bitmap数据拷贝出来，在内存上直接操作，操作完成后在拷贝到Bitmap中

复制代码 
public class LockBitmap
        {
            Bitmap source = null;
            IntPtr Iptr = IntPtr.Zero;
            BitmapData bitmapData = null;

            public byte[] Pixels { get; set; }
            public int Depth { get; private set; }
            public int Width { get; private set; }
            public int Height { get; private set; }

            public LockBitmap(Bitmap source)
            {
                this.source = source;
            }

            /// 
            /// Lock bitmap data
            /// 
            public void LockBits()
            {
                try
                {
                    // Get width and height of bitmap
                    Width = source.Width;
                    Height = source.Height;

                    // get total locked pixels count
                    int PixelCount = Width * Height;

                    // Create rectangle to lock
                    Rectangle rect = new Rectangle(0, 0, Width, Height);

                    // get source bitmap pixel format size
                    Depth = System.Drawing.Bitmap.GetPixelFormatSize(source.PixelFormat);

                    // Check if bpp (Bits Per Pixel) is 8, 24, or 32
                    if (Depth != 8 && Depth != 24 && Depth != 32)
                    {
                        throw new ArgumentException("Only 8, 24 and 32 bpp images are supported.");
                    }

                    // Lock bitmap and return bitmap data
                    bitmapData = source.LockBits(rect, ImageLockMode.ReadWrite,
                                                 source.PixelFormat);

                    // create byte array to copy pixel values
                    int step = Depth / 8;
                    Pixels = new byte[PixelCount * step];
                    Iptr = bitmapData.Scan0;

                    // Copy data from pointer to array
                    Marshal.Copy(Iptr, Pixels, 0, Pixels.Length);
                }
                catch (Exception ex)
                {
                    throw ex;
                }
            }

            /// 
            /// Unlock bitmap data
            /// 
            public void UnlockBits()
            {
                try
                {
                    // Copy data from byte array to pointer
                    Marshal.Copy(Pixels, 0, Iptr, Pixels.Length);

                    // Unlock bitmap data
                    source.UnlockBits(bitmapData);
                }
                catch (Exception ex)
                {
                    throw ex;
                }
            }

            /// 
            /// Get the color of the specified pixel
            /// 
            /// 
            /// 
            /// 
            public Color GetPixel(int x, int y)
            {
                Color clr = Color.Empty;

                // Get color components count
                int cCount = Depth / 8;

                // Get start index of the specified pixel
                int i = ((y * Width) + x) * cCount;

                if (i > Pixels.Length - cCount)
                    throw new IndexOutOfRangeException();

                if (Depth == 32) // For 32 bpp get Red, Green, Blue and Alpha
                {
                    byte b = Pixels[i];
                    byte g = Pixels[i + 1];
                    byte r = Pixels[i + 2];
                    byte a = Pixels[i + 3]; // a
                    clr = Color.FromArgb(a, r, g, b);
                }
                if (Depth == 24) // For 24 bpp get Red, Green and Blue
                {
                    byte b = Pixels[i];
                    byte g = Pixels[i + 1];
                    byte r = Pixels[i + 2];
                    clr = Color.FromArgb(r, g, b);
                }
                if (Depth == 8)
                // For 8 bpp get color value (Red, Green and Blue values are the same)
                {
                    byte c = Pixels[i];
                    clr = Color.FromArgb(c, c, c);
                }
                return clr;
            }

            /// 
            /// Set the color of the specified pixel
            /// 
            /// 
            /// 
            /// 
            public void SetPixel(int x, int y, Color color)
            {
                // Get color components count
                int cCount = Depth / 8;

                // Get start index of the specified pixel
                int i = ((y * Width) + x) * cCount;

                if (Depth == 32) // For 32 bpp set Red, Green, Blue and Alpha
                {
                    Pixels[i] = color.B;
                    Pixels[i + 1] = color.G;
                    Pixels[i + 2] = color.R;
                    Pixels[i + 3] = color.A;
                }
                if (Depth == 24) // For 24 bpp set Red, Green and Blue
                {
                    Pixels[i] = color.B;
                    Pixels[i + 1] = color.G;
                    Pixels[i + 2] = color.R;
                }
                if (Depth == 8)
                // For 8 bpp set color value (Red, Green and Blue values are the same)
                {
                    Pixels[i] = color.B;
                }
            }
        }
复制代码

使用：先锁定Bitmap，然后通过Pixels操作颜色对象，最后释放锁，把数据更新到Bitmap中

复制代码 
string file = @"C:\test.jpg";
            Bitmap bmp = new Bitmap(Image.FromFile(file));
            
            LockBitmap lockbmp = new LockBitmap(bmp);
            //锁定Bitmap，通过Pixel访问颜色
            lockbmp.LockBits();

            //获取颜色
            Color color = lockbmp.GetPixel(10, 10);

            //从内存解锁Bitmap
            lockbmp.UnlockBits();
复制代码

2、指针法

　　这种方法访问速度比内存法更快，直接通过指针对内存进行操作，不需要进行拷贝，但是在C#中直接通过指针操作内存是不安全的，所以需要在代码中加入unsafe关键字，在生成选项中把允许不安全代码勾上，才能编译通过

　　这里定义成PointerBitmap类

复制代码 
public class PointBitmap
            {
                Bitmap source = null;
                IntPtr Iptr = IntPtr.Zero;
                BitmapData bitmapData = null;

                public int Depth { get; private set; }
                public int Width { get; private set; }
                public int Height { get; private set; }

                public PointBitmap(Bitmap source)
                {
                    this.source = source;
                }

                public void LockBits()
                {
                    try
                    {
                        // Get width and height of bitmap
                        Width = source.Width;
                        Height = source.Height;

                        // get total locked pixels count
                        int PixelCount = Width * Height;

                        // Create rectangle to lock
                        Rectangle rect = new Rectangle(0, 0, Width, Height);

                        // get source bitmap pixel format size
                        Depth = System.Drawing.Bitmap.GetPixelFormatSize(source.PixelFormat);

                        // Check if bpp (Bits Per Pixel) is 8, 24, or 32
                        if (Depth != 8 && Depth != 24 && Depth != 32)
                        {
                            throw new ArgumentException("Only 8, 24 and 32 bpp images are supported.");
                        }

                        // Lock bitmap and return bitmap data
                        bitmapData = source.LockBits(rect, ImageLockMode.ReadWrite,
                                                     source.PixelFormat);

                        //得到首地址
                        unsafe
                        {
                            Iptr = bitmapData.Scan0;
                            //二维图像循环
                            
                        }
                    }
                    catch (Exception ex)
                    {
                        throw ex;
                    }
                }

                public void UnlockBits()
                {
                    try
                    {
                        source.UnlockBits(bitmapData);
                    }
                    catch (Exception ex)
                    {
                        throw ex;
                    }
                }

                public Color GetPixel(int x, int y)
                {
                    unsafe
                    {
                        byte* ptr = (byte*)Iptr;
                        ptr = ptr + bitmapData.Stride * y;
                        ptr += Depth * x / 8;
                        Color c = Color.Empty;
                        if (Depth == 32)
                        {
                            int a = ptr[3];
                            int r = ptr[2];
                            int g = ptr[1];
                            int b = ptr[0];
                            c = Color.FromArgb(a, r, g, b);
                        }
                        else if (Depth == 24)
                        {
                            int r = ptr[2];
                            int g = ptr[1];
                            int b = ptr[0];
                            c = Color.FromArgb(r, g, b);
                        }
                        else if (Depth == 8)
                        {
                            int r = ptr[0];
                            c = Color.FromArgb(r, r, r);
                        }
                        return c;
                    }
                }

                public void SetPixel(int x, int y, Color c)
                {
                    unsafe
                    {
                        byte* ptr = (byte*)Iptr;
                        ptr = ptr + bitmapData.Stride * y;
                        ptr += Depth * x / 8;
                        if (Depth == 32)
                        {
                            ptr[3] = c.A;
                            ptr[2] = c.R;
                            ptr[1] = c.G;
                            ptr[0] = c.B;
                        }
                        else if (Depth == 24)
                        {
                            ptr[2] = c.R;
                            ptr[1] = c.G;
                            ptr[0] = c.B;
                        }
                        else if (Depth == 8)
                        {
                            ptr[2] = c.R;
                            ptr[1] = c.G;
                            ptr[0] = c.B;
                        }
                    }
                }
            }
复制代码

使用方法这里就不列出来了，跟上面的LockBitmap类似

 

本文实例讲述了C#对图片文件的压缩、裁剪操作方法，在C#项目开发中非常有实用价值。分享给大家供大家参考。具体如下：

一般在做项目时，对图片的处理，以前都采用在上传时，限制其大小的方式，这样带来诸多不便。毕竟网站运维人员不一定会对图片做处理，经常超出大小限制，即使会使用图片处理软件的，也由于个人水平方面原因，处理效果差强人意。

于是采用C#为我们提供的图像编辑功能，实现一站式上传，通过程序生成所需大小、尺寸的目标图片。

具体步骤如下：

先说图片压缩：

第一步：需要读取一个图片文件，读取方法：

// 图片文件的全路径名称 
public Image ResourceImage =Image.FromFile(ImageFilePathAndName);

说明：

Image类：引用自System.Drawing，为源自 Bitmap 和 Metafile 的类提供功能的抽象基类。

主要属性：Size->获取此图像的以像素为单位的宽度和高度。

PhysicalDimension->获取此图像的宽度和高度（如果该图像是位图，以像素为单位返回宽度和高度。如果该图像是图元文件，则以0.01 毫米为单位返回宽度和高度。）。

PixelFormat->获取此 Image 的像素格式。

Height、Width->获取此 Image 的高度、宽度（以像素为单位）。

主要方法：FromFile(String)->从指定的文件创建 Image。

FromStream(Stream)->从指定的数据流创建 Image。

Save(String fileName)->将该 Image 保存到指定的文件或流。

Save(Stream, ImageFormat)->将此图像以指定的格式保存到指定的流中。

Save(String, ImageFormat)->将此 Image 以指定格式保存到指定文件。

更多属性和方法说明请点击。

第二步，生成缩略图，并且将原图内容按指定大小绘制到目标图片。

复制代码 
///  
/// 生成缩略图重载方法1，返回缩略图的Image对象 
///  
/// 缩略图的宽度 
/// 缩略图的高度 
/// 缩略图的Image对象 
public Image GetReducedImage(int Width, int Height) 
{ 
  try
  { 
 //用指定的大小和格式初始化Bitmap类的新实例 
 Bitmap bitmap = new Bitmap(Width, Height, PixelFormat.Format32bppArgb); 
 //从指定的Image对象创建新Graphics对象 
 Graphics graphics = Graphics.FromImage(bitmap); 
 //清除整个绘图面并以透明背景色填充 
 graphics.Clear(Color.Transparent); 
 //在指定位置并且按指定大小绘制原图片对象 
 graphics.DrawImage(ResourceImage, new Rectangle(0, 0, Width, Height)); 
 return bitmap; 
  } 
  catch (Exception e) 
  { 
 ErrMessage = e.Message; 
 return null; 
  } 
}
复制代码

说明：

1、Bitmap类

引用自System.Drawing，封装 GDI+ 位图，此位图由图形图像及其特性的像素数据组成。Bitmap 是用于处理由像素数据定义的图像的对象。

关于封装图像的对象，详细介绍可参看官方文档：http://msdn.microsoft.com/zh-cn/library/system.drawing.bitmap.aspx。

2、Graphics类

引用自System.Drawing，（处理图像的对象），封装一个 GDI+ 绘图图面。

关于Graphics类可点此查看官方教程：http://msdn.microsoft.com/zh-cn/library/system.drawing.graphics.aspx。

第三步，保存

第二步操作中返回的Image对象，暂时命名为：iImage:

iImage.Save(pathAndName, System.Drawing.Imaging.ImageFormat.Jpeg); 

以上是压缩操作，做了下试验，101k的图片，经过压缩后是57k。这个应该和尺寸有关系。

以下是图片裁剪，其实原理和上面相似，无非也就是对图片进行重画操作。

复制代码 
///  
/// 截取图片方法 
///  
/// 图片地址 
/// 开始位置-X 
/// 开始位置-Y 
/// 截取宽度 
/// 截取长度 
/// 文件名称 
/// 保存路径 
/// 后缀名 
public static string CutImage(string url, int beginX, int beginY, int getX, int getY, string fileName, string savePath, string fileExt) 
{ 
  if ((beginX < getX) && (beginY < getY)) 
  { 
 Bitmap bitmap = new Bitmap(url);//原图 
if (((beginX + getX) <= bitmap.Width) && ((beginY + getY) <= bitmap.Height)) 
 { 
   Bitmap destBitmap = new Bitmap(getX, getY);//目标图 
   Rectangle destRect = new Rectangle(0, 0, getX, getY);//矩形容器 
   Rectangle srcRect = new Rectangle(beginX, beginY, getX, getY); 
 
   Graphics.FromImage(destBitmap); 
　　　　　　　　　　　　Graphics.DrawImage(bitmap, destRect, srcRect, GraphicsUnit.Pixel); 
     
   ImageFormat format = ImageFormat.Png; 
   switch (fileExt.ToLower()) 
   { 
 case "png": 
   format = ImageFormat.Png; 
   break; 
 case "bmp": 
   format = ImageFormat.Bmp; 
   break; 
 case "gif": 
   format = ImageFormat.Gif; 
   break; 
   } 
   destBitmap.Save(savePath + "//" + fileName , format); 
   return savePath + "\\" + "*" + fileName.Split('.')[0] + "." + fileExt; 
 } 
 else
 { 
   return "截取范围超出图片范围"; 
 } 
  } 
  else
  { 
 return "请确认(beginX < getX)&&(beginY < getY)"; 
  } 
}
复制代码

说明：

Rectangle类：矩形，详情可参考官方文档：http://msdn.microsoft.com/zh-cn/library/system.windows.shapes.rectangle(v=vs.85).aspx

转载于:https://www.cnblogs.com/cjm123/p/9231207.html

你可能感兴趣的:(c#,运维,操作系统)

  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • C#中使用split分割字符串 互联网打工人no1 c#
    1、用字符串分隔：usingSystem.Text.RegularExpressions;stringstr="aaajsbbbjsccc";string[]sArray=Regex.Split(str,"js",RegexOptions.IgnoreCase);foreach(stringiinsArray)Response.Write(i.ToString()+"");输出结果：aaabbbc
  • PHP环境搭建详细教程 好看资源平台 前端php
    PHP是一个流行的服务器端脚本语言，广泛用于Web开发。为了使PHP能够在本地或服务器上运行，我们需要搭建一个合适的PHP环境。本教程将结合最新资料，介绍在不同操作系统上搭建PHP开发环境的多种方法，包括Windows、macOS和Linux系统的安装步骤，以及本地和Docker环境的配置。1.PHP环境搭建概述PHP环境的搭建主要分为以下几类：集成开发环境：例如XAMPP、WAMP、MAMP，这
  • python os 环境变量 CV矿工 python开发语言numpy
    环境变量：环境变量是程序和操作系统之间的通信方式。有些字符不宜明文写进代码里，比如数据库密码，个人账户密码，如果写进自己本机的环境变量里，程序用的时候通过os.environ.get（）取出来就行了。os.environ是一个环境变量的字典。环境变量的相关操作importos"""设置/修改环境变量：os.environ[‘环境变量名称’]=‘环境变量值’#其中key和value均为string类
  • 你可能遗漏的一些C#/.NET/.NET Core知识点 追逐时光者 C#.NETDotNetGuide编程指南c#.net.netcoremicrosoft
    前言在这个快速发展的技术世界中，时常会有一些重要的知识点、信息或细节被忽略或遗漏。《C#/.NET/.NETCore拾遗补漏》专栏我们将探讨一些可能被忽略或遗漏的重要知识点、信息或细节，以帮助大家更全面地了解这些技术栈的特性和发展方向。拾遗补漏GitHub开源地址https://github.com/YSGStudyHards/DotNetGuide/blob/main/docs/DotNet/D
  • 【从浅识到熟知Linux】Linux发展史 Jammingpro 从浅学到熟知Linuxlinux运维服务器
    归属专栏：从浅学到熟知Linux个人主页：Jammingpro每日努力一点点，技术变化看得见文章前言：本篇文章记录Linux发展的历史，因在介绍Linux过程中涉及的其他操作系统及人物，本文对相关内容也有所介绍。文章目录Unix发展史Linux发展史开源Linux官网企业应用情况发行版本在学习Linux前，我们可能都会问Linux从哪里来？它是如何发展的。但在介绍Linux之前，需要先介绍一下Un
  • linux 发展史 种树的猴子 内核java操作系统linux大数据
    linux发展史说明此前对linux认识模糊一知半解，近期通过学习将自己对于linux的发展总结一下方便大家日后的学习。那Linux是目前一款非常火热的开源操作系统，可是linux是什么时候出现的，又是因为什么样的原因被开发出来的呢。以下将对linux的发展历程进行详细的讲解。目录一、Linux发展背景二、UINIX的诞生三、UNIX的重要分支-BSD的诞生四、Minix的诞生五、GNU与Free
  • 2023最详细的Python安装教程（Windows版本） 程序员林哥 Pythonpythonwindows开发语言
    python安装是学习pyhon第一步，很多刚入门小白不清楚如何安装python，今天我来带大家完成python安装与配置，跟着我一步步来，很简单，你肯定能完成。第一部分：python安装（一）准备工作1、下载和安装python(认准官方网站)当然你不想去下载的话也可以分享给你，还有入门学习教程，点击下方卡片跳转进群领取（二）开始安装对于Windows操作系统，可以下载“executableins
  • 深入浅出 -- 系统架构之负载均衡Nginx的性能优化 xiaoli8748_软件开发 系统架构系统架构负载均衡nginx
    一、Nginx性能优化到这里文章的篇幅较长了，最后再来聊一下关于Nginx的性能优化，主要就简单说说收益最高的几个优化项，在这块就不再展开叙述了，毕竟影响性能都有多方面原因导致的，比如网络、服务器硬件、操作系统、后端服务、程序自身、数据库服务等，对于性能调优比较感兴趣的可以参考之前《JVM性能调优》中的调优思想。优化一：打开长连接配置通常Nginx作为代理服务，负责分发客户端的请求，那么建议开启H
  • 经纬恒润二面&三七互娱一面&元象二面 Redstone Monstrosity 面试前端
    1.请尽可能详细地说明，进程和线程的区别，分别有哪些应用场景？进程间如何通信？线程间如何通信？你的回答中不要写出示例代码。进程和线程是操作系统中的两个基本概念，它们在计算机系统中扮演着不同的角色，并且在不同的应用场景中发挥作用。进程和线程的区别定义：进程：进程是操作系统进行资源分配和调度的基本单位。每个进程都有独立的内存空间和系统资源。线程：线程是进程内的一个执行单元，是操作系统进行调度的最小单位
  • C++常见知识掌握 nfgo c++开发语言
    1.Linux软件开发、调试与维护内核与系统结构Linux内核是操作系统的核心，负责管理硬件资源，提供系统服务，它是系统软件与硬件之间的桥梁。主要组成部分包括：进程管理：内核通过调度器分配CPU时间给各个进程，实现进程的创建、调度、终止等操作。使用进程描述符（task_struct）来存储进程信息，包括状态（就绪、运行、阻塞等）、优先级、内存映射等。内存管理：包括物理内存和虚拟内存管理。通过页表映
  • 2020年最新程序员职业发展路线指南，超详细！ 编程流川枫 11编程语言程序员互联网IT职业
    【文章来源微信公众号：每天学编程】01、程序员的特性技术出身的职场人特性很明显，与做市场、业务出身的职场人区别尤其明显。IT行业中常见的一些职场角色：老板、项目经理、产品经理、需求分析师、设计师、开发工程师、运维工程师等。开发工程师具有如下特征：1、逻辑思维清晰、严谨和细腻；但是有时不容易转弯，有些程序员容易较劲、钻牛角尖。2、性格偏内向、不善于沟通、表达和交际；但是在网络聊天工具上，有些显为幽默
  • AUTO TECH 2025 广州国际汽车软件与安全技术展览会 ws201907 汽车安全
    AUTOTECH2025广州国际汽车软件与安全技术展览会ChinaGuangzhouSoftware-DefinedVehicleExpo2025亚洲领先的汽车软件与安全技术专业展会——是与来自世界各地的汽车工程师们交流的最佳平台！广州国际汽车软件与安全技术展览会是AUTOTECH2025华南展专题展之一，汇集了各种汽车嵌入式软件开发与应用、车载操作系统、智驾功能安全与SOTIF、基础软件平台、车
  • 【从问题中去学习k8s】k8s中的常见面试题（夯实理论基础）（二十八） 向往风的男子 k8s学习kubernetes容器
    本站以分享各种运维经验和运维所需要的技能为主《python零基础入门》：python零基础入门学习《python运维脚本》：python运维脚本实践《shell》：shell学习《terraform》持续更新中：terraform_Aws学习零基础入门到最佳实战《k8》从问题中去学习k8s《docker学习》暂未更新《ceph学习》ceph日常问题解决分享《日志收集》ELK+各种中间件《运维日常》
  • python中文版软件下载-Python中文版 编程大乐趣
    python中文版是一种面向对象的解释型计算机程序设计语言。python中文版官网面向对象编程，拥有高效的高级数据结构和简单而有效的方法，其优雅的语法、动态类型、以及天然的解释能力，让它成为理想的语言。软件功能强大，简单易学，可以帮助用户快速编写代码，而且代码运行速度非常快，几乎可以支持所有的操作系统，实用性真的超高的。python中文版软件介绍：python中文版的解释器及其扩展标准库的源码和编
  • 关闭Windows自动更新的6种方法 Gemini1995 windows
    在Windows操作系统中，可以使用多种方法来关闭自动更新。以下是其中一些常用的方法：使用设置应用：打开“设置”应用（Win+I），选择“更新和安全”。在左侧菜单中选择“Windows更新”。点击“更改活动时间”或“高级选项”。在“更新选项”下拉菜单中选择“通知我但不自动下载或安装”或“从不检查更新”。通过服务管理器：打开“服务”管理器，可以通过在运行对话框中输入services.msc来打开。找
  • C#动态加载DLL程序集及使用反射创建实例-简记 不全 C#相关Asp.netWebFormAsp.netMVCc#Assembly反射程序集
    Assembly动态加载程序集：分两种情况：1、需要加载的程序集已经在程序中被引用了，则直接从当前程序域中查找即可：Assemblyassembly=AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault(x=>x.GetName().Name.Contains("theAssemblyName"));2、需要加载的程序集未被加载，则使用程序集
  • 开发游戏的学习规划 杰克逊的日记 游戏学习
    第一阶段：●C#语言快速系统地学习一遍（基础的语法、面向对象、基础的数据结构、基础的设计模式）●Unity的2D和3D部分及UI、动画、物理系统●阶段性测验：需要去用前面所学的这些基础知识来完成一个简单的2d或者3d的案例，将通过一个自制的《Flappybird》游戏案例讲解游戏开发的思想及方法，并将《Flappybird》这个游戏进一步改造成一个横版射击类游戏《Crazybird》以巩固并且升华
  • python可以制作大型游戏_python能做游戏吗-python能开发游戏吗 靖dede python可以制作大型游戏
    python可以写游戏，但不适合。下面我们来分析一下具体原因。用锤子能造汽车吗？谁也没法说不能吧？历史上也确实曾经有些汽车，是用锤子造出来的。但一般来说，还是用工业机器人更合适对吗？比较大型的，使用Python的游戏有两个，一个是《EVE》，还有一个是《文明》。但这仅仅是个例，没有广泛意义。一般来说，用来做游戏的语言，有两种。一是C++。。一是C#。。Python理论上，不仅不适合做游戏，而是只要
  • ruby和python哪个好学 hakesashou python基础知识rubypython开发语言
    Ruby和python都挺好学的。建议学习Python，语法的话，Python相对更简洁。而且Python应用场合更广泛，运维、网站开发、数据处理、科学研究都可以。Ruby和Python十分相似，有很多共同点，但也有一些不同之外，以下是Python和Ruby的对比：1、Python和Ruby都是面向对象的语言，都是动态和灵活的。二者的主要区别在于他们解决问题的方式。Ruby提供了不同的方法，而Py
  • Day9：别沦为自动化的奴隶——为自己建一座“喷泉广场” 钱塘风华
    电子设备解决了小麻烦，却制造了大麻烦。【书名】：混乱——如何成为失控时代的掌控者【作者】：蒂姆哈福德【本书总页码】：288【已读页码】：220（第七章：自动化end）2009年5月31日晚，法航447号航班在电传操作系统失效的情况下，飞行员因习惯了对电传操作系统的依赖，无法对当时的情况作出正确判断，因而也无法作出对应操作——当时的情况：飞机因为急速上升后，过于稀薄的空气密度导致飞机失速，机头抬升，
  • OpenCV图像处理技术（Python）——入门 森屿_ opencv
    ©FuXianjun.AllRightsReserved.OpenCV入门图像作为人类感知世界的视觉基础，是人类获取信息、表达信息的重要手段，OpenCV作为一个开源的计算机视觉库，它包括几百个易用的图像成像和视觉函数，既可以用于学术研究，也可用于工业邻域，它于1999年由因特尔的GaryBradski启动，OpenCV库主要由C和C++语言编写，它可以在多个操作系统上运行。1.1图像处理基本操作
  • 如何重启Linux服务器？ 老男孩IT教育 gitlinux运维
    在Linux操作系统中，提供了多种方法用于重启服务器，那么Linux服务器如何重启?以下列举了常用的几种方法，希望对大家有所帮助，快来看看吧。重启Linux服务器有以下几种方法：1、使用命令行使用reboot命令reboot使用shutdown命令shutdown-rnow2、使用systemctl使用以下命令：systemctlreboot3、使用web界面大多数现代Linux发行版本都提供一个
  • 操作系统基础 怡晗★ Linuxlinux
    目录操作系统基础冯诺依曼体系结构介绍操作系统基本认知本篇文章是后面学习操作系统知识的基础操作系统基础冯诺依曼体系结构介绍冯诺依曼体系结构如下：在上图中「输入设备」和「输出设备」一般被称为计算机的外设，而「存储器」在冯诺依曼体系结构中表示「内存」输入设备一般包括：网卡、磁盘、键盘、触摸屏等输出设备一般包括：网卡、磁盘、鼠标、触摸屏、显示器（非触摸屏）等内存的作用「内存」是中央处理器与计算机其他设备的
  • 【C#生态园】深度剖析：C#嵌入式开发工具大揭秘 friklogff C#生态园c#开发语言
    C#嵌入式开发：全面了解六大框架与库前言随着物联网和嵌入式系统的快速发展，越来越多的开发者开始关注使用C#语言进行嵌入式开发。本文将介绍几种用于C#的嵌入式开发框架和相关库，以及它们的核心功能、安装配置方法和API概览，帮助读者了解并选择适合自己项目的工具和资源。欢迎订阅专栏：C#生态园文章目录C#嵌入式开发：全面了解六大框架与库前言1.nanoFramework：一个用于C#的嵌入式开发框架1.
  • Lua 与 C#交互 z2014z luac#开发语言
    Lua与C#交互前提Lua是一种嵌入式脚本语言，Lua的解释器是用C编写的，因此可以方便的与C/C++进行相互调用。轻量级Lua语言的官方版本只包括一个精简的核心和最基本的库，这使得Lua体积小、启动速度快，也适合嵌入在别的程序里。交互过程C#调用Lua:由C#文件调用Lua解析器底层dll库（由C语言编写），再由dll文件执行相应的Lua文件。Lua调用C#：1、Wrap方式：首先生成C#源文件
  • golang学习笔记--MPG模型 xxzed golang#学习笔记学习笔记golang
    MPG模式：M（Machine）：操作系统的主线程P（Processor）：协程执行需要的资源（上下文context），可以看作一个局部的调度器，使go代码在一个线程上跑，他是实现从N：1到N：M映射的关键G（Goroutine）：协程，有自己的栈。包含指令指针（instructionpointer）和其它信息（正在等待的channel等等），用于调度。一个P下面可以有多个G1、当前程序有三个M,
  • C# 开发教程-入门基础 天马3798 教程系列整理c#开发语言
    1.C#简介、环境，程序结构2.C#基本语法，变量，控制局域，数据类型，类型转换3.C#数组、循环，Linq4.C#类，封装，方法5.C#枚举、字符串6.C#面相对象，继承，封装，多态7.C#特性、属性、反射、索引器8.C#委托，事件，集合，泛型9.C#匿名方法10.C#多线程更多：JQuery开发教程入门基础Vue开发基础入门教程Vue开发高级学习教程
  • Linux使用mjpg-streamer进行图像传输 —你的鼬先生 Linux驱动linux树莓派图像传输
    图像传输是一项在Linux操作系统中比较常见的一个操作，在视频图传时，一般是采用MJPG-streamer来进行图像传输，本文就以树莓派为例子，来示范一个图像传输。1.树莓派的摄像头激活首先更新树莓派sudoapt-getupdatesudoapt-getupgrade随后打开树莓派的配置界面，选择InterfaceOptionsudoraspi-config在InterfaceOption选择C
  • C# 禁止程序重复启动 wiseyao1219 c#
    修改：Program.cs[STAThread]staticvoidMain(){Mutexmutex=newMutex(true,"NewGuid123456",outboolisCreatedNew);if(!isCreatedNew){MessageBox.Show(Application.ProductName+"isrunning...");return;}Application.Ena
  • 基本数据类型和引用类型的初始值 3213213333332132 java基础
    package com.array; /** * @Description 测试初始值 * @author FuJianyong * 2015-1-22上午10:31:53 */ public class ArrayTest { ArrayTest at; String str; byte bt; short s; int i; long
  • 摘抄笔记--《编写高质量代码：改善Java程序的151个建议》 白糖_ 高质量代码
            记得3年前刚到公司，同桌同事见我无事可做就借我看《编写高质量代码：改善Java程序的151个建议》这本书，当时看了几页没上心就没研究了。到上个月在公司偶然看到，于是乎又找来看看，我的天，真是非常多的干货，对于我这种静不下心的人真是帮助莫大呀。           看完整本书，也记了不少笔记
  • 【备忘】Django 常用命令及最佳实践 dongwei_6688 django
    注意：本文基于 Django 1.8.2 版本   生成数据库迁移脚本（python 脚本） python manage.py makemigrations polls  说明：polls 是你的应用名字，运行该命令时需要根据你的应用名字进行调整   查看该次迁移需要执行的 SQL 语句（只查看语句，并不应用到数据库上）： python manage.p
  • 阶乘算法之一N! 末尾有多少个零 周凡杨 java算法阶乘面试效率
                                     &n
  • spring注入servlet g21121 Spring注入
    传统的配置方法是无法将bean或属性直接注入到servlet中的，配置代理servlet亦比较麻烦，这里其实有比较简单的方法，其实就是在servlet的init()方法中加入要注入的内容： ServletContext application = getServletContext(); WebApplicationContext wac = WebApplicationContextUtil
  • Jenkins 命令行操作说明文档 510888780 centos
    假设Jenkins的URL为http://22.11.140.38:9080/jenkins/ 基本的格式为 java 基本的格式为 java -jar jenkins-cli.jar [-s JENKINS_URL] command [options][args] 下面具体介绍各个命令的作用及基本使用方法 1. &nb
  • UnicodeBlock检测中文用法 布衣凌宇 UnicodeBlock
    /**  * 判断输入的是汉字  */ public static boolean isChinese(char c) {        Character.UnicodeBlock ub = Character.UnicodeBlock.of(c);    
  • java下实现调用oracle的存储过程和函数 aijuans javaorale
    1.创建表：STOCK_PRICES     2.插入测试数据：     3.建立一个返回游标：  PKG_PUB_UTILS   4.创建和存储过程：P_GET_PRICE     5.创建函数：   6.JAVA调用存储过程返回结果集 JDBCoracle10G_INVO
  • Velocity Toolbox antlove 模板toolboxvelocity
    velocity.VelocityUtil package velocity; import org.apache.velocity.Template; import org.apache.velocity.app.Velocity; import org.apache.velocity.app.VelocityEngine; import org.apache.velocity.c
  • JAVA正则表达式匹配基础 百合不是茶 java正则表达式的匹配
      正则表达式;提高程序的性能,简化代码,提高代码的可读性,简化对字符串的操作   正则表达式的用途; 字符串的匹配 字符串的分割 字符串的查找 字符串的替换       正则表达式的验证语法     [a] //[]表示这个字符只出现一次 ,[a] 表示a只出现一
  • 是否使用EL表达式的配置 bijian1013 jspweb.xmlELEasyTemplate
            今天在开发过程中发现一个细节问题，由于前端采用EasyTemplate模板方法实现数据展示，但老是不能正常显示出来。后来发现竟是EL将我的EasyTemplate的${...}解释执行了，导致我的模板不能正常展示后台数据。         网
  • 精通Oracle10编程SQL(1-3)PLSQL基础 bijian1013 oracle数据库plsql
    --只包含执行部分的PL/SQL块 --set serveroutput off begin dbms_output.put_line('Hello,everyone!'); end; select * from emp; --包含定义部分和执行部分的PL/SQL块 declare v_ename varchar2(5); begin select
  • 【Nginx三】Nginx作为反向代理服务器 bit1129 nginx
    Nginx一个常用的功能是作为代理服务器。代理服务器通常完成如下的功能：   接受客户端请求 将请求转发给被代理的服务器 从被代理的服务器获得响应结果 把响应结果返回给客户端 实例 本文把Nginx配置成一个简单的代理服务器 对于静态的html和图片，直接从Nginx获取 对于动态的页面，例如JSP或者Servlet，Nginx则将请求转发给Res
  • Plugin execution not covered by lifecycle configuration: org.apache.maven.plugin blackproof maven报错
    转：http://stackoverflow.com/questions/6352208/how-to-solve-plugin-execution-not-covered-by-lifecycle-configuration-for-sprin   maven报错： Plugin execution not covered by lifecycle configuration:
  • 发布docker程序到marathon ronin47 docker 发布应用
    1 发布docker程序到marathon 1.1 搭建私有docker registry 1.1.1 安装docker regisry docker pull docker-registry docker run -t -p 5000:5000 docker-registry 下载docker镜像并发布到私有registry docker pull consol/tomcat-8.0
  • java-57-用两个栈实现队列&&用两个队列实现一个栈 bylijinnan java
    import java.util.ArrayList; import java.util.List; import java.util.Stack; /* * Q 57 用两个栈实现队列 */ public class QueueImplementByTwoStacks { private Stack<Integer> stack1; pr
  • Nginx配置性能优化 cfyme nginx
    转载地址：http://blog.csdn.net/xifeijian/article/details/20956605   大多数的Nginx安装指南告诉你如下基础知识——通过apt-get安装，修改这里或那里的几行配置，好了，你已经有了一个Web服务器了。而且，在大多数情况下，一个常规安装的nginx对你的网站来说已经能很好地工作了。然而，如果你真的想挤压出Nginx的性能，你必
  • [JAVA图形图像]JAVA体系需要稳扎稳打,逐步推进图像图形处理技术 comsci java
         对图形图像进行精确处理，需要大量的数学工具，即使是从底层硬件模拟层开始设计，也离不开大量的数学工具包，因为我认为，JAVA语言体系在图形图像处理模块上面的研发工作，需要从开发一些基础的，类似实时数学函数构造器和解析器的软件包入手，而不是急于利用第三方代码工具来实现一个不严格的图形图像处理软件......   &nb
  • MonkeyRunner的使用 dai_lm androidMonkeyRunner
    要使用MonkeyRunner，就要学习使用Python，哎 先抄一段官方doc里的代码 作用是启动一个程序（应该是启动程序默认的Activity），然后按MENU键，并截屏 # Imports the monkeyrunner modules used by this program from com.android.monkeyrunner import MonkeyRun
  • Hadoop-- 海量文件的分布式计算处理方案 datamachine mapreducehadoop分布式计算
    csdn的一个关于hadoop的分布式处理方案，存档。 原帖：http://blog.csdn.net/calvinxiu/article/details/1506112。     Hadoop 是Google MapReduce的一个Java实现。MapReduce是一种简化的分布式编程模式，让程序自动分布到一个由普通机器组成的超大集群上并发执行。就如同ja
  • 以資料庫驗證登入 dcj3sjt126com yii
    以資料庫驗證登入 由於 Yii 內定的原始框架程式, 採用綁定在UserIdentity.php 的 demo 與 admin 帳號密碼:    public function authenticate()    {        $users=array( &nbs
  • github做webhooks：[2]php版本自动触发更新 dcj3sjt126com githubgitwebhooks
    上次已经说过了如何在github控制面板做查看url的返回信息了。这次就到了直接贴钩子代码的时候了。 工具/原料 git github 方法/步骤   在github的setting里面的webhooks里把我们的url地址填进去。   钩子更新的代码如下： error_reportin
  • Eos开发常用表达式 蕃薯耀 Eos开发Eos入门Eos开发常用表达式
    Eos开发常用表达式 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 蕃薯耀 2014年8月18日 15:03:35 星期一     &
  • SpringSecurity3.X--SpEL 表达式 hanqunfeng SpringSecurity
    使用 Spring 表达式语言配置访问控制，要实现这一功能的直接方式是在<http>配置元素上添加 use-expressions 属性：   <http auto-config="true" use-expressions="true"> 这样就会在投票器中自动增加一个投票器：org.springframework
  • Redis vs Memcache IXHONG redis
    1. Redis中，并不是所有的数据都一直存储在内存中的，这是和Memcached相比一个最大的区别。 2. Redis不仅仅支持简单的k/v类型的数据，同时还提供list，set，hash等数据结构的存储。 3. Redis支持数据的备份，即master-slave模式的数据备份。 4. Redis支持数据的持久化，可以将内存中的数据保持在磁盘中，重启的时候可以再次加载进行使用。 Red
  • Python - 装饰器使用过程中的误区解读 kvhur JavaScriptjqueryhtml5css
    大家都知道装饰器是一个很著名的设计模式，经常被用于AOP(面向切面编程)的场景，较为经典的有插入日志，性能测试，事务处理，Web权限校验， Cache等。 原文链接：http://www.gbtags.com/gb/share/5563.htm Python语言本身提供了装饰器语法（@），典型的装饰器实现如下：   @function_wrapper de
  • 架构师之mybatis-----update 带case when 针对多种情况更新 nannan408 case when
    1.前言.    如题. 2. 代码.   <update id="batchUpdate" parameterType="java.util.List"> <foreach collection="list" item="list" index=&
  • Algorithm算法视频教程 栏目记者 Algorithm算法
    课程：Algorithm算法视频教程 百度网盘下载地址： http://pan.baidu.com/s/1qWFjjQW 密码: 2mji 程序写的好不好,还得看算法屌不屌！Algorithm算法博大精深。 一、课程内容： 课时1、算法的基本概念 + Sequential search 课时2、Binary search 课时3、Hash table 课时4、Algor
  • C语言算法之冒泡排序 qiufeihu c算法
    任意输入10个数字由小到大进行排序。 代码： #include <stdio.h> int main() { int i,j,t,a[11]; /*定义变量及数组为基本类型*/ for(i = 1;i < 11;i++){ scanf("%d",&a[i]); /*从键盘中输入10个数*/ } for
  • JSP异常处理 wyzuomumu Webjsp
    1.在可能发生异常的网页中通过指令将HTTP请求转发给另一个专门处理异常的网页中: <%@ page errorPage="errors.jsp"%>   2.在处理异常的网页中做如下声明： errors.jsp: <%@ page isErrorPage="true"%>，这样设置完后就可以在网页中直接访问exc