本笔记摘抄自:https://www.cnblogs.com/liqingwen/p/5832322.html,记录一下学习过程以备后续查用。

LINQ 简介:

    语言集成查询(LINQ)是Visual Studio 2008和.NET Framework 3.5版中引入的一项创新功能。

 传统上,针对数据的查询都是以简单的字符串表示,而没有编译时类型检查或IntelliSense支持。此外,您还必须针对以下各种数据源学习一种不同的查询

语言:SQL数据库、XML文档、各种Web服务等。通过LINQ,可以使用语言关键字和熟悉的运算符针对强类型化对象集合编写查询。

在Visual Studio中,可以为以下数据源编写LINQ查询:SQL Server数据库、XML文档、ADO.NET数据集以及支持 IEnumerable或泛型 IEnumerable<T>

接口的任意对象集合,使用要求:项目 ≥ .NET Framework 3.5。

一、LINQ查询

    查询是一种从数据源检索数据的表达式。随着时间的推移,人们已经为各种数据源开发了不同的语言。例如,用于关系数据库的SQL和用于XML的XQuery。

因此,开发人员不得不针对他们必须支持的每种数据源或数据格式而学习新的查询语言。LINQ通过提供一种跨数据源和数据格式使用数据的一致模型,简化

了这一情况。在LINQ查询中,始终会用到对象。可以使用相同的编码模式来查询和转换XML文档、SQL数据库、ADO.NET数据集、.NET集合中的数据以及

对其有LINQ提供程序可用的任何其他格式的数据。

1.1 查询操作的三个部分

    操作三部曲:①取数据源 ②创建查询 ③执行查询

下面代码演示LINQ to OBJECT:

    class Program
{
static void Main(string[] args)
{
#region LINQ to OBJECT
//查询三部曲:1、获取数据源
var nums = new int[] { , , , , , , }; //查询三部曲:2、创建查询
var query =
from num in nums
where (num % ) ==
select num; //查询三部曲:3、执行查询
foreach (var num in query)
{
Console.Write($"{num} ");
} Console.Read();
#endregion
}
}

运行结果如下:

下图显示了完整的查询操作。在LINQ中,查询的执行与查询本身截然不同。换句话说,查询本身指的是只创建查询变量,不检索任何数据。

1.2 数据源

在上一个示例中(LINQ to OBJECT),由于数据源是数组,因此它隐式支持泛型 IEnumerable<T> (可枚举)接口。支持 IEnumerable<T> 或派生接口(如

泛型IQueryable<T>)的类型称为可查询类型。

可查询类型不需要进行修改或特殊处理就可以用作LINQ数据源。如果源数据还没有作为可查询类型出现在内存中,则LINQ提供程序必须以此方式表示源数

据。例如,LINQ to XML将XML文档加载到可查询的 XElement 类型中。

下面代码演示LINQ to XML:

创建一个Test.xml文件,放在主目录下。

