LinQ实战学习笔记,种类函数

By admin in 4858.com on 2019年5月5日

 

■ PHP 常用 mysql_ 体系函数:

LinQ实战学习笔记(肆) LINQ to Object, 常用查询操作符,linq学习笔记

 

 这一篇介绍了下边的始末:

  • 查询object数组
  • 询问强类型数组
  • 查询泛型字典
  • 询问字符串
  • SelectMany
  • 索引
  • Distinct操作符
  • 排序
  • 嵌套查询
  • 分组
  • 组连接
  • 内连接
  • 左外连接
  • 6续连接
  • skip,take

 

详细请参考代码.

  1 using System;
  2 using System.Collections.Generic;
  3 using System.ComponentModel;
  4 using System.Data;
  5 using System.Drawing;
  6 using System.Linq;
  7 using System.Text;
  8 using System.Windows.Forms;
  9 
 10 namespace WindowsFormsApplication1
 11 {
 12     public partial class Form1 : Form
 13     {
 14         public Form1()
 15         {
 16             InitializeComponent();
 17         }
 18 
 19         private void Form1_Load(object sender, EventArgs e)
 20         {
 21             
 22         }
 23 
 24         private void button1_Click(object sender, EventArgs e)
 25         {
 26             //查询object数组
 27             Object[] array = { "String", 12, true, 'a' };
 28             var types = array
 29                 .Select(s => s.GetType().Name)
 30                 .OrderBy(s => s);
 31             ObjectDumper.Write(types);
 32         }
 33 
 34         private void button2_Click(object sender, EventArgs e)
 35         {
 36             //查询强类型数组
 37             Book[] books ={
 38                 new Book{Title="Linq in Action"},
 39                 new Book{Title="Linq for Fun"},
 40                 new Book{Title="Extreme LINQ"}
 41             };
 42 
 43             var titles =
 44                 books
 45                 .Where(s => s.Title.Contains("Action"))
 46                 .Select(s => s.Title);
 47 
 48             ObjectDumper.Write(titles);
 49         }
 50 
 51         private void button3_Click(object sender, EventArgs e)
 52         {
 53             //查询泛型字典
 54             var dic = new Dictionary<int, string>();
 55             dic.Add(0, "zero");
 56             dic.Add(1, "un");
 57             dic.Add(2, "deux");
 58             dic.Add(3, "trois");
 59             dic.Add(4, "quatre");
 60             var list =
 61                 dic
 62                 .Where(s => s.Key % 2 == 0)
 63                 .Select(s => s.Value);
 64 
 65             ObjectDumper.Write(list);
 66         }
 67 
 68         private void button4_Click(object sender, EventArgs e)
 69         {
 70             //查询字符串, 字符串实现了IEnumerable<Char>接口
 71             var count = "Non-letter characters in this string: 6"
 72                 .Where(s => !Char.IsLetter(s))
 73                 .Count();
 74 
 75             ObjectDumper.Write(count);
 76         }
 77 
 78         private void button5_Click(object sender, EventArgs e)
 79         {
 80             string[] books ={"Funny Stories","All your base are belong to us",
 81                                "LINQ rules","C# on Rails","Bonjour mon Amour"};
 82             var query =
 83                 books
 84                     .Where(s => s.Length > 10)
 85                     .Select(s => new { Book = s.ToUpper() });
 86 
 87             var query1 =
 88                 from s in books
 89                 where s.Length > 10
 90                 orderby s
 91                 select new { Book = s.ToUpper() };
 92 
 93             dataGridView1.DataSource = query1.ToList();
 94         }
 95 
 96         private void button6_Click(object sender, EventArgs e)
 97         {
 98             var query =
 99                 from s in SampleData.Books
100                 where s.Title.Length > 5
101                 orderby s.Title
102                 select new { Book = s.Title, Price = s.Price };
103 
104             dataGridView2.DataSource = query.ToList();
105         }
106 
107         private void button7_Click(object sender, EventArgs e)
108         {
109             //SelectMany
110 
111             var query1 =
112                 SampleData.Books
113                 .SelectMany(s => s.Authors);
114             ObjectDumper.Write(query1);
115 
116             var query =
117                 from book in SampleData.Books
118                 from author in book.Authors
119                 select author.FirstName + author.LastName;
120 
121             ObjectDumper.Write(query);
122         }
123 
124         private void button8_Click(object sender, EventArgs e)
125         {
126             var book =
127                 SampleData.Books
128                     .Select((s, no) => new { no, s.Title })
129                     .OrderBy(s => s.Title);
130 
131             //无法翻译为等同的查询表达式语法
132 
133             ObjectDumper.Write(book);
134                     
135         }
136 
137         private void button9_Click(object sender, EventArgs e)
138         {
139             //Distinct操作符
140             var query =
141                 SampleData.Books
142                     .SelectMany(s => s.Authors)
143                     .Select(s => s.FirstName + s.LastName);
144             ObjectDumper.Write(query);
145 
146             //去除重复的author,C#没有和distinct等同的查询表达式
147             var query1 =
148                 SampleData.Books
149                     .SelectMany(s => s.Authors)
150                     .Distinct()
151                     .Select(s => s.FirstName + s.LastName);
152             Console.WriteLine();
153             ObjectDumper.Write(query1);
154 
155         }
156 
157         private void button10_Click(object sender, EventArgs e)
158         {
159             //排序
160             var query =
161                 from s in SampleData.Books
162                 orderby s.Publisher.Name, s.Price descending, s.Title
163                 select new
164                 {
165                     Publisher=s.Publisher.Name,
166                     s.Price,
167                     s.Title
168                 };
169             dataGridView1.DataSource = query.ToList();
170             ObjectDumper.Write(query);
171 
172             var query1 =
173                 SampleData.Books
174                 .OrderBy(s => s.Publisher.Name)
175                 .ThenByDescending(s => s.Price)
176                 .ThenBy(s => s.Title)
177                 .Select(s => new
178                     {
179                         publisher = s.Publisher.Name,
180                         s.Price,
181                         s.Title
182                     });
183             Console.WriteLine();
184             ObjectDumper.Write(query1);
185            
186         }
187 
188         private void button11_Click(object sender, EventArgs e)
189         {
190             //嵌套查询
191 
192             var query =
193                 from s in SampleData.Publishers
194                 select new
195                 {
196                     item1 = s.Name,
197                     item2 =
198                         from book in SampleData.Books
199                         where book.Publisher.Name == s.Name
200                         select book
201                 };
202 
203             foreach (var m in query)
204             {
205                 Console.WriteLine(m.item1+":");
206                 foreach (var k in m.item2)
207                 {
208                     Console.WriteLine(k.Title);
209                 }
210                 Console.WriteLine();
211             }
212             
213 
214         }
215 
216         private void button12_Click(object sender, EventArgs e)
217         {
218             //分组
219             //代码让图书按出版社分组.属于同一出版社的图书将被分到相同的组中.
220             //在这个查询中,该分组publisherBooks对象是IGrouping<TKey,T>接口.
221             //其中T为集合IEnumerable<Book>
222 
223             var query =
224                 from s in SampleData.Books
225                 group s by s.Publisher into publisherBooks
226                 select new
227                 {
228                     publisher=publisherBooks.Key.Name,
229                     books=publisherBooks,
230                     booksum=publisherBooks.Count()
231                 };
232             foreach (var m in query)
233             {
234                 Console.WriteLine(m.publisher + ":");
235                 foreach (var k in m.books)
236                 {
237                     Console.WriteLine(k.Title);
238                 }
239                 Console.WriteLine(m.booksum);
240                 Console.WriteLine();
241             }
242              
243         }
244 
245         private void button13_Click(object sender, EventArgs e)
246         {
247             //组连接
248             var query =
249                 from s in SampleData.Publishers
250                 join book in SampleData.Books
251                 on s equals book.Publisher into publisherBooks
252                 select new
253                 {
254                     publisher=s.Name,
255                     books=publisherBooks
256                 };
257 
258             foreach (var m in query)
259             {
260                 Console.WriteLine(m.publisher + ":");
261                 foreach (var k in m.books)
262                 {
263                     Console.WriteLine(k.Title);
264                 }
265                 Console.WriteLine();
266             }
267 
268         }
269 
270         private void button14_Click(object sender, EventArgs e)
271         {
272             //内连接,旨在找到两个序列的交集
273             //和组连接的差别是,没有使用into关键字将元素分组,而是将图书投影在了出版社对象上
274             //注意没有任何书籍的出版社没有显示出来,这是因为在两个待连接序列中均符合条件的组合才会出现在结果序列中.
275             var query =
276                 from s in SampleData.Publishers
277                 join book in SampleData.Books on s equals book.Publisher
278                 select new
279                 {
280                     publisher=s.Name,
281                     books=book.Title
282                 };
283 
284             var query2=
285                 SampleData.Publishers
286                     .Join(SampleData.Books,     //内部序列
287                         s=>s,                   //外部的key选择器
288                         book=>book.Publisher,   //内部的key选择器
289                         (s,book)=>new           //结果选择器
290                         {
291                             publisher=s.Name,
292                             books=book.Title
293                         });
294 
295             ObjectDumper.Write(query2);
296 
297             foreach (var m in query)
298             {
299                 Console.WriteLine(m.publisher + ":");
300                 Console.WriteLine(m.books);
301                 Console.WriteLine();
302             }
303 
304         }
305 
306         private void button15_Click(object sender, EventArgs e)
307         {
308             //左外连接
309             var query =
310                 from s in SampleData.Publishers
311                 join book in SampleData.Books
312                     on s equals book.Publisher into publisherBooks
313                 from book in publisherBooks.DefaultIfEmpty()            //为空序列提供默认元素
314                 select new
315                 {
316                     publisher=s.Name,
317                     books=book==default(Book)?"(no books)":book.Title
318                 };
319 
320             ObjectDumper.Write(query);
321         }
322 
323         private void button16_Click(object sender, EventArgs e)
324         {
325             //交叉连接, 计算出两个序列中所有元素的积
326             //结果序列由一个序列的每个元素和另一个序列中每个元素的完全组合构成
327             var query =
328                 from s in SampleData.Publishers
329                 from book in SampleData.Books
330                 select new
331                 {
332                     correct=(s==book.Publisher),
333                     publisher=s.Name,
334                     books=book.Title
335                 };
336             ObjectDumper.Write(query);   
337         }
338 
339         private void button17_Click(object sender, EventArgs e)
340         {
341             //skip,take
342             var list1 = new List<string>();
343             for (int i = 0; i < 100; i++)
344                 list1.Add(i.ToString());
345 
346             var query =
347                 list1
348                 .Select(s=>s)
349                 .Skip(90).Take(10);
350                 
351 
352             ObjectDumper.Write(query);
353         }
354 
355 
356 
357 
358 
359     }
360 
361   
362 }

 

