Showing posts with label LINQ to Objects. Show all posts
Showing posts with label LINQ to Objects. Show all posts

2008-07-14

LINQ to Objects und DataBinding mit DataGridView

Ein Leser von meinem Buch LINQ hat mir die Frage gestellt, wie er mit LINQ to Objects erstellte Objekte (Objects) in einem DataGridView Control auflisten kann.

Beispiel (Sample) 1

Im Beispiel-Code haben wir die Klasse (Class) Person zwei Public Felder (Fields) mit dem Namen Age und Name.

public class Person
{
public int Age;
public string Name;
}



Als nächstes erstellen wir unsere Daten wie folgt:




List<Person> firends = new List<Person>();

Person friend1 = new Person();
friend1.Name = "Hans";
friend1.Age = 38;
firends.Add(friend1);

Person friend2 = new Person();
friend2.Name = "Karin";
friend2.Age = 26;
firends.Add(friend2);



Bevor wird die Daten (friends) an die DataSource-Eigenschaft (Property) des DataGridView-Controls zuweisen, ist es wichtig, dass die gewünschten Felder mit Hilfe einer Abfrage bestimmt werden.




var friend = from f in friends
select new { f.Age, f.Name };



Durch die Verwendung der ToList() Methode werden unsere Daten DataGridView-Control tauglich.




this.dataGridView1.AutoGenerateColumns = true;
this.dataGridView1.DataSource = friend.ToList();



Nach der Zuweisung werden die Daten automatisch im Control aufgelistet.image



Den kompletten Source-Code findet Ihr wie folgt:




using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows.Forms;

namespace LinqToObjectsDataGridView
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}

private void btnShowData_Click(object sender, EventArgs e)
{
List<Person> friends = new List<Person>();

Person friend1 = new Person();
friend1.Name = "Hans";
friend1.Age = 38;
friends.Add(friend1);

Person friend2 = new Person();
friend2.Name = "Karin";
friend2.Age = 26;
friends.Add(friend2);

var qry = from f in friends
select new { f.Age, f.Name };

this.dataGridView1.AutoGenerateColumns = true;
this.dataGridView1.DataSource = qry.ToList();
}
}

public class Person
{
public int Age;
public string Name;
}
}



Beispiel (Sample) 2



Wenn Sie die Getter-und-Setter in Ihrer Klasse verwenden, dann müssen Sie die Namen der Felder nicht explizit definieren.




public class PersonExtended
{
private int _Age;
public int Age
{
get { return _Age; }
set { _Age = value; }
}

private string _Name;
public string Name
{
get { return _Name; }
set { _Name = value; }
}
}



Die Abfrage sieht in diesem Beispiel wie folgt aus:




IEnumerable<PersonExtended> qry = from f in friends
select f;



Und anschließend die Zuweisung an die DataSource-Eigenschaft:




this.dataGridView1.AutoGenerateColumns = true;
this.dataGridView1.DataSource = qry.ToList();



Als Resultat erhalten wir die gleichen Einträge:



image



Source-Code sieht wie folgt aus:




using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows.Forms;

namespace LinqToObjectsDataGridView
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}

private void btnShowData_Click(object sender, EventArgs e)
{
List<PersonExtended> friends = new List<PersonExtended>();
PersonExtended friend1 = new PersonExtended();
friend1.Name = "Hans";
friend1.Age = 38;
friends.Add(friend1);

PersonExtended friend2 = new PersonExtended();
friend2.Name = "Karin";
friend2.Age = 26;
friends.Add(friend2);

IEnumerable<PersonExtended> qry = from f in friends
select f;

this.dataGridView1.AutoGenerateColumns = true;
this.dataGridView1.DataSource = qry.ToList();
}
}

public class PersonExtended
{
private int _Age;
public int Age
{
get { return _Age; }
set { _Age = value; }
}

private string _Name;
public string Name
{
get { return _Name; }
set { _Name = value; }
}
}
}



Das komplette ZIP-File mit Source findet Ihr unter: LinqToObjectsDataGridView



Viel Spaß...

2008-01-02

Network Adapter Configuration mit LINQ ermitteln

Die ManagementClass unter dem Namespace System.Management kann für die Ermittlung von System-Informationen verwendet werden. Im folgenden Beispiel werden ein paar Network Adapter Configuration-Informationen mithilfe der ManagementClass und LINQ ermittelt.

Für das folgende Beispiel müssen Sie die System.Management.dll Assembly als Referenz in Ihrem Projekt hinzufügen.

using System;
using System.Linq;
using System.Management;