<DocumentElement>
<Category>
<MO_NO>MOA1911070001</MO_NO>
<MRP_NO>8198712090963008</MRP_NO>
<QTY>1.00000000</QTY>
<BIL_NO>MPA19110701</BIL_NO>
</Category>
<Category>
<MO_NO>MOA1911070002</MO_NO>
<MRP_NO>8193000000003172</MRP_NO>
<QTY>1.00000000</QTY>
<BIL_NO>MPA19110702</BIL_NO>
</Category>
<Category>
<MO_NO>MOA1911070003</MO_NO>
<MRP_NO>8193002043133003</MRP_NO>
<QTY>1.00000000</QTY>
<BIL_NO>MPA19110702</BIL_NO>
</Category>
<Category>
<MO_NO>MOA1911070004</MO_NO>
<MRP_NO>8193002043133004</MRP_NO>
<QTY>1.00000000</QTY>
<BIL_NO>MPA19110702</BIL_NO>
</Category>
<Category>
<MO_NO>MOA1911070005</MO_NO>
<MRP_NO>8193002043133005</MRP_NO>
<QTY>1.00000000</QTY>
<BIL_NO>MPA19110702</BIL_NO>
</Category>
<Category>
<MO_NO>MOA1911070006</MO_NO>
<MRP_NO>8198922092971001</MRP_NO>
<QTY>1.00000000</QTY>
<BIL_NO>MPA19110703</BIL_NO>
</Category>
<Category>
<MO_NO>MOA1911070007</MO_NO>
<MRP_NO>8198922092971002</MRP_NO>
<QTY>1.00000000</QTY>
<BIL_NO>MPA19110703</BIL_NO>
</Category>
<Category>
<MO_NO>MOA1911070008</MO_NO>
<MRP_NO>8198922092971010</MRP_NO>
<QTY>1.00000000</QTY>
<BIL_NO>MPA19110703</BIL_NO>
</Category>
<Category>
<MO_NO>MOA1911070009</MO_NO>
<MRP_NO>8198922092971200</MRP_NO>
<QTY>1.00000000</QTY>
<BIL_NO>MPA19110703</BIL_NO>
</Category>
<Category>
<MO_NO>MOA1911070010</MO_NO>
<MRP_NO>8199862094443008</MRP_NO>
<QTY>1.00000000</QTY>
<BIL_NO>MPA19110704</BIL_NO>
</Category>
</DocumentElement>
    class Program
{
static void Main(string[] args)
{
#region LINQ to XML
var xe = XElement.Load(@"..\..\Test.xml");
var query =
from item in xe.Descendants("Category")
select item;
foreach (var item in query)
{
Console.WriteLine($"MO_NO={item.Element("MO_NO").Value}");
}
Console.Read();
#endregion
}
}

运行结果如下:

LINQ to SQL中,首先需要生成对象模型映射到关系数据库,然后针对这些对象编写查询,由LINQ to SQL在运行时处理与数据库的通信。

准备一:下文中用到的Northwind数据库,下载地址为:https://www.microsoft.com/en-us/download/confirmation.aspx?id=23654

准备二:若本机没有安装LINQ to SQL工具,可参考安装教程:https://blog.csdn.net/u011176794/article/details/90287293

准备三:添加新建项,选择LINQ to SQL类,命名为Sample。

准备四:服务器资源管理器的数据连接中,右键添加连接,依导向连接至SQL Server数据库。

准备五:将相关数据表拖至Sample.dbml中并保存。

准备六:添加引用System.Data.Linq。

下面代码演示LINQ to SQL:

    class Program
{
static void Main(string[] args)
{
#region LINQ to SQL
var db = new SampleDataContext();
var query =
from cust in db.Customers
where cust.City == "London"
select cust;
foreach (var item in query)
{
Console.WriteLine($"CustomerID={item.CustomerID}");
}
Console.Read();
#endregion
}
}

运行结果如下:

    1.3查询

查询指定要从数据源中检索的信息,可以指定在返回这些信息之前如何对其进行排序、分组和结构化。 查询存储在查询变量中,并用查询表达式进行初始

化。之前的示例中的查询是从整数数组中返回所有的偶数。该查询表达式包含三个子句:fromwhereselect。如果您熟悉SQL,您会注意到这些子句的

顺序与SQL中的顺序相反,from 子句指定数据源,where 子句指定应用筛选器,select 子句指定返回的元素的类型。目前需要注意的是,在LINQ中,查询

变量本身不执行任何操作并且不返回任何数据,它只是存储在以后某个时刻执行查询时为生成结果而必需的信息。

    1.4 查询执行

1.延迟执行

如前所述,查询变量本身只是存储查询命令,实际的查询执行会延迟到在foreach语句中循环访问查询变量时发生,此概念称为“延迟执行”。

2.强制立即执行

对一系列源元素执行聚合函数的查询必须首先循环访问这些元素,CountMaxAverageFirst就属于此类查询。由于查询本身必须使用foreach以便

