Prima dell’avvento dei Generics, con la versione 2.0 del framework .NET, le collezioni erano tutte radunate sotto un unico namespace: System.Collections.

Ora invece abbiamo a disposizione le versioni generiche di molte di esse (e altre ne stanno per arrivare, ora che .NET 4.0 è alle porte). Basta includere il namespace System.Collections.Generic.

L’introduzione dei Generics ha determinato, oltre all’aggiunta di classi che rappresentano le collezioni vere e proprie, anche la comparsa delle controparti generiche delle interfacce già presenti in System.Collection (ad esempio IList<T> per IList, IEnumerable<T> per IEnumerable, ICollection<T> per ICollection>).

Ed è proprio questa la chiave di volta della faccenda: possiamo invocare buona parte degli operatori standard di LINQ su una collezione solo se questa implementa l’interfaccia IEnumerable<T>. E le vecchie collezioni, naturalmente, non la implementano.

Ci vengono in soccorso proprio due degli operatori standard capaci di lavorare con collezioni che non implementano IEnumerable<T>: Cast e OfType (aggiunti all’interfaccia IEnumerable sfruttando gli Extension Methods).

Entrambi richiedono un type parameter (racchiuso tra parentesi angolari, come sempre quando abbiamo a che fare con i Generics) e nessun argomento ordinario.

La differenza fondamentale tra i due è questa: Cast opera la conversione verso il tipo specificato e, se non ci riesce, solleva un’eccezione di tipo InvalidCastException. OfType, invece, agisce in maniera più simile ad un filtro: prova a convertire ciascun elemento della collezione e, se questo non è possibile, semplicemente passa all’elemento successivo.

Vale la pena ricordare che le collezioni non generiche eseguono il boxing automatico dei valori che aggiungiamo, trattandoli tutti come object. Se da un lato questo offre un certo grado di flessibilità, dall’altro permette di aggiungere un oggetto di qualsiasi tipo, anche in maniera accidentale.

Ecco il perché dell’esistenza di questi due metodi che, se escludiamo la diversa gestione di un eventuale errore di conversione, si comportano in maniera perfettamente identica.

La decisione tra i due, come spesso capita, dipende dal contesto. Se vogliamo evitare eccezioni a runtime, che è forse il caso più probabile, useremo OfType. Se, invece, vogliamo essere sicuri che le situazioni anomale non possano sfuggirci, potremmo voler impiegare Cast ed implementare una gestione custom di InvalidCastException (scelta che, specie nel caso di collezioni contenenti grandi numeri di oggetti, inevitabilmente porterà ad un decadimento delle prestazioni).

Una cosa importante da notare è che, dichiarando esplicitamente il tipo della variabile d’iterazione nella nostra query expression (aggiungendo cioè il tipo di variabile dopo la clausola from e prima del nome della variabile stessa) possiamo far sì che Cast venga richiamato in modo implicito.

Pertanto, questa query LINQ

var result = from Employee e in someCollection select e;

e quest’altra

var result = from e in someCollection.Cast<Employee>() select e;

sono perfettamente equivalenti (in particolare, la prima è la forma implicita della seconda).

Per finire, vale la pena osservare che questo è l’unico caso in cui abbiamo bisogno specificare il tipo della variabile dopo una clausola from: in tutti gli altri casi sarà l’inferenza di tipo del compilatore a lavorare per noi.

Usando LINQ para gerenciar coleções de objetos

LINQ (Language INtegrated Query) é um conjunto de recursos introduzidos no .NET Framework 3.5 que estendem o C# e o Visual Basic.NET com uma sintaxe para consultas similar à linguagem SQL, além de fornecer bibliotecas de classes para tirar proveito destes recursos.

Existem cinco formas de utilizá-lo:

• LINQ to Entities
• LINQ to SQL
• LINQ to XML
• LINQ to Objects
• LINQ to DataSet

Neste artigo usaremos LINQ to Objects, que refere-se ao uso de consultas com LINQ em qualquer coleção IEnumerable ou IEnumerable<T>, ou seja, podemos consultar qualquer coleção enumerável como List<T>, Array, Dictionary<TKey, TValue>, etc com LINQ.

Vamos definir uma classe Product com as propriedades ProductID, ProductName, UnitPrice e UnitsInStock:

 1: public class Product
 2: {
 3:     public int ProductID { get; set; }
 4:     public string ProductName { get; set; }
 5:     decimal UnitPrice { get; set; }
 6:     public short UnitsInStock { get; set; }
 7: }

Imaginemos então uma lista de Product carregada com diversos produtos de características diferentes:

 1: List products = new List<Product>();

Nota: no código disponível na seção de downloads, no final do artigo, esta lista é carregada a partir de um arquivo XML que contém as informações dos produtos.

Agora podemos realizar nossas consultas na lista de produtos, que podem ser feitas de duas formas: usando os métodos de extensão (Extension Methods) disponíveis ao importar o namespace System.Linq, ou com a própria sintaxe para consultas.

Nota: Extension Methods também é um recurso introduzido no .NET Framework 3.5, que permite “adicionar” métodos em um tipo existente sem criar um tipo derivado ou modificar o tipo original.

Usando Extension Methods

Produtos ordenados por nome

 1: IEnumerable<Product> productsByName = products.OrderBy(p =>
    p.ProductName);

Esta simples linha de código ordena os produtos por nome. O método OrderBy recebe uma expressão lambda (Lambda Expression), e retorna uma coleção ordenada conforme indicado na expressão.

Nota: Lambda Expressions são métodos traduzidos para uma instância de delegate pelo compilador, nos permitindo criar métodos on the fly e com uma sintaxe simples: “parâmetros de entrada => implementação do método”.

Também é possível imprimir o resultado da ordenação com apenas uma linha de código:

 1: productsByName.ToList().ForEach(p => Console.WriteLine(
    p.ProductName));

Ou até fazer os dois!

 1: products.OrderBy(p => p.ProductName)
 2:         .ToList()
 3:         .ForEach(p => Console.WriteLine(p.ProductName));

Seguem mais alguns exemplos utilizando os métodos OrderBy, Reverse, Where e Sum.

Produtos ordenados por preço, decrescente

 1: IEnumerable<Product> productsByPrice = products.OrderBy(
    p => p.UnitPrice).Reverse();
 2: productsByPrice.ToList().ForEach(p =>
    Console.WriteLine(String.Format({0:c} por {1}",
    p.UnitPrice, p.ProductName)));

Produtos em estoque, ordenados por unidades em estoque, decrescente

 1: IEnumerable<Product> productsInStock = products.Where(
    p => p.UnitsInStock > 0).OrderBy(p => p.UnitsInStock)
    .Reverse();
 2: productsInStock.ToList().ForEach(p =>
    Console.WriteLine(String.Concat(p.UnitsInStock,
    " unidades de ", p.ProductName)));