namespace MacAddress
{
class Program
{
static void Main(string[] args)
{
ManagementClass mc
= new ManagementClass("Win32_NetworkAdapterConfiguration");
ManagementObjectCollection moc
= mc.GetInstances();

ManagementObject[] managementObjs
= new ManagementObject[moc.Count];
moc.CopyTo(managementObjs,
0);

var qry
= from mo in managementObjs
where ((bool)((ManagementObject)mo)["IPEnabled"]) == true
select
new
{
IPAddress
= ((ManagementObject)mo)["IPAddress"],
MacAddress
= ((ManagementObject)mo)["MacAddress"],
DHCPServer
= ((ManagementObject)mo)["DHCPServer"]
};

foreach (var netwAdaptConf in qry)
{
foreach (string ip in (string[])netwAdaptConf.IPAddress)
{
Console.WriteLine(
"IPAddress : " + ip);
}

Console.WriteLine(
"MacAddress: " + netwAdaptConf.MacAddress.ToString());
Console.WriteLine(netwAdaptConf.DHCPServer
!= null ? "DHCPServer: " + netwAdaptConf.DHCPServer.ToString() : "DHCPServer:");

Console.WriteLine(
"");
}

Console.ReadLine();
}
}
}

2007-12-30

File System-Berechtigungen mit LINQ ermitteln

Sie können LINQ to Objects für die Auswertung von Collections verwenden, die den IEnumerable<> Interface implementieren. Im .NET Framework implementieren viele Collections den nötigen Interface und das gibt uns Entwickler die Möglichkeit, diese collections mit Hilfe vom LINQ to Objects auswerten zu können.

Mit dem folgenden Beispielcode können die Berechtigungen einer Datei ermittelnt und mit LINQ-Abfragen ausgewertet werden.

Die Informationen für die Berechtigungen werden mit Standard Klassen und Methoden des .NET Frameworks ermittelt.

using System;
using System.IO;
using System.Linq;
using System.Security.AccessControl;
using System.Security.Principal;