返回结果,因此这些查询在执行时不使用显式foreach语句。另外还要注意,这些类型的查询返回单个值,而不是IEnumerable集合。

    class Program
{
static void Main(string[] args)
{
#region LINQ查询强制立即执行一
var nums = new int[] { , , , , , , };
var query =
from num in nums
where (num % ) ==
select num;
var numCount = query.Count();
Console.WriteLine($"NumCount={numCount}");
Console.Read();
#endregion
}
}
    运行结果如下:

若要强制立即执行任意查询并缓存其结果,可以调用ToList<TSource>ToArray<TSource>方法。

    class Program
{
static void Main(string[] args)
{
#region LINQ查询强制立即执行二
var nums = new int[] { , , , , , , }; var query2 =
(from num in nums
where (num % ) ==
select num).ToList(); var query3 =
(from num in nums
where (num % ) ==
select num).ToArray(); Console.WriteLine($"NumCount={query2.Count}");
Console.WriteLine($"NumCount={query3.Length}");
Console.Read();
#endregion
}
}

运行结果如下:

二、基本 LINQ 查询操作

2.1 获取数据源:from

在LINQ查询中,第一步是指定数据源。像在大多数编程语言中一样,必须先声明变量,才能使用它。在LINQ查询中,最先使用from子句的目的是引入数据

源和范围变量。

    class Program
{
static void Main(string[] args)
{
#region LINQ to SQL
var db = new SampleDataContext(); //query是IEnumerable<Cutsomer>类型
//数据源(db.customers)和范围变量(cust)
var query =
from cust in db.Customers
where cust.City == "London"
select cust; foreach (var item in query)
{
Console.WriteLine($"CustomerID={item.CustomerID}");
}
Console.Read();
#endregion
}
}

范围变量类似于foreach循环中的迭代变量,但在查询表达式中,实际上不发生迭代。执行查询时,范围变量将用作对customers中的每个后续元素的引用。

因为编译器可以推断cust的类型,所以您不必显式指定此类型。

2.2 筛选:where

也许最常用的查询操作是应用布尔表达式形式的筛选器,此筛选器使查询只返回那些表达式结果为true的元素。使用where子句生成结果,实际上,筛选器

指定从源序列中排除哪些元素。

您可以使用熟悉的C#逻辑AND(&&)OR(||)运算符来根据需要在where子句中应用任意数量的筛选表达式。

    class Program
{
static void Main(string[] args)
{
#region LINQ 筛选:where
var db = new SampleDataContext(); var query1 =
from cust in db.Customers
where cust.City == "London" && cust.CustomerID == "AROUT"
select cust;
var query2 =
from cust in db.Customers
where cust.City == "London" || cust.City == "Paris"
select cust; foreach (var item in query1)
{
Console.WriteLine($"query1->City={item.City},CustomerID={item.CustomerID}");
}
foreach (var item in query2)
{
Console.WriteLine($"query2->City={item.City},CustomerID={item.CustomerID}");
}
Console.Read();
#endregion
}
}

运行结果如下:

2.3 排序:orderby

    通常可以很方便地将返回的数据进行排序。orderby子句将使返回的序列中的元素按照被排序的类型的默认比较器进行排序。

    class Program
{
static void Main(string[] args)
{
#region LINQ 排序:orderby
var db = new SampleDataContext();
var query =
from cust in db.Customers
where cust.City == "London"
orderby cust.CustomerID
select cust;
foreach (var item in query)
{
Console.WriteLine($"CustomerID={item.CustomerID}");
}
Console.Read();
#endregion
}
}

运行结果如下:

2.4 分组:group

    使用group子句,您可以按指定的键分组结果。

    class Program
{
static void Main(string[] args)
{
#region LINQ 分组一:group
var db = new SampleDataContext();
var query =
from cust in db.Customers
where cust.City == "London" || cust.City == "Paris"
group cust by cust.City;
foreach (var group in query)
{
Console.WriteLine(group.Key);
foreach (var cust in group)
{
Console.WriteLine($"City={cust.City},CustomerID={cust.CustomerID}");
}
}
Console.Read();
#endregion
}
}

运行结果如下:

在本例中,cust.City是键。

在使用group子句结束查询时,结果采用列表的列表形式。列表中的每个元素是一个具有Key成员及根据该键分组的元素列表的对象。在循环访问生成组