Quantidade de produtos em estoque

 1: decimal productsCount = products.Sum(p => p.UnitsInStock);
 2: Console.WriteLine("\nQuantidade de produtos em estoque:
    {0}", productsCount);

Valor dos produtos em estoque

 1: decimal productsValue = products.Sum(p =>
    (p.UnitsInStock * p.UnitPrice));
 2: Console.WriteLine(String.Format("\nValor dos produtos em
    estoque: {0:c}", productsValue));

Usando a sintaxe para consultas

Também podemos gerenciar as coleções com diversas combinações de comandos usando uma sintaxe similar à linguagem SQL. Seguem alguns exemplos:

Produtos que começam com a letra C

 1: var productsWithC = from p in products
 2:                     where p.ProductName.StartsWith("C")
 3:                     orderby p.ProductName
 4:                     select p;
 5: productsWithC.ToList().ForEach(p =>
    Console.WriteLine(p.ProductName));

Produtos que custam mais que R$ 20,00

É possível obter apenas as propriedades desejadas como resultado usando o comando new:

 1: var expensiveProducts = from p in products
 2:                         where p.UnitPrice > 20
 3:                         orderby p.UnitPrice descending
 4:                         select new
 5:                         {
 6:                             Name = p.ProductName,
 7:                             Price = p.UnitPrice
 8:                         };
 9: expensiveProducts.ToList().ForEach(p =>
    Console.WriteLine(String.Format("{0:c} por {1}",
    p.Price, p.Name)));

Produto mais barato

Também é possível retornar um único objeto com o comando Single:

 1: Product cheaperProduct = (from p in products
 2:                           where p.UnitPrice == products
    .Min(p1 => p1.UnitPrice)
 3:                           select p).Single();
 4: Console.WriteLine(String.Format(
    "\nProduto mais barato:\n{0:c} por {1}",
    cheaperProduct.UnitPrice, cheaperProduct.ProductName));

Enfim, existem diversas combinações que podem ser feitas. Daqui pra frente basta usar a imaginação… Happy coding!

Downloads:

• GHR.Samples.LINQtoObjects

Referências:

• LINQ: http://msdn.microsoft.com/en-us/netframework/aa904594.aspx
• LINQ to Objetcs: http://msdn.microsoft.com/en-us/library/bb397919.aspx
• Extension Methods: http://msdn.microsoft.com/en-us/library/bb383977.aspx
• Lambda Expressions: http://msdn.microsoft.com/en-us/library/bb397687.aspx

We had seen in earlier posts how to left join and right join 2 lists using LINQ. But what about multiple list joining is it in the same way or are there any challanges in the implementation.

Select Emp.Name, Dept.Name, branch.Name from ((Employees as Emp left join 
Departments as Dept on Dept.ID = Emp.DeptID)left join 
Branches as branch on Dept.BranchID = branch.ID)

var MultipleListJoin = from empdept in
                                   (from emp in ListOfEmployees
join dept in ListOfDepartment
on emp.DeptID equals dept.ID into JoinedEmpDept
from dept in JoinedEmpDept.DefaultIfEmpty()
select new                                    
{
EmployeeName = emp.Name,
BranchID = dept != null ? dept.BranchID : 0,
DepartmentName = dept != null ? dept.Name : null                                    
})
join branch in ListOfBranch on
                               empdept.BranchID equals branch.ID into JoinedwithBranch
from branch in JoinedwithBranch.DefaultIfEmpty()
select new                               
{
EmpName = empdept.EmployeeName,
DeptName = empdept.DepartmentName,
BranchName = branch != null ? branch.Name : string.Empty
};

from emp in ListOfEmployees
join dept in ListOfDepartment
on emp.DeptID equals dept.ID into JoinedEmpDept
from dept in JoinedEmpDept.DefaultIfEmpty()
select new                                    
{
EmployeeName = emp.Name,
BranchID = dept != null ? dept.BranchID : 0,
DepartmentName = dept != null ? dept.Name : null}

Happy Learning

LINQ to XML is one of the many technologies introduced with the .NET Framework 3.5, and one that is certainly a step forward in terms of usability. It allows querying in both the functional style (using LINQ and lambda expressions) and the more traditional imperative one, meaning that it’s a great tool for concisely working with XML data in any sort of application, and undoubtedly a significant improvement over the old XML DOM that resides in the System.Xml namespace.

In the spirit of LINQ, and with the advent of YAML, I recntly decided it was about time that this new “markup language” were integrated with LINQ. Surprisingly, there does not already exist anything akin to LINQ to YAML out there (though there are a couple of fairly usable implementations of a YAML reader/writer for .NET). This seemed to me like a good chance to potentially create something that might be used by more than the odd .NET developer or two. My plans are to implement a LINQ to YAML provider either from scratch or on top of one of the existing YAML libraries. (Which option I choose will depend on the state of the existing projects, which I haven’t yet investigated properly. I am however suspecting that it might be worthwhile writing my own, since it would a) teach me all the intricacies of YAML, and b) allow me to support the latest version [1.2], which the existing libraries do not.)

Before I launch into an overview of my intended implementation, here is a little bit about YAML itself, for those who aren’t already familiar with it. Although technically YAML isn’t a markup language (after all, the recursive acronym stands for YAML Ain’t Markup Language) – it is rather a serialisation format – it does essentially fulfill the the role that XML  traditionally has, in a variety of common situations. I’m not going to try to sell the format to you right now, but it should suffice to say that you wouldn’t have reached this far in the post if you weren’t already at least intrigued! Without doubt, the format is actively gaining popularity because of it’s ultra-lightweight syntax and suitability for hand editing, perhaps the two points that summarise its advantages over XML.

Anyway, here’s a short example of a YAML document (taken straight from the Wikipedia page), so you can see precisely how pleasant it is to work with (at least for humans).

—

receipt:     Oz-Ware Purchase Invoice
date:        2007-08-06
customer:
    given:   Dorothy
    family:  Gale

items:
    - part_no:   A4786
      descrip:   Water Bucket (Filled)
      price:     1.47
      quantity:  4

    - part_no:   E1628
      descrip:   High Heeled "Ruby" Slippers
      price:     100.27
      quantity:  1

bill-to:  &id001
    street: |
            123 Tornado Alley
            Suite 16
    city:   East Westville
    state:  KS

ship-to:  *id001

specialDelivery:  >
    Follow the Yellow Brick
    Road to the Emerald City.
    Pay no attention to the
    man behind the curtain.
...

Of course, the great thing about YAML, which is demonstrated clearly by this example, is that you don’t have to have any real knowledge about YAML to understand exactly and immediately what the data represents, and as a bonus it doesn’t hurt your eyes to stare at for too long! Even the referencing syntax should be fairly self evident. (&id00 and *id001 would surely be nothing new to C programmers.)

The semantics as well as the syntax of YAML obviously differ to those of XML greatly, although there is almost always some sort of correspondence between the features and possibilities that the two formats offer. The only notable missing feature when contrasted to XML is attributes, yet their usefulness is questionable anyway.

Right, so now I ought to explain a bit about how I actually plan to design this library. The basic framework will be virtually equivalent to that of LINQ to XML. In other words, the hierarchy will be largely based around an abstract YamlObject (YObject?) class, and will look very much like the one contained within System.Xml.Linq.

LINQ to XML class hierarchy

Though LINQ to YAML must of course accomodate for the unique nature of the format, I would initially aim for minimal difference and only significantly adjust the hierarchy when it is found to be necessary. Classes such as XCData and XDocumentType would not apply at all to YAML, yet there would need to be a place for a YReference or such somewhere in the hierarchy. The referencing aspect of YAML will likely prove to be one of the more interesting challenges; while YAML’s lists, maps (dictionaries), and combinations thereof would seem relatively straightforward with regards to emulation of the LINQ to XML design, references would introduce a substantially novel concept. Some sort of implementation of lazy evaluation followed by concrete referencing should be able to solve the problem, but there’s no way to predict how well this might work in practice at this moment.

What I realised only after deciding to create a LINQ to YAML library is that among LINQ providers, LINQ to XML is somewhat special in that the LINQ aspect of it is built on top of LINQ to Objects (i.e. LINQ using IEnumerable<T> objects), with only a relatively small number of extension methods specific to LINQ to XML. Indeed, most LINQ providers (LINQ to Objects and LINQ to SQL among others) require you to implement the IQueryable and IQueryProvider interfaces to provide complex logic for interpreting and returning the results of expressions, as well as evaluating complex expression trees.  All this means that I can pretty much just design a DOM  to a certain style (i.e. one suited to functional code, like LINQ to XML), and let LINQ to Objects to everything else for me.

As I can’t think of anything more worth mentioning about my project at this time, I shall leave any more specific and complex details to a future post. Still, do by all means feel free to query me about my plans – I would be glad to answer any questions, and even gladder to receive some suggestions as how you think I might design LINQ to YAML, or simply a nod that you might find this useful at some point. I don’t anticipate this project to be a very long one, though I must say that both my work and free-time schedule are likely to be fairly messed up for the next month or two, therefore I’m not going to promise when I’ll get around to my initial release. Whenever it so happens, I will duly post the link to the project page on Launchpad (or wherever I decide to host it).

Hi Friends,

In this post let us see how we can handle Left Join and Right Join when using LINQ. There are no keywords defined in C#, we have to use DefaultIfEmpty() function to get the desired result.
Let us see how we can achieve it.

To make you understand better I use a Employee -> Department realation to explain.

First we shall create two classes namely Employee and Department

class Employee    
{
public string Name { get; set; }
public int ID { get; set; }
public int DeptID { get; set; }
}

class Department    
{
public int ID { get; set; }
public string Name { get; set; }
}

Lets create some objects of both the classes and fill some dummy data in it.

Employee emp1 = new Employee() { ID = 1, Name = "A", DeptID = 1};
Employee emp2 = new Employee() { ID = 2, Name = "B", DeptID = 1};
Employee emp3 = new Employee() { ID = 3, Name = "C", DeptID = 1 };
Employee emp4 = new Employee() { ID = 4, Name = "D", DeptID = 2 };
Employee emp5 = new Employee() { ID = 5, Name = "E", DeptID = 2 };
Employee emp6 = new Employee() { ID = 6, Name = "F", DeptID = 2 };
Employee emp7 = new Employee() { ID = 7, Name = "G", DeptID = 6 };
Employee emp8 = new Employee() { ID = 8, Name = "H", DeptID = 3 };
Employee emp9 = new Employee() { ID = 9, Name = "I", DeptID = 3 };
Employee emp10 = new Employee() { ID = 10, Name = "J", DeptID = 7};
Employee emp11 = new Employee() { ID = 11, Name = "K", DeptID = 7};
Employee emp12 = new Employee() { ID = 12, Name = "L", DeptID = 5};

Department Dept1 = new Department() { ID = 1, Name = "Development"};
Department Dept2 = new Department() { ID = 2, Name = "Testing"};
Department Dept3 = new Department() { ID = 3, Name = "Marketing"};
Department Dept4 = new Department() { ID = 4, Name = "Support"};

List<Employee> ListOfEmployees = new List<Employee>();
ListOfEmployees.AddRange((new Employee[] { emp1, emp2, emp3, emp4, emp5, emp6, emp7,
emp8, emp9, emp10, emp11, emp12 }));

List<Department> ListOfDepartment = new List<Department>();
ListOfDepartment.AddRange( new Department[]{ Dept1,Dept2,Dept3,Dept4});

So we finish loading the objects into ListOfEmployees and ListOfDepartments, using this lists we shall see how we can join them to get the results.
First let us see what would be the query in SQL if we had the same structure in our tables.
For Left join and right join we would have used the query

--Left Join in SQL
select Emp.Name, Dept.Name from Employee Emp left join Department Dept on
Emp.DeptID = Dept.ID

--Right Join In SQL
select Emp.Name, Dept.Name from Employee Emp right join Department Dept on
Emp.DeptID = Dept.ID

Using LINQ, Left Join can be acheived as follows

var LeftJoin = from emp in ListOfEmployees
join dept in ListOfDepartment
on emp.DeptID equals dept.ID into JoinedEmpDept 
from dept in JoinedEmpDept.DefaultIfEmpty()
select new                          
{
EmployeeName = emp.Name,
DepartmentName = dept != null ? dept.Name : null                          
};

And for Right Join there is no pretty difference, we just need to reverse the joining in first 2 lines. Here it follows

var RightJoin = from dept in ListOfDepartment
join employee in ListOfEmployees
on dept.ID equals employee.DeptID into joinDeptEmp
from employee in joinDeptEmp.DefaultIfEmpty()
select new                            
{
EmployeeName = employee != null ? employee.Name : null,
DepartmentName = dept.Name
};

Do you believe it will work ??? lets check it by displaying,

Console.WriteLine(string.Join("n" , LeftJoin.Select(emp => " Employee Name = " +
emp.EmployeeName + ", Department Name = " + emp.DepartmentName).ToArray<string>()));

Console.WriteLine(string.Join("n", RightJoin.Select(emp => " Employee Name = " +
emp.EmployeeName + ", Department Name = " + emp.DepartmentName).ToArray<string>()));

Output of Left Join in LINQ

Output of Right Join in LINQ

Great, it has worked. So friends in this way you can handle Left and Right Joins in LINQ, hope you understood the sample.

Next -> Multiple List Left Join

Happy Learning

Hi Friends,

In this post lets us try to understand how Join is handled using LINQ. We will take a sample that would make us clear what we are trying to acheive.

Consider a department that handles a type of category of items, it can be active or not. The class of the department will look like

public class Dept    
{
public int ID { get; set; }
public int CategoryID { get; set; }
public bool IsActive { get; set; }
}

After creating the department class lets move to create the Items class

public class Item    
{
public int ID { get; set; }
public int DeptID { get; set; }
public int CategoryID { get; set; }
public bool IsActive { get; set; }
public int Quantity { get; set; }
}

First let us create a list of Department and Items

//Create Items            
Item itm1 = new Item() { ID = 1, DeptID = 1, CategoryID = 1, IsActive = true, Quantity = 30 };
Item itm2 = new Item() { ID = 2, DeptID = 1, CategoryID = 1, IsActive = false, Quantity = 5 };
Item itm3 = new Item() { ID = 3, DeptID = 1, CategoryID = 2, IsActive = true, Quantity = 2 };
Item itm4 = new Item() { ID = 4, DeptID = 1, CategoryID = 2, IsActive = false, Quantity = 0 };

Item itm5 = new Item() { ID = 5, DeptID = 2, CategoryID = 1, IsActive = true, Quantity = 0 };
Item itm6 = new Item() { ID = 6, DeptID = 2, CategoryID = 1, IsActive = false, Quantity = 0 };
Item itm7 = new Item() { ID = 7, DeptID = 2, CategoryID = 2, IsActive = true, Quantity = 20 };
Item itm8 = new Item() { ID = 8, DeptID = 2, CategoryID = 2, IsActive = false, Quantity = 5 };

Item[] ListOfItems = { itm1, itm2, itm3, itm4, itm5, itm6, itm7, itm8 };

//Create Departments            
Dept dept1 = new Dept() { ID = 1, CategoryID = 1, IsActive = true };
Dept dept2 = new Dept() { ID = 1, CategoryID = 1, IsActive = false};
Dept dept3 = new Dept() { ID = 1, CategoryID = 2, IsActive = true };
Dept dept4 = new Dept() { ID = 1, CategoryID = 2, IsActive = false };

Dept dept5 = new Dept() { ID = 2, CategoryID = 1, IsActive = true };
Dept dept6 = new Dept() { ID = 2, CategoryID = 1, IsActive = false };
Dept dept7 = new Dept() { ID = 2, CategoryID = 2, IsActive = true };
Dept dept8 = new Dept() { ID = 2, CategoryID = 2, IsActive = false };

Dept[] ListOfDept = { dept1, dept2, dept3, dept4,dept5,dept6,dept7,dept8 };

Lets move furthur to check how these two classes can be joined to derive the result

Join single column-> No of items in Department 1:
We will join the two classes on department id and get the the sum of items present in department 1.

//Single Join            
//List No of items in Dept 1            
int NoOfItems = (from dept in ListOfDept
join item in ListOfItems
on dept.ID equals item.DeptID 
where dept.ID == 1
select new { item.ID, item.Quantity }).Distinct().Sum(itm => itm.Quantity);

In the above code I am filtering the same records that are returned due to equijoin.

Join multiple columns -> Get the item * and dept * for the following criteria
Lets join the dept and item objects on the following criteria

Relation between Department and Items

and add a extra condition for Item.Quantity > 0 and retrive the values

First let us see how the above result are acheived without using join to make you clearly understand the difference between using and not using the join

var WithoutJoin = from dept in ListOfDept
from item in ListOfItems
where dept.ID == item.DeptID &&
dept.CategoryID == item.CategoryID &&
dept.IsActive == item.IsActive &&
item.IsActive == true &&
item.Quantity > 0
select new { item, dept };

Now lets retrive the same values using join

var WithJoin = from dept in ListOfDept
join item in ListOfItems
on new { deptid = dept.ID, catID = dept.CategoryID , isActive = dept.IsActive } equals
new { deptid = item.DeptID, catID = item.CategoryID, isActive = item.IsActive }
where item.IsActive == true && item.Quantity > 0
select new { item, dept };

Hope you have understood how to join single column and join multiple columns using LINQ. If you need any clarification please feel free.

Happy Learning

Hi friends,
In my previous post LINQ with best example – 1 , we had seen the basic concepts of linq with the company sample. Today we will move a bit furthur and see how LINQ can be used for an project handling Inventory.

The Inventory Sample

Downloads:
Download source code – 8 Kb

In inventory we will create 3 classes namely Customer, Item, and Sales. The Class diagram of the 3 classes are shown below.

Class Diagram

Create Customers, Items and Sales:
First let us insert some dummy records into the list of customer, Items and sales.

List<Customer> ListOfCustomer = new List<Customer>();
Customer C1 = new Customer() { Name = "Naveen", Area = "Mahalaxmi", City = "Bangalore", ID = 1 };
Customer C2 = new Customer() { Name = "Aatish", Area = "Layout", City = "Bangalore", ID = 2 };
Customer C3 = new Customer() { Name = "Manas", Area = "Layout", City = "Bangalore", ID = 3};
Customer C4 = new Customer() { Name = "Raghu", Area = "Mahalaxmi", City = "Bombay", ID = 4 };
ListOfCustomer.AddRange(new Customer[]{C1,C2,C3,C4});

List<Item> ListOfItems = new List<Item>();
Item I1 = new Item() { ID = 1, Name = "Monitor", Quantity = 15, UnitPrice = 5000 };
Item I2 = new Item() { ID = 2, Name = "Processor", Quantity = 10, UnitPrice = 10000};
Item I3 = new Item() { ID = 3, Name = "Keyboard", Quantity = 25 ,UnitPrice = 1000};
ListOfItems.AddRange(new Item[]{I1,I2,I3});

List<Sales> ListOfSales = new List<Sales>();
Sales S1 = new Sales() { CustomerID = 1, ItemID = 1, Quantity = 5 };
Sales S2 = new Sales() { CustomerID = 1, ItemID = 2, Quantity = 3 };
Sales S3 = new Sales() { CustomerID = 2, ItemID = 1, Quantity = 5 };
Sales S4 = new Sales() { CustomerID = 2, ItemID = 3, Quantity = 5 };
Sales S5 = new Sales() { CustomerID = 3, ItemID = 2, Quantity = 5 };
Sales S6 = new Sales() { CustomerID = 3, ItemID = 3, Quantity = 15};
ListOfSales.AddRange(new Sales[]{S1,S2,S3,S4,S5,S6});

Using the above classes we will query the following

• List all customers
• List customers from a specific city
• No of customers in each city
• No of items purchased by each customer
• No of Items remaining in inventory
• Amount received from each item
• Amount paid by each customer

List all customers:
For listing the customers use the following code.

foreach (Customer c in ListOfCustomer)
{
Console.WriteLine(c.Name + "," + c.ID + "," + c.Area + "," + c.City);
}

List customers from a specific city:
For filltering the customer depending on a specific city you can use

var CustomerCity = from customer in ListOfCustomer
where customer.City == "Bangalore"                               
select new                               
{
Name = customer.Name,
ID = customer.ID
};

You can also use where customer.City.StartsWith(“Ba”) to filter a customer when there is an entry in Quick search box.

No of customers in each city:
For finding the No. of customers from each city we have to group the customers on key ‘CITY’.

var CustomersInCity = from customer in ListOfCustomer
group customer by customer.City into GroupedCustomer
select new                               
{
City = GroupedCustomer.Key,
EmployeeCount = GroupedCustomer.Count()
};

No of items purchased by each customer:
For searching the items purchased by each customer we shall join all 3 lists and derive the output.

var CustomerItem = from cust in ListOfCustomer
join sale in ListOfSales 
on cust.ID equals sale.CustomerID 
join item in ListOfItems
on sale.ItemID equals item.ID 
select new { CustName = cust.Name, ItmName = item.Name, Qnt = sale.Quantity };

No of Items remaining in inventory:
For finding the remaining items in inventory we shall group the items in sales with itemid key. After which, we get quantity of each item sold. Then we will join the output of ItemID and SoldItems with Items in which we will get the No of items purchased. Subtracting Initial Count with Sold Count we get the items in Inventory.

var RemainingInventory = from itm in ListOfItems
join sold in
                                      (
from sale in ListOfSales
group sale by sale.ItemID into GroupedItemInSale
select new                                          
{
ID = GroupedItemInSale.Key,
Qty = GroupedItemInSale.Sum(sold => sold.Quantity)
})
on itm.ID equals sold.ID
select new { itm.Name, RemQnt = itm.Quantity - sold.Qty };

Amount received from each item:
For getting the amount received from each item, first we require the total no of each item sold, so we shall group the sales on ItemId. By this we get the ItemID and no of items sold. Then the unit Pice of each item can be multiplied by the no of peices sold by joining the first query output with Item List.

var IncomeFromSales = from item in ListOfItems
join sold in
                                      (
from sale in ListOfSales
group sale by sale.ItemID into GroupedItems
select new                                          
{
ID = GroupedItems.Key,
Quantity = GroupedItems.Sum(GI => GI.Quantity)
})
on item.ID equals sold.ID 
select new { Name = item.Name, AmountRec = item.UnitPrice * sold.Quantity };

Amount paid by each customer:
For this first let us analyze what is required and then split it till we go to the solution
1) Customer Name with Total Amount – the final output we require is Customer Name and Total Amount
2) ListOfcustomer, (Customer ID, each item quantity , each item price) – Customer Name can be fetched by joining LIstofcustomer with an output that has (customerID, Quantity of each item purchased and item price for each)
3) ListOfCustomer, Joining(Item and Sales) – to attain the output for (2) can be attained if we join Item and sales.

