Admin: 1 версия

2010-05-26T12:18:26Z

1 версия

Новая страница

==All employees in a tree are grouped by department==

<source lang="csharp">using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
public class Tree<TreeNode> : IEnumerable<TreeNode> where TreeNode : IComparable<TreeNode> {
public Tree(TreeNode nodeValue) {
this.NodeData = nodeValue;
this.LeftTree = null;
this.RightTree = null;
}
public void Insert(TreeNode newItem) {
TreeNode currentNodeValue = this.NodeData;
if (currentNodeValue.rupareTo(newItem) > 0) {
if (this.LeftTree == null) {
this.LeftTree = new Tree<TreeNode>(newItem);
} else {
this.LeftTree.Insert(newItem);
}
} else {
if (this.RightTree == null) {
this.RightTree = new Tree<TreeNode>(newItem);
} else {
this.RightTree.Insert(newItem);
}
}
}
public void WalkTree() {
if (this.LeftTree != null) {
this.LeftTree.WalkTree();
}
Console.WriteLine(this.NodeData.ToString());
if (this.RightTree != null) {
this.RightTree.WalkTree();
}
}
public TreeNode NodeData { get; set; }
public Tree<TreeNode> LeftTree { get; set; }
public Tree<TreeNode> RightTree { get; set; }

IEnumerator<TreeNode> IEnumerable<TreeNode>.GetEnumerator() {
if (this.LeftTree != null) {
foreach (TreeNode item in this.LeftTree) {
yield return item;
}
}
yield return this.NodeData;
if (this.RightTree != null) {
foreach (TreeNode item in this.RightTree) {
yield return item;
}
}
}
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() {
throw new NotImplementedException();
}
}
class Employee : IComparable<Employee> {
public string FirstName { get; set; }
public string LastName { get; set; }
public string Department { get; set; }
public int Id { get; set; }
public override string ToString() {
return String.Format("Id: {0}, Name: {1} {2}, Dept: {3}", this.Id, this.FirstName, this.LastName, this.Department);
}
int IComparable<Employee>.rupareTo(Employee other) {
if (other == null)
return 1;
if (this.Id > other.Id)
return 1;
if (this.Id < other.Id)
return -1;
return 0;
}
}
class Program {
static void Main() {
Tree<Employee> empTree = new Tree<Employee>(new Employee { Id = 1, FirstName = "Janet", LastName = "Gates", Department = "IT" });
empTree.Insert(new Employee { Id = 2, FirstName = "O", LastName = "G", Department = "Marketing" });
empTree.Insert(new Employee { Id = 4, FirstName = "K", LastName = "H", Department = "IT" });
empTree.Insert(new Employee { Id = 6, FirstName = "L", LastName = "H", Department = "Sales" });
empTree.Insert(new Employee { Id = 3, FirstName = "E", LastName = "L", Department = "Sales" });
empTree.Insert(new Employee { Id = 5, FirstName = "D", LastName = "L", Department = "Marketing" });
var employeesByDept = empTree.GroupBy(e => e.Department);
foreach (var dept in employeesByDept)
{
Console.WriteLine("Department: {0}", dept.Key);
foreach (var emp in dept)
{
Console.WriteLine("\t{0} {1}", emp.FirstName, emp.LastName);
}
}
}
}</source>

==ArrayList Query==

<source lang="csharp">using System;
using System.Collections;
using System.ruponentModel;
public class Product
{
string name;
public string Name
{
get { return name; }
}
decimal price;
public decimal Price
{
get { return price; }
}
public Product(string name, decimal price)
{
this.name = name;
this.price = price;
}
public static ArrayList GetSampleProducts()
{
ArrayList list = new ArrayList();
list.Add(new Product("C", 9.99m));
list.Add(new Product("A", 1.99m));
list.Add(new Product("F", 2.99m));
list.Add(new Product("S", 3.99m));
return list;
}
public override string ToString()
{
return string.Format("{0}: {1}", name, price);
}
}
class ArrayListQuery
{
static void Main()
{
ArrayList products = Product.GetSampleProducts();
foreach (Product product in products)
{
if (product.Price > 10m)
{
Console.WriteLine(product);
}
}
}
}</source>

