в 15:31, 26 мая 2010

2010-05-26T15:31:53Z

Admin: 1 версия

2010-05-26T12:18:16Z

1 версия

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

==An array of string values sorted first by length, then sorted alphabetically, using a case-insentive comparison.==

<source lang="csharp">using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
public class CaseInsensitiveComparer : IComparer<string> {
public int Compare(string x, string y) {
return string.rupare(x, y, true);
}
}
public class MainClass {
public static void Main() {
string[] words = { "a", "A", "b", "B", "C", "c" };
var sortedWords =
words.OrderBy(a => a.Length)
.ThenBy(a => a, new CaseInsensitiveComparer());
Console.Write(sortedWords);
}
}</source>

==First OrderBy Prototype==

<source lang="csharp">using System;
using System.Linq;
using System.Collections;
using System.Collections.Generic;
public class MainClass {
public static void Main() {
string[] presidents = {"ant", "arding", "arrison", "eyes", "over", "ackson"};
IEnumerable<string> items = presidents.OrderBy(s => s.Length);
foreach (string item in items)
Console.WriteLine(item);
}
}</source>

==Icecreams with Least Price==

<source lang="csharp">using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Linq.Expressions;
using System.Xml.Linq;
class Program
{
static void Main(string[] args)
{
List<Icecream> icecreamsList3 = new List<Icecream>{
new Icecream("A", 10.5),
new Icecream("B", 9.80 ),
new Icecream("C", 7.5)

};
var icecreamswithLeastPrice =from Ice in icecreamsList3 where Ice.price <= 10 select new { Ice.name, Ice.price };
foreach (var ice in icecreamswithLeastPrice)
{
Console.WriteLine(ice.name + " " + ice.price);
}
var count = icecreamsList3.Count<Icecream>(Ice => Ice.price <= 10);
Console.WriteLine(count);
}

}

public class Icecream
{
public string name;
public double price;
public Icecream(string name, double price)
{
this.name = name;
this.price = price;
}
}</source>

==Multi Level Ordering==

<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
orderby c.Region, c.Country descending, c.City
select new { c.ID, c.Region, c.Country, c.City }
;
foreach (var item in queryResults)
{
Console.WriteLine(item);
}
}
}</source>

==Not in Top Five Customers by Sales==

<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="N", City="Los Angeles", Country="USA", Region="North America", Sales=5000 },
new Customer { ID="O", City="Cairo", Country="Egypt", Region="Africa", Sales=6000 },
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
orderby c.Sales descending
select new { c.ID, c.City, c.Country, c.Sales }
;
Console.WriteLine("Customers Not In Top Five");
foreach (var item in queryResults.Skip(5))
{
Console.WriteLine(item);
}

}
}</source>

==Order by descending==

<source lang="csharp">using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
class Employee
{
public string Name { get; set; }
public decimal Salary { get; set; }
}
class Department
{
public string Name { get; set; }
List<Employee> employees = new List<Employee>();
public IList<Employee> Employees
{
get { return employees; }
}
}
class Company
{
public string Name { get; set; }
List<Department> departments = new List<Department>();
public IList<Department> Departments
{
get { return departments; }
}
}
class SalaryReport
{
static void Main()
{
var company = new Company
{
Name = "A",
Departments =
{
new Department
{
Name = "Development",
Employees =
{
new Employee { Name = "T", Salary = 75000m },
new Employee { Name = "D", Salary = 45000m },
new Employee { Name = "M", Salary = 150000m }
}
},
new Department
{
Name = "Marketing",
Employees =
{
new Employee { Name = "Z", Salary = 200000m },
new Employee { Name = "X", Salary = 120000m }
}
}
}
};
var query = company.Departments
.Select(dept => new { dept.Name, Cost = dept.Employees.Sum(person => person.Salary) })
.OrderByDescending(deptWithCost => deptWithCost.Cost);
foreach (var item in query)
{
Console.WriteLine(item);
}
}
}</source>

==OrderBy: prints an alphabetically sorted version of a string array==

<source lang="csharp">using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
public class MainClass {
public static void Main() {
string[] words = { "C", "a", "b" };
var sortedWords =
from w in words
orderby w
select w;
Console.WriteLine("The sorted list of words:");
foreach (var w in sortedWords) {
Console.WriteLine(w);
}
}
}</source>

==OrderBy with customized Comparer==

