A LINQ célja egy univerzális objektum-halmaz lekérdező API felület biztosítása, mely révén bármilyen objektum forrásból egységes szintaktikával lehet az igényelt objektumokat begyűjteni. A LINQ kifejezések szintaktikája több elemében az SQL szintaktikájára épít,de számos ponton el is tér tőle. A lekérdezésekben az SQL mellett számos xQuery vonást is felfedezhetünk, ami összecseng azzal a törekvéssel, hogy a LINQ-t az XML adatokra is alkalmazható felületet biztosít.

A LINQ rendszer fő jellemzője az egységes lekérdező felület mellett az, hogy a lekérdezés gazdanyelvi szinten valósul meg, tehát a parancs végrehajtása nem a távoli DBMS magjában fut le, hanem az alkalmazásban. Ennek előnye, hogy a lekérdezés közvetlenül nyomkövethető, a hibakezelés a gazdanyelvi környezetbe integrálható. A LINQ API mögött tehát egy a gazdanyelve ágyazott mini DBMS motor működiik, mely az alkalmazás saját adatival dolgozhat. Ez a működési mód természetesen nem alkalmazható elosztottan módosítható adatok esetében, ott továbbra is centralizált DBMS viztisítja a megoldást.

A LINQ rendszer egy olyan API adatlekérdező felület amely az adatforrások széles körét támogatva halmaz orientált lekérdező kifejezések használatát teszi lehetvé. A LINQ által támogatott adatforrások:

A LINQ lekérdezés általános alakja az alábbi absztrakt szintaktikára illeszkedik:

   Q = from-clause join-clause*
   (from-clause join-clause* | let-clause | where-clause)*
   (orderby-clause)?
   (select-clause | groupby-clause)
   (query-continuation Q) ?
      

A LINQ lekérdezés tehát az alábbi komponenseket tartalmazhatja:

A lekérdezések egymásba ágyazhatók és egymásután f0zhetők. Az egyes query elemek halmazműveletekkel összefűzhetők

A támogatott operátorok körét foglalja össze az alábbi táblázat.

var q =
      from v in new[] { 11, 5, 3, 17, 4, 32}
         where v < 5
      select v;
   q.Dump();

   void Main()
   {
      Tgyarto[] A = new Tgyarto[2];
      Ttermek[] B = new Ttermek[5];
      A[0] = new Tgyarto(1,"VASGYAR");
      A[1] = new Tgyarto(2,"ITALGYAR");
      B[0] = new Ttermek(1,"KAPA",23);
      B[1] = new Ttermek(1,"ASO",15);
      B[2] = new Ttermek(2,"TEJ",8);
      B[3] = new Ttermek(2,"VODKA",13);
      B[4] = new Ttermek(2,"TRAUBI",6);
   
      var q =
        from a in A
        join b in B on a.kod equals b.gyarto
        select new {anev = a.nev, bnev = b.nev};
   
      foreach (var v in q) {
        Console.WriteLine(v.anev+" "+ v.bnev);
      }
   }
   
   class Tgyarto {
      public int kod;
      public String nev;
   
      public Tgyarto (int a, String b) {
         this.kod = a;
                this.nev = b;
      }
   }
   
   class Ttermek {
      public int gyarto;
      public String nev;
      public int ar;
   
      public Ttermek (int a, String b, int c) {
         this.gyarto = a;
         this.nev = b;
         this.ar = c;
      }
   }

var q = B
      .Count();
         Console.WriteLine(q);

var q = B
      .Where (t => t.ar > 10)
      .Count();
   Console.WriteLine(q);

var q = B
      .Where (t => t.ar > 10)
      .Select (e => e.nev)
      .OrderBy (e => e);
   Console.WriteLine(q);

var q = A
      .Where (t => t.nev == "ITALGYAR")
      .Join(B, b => b.kod, a => a.gyarto, (a,b) => new {b.nev})
      .OrderBy(e => e.nev);
   Console.WriteLine(q);

var q = A
   .Where (t => t.nev == "ITALGYAR")
   .Join(B, b => b.kod, a => a.gyarto, (a,b) => new {b.nev, b.ar})
   .Average(e => e.ar);
   Console.WriteLine(q);

var q = B
      .Where (t => t.ar > ( B.Average(e => e.ar) ) )
      .Select (t => t.nev);
   Console.WriteLine(q);

var q = B
      .Where (t => t.ar > ( A
      .Where (e => e.nev == "ITALGYAR")
      .Join(B, b => b.kod, a => a.gyarto, (a,b) => new {b.nev, b.ar})
      .Average(e => e.ar) ) )
      .Select (t => t.nev)
      .OrderBy (t => t);
   Console.WriteLine(q);