无欢以承
无欢以承

C#快速入门

        时过境迁，今年java求职是真的难，boss直聘往年每天99+，今年仿佛落寂深林一般。此诚危急存亡之秋也。好在最近内推进了一家,不过做的.net,这不重新捡起大学老本么。为了快速上手公司项目，赶紧温习些重点。

目录

辅助学习文档：C# 封装 | 菜鸟教程 (runoob.com)

结构体struct

数据类型 

访问修饰符 

特性（Attribute） 

规定特性：

预定义特性：

1. AttributeUsageAttribute：该特性可以用于声明其他特性的使用约束。通过指定 AttributeTargets 枚举作为参数，可以限制特性应用的类型。例如：

2. ConditionalAttribute：此特性可以用于指示方法或属性在编译时预处理期间是否应该被忽略。例如：

3. ObsoleteAttribute：该特性可以用于声明过时的方法或类型。其第一个参数是对比较新的 API 的警告消息。

4. SerializableAttribute：当需要将对象序列化为字节数组以便存储或传输时，可以应用此特性来控制序列化行为。

反射（reflection） 

System.Type类

索引器（indexer） 

委托（delegate） 

委托的声明和使用

委托链：C#中的委托也支持委托链，即将多个委托合并在一起以便同时调用。例如将两个委托合并可以使用+运算符，而将一个委托从另一个委托中删除则使用-运算符。

泛型委托

委托中的Lambda表达式

使用委託代替Action類型

事件（event） 

事件委托：

Observer设计模式

.NET 框架中的委托与事件

委托和方法的异步调用

多线程 

使用Thread类

使用Task类

使用ThreadPool类

 集合

List

Dictionary

Queue

Stack

其他补充

辅助学习文档：C# 封装 | 菜鸟教程 (runoob.com)

结构体struct

定义及作用 

  • 在 C# 中，结构体（struct）是一种用户自定义的值类型，它可以包含不同数据类型的成员变量和方法。与类不同，结构体是轻量级的，并且是按值传递的。
  • 下面是一个示例结构体的定义： 
    public struct Point 
{
    public int X; // 结构体中的公共字段
    public int Y;
    public Point(int x, int y)  // 结构体中的构造函数
    {
        X = x;
        Y = y;
    }
    public void Display()  // 结构体中的方法
    {
        Console.WriteLine("X = {0}, Y = {1}", X, Y);
    }
}

//  使用结构体时，可以像使用其他类型的变量一样来声明和初始化它：

Point point1 = new Point(10, 20);

//  也可以直接对结构体进行赋值：

Point point2;
point2.X = 30;
point2.Y = 40;

    需要注意的是，当定义一个结构体时，必须为每个公共字段分配默认值，否则编译器会报错。默认情况下，所有的字段都被初始化为零值。

结构体的作用范围被限定在定义它的命名空间内，在方法或属性内部创建的结构体对象将在方法执行结束后就会立即销毁。因此，它们的生命周期较短，适合用于小型数据类型或者要频繁创建和销毁的对象。

与类的区别

  • 1. 存储方式： 结构体是值类型，而类是引用类型。值类型存储在栈中，而引用类型存储在堆中。
  • 2. 性能： 在声明变量时，对于简单的数据类型和小的对象，使用结构体可能比使用类更快，因为它们不需要从堆中分配内存和回收内存。
  • 3. 继承： 类支持继承，而结构体不支持继承。
  • 4. 初始化： 结构体可以有无参构造函数和参数化构造函数，但没有析构函数。类可以有无参、参数化构造函数和析构函数。
  • 5. 赋值： 对结构体的赋值操作会创建该结构体的一个副本，并将其存储在另一块内存中；而对类进行赋值操作时，只是将一个指向原始对象的新引用存储在另一个变量中，两个变量将引用同一个对象。

总的来说，结构体和类之间的区别在于它们的实现方式不同。如果你要处理较小的数据类型或者要频繁地创建和销毁对象，使用结构体比较合适；如果你需要支持继承、动态多态性等高级功能，那么使用类就更加适合。

数据类型 

  • 以下是 C# 中常用的数据类型及其取值范围和内存占用大小等信息的表格：

    C#快速入门_第1张图片

  • 特殊类型：
    • 动态（Dynamic）类型
      • 您可以存储任何类型的值在动态数据类型变量中。这些变量的类型检查是在运行时发生的。
      • 声明动态类型的语法：dynamic = value;
    • 指针类型（Pointer types）
      • 指针类型变量存储另一种类型的内存地址。C# 中的指针与 C 或 C++ 中的指针有相同的功能。
      • 声明指针类型的语法：type* identifier;
  • 注意：以上表格中数据类型所占内存大小是在 32 位机器上运行时的情况，64 位机器上可能会略有不同。另外，C# 中的许多数据类型也有其它的属性和方法，因此可以扩展它们的功能来满足特定的需求。

访问修饰符 

  • public：公共的，对所有程序集可见。
  • private：私有的，只对当前类可见，不能被其它类引用。
  • protected：受保护的，对当前类和派生类可见，其他类不能访问该成员。
  • internal：内部的，对同一程序集中的类可见，对其他程序集不可见。
  • protected internal：受保护的内部的，对同一程序集中的类以及派生类可见，对其他程序集不可见。

特性（Attribute） 

  • 定义：用于在运行时传递程序中各种元素（比如类、方法、结构、枚举、组件等）的行为信息的声明性标签。您可以通过使用特性向程序添加声明性信息。一个声明性标签是通过放置在它所应用的元素前面的方括号（[ ]）来描述的。
  • 特性（Attribute）用于添加元数据，如编译器指令和注释、描述、方法、类等其他信息。.Net 框架提供了两种类型的特性：预定义特性和自定义特性。
  • 作用：
    • - 帮助编写器检查代码错误
    • - 控制编译器行为
    • - 支持自定义属性的序列化和反序列化
    • - 暴露调试、测试和执行信息

  • 规定特性：

    • [attribute(positional_parameters, name_parameter = value, ...)]element
    • 特性（Attribute）的名称和值是在方括号内规定的，放置在它所应用的元素之前。positional_parameters 规定必需的信息，name_parameter 规定可选的信息。

  • 预定义特性：

    • C#语言中的特性（Attribute）是在代码中可用于添加注释和元数据的一种语言结构。特性提供了一种简单而强大的方式来描述类型、成员和程序集等元素，以便能够在运行时进行获取或分析。
    • 1. AttributeUsageAttribute：该特性可以用于声明其他特性的使用约束。通过指定 AttributeTargets 枚举作为参数，可以限制特性应用的类型。例如：
      [AttributeUsage(AttributeTargets.Class)]
public class MyCustomAttribute : Attribute
{
// ...
}
       
      • 语法：[AttributeUsage( validon, AllowMultiple=allowmultiple, Inherited=inherited)]
      • 参数 validon 规定特性可被放置的语言元素。它是枚举器 AttributeTargets 的值的组合。默认值是 AttributeTargets.All。
      • 参数 allowmultiple（可选的）为该特性的 AllowMultiple 属性（property）提供一个布尔值。如果为 true，则该特性是多用的。默认值是 false（单用的）。
      • 参数 inherited（可选的）为该特性的 Inherited 属性（property）提供一个布尔值。如果为 true，则该特性可被派生类继承。默认值是 false（不被继承）。
      • 例如：[AttributeUsage(AttributeTargets.Class |AttributeTargets.Constructor |AttributeTargets.Field |AttributeTargets.Method |AttributeTargets.Property, AllowMultiple = true)]
    • 2. ConditionalAttribute：此特性可以用于指示方法或属性在编译时预处理期间是否应该被忽略。例如：
    • [Conditional("DEBUG")]
public void Log(string message)
{
// ...
}

      这表示 Log 方法仅在调试模式下编译并包含在二进制文件中。

    • 3. ObsoleteAttribute：该特性可以用于声明过时的方法或类型。其第一个参数是对比较新的 API 的警告消息。
      • 例如： 
        [Obsolete("Use the NewMethod instead.")]
public void OldMethod()
{
// ...
}

        这将使编译器在代码中使用此方法时生成一个警告。

    • 4. SerializableAttribute：当需要将对象序列化为字节数组以便存储或传输时，可以应用此特性来控制序列化行为。
    • 例如： 
      [Serializable]
public class MyCustomClass
{
public int Id { get; set; }
public string Name { get; set; }
}

反射（reflection） 

  • 定义：
    • 反射指程序可以访问、检测和修改它本身状态或行为的一种能力。
    • 程序集包含模块，而模块包含类型，类型又包含成员。反射则提供了封装程序集、模块和类型的对象。
    • 您可以使用反射动态地创建类型的实例，将类型绑定到现有对象，或从现有对象中获取类型。然后，可以调用类型的方法或访问其字段和属性。
  • 用途：
    • 它允许在运行时查看特性（attribute）信息。
    • 它允许审查集合中的各种类型，以及实例化这些类型。
    • 它允许延迟绑定的方法和属性（property）。
    • 它允许在运行时创建新类型，然后使用这些类型执行一些任务。
  • 查看元数据：
    • System.Reflection 类的 MemberInfo 对象需要被初始化，用于发现与类相关的特性（attribute）
    • System.Reflection.MemberInfo info = typeof(MyClass);

  • System.Type类

    • 在C#中，Type类表示一个类型（也称为一个类或结构）的元数据。使用Type类，您可以获取有关类型的各种信息，例如类型的名称、命名空间、基类型、实现的接口、字段、属性、方法等。
    • ​
using System;
class MyClass
{
public int MyField;
public void MyMethod() { }
}
class Program
{
static void Main(string[] args)
{
Type type = typeof(MyClass);
Console.WriteLine("类型名：" + type.Name);
Console.WriteLine("所属命名空间：" + type.Namespace);
Console.WriteLine("基类型：" + type.BaseType.Name);
Console.WriteLine("字段：");
foreach (var field in type.GetFields())
{
Console.WriteLine("- " + field.Name + "（" + field.FieldType + "）");
}
Console.WriteLine("方法：");
foreach (var method in type.GetMethods())
{
Console.WriteLine("- " + method.Name + "（" + method.ReturnType + "）");
}
}
}