<source lang="csharp">using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
public class CaseInsensitiveComparer : IComparer<string> {
public int Compare(string x, string y) {
return string.rupare(x, y, true);
}
}
public class MainClass {
public static void Main() {
string[] words = { "a", "A", "b", "B", "C", "c" };
var sortedWords = words.OrderBy(a => a, new CaseInsensitiveComparer());

}
}</source>

==OrderBy with passing a lambda function==

<source lang="csharp">using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
public class CaseInsensitiveComparer : IComparer<string> {
public int Compare(string x, string y) {
return string.rupare(x, y, true);
}
}
public class MainClass {
public static void Main() {
string[] words = { "a", "A", "b", "B", "C", "c" };
var sortedWords = words.OrderBy(a => a, new CaseInsensitiveComparer());

}
}</source>

==Ordered by PetName==

<source lang="csharp">using System;
using System.Collections.Generic;
using System.Text;
using System.Xml.Linq;
using System.Linq;
class Car
{
public string PetName;
public string Color;
public int Speed;
public string Make;

public override string ToString()
{
return string.Format("Make={0}, Color={1}, Speed={2}, PetName={3}",Make, Color, Speed, PetName);
}
}
class Program
{
static void Main(string[] args)
{
Car[] myCars = new []{
new Car{ PetName = "A", Color = "Silver", Speed = 100, Make = "BMW"},
new Car{ PetName = "B", Color = "Black", Speed = 55, Make = "VW"},
new Car{ PetName = "C", Color = "White", Speed = 43, Make = "Ford"}
};

var subset = from c in myCars orderby c.PetName select c;

foreach (Car c in subset)
{
Console.WriteLine(c.ToString());
}

}
}</source>

==Order Method Syntax==

<source lang="csharp">using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
class Program
{
static void Main(string[] args)
{
string[] names = {"Zheng", "Smith" };
var queryResults = names.OrderBy(n => n).Where(n => n.StartsWith("S"));
foreach (var item in queryResults)
{
Console.WriteLine(item);
}
}
}</source>

==Order Query Results==

<source lang="csharp">using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
class Program
{
static void Main(string[] args)
{
string[] names = { "Zheng", "Smith", "Small" };
var queryResults =
from n in names
where n.StartsWith("S")
orderby n
select n;
foreach (var item in queryResults)
{
Console.WriteLine(item);
}
}
}</source>

==products sorted alphabetically by the product name==

<source lang="csharp">using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
public class MainClass {
public static void Main() {
List<Product> products = GetProductList();
var sortedProducts =
from p in products
orderby p.ProductName
select p;
Console.WriteLine(sortedProducts);
}
static List<Product> GetProductList() {
List<Product> empTree = new List<Product>();
empTree.Add(new Product { ProductName = "A", Category = "O", UnitPrice = 12, UnitsInStock = 5, Total = 36, OrderDate = new DateTime(2005, 1, 1), Id = 1 });
empTree.Add(new Product { ProductName = "B", Category = "O", UnitPrice = 2, UnitsInStock = 4, Total = 35, OrderDate = new DateTime(2005, 1, 1), Id = 1 });
empTree.Add(new Product { ProductName = "C", Category = "O", UnitPrice = 112, UnitsInStock = 3, Total = 34, OrderDate = new DateTime(2005, 1, 1), Id = 1 });
empTree.Add(new Product { ProductName = "D", Category = "O", UnitPrice = 112, UnitsInStock = 0, Total = 33, OrderDate = new DateTime(2005, 1, 1), Id = 1 });
empTree.Add(new Product { ProductName = "E", Category = "O", UnitPrice = 1112, UnitsInStock = 2, Total = 32, OrderDate = new DateTime(2005, 1, 1), Id = 1 });
empTree.Add(new Product { ProductName = "F", Category = "O", UnitPrice = 11112, UnitsInStock = 0, Total = 31, OrderDate = new DateTime(2005, 1, 1), Id = 1 });
return empTree;
}
}
class Product : IComparable<Product> {
public string ProductName { get; set; }
public string Category { get; set; }
public int UnitPrice { get; set; }
public int UnitsInStock { get; set; }
public int Total { get; set; }
public DateTime OrderDate { get; set; }
public int Id { get; set; }
public override string ToString() {
return String.Format("Id: {0}, Name: {1} , Category: {3}", this.Id, this.ProductName, this.Category);
}
int IComparable<Product>.rupareTo(Product other) {
if (other == null)
return 1;
if (this.Id > other.Id)
return 1;
if (this.Id < other.Id)
return -1;
return 0;
}
}</source>

==products sorted by the number of units of each product that are in stock==

<source lang="csharp">using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
public class MainClass {
public static void Main() {
List<Product> products = GetProductList();
var sortedProducts =
from p in products
orderby p.UnitsInStock descending
select p;
Console.Write(sortedProducts);
}
static List<Product> GetProductList() {
List<Product> empTree = new List<Product>();
empTree.Add(new Product { ProductName = "A", Category = "O", UnitPrice = 12, UnitsInStock = 5, Total = 36, OrderDate = new DateTime(2005, 1, 1), Id = 1 });
empTree.Add(new Product { ProductName = "B", Category = "O", UnitPrice = 2, UnitsInStock = 4, Total = 35, OrderDate = new DateTime(2005, 1, 1), Id = 1 });
empTree.Add(new Product { ProductName = "C", Category = "O", UnitPrice = 112, UnitsInStock = 3, Total = 34, OrderDate = new DateTime(2005, 1, 1), Id = 1 });
empTree.Add(new Product { ProductName = "D", Category = "O", UnitPrice = 112, UnitsInStock = 0, Total = 33, OrderDate = new DateTime(2005, 1, 1), Id = 1 });
empTree.Add(new Product { ProductName = "E", Category = "O", UnitPrice = 1112, UnitsInStock = 2, Total = 32, OrderDate = new DateTime(2005, 1, 1), Id = 1 });
empTree.Add(new Product { ProductName = "F", Category = "O", UnitPrice = 11112, UnitsInStock = 0, Total = 31, OrderDate = new DateTime(2005, 1, 1), Id = 1 });
return empTree;
}
}
class Product : IComparable<Product> {
public string ProductName { get; set; }
public string Category { get; set; }
public int UnitPrice { get; set; }
public int UnitsInStock { get; set; }
public int Total { get; set; }
public DateTime OrderDate { get; set; }
public int Id { get; set; }
public override string ToString() {
return String.Format("Id: {0}, Name: {1} , Category: {3}", this.Id, this.ProductName, this.Category);
}
int IComparable<Product>.rupareTo(Product other) {
if (other == null)
return 1;
if (this.Id > other.Id)
return 1;
if (this.Id < other.Id)
return -1;
return 0;
}
}</source>

==sorted alphabetically in descending order, using a case insensitive comparision.==

<source lang="csharp">using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
public class CaseInsensitiveComparer : IComparer<string> {
public int Compare(string x, string y) {
return string.rupare(x, y, true);
}
}
public class MainClass {
public static void Main() {
string[] words = { "a", "A", "b", "B", "C", "c" };
var sortedWords = words.OrderByDescending(a => a, new CaseInsensitiveComparer());
}
}</source>

==Sorted join query==

<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 CustomerAddress
{
public Customer Customer { get; set; }
public Address Address { get; set; }
}
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 = from customer in customers
join address in addresses on
string.Format("{0} {1}", customer.FirstName, customer.LastName)
equals address.Name
orderby customer.LastName, address.Street descending
select new { Customer = customer, Address = address };
foreach (var ca in result)
{
Console.WriteLine(string.Format("{0}\nAddress: {1}",
ca.Customer, ca.Address));
}
}
}</source>

==Sorting strings in a file==

<source lang="csharp">using System;
using System.IO;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Linq.Expressions;
using System.Xml.Linq;
class Program
{
static void Main(string[] args)
{
List<string> strs = new List<string>();
using( StreamReader sReader = new StreamReader("data.txt"))
{
string str;
str = sReader.ReadLine();
while (str != null)
{
strs.Add(str);
}
}
IEnumerable<string> i = from name in strs orderby name descending select name;
foreach (string nam in i)
{
Console.WriteLine(nam);
}
}
}</source>

==Sort object by its property==

<source lang="csharp">using System;
using System.Collections.Generic;
using System.ruponentModel;
class Film
{
public string Name { get; set; }
public int Year { get; set; }
public override string ToString()
{
return string.Format("Name={0}, Year={1}", Name, Year);
}
}
class MainClass
{
static void Main()
{
var films = new List<Film>
{
new Film {Name="J", Year=1975},
new Film {Name="H", Year=2000},
new Film {Name="T", Year=1995}
};
Action<Film> print = film => Console.WriteLine(film);
Console.WriteLine("All films");
films.ForEach(print);
Console.WriteLine();
Console.WriteLine("Oldies");
films.FindAll(film => film.Year < 1980).ForEach(print);
Console.WriteLine();
Console.WriteLine("Sorted");
films.Sort((f1, f2) => f1.Name.rupareTo(f2.Name));
films.ForEach(print);
}
}</source>

==string array sorted by the length each element==

<source lang="csharp">using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
public class MainClass {
public static void Main() {
string[] words = { "abc", "bcd", "def" };
var sortedWords =
from w in words
orderby w.Length
select w;
Console.WriteLine("The sorted list of words (by length):");
foreach (var w in sortedWords) {
Console.WriteLine(w);
}
}
}</source>

==Top Five Customers by Sales==

<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="N", City="Los Angeles", Country="USA", Region="North America", Sales=5000 },
new Customer { ID="O", City="Cairo", Country="Egypt", Region="Africa", Sales=6000 },
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
orderby c.Sales descending
select new { c.ID, c.City, c.Country, c.Sales }
;
Console.WriteLine("Top Five Customers by Sales");
foreach (var item in queryResults.Take(5))
{
Console.WriteLine(item);
}

}
}</source>

==Using a compound orderby to sort a list of digits first by length of their name, and then alphabetically.==

<source lang="csharp">using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
public class MainClass {
public static void Main() {
string[] digits = { "zero", "one", "two", "three"};
var sortedDigits =
from d in digits
orderby d.Length, d
select d;
Console.WriteLine("Sorted digits:");
foreach (var d in sortedDigits) {
Console.WriteLine(d);
}
}
}</source>

==Using a compound orderby to sort a list of products, first by category, and then by unit price, from highest to lowest.==

<source lang="csharp">using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
public class MainClass {
public static void Main() {
List<Product> products = GetProductList();
var sortedProducts =
from p in products
orderby p.Category, p.UnitPrice descending select p;
foreach (var s in sortedProducts) {
Console.Write(s);
}
}
static List<Product> GetProductList() {
List<Product> empTree = new List<Product>();
empTree.Add(new Product { ProductName = "A", Category = "O", UnitPrice = 12, UnitsInStock = 5, Total = 36, OrderDate = new DateTime(2005, 1, 1), Id = 1 });
empTree.Add(new Product { ProductName = "B", Category = "O", UnitPrice = 2, UnitsInStock = 4, Total = 35, OrderDate = new DateTime(2005, 1, 1), Id = 1 });
empTree.Add(new Product { ProductName = "C", Category = "O", UnitPrice = 112, UnitsInStock = 3, Total = 34, OrderDate = new DateTime(2005, 1, 1), Id = 1 });
empTree.Add(new Product { ProductName = "D", Category = "O", UnitPrice = 112, UnitsInStock = 0, Total = 33, OrderDate = new DateTime(2005, 1, 1), Id = 1 });
empTree.Add(new Product { ProductName = "E", Category = "O", UnitPrice = 1112, UnitsInStock = 2, Total = 32, OrderDate = new DateTime(2005, 1, 1), Id = 1 });
empTree.Add(new Product { ProductName = "F", Category = "O", UnitPrice = 11112, UnitsInStock = 0, Total = 31, OrderDate = new DateTime(2005, 1, 1), Id = 1 });
return empTree;
}
}
class Product : IComparable<Product> {
public string ProductName { get; set; }
public string Category { get; set; }
public int UnitPrice { get; set; }
public int UnitsInStock { get; set; }
public int Total { get; set; }
public DateTime OrderDate { get; set; }
public int Id { get; set; }
public override string ToString() {
return String.Format("Id: {0}, Name: {1} , Category: {3}", this.Id, this.ProductName, this.Category);
}
int IComparable<Product>.rupareTo(Product other) {
if (other == null)
return 1;
if (this.Id > other.Id)
return 1;
if (this.Id < other.Id)
return -1;
return 0;
}
}</source>

==Using orderby clause to order result==

<source lang="csharp">using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
class Program
{
static void Main(string[] args)
{
string[] names = { "Zheng", "Smith", "Small" };
var queryResults =
from n in names
where n.StartsWith("S")
orderby n
select n;
foreach (var item in queryResults)
{
Console.WriteLine(item);
}
}
}</source>

==Where with OrderBy==

<source lang="csharp">using System;
using System.Collections.Generic;
using System.Linq;
public class MainClass {
public static void Main() {
string[] names = { "J", "P", "G", "Pa" };
IEnumerable<string> query = names.Where(n => n.Contains("a"))
.OrderBy(n => n.Length)
.Select(n => n.ToUpper());
}
}</source>

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

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

в 15:31, 26 мая 2010

Admin: 1 версия