==Chaining Query Operators/extracts all strings containing the letter "a", sorts them by length, and then converts the results to uppercase==

<source lang="csharp">using System;
using System.Collections.Generic;
using System.Linq;
class LinqDemo {
static void Main() {
string[] names = { "J", "P", "G", "P" };
IEnumerable<string> query = names
.Where(n => n.Contains("a"))
.OrderBy(n => n.Length)
.Select(n => n.ToUpper());
foreach (string name in query) Console.Write(name + "|");
}
}</source>

==Complex Query Using Method Syntax==

<source lang="csharp">using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
public class Customer
{
public string FirstName { get; set; }
public string LastName { get; set; }
public string EmailAddress { get; set; }
public override string ToString(){
return string.Format("{0} {1}\nEmail: {2}",FirstName, LastName, EmailAddress);
}
}
public class Address
{
public string Name { get; set; }
public string Street { get; set; }
public string City { get; set; }
public override string ToString()
{
return string.Format("{0}, {1}", Street, City);
}
}
public class Tester
{
static void Main()
{
List<Customer> customers = new List<Customer>
{
new Customer { FirstName = "A",
LastName = "B",
EmailAddress = "o@a.ru"},
new Customer { FirstName = "B",
LastName = "C",
EmailAddress = "k@a.ru" },
new Customer { FirstName = "D",
LastName = "C",
EmailAddress = "d@a.ru" },
new Customer { FirstName = "F",
LastName = "G",
EmailAddress = "j@a.ru" },
new Customer { FirstName = "L",
LastName = "H",
EmailAddress = "l@a.ru" }
};
List<Address> addresses = new List<Address>
{
new Address { Name = "J",
Street = "165 Main",
City = "City 1" },
new Address { Name = "K H",
Street = "3207 Way",
City = "Cith 2" },
new Address { Name = "J G",
Street = "800 Blvd.",
City = "City 3" },
new Address { Name = "Mary",
Street = "7 Ave",
City = "City 4" },
new Address { Name = "Kate",
Street = "2251 Avenue",
City = "City 5" }
};
var result = customers.Join(addresses,
customer => string.Format("{0} {1}", customer.FirstName, customer.LastName),
address => address.Name,
(customer, address) => new { Customer = customer, Address = address })
.OrderBy(ca => ca.Customer.LastName)
.ThenByDescending(ca => ca.Address.Street);
foreach (var ca in result)
{
Console.WriteLine(string.Format("{0}\nAddress: {1}",ca.Customer, ca.Address));
}
}
}</source>

==Conduct query on the result again==

<source lang="csharp">using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

class Customer
{
public string ID { get; set; }
public string City { get; set; }
public string Country { get; set; }
public string Region { get; set; }
public decimal Sales { get; set; }
}
class Program
{
static void Main(string[] args)
{
List<Customer> customers = new List<Customer> {
new Customer { ID="Q", City="London", Country="UK", Region="Europe", Sales=8000 },
new Customer { ID="R", City="Beijing", Country="China", Region="Asia", Sales=9000 },
new Customer { ID="T", City="Lima", Country="Peru", Region="South America", Sales=2002 }
};
var queryResults =
from c in customers
group c by c.Region into cg
select new { TotalSales = cg.Sum(c => c.Sales), Region = cg.Key }
;
var orderedResults =
from cg in queryResults
orderby cg.TotalSales descending
select cg
;
foreach (var item in orderedResults)
{
Console.WriteLine(item.TotalSales + "\t: " + item.Region);
}
}
}</source>

==Get Distinct departments with condition==