namespace ConsoleApplication3
{
class Program
{
static void Main(string[] args)
{
string directory = @"C:\AUTOEXEC.BAT";
WindowsIdentity winIdentity
= WindowsIdentity.GetCurrent();

DirectorySecurity directorySec
= Directory.GetAccessControl(directory, AccessControlSections.Access);
AuthorizationRuleCollection authorizationRuleCol
= directorySec.GetAccessRules(true, true, typeof(SecurityIdentifier));

FileSystemAccessRule[] fileSystemAccRule
= new FileSystemAccessRule[authorizationRuleCol.Count];
authorizationRuleCol.CopyTo(fileSystemAccRule,
0);

var qry
= from rule in fileSystemAccRule
where (winIdentity.User == rule.IdentityReference || winIdentity.Groups.Contains(rule.IdentityReference))
select
new
{
Directory
= directory,
NTAccount
= new SecurityIdentifier(rule.IdentityReference.ToString()).Translate(typeof(NTAccount)),
AccessControltype
= rule.AccessControlType,
AppendData
= (((int)FileSystemRights.AppendData & (int)rule.FileSystemRights) == (int)FileSystemRights.AppendData),
ChangePermissions
= (((int)FileSystemRights.ChangePermissions & (int)rule.FileSystemRights) == (int)FileSystemRights.ChangePermissions),
CreateDirectories
= (((int)FileSystemRights.CreateDirectories & (int)rule.FileSystemRights) == (int)FileSystemRights.CreateDirectories),
CreateFiles
= (((int)FileSystemRights.CreateFiles & (int)rule.FileSystemRights) == (int)FileSystemRights.CreateFiles),
Delete
= (((int)FileSystemRights.Delete & (int)rule.FileSystemRights) == (int)FileSystemRights.Delete),
DeleteSubdirectoriesAndFiles
= (((int)FileSystemRights.DeleteSubdirectoriesAndFiles & (int)rule.FileSystemRights) == (int)FileSystemRights.DeleteSubdirectoriesAndFiles),
ExecuteFile
= (((int)FileSystemRights.ExecuteFile & (int)rule.FileSystemRights) == (int)FileSystemRights.ExecuteFile),
FullControl
= (((int)FileSystemRights.FullControl & (int)rule.FileSystemRights) == (int)FileSystemRights.FullControl),
ListDirectory
= (((int)FileSystemRights.ListDirectory & (int)rule.FileSystemRights) == (int)FileSystemRights.ListDirectory),
Modify
= (((int)FileSystemRights.Modify & (int)rule.FileSystemRights) == (int)FileSystemRights.Modify),
Read
= (((int)FileSystemRights.Read & (int)rule.FileSystemRights) == (int)FileSystemRights.Read),
ReadAndExecute
= (((int)FileSystemRights.ReadAndExecute & (int)rule.FileSystemRights) == (int)FileSystemRights.ReadAndExecute),
ReadAttributes
= (((int)FileSystemRights.ReadAttributes & (int)rule.FileSystemRights) == (int)FileSystemRights.ReadAttributes),
ReadData
= (((int)FileSystemRights.ReadData & (int)rule.FileSystemRights) == (int)FileSystemRights.ReadData),
ReadExtendedAttributes
= (((int)FileSystemRights.ReadExtendedAttributes & (int)rule.FileSystemRights) == (int)FileSystemRights.ReadExtendedAttributes),
ReadPermissions
= (((int)FileSystemRights.ReadPermissions & (int)rule.FileSystemRights) == (int)FileSystemRights.ReadPermissions),
Synchronize
= (((int)FileSystemRights.Synchronize & (int)rule.FileSystemRights) == (int)FileSystemRights.Synchronize),
TakeOwnership
= (((int)FileSystemRights.TakeOwnership & (int)rule.FileSystemRights) == (int)FileSystemRights.TakeOwnership),
Traverse
= (((int)FileSystemRights.Traverse & (int)rule.FileSystemRights) == (int)FileSystemRights.Traverse),
Write
= (((int)FileSystemRights.Write & (int)rule.FileSystemRights) == (int)FileSystemRights.Write),
WriteAttributes
= (((int)FileSystemRights.WriteAttributes & (int)rule.FileSystemRights) == (int)FileSystemRights.WriteAttributes),
WriteData
= (((int)FileSystemRights.WriteData & (int)rule.FileSystemRights) == (int)FileSystemRights.WriteData),
WriteExtendedAttributes
= (((int)FileSystemRights.WriteExtendedAttributes & (int)rule.FileSystemRights) == (int)FileSystemRights.WriteExtendedAttributes)
};

bool canAppendData = (from rule in qry where rule.AccessControltype == AccessControlType.Allow && rule.AppendData == true select rule).Any();
bool canChangePermissions = (from rule in qry where rule.AccessControltype == AccessControlType.Allow && rule.ChangePermissions == true select rule).Any();
bool canCreateDirectories = (from rule in qry where rule.AccessControltype == AccessControlType.Allow && rule.CreateDirectories == true select rule).Any();
bool canCreateFiles = (from rule in qry where rule.AccessControltype == AccessControlType.Allow && rule.CreateFiles == true select rule).Any();
bool canDelete = (from rule in qry where rule.AccessControltype == AccessControlType.Allow && rule.Delete == true select rule).Any();
bool canDeleteSubdirectoriesAndFiles = (from rule in qry where rule.AccessControltype == AccessControlType.Allow && rule.DeleteSubdirectoriesAndFiles == true select rule).Any();
bool canExecuteFile = (from rule in qry where rule.AccessControltype == AccessControlType.Allow && rule.ExecuteFile == true select rule).Any();
bool canFullControl = (from rule in qry where rule.AccessControltype == AccessControlType.Allow && rule.FullControl == true select rule).Any();
bool canListDirectory = (from rule in qry where rule.AccessControltype == AccessControlType.Allow && rule.ListDirectory == true select rule).Any();
bool canModify = (from rule in qry where rule.AccessControltype == AccessControlType.Allow && rule.Modify == true select rule).Any();
bool canRead = (from rule in qry where rule.AccessControltype == AccessControlType.Allow && rule.Read == true select rule).Any();
bool canReadAndExecute = (from rule in qry where rule.AccessControltype == AccessControlType.Allow && rule.ReadAndExecute == true select rule).Any();
bool canReadAttributes = (from rule in qry where rule.AccessControltype == AccessControlType.Allow && rule.ReadAttributes == true select rule).Any();
bool canReadData = (from rule in qry where rule.AccessControltype == AccessControlType.Allow && rule.ReadData == true select rule).Any();
bool canReadExtendedAttributes = (from rule in qry where rule.AccessControltype == AccessControlType.Allow && rule.ReadExtendedAttributes == true select rule).Any();
bool canReadPermissions = (from rule in qry where rule.AccessControltype == AccessControlType.Allow && rule.ReadPermissions == true select rule).Any();
bool canSynchronize = (from rule in qry where rule.AccessControltype == AccessControlType.Allow && rule.Synchronize == true select rule).Any();
bool canTakeOwnership = (from rule in qry where rule.AccessControltype == AccessControlType.Allow && rule.TakeOwnership == true select rule).Any();
bool canTraverse = (from rule in qry where rule.AccessControltype == AccessControlType.Allow && rule.Traverse == true select rule).Any();
bool canWrite = (from rule in qry where rule.AccessControltype == AccessControlType.Allow && rule.Write == true select rule).Any();
bool canWriteAttributes = (from rule in qry where rule.AccessControltype == AccessControlType.Allow && rule.WriteAttributes == true select rule).Any();
bool canWriteData = (from rule in qry where rule.AccessControltype == AccessControlType.Allow && rule.WriteData == true select rule).Any();
bool canWriteExtendedAttributes = (from rule in qry where rule.AccessControltype == AccessControlType.Allow && rule.WriteExtendedAttributes == true select rule).Any();

Console.ReadLine();
}
}
}