序列的查询时,您必须使用嵌套的foreach循环。外部循环用于循环访问每个组,内部循环用于循环访问每个组的成员。

如果您必须引用组操作的结果,可以使用into关键字来创建可进一步查询的标识符。

    class Program
{
static void Main(string[] args)
{
#region LINQ 分组二:group
var db = new SampleDataContext();
var query =
from cust in db.Customers
where cust.City == "London" || cust.City == "Paris"
group cust by cust.City into custGroup
where custGroup.Count() >
orderby custGroup.Key
select custGroup;
foreach (var group in query)
{
Console.WriteLine(group.Key);
foreach (var cust in group)
{
Console.WriteLine($"City={cust.City},CustomerID={cust.CustomerID}");
}
}
Console.Read();
#endregion
}
}

运行结果如下:

2.5 联接:join

    联接运算创建数据源中没有显式建模的序列之间的关联。例如,您可以执行联接来查找位于同一地点的所有客户和经销商。在LINQ中,join子句始终针对

对象集合而非直接针对数据库表运行。

    class Program
{
static void Main(string[] args)
{
#region LINQ 联接:join
var db = new SampleDataContext();
var qurey =
from order in db.Orders
join cust in db.Customers on order.CustomerID equals cust.CustomerID
select new { order.OrderID, order.CustomerID, cust.ContactName };
foreach (var item in qurey.Take())
{
Console.WriteLine($"OrderID={item.OrderID},CustomerID={item.CustomerID},ContactName={item.ContactName}");
}
Console.Read();
#endregion
}
}

运行结果如下:

2.6 选择(投影):select

    select子句生成查询结果并指定每个返回的元素的“形状”或类型。

例如,您可以指定结果包含的是整个Customer对象、仅一个成员、成员的子集或者某个基于计算或新对象创建的完全不同的结果类型。当select子句生成除源

元素副本以外的内容时,该操作称为“投影”。

三、使用 LINQ 进行数据转换

语言集成查询 (LINQ) 不但是检索数据的利器,而且还是一个功能强大的数据转换工具。通过使用LINQ查询,您可以将源序列用作输入,并采用多种方式修改

它以创建新的输出序列。您可以通过排序及分组来修改该序列,而不必修改元素本身。但是,LINQ 查询的最强大的功能是能够创建新类型。这一功能在select子

句中实现。

3.1 将多个输入联接到一个输出序列

    /// <summary>
/// 学生类
/// </summary>
class Student
{
public string Name { get; set; } public int Age { get; set; } public string City { get; set; } public List<int> Scores { get; set; }
} /// <summary>
/// 教师类
/// </summary>
class Teacher
{
public string Name { get; set; } public int Age { get; set; } public string City { get; set; }
} class Program
{
static void Main(string[] args)
{
#region LINQ 将多个输入联接到一个输出序列
//创建第一个数据源
var students = new List<Student>()
{
new Student()
{
Age = ,
City = "广州",
Name = "小A",
Scores = new List<int>(){,,,}
},
new Student()
{
Age = ,
City = "深圳",
Name = "小B",
Scores = new List<int>(){,,,}
}
}; //创建第二个数据源
var teachers = new List<Teacher>()
{
new Teacher()
{
Age = ,
City = "广州",
Name = "张A"
},
new Teacher()
{
Age = ,
City = "广州",
Name = "李A"
}
}; //创建查询
var query =
(
from student in students
where student.City == "广州"
select student.Name
).Concat
(
from teacher in teachers
where teacher.City == "广州"
select teacher.Name
); //执行查询
foreach (var person in query)
{
Console.WriteLine(person);
} Console.Read();
#endregion
}
}

运行结果如下:

3.2 选择各个源元素的子集

1. 若要只选择源元素的一个成员,请使用点运算。

var query =
from cust in db.Customers
select cust.City;

2. 若要创建包含源元素的多个属性的元素,可以使用具有命名对象或匿名类型的对象初始值设定项。

var query =
from cust in db.Customer
select new { cust.Name, cust.City };