<source lang="csharp">using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
public class Tree<TreeNode> : IEnumerable<TreeNode> where TreeNode : IComparable<TreeNode> {
public Tree(TreeNode nodeValue) {
this.NodeData = nodeValue;
this.LeftTree = null;
this.RightTree = null;
}
public void Insert(TreeNode newItem) {
TreeNode currentNodeValue = this.NodeData;
if (currentNodeValue.rupareTo(newItem) > 0) {
if (this.LeftTree == null) {
this.LeftTree = new Tree<TreeNode>(newItem);
} else {
this.LeftTree.Insert(newItem);
}
} else {
if (this.RightTree == null) {
this.RightTree = new Tree<TreeNode>(newItem);
} else {
this.RightTree.Insert(newItem);
}
}
}
public void WalkTree() {
if (this.LeftTree != null) {
this.LeftTree.WalkTree();
}
Console.WriteLine(this.NodeData.ToString());
if (this.RightTree != null) {
this.RightTree.WalkTree();
}
}
public TreeNode NodeData { get; set; }
public Tree<TreeNode> LeftTree { get; set; }
public Tree<TreeNode> RightTree { get; set; }

IEnumerator<TreeNode> IEnumerable<TreeNode>.GetEnumerator() {
if (this.LeftTree != null) {
foreach (TreeNode item in this.LeftTree) {
yield return item;
}
}
yield return this.NodeData;
if (this.RightTree != null) {
foreach (TreeNode item in this.RightTree) {
yield return item;
}
}
}
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() {
throw new NotImplementedException();
}
}
class Employee : IComparable<Employee> {
public string FirstName { get; set; }
public string LastName { get; set; }
public string Department { get; set; }
public int Id { get; set; }
public override string ToString() {
return String.Format("Id: {0}, Name: {1} {2}, Dept: {3}", this.Id, this.FirstName, this.LastName, this.Department);
}
int IComparable<Employee>.rupareTo(Employee other) {
if (other == null)
return 1;
if (this.Id > other.Id)
return 1;
if (this.Id < other.Id)
return -1;
return 0;
}
}
class Program {
static void Main() {
Tree<Employee> empTree = new Tree<Employee>(new Employee { Id = 1, FirstName = "Janet", LastName = "Gates", Department = "IT" });
empTree.Insert(new Employee { Id = 2, FirstName = "O", LastName = "G", Department = "Marketing" });
empTree.Insert(new Employee { Id = 4, FirstName = "K", LastName = "H", Department = "IT" });
empTree.Insert(new Employee { Id = 6, FirstName = "L", LastName = "H", Department = "Sales" });
empTree.Insert(new Employee { Id = 3, FirstName = "E", LastName = "L", Department = "Sales" });
empTree.Insert(new Employee { Id = 5, FirstName = "D", LastName = "L", Department = "Marketing" });
var depts = empTree.Select(d => d.Department).Distinct();
foreach (var dept in depts)
Console.WriteLine("Department: {0}", dept);
}
}</source>

==Join Query==

<source lang="csharp">using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
class Customer
{
public string ID { get; set; }
public string City { get; set; }
public string Country { get; set; }
public string Region { get; set; }
public decimal Sales { get; set; }
}
class Order
{
public string ID { get; set; }
public decimal Amount { get; set; }
}
class Program
{
static void Main(string[] args)
{
List<Order> orders = new List<Order> {
new Order { ID="X", Amount=900 },
new Order { ID="Y", Amount=1000 },
new Order { ID="Z", Amount=1100 }
};
List<Customer> customers = new List<Customer> {
new Customer { ID="X", City="Beijing", Country="China", Region="Asia", Sales=9000 },
new Customer { ID="Y", City="Bogotá", Country="Colombia", Region="South America", Sales=1001 },
new Customer { ID="Z", City="Lima", Country="Peru", Region="South America", Sales=2002 }
};
var queryResults =
from c in customers
join o in orders on c.ID equals o.ID
select new { c.ID, c.City, SalesBefore = c.Sales, NewOrder = o.Amount, SalesAfter = c.Sales+o.Amount };
foreach (var item in queryResults)
{
Console.WriteLine(item);
}
}
}</source>