​
    • Type类的GetCustomAttributes()方法用于获取特定类型及其成员上应用的自定义属性集合。
      • Type类的GetCustomAttributes()方法的第一个参数是要获取的自定义属性的类型，第二个参数指示是否搜索继承链并获取基类上的自定义属性。返回值是一个object数组，其中包含应用到类型或成员上的所有特定的自定义属性实例。
    • using System;
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
public class MyAttribute : Attribute
{
public string MyProperty { get; set; }
public MyAttribute(string propertyValue)
{
MyProperty = propertyValue;
}
}
[My("TestClass")]
class MyClass
{
[My("TestMethod")]
public void MyMethod() { }
}
class Program
{
static void Main(string[] args)
{
Type type = typeof(MyClass);
// 获取类型的自定义属性
object[] attributes = type.GetCustomAttributes(typeof(MyAttribute), true);
foreach (MyAttribute attribute in attributes)
{
Console.WriteLine("类的自定义属性：{0}", attribute.MyProperty);
}
// 获取方法的自定义属性
var method = type.GetMethod("MyMethod");
attributes = method.GetCustomAttributes(typeof(MyAttribute), true);
foreach (MyAttribute attribute in attributes)
{
Console.WriteLine("方法的自定义属性：{0}", attribute.MyProperty);
}
}
}

    • 在该示例中，首先定义了一个MyAttribute类作为自定义属性，并将其应用于MyClass类和其中的MyMethod方法。然后，我们使用Type类和MethodInfo类的GetCustomAttributes()方法获取MyClass类及其MyMethod方法上应用的MyAttribute自定义属性并输出其值。

索引器（indexer） 

  • 索引器（Indexer） 允许一个对象可以像数组一样使用下标的方式来访问。
  • 一维索引器的语法： 
    element-type this[int index]
{
// get 访问器
get
{
// 返回 index 指定的值
}
// set 访问器
set
{
// 设置 index 指定的值
}
}
  • 示例 
    class IndexerTest
{
private string[] namelist = new string[size];
public static int size = 10;
public IndexerTest()
{
for(int i = 0; i < size; i++)
{
namelist[i] = "N.S.";
}
}
public string this[int index]
{
get
{
string temp;
if (index >= 0 && index <= size - 1)
{
temp = namelist[index];
}
else
{
temp = "";
}
return (temp);
}
set
{
if (index >= 0 && index <= size - 1)
{
namelist[index] = value;
}
}
}
static void Main(string[] args)
{
IndexerTest names = new IndexerTest();
names[0] = "Zara";
names[1] = "Riz";
names[2] = "Nuha";
names[3] = "Asif";
names[4] = "Davinder";
names[5] = "Sunil";
names[6] = "Rubic";
for (int i = 0; i < IndexerTest.size; i++)
{
Console.WriteLine(names[i]);
}
Console.ReadLine();
}
}
  • 优点：
    • 1.方便地访问集合元素：通过索引器，您可以方便地像访问数组一样访问集合中的元素。这样就可以编写更灵活、更易用的代码，同时将代码与处理数据相关的其他细节分离开来。
    • 2.提供更多的灵活性：索引器可以有多个参数，这意味着您可以将其用于操作多维集合和其他更加复杂的数据结构。
    • 3.更好的可读性：使用索引器可以使您的代码更具可读性。它可以让您直接处理数据集合，而无需编写常规的附加函数或API调用来进行相同的操作。
    • 4.更好的性能：在某些情况下，使用索引器比使用属性更快。这是因为多次调用setter和getter方法可能导致额外的开销和性能损失，而使用索引器可以更快地读取或设置对象的变量。
    • 总之，索引器通常在处理集合和其他数据结构时更容易并更加灵活。当您需要可读性强的代码、更好的维护性和更好的性能时，使用索引器可能是一个不错的选择。
  • 索引器的重载
    • 索引器（Indexer）可被重载。索引器声明的时候也可带有多个参数，且每个参数可以是不同的类型。没有必要让索引器必须是整型的。C# 允许索引器可以是其他类型，例如，字符串类型。
    • 例如： 
      class IndexerTest
{
private string[] namelist = new string[size];
public static int size = 10;
public IndexerTest()
{
for(int i = 0; i < size; i++)
{
namelist[i] = "N.S.";
}
}
public string this[int index]
{
get
{
string temp;
if (index >= 0 && index <= size - 1)
{
temp = namelist[index];
}
else
{
temp = "";
}
return (temp);
}
set
{
if (index >= 0 && index <= size - 1)
{
namelist[index] = value;
}
}
}
public int this[string name]
{
get
{
int index = 0;
while (index < size)
{
if (namelist[index] == name)
{
return index;
}
index++;
}
return index;
}
}
static void Main(string[] args)
{
IndexerTest names = new IndexerTest();
names[0] = "Zara";
names[1] = "Riz";
names[2] = "Nuha";
names[3] = "Asif";
names[4] = "Davinder";
names[5] = "Sunil";
names[6] = "Rubic";
for (int i = 0; i < IndexerTest.size; i++)
{
Console.WriteLine(names[i]);
}
Console.WriteLine(names["Nuha"]);//返回2
Console.ReadLine();
}
}

委托（delegate） 

  • 定义：
    • C#中的委托是一种类型，它表示对具有特定参数列表和返回类型的方法的引用。委托通常用于实现回调机制、事件和可插入式（pluggable）体系结构。C#中的委托与函数指针在某些方面类似，但是它具备更大的安全性和灵活性。所有的委托（Delegate）都派生自 System.Delegate 类

  • 委托的声明和使用

    • 声明一个委托时，需要定义其类型签名。例如：delegate int Calculate(int x, inty);
    • 使用： 
      static int Add(int x, int y){ return x + y;}
​static void Main(string[] args){
​ Calculate calc = new Calculate(Add);
​ int result = calc(3, 4);
// returns 7
​}

  • 委托链：C#中的委托也支持委托链，即将多个委托合并在一起以便同时调用。例如将两个委托合并可以使用+运算符，而将一个委托从另一个委托中删除则使用-运算符。

    • 例如： 
      static int Add(int x, int y){
​ return x + y;
​}
​static int Multiply(int x, int y){
​ return x * y;
​}
​static void Main(string[] args){
​ Calculate calc1 = new Calculate(Add);
​ Calculate calc2 = new Calculate(Multiply);
​ Calculate calcMixed = calc1 + calc2;
​ int result1 = calc1(3, 4); // returns 7
​ int result2 = calc2(3, 4); // returns 12
​ int result3 = calcMixed(3, 4); // returns 15
​}

  • 泛型委托

    • C# 还支持泛型委托，这是一种定义能够引用任意方法（无论其签名）的强类型模板。
    • 语法：delegate TResult Func(T arg);
    • 它有一个输入参数 T 和输出结果 TResult，并且可以引用任何带有 T 类型输入和 TResult 类型输出的方法。

  • 委托中的Lambda表达式

    • 使代码更加简洁
    • 例如 
      static void Main(string[] args)
{
Calculate calc1 = (x, y) => x + y;
Calculate calc2 = (x, y) => x * y;
int result1 = calc1(3, 4); // returns 7
int result2 = calc2(3, 4); // returns 12
}

  • 使用委託代替Action類型

    • 使用委托代替 `Action` 类型也是一种常见的做法。以下是使用委托的示例： 
      public delegate void SomeMethodDelegate();
public void DoSomethingBasedOnCondition(bool condition)
{
var groups = new[]
{
new { Condition = true, Action = new SomeMethodDelegate(SomeMethod1) },
new { Condition = false, Action = new SomeMethodDelegate(SomeMethod2) }
};
var matchingGroup = groups.FirstOrDefault(g => g.Condition == condition);
if (matchingGroup != null)
{
matchingGroup.Action.Invoke();
}
}
private void SomeMethod1()
{
Console.WriteLine("条件为 true，执行方法1");
}
private void SomeMethod2()
{
Console.WriteLine("条件为 false，执行方法2");
}

事件（event） 

  • C# 中使用事件机制实现线程间的通信。

  • 事件委托：

    • 事件在类中声明且生成，且通过使用同一个类或其他类中的委托与事件处理程序关联。包含事件的类用于发布事件。这被称为 发布器（publisher） 类。其他接受该事件的类被称为 订阅器（subscriber） 类。事件使用 发布-订阅（publisher-subscriber） 模型。
    • 发布器（publisher） 是一个包含事件和委托定义的对象。事件和委托之间的联系也定义在这个对象中。发布器（publisher）类的对象调用这个事件，并通知其他的对象。
    • 订阅器（subscriber） 是一个接受事件并提供事件处理程序的对象。在发布器（publisher）类中的委托调用订阅器（subscriber）类中的方法（事件处理程序）。
    • 事件声明
      • 首先在类的内部声明事件，首先必须声明该事件的委托类型。例如：
      • public delegate void BoilerLogHandler(string status);
      • 然后，声明事件本身，使用 event 关键字：
      • public event BoilerLogHandler BoilerEventLog;
    • 例如： 
      using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace MyWork.Delegate
{
class DelegateTest
{
static void Main(string[] args)
{
Publishser pub = new Publishser();
Subscriber sub = new Subscriber();
pub.NumberChanged += new NumberChangedEventHandler(sub.OnNumberChanged);
pub.DoSomething(); // 应该通过DoSomething()来触发事件
// pub.NumberChanged(100); // 但可以被这样直接调用，对委托变量的不恰当使用
}
}
///
/// 定义委托
///
///
public delegate void NumberChangedEventHandler(int count);
///
/// 定义事件发布者
///
public class Publishser
{
private int count;
// public NumberChangedEventHandler NumberChanged; // 声明委托变量
public event NumberChangedEventHandler NumberChanged; // 声明一个事件
public void DoSomething()
{
// 在这里完成一些工作 ...
if (NumberChanged != null) // 触发事件
{
count++;
NumberChanged(count);
}
}
}
///
/// 定义事件订阅者
///
public class Subscriber
{
public void OnNumberChanged(int count)
{
Console.WriteLine("Subscriber notified: count = {0}", count);
}
}
}

  • Observer设计模式

    • Observer是一种常见的设计模式，在该模式中，对象维护一个依赖于它的观察者列表，当对象自身发生变化时，会通知所有观察者进行更新。
    • 具体来说，Observer模式包含两个主要角色：Subject和Observer。Subject是被观察者，负责维护所有注册了它的Observer的列表，并实现了对这些Observer的管理方法（例如添加、删除、通知）。Observer则是观察者，负责实现在Subject发生变化时所需进行的行为。
    • 使用Observer模式可以实现对象间的松耦合，提高代码的可维护性和扩展性。同时，Observer模式也能使对象之间的关系更加清晰易懂，增强代码的可读性。
    • 在实际应用中，Observer模式经常被用来处理一些动态的事件或状态变化，例如用户界面上的按钮点击事件、网络连接状态的变化等等。
    • 例如： 
      using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace MyWork.Delegate
{
public class BoilWaterTest
{
static void Main(string[] args)
{
Heater heater = new Heater();
Alarm alarm = new Alarm();
heater.BoilEvent += alarm.MakerAlert;
heater.BoilEvent += (new Alarm()).MakerAlert;//给匿名对象注册方法
heater.BoilEvent += Display.MakerDisplay;
heater.BoilWater();
}
}
public class Heater
{
private int temperature;//温度
public delegate void BoilHandler(int param);
public event BoilHandler BoilEvent;
public void BoilWater()
{
for(int i = 0; i <= 100; i++)
{
temperature = i;
if (temperature > 95)
{
if (BoilEvent != null)
{
BoilEvent(temperature);//调用所有注册对象的方法
}
}
}
}
}
public class Alarm
{
public void MakerAlert(int param)
{
Console.WriteLine("滴滴滴！水烧开了！当前{0}度", param);
}
}
public class Display
{
public static void MakerDisplay(int param)
{
Console.WriteLine("水快烧开了！当前{0}度", param);
}
}
}

  • .NET 框架中的委托与事件

    • 编码规范：
      • 1. 委托类型的名称都应该以 EventHandler 结束。
      • 2. 委托的原型定义：有一个void 返回值，并接受两个输入参数：一个Object 类型，一个EventArgs 类型(或继承自EventArgs)。
      • 3. 事件的命名为委托去掉 EventHandler 之后剩余的部分。
      • 4. 继承自 EventArgs 的类型应该以EventArgs 结尾。
    • 示例代码：
      • 委托类： 
        public class Heater
{
private int temperature;
public string type = "RealFire 001"; // 添加型号作为演示
public string area = "China Xian"; // 添加产地作为演示
public delegate void BoiledEventHandler(Object sender, BoiledEventArgs e);
public event BoiledEventHandler Boiled; // 声明事件
// 定义 BoiledEventArgs 类，传递给 Observer 所感兴趣的信息
public class BoiledEventArgs : EventArgs
{
public readonly int temperature;
public BoiledEventArgs(int temperature)
{
this.temperature = temperature;
}
}
// 可以供继承自 Heater 的类重写，以便继承类拒绝其他对象对它的监视
protected virtual void OnBoiled(BoiledEventArgs e)
{
if (Boiled != null)
{
Boiled(this, e); // 调用所有注册对象的方法
}
}
public void BoilWater()
{
for (int i = 0; i <= 100; i++)
{
temperature = i;
if (temperature > 95)
{
// 建立BoiledEventArgs 对象。
BoiledEventArgs e = new BoiledEventArgs(temperature);
OnBoiled(e); // 调用 OnBolied 方法
}
}
}
}
      • 测试： 
        public class Alarm
{
public void MakeAlert(Object sender, Heater.BoiledEventArgs e)
{
Heater heater = (Heater)sender; // 这里是不是很熟悉呢？
// 访问 sender 中的公共字段
Console.WriteLine("Alarm：{0} - {1}: ", heater.area, heater.type);
Console.WriteLine("Alarm: 嘀嘀嘀，水已经 {0} 度了：", e.temperature);
Console.WriteLine();
}
}
public class Display
{
public static void ShowMsg(Object sender, Heater.BoiledEventArgs e) // 静态方法
{
Heater heater = (Heater)sender;
Console.WriteLine("Display：{0} - {1}: ", heater.area, heater.type);
Console.WriteLine("Display：水快烧开了，当前温度：{0}度。", e.temperature);
Console.WriteLine();
}
}
class Program
{
static void Main()
{
Heater heater = new Heater();
Alarm alarm = new Alarm();
// heater.Boiled += alarm.MakeAlert; //注册方法
// heater.Boiled += (new Alarm()).MakeAlert; //给匿名对象注册方法
//heater.Boiled += new Heater.BoiledEventHandler(alarm.MakeAlert); //也可以这么注册
// heater.Boiled += Display.ShowMsg; //注册静态方法
heater.BoilWater(); //烧水，会自动调用注册过对象的方法
}
}

  • 委托和方法的异步调用

    • AsyncResult ： 
      ​