3.3 将内存中的对象转换为XML

    /// <summary>
/// 学生类
/// </summary>
class Student
{
public string Name { get; set; } public int Age { get; set; } public string City { get; set; } public List<int> Scores { get; set; }
} class Program
{
static void Main(string[] args)
{
#region LINQ 将内存中的对象转换为XML
//创建数据源
var students = new List<Student>()
{
new Student()
{
Age = ,
City = "广州",
Name = "小A",
Scores = new List<int>(){,,,}
},
new Student()
{
Age = ,
City = "深圳",
Name = "小B",
Scores = new List<int>(){,,,}
}
};
//创建查询
var studentsToXml = new XElement
(
"Root",
from student in students
let x = $"{student.Scores[0]},{student.Scores[1]},{student.Scores[2]},{student.Scores[3]}"
select new XElement
(
"student",
new XElement("Name", student.Name),
new XElement("Age", student.Age),
new XElement("Scores", x)
)
); //执行查询
Console.WriteLine(studentsToXml);
Console.Read();
#endregion
}
}

运行结果如下:

3.4 对源元素执行操作

输出序列可能不包含源序列的任何元素或元素属性,它可能是通过将源元素用作输入参数计算出的值的序列。

    class Program
{
static void Main(string[] args)
{
#region LINQ 对源元素执行操作
//数据源
double[] radius = { , , };
//创建查询
var query =
from radiu in radius
select $"{3.14 * radiu * radiu}";
//执行查询
foreach (var item in query)
{
Console.WriteLine(item);
}
Console.Read();
#endregion
}
}

运行结果如下:

四、LINQ 查询操作的类型关系

LINQ 查询操作在数据源、查询本身及查询执行中是强类型的。查询中变量的类型必须与数据源中元素的类型和foreach语句中迭代变量的类型兼容。强类型可

以保证在编译时捕获类型错误,以便及时改正。

4.1 不转换源数据的查询

下图演示不对数据执行转换的LINQ to OBJECT查询操作。源包含一个字符串序列,查询输出也是一个字符串序列。

①数据源的类型参数决定范围变量的类型。

select语句返回Name属性,而非完整的Customer对象。因为Name是一个字符串,所以custNameQuery的类型参数是string,而非Customer。

③因为custNameQuery是一个字符串序列,所以foreach循环的迭代变量也必须是string

4.2 转换源数据的查询

下图演示对数据执行简单转换的LINQ to SQL查询操作。查询将一个Customer对象序列用作输入,并只选择结果中的Name属性。因为Name是一个字符串,

所以查询生成一个字符串序列作为输出。

①数据源的类型参数决定范围变量的类型。

select语句返回Name属性,而非完整的Customer对象。因为Name是一个字符串,所以custNameQuery的类型参数是string,而非Customer。

③因为custNameQuery是一个字符串序列,所以foreach循环的迭代变量也必须是string

下图演示另一种转换。select 语句返回只捕获原始Customer对象的两个成员的匿名类型。

①数据源的类型参数始终为查询中的范围变量的类型。

②因为select语句生成匿名类型,所以必须使用var隐式类型化查询变量。

③因为查询变量的类型是隐式的,所以foreach循环中的迭代变量也必须是隐式的。

4.3 让编译器推断类型信息

您也可以使用关键字var,可用于查询操作中的任何局部变量。但是,编译器为查询操作中的各个变量提供强类型。

五、LINQ 中的查询语法和方法语法

我们编写的LINQ查询语法,在编译代码时,CLR会将查询语法转换为方法语法。这些方法调用标准查询运算符的名称类似Where、Select、GroupBy、Join、

Max和Average,我们也是可以直接使用这些方法语法的。

查询语法和方法语法语义相同,但是,许多人员发现查询语法更简单、更易于阅读。某些查询必须表示为方法调用。例如,必须使用方法调用表示检索元素

的数量与指定的条件的查询,还必须使用方法需要检索元素的最大值在源序列的查询。System.Linq命名空间中的标准查询运算符的参考文档通常使用方法语法。