==query with extension methods==

<source lang="csharp">using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
public class Customer
{
public string FirstName { get; set; }
public string LastName { get; set; }
public string EmailAddress { get; set; }
public override string ToString()
{
return string.Format("{0} {1}\nEmail: {2}",FirstName, LastName, EmailAddress);
}
}
public class Tester
{
static void Main()
{
List<Customer> customers = new List<Customer>{
new Customer { FirstName = "A",
LastName = "B",
EmailAddress = "o@a.ru"},
new Customer { FirstName = "B",
LastName = "C",
EmailAddress = "k@a.ru" },
new Customer { FirstName = "D",
LastName = "C",
EmailAddress = "d@a.ru" },
new Customer { FirstName = "F",
LastName = "G",
EmailAddress = "j@a.ru" },
new Customer { FirstName = "L",
LastName = "H",
EmailAddress = "l@a.ru" }
};
IEnumerable<Customer> result = customers.Where(customer => customer.FirstName == "Donna");
foreach (Customer customer in result)
Console.WriteLine(customer.ToString());
}
}</source>

==Use a LINQ query to find the public enums==

<source lang="csharp">using System;
using System.Reflection;
using System.IO;
using System.Linq;
public class MainClass
{
static void Main(string[] args)
{
string displayName = null;
displayName = "System.Windows.Forms,Version=2.0.0.0,PublicKeyToken=b77a5c561934e089,Culture=\"\"";
Assembly a = Assembly.Load(displayName);
Type[] types = a.GetTypes();
var publicEnums = from pe in types where pe.IsEnum && pe.IsPublic select pe;
foreach (var pe in publicEnums)
{
Console.WriteLine(pe);
}
}
}</source>

==Use Contains, Length and ToUpper from Linq==

<source lang="csharp">using System;
using System.Collections.Generic;
using System.Linq;
public class MainClass {
public static void Main() {
string[] names = { "Tom", "Dick", "Harry", "Mary", "Jay" };
IEnumerable<string> filtered = names.Where(n => n.Contains("a"));
IEnumerable<string> sorted = filtered.OrderBy(n => n.Length);
IEnumerable<string> finalQuery = sorted.Select(n => n.ToUpper());
foreach (string name in filtered)
Console.Write(name + "|");
Console.WriteLine();
foreach (string name in sorted)
Console.Write(name + "|");
Console.WriteLine();
foreach (string name in finalQuery)
Console.Write(name + "|");
}
}</source>

==Use from where select to choose the Employees in the IT department from a tree==