本节源代码下载

 

原创文章,出自”和讯, 猪悟能’S博客” : 

 

) LINQ to Object,
常用查询操作符,linq学习笔记 那壹篇介绍了上面包车型大巴内容: 查询object数组
查询强类型数组 查询泛型字典 查…

Laravel 能够格外轻易的行使原生的 SQL,流利的询问创设器,和 Eloquent O奥迪Q7M
来张开跨终端的后端数据库连接的营造与互相。最近,Laravel 帮助的 4种数据库系统:

 这1篇介绍了下边包车型大巴剧情:

 

  • MySQL
  • Postgres
  • SQLite
  • SQL Serve
  • 查询object数组
  • 查询强类型数组
  • 询问泛型字典
  • 询问字符串
  • SelectMany
  • 索引
  • Distinct操作符
  • 排序
  • 嵌套查询
  • 分组
  • 组连接
  • 内连接
  • 左外连接
  • 穿插连接
  • skip,take

mysql_connect(服务器,用户名,密码 [,端口])

配置

Laravel
使建立数据库连接与其进行交互变的非凡轻松。而数据库的配备文件就存放在
config/database.php。在这么些文件中您能够定义全数的数据库连接,以及钦赐何种连接作为利用的私下认可数据库连接。对于有着协理的数据库系统,该公文中都提交了相应的布置示范。