2007-12-03

LINQ

LINQ ist die Abkürzung für Language Integrated Query.

Im Jahr 2002 wurde das .NET Framework V1.0 und Visual Studio 2002 als Entwicklungsumgebung vorgestellt. In der Zwischenzeit hat das .NET Framework mehrere Versionen hinter sich und wir Entwickler haben mit jeder Version unsere Erfahrungen gemacht.

Die neueste .NET Framework Version 3.5 und die Entwicklungsumgebung Visual Studio 2008 ist hier und wird uns Entwickler bei der Entwicklung von neuen Softwareprodukten unterstützen.

Die Version 1.0 hat eine kurze Lebensdauer hinter sich. Fast ein Jahr später wurde bereits die Version 1.1 mit Visual Studio 2003 veröffentlicht. Die Verbesserungen und Erweiterungen zwischen den beiden Versionen waren nicht sehr groß.

Im Jahre 2005 veröffentlichte Microsoft die Version 2.0 des .NET Frameworks mit Visual Studio 2005, die bisher aktuellste Versionen waren.

Die Version 3.0 wurde im Jahr 2006 veröffentlich und beinhaltete die neue Technologie wie WCF, WPF und WF.

Mit jeder Version wurde das .NET Framework erweitert und die Erweiterungen haben uns Entwickler geholfen, effizienter zu arbeiten.

November 2007 war es soweit für die neueste Version des .NET Frameworks. Die Version 3.5 mit der Visual Studio 2008 wird vom Microsoft in englischer Version veröffentlicht.

.NET Framework 3.5 bringt auch neue Spracherweiterungen mit sich. Die Programmiersprachen C# 3.0 und Visual Basic 9.0 sind mit neuen Sprachfeatures ausgestattet. Diese Spracherweiterungen waren für eine vollständige Unterstützung von LINQ notwendig.

Eine von den wichtigsten Erneuerungen im .NET Framework 3.5 ist das LINQ.

LINQ ermöglicht die Integration von SQL ähnlichen Anweisungen (LINQ-Abfragen) direkt in den Quelltext. Diese Integration vereinfacht den Zugang zu den relationalen Daten und XML-Dokumenten. Auch die Collections können mit Hilfe von LINQ-Abfragen einfacher ausgewertet werden als bisher.

LINQ steht mit dem .NET Framework 3.5 für die .NET Programmiersprachen zur Verfügung. Die .NET Programmiersprachen mussten mit neuen Sprachfeatures erweitert werden, damit sie die LINQ-Implementierung einsetzen können. Die meist verbreiteten.NET Sprachen C# und Visual Basic wurden für die Verwendung vom LINQ mit diesen neuen Features erweitert.

In dieser Version unterstützt LINQ als Datenquelle den SQL Server, XML-Dokumente und die .NET-Objekte. Damit ein .NET-Objekt als Datenquelle verwendet werden kann, muss das Objekt das IEnumerable-Interface implementieren. Die Architektur von LINQ ist in der folgende Darstellung ersichtlich.

C# 3.0

Visual Basic 9.0

Andere .NET Sprachen

.NET Language Integrated Query

Datenquellen

LINQ to SQL

LINQ to XML

LINQ to Objects

Relationale Daten

SQL Server

XML

Objekte

LINQ unterstützt nicht nur den SQL Server, XML-Dateien und Objekte als Datenquelle. Mit einem spezifischen LINQ Provider kann eine beliebige Datenquelle LINQ fähig gemacht werden.

Es sind bereits mehrere Projekte vorhanden, in denen für verschiedene Datenquellen LINQ-Providers realisiert werden. Die bekannteste von diesen Projekten sind Active Directory, LDAP, SharePoint und Flickr LINQ Providers.

2007-10-31

Query Operatoren

Die Query-Operatoren lassen sich grob in die folgenden Kategorien gliedern.

Restriktionsoperator
Where