5.1 标准查询运算符扩展方法

    class Program
{
static void Main(string[] args)
{
#region LINQ 标准查询运算符扩展方法
var nums = new int[] { , , , }; //创建查询表达式
var query1 =
from num in nums
where num % ==
orderby num descending
select num; Console.WriteLine("Query1's result:");
foreach (var num in query1)
{
Console.WriteLine(num);
} //使用方法进行查询
var query2 = nums.Where(num => num % == ).OrderByDescending(num => num); Console.WriteLine("Query2's result:");
foreach (var num in query2)
{
Console.WriteLine(num);
} Console.Read();
#endregion
}
}

运行结果如下:

两个示例的输出是相同的。您可以看到两种形式的查询变量的类型是相同的:IEnumerable<T>

若要了解基于方法的查询,让我们进一步地分析它。注意,在表达式的右侧,where子句现在表示为对numbers对象的实例方法,在您重新调用该对象时其类型

为IEnumerable<int>。如果您熟悉泛型 IEnumerable<T> 接口,那么您就会了解,它不具有Where方法。但是,如果您在Visual Studio IDE中调用IntelliSense完成

列表,那么您不仅将看到Where方法,而且还会看到许多其他方法,如SelectSelectManyJoin 和Orderby

下面是所有标准查询运算符:

尽管看起来IEnumerable<T>似乎已被重新定义以包括这些附加方法,但事实上并非如此,这些标准查询运算符都是作为“扩展方法”实现的。

5.2 Lambda 表达式

在前面的示例中,通知该条件表达式 (num % 2 == 0) 是作为内联参数。Where方法:Where (num => num % 2 == 0) 此内联表达式称为lambda表达式。将代码

编写为匿名方法或泛型委托或表达式树是一种便捷的方法,否则编写起来就要麻烦得多。=>是lambda运算符,可读为“goes to”。运算符左侧的num是输入变量,

与查询表达式中的num相对应。编译器可推断num的类型,因为它了解numbers是泛型IEnumerable<T>类型。Lambda表达式与查询语法中的表达式或任何其他C#

表达式或语句中的表达式相同,它可以包括方法调用和其他复杂逻辑,“返回值”就是表达式结果。

5.3 查询的组合性

在上面的代码示例中,请注意OrderBy方法是通过在对Where的调用中使用点运算符来调用的。Where生成筛选序列,然后Orderby通过对该序列排序来对它进行

操作。因为查询会返回IEnumerable,所以您可通过将方法调用链接在一起,在方法语法中将这些查询组合起来。这就是在您通过使用查询语法编写查询时编译器在

后台所执行的操作,并且由于查询变量不存储查询的结果,因此您可以随时修改它或将它用作新查询的基础,即使在执行它后。