So now reverse the process and the following query will be acheived.

var AmountPaidByCustomers = from cust in ListOfCustomer
join GroupedAmount in
(from GroupAmount in
(from itm in ListOfItems
join sale in ListOfSales
on itm.ID equals sale.ItemID
select new                                              
{
sale.CustomerID,
Amount = sale.Quantity * itm.UnitPrice
})
group GroupAmount by GroupAmount.CustomerID into GroupedAmount
select new                                      
{CustomerID = GroupedAmount.Key,
Amount = GroupedAmount.Sum(i => i.Amount)
})
on cust.ID equals GroupedAmount.CustomerID
select new                              
{cust.Name,GroupedAmount.Amount};

The above analysis helped in identifying how to proceed, So the steps followed to attain the final output
1) Join Sales and Item -> Get CustomerID, Amount = ItemID * Unit Pice ( this will be the amount for each type of item purchased)
2) Group the output of (1) on CustomerID -> Gets CustomerID, Amount ( this will be the total amount Purchased by the customer)
3) Join result of (2) with LIstOfCustomer on ID -> Gets Customer Name and Amount

Output :

Final Output

By the last problem we come to know that problem are simple to solve, but you should analyze the problems and split it up in simple steps.
Hope you have understood the Inventory sample, if you have any doubts or want a different sample then you can post a comment.