public delegate int AddDelegate(int x, int y);
class AsyncTest
{
static void Main(string[] args)
{
Console.WriteLine("Client application started!\n");
Thread.CurrentThread.Name = "Main Thread";
Calculator cal = new Calculator();
AddDelegate del = new AddDelegate(cal.Add);
IAsyncResult asyncResult = del.BeginInvoke(2, 5, null, null); // 异步调用方法
// 做某些其它的事情，模拟需要执行3 秒钟
for (int i = 1; i <= 3; i++)
{
Thread.Sleep(TimeSpan.FromSeconds(i));
Console.WriteLine("{0}: Client executed {1} second(s).", Thread.CurrentThread.Name, i);
}
int rtn = del.EndInvoke(asyncResult);
Console.WriteLine("Result: {0}\n", rtn);
Console.WriteLine("\nPress any key to exit...");
Console.ReadLine();
}
}
public class Calculator
{
public int Add(int x, int y)
{
if (Thread.CurrentThread.IsThreadPoolThread)
{
Thread.CurrentThread.Name = "Pool Thread";
}
Console.WriteLine("Method invoked!");
// 执行某些事情，模拟需要执行2 秒钟
for (int i = 1; i <= 2; i++)
{
Thread.Sleep(TimeSpan.FromSeconds(i));
Console.WriteLine("{0}: Add executed {1} second(s).", Thread.CurrentThread.Name, i);
}
Console.WriteLine("Method complete!");
return x + y;
}
}

​
      • 在示例代码中，BeginInvoke() 方法的最后两个参数分别是 AsyncCallback 回调函数和一个用户定义的对象。这两个参数可以方便地向异步操作传递额外的信息。
      • 第一个参数 AsyncCallback 是一个委托类型，用于指向一个函数，该函数将在异步操作完成时自动调用。该委托函数包含一个 IAsyncResult 参数，以便接收异步操作的状态信息。
      • 在示例代码中，我们并未设置回调函数，因此传递了一个 null 值。如果需要的话，也可以创建一个名为 MyCallback 的方法，并在 BeginInvoke() 方法中传递该方法名作为回调函数。
      • 第二个参数是用户定义的对象（UserState），可用于存储任何数据对象。当异步操作完成时，执行回调函数时，该值会传递给回调函数，从而使得回调函数能够访问其内容。
      • 在示例代码中，我们同样使用了 null 值。如果需要为异步操作传递一些附加数据，则可以将它们作为第二个参数传递到 BeginInvoke() 方法中。
    • iAyncResult.AsyncWaitHandle.WaitOne(500, false)方法说明
      • 这段代码是在等待异步操作完成。具体来说，它会等待异步操作的WaitHandle对象信号被触发，或者等待一定的时间间隔后超时返回。
      • 参数500表示最长等待时间为500毫秒，如果在这段时间内等待句柄没有被触发，就会返回；第二个参数false表示不将等待句柄重置，即使之前已经有其他线程等待过它了，当前线程依然可以等待该句柄。

多线程 

  • 实现多线程的几种方式

    • 使用Thread类

    • Thread类是C#中最基本的多线程实现方式，需要手动管理线程的生命周期和线程同步机制。

      using System;
using System.Threading;

class Program
{
    static void Main()
    {
        // 创建线程实例
        Thread thread = new Thread(new ThreadStart(DoWork));

        // 启动线程
        thread.Start();

        // 主线程继续执行其他任务
        for (int i = 0; i < 10; i++)
        {
            Console.WriteLine("Main thread is running.");
            Thread.Sleep(1000);
        }

        // 等待线程结束
        thread.Join();

        Console.WriteLine("Thread has finished.");
    }

    static void DoWork()
    {
        for (int i = 0; i < 10; i++)
        {
            Console.WriteLine("Worker thread is running.");
            Thread.Sleep(1000);
        }
    }
}

    • 使用Task类

    • Task类是.NET Framework中的新特性，可以更方便地管理线程的生命周期和线程同步机制

      using System;
using System.Threading.Tasks;

class Program
{
    static void Main()
    {
        // 创建Task实例
        Task task = Task.Factory.StartNew(DoWork);

        // 主线程继续执行其他任务
        for (int i = 0; i < 10; i++)
        {
            Console.WriteLine("Main thread is running.");
            Task.Delay(1000).Wait();
        }

        // 等待Task完成
        task.Wait();

        Console.WriteLine("Task has finished.");
    }

    static void DoWork()
    {
        for (int i = 0; i < 10; i++)
        {
            Console.WriteLine("Worker thread is running.");
            Task.Delay(1000).Wait();
        }
    }
}

    • 使用ThreadPool类

    • ThreadPool类是.NET Framework提供的线程池实现，可以更方便地管理线程的生命周期和线程同步机制

      using System;
using System.Threading;

class Program
{
    static void Main()
    {
        // 将工作项添加到线程池
        ThreadPool.QueueUserWorkItem(DoWork);

        // 主线程继续执行其他任务
        for (int i = 0; i < 10; i++)
        {
            Console.WriteLine("Main thread is running.");
            Thread.Sleep(1000);
        }

        Console.WriteLine("Thread has finished.");
    }

    static void DoWork(object state)
    {
        for (int i = 0; i < 10; i++)
        {
            Console.WriteLine("Worker thread is running.");
            Thread.Sleep(1000);
        }
    }
}
  • 相关方法：
    • 1. Thread.Sleep()，它会让执行当前代码的线程暂停一段时间（如果你对线程的概念比较陌生，可以理解为使程序的执行暂停一段时间），以毫秒为单位，比如Thread.Sleep(1000)，将会使线程暂停1 秒钟。在上面我使用了它的重载方法，个人觉得使用TimeSpan.FromSeconds(1)，可读性更好一些。
    • 2. Thread.CurrentThread.Name，通过这个属性可以设置、获取执行当前代码的线程的名称，值得注意的是这个属性只可以设置一次，如果设置两次，会抛出异常。
    • 3. Thread.IsThreadPoolThread，可以判断执行当前代码的线程是否为线程池中的线程

 集合

List

List是C#中最常用的集合类之一，可以动态地增加或减少元素。List实现了IList接口，支持随机访问元素。List中的元素可以是任何类型，包括值类型和引用类型。

  • 创建List实例

  • 可以使用new关键字创建List实例，需要指定List中元素的类型。以下是创建List实例的示例代码：

    List list1 = new List(); // 创建int类型的空List实例
List list2 = new List(); // 创建string类型的空List实例
List list3 = new List(); // 创建object类型的空List实例
 
    也可以使用集合初始化器创建List实例，并添加元素。以下是使用集合初始化器创建List实例的示例代码：
     
    List list1 = new List { 1, 2, 3 }; // 创建包含3个int类型元素的List实例
List list2 = new List { "one", "two", "three" }; // 创建包含3个string类型元素的List实例
List list3 = new List { 1, "two", '3' }; // 创建包含3个object类型元素的List实例
  
    
  • 添加和删除元素
    •  
    
  •  
    可以使用Add方法向List中添加元素，使用Remove方法从List中删除指定元素。以下是添加和删除元素的示例代码：
     
     
    List list = new List();
list.Add("one"); // 添加元素
list.Add("two");
list.Add("three");

bool result = list.Remove("two"); // 删除元素

foreach (string item in list)
{
    Console.WriteLine(item);
}

     
    输出结果为：
     
     
    one