暗许的,Laravel 的情况安排示范已经在 Laravel Homestead
中被设置使用,当然,你能够自由的依照须求来修改这几个布局。

SQLite 配置

在成立 SQLite 数据库之后,举例你能够透过
touch database/database.sqlite
命令直接开立2个文书,然后您就可以在境况布置中增多新制造的数据库的绝对路线了:

DB_CONNECTION=sqliteDB_DATABASE=/absolute/path/to/database.sqlite

SQL Server Configuration

Laravel 帮助 SQL Server
的开箱即用。但是,你须求为这几个数据库加多连接配置:

'sqlsrv' => [ 'driver' => 'sqlsrv', 'host' => env('DB_HOST', 'localhost'), 'database' => env('DB_DATABASE', 'forge'), 'username' => env('DB_USERNAME', 'forge'), 'password' => env('DB_PASSWORD', ''), 'charset' => 'utf8', 'prefix' => '', ],

读写分离的连接

偶尔,你或者希望选取2个数据库连接来拍卖 SELECT
证明,而接纳其它多少个接二连3来管理 INSERT,UPDATE,和 DELETE 注明。Laravel
能够轻巧的做到那些,并且不论你是利用的原生查询依然经过查询构造器,又可能是
Eloquent OLANDM,laravel 都会为您提供方便的连日。