C# LINQ学习笔记一:走进LINQ的世界的更多相关文章

  1. C# LINQ学习笔记五:LINQ to XML

    本笔记摘抄自:https://www.cnblogs.com/yaozhenfa/p/CSharp_Linq_For_Xml.html,记录一下学习过程以备后续查用. 一.生成xml 1.1创建简单的 ...

  2. C# LINQ学习笔记四:LINQ to OBJECT之操作文件目录

    本笔记摘抄自:https://www.cnblogs.com/liqingwen/p/5816051.html,记录一下学习过程以备后续查用. 许多文件系统操作实质上是查询,因此非常适合使用LINQ方 ...

  3. C# LINQ学习笔记三:LINQ to OBJECT之操作字符串

    本笔记摘抄自:https://www.cnblogs.com/liqingwen/p/5814204.html,记录一下学习过程以备后续查用. 一.统计单词在字符串中出现的次数 请注意,若要执行计数, ...

  4. C# LINQ学习笔记二:LINQ标准查询操作概述

    本笔记摘抄自:https://www.cnblogs.com/liqingwen/p/5801249.html,记录一下学习过程以备后续查用. “标准查询运算符”是组成语言集成查询 (LINQ) 模式 ...

  5. Linq学习笔记四之linq to sql 的基本操作

    首先需要在项目中新增一个 linq  to sql 的服务 新增项,数据,LINQ TO sql 类的这个方法 第二步需要一个model类,用作映射 [Table] public class S_ZD ...

  6. C#之Linq学习笔记【转】

    写在前面 其实在09年就已经学习过Linq了,并被她那优美的语法所吸引,只是现在所在的公司还在使用VS2005在.Net2.0的框架下面的开发,所以Linq也很久没有用过了,最近看部门的同事对这个有些 ...

  7. linq学习笔记

    最近在学习linq的一些基础知识,看了c#高级编程及阅读了园子内部几篇优秀的博文,有所体会,感觉应该记录下来,作为以后复习使用.都是一些最基础的知识,大致分为三个部分:linq预备知识:linq查询: ...

  8. (转)Linq学习笔记

    写在前面 最近在看Linq,在博客园看到这篇文章,写的通俗易懂,转来和大家一起做个分享.原文地址http://www.cnblogs.com/goscan/archive/2011/05/05/Lin ...

  9. Linq学习笔记(转)

    开始Linq前你要知道的 扩展方法 顾名思义就是对现有类进行扩展的的方法,扩展方法可以在不修改现有类的情况下,为现有类增加公共的接口(不是C#中的interface). 扩展方法本质上是一个静态方法, ...

随机推荐

  1. Cacti 抓取数据方式 安装spine

    安装好cacti后首先要设置获取数据的方式 Cacti 获取数据的方式有两种,1.监控端的脚本(可以是php, shell, perl 或其他脚本)2.或者 snmp 协议获取. Cacti 会在固定 ...

  2. 高级安全Windows防火墙概述以及最佳实践

    本文简单介绍Windows防火墙的概念,给出使用场景并列出了常见的防火墙操作. 简介 在Windows NT6.0之后微软推出了高级安全Windows防火墙(简称WFAS),高级安全Windows防火 ...

  3. 06_TypeScript泛型

    1.泛型的定义 泛型就是解决 类,接口 方法的复用性,以及对不特定数据的支持(类型校验). 2.泛型函数 //T 表示泛型,具体什么类型是调用这个方法的时候决定的, //T可以用其他大写字母表示,传入 ...

  4. Swift 枚举-从汇编角度看枚举内存结构

    一.基本使用 先看枚举的几种使用(暂不要问,看看是否都能看懂,待会会逐一讲解) 1.操作一 简单使用 //第一种方式 enum Direction { case east case west case ...

  5. Linux文件结构-底层文件访问&文件目录和维护

    每个运行中的程序被称为进程(process),它有一些与之关联的文件描述符(一些小值整数).可以通过文件描述符访问打开的文件或设备. 一个程序运行时,一般会有三个文件描述符与之对应 0:标准输入 1: ...

  6. DotNet 源码学习——QUEUE

    1.Queue声明创建对象.(Queue为泛型对象.) public class Queue<T> :IEnumerable<T>,System.Collections.ICo ...

  7. Java基础之六、Java编程思想(8-10)

    八.多态 多态(也称作动态绑定.后期绑定或运行时绑定) 域(成员变量)是不具有多态性的,只有普通的方法调用是多态的,任何域访问操作都将由编译器解析,因此不是多态的 静态方法也是不具有多态性的 publ ...

  8. redis 5.0.7 源码阅读——动态字符串sds

    redis中动态字符串sds相关的文件为:sds.h与sds.c 一.数据结构 redis中定义了自己的数据类型"sds",用于描述 char*,与一些数据结构 typedef c ...

  9. 使用HSSFWorkbook导出、操作excel

    原文地址:https://www.jianshu.com/p/dd1e4f28757b 在实际开发中我们经常需要导入数据,统计数据,并且将统计好的数据导出excel,今天分享一个导出学生信息的方法. ...

  10. #《Essential C++》读书笔记# 第三章 泛型编程风格

    基础知识 array与vector是连续存储空间,可以用指针的算术运算实现对容器的访问.list也是一个容器,不同的是,list的元素以一组指针相互链接(linked):前向(forward)指针指向 ...