three

     
    也可以使用Insert方法在指定位置插入元素，使用RemoveAt方法删除指定位置的元素。以下是插入和删除元素的示例代码：
     
     
    List list = new List();
list.Add("one");
list.Add("three");

list.Insert(1, "two"); // 插入元素

list.RemoveAt(1); // 删除元素

foreach (string item in list)
{
    Console.WriteLine(item);
}

     
    输出结果为：
     
     
    one

     
    •  
    
  • 查找元素
    •  
    
  •  
    可以使用Contains方法查找List中是否包含指定元素，使用IndexOf方法查找指定元素在List中的位置，使用LastIndexOf方法查找指定元素在List中的最后位置。以下是查找元素的示例代码：
     
     
    List list = new List();
list.Add("one");
list.Add("two");
list.Add("three");
list.Add("two");

bool result1 = list.Contains("two"); // 是否包含元素
// result1为true

int index1 = list.IndexOf("two"); // 查找元素位置
// index1为1

int index2 = list.LastIndexOf("two"); // 查找元素最后位置
// index2为3

     
    •  
    
  • 排序元素
    •  
    
  •  
    可以使用Sort方法对List中的元素进行排序。Sort方法接受一个实现IComparer接口的对象作为比较器，用于比较List中的元素。以下是排序元素的示例代码：
     
     
    List list = new List { 3, 1, 2 };
list.Sort(); // 排序

foreach (int item in list)
{
    Console.WriteLine(item);
}

     
    输出结果为：
     
     
    1
2
3

     
    也可以使用Sort方法的重载版本，传入一个Lambda表达式作为比较器。以下是使用Lambda表达式排序元素的示例代码：
     
     
    List list = new List { "one", "Two", "THREE" };
list.Sort((x, y) => string.Compare(x, y, StringComparison.OrdinalIgnoreCase)); // 忽略大小写排序

foreach (string item in list)
{
    Console.WriteLine(item);
}

     
    输出结果为：
     
     
    复制代码
     
    one
THREE
Two

     
    •  
    
  • 高级使用
    •  
    
  •  
    List还支持一些高级使用，包括以下几个方面：
     
    •  
    
  • 缩减List的容量 可以使用TrimExcess方法缩减List的容量，以减少内存占用。以下是缩减List容量的示例代码：
    •  
    
  •  
    List list = new List { 1, 2, 3 };
list.TrimExcess();

     
    •  
    
  • 清空List中的元素 可以使用Clear方法清空List中的元素。以下是清空List中元素的示例代码：
    •  
    
  •  
    List list = new List { 1, 2, 3 };
list.Clear();

     
    •  
    
  • 将List转换为数组 可以使用ToArray方法将List转换为数组。以下是将List转换为数组的示例代码：
    •  
    
  •  
    List list = new List { 1, 2, 3 };
int[] array = list.ToArray();

     
    •  
    
  • 将数组转换为List 可以使用ToList方法将数组转换为List。以下是将数组转换为List的示例代码：
    •  
    
  •  
    int[] array = { 1, 2, 3 };
List list = array.ToList();

     
    •  
    
  • 使用Foreach方法遍历List 可以使用Foreach方法遍历List中的元素。Foreach方法接受一个Lambda表达式作为参数，用于处理List中的每个元素。以下是使用Foreach方法遍历List的示例代码：
    •  
    
  •  
    List list = new List { "one", "two", "three" };
list.ForEach(item => Console.WriteLine(item));

     
    输出结果为：
     
     
    one
two
three
     
    •  
    
   
  
     
   
    Dictionary
     
   
    Dictionary是C#中常用的键值对集合类，可以根据键来访问值。Dictionary实现了IDictionary接口，支持添加、删除、查找和遍历操作。
     
   
       
    
    • 创建Dictionary实例
      •  
    
    •  
      可以使用new关键字创建Dictionary实例，需要指定键和值的类型。以下是创建Dictionary实例的示例代码：
       
       
      Dictionary dict1 = new Dictionary(); // 创建string和int类型的空Dictionary实例
Dictionary dict2 = new Dictionary(); // 创建int和string类型的空Dictionary实例

       
      也可以使用集合初始化器创建Dictionary实例，并添加键值对。以下是使用集合初始化器创建Dictionary实例的示例代码：
       
       
      Dictionary dict1 = new Dictionary
{
    { "one", 1 },
    { "two", 2 },
    { "three", 3 }
};

Dictionary dict2 = new Dictionary
{
    { 1, "one" },
    { 2, "two" },
    { 3, "three" }
};

       
      •  
    
    • 添加和删除键值对
      •  
    
    •  
      可以使用Add方法向Dictionary中添加键值对，使用Remove方法从Dictionary中删除指定键的键值对。以下是添加和删除键值对的示例代码：
       
       
      Dictionary dict = new Dictionary();
dict.Add("one", 1); // 添加键值对
dict.Add("two", 2);
dict.Add("three", 3);

bool result = dict.Remove("two"); // 删除键值对

       
      也可以使用索引器访问和修改Dictionary中的键值对。以下是使用索引器添加和修改键值对的示例代码：
       
       
      Dictionary dict = new Dictionary();
dict["one"] = 1; // 添加或修改键值对
dict["two"] = 2;
dict["three"] = 3;

int value = dict["two"]; // 访问键值对

       
      需要注意的是，如果访问不存在的键，则会抛出KeyNotFoundException异常。可以使用TryGetValue方法来避免抛出异常。以下是使用TryGetValue方法访问键值对的示例代码：
       
       
      Dictionary dict = new Dictionary();
dict.Add("one", 1);
dict.Add("three", 3);

int value;
bool result = dict.TryGetValue("two", out value); // 此时result为false

if (result)
{
    Console.WriteLine(value);
}
else
{
    Console.WriteLine("Key not found.");
}

       
      输出结果为：
       
       
      Key not found.

       
      •  
    
    • 查找键值对
      •  
    
    •  
      可以使用ContainsKey方法查找Dictionary中是否包含指定键，使用ContainsValue方法查找Dictionary中是否包含指定值，使用TryGetValue方法获取指定键的值。以下是查找键值对的示例代码：
       
       
      Dictionary dict = new Dictionary();
dict.Add("one", 1);
dict.Add("two", 2);
dict.Add("three", 3);

bool result1 = dict.ContainsKey("two"); // 是否包含键
// result1为true

bool result2 = dict.ContainsValue(2); // 是否包含值
// result2为true

int value;
bool result3 = dict.TryGetValue("two", out value); // 获取值
// result3为true，value为2

       
      •  
    
    • 遍历键值对
      •  
    
    •  
      可以使用foreach循环遍历Dictionary中的键值对。foreach循环每次迭代都会返回一个KeyValuePair结构体，可以使用结构体的Key和Value属性来访问键和值。以下是遍历键值对的示例代码：
       
       
      Dictionary dict = new Dictionary();
dict.Add("one", 1);
dict.Add("two", 2);
dict.Add("three", 3);

foreach (KeyValuePair kvp in dict)
{
    Console.WriteLine("Key = {0}, Value = {1}", kvp.Key, kvp.Value);
}

       
      输出结果为：
       
       
      Key = one, Value = 1
Key = two, Value = 2
Key = three, Value = 3

       
      也可以使用foreach循环遍历Dictionary中的键或值。需要使用字典的Keys或Values属性来访问键或值。以下是遍历键和值的示例代码：
       
       
      复制代码
       
      Dictionary dict = new Dictionary();
dict.Add("one", 1);
dict.Add("two", 2);
dict.Add("three", 3);

foreach (string key in dict.Keys)
{
    Console.WriteLine("Key = {0}", key);
}

foreach (int value in dict.Values)
{
    Console.WriteLine("Value = {0}", value);
}

       
      输出结果为：
       
       
      Key = one
Key = two
Key = three
Value = 1
Value = 2
Value = 3

       
      •  
    
    • 高级使用
      •  
    
    •  
      Dictionary还支持一些高级使用，包括以下几个方面：
       
      •  
    
    • 获取Dictionary中键或值的集合 可以使用Keys属性获取Dictionary中键的集合，使用Values属性获取Dictionary中值的集合。以下是获取键或值的集合的示例代码：
      •  
    
    •  
      Dictionary dict = new Dictionary();
dict.Add("one", 1);
dict.Add("two", 2);
dict.Add("three", 3);

ICollection keys = dict.Keys; // 获取键的集合
ICollection values = dict.Values; // 获取值的集合

       
      •  
    
    • 将Dictionary转换为数组 可以使用ToArray方法将Dictionary转换为数组。ToArray方法返回一个包含Dictionary中所有键值对的KeyValuePair数组。以下是将Dictionary转换为数组的示例代码：
      •  
    
    •  
      Dictionary dict = new Dictionary();
dict.Add("one", 1);
dict.Add("two", 2);
dict.Add("three", 3);

KeyValuePair[] array = dict.ToArray(); // 转换为数组

       
      •  
    
    • 将数组转换为Dictionary 可以使用ToDictionary方法将数组转换为Dictionary。ToDictionary方法接受一个Lambda表达式作为参数，用于从数组元素中提取键和值。以下是将数组转换为Dictionary的示例代码：
      •  
    
    •  
      int[] array = { 1, 2, 3 };
Dictionary dict = array.To
       
      •  
   
     
   
       
    
    •  
      LINQ查询
       
      通过使用LINQ查询，可以从Dictionary对象中筛选出符合某些特定条件的元素。下面以一个Dictionary为例，演示如何使用LINQ查询语法从Dictionary中筛选出所有值大于2的键值对。
       
       
      Dictionary dict = new Dictionary {
    {"one", 1},
    {"two", 2},
    {"three", 3},
    {"four", 4}
};

var result = from item in dict
             where item.Value > 2
             select item;

foreach (var item in result) {
    Console.WriteLine("{0}: {1}", item.Key, item.Value);
}

       
      输出：
       
       
      three: 3
four: 4

       
      2.Lambda表达式
       
      Lambda表达式是一种用于简洁地定义匿名方法的方式，可以在Collections类的扩展方法中使用。下面以一个Dictionary为例，演示如何使用Lambda表达式筛选出所有值大于2的键值对：
       
       
      Dictionary dict = new Dictionary {
    {"one", 1},
    {"two", 2},
    {"three", 3},
    {"four", 4}
};

var result = dict.Where(x => x.Value > 2);

foreach (var item in result) {
    Console.WriteLine("{0}: {1}", item.Key, item.Value);
}

       
      输出：
       
       
      three: 3
four: 4

       
      转换操作
       
      除了筛选元素之外，LINQ和Lambda表达式还可以执行一些转换操作，如映射、分组、排序等。下面以一个Dictionary为例，演示如何使用Lambda表达式对字典中的值进行平方操作：
       
       
      Dictionary dict = new Dictionary {
    {"one", 1},
    {"two", 2},
    {"three", 3},
    {"four", 4}
};