LinQ实战学习笔记,种类函数。上边给出的演示来演示怎么样安插读写分离的数据库:

'mysql' => [ 'read' => [ 'host' => '192.168.1.1', ], 'write' => [ 'host' => '192.168.1.2' ], 'driver' => 'mysql', 'database' => 'database', 'username' => 'root', 'password' => '', 'charset' => 'utf8', 'collation' => 'utf8_unicode_ci', 'prefix' => '',],

你应有专注到了数组中被加多了四个键:read
write。它们七个都以2个数组且只包罗了几个键: host。而对 read
write 连接的别的选项都会从 mysql 数组中会集过来。

故而,假如大家想要覆盖主数组中的值,大家只须要在 readwrite
数组中增加相应的项就能够了。在那些现象下,192.168.1.1
会被用来作为读连接,而 192.168.1.2
将会被用来作为写连接。数据库凭证,数据表前缀,字符集,全数主 mysql
数组中的别的选项都会被分享到那多少个接二连三中。

当你布置完你的数据库连接之后,你能够经过行使 DB 假面来推行查询。DB
假面对每序列型的查询都提供了措施:selectupdate4858.com,,insertdelete
statement

执行 select 查询

大家能够运用 DB 假面的 select 方法来进展基础的询问:

<?phpnamespace App\Http\Controllers;use DB;use App\Http\Controllers\Controller;class UserController extends Controller{ /** * Show a list of all of the application's users. * * @return Response */ public function index() { $users = DB::select('select * from users where active = ?', [1]); return view('user.index', ['users' => $users]); }}

传递到 select 方法的率先个参数是一个原生的 SQL
查询,而第二个参数则是传递的具有绑定到查询中的参数值。常常,那么些值都是有关规范约束的。参数绑定提供了针对
SQL 注入的护卫。

select 方法总是回到一个 array 作为结果。而数组中的每一项都应当是二个
StdClass PHP 对象,那允许你从结果中做客它的值:

foreach($users as $user) { echo $user->name;}

应用命名的绑定

你能够选拔命名的绑定来代替使用 ? 参数绑定:

$results = DB::select('select * from users where id = :id', ['id' => 1]);

运营二个 Insert 表明

你能够应用 DB 假面的 insert 方法来举办贰个 insert 声明。就像
select 同样,该办法接收七个原生的 SQL
查询作为第一个参数,1个绑定值作为第三个参数:

DB::insert('insert into users  values ', [1, 'Dayle']);

运作七个 Update 注脚

update 方法会更新数据库中寻找到的记录。那么些方法会再次回到受影响的行数:

$affected = DB::update('update users set votes = 100 where name = ?', ['John']);

运作3个 Delete 申明

delete 方法应该用来从数据库中删除记录。如同 update
同样,它回到删除的行数:

$deleted = DB::delete('delete from users');

运营普通的扬言

一部分数据库申明不该回到放四的值。对于那几个尤其的操作,你能够选择 DB
假面的 statement 方法:

DB::statement('drop table users');

 

————效用:用于展开连接 MySQL 函数,再次回到“连接”。

监听查询事件

倘让你愿目的在于历次应用中举行查询时都受到通报,那么你能够运用 listen
方法,该方法一般用来作为查询日志的调治。你能够在服务提供者中开始展览挂号3个查询监听器:

<?phpnamespace App\Providers;use DB;use Illuminate\Support\ServiceProvider;class AppServiceProvider extends ServiceProvider{ /** * Bootstrap any application services. * * @return void */ public function boot() { DB::listen(function  { // $query->sql // $query->bindings // $query->time }); } /** * Register the service provider. * * @return void */ public function register() { // }}

你能够通过运用 DB 假面的 transaction
方法来在数据库事务中奉行某个操作。假如在事务 Closure
中抛出了尤其,那么事务会自动的施行回滚操作。要是 Closure
成功的奉行,那么事务就能自行的进展提交操作。你并不必要在选取
transaction 方法时担忧怎么样手动的施行回滚大概提交操作:

DB::transaction(function () { DB::table->update(['votes' => 1]); DB::table->delete;

手动的施用专门的学问

比如你想要手动的进行职业,并且想要对回滚和交由具备完整的调节权,那么你能够应用
DB 假面的 beginTransaction 方法:

DB::beginTransaction();

你能够由此 rollBack 方法来进展回滚操作:

DB::rollBack();

末尾,你能够采纳 commit 方法来实行付出操作:

DB::commit();

注意:使用 DB 假面包车型地铁事体方法一致对查询构造器和 Eloquent O奥迪Q7M 有效。

当使用四个数据连接时,你能够由此 DB 假面的 connection
方法来访问那个连接。传递到 connection 方法中的 name 应该与您的
config/database.php 配置文件中的连接相匹配:

$users = DB::connection->select;

您也得以在连接实例上调用 getPdo 方法来得到底层的 PDO 实例。

详细请参见代码.

————注意:端口默以为 330陆 。

  1 using System;
  2 using System.Collections.Generic;
  3 using System.ComponentModel;
  4 using System.Data;
  5 using System.Drawing;
  6 using System.Linq;
  7 using System.Text;
  8 using System.Windows.Forms;
  9 
 10 namespace WindowsFormsApplication1
 11 {
 12     public partial class Form1 : Form
 13     {
 14         public Form1()
 15         {
 16             InitializeComponent();
 17         }
 18 
 19         private void Form1_Load(object sender, EventArgs e)
 20         {
 21             
 22         }
 23 
 24         private void button1_Click(object sender, EventArgs e)
 25         {
 26             //查询object数组
 27             Object[] array = { "String", 12, true, 'a' };
 28             var types = array
 29                 .Select(s => s.GetType().Name)
 30                 .OrderBy(s => s);
 31             ObjectDumper.Write(types);
 32         }
 33 
 34         private void button2_Click(object sender, EventArgs e)
 35         {
 36             //查询强类型数组
 37             Book[] books ={
 38                 new Book{Title="Linq in Action"},
 39                 new Book{Title="Linq for Fun"},
 40                 new Book{Title="Extreme LINQ"}
 41             };
 42 
 43             var titles =
 44                 books
 45                 .Where(s => s.Title.Contains("Action"))
 46                 .Select(s => s.Title);
 47 
 48             ObjectDumper.Write(titles);
 49         }
 50 
 51         private void button3_Click(object sender, EventArgs e)
 52         {
 53             //查询泛型字典
 54             var dic = new Dictionary<int, string>();
 55             dic.Add(0, "zero");
 56             dic.Add(1, "un");
 57             dic.Add(2, "deux");
 58             dic.Add(3, "trois");
 59             dic.Add(4, "quatre");
 60             var list =
 61                 dic
 62                 .Where(s => s.Key % 2 == 0)
 63                 .Select(s => s.Value);
 64 
 65             ObjectDumper.Write(list);
 66         }
 67 
 68         private void button4_Click(object sender, EventArgs e)
 69         {
 70             //查询字符串, 字符串实现了IEnumerable<Char>接口
 71             var count = "Non-letter characters in this string: 6"
 72                 .Where(s => !Char.IsLetter(s))
 73                 .Count();
 74 
 75             ObjectDumper.Write(count);
 76         }
 77 
 78         private void button5_Click(object sender, EventArgs e)
 79         {
 80             string[] books ={"Funny Stories","All your base are belong to us",
 81                                "LINQ rules","C# on Rails","Bonjour mon Amour"};
 82             var query =
 83                 books
 84                     .Where(s => s.Length > 10)
 85                     .Select(s => new { Book = s.ToUpper() });
 86 
 87             var query1 =
 88                 from s in books
 89                 where s.Length > 10
 90                 orderby s
 91                 select new { Book = s.ToUpper() };
 92 
 93             dataGridView1.DataSource = query1.ToList();
 94         }
 95 
 96         private void button6_Click(object sender, EventArgs e)
 97         {
 98             var query =
 99                 from s in SampleData.Books
100                 where s.Title.Length > 5
101                 orderby s.Title
102                 select new { Book = s.Title, Price = s.Price };
103 
104             dataGridView2.DataSource = query.ToList();
105         }
106 
107         private void button7_Click(object sender, EventArgs e)
108         {
109             //SelectMany
110 
111             var query1 =
112                 SampleData.Books
113                 .SelectMany(s => s.Authors);
114             ObjectDumper.Write(query1);
115 
116             var query =
117                 from book in SampleData.Books
118                 from author in book.Authors
119                 select author.FirstName + author.LastName;
120 
121             ObjectDumper.Write(query);
122         }
123 
124         private void button8_Click(object sender, EventArgs e)
125         {
126             var book =
127                 SampleData.Books
128                     .Select((s, no) => new { no, s.Title })
129                     .OrderBy(s => s.Title);
130 
131             //无法翻译为等同的查询表达式语法
132 
133             ObjectDumper.Write(book);
134                     
135         }
136 
137         private void button9_Click(object sender, EventArgs e)
138         {
139             //Distinct操作符
140             var query =
141                 SampleData.Books
142                     .SelectMany(s => s.Authors)
143                     .Select(s => s.FirstName + s.LastName);
144             ObjectDumper.Write(query);
145 
146             //去除重复的author,C#没有和distinct等同的查询表达式
147             var query1 =
148                 SampleData.Books
149                     .SelectMany(s => s.Authors)
150                     .Distinct()
151                     .Select(s => s.FirstName + s.LastName);
152             Console.WriteLine();
153             ObjectDumper.Write(query1);
154 
155         }
156 
157         private void button10_Click(object sender, EventArgs e)
158         {
159             //排序
160             var query =
161                 from s in SampleData.Books
162                 orderby s.Publisher.Name, s.Price descending, s.Title
163                 select new
164                 {
165                     Publisher=s.Publisher.Name,
166                     s.Price,
167                     s.Title
168                 };
169             dataGridView1.DataSource = query.ToList();
170             ObjectDumper.Write(query);
171 
172             var query1 =
173                 SampleData.Books
174                 .OrderBy(s => s.Publisher.Name)
175                 .ThenByDescending(s => s.Price)
176                 .ThenBy(s => s.Title)
177                 .Select(s => new
178                     {
179                         publisher = s.Publisher.Name,
180                         s.Price,
181                         s.Title
182                     });
183             Console.WriteLine();
184             ObjectDumper.Write(query1);
185            
186         }
187 
188         private void button11_Click(object sender, EventArgs e)
189         {
190             //嵌套查询
191 
192             var query =
193                 from s in SampleData.Publishers
194                 select new
195                 {
196                     item1 = s.Name,
197                     item2 =
198                         from book in SampleData.Books
199                         where book.Publisher.Name == s.Name
200                         select book
201                 };
202 
203             foreach (var m in query)
204             {
205                 Console.WriteLine(m.item1+":");
206                 foreach (var k in m.item2)
207                 {
208                     Console.WriteLine(k.Title);
209                 }
210                 Console.WriteLine();
211             }
212             
213 
214         }
215 
216         private void button12_Click(object sender, EventArgs e)
217         {
218             //分组
219             //代码让图书按出版社分组.属于同一出版社的图书将被分到相同的组中.
220             //在这个查询中,该分组publisherBooks对象是IGrouping<TKey,T>接口.
221             //其中T为集合IEnumerable<Book>
222 
223             var query =
224                 from s in SampleData.Books
225                 group s by s.Publisher into publisherBooks
226                 select new
227                 {
228                     publisher=publisherBooks.Key.Name,
229                     books=publisherBooks,
230                     booksum=publisherBooks.Count()
231                 };
232             foreach (var m in query)
233             {
234                 Console.WriteLine(m.publisher + ":");
235                 foreach (var k in m.books)
236                 {
237                     Console.WriteLine(k.Title);
238                 }
239                 Console.WriteLine(m.booksum);
240                 Console.WriteLine();
241             }
242              
243         }
244 
245         private void button13_Click(object sender, EventArgs e)
246         {
247             //组连接
248             var query =
249                 from s in SampleData.Publishers
250                 join book in SampleData.Books
251                 on s equals book.Publisher into publisherBooks
252                 select new
253                 {
254                     publisher=s.Name,
255                     books=publisherBooks
256                 };
257 
258             foreach (var m in query)
259             {
260                 Console.WriteLine(m.publisher + ":");
261                 foreach (var k in m.books)
262                 {
263                     Console.WriteLine(k.Title);
264                 }
265                 Console.WriteLine();
266             }
267 
268         }
269 
270         private void button14_Click(object sender, EventArgs e)
271         {
272             //内连接,旨在找到两个序列的交集
273             //和组连接的差别是,没有使用into关键字将元素分组,而是将图书投影在了出版社对象上
274             //注意没有任何书籍的出版社没有显示出来,这是因为在两个待连接序列中均符合条件的组合才会出现在结果序列中.
275             var query =
276                 from s in SampleData.Publishers
277                 join book in SampleData.Books on s equals book.Publisher
278                 select new
279                 {
280                     publisher=s.Name,
281                     books=book.Title
282                 };
283 
284             var query2=
285                 SampleData.Publishers
286                     .Join(SampleData.Books,     //内部序列
287                         s=>s,                   //外部的key选择器
288                         book=>book.Publisher,   //内部的key选择器
289                         (s,book)=>new           //结果选择器
290                         {
291                             publisher=s.Name,
292                             books=book.Title
293                         });
294 
295             ObjectDumper.Write(query2);
296 
297             foreach (var m in query)
298             {
299                 Console.WriteLine(m.publisher + ":");
300                 Console.WriteLine(m.books);
301                 Console.WriteLine();
302             }
303 
304         }
305 
306         private void button15_Click(object sender, EventArgs e)
307         {
308             //左外连接
309             var query =
310                 from s in SampleData.Publishers
311                 join book in SampleData.Books
312                     on s equals book.Publisher into publisherBooks
313                 from book in publisherBooks.DefaultIfEmpty()            //为空序列提供默认元素
314                 select new
315                 {
316                     publisher=s.Name,
317                     books=book==default(Book)?"(no books)":book.Title
318                 };
319 
320             ObjectDumper.Write(query);
321         }
322 
323         private void button16_Click(object sender, EventArgs e)
324         {
325             //交叉连接, 计算出两个序列中所有元素的积
326             //结果序列由一个序列的每个元素和另一个序列中每个元素的完全组合构成
327             var query =
328                 from s in SampleData.Publishers
329                 from book in SampleData.Books
330                 select new
331                 {
332                     correct=(s==book.Publisher),
333                     publisher=s.Name,
334                     books=book.Title
335                 };
336             ObjectDumper.Write(query);   
337         }
338 
339         private void button17_Click(object sender, EventArgs e)
340         {
341             //skip,take
342             var list1 = new List<string>();
343             for (int i = 0; i < 100; i++)
344                 list1.Add(i.ToString());
345 
346             var query =
347                 list1
348                 .Select(s=>s)
349                 .Skip(90).Take(10);
350                 
351 
352             ObjectDumper.Write(query);
353         }
354 
355 
356 
357 
358 
359     }
360 
361   
362 }

 

 

mysql_query(查询 [,连接])

本节源代码下载

————功能:用于发送 MySQL 查询(操作)。

 

————注意:重临 bool值 或 能源类型。

原创小说,出自”博客园, 猪八戒’S博客” : 

 

 

mysql_db_query(库名,查询,连接)

————功能:用于发送 MySQL 查询(操作)。

 

mysql_select_db(库名,连接)

————成效:用于选拔数据库。(不引进应用)

 

mysql_fetch_object()

————作用:从结果聚焦取得壹行(即 数据表中的一行、二个记录)作为对象。

 

mysql_fetch_array(查询结果)

————作用:从结果聚集获得壹行作为数组。

————注意:重返 关联数组 及 索引数组。

 

mysql_fetch_assoc(查询结果)

————功用:从结果集中获得一行作为数组。

————注意:再次来到 关联数组
,以表中的列名作为数组成分的键。比方下标为:[“id”]、[“name”]。

 

mysql_fetch_row(查询结果)

————成效:从结果集中获得一行作为数组。

————注意:重回 索引数组 。举例下标为:[0]、[1]、[2]。

 

mysql_num_fields(结果集)

————成效:获得结果聚焦列的多少。

 

mysql_num_rows(结果集)

————成效:取得结果集中央银行的数据。

 

mysql_field_name(结果集,数字偏移量)

————效能:取得结果集中钦赐列的列名。

 

mysql_error(连接)

————功能:重返上3个 MySQL 操作的语法错误音信(用于查错)。

 

mysql_close(连接)

————成效:关闭钦赐的 MySQL 连接。(没必要的!除非在cgi方式下)

 

mysql_free_result(查询结果)

————效用:释放查询结果的内部存款和储蓄器。(须求!)

 

mysql_affected_rows(连接)

————成效:取得前一回 MySQL 操作所影响的笔录行数,再次来到整型数值。

留意:假若前3遍查询退步以来,函数会回到 -一 。

 

mysql_insert_id(连接)

————功能:重回刚插入的信息中 increment 列的值。(常用来重临 id )

 

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图
Copyright @ 2010-2019 美高梅手机版4858 版权所有