<source lang="csharp">using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
public class Tree<TreeNode> : IEnumerable<TreeNode> where TreeNode : IComparable<TreeNode> {
public Tree(TreeNode nodeValue) {
this.NodeData = nodeValue;
this.LeftTree = null;
this.RightTree = null;
}
public void Insert(TreeNode newItem) {
TreeNode currentNodeValue = this.NodeData;
if (currentNodeValue.rupareTo(newItem) > 0) {
if (this.LeftTree == null) {
this.LeftTree = new Tree<TreeNode>(newItem);
} else {
this.LeftTree.Insert(newItem);
}
} else {
if (this.RightTree == null) {
this.RightTree = new Tree<TreeNode>(newItem);
} else {
this.RightTree.Insert(newItem);
}
}
}
public void WalkTree() {
if (this.LeftTree != null) {
this.LeftTree.WalkTree();
}
Console.WriteLine(this.NodeData.ToString());
if (this.RightTree != null) {
this.RightTree.WalkTree();
}
}
public TreeNode NodeData { get; set; }
public Tree<TreeNode> LeftTree { get; set; }
public Tree<TreeNode> RightTree { get; set; }

IEnumerator<TreeNode> IEnumerable<TreeNode>.GetEnumerator() {
if (this.LeftTree != null) {
foreach (TreeNode item in this.LeftTree) {
yield return item;
}
}
yield return this.NodeData;
if (this.RightTree != null) {
foreach (TreeNode item in this.RightTree) {
yield return item;
}
}
}
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() {
throw new NotImplementedException();
}
}
class Employee : IComparable<Employee> {
public string FirstName { get; set; }
public string LastName { get; set; }
public string Department { get; set; }
public int Id { get; set; }
public override string ToString() {
return String.Format("Id: {0}, Name: {1} {2}, Dept: {3}", this.Id, this.FirstName, this.LastName, this.Department);
}
int IComparable<Employee>.rupareTo(Employee other) {
if (other == null)
return 1;
if (this.Id > other.Id)
return 1;
if (this.Id < other.Id)
return -1;
return 0;
}
}
class Program {
static void Main() {
Tree<Employee> empTree = new Tree<Employee>(new Employee { Id = 1, FirstName = "Janet", LastName = "Gates", Department = "IT" });
empTree.Insert(new Employee { Id = 2, FirstName = "O", LastName = "G", Department = "Marketing" });
empTree.Insert(new Employee { Id = 4, FirstName = "K", LastName = "H", Department = "IT" });
empTree.Insert(new Employee { Id = 6, FirstName = "L", LastName = "H", Department = "Sales" });
empTree.Insert(new Employee { Id = 3, FirstName = "E", LastName = "L", Department = "Sales" });
empTree.Insert(new Employee { Id = 5, FirstName = "D", LastName = "L", Department = "Marketing" });
var ITEmployees = from e in empTree
where String.Equals(e.Department, "IT")
select e;
foreach (var emp in ITEmployees)
Console.WriteLine(emp);
}
}</source>

==Use LINQ to get Employees in the IT department from a tree==

<source lang="csharp">using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
public class Tree<TreeNode> : IEnumerable<TreeNode> where TreeNode : IComparable<TreeNode> {
public Tree(TreeNode nodeValue) {
this.NodeData = nodeValue;
this.LeftTree = null;
this.RightTree = null;
}
public void Insert(TreeNode newItem) {
TreeNode currentNodeValue = this.NodeData;
if (currentNodeValue.rupareTo(newItem) > 0) {
if (this.LeftTree == null) {
this.LeftTree = new Tree<TreeNode>(newItem);
} else {
this.LeftTree.Insert(newItem);
}
} else {
if (this.RightTree == null) {
this.RightTree = new Tree<TreeNode>(newItem);
} else {
this.RightTree.Insert(newItem);
}
}
}
public void WalkTree() {
if (this.LeftTree != null) {
this.LeftTree.WalkTree();
}
Console.WriteLine(this.NodeData.ToString());
if (this.RightTree != null) {
this.RightTree.WalkTree();
}
}
public TreeNode NodeData { get; set; }
public Tree<TreeNode> LeftTree { get; set; }
public Tree<TreeNode> RightTree { get; set; }

IEnumerator<TreeNode> IEnumerable<TreeNode>.GetEnumerator() {
if (this.LeftTree != null) {
foreach (TreeNode item in this.LeftTree) {
yield return item;
}
}
yield return this.NodeData;
if (this.RightTree != null) {
foreach (TreeNode item in this.RightTree) {
yield return item;
}
}
}
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() {
throw new NotImplementedException();
}
}
class Employee : IComparable<Employee> {
public string FirstName { get; set; }
public string LastName { get; set; }
public string Department { get; set; }
public int Id { get; set; }
public override string ToString() {
return String.Format("Id: {0}, Name: {1} {2}, Dept: {3}", this.Id, this.FirstName, this.LastName, this.Department);
}
int IComparable<Employee>.rupareTo(Employee other) {
if (other == null)
return 1;
if (this.Id > other.Id)
return 1;
if (this.Id < other.Id)
return -1;
return 0;
}
}
class Program {
static void Main() {
Tree<Employee> empTree = new Tree<Employee>(new Employee { Id = 1, FirstName = "Janet", LastName = "Gates", Department = "IT" });
empTree.Insert(new Employee { Id = 2, FirstName = "O", LastName = "G", Department = "Marketing" });
empTree.Insert(new Employee { Id = 4, FirstName = "K", LastName = "H", Department = "IT" });
empTree.Insert(new Employee { Id = 6, FirstName = "L", LastName = "H", Department = "Sales" });
empTree.Insert(new Employee { Id = 3, FirstName = "E", LastName = "L", Department = "Sales" });
empTree.Insert(new Employee { Id = 5, FirstName = "D", LastName = "L", Department = "Marketing" });
var ITEmployees = empTree.Where(e => String.Equals(e.Department, "IT")).Select(emp => emp);
foreach (var emp in ITEmployees)
Console.WriteLine(emp);
}
}</source>