var result = dict.Select(x => new KeyValuePair(x.Key, x.Value * x.Value));

foreach (var item in result) {
    Console.WriteLine("{0}: {1}", item.Key, item.Value);
}

       
      输出：
       
      one: 1
two: 4
three: 9
four: 16

       
      4.Sum、Max和Min操作
       
      在LINQ中，可以使用Sum、Max和Min等聚合操作对集合中的元素进行求和、最大值和最小值等操作。下面以一个Dictionary为例，演示如何使用LINQ查询语法从Dictionary中计算所有值的和：
       
       
      Dictionary dict = new Dictionary {
    {"one", 1},
    {"two", 2},
    {"three", 3},
    {"four", 4}
};

int sum = (from item in dict
           select item.Value).Sum();

Console.WriteLine("Sum: {0}", sum);

       
      输出：
       
       
      Sum: 10

       
      使用Lambda表达式也可以进行相同的操作：
       
       
      Dictionary dict = new Dictionary {
    {"one", 1},
    {"two", 2},
    {"three", 3},
    {"four", 4}
};

int sum = dict.Values.Sum();

Console.WriteLine("Sum: {0}", sum);

       
      输出：
       
       
      Sum: 10

       
      5.OrderBy和ThenBy操作
       
      在LINQ中，可以使用OrderBy和ThenBy方法对集合进行排序。OrderBy方法用于对集合进行升序排序，ThenBy方法用于在升序排序的基础上继续对集合进行排序。下面以一个Dictionary为例，演示如何使用Lambda表达式对字典中的值进行排序：
       
       
      Dictionary dict = new Dictionary {
    {"one", 1},
    {"two", 2},
    {"three", 3},
    {"four", 4}
};

var result = dict.OrderBy(x => x.Value);

foreach (var item in result) {
    Console.WriteLine("{0}: {1}", item.Key, item.Value);
}

       
      输出：
       
       
      one: 1
two: 2
three: 3
four: 4

       
      可以使用ThenBy方法对排序进行进一步的指定：
       
       
      Dictionary dict = new Dictionary {
    {"one", 1},
    {"two", 2},
    {"three", 3},
    {"four", 4}
};

var result = dict.OrderBy(x => x.Value).ThenBy(x => x.Key);

foreach (var item in result) {
    Console.WriteLine("{0}: {1}", item.Key, item.Value);
}

       
      输出：
       
      •  
    
    •  
       
      one: 1
two: 2
three: 3
four: 4
       
      •  
   
     
  
     
  
     
   
    Queue
     
   
    C#中的Queue是一个基于先进先出（FIFO）原则的集合类，用于存储同一类型对象的集合。Queue类有两种实现方式：基于数组的实现和基于链表的实现。Queue类提供了一系列方法，可以用于在队列中添加、删除、查询元素，以及确定队列中元素的数量等操作。
     
   
       
    
    •  
      1.创建和初始化Queue对象
       
      首先需要创建一个Queue对象，并进行初始化，以便向队列中添加元素。下面是一个基于数组的Queue初始化的示例代码：
       
       
      Queue queue = new Queue();

       
      可以使用Add或Enqueue方法向队列中添加元素，例如：
       
       
      queue.Enqueue(1);
queue.Enqueue(2);
queue.Enqueue(3);

       
      也可以使用数组的方式进行初始化：
       
       
      Queue queue = new Queue(new[] { 1, 2, 3 });

       
      2.添加元素
       
      可以使用Enqueue方法向队列中添加元素，如：
       
       
      queue.Enqueue(4);
queue.Enqueue(5);

       
      3.获取元素
       
      可以使用Dequeue方法从队列中获取并删除第一个元素，如：
       
       
      int first = queue.Dequeue();
Console.WriteLine(first);

       
      也可以使用Peek方法获取并保留第一个元素，如：
       
       
      int first = queue.Peek();
Console.WriteLine(first);

       
      4.查询元素
       
      可以使用Contains方法查询元素是否存在于队列中，如：
       
       
      bool exists = queue.Contains(3);
Console.WriteLine(exists);

       
      也可以使用ToArray方法将队列中的所有元素复制到一个数组中：
       
       
      int[] array = queue.ToArray();
foreach (int i in array) {
    Console.WriteLine(i);
}

       
      5.队列的长度
       
      可以使用Count属性获取队列中的元素数量，如：
       
       
      int count = queue.Count;
Console.WriteLine(count);

       
      6.迭代器
       
      Queue也支持迭代器，可以使用foreach语句遍历Queue中的元素，如：
       
       
      foreach (int i in queue) {
    Console.WriteLine(i);
}

       
      7.清空队列
       
      可以使用Clear方法清空队列中的所有元素：
       
       
      queue.Clear();

       
      高级使用：
       
      1.使用自定义对象
       
      可以使用自定义类型作为Queue中的元素类型。只需要确保自定义类型实现了相应的接口（例如IComparable或IEquatable）即可。例如：
       
       
      class Person : IComparable {
    public string Name { get; set; }
    public int Age { get; set; }

    public int CompareTo(Person other) {
        return this.Age.CompareTo(other.Age);
    }
}

Queue queue = new Queue();
queue.Enqueue(new Person { Name = "Tom", Age = 20 });
queue.Enqueue(new Person { Name = "Mary", Age = 25 });

       
      2.使用委托自定义比较器
       
      可以使用委托来自定义比较器，例如需要按照Person对象的Name属性进行排序：
       
       
      class Person {
    public string Name { get; set; }
    public int Age { get; set; }
}

Queue queue = new Queue((x, y) => String.Compare(x.Name, y.Name));
queue.Enqueue(new Person { Name = "Tom", Age = 20 });
queue.Enqueue(new Person { Name = "Mary", Age = 25 });

       
      3.使用Queue与Stack结合实现栈
       
      Queue和Stack都是一种基于集合的数据结构，它们的实现机制不同，但用法非常类似。可以使用Queue和Stack结合实现栈的功能，例如：
       
       
      class Stack {
    private Queue queue = new Queue();

    public void Push(T item) {
        queue.Enqueue(item);
        int count = queue.Count;
        while (count-- > 1) {
            queue.Enqueue(queue.Dequeue());
        }
    }

    public T Pop() {
        return queue.Dequeue();
    }

    public int Count {
        get { return queue.Count; }
    }
}

Stack stack = new Stack();
stack.Push(1);
stack.Push(2);
stack.Push(3);

Console.WriteLine(stack.Pop());  // 3
Console.WriteLine(stack.Pop());  // 2
Console.WriteLine(stack.Pop());  // 1
       
      •  
   
     
  
     
  
     
   
    Stack
     
   
    C#中的Stack是一种基于后进先出（LIFO）原则的集合类，用于存储同一类型对象的集合。Stack类有两种实现方式：基于数组的实现和基于链表的实现。Stack类提供了一系列方法，可以用于在栈中添加、删除、查询元素，以及确定栈中元素的数量等操作
     
   
         
     
   
    1.创建和初始化Stack对象
     
   
    首先需要创建一个Stack对象，并进行初始化，以便向栈中添加元素。下面是一个基于数组的Stack初始化的示例代码：
     
   
     
   
    Stack stack = new Stack();

     
   
    也可以使用数组的方式进行初始化：
     
   
     
   
    Stack stack = new Stack(new[] { 1, 2, 3 });

     
   
    2.添加元素
     
   
    可以使用Push方法向栈中添加元素，如：
     
   
     
   
    stack.Push(4);
stack.Push(5);

     
   
    3.获取元素
     
   
    可以使用Pop方法从栈中获取并删除最后一个元素，如：
     
   
     
   
    int last = stack.Pop();
Console.WriteLine(last);

     
   
    也可以使用Peek方法获取并保留最后一个元素，如：
     
   
     
   
    int last = stack.Peek();
Console.WriteLine(last);

     
   
    4.查询元素
     
   
    可以使用Contains方法查询元素是否存在于栈中，如：
     
   
     
   
    bool exists = stack.Contains(3);
Console.WriteLine(exists);

     
   
    也可以使用ToArray方法将栈中的所有元素复制到一个数组中：
     
   
     
   
    int[] array = stack.ToArray();
foreach (int i in array) {
    Console.WriteLine(i);
}

     
   
    5.栈的长度
     
   
    可以使用Count属性获取栈中的元素数量，如：
     
   
     
   
    int count = stack.Count;
Console.WriteLine(count);

     
   
    6.迭代器
     
   
    Stack也支持迭代器，可以使用foreach语句遍历Stack中的元素，如：
     
   
     
   
    foreach (int i in stack) {
    Console.WriteLine(i);
}

     
   
    7.清空栈
     
   
    可以使用Clear方法清空栈中的所有元素：
     
   
     
   
    stack.Clear();

     
   
    高级使用：
     
   
    1.使用自定义对象
     
   
    可以使用自定义类型作为Stack中的元素类型。只需要确保自定义类型实现了相应的接口（例如IComparable或IEquatable）即可。例如：
     
   
     
   
    class Person : IComparable {
    public string Name { get; set; }
    public int Age { get; set; }

    public int CompareTo(Person other) {
        return this.Age.CompareTo(other.Age);
    }
}

Stack stack = new Stack();
stack.Push(new Person { Name = "Tom", Age = 20 });
stack.Push(new Person { Name = "Mary", Age = 25 });

     
   
    2.使用委托自定义比较器
     
   
    可以使用委托来自定义比较器，例如需要按照Person对象的Name属性进行排序：
     
   
     
   
    class Person {
    public string Name { get; set; }
    public int Age { get; set; }
}

Stack stack = new Stack((x, y) => String.Compare(x.Name, y.Name));
stack.Push(new Person { Name = "Tom", Age = 20 });
stack.Push(new Person { Name = "Mary", Age = 25 });

     
   
    3.使用Stack与Queue结合实现队列
     
   
    Stack和Queue都是一种基于集合的数据结构，它们的实现机制不同，但用法非常类似。可以使用Stack和Queue结合实现队列的功能，例如：
     
   
    ti
     
   
    class Queue {
    private Stack stack1 = new Stack();
    private Stack stack2 = new Stack();

    public void Enqueue(T item) {
        stack1.Push(item);
    }

    public T Dequeue() {
        if (stack2.Count == 0) {
            while (stack1.Count > 0) {
                stack2.Push(stack1.Pop());
            }
        }
        return stack2.Pop();
    }

    public int Count {
        get { return stack1.Count + stack2.Count; }
    }
}

Queue queue = new Queue();
queue.Enqueue(1);
queue.Enqueue(2);
queue.Enqueue(3);