Happy Learning

This post gets you Linq access to the GAC with no fuss.

Fusion is wrapped for you so no need to understand the unmanaged stuff unless you want to. Your up and running with GAC as a new Linq to Objects source in minutes.

The Big Picture of the Project (You can skip to the next section if you just want the GAC code)

Note: The reason both the Gac and MyEnvironment IEnumerable<T> references below are different? See the reference on the bottom right of the picture into the entry point to all of it (ThisBox)?

Introduction to the Fusion Wrapped IEnumerable

A simple case. I want to know how my GAC is broken into ‘Major Vendors’. We assume this is roughly the first part of the name. (i.e. Microsoft.System = Microsoft).

Oh yeah. Exclude the assemblies that only occur once. We are looking for the larger view here.

Here is an easy solution:

        [Fact]
        public void should_show_gac_by_vendor()
        {
            var result = from matchedAssembly in ThisBox.By<AssemblyDetail>()
                         group matchedAssembly by
                             matchedAssembly.MajorName
                             into grouping
                             where grouping.Count() > 1
                             orderby grouping.Count() descending
                             select grouping;

            var TotalSum = result.Sum(ad => ad.Count());

            Console.WriteLine("** ASSEMBLIES BY NAME WITH > 1 REGISTERED  = {0} ***", TotalSum);

            foreach (var firstGroup in result)
            {
                var groupCount = firstGroup.Count();
                Console.WriteLine("Group '{0}' Assemblies={1} Percent={2} Public Keys Used={3}",
                                    firstGroup.Key,
                                    groupCount,
                                    groupCount.ToPctString(TotalSum),
                                    firstGroup.Select(ad => ad.PublicKey).Distinct().Count()
                                    );
            }
        }