Projektionsoperatoren
Select
SelectMany

Aufteilungsoperatoren
Skip
SkipWhile
Take
TakeWhile

Join-Operatoren
GroupJoin
Join

Konkatinierungsoperator
Concat

Sortieroperatoren
OrderBy (descending)
ThenBy (descending)
Reverse

Gruppierungsoperatoren
GroupBy

Set-Operatoren
Set
Distinct
Except
Intersect
Union

Konvertierungsoperatoren
AsEnumerable
AsQueryable
Cast
ToArray
ToDictionary
ToList
ToLookup

Vergleichsoperatoren
SequenceEqual

Elementoperatoren
ElementAt
ElementAtOrDefault
First
FirstOrDefault
Last
LastOrDefault
Single
SingleOrDefault
DefaultIfEmpty

Generierungsoperatoren
Empty
Range
Repeat

Quantifizierungsoperatoren
All
Any
Contains

Aggregatoperatoren
Aggregate
Average
Count
LongCount
Max
Min
Sum

Andere
Like (StartWith)

2007-10-17

Array als Datenquelle

Der Typ Array implementiert die Interface IEnumerable und dadurch können wir einen Array als Datenquelle für unsere LINQ-Abfragen verwenden.

Mit einem einfachen Beispiel sehen wir, wie ein Array als Datenquelle verwendet werden kann.

Als nächstes definieren wir einen Array von Integer-Werten, welches wir bei unserem Beispiel als Datenquelle verwenden werden.

Der folgende Array beinhaltet die Zahlen 0 bis 9.

int[] integers = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };

Den Inhalt dieses Integer-Arrays können wir mit Hilfe einer LINQ-Abfrage wie folgt selektieren:

var qry = from i in integers select i;

oder

var qry2 = integers.Select(i => i);

Als Resultat erhalten wir in der qry-Variable die Zahlen 0 bis 9, weil wir keine Filterbedingung in der LINQ-Abfrage definieren haben.

Den folgenden Code können Sie mit einem Console-Application Projekt laufen lassen.

using System;
using System.Linq;
namespace LinqToObjectsSample
{
class Program
{
static void Main(string[] args)
{
int[] integers = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };

var qry
= from i in integers select i

foreach (var i in qry)
{
Console.WriteLine(i.ToString());
}

Console.ReadLine();
}
}
}

LINQ to Objects - Was kann als Datenquelle verwendet werden?

In .NET Framework implementieren die meisten Auflistungen die IEnumerable und IEnumerable Interfaces.

Die Implementierung von IEnumerable Interface ist die Voraussetzung für eine Auflistung, wenn diese als Datenquelle in einer LINQ-Abfrage mit LINQ to Objects verwendet werden soll.

Weil die viele Auflistungen in .NET Framework der obenerwähnten Interfaces implementieren, können die meisten Auflistungen die bereits in Applikationen verwendet wurden, als Datenquelle für LINQ-Abfragen eingesetzt werden.

LINQ to Objects

Eine LINQ-Abfrage kann nicht nur auf die Daten aus der Datenbank oder auf eine XML-Datei angewendet werden, sonder auch auf die Auflistungen von Objekten in unserem Programmcode.

Der Namespace System.Linq ist die Voraussetzung für die Verwendung von LINQ to Objects in unseren Code. Bevor wir mit LINQ to Objects arbeiten können, müssen wir diesen Namespace in unseren Code einbinden.

2007-09-28

TakeWhile

TakeWhile-Operator steht in dieser Version für LINQ to SQL nicht zur Verfügung. Dieser Operator kann mit LINQ to Objects verwendet werden.

Mit TakeWhile werden in der Quelle vorhandene Elemente sequentiell verarbeitet. Diese sequentielle Verarbeitung dauert solange bis die mitgegebene Bedingung einen true-Wert zurückliefert. Es werden Elemente bis zu dieser Stelle als Resultat zurückgeliefert.

Im Beispiel verwenden wir einen String-Array als Datenquelle. In der Datenquelle sind die Buchstaben von a bis h vorhanden.

string[] source = {"a", "b", "c", "d", "e", "f", "g", "h"};

Wir möchten in unserer Quelle die Elemente sequentiell durchgehen und die Elemente als Resultat zurückliefert bis der Bedingung erfüllt ist.

Als Resultat erwarten wir die Buchstaben a bis d.

Lambda Expression
string[] src = {"a", "b", "c", "d", "e", "f", "g", "h"};
IEnumerable rslt = src.TakeWhile(c => c != "e");

Resultat
Als Resultat liefert die Lambda Expression die Buchstaben von a bis d.