Console.WriteLine(queue.Dequeue());  // 1
Console.WriteLine(queue.Dequeue());  // 2
Console.WriteLine(queue.Dequeue());  // 3
     
  
     
  
    其他补充
     
  
     
   
       
    
    • 其它补充 
     
         
      
      • Console.ReadKey() 
       
           
        
        • 在C#中，Console.ReadKey()是一个阻塞方法，它等待用户按下任意键，并返回一个表示所按键的KeyInfo对象。它通常用于控制台程序的调试和交互过程中。
          •  
       
         
       
           
        
        • 下面是使用Console.ReadKey()的示例：
          •  
       
         
       
           
        
        •  
          using System;
class Program
{
static void Main(string[] args)
{
Console.WriteLine("按下任意键继续...");
Console.ReadKey();
Console.WriteLine("您已按下键！");
}
}

           
          •  
       
         
       
           
        
        • 在上面的示例中，程序在控制台输出"按下任意键继续..."，并等待用户按键。当用户按下键后，控制台将输出"您已按下键！"。
          •  
       
         
       
           
        
        • 需要注意的是，Console.ReadKey()方法在读取到按键后会将该键从输入缓冲区中删除。如果需要保留输入缓冲区的内容，请使用Console.Read()方法。
          •  
       
        •  
     
       
     
         
      
      • abstract和virtual的区别： 
       
           
        
        • abstract可以修饰类和方法，子类继承基类时，必须实现基类使用abstract所修饰的方法
          •  
       
         
       
           
        
        • virtual只能修饰方法，且不要求子类一定实现基类使用virtual所修饰的方法
          •  
       
        •  
     
       
     
         
      
      • Visual studio工具 
       
           
        
        • 调试快捷键： 
         
             
          
          • F5：开始调试
            •  
         
           
         
             
          
          • shift+F5：停止调试
            •  
         
           
         
             
          
          • F9：设置或取消断点
            •  
         
           
         
             
          
          • Ctrl+F9:取消断点
            •  
         
           
         
             
          
          • F10：单步执行
            •  
         
           
         
             
          
          • F2 : 转到所调用过程或变量的定义
            •  
         
           
         
             
          
          • Ctrl+F2: 将焦点转移到类的下拉列表框
            •  
         
          •  
       
         
       
           
        
        • 编码快捷键： 
         
             
          
          • 封装字段：Ctrl+R+E
            •  
         
          •  
       
        •  
     
      •  
   
     
  
     
  

                            
                        
                    
                    
                    
    
                    
                    
                    
    
                
                
    
                    
                
    
            
        
    
    
    
        
    你可能感兴趣的:(c#,.net,开发语言)
    
        
    
            
    
                
      
                    
    • 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
      
                    
      • 
                    
    • python os.environ_python os.environ 读取和设置环境变量
                        weixin_39605414
pythonos.environ
                        
      >>>importos>>>os.environ.keys()['LC_NUMERIC','GOPATH','GOROOT','GOBIN','LESSOPEN','SSH_CLIENT','LOGNAME','USER','HOME','LC_PAPER','PATH','DISPLAY','LANG','TERM','SHELL','J2REDIR','LC_MONETARY','QT_QPA
      
                    
      • 
                    
    • Git常用命令－修改远程仓库地址
                        猿大师
LinuxJavagitjava
                        
      查看远程仓库地址gitremote-v返回结果originhttps://git.coding.net/＊＊＊＊＊.git(fetch)originhttps://git.coding.net/＊＊＊＊＊.git(push)修改远程仓库地址gitremoteset-urloriginhttps://git.coding.net/＊＊＊＊＊.git先删除后增加远程仓库地址gitremotermori
      
                    
      • 
                    
    • 【无标题】达瓦达瓦
                        JhonKI
考研
                        
      博客主页：https://blog.csdn.net/2301_779549673欢迎点赞收藏⭐留言如有错误敬请指正！本文由JohnKi原创，首发于CSDN未来很长，值得我们全力奔赴更美好的生活✨文章目录前言111️‍111❤️111111111111111总结111前言111骗骗流量券，嘿嘿111111111111111111111111111️‍111❤️111111111111111总结11
      
                    
      • 
                    
    • 上图为是否色发
                        JhonKI
考研
                        
      博客主页：https://blog.csdn.net/2301_779549673欢迎点赞收藏⭐留言如有错误敬请指正！本文由JohnKi原创，首发于CSDN未来很长，值得我们全力奔赴更美好的生活✨文章目录前言111️‍111❤️111111111111111总结111前言111骗骗流量券，嘿嘿111111111111111111111111111️‍111❤️111111111111111总结11
      
                    
      • 
                    
    • 143234234123432
                        JhonKI
考研
                        
      博客主页：https://blog.csdn.net/2301_779549673欢迎点赞收藏⭐留言如有错误敬请指正！本文由JohnKi原创，首发于CSDN未来很长，值得我们全力奔赴更美好的生活✨文章目录前言111️‍111❤️111111111111111总结111前言111骗骗流量券，嘿嘿111111111111111111111111111️‍111❤️111111111111111总结11
      
                    
      • 
                    
    • Python中深拷贝与浅拷贝的区别
                        yuxiaoyu.

                        
      转自：http://blog.csdn.net/u014745194/article/details/70271868定义：在Python中对象的赋值其实就是对象的引用。当创建一个对象，把它赋值给另一个变量的时候，python并没有拷贝这个对象，只是拷贝了这个对象的引用而已。浅拷贝：拷贝了最外围的对象本身，内部的元素都只是拷贝了一个引用而已。也就是，把对象复制一遍，但是该对象中引用的其他对象我不复
      
                    
      • 
                    
    • 你可能遗漏的一些C#/.NET/.NET Core知识点
                        追逐时光者
C#.NETDotNetGuide编程指南c#.net.netcoremicrosoft
                        
      前言在这个快速发展的技术世界中，时常会有一些重要的知识点、信息或细节被忽略或遗漏。《C#/.NET/.NETCore拾遗补漏》专栏我们将探讨一些可能被忽略或遗漏的重要知识点、信息或细节，以帮助大家更全面地了解这些技术栈的特性和发展方向。拾遗补漏GitHub开源地址https://github.com/YSGStudyHards/DotNetGuide/blob/main/docs/DotNet/D
      
                    
      • 
                    
    • 第1步win10宿主机与虚拟机通过NAT共享上网互通
                        学习3人组
大数据大数据
                        
      VM的CentOS采用NAT共用宿主机网卡宿主机器无法连接到虚拟CentOS要实现宿主机与虚拟机通信，原理就是给宿主机的网卡配置一个与虚拟机网关相同网段的IP地址，实现可以互通。1、查看虚拟机的IP地址2、编辑虚拟机的虚拟网络的NAT和DHCP的配置，设置虚拟机的网卡选择NAT共享模式3、宿主机的IP配置，确保vnet8的IPV4属性与虚拟机在同一网段4、ping测试连通性[root@localh
      
                    
      • 
                    
    • SpringCloudAlibaba—Sentinel(限流)
                        菜鸟爪哇

                        
      前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源
      
                    
      • 
                    
    • 光盘文件系统 (iso9660) 格式解析
                        穷人小水滴
光盘文件系统iso9660denoGNU/Linuxjavascript
                        
      越简单的系统,越可靠,越不容易出问题.光盘文件系统(iso9660)十分简单,只需不到200行代码,即可实现定位读取其中的文件.参考资料:https://wiki.osdev.org/ISO_9660相关文章:《光盘防水嘛?DVD+R刻录光盘泡水实验》https://blog.csdn.net/secext2022/article/details/140583910《光驱的内部结构及日常使用》ht
      
                    
      • 
                    
    • 科幻游戏 《外卖员模拟器》 主要地理环境设定 (1)
                        穷人小水滴
游戏科幻设计
                        
      游戏名称:《外卖员模拟器》(英文名称:waimai_se)作者:穷人小水滴本故事纯属虚构,如有雷同实属巧合.故事发生在一个(架空)平行宇宙的地球,21世纪(超低空科幻流派).相关文章:https://blog.csdn.net/secext2022/article/details/141790630目录1星球整体地理设定2巨蛇国主要设定3海蛇市主要设定3.1主要地标建筑3.2交通3.3能源(电力)
      
                    
      • 
                    
    • react-intl——react国际化使用方案
                        苹果酱0567
面试题汇总与解析java开发语言中间件springboot后端
                        
      国际化介绍i18n：internationalization国家化简称，首字母+首尾字母间隔的字母个数+尾字母，类似的还有k8s(Kubernetes)React-intl是React中最受欢迎的库。使用步骤安装#usenpmnpminstallreact-intl-D#useyarn项目入口文件配置//index.tsximportReactfrom"react";importReactDOMf
      
                    
      • 
                    
    • Mongodb Error: queryTxt ETIMEOUT xxxx.wwwdz.mongodb.net
                        佛一脚
errorreactmongodb数据库
                        
      背景每天都能遇到奇怪的问题，做个记录，以便有缘人能得到帮助！换了一台电脑开发nextjs程序。需要连接mongodb数据，对数据进行增删改查。上一台电脑好好的程序，新电脑死活连不上mongodb数据库。同一套代码，没任何修改，搞得我怀疑人生了，打开浏览器进入mongodb官网毫无问题，也能进入线上系统查看数据，网络应该是没问题。于是我尝试了一下手机热点，这次代码能正常跑起来，连接数据库了！！！是不
      
                    
      • 
                    
    • C++ lambda闭包消除类成员变量
                        barbyQAQ
c++c++java算法
                        
      原文链接：https://blog.csdn.net/qq_51470638/article/details/142151502一、背景在面向对象编程时，常常要添加类成员变量。然而类成员一旦多了之后，也会带来干扰。拿到一个类，一看成员变量好几十个，就问你怕不怕？二、解决思路可以借助函数式编程思想，来消除一些不必要的类成员变量。三、实例举个例子：classClassA{public:...intfu
      
                    
      • 
                    
    • tiff批量转png
                        诺有缸的高飞鸟
opencv图像处理pythonopencv图像处理
                        
      目录写在前面代码完写在前面1、本文内容tiff批量转png2、平台/环境opencv,python3、转载请注明出处：https://blog.csdn.net/qq_41102371/article/details/132975023代码importnumpyasnpimportcv2importosdeffindAllFile(base):file_list=[]forroot,ds,fsin
      
                    
      • 
                    
    • 笋丁网页自动回复机器人V3.0.0免授权版源码
                        希希分享
软希网58soho_cn源码资源笋丁网页自动回复机器人
                        
      笋丁网页机器人一款可设置自动回复，默认消息，调用自定义api接口的网页机器人。此程序后端语言使用Golang，内存占用最高不超过30MB，1H1G服务器流畅运行。仅支持Linux服务器部署，不支持虚拟主机，请悉知！使用自定义api功能需要有一定的建站基础。源码下载：https://download.csdn.net/download/m0_66047725/89754250更多资源下载：关注我。安
      
                    
      • 
                    
    • 【树一线性代数】005入门
                        Owlet_woodBird
算法
                        
      Index本文稍后补全，推荐阅读：https://blog.csdn.net/weixin_60702024/article/details/141874376分析实现总结本文稍后补全，推荐阅读：https://blog.csdn.net/weixin_60702024/article/details/141874376已知非空二叉树T的结点值均为正整数，采用顺序存储方式保存，数据结构定义如下:t
      
                    
      • 
                    
    • Ubuntu18.04 Docker部署Kinship(Django)项目过程
                        Dante617

                        
      1Docker的安装https://blog.csdn.net/weixin_41735055/article/details/1003551792下载镜像dockerpullprogramize/python3.6.8-dlib下载的镜像里包含python3.6.8和dlib19.17.03启动镜像dockerrun-it--namekinship-p7777:80-p3307:3306-p55
      
                    
      • 
                    
    • Dockerfile命令详解之 FROM
                        清风怎不知意
容器化java前端javascript
                        
      许多同学不知道Dockerfile应该如何写，不清楚Dockerfile中的指令分别有什么意义，能达到什么样的目的，接下来我将在容器化专栏中详细的为大家解释每一个指令的含义以及用法。专栏订阅传送门https://blog.csdn.net/qq_38220908/category_11989778.html指令不区分大小写。但是，按照惯例，它们应该是大写的，以便更容易地将它们与参数区分开来。(引用
      
                    
      • 
                    
    • 【C语言】- 自定义类型：结构体、枚举、联合
                        Cavalier_01
C语言
                        
      【C语言】：操作符（https://mp.csdn.net/editor/html/115218055）数据类型（https://mp.csdn.net/editor/html/115219664）自定义类型：结构体、枚举、联合（https://mp.csdn.net/editor/html/115373785）变量、常量（https://mp.csdn.net/editor/html/11523
      
                    
      • 
                    
    • html+css网页设计 旅游网站首页1个页面
                        html+css+js网页设计
htmlcss旅游
                        
      html+css网页设计旅游网站首页1个页面网页作品代码简单，可使用任意HTML辑软件（如：Dreamweaver、HBuilder、Vscode、Sublime、Webstorm、Text、Notepad++等任意html编辑软件进行运行及修改编辑等操作）。获取源码1，访问该网站https://download.csdn.net/download/qq_42431718/897527112，点击
      
                    
      • 
                    
    • Kubernetes数据持久化
                        看清所苡看轻
kubernetes(k8s)emptyDirHostPathpvpvckubernetes
                        
      在k8s中，Volume（数据卷）存在明确的生命周期（与包含该数据卷的容器组（pod）相同）。因此Volume的生命周期比同一容器组（pod）中任意容器的生命周期要更长，不管容器重启了多少次，数据都被保留下来。当然，如果pod不存在了，数据卷自然退出了。此时，根据pod所使用的数据卷类型不同，数据可能随着数据卷的退出而删除，也可能被真正持久化，并在下次容器组重启时仍然可以使用。从根本上来说，一个数
      
                    
      • 
                    
    • 网关gateway学习总结
                        猪猪365
学习总结学习总结
                        
      一微服务概述:微服务网关就是一个系统!通过暴露该微服务的网关系统,方便我们进行相关的鉴权,安全控制,日志的统一处理,易于监控的相关功能!实现微服务网关技术都有哪些呢?1nginx:nginx是一个高性能的http和反向代理web的服务器,同事也提供了IMAP/POP3/SMTP服务.他可以支撑5万并发链接,并且cpu,内存等资源消耗非常的低,运行非常的稳定!2Zuul:Zuul是Netflix公司
      
                    
      • 
                    
    • ArcGIS Pro SDK （十四）地图探索 5 时间与动画
                        WineMonk
ArcGISProSDKarcgisarcgisprosdkgisc#
                        
      ArcGISProSDK（十四）地图探索5时间与动画文章目录ArcGISProSDK（十四）地图探索5时间与动画1时间1.1时间提前1个月1.2禁用地图中的时间。2动画2.1设置动画长度2.2缩放动画2.3相机关键帧2.4插值相机2.5插值时间2.6插值范围2.7创建摄像机关键帧2.8创建时间关键帧2.9创建范围关键帧2.10创建图层关键帧环境：VisualStudio2022+.NET6+Arc
      
                    
      • 
                    
    • 解决SDK Manager 中 没有 Support Library
                        木鱼wzh

                        
      1、直接修改SDK-MANAGER打开sdk-manager—->Tools—->options然后点击packages—->showobsoletepackages即可在最下面的Extras目录下找到推荐两个自己使用的镜像服务器：mirrors.neusoft.edu.cn端口80mirrors.dormforce.net端口802、去官网下载SupportLibrar点击这里进入官网进入百度云
      
                    
      • 
                    
    • Kubernetes部署MySQL数据持久化
                        沫殇-MS
KubernetesMySQL数据库kubernetesmysql容器
                        
      一、安装配置NFS服务端1、安装nfs-kernel-server：sudoapt-yinstallnfs-kernel-server2、服务端创建共享目录#列出所有可用块设备的信息lsblk#格式化磁盘sudomkfs-text4/dev/sdb#创建一个目录：sudomkdir-p/data/nfs/mysql#更改目录权限：sudochown-Rnobody:nogroup/data/nfs
      
                    
      • 
                    
    • 个人学习笔记7-6：动手学深度学习pytorch版-李沐
                        浪子L
深度学习深度学习笔记计算机视觉python人工智能神经网络pytorch
                        
      #人工智能##深度学习##语义分割##计算机视觉##神经网络#计算机视觉13.11全卷积网络全卷积网络（fullyconvolutionalnetwork，FCN）采用卷积神经网络实现了从图像像素到像素类别的变换。引入l转置卷积（transposedconvolution）实现的，输出的类别预测与输入图像在像素级别上具有一一对应关系：通道维的输出即该位置对应像素的类别预测。13.11.1构造模型下
      
                    
      • 
                    
    • Kubernetes的3种数据持久化方式
                        Seal^_^
【云原生】容器化与编排技术持续集成#Kuberneteskubernetes容器云原生EmptyDir面试HostPath
                        
      Kubernetes的3种数据持久化方式1.EmptyDir2.HostPath3.PersistentVolume(PV)TheBegin点点关注，收藏不迷路Kubernetes提供了几种数据持久化方式，以满足不同场景的需求：1.EmptyDir用途：临时数据存储，Pod内容器间共享。特点：生命周期与Pod相同，Pod删除时数据也删除。2.HostPath用途：访问宿主机特定文件或目录。特点：增
      
                    
      • 
                    
    • 【Kubernetes】常见面试题汇总（十一）
                        summer.335
Kuberneteskubernetes容器云原生
                        
      目录33.简述Kubernetes外部如何访问集群内的服务？34.简述Kubernetesingress？35.简述Kubernetes镜像的下载策略？33.简述Kubernetes外部如何访问集群内的服务？（1）对于Kubernetes，集群外的客户端默认情况，无法通过Pod的IP地址或者Service的虚拟IP地址：虚拟端口号进行访问。（2）通常可以通过以下方式进行访问Kubernetes集群
      
                    
      • 
                                
    • 强大的销售团队背后 竟然是大数据分析的身影
                                    蓝儿唯美
数据分析
                                    
      Mark Roberge是HubSpot的首席财务官，在招聘销售职位时使用了大量数据分析。但是科技并没有挤走直觉。 
大家都知道数理学家实际上已经渗透到了各行各业。这些热衷数据的人们通过处理数据理解商业流程的各个方面，以重组弱点，增强优势。 
Mark Roberge是美国HubSpot公司的首席财务官，HubSpot公司在构架集客营销现象方面出过一份力——因此他也是一位数理学家。他使用数据分析 
      
                                
      • 
                                
    • Haproxy+Keepalived高可用双机单活
                                    bylijinnan
负载均衡keepalivedhaproxy高可用
                                    
      我们的应用MyApp不支持集群，但要求双机单活（两台机器：master和slave）： 
1.正常情况下，只有master启动MyApp并提供服务 
2.当master发生故障时，slave自动启动本机的MyApp，同时虚拟IP漂移至slave，保持对外提供服务的IP和端口不变 
 
F5据说也能满足上面的需求，但F5的通常用法都是双机双活，单活的话还没研究过 
 
 
服务器资源 
 
10.7
      
                                
      • 
                                
    • eclipse编辑器中文乱码问题解决
                                    0624chenhong
eclipse乱码
                                    
      使用Eclipse编辑文件经常出现中文乱码或者文件中有中文不能保存的问题，Eclipse提供了灵活的设置文件编码格式的选项，我们可以通过设置编码 格式解决乱码问题。在Eclipse可以从几个层面设置编码格式：Workspace、Project、Content Type、File 
本文以Eclipse 3.3（英文）为例加以说明： 
1. 设置Workspace的编码格式： 
Windows-&g
      
                                
      • 
                                
    • 基础篇--resources资源
                                    不懂事的小屁孩
android
                                    
      最近一直在做java开发，偶尔敲点android代码，突然发现有些基础给忘记了，今天用半天时间温顾一下resources的资源。 
 
String.xml    字符串资源   涉及国际化问题  

http://www.2cto.com/kf/201302/190394.html   
 
string-array
      
                                
      • 
                                
    • 接上篇补上window平台自动上传证书文件的批处理问卷
                                    酷的飞上天空
window
                                    
        
@echo off
: host=服务器证书域名或ip，需要和部署时服务器的域名或ip一致  ou=公司名称, o=公司名称
set host=localhost      
set ou=localhost        
set o=localhost         
set password=123456
set validity=3650

set salias=s
      
                                
      • 
                                
    • 企业物联网大潮涌动：如何做好准备？
                                    蓝儿唯美
企业
                                    
      物联网的可能性也许是无限的。要找出架构师可以做好准备的领域然后利用日益连接的世界。 
尽管物联网（IoT）还很新，企业架构师现在也应该为一个连接更加紧密的未来做好计划，而不是跟上闸门被打开后的集成挑战。“问题不在于物联网正在进入哪些领域，而是哪些地方物联网没有在企业推进，” Gartner研究总监Mike Walker说。 
Gartner预测到2020年物联网设备安装量将达260亿，这些设备在全
      
                                
      • 
                                
    • spring学习——数据库（mybatis持久化框架配置）
                                    a-john
mybatis
                                    
      Spring提供了一组数据访问框架，集成了多种数据访问技术。无论是JDBC，iBATIS(mybatis)还是Hibernate，Spring都能够帮助消除持久化代码中单调枯燥的数据访问逻辑。可以依赖Spring来处理底层的数据访问。 
mybatis是一种Spring持久化框架，要使用mybatis，就要做好相应的配置： 
1，配置数据源。有很多数据源可以选择，如：DBCP，JDBC，aliba
      
                                
      • 
                                
    • Java静态代理、动态代理实例
                                    aijuans
Java静态代理
                                    
        
采用Java代理模式，代理类通过调用委托类对象的方法，来提供特定的服务。委托类需要实现一个业务接口，代理类返回委托类的实例接口对象。 
按照代理类的创建时期，可以分为：静态代理和动态代理。 
所谓静态代理：　指程序员创建好代理类，编译时直接生成代理类的字节码文件。 
所谓动态代理：　在程序运行时，通过反射机制动态生成代理类。 
  
一、静态代理类实例： 
1、Serivce.ja
      
                                
      • 
                                
    • Struts1与Struts2的12点区别
                                    asia007
Struts1与Struts2
                                    
      1) 在Action实现类方面的对比：Struts 1要求Action类继承一个抽象基类；Struts 1的一个具体问题是使用抽象类编程而不是接口。Struts 2 Action类可以实现一个Action接口，也可以实现其他接口，使可选和定制的服务成为可能。Struts 2提供一个ActionSupport基类去实现常用的接口。即使Action接口不是必须实现的，只有一个包含execute方法的P
      
                                
      • 
                                
    • 初学者要多看看帮助文档 不要用js来写Jquery的代码
                                    百合不是茶
jqueryjs
                                    
      解析json数据的时候需要将解析的数据写到文本框中,  出现了用js来写Jquery代码的问题; 
  
1, JQuery的赋值  有问题 
   代码如下: data.username 表示的是:  网易 
  
         $("#use
      
                                
      • 
                                
    • 经理怎么和员工搞好关系和信任
                                    bijian1013
团队项目管理管理
                                    
              产品经理应该有坚实的专业基础，这里的基础包括产品方向和产品策略的把握，包括设计，也包括对技术的理解和见识，对运营和市场的敏感，以及良好的沟通和协作能力。换言之，既然是产品经理，整个产品的方方面面都应该能摸得出门道。这也不懂那也不懂，如何让人信服？如何让自己懂？就是不断学习，不仅仅从书本中，更从平时和各种角色的沟通
      
                                
      • 
                                
    • 如何为rich:tree不同类型节点设置右键菜单
                                    sunjing
contextMenutreeRichfaces
                                    
      组合使用target和targetSelector就可以啦，如下： <rich:tree id="ruleTree" value="#{treeAction.ruleTree}" var="node" nodeType="#{node.type}"
    selectionChangeListener=&qu
      
                                
      • 
                                
    • 【Redis二】Redis2.8.17搭建主从复制环境
                                    bit1129
redis
                                    
      开始使用Redis2.8.17 
Redis第一篇在Redis2.4.5上搭建主从复制环境，对它的主从复制的工作机制，真正的惊呆了。不知道Redis2.8.17的主从复制机制是怎样的，Redis到了2.4.5这个版本，主从复制还做成那样，Impossible is nothing! 本篇把主从复制环境再搭一遍看看效果，这次在Unbuntu上用官方支持的版本。   Ubuntu上安装Red
      
                                
      • 
                                
    • JSONObject转换JSON--将Date转换为指定格式
                                    白糖_
JSONObject
                                    
      项目中，经常会用JSONObject插件将JavaBean或List<JavaBean>转换为JSON格式的字符串，而JavaBean的属性有时候会有java.util.Date这个类型的时间对象，这时JSONObject默认会将Date属性转换成这样的格式： 
  
{"nanos":0,"time":-27076233600000,
      
                                
      • 
                                
    • JavaScript语言精粹读书笔记
                                    braveCS
JavaScript
                                    
      【经典用法】： 
  
//①定义新方法

Function .prototype.method=function(name, func){

              this.prototype[name]=func;

              return this;

}

 

//②给Object增加一个create方法，这个方法创建一个使用原对
      
                                
      • 
                                
    • 编程之美-找符合条件的整数 用字符串来表示大整数避免溢出
                                    bylijinnan
编程之美
                                    
      

import java.util.LinkedList;

public class FindInteger {

	/**
	 *  编程之美 找符合条件的整数 用字符串来表示大整数避免溢出
	 *  题目：任意给定一个正整数N，求一个最小的正整数M(M>1)，使得N*M的十进制表示形式里只含有1和0
	 *  
	 *  假设当前正在搜索由0，1组成的K位十进制数
      
                                
      • 
                                
    • 读书笔记
                                    chengxuyuancsdn
读书笔记
                                    
      1、Struts访问资源 
2、把静态参数传递给一个动作 
3、<result>type属性 
4、s:iterator、s:if c:forEach 
5、StringBuilder和StringBuffer 
6、spring配置拦截器 
 
1、访问资源 
(1)通过ServletActionContext对象和实现ServletContextAware,ServletReque
      
                                
      • 
                                
    • [通讯与电力]光网城市建设的一些问题
                                    comsci
问题
                                    
       
      信号防护的问题,前面已经说过了,这里要说光网交换机与市电保障的关系 
 
      我们过去用的ADSL线路,因为是电话线,在小区和街道电力中断的情况下,只要在家里用笔记本电脑+蓄电池,连接ADSL,同样可以上网........ 
 
    
      
                                
      • 
                                
    • oracle 空间RESUMABLE
                                    daizj
oracle空间不足RESUMABLE错误挂起
                                    
      空间RESUMABLE操作  转 
 
 
 
Oracle从9i开始引入这个功能，当出现空间不足等相关的错误时，Oracle可以不是马上返回错误信息，并回滚当前的操作，而是将操作挂起，直到挂起时间超过RESUMABLE TIMEOUT，或者空间不足的错误被解决。 
 
这一篇简单介绍空间RESUMABLE的例子。 
 
 
 
第一次碰到这个特性是在一次安装9i数据库的过程中，在利用D
      
                                
      • 
                                
    • 重构第一次写的线程池
                                    dieslrae
线程池 python
                                    
      最近没有什么学习欲望,修改之前的线程池的计划一直搁置,这几天比较闲,还是做了一次重构,由之前的2个类拆分为现在的4个类. 
 
1、首先是工作线程类:TaskThread,此类为一个工作线程,用于完成一个工作任务,提供等待(wait),继续(proceed),绑定任务(bindTask)等方法 
 

#!/usr/bin/env python
# -*- coding:utf8 -*-


      
                                
      • 
                                
    • C语言学习六指针
                                    dcj3sjt126com
c
                                    
      初识指针，简单示例程序： 
/*
	指针就是地址，地址就是指针
	地址就是内存单元的编号
	指针变量是存放地址的变量
	指针和指针变量是两个不同的概念
	但是要注意： 通常我们叙述时会把指针变量简称为指针，实际它们含义并不一样
*/
# include <stdio.h>

int main(void)
{
	int * p;	// p是变量的名字， int * 
      
                                
      • 
                                
    • yii2 beforeSave afterSave beforeDelete
                                    dcj3sjt126com
delete
                                    
      public function afterSave($insert, $changedAttributes)
{
    parent::afterSave($insert, $changedAttributes);
    if($insert) {
        //这里是新增数据
    } else {
        //这里是更新数据
    }  
} 
 
      
                                
      • 
                                
    • timertask
                                    shuizhaosi888
timertask
                                    
      java.util.Timer timer = new java.util.Timer(true); 
// true 说明这个timer以daemon方式运行（优先级低， 
// 程序结束timer也自动结束），注意，javax.swing 
// 包中也有一个Timer类，如果import中用到swing包， 
// 要注意名字的冲突。 

TimerTask task = new
      
                                
      • 
                                
    • Spring Security（13）——session管理
                                    234390216
sessionSpring Security攻击保护超时
                                    
      session管理 
目录 
  
1.1     检测session超时 
1.2     concurrency-control 
1.3     session 固定攻击保护 
  
      
      
                                
      • 
                                
    • 公司项目NODEJS实践0.3[ mongo / session ...]
                                    逐行分析JS源代码
mongodbsessionnodejs
                                    
          
http://www.upopen.cn 
  
一、前言 
        书接上回，我们搭建了WEB服务端路由、模板等功能，完成了register 通过ajax与后端的通信，今天主要完成数据与mongodb的存取，实现注册 / 登录 /
      
                                
      • 
                                
    • pojo.vo.po.domain区别
                                    LiaoJuncai
javaVOPOJOjavabeandomain
                                    
      　　POJO = "Plain Old Java Object"，是MartinFowler等发明的一个术语，用来表示普通的Java对象，不是JavaBean, EntityBean 或者 SessionBean。POJO不但当任何特殊的角色，也不实现任何特殊的Java框架的接口如，EJB， JDBC等等。 
　　 
　　即POJO是一个简单的普通的Java对象，它包含业务逻辑
      
                                
      • 
                                
    • Windows Error Code
                                    OhMyCC
windows
                                    
      0 操作成功完成. 
1 功能错误. 
2 系统找不到指定的文件. 
3 系统找不到指定的路径. 
4 系统无法打开文件. 
5 拒绝访问. 
6 句柄无效. 
7 存储控制块被损坏. 
8 存储空间不足, 无法处理此命令. 
9 存储控制块地址无效. 
10 环境错误. 
11 试图加载格式错误的程序. 
12 访问码无效. 
13 数据无效. 
14 存储器不足, 无法完成此操作. 
15 系
      
                                
      • 
                                
    • 在storm集群环境下发布Topology
                                    roadrunners
集群stormtopologyspoutbolt
                                    
      storm的topology设计和开发就略过了。本章主要来说说如何在storm的集群环境中，通过storm的管理命令来发布和管理集群中的topology。 
  
1、打包 
打包插件是使用maven提供的maven-shade-plugin，详细见maven-shade-plugin。 
<plugin>
	<groupId>org.apache.maven.
      
                                
      • 
                                
    • 为什么不允许代码里出现“魔数”
                                    tomcat_oracle
java
                                    
      　　在一个新项目中，我最先做的事情之一，就是建立使用诸如Checkstyle和Findbugs之类工具的准则。目的是制定一些代码规范，以及避免通过静态代码分析就能够检测到的bug。   　　迟早会有人给出案例说这样太离谱了。其中的一个案例是Checkstyle的魔数检查。它会对任何没有定义常量就使用的数字字面量给出警告，除了-1、0、1和2。   　　很多开发者在这个检查方面都有问题，这可以从结果
      
                                
      • 
                                
    • zoj 3511 Cake Robbery(线段树)
                                    阿尔萨斯
线段树
                                    
       题目链接：zoj 3511 Cake Robbery 
 题目大意：就是有一个N边形的蛋糕，切M刀，从中挑选一块边数最多的，保证没有两条边重叠。 
 解题思路：有多少个顶点即为有多少条边，所以直接按照切刀切掉点的个数排序，然后用线段树维护剩下的还有哪些点。 
#include <cstdio>
#include <cstring>
#include <vector&
      
                                
      •