** ASSEMBLIES BY NAME WITH > 1 REGISTERED  = 664 ***

Group ‘Microsoft’ Assemblies=466 Percent=70.18% Public Keys Used=5
Group ‘DevExpress’ Assemblies=73 Percent=10.99% Public Keys Used=2
Group ‘System’ Assemblies=71 Percent=10.69% Public Keys Used=4
Group ‘Policy’ Assemblies=14 Percent=2.11% Public Keys Used=2
Group ‘FSharp’ Assemblies=11 Percent=1.66% Public Keys Used=1
Group ‘VLinq’ Assemblies=10 Percent=1.51% Public Keys Used=1
Group ‘policy’ Assemblies=6 Percent=0.9% Public Keys Used=2
Group ‘PresentationFramework’ Assemblies=5 Percent=0.75% Public Keys Used=1
Group ‘mscorcfg’ Assemblies=2 Percent=0.3% Public Keys Used=1
Group ‘WebDev’ Assemblies=2 Percent=0.3% Public Keys Used=1
Group ‘VSTADTEProvider’ Assemblies=2 Percent=0.3% Public Keys Used=1
Group ‘VsWebSite’ Assemblies=2 Percent=0.3% Public Keys Used=1

Try that with GacUtil (grin)..

C# GAC IEnumerable<Assembly> implementation

Ah yes the GAC Fusion wrapper code.  Thanks to Debasish Bose for his help here.

C# Fusion Gac Enumerable : Domain.Dot.Net Team

    /// <summary>
    /// Just to have some room to breath
    /// </summary>
    public class AssemblyDetail : AssemblyDetailBase
    {
        public AssemblyDetail(IAssemblyName currentAssembly) : base(currentAssembly) {}

        public override String FullName
        {
            get
            {
                return _fullName;
            }
        }
        public override string Version
        {
            get
            {
                return _versionString;
            }
        }
        public override int Major
        {
            get
            {
                return VersionComponent(0);
            }
        }
        public override int Minor
        {
            get
            {
                return VersionComponent(1);
            }
        }
        public override int Revision
        {
            get
            {
                return VersionComponent(2);
            }
        }
        public override int Build
        {
            get
            {
                return VersionComponent(3);
            }
        }

        public override string PublicKey
        {
            get
            {
                return _pkey;
            }
        }
        public override string MajorName
        {
            get
            {
                return _majorName;
            }
        }
        public String Name
        {
            get
            {
                return _fullName;
            }
        }

        int VersionComponent(int position)
        {
            return _version.Length <= position + 1
                           ? Convert.ToInt32(_version[position]) : 0;
        }
    }

    #region

    using System;
    using System.Runtime.InteropServices;

    #endregion

    /// <summary>
    /// Alpha - Comment and Add Regressions
    /// </summary>
    public abstract class AssemblyDetailBase
    {
        protected string _fullName;
        protected string _majorName;
        string[] _nameSplit;
        protected string _pkey;
        string _rawname;
        protected string[] _version;
        protected string _versionString;

        /// <summary>
        /// Initializes a new instance of the <see cref="AssemblyDetailBase"/> class.
        /// </summary>
        /// <param name="Current">The current.</param>
        protected AssemblyDetailBase(IAssemblyName Current)
        {
            ExtractParsedDetail(Current);
        }

        public abstract string FullName
        {
            get;
        }
        public abstract string Version
        {
            get;
        }
        public abstract int Major
        {
            get;
        }
        public abstract int Minor
        {
            get;
        }
        public abstract int Revision
        {
            get;
        }
        public abstract int Build
        {
            get;
        }
        public abstract string PublicKey
        {
            get;
        }
        public abstract string MajorName
        {
            get;
        }

        /// <summary>
        /// I do not want to persist the IAssemblyName
        /// as it might introduce a COM reference when
        /// we just can extract what we need and let it
        /// pass away into whatever...
        ///
        /// Extracts the parsed detail.
        /// </summary>
        /// <param name="Current">The current.</param>
        void ExtractParsedDetail(IAssemblyName Current)
        {
            const int stongKeyPosition = 3;
            const int versionPosition = 1;

            // Main Work Happens Here
            _fullName = GetDisplayName(Current);

            // Simply parse the ", " that seperates the full
            // name
            var _parsedDetails = _fullName.Split(new[]
                                                 {
                                                         ", "
                                                 }, StringSplitOptions.RemoveEmptyEntries);

            ExtractVersionInfo(versionPosition, _parsedDetails);
            ExtractAddition(stongKeyPosition, _parsedDetails);
        }

        void ExtractAddition(int stongKeyPosition, string[] parsedDetails)
        {
            _pkey = parsedDetails[stongKeyPosition];
            _rawname = parsedDetails[0].Trim();
            _nameSplit = _rawname.Split('.');
            _majorName = _nameSplit[0].Trim();
        }

        /// <summary>
        /// Gets the display name from the unmanaged pointer
        /// </summary>
        /// <param name="aName">A name.</param>
        /// <returns></returns>
        static string GetDisplayName(IAssemblyName aName)
        {
            var displayFlags = AssemblyNameDisplayFlags.ALL;

            uint uiLen = 0;

            string _displayAssemblyName = null;

            // Get the length
            aName.GetDisplayName(IntPtr.Zero, ref uiLen, (uint) displayFlags);

            if (uiLen > 0)
            {
                var byteBuffer = new byte[(uiLen + 1)*2];
                unsafe //turn on sunsafe in project properties
                {
                    fixed (byte* numRef1 = byteBuffer)
                    {
                        var ptr1 = new IntPtr(numRef1);
                        aName.GetDisplayName(ptr1, ref uiLen, (uint) displayFlags);
                        _displayAssemblyName = Marshal.PtrToStringUni(ptr1);
                    }
                }
            }

            return _displayAssemblyName;
        }

        /// <summary>
        /// Extracts the version info.
        /// </summary>
        /// <param name="versionPosition">The version position.</param>
        /// <param name="parsedDetails">The parsed details.</param>
        void ExtractVersionInfo(int versionPosition, string[] parsedDetails)
        {
            var versionLiteral = parsedDetails[versionPosition];
            _versionString = ToCoreVersion(versionPosition, versionLiteral);
            if (_versionString != String.Empty)
                _version = _versionString.Split('.');
        }

        /// <summary>
        /// Gets the nice clean x.x.x.x string
        /// </summary>
        /// <param name="versionPosition">The version position.</param>
        /// <param name="versionLiteral">The version literal.</param>
        /// <returns></returns>
        static string ToCoreVersion(int versionPosition, string versionLiteral)
        {
            var returnVal = String.Empty;

            if (!String.IsNullOrEmpty(versionLiteral))
            {
                var _indexOf = versionLiteral.IndexOf("=");

                if (_indexOf != -1)
                    returnVal = versionLiteral.Substring(_indexOf + versionPosition);
            }

            return returnVal;
        }
    }

#region

using System.Runtime.InteropServices;

#endregion

class GAC
{
    GAC() {}

    [DllImport("Fusion.dll", CharSet = CharSet.Auto)]
    public static extern int CreateAssemblyEnum(out IAssemblyEnum ppEnum,
                                                IApplicationContext pAppCtx,
                                                IAssemblyName pName, uint dwFlags,
                                                int pvReserved);
}

#region

using System.Runtime.InteropServices;
using System.Security;

#endregion

[SuppressUnmanagedCodeSecurity, ComImport, Guid("7C23FF90-33AF-11D3-95DA-00A024A85B51"),
 InterfaceType(1)]
public interface IApplicationContext
{
    void SetContextNameObject(IAssemblyName pName);

    void GetContextNameObject([Out] out IAssemblyName ppName);

    void Set([MarshalAs(UnmanagedType.LPWStr)] string szName, int pvValue, uint cbValue,
             uint dwFlags);

    void Get([MarshalAs(UnmanagedType.LPWStr)] string szName, [Out] out int pvValue,
             ref uint pcbValue, uint dwFlags);

    void GetDynamicDirectory([Out] out int wzDynamicDir, ref uint pdwSize);
}

#region

using System;
using System.Runtime.InteropServices;
using System.Security;
using System.Text;