==Use select to retrieve all nodes in a Binary tree==

<source lang="csharp">using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
public class Tree<TreeNode> : IEnumerable<TreeNode> where TreeNode : IComparable<TreeNode> {
public Tree(TreeNode nodeValue) {
this.NodeData = nodeValue;
this.LeftTree = null;
this.RightTree = null;
}
public void Insert(TreeNode newItem) {
TreeNode currentNodeValue = this.NodeData;
if (currentNodeValue.rupareTo(newItem) > 0) {
if (this.LeftTree == null) {
this.LeftTree = new Tree<TreeNode>(newItem);
} else {
this.LeftTree.Insert(newItem);
}
} else {
if (this.RightTree == null) {
this.RightTree = new Tree<TreeNode>(newItem);
} else {
this.RightTree.Insert(newItem);
}
}
}
public void WalkTree() {
if (this.LeftTree != null) {
this.LeftTree.WalkTree();
}
Console.WriteLine(this.NodeData.ToString());
if (this.RightTree != null) {
this.RightTree.WalkTree();
}
}
public TreeNode NodeData { get; set; }
public Tree<TreeNode> LeftTree { get; set; }
public Tree<TreeNode> RightTree { get; set; }

IEnumerator<TreeNode> IEnumerable<TreeNode>.GetEnumerator() {
if (this.LeftTree != null) {
foreach (TreeNode item in this.LeftTree) {
yield return item;
}
}
yield return this.NodeData;
if (this.RightTree != null) {
foreach (TreeNode item in this.RightTree) {
yield return item;
}
}
}
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() {
throw new NotImplementedException();
}
}
class Employee : IComparable<Employee> {
public string FirstName { get; set; }
public string LastName { get; set; }
public string Department { get; set; }
public int Id { get; set; }
public override string ToString() {
return String.Format("Id: {0}, Name: {1} {2}, Dept: {3}", this.Id, this.FirstName, this.LastName, this.Department);
}
int IComparable<Employee>.rupareTo(Employee other) {
if (other == null)
return 1;
if (this.Id > other.Id)
return 1;
if (this.Id < other.Id)
return -1;
return 0;
}
}
class Program {
static void Main() {
Tree<Employee> empTree = new Tree<Employee>(new Employee { Id = 1, FirstName = "Janet", LastName = "Gates", Department = "IT" });
empTree.Insert(new Employee { Id = 2, FirstName = "O", LastName = "G", Department = "Marketing" });
empTree.Insert(new Employee { Id = 4, FirstName = "K", LastName = "H", Department = "IT" });
empTree.Insert(new Employee { Id = 6, FirstName = "L", LastName = "H", Department = "Sales" });
empTree.Insert(new Employee { Id = 3, FirstName = "E", LastName = "L", Department = "Sales" });
empTree.Insert(new Employee { Id = 5, FirstName = "D", LastName = "L", Department = "Marketing" });
var allEmployees = from e in empTree.ToList<Employee>()
select e;
foreach (var emp in allEmployees)
Console.WriteLine(emp);
}
}</source>

Csharp/CSharp Tutorial/LINQ/Query - История изменений

в 15:31, 26 мая 2010

Admin: 1 версия

← Предыдущая	Версия 15:31, 26 мая 2010
(нет различий)