#endregion

/// <summary>
/// IAssemblyName from Fusion
/// </summary>
[SuppressUnmanagedCodeSecurity, ComImport, Guid("CD193BC0-B4BC-11D2-9833-00C04FC31D2E"),
 InterfaceType(1)]
public interface IAssemblyName
{
    [PreserveSig]
    int SetProperty(uint PropertyId, IntPtr pvProperty, uint cbProperty);

    [PreserveSig]
    int GetProperty(uint PropertyId, IntPtr pvProperty, ref uint pcbProperty);

    [PreserveSig]
    int Finalize();

    [PreserveSig]
    int GetDisplayName(IntPtr szDisplayName, ref uint pccDisplayName, uint dwDisplayFlags);

    [PreserveSig]
    int BindToObject(object refIID, object pAsmBindSink,
                     IApplicationContext pApplicationContext,
                     [MarshalAs(UnmanagedType.LPWStr)] string szCodeBase, long llFlags,
                     int pvReserved, uint cbReserved, [Out] out int ppv);

    [PreserveSig]
    int GetName(ref uint lpcwBuffer,
                [Out, MarshalAs(UnmanagedType.LPWStr)] StringBuilder pwzName);

    [PreserveSig]
    int GetVersion([Out] out uint pdwVersionHi, [Out] out uint pdwVersionLow);

    [PreserveSig]
    int IsEqual(IAssemblyName pName, uint dwCmpFlags);

    [PreserveSig]
    int Clone([Out] out IAssemblyName pName);
}

#region

using System.Runtime.InteropServices;
using System.Security;

#endregion

[SuppressUnmanagedCodeSecurity, ComImport, Guid("21B8916C-F28E-11D2-A473-00C04F8EF448"),
 InterfaceType(1)]
interface IAssemblyEnum
{
    [PreserveSig]
    int GetNextAssembly([Out] out IApplicationContext ppAppCtx,
                        [Out] out IAssemblyName ppName, uint dwFlags);

    [PreserveSig]
    int Reset();

    [PreserveSig]
    int Clone([Out] out IAssemblyEnum ppEnum);
}

#region

using System.Collections;
using System.Collections.Generic;
using System.Runtime.InteropServices;

#endregion

/// <summary>
/// Fairly basic stuff once the
/// unmanaged stuff is all mapped
/// </summary>
public class GacEnumerable : IEnumerator<IAssemblyName>, IEnumerable<IAssemblyName>
{
    readonly IAssemblyEnum _enumeration;
    IAssemblyName _enumCurrentAssembly;

    GacEnumerable()
    {
        HandleCom(GAC.CreateAssemblyEnum(out _enumeration, null, null,
                                         (uint) AssemblyCacheFlags.GAC, 0));
    }

    public static GacEnumerable New
    {
        get
        {
            return new GacEnumerable();
        }
    }

    #region IEnumerable<IAssemblyName> Members

    /// <summary>
    /// Returns an enumerator that iterates through the collection.
    /// </summary>
    /// <returns>
    /// A <see cref="T:System.Collections.Generic.IEnumerator`1"/> that can be used to iterate through the collection.
    /// </returns>
    public IEnumerator<IAssemblyName> GetEnumerator()
    {
        return this;
    }

    /// <summary>
    /// Returns an enumerator that iterates through a collection.
    /// </summary>
    /// <returns>
    /// An <see cref="T:System.Collections.IEnumerator"/> object that can be used to iterate through the collection.
    /// </returns>
    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }

    #endregion

    #region IEnumerator<IAssemblyName> Members

    /// <summary>
    /// Advances the enumerator to the next element of the collection.
    /// </summary>
    /// <returns>
    /// true if the enumerator was successfully advanced to the next element; false if the enumerator has passed the end of the collection.
    /// </returns>
    /// <exception cref="T:System.InvalidOperationException">The collection was modified after the enumerator was created. </exception>
    bool IEnumerator.MoveNext()
    {
        IApplicationContext context1;
        return (0 ==
                _enumeration.GetNextAssembly(out context1, out _enumCurrentAssembly, 0));
    }

    /// <summary>
    /// Sets the enumerator to its initial position, which is before the first element in the collection.
    /// </summary>
    /// <exception cref="T:System.InvalidOperationException">The collection was modified after the enumerator was created. </exception>
    void IEnumerator.Reset()
    {
        _enumeration.Reset();
    }

    /// <summary>
    /// IAssemblyName is a Fusion interface
    /// Gets the element in the collection at the current position of the enumerator.
    /// </summary>
    /// <value></value>
    /// <returns>The element in the collection at the current position of the enumerator.</returns>
    public IAssemblyName Current
    {
        get
        {
            return _enumCurrentAssembly;
        }
    }
    // Properties
    object IEnumerator.Current
    {
        // Go to the other darn Current not this one
        get
        {
            return Current;
        }
    }
    // Fields
    public void Dispose()
    {
        _enumCurrentAssembly = null;
    }

    #endregion

    internal static void HandleCom(int hResult)
    {
        if (hResult < 0)
            Marshal.ThrowExceptionForHR(hResult);
    }
}

[Flags]
enum AssemblyCacheFlags
{
    NGenCache = 0x1,
    GAC = 0x2,
    DownloadCache = 0x4
}

[Flags]
public enum AssemblyNameDisplayFlags
{
    VERSION = 0x01,
    CULTURE = 0x02,
    PUBLIC_KEY_TOKEN = 0x04,
    PROCESSORARCHITECTURE = 0x20,
    RETARGETABLE = 0x80,
    ALL = VERSION |
        CULTURE | PROCESSORARCHITECTURE |
        PUBLIC_KEY_TOKEN | RETARGETABLE
}

More to Come

This is the tip of the iceberg so to speak. Here is a test case to show you what this now is doing and perhaps you can give us ideas where to take it. There is a lot of code. Should it be up on CodePlex? Google Code? Your Environment Variables:

       [Fact]
        public void should_show_my_env()
        {
            var sw = Stopwatch.StartNew();
            var dirs = from env in ThisBox.By<EnvironmentVariable>()
                       select env;
            foreach (var s in dirs)
            {
                Console.WriteLine(s.TypeOfEnv + " " + s.KeyName);
                Console.WriteLine("  ==>" + s.Value);
            }
            Console.WriteLine("Count : " + dirs.Count());
            Console.WriteLine("Search Took : " + sw.ElapsedMilliseconds + " ms");
            sw.Stop();
        }

Let’s join our GAC with our registry!

NOTE: we get 592 hits in 20 or so seconds…

        [Fact]
        public void should_join_policy_registry_section()
        {
            var sw = Stopwatch.StartNew();

            var result = from
                             gac in ThisBox.By<AssemblyDetail>()
                         join
                             registryKey in ThisBox.By<RegistryKey>() 

                         on gac.MajorName equals registryKey.FirstRegValue()

                         select new
                                {
                                        gac, RegVal=registryKey.FirstRegValue()
                                };

            Console.WriteLine("Count : " + result.Count());
            sw.Stop();
            foreach (var a in result)
            {
                Console.WriteLine(a.gac.MajorName + " == " + a.RegVal);
                Console.WriteLine(" ==>" + a.gac.FullName);
            }

            Console.WriteLine("Search Took : " + sw.ElapsedMilliseconds + " ms");
        }

Appendix : A Few Extension Methods we Use

  static class LinqProviderTestExtensions
    {
        /// <summary>
        /// Will perform each action for each
        /// 'row' in the included collection
        /// Each 'row' is of Type TTreeNode
        /// Will typically only be one action
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="items"></param>
        /// <param name="actions"></param>
        static internal void ForEach<T>(this IEnumerable<T> items, params Action<T>[] actions)
        {
            foreach (var t in items)
                foreach (var act in actions)
                    act.Invoke(t);
        }

        public static string FirstRegValue(this RegistryKey registryKey)
        {
            return registryKey.ValueCount > 0
                           ? (string) registryKey.GetValueNames().GetValue(0) : String.Empty;
        }

        public static double ToPercent(this int target, int total)
        {
            return target.ToPercent((double) total);
        }

        public static String ToPctString(this int target, int total)
        {
            return target.ToPercent((double) total) + "%";
        }

        public static double ToPercent(this int target, double total)
        {
            return Math.Round((target/total)*100, 2);
        }
    }

A huge Thanks:

Debasish Bose

del.icio.us Tags: Advanced C#,C# Unmanaged Wrapper,Fusion,GAC,Global Assembly Cache,IEnumerable,IEnumerator,Internals,Lambada,Linq to Gac,Linq to Objects,Machine,Registry
Technorati Tags: Advanced C#,C# Unmanaged Wrapper,Fusion,GAC,Global Assembly Cache,IEnumerable,IEnumerator,Internals,Lambada,Linq to Gac,Linq to Objects,Machine,Registry

Related Posts

Hi found a nice way to search a word or phrase within a file, so thought of sharing with you all.

string DirPath = Application.StartupPath + "\Search\";
string SearchText = "Temp";
string[] Files = (from file in new DirectoryInfo(DirPath).GetFiles()
                     where new StreamReader(file.FullName).ReadToEnd().Contains(SearchText)
                     select file.Name).ToArray<string>();

Download Sample – 21 kb

If you know a better way, please post a comment.

Happy Learning

The difference between select and selectMany can be seen when we are accessing data from multilevel classes.

Download Sample Code – 2.62 Kb

In the below example we shall see what exactly is the difference while accessing the properties.

When we access some data by using select it gives us the data that is grouped under the parent (i.e gives multiple arrays). To access the output we need to loop twice.

////This code shows how to use Select()             
var Query2 = Builders.Select(Build => Build.Locations);

// Notice that two foreach loops are required to iterate through
// the results because the query returns a collection of arrays.            
foreach (List<String> BuildList in Query2)
{
        foreach (string builds in BuildList)
        {
                Console.WriteLine(builds);
        }

        Console.WriteLine();
}

But using the same sample when we use select many it gives the selected items in one array(i.e it give the output as it is joining all the output from select command)

// Query using SelectMany().            
var query1 = Builders.SelectMany(Build => Build.Locations);

// Only one foreach loop is required to iterate through the
// results because it is a one-dimensional collection.
// Select many joins the output of all the sub collections in to one.            
foreach (string Loc in query1)
        Console.WriteLine(Loc);

Output:

Difference Select and SelectMany

Happy learning

I was just thinking where and all linq can be used, surpirsingly i found that whatever i thought to do i was able to implement linq to make it much better.

Firstly i thought how linq can be used with file system and check what i got.

LINQ to System Files:

Here i made a sample which will search the files from system directory and list the files that are of .dll extension and have size greater than 100000 bytes

string DirPath = System.Environment.GetFolderPath(Environment.SpecialFolder.System);
string[] Files = (from file in new DirectoryInfo(DirPath).GetFiles()
                     where file.Extension == ".dll" && file.Length > 1000000
                     select file.Name).ToArray<string>();

Next i thought how linq can be used with processes

LINQ to system Processes:

Here we shall see how a running process can be handled using LINQ. This sample will list all the processes that are currently running and order them in ascending order of the memory taken

var ProcInfo = from proc in Process.GetProcesses()
       orderby proc.PagedMemorySize64
       select new { Name = proc.ProcessName , Memory = proc.PagedMemorySize64};

Download sample – 24 kb

So people just keep thinking where all you can utilize linq and you will get more creatives ways to use it.

Happy learing

I had many confusions when i used linq for the first time. For each function i searched its usage and then used it. It was pretty time consuming. So i decided to make a sample that will explain almost all linq functions at one place.

Here comes the sample.
Download sample – 45.2Kb

int[] arrNumbers1 = { 1, 4, 8, 4, 15, 12, 15};
int[] arrNumbers2 = { 2, 9, 3, 5, 8, 18, 15 };

//********Aggregate**********
//The LINQ aggregate operators allow you to perform simple math
//operations over the elements in a collection in a sequence

//1.Take min of the elements in a collection
int ArrgrNum = arrNumbers2.Aggregate((s, t) => Math.Min(s, t));

//2.Lets reverse a string
string sentence = "I went with her for a walk in evening";
// Split the string into individual words.
string[] words = sentence.Split(' ');
// Join each word to the beginning of the new sentence to reverse the word oder.
string reverse = words.Aggregate((CurrentWord, next) => next + " " + CurrentWord);
Console.WriteLine(reverse);

//3.Lets check with an example to find the factorial of a given Number.
int N = 5;
IEnumerable intSequence = Enumerable.Range(1, N);
int agg = intSequence.Aggregate((av, e) => av * e);
Console.WriteLine("{0}! = {1}", N, agg);

//*********ALL*****************
//All<> does not return a list of the items in the collection.
//It returns a bool indicating if all the items in the list match an expression.

//We will first check whether all NO's in the array are even or not
var AllEven = arrNumbers1.All(temp => temp % 2 == 0);

//Here we check all the numbers in the array are greater than 1 or not
var AllGreater = arrNumbers2.All(Greater => Greater > 1);

//********Any*****************
//Any is reverse of All, it checks like "If any element satisfies the condition return true"
var AnyEven = arrNumbers1.Any(temp => temp % 2 == 0);

//******Average*********
var AvgNum =  arrNumbers1.Average();

//conditional avereage
//This takes the average of all elemets in an array whose value are greater than 8
//If less then it will replace it with 8 and take the average
var AvgOther = arrNumbers1.Average(temp => temp > 8 ? temp : 8);

//********Cast***********
var strArray =  arrNumbers1.Cast();

//********Concat********
//Concatenates both the array
var ConcatArr = arrNumbers2.Concat(arrNumbers1);

//*********Contains******
bool hasElement = arrNumbers1.Contains(2);

//*********Distinct*********
//Removes the duplicates and returns only distinct elements
int[] DistinctOnly = arrNumbers1.Distinct().ToArray();

//*********ELement at********
//Returns Element at give index
var ElementAt = arrNumbers2.ElementAt(3);

//ElementAtOrDefault
//returns the element if its present at the given index
//Or returns its default eg: int 0, stirng empty
var ElementAtOrDef = arrNumbers2.ElementAtOrDefault(15);

//*********Except eg***********
//Selects the elements other than the specified in parameter
var ExceptEg = arrNumbers2.Except(arrNumbers1);
var ExceptEg1 = arrNumbers1.Except(Enumerable.Range(1,5));

//*********First*********
//Returns the first element that matches the condition
var FirstEle = arrNumbers1.First(temp => temp > 8);

//********FirstOrDefault******
//Returns the first element that matches the condition or
//returns the default value
var FirstOrDef = arrNumbers1.FirstOrDefault(temp => temp > 15);

//******GetValue*********
//Gets value of the element at given Index
var GetValuesAtIndex = arrNumbers1.GetValue(3);

//*********Intersect**********
//Returns the elements those are comman in both the arrays
var IntersectOfBoth = arrNumbers1.Intersect(arrNumbers2);

//********Last***********
//Gives the last element matching the condition specified in the parameter
var Last = arrNumbers2.Last(temp => temp > 6);

//*********LastOrdefault********
//Gives the last element matching the condition specified in the parameter
//If not found then returns the default value
var LastOrDef = arrNumbers2.LastOrDefault(temp => temp > 150);

//***********MAX**********
//Returns the max element in the collection
var MaxEle = arrNumbers2.Max();

//**********MIN***********
//Returns the min element in the collection
var MinEle = arrNumbers2.Min();

//********OrderBy**********
//Orders the list in ascending order
var OrderBY = arrNumbers2.OrderBy(x => x);

//****OrderByDescending******
//ORders the list in Descendig order
var DscArray = arrNumbers2.OrderByDescending(x => x);

//********Reverse**********
//Reverses the list
var ReverseArr = arrNumbers2.Reverse();

//********Select***********
//Selects the element that satisfies the given condition
//here we will select all elements as power of 2
var SelectArr = arrNumbers2.Select(ele => Math.Pow(2,ele));

//*********SequenceEqual******
//If both the arrays are equal return true else return false
bool AreEqual = arrNumbers2.SequenceEqual(arrNumbers1);

//********Set Value**********
//Sets the given value to the element in the collection at given index
arrNumbers1.SetValue(100, 2);

//**********Single*************
//Returns the index of the element whose value is equal to the given parameter
//If it has 0 or 2 elements with same value then it gives an error.
int SingleIndex = arrNumbers1.Single(imp => imp == 1);

//*********SingleDefault**********
//Returns the index of the element whose value is equal to the given parameter
//If no element with the given value then it returns the default
int SingleDef = arrNumbers1.SingleOrDefault(imp => imp == 10);

//**********Skip*********
//Skip first 3 elements and returs other elements
var SkipFirstElements = arrNumbers2.Skip(3);

//*********SkipWhile********
//Here in this sample we will extract only those no that are
//divisible by 3
var SkipConditional = arrNumbers1.SkipWhile(num => num % 3 != 0);

//********Sum***********
//Get the sum of an array
var SumOfArray = arrNumbers1.Sum();

//*********Take*********
//Its just the reverse operation of skip
//here it takes the first n elements specified in the parameter
var Take = arrNumbers2.Take(3);

//*********TakeWhile*********
//Takes only those elements that are not divisible by 3
var TakeWhile = arrNumbers2.TakeWhile(num => num % 3 != 0);

//*********ToArray***********
//converts the IEnumerable ouput an array of type specified in T
int[] IntArray = arrNumbers1.Take(3).ToArray();

//********Union***********
//Union of both the arrays - only unique
int[] UnionOfBoth = arrNumbers1.Union(arrNumbers2).ToArray();

//**********Where***********
//Select elements those are greater than 5
int[] GreaterThan5 = arrNumbers2.Where(x => x > 5).ToArray();

Any suggestions are wide open.

Happy learning

What is LINQ??

LINQ stand for Language-Integrated Query is now available as a integral part of Visual Studio 2008.

LINQ has a great power of querying on any source of data, data source could be the collections of objects, database or XML files. We can easily retrieve data from any object that implements the IEnumerable<T> interface. Microsoft basically divides LINQ into three areas and that are give below.

• LINQ to Object
• LINQ to ADO.Net
  • LINQ to SQL
  • LINQ to Dataset
  • LINQ to Entities
• LINQ to XML 

Basics samples of LINQ:

http://msdn.microsoft.com/en-us/vcsharp/aa336746.aspx

 

Assuming you know the basics of LINQ I will continue with a bit high end sample lets move further with an example of a company.

 

The Company Sample

Downloads:

Download complete Project (56.66kb)

Here we will see how a linq can be utilized in a company module. The company class will contain a Collection of employee class and employee will contain a struct for individual addresses.

 Hierarchy:

Company Hierarchy

If we have a project with above hierarchy, let’s see how we can use LINQ to access details from multilevel classes. After creation of companies we will try to find the details at multilevel and see how conditionally data can be fetched.
1)  List details of employees
2)  Count no of employees in each company
3)  List employees who are staying in Bangalore
4)  List employee who is paid highest in each companies
5)  Overall Highest paid employee
6)  Salary paid by companies in each city
7)  Salary paid by each company in each city.

List details of employees:
Now we shall list all the employees with their details and company name.

Var EmpDetails = from comp in ListCompany
select new
{
Emp = (from emp in comp.ListEmp
select new { Company = comp.Name, emp })
};

Here we use sub queries since we need all employee details with their respective company name and both the details are at different levels. So first we Loops through the companies in the company list from comp in ListCompany and then within each selected company it loops through each employee from emp in comp.ListEmp Count no of employees in each company:

var LessEmp = from Comp in ListCompany 
select new{Comp.Name, EmpCount = Comp.ListEmp.Count };

List employees who are staying in Bangalore: Here we use compound from clause to retrieve the employees who are staying in any city that contains BAN or ban.

var EmpInACity = from comp in ListCompany from emplist in comp.ListEmp 
where emplist.Address.City.ToUpper().Contains("BAN") 
select new { CompName = comp.Name, EmployeeName = emplist.Name };

List employee who is paid highest in each companies: For finding the highest paid employee we first loop through all the companies and employees in each company using compound from clause. Where condition filters only those employees those have the salary equal to the max salary in current company.

Var EmpHighSal = from comp in ListCompany 
from empHigh in comp.ListEmp 
where empHigh.salary == comp.ListEmp.Max(HighEmp => HighEmp.salary) 
select new { CompanyName = comp.Name, EmpHighName = empHigh.Name, 
EmpHighSal = empHigh.salary }; 

Overall Highest paid employee: The same above procedure is followed but the only difference comes in the where condition where we match the employee’s salary to the max salary from all the companies.

var EmpHighSal = from comp in ListCompany
from emp in comp.ListEmp where emp.salary == 
ListCompany.Max(TComp => TComp.ListEmp.Max(HighEmp => HighEmp.salary))
select new { CompanyName = comp.Name , EmployeeName = emp.Name, 
EmpSal = emp.salary };

Salary paid by companies in each city: Here we will group by city and sum up all the salaries of the employees who are staying in that city.

var CompanyCityWise = from comp in ListCompany 
from emp in comp.ListEmp group emp by emp.Address.City into CityWiseEmp 
select new { State = CityWiseEmp.Key, 
TotalSalary = CityWiseEmp.Sum(emp => emp.salary)};
 

Salary paid by each company in each city. Here for each company a group by clause is applied and from each company employees staying at different locations are fetched.

var CityWiseSalary = from comp in ListCompany
select new
{comp.Name, Emp =(from emp in comp.ListEmp 
group emp by emp.Address.City into CityWiseEmp 
select new { State = CityWiseEmp.Key, 
TotalSalary = CityWiseEmp.Sum(emp => emp.salary) })};

 
Next >> LINQ with best example – 2

More references on LINQ: Standard Query Operators in a Nutshell: http://msdn.microsoft.com/en-us/library/bb308959.aspx#linqoverview_topic8 More LINQ: http://msdn.microsoft.com/en-us/library/bb397676.aspx

Happy learning

More accurately called ..‘Variance and Generalized Constraints for C# Generics’) (1)

An item we often see teams ‘leaving money on the table’ with is a failure to leverage (or leverage fully) generic type constraints. Now with Linq you cannot get away with it anymore as for now, although far more powerful, there are still long lines of complex generic delegate types to navigate.

This post based on the docs from MSDN, however we’ve added some significant teeth we believe (with more to come) We at least made this potentially more ‘real world’ in complexity.

By constraining the type parameter, you increase the number of allowable operations and

method calls to those supported by the constraining type and all types in its inheritance hierarchy. Therefore, when you design generic classes or methods, if you will be performing any operation on the generic members beyond simple assignment or calling any methods not supported by System.Object, you will have to apply constraints to the type parameter.

When applying the where T : class constraint, avoid the == and != operators on the type parameter because these operators will test for reference identity only, not for value equality. This is the case even if these operators are overloaded in a type that is used as an argument. The following code illustrates this point; the output is false even though the String class overloads the == operator.

public static void OpTest<T>(T s, T t) where T : class {

       System.Console.WriteLine(s == t);

}

 static void Main() {

           string s1 = “foo”;

            var sb = new System.Text.StringBuilder(“foo”);

            string s2 = sb.ToString();

            OpTest<string>(s1, s2);

}

The reason for this behavior is that, at compile time, the compiler only knows that T is a reference type, and therefore must use the default operators that are valid for all reference types. If you must test for value equality, the recommended way is to also apply the where T : IComparable<T> constraint and implement that interface in any class that will be used to construct the generic class.

In the previous example, T is a naked type constraint in the context of the Add method, and an unbounded type parameter in the context of the List class.

Naked type constraints can also be used in generic class definitions. Note that the naked type constraint must also have been declared within the angle brackets together with any other type parameters:

//naked type constraint

public class SampleClass<T, U, V> where T : V { }

The usefulness of naked type constraints with generic classes is very limited because the

compiler can assume nothing about a naked type constraint except that it derives from System.Object. Use naked type constraints on generic classes in scenarios in which you want to enforce an inheritance relationship between two type parameters.

Burak Emir1, Andrew Kennedy2, Claudio Russo2, and Dachuan Yu3

1 EPFL, Lausanne, Switzerland

2 Microsoft Research, Cambridge, U.K.

3 DoCoMo Communications Laboratories USA, San Jose, California

Su Msdn è presente questa risorsa molto utile per capire Linq, orientato all’ utilizzo con gli Object.