Mi sto perdendo qualcosa su LINQ?

Question

Sembra che mi manchi qualcosa su LINQ.A me sembra che stia prendendo alcuni degli elementi di SQL che mi piacciono di meno, spostandoli nel linguaggio C# e utilizzandoli per altre cose.

Voglio dire, ho potuto vedere il vantaggio di utilizzare istruzioni di tipo SQL su cose diverse dai database.Ma se volessi scrivere SQL, beh, perché non scrivere semplicemente SQL e tenerlo fuori da C#?Cosa mi manca qui?

Answer 1

LINQ non riguarda SQL.LINQ riguarda l'applicazione di paradigmi di programmazione funzionale sugli oggetti.

LINQ to SQL è un ORM costruito sulla base LINQ, ma LINQ è molto di più.Non utilizzo LINQ to SQL, ma utilizzo sempre LINQ.

Prenditi il ​​compito di trovare l'intersezione di due elenchi:

Prima di LINQ, questa attività richiedeva la scrittura di un foreach nidificato che ripeta l'elenco piccolo una volta per ogni elemento dell'elenco grande O(N*M) e richiede circa 10 righe di codice.

foreach (int number in list1)
{
    foreach (int number2 in list2)
    {
        if (number2 == number)
        {
            returnList.add(number2);
        }
    }
}

Usando LINQ, fa la stessa cosa in una riga di codice:

var results = list1.Intersect(list2);

Noterai che non assomiglia a LINQ, eppure lo è.Non è necessario utilizzare la sintassi dell'espressione se non lo desideri.

Answer 2

Prima:

// Init Movie
m_ImageArray = new Image[K_NB_IMAGE];

Stream l_ImageStream = null;
Bitmap l_Bitmap = null;

// get a reference to the current assembly
Assembly l_Assembly = Assembly.GetExecutingAssembly();

// get a list of resource names from the manifest
string[] l_ResourceName = l_Assembly.GetManifestResourceNames();

foreach (string l_Str in l_ResourceName)
{
    if (l_Str.EndsWith(".png"))
    {
        // attach to stream to the resource in the manifest
        l_ImageStream = l_Assembly.GetManifestResourceStream(l_Str);
        if (!(null == l_ImageStream))
        {
            // create a new bitmap from this stream and 
            // add it to the arraylist
            l_Bitmap = Bitmap.FromStream(l_ImageStream) as Bitmap;
            if (!(null == l_Bitmap))
            {
                int l_Index = Convert.ToInt32(l_Str.Substring(l_Str.Length - 6, 2));
                l_Index -= 1;
                if (l_Index < 0) l_Index = 0;
                if (l_Index > K_NB_IMAGE) l_Index = K_NB_IMAGE;
                m_ImageArray[l_Index] = l_Bitmap;
            }
            l_Bitmap = null;
            l_ImageStream.Close();
            l_ImageStream = null;
        } // if
    } // if
} // foreach

Dopo:

Assembly l_Assembly = Assembly.GetExecutingAssembly();

//Linq is the tops
m_ImageList = l_Assembly.GetManifestResourceNames()
    .Where(a => a.EndsWith(".png"))
    .OrderBy(b => b)
    .Select(c => l_Assembly.GetManifestResourceStream(c))
    .Where(d => d != null)  //ImageStream not null
    .Select(e => Bitmap.FromStream(e))
    .Where(f => f != null)  //Bitmap not null
    .ToList();

Oppure, in alternativa (sintassi dell'interrogazione):

Assembly l_Assembly = Assembly.GetExecutingAssembly();

//Linq is the tops
m_ImageList = (
    from resource in l_Assembly.GetManifestResourceNames()
    where resource.EndsWith(".png")
    orderby resource
    let imageStream = l_Assembly.GetManifestResourceStream(resource)
    where imageStream != null
    let bitmap = Bitmap.FromStream(imageStream)
    where bitmap != null)
    .ToList();

Answer 3

Quindi il vero, davvero grosso problema di LINQ non ha nulla a che fare con Linq to SQL.Riguarda i miglioramenti apportati al linguaggio C# stesso.

Answer 4

LINQ non è solo un sistema ORM, come ha sottolineato Jonathan, porta molti elementi di programmazione funzionale in C#.E ti consente di fare molte cose "database" nel normale codice C#.È difficile spiegare quanto possa essere incredibilmente potente.Considera quanto l'inclusione di strutture dati generiche solide e ben progettate (come elenchi, stack, dizionario/hash, ecc.) in framework comuni abbia migliorato lo stato di sviluppo dei linguaggi moderni.Proprio perché l’utilizzo di queste strutture dati è molto comune e ridurre il sovraccarico intellettuale derivante dal loro utilizzo è un enorme vantaggio.LINQ non fa nulla che non puoi fare da solo, ma rende molte operazioni molto più semplici e immediate.

Considera l'esempio ormai consacrato della rimozione dei duplicati da un elenco non ordinato.In un linguaggio di livello inferiore come C o C++ probabilmente dovresti ordinare l'elenco e mantenere due indici nell'elenco mentre rimuovi i duplicati.In un linguaggio con hash (Java, C#, Javascript, Perl, ecc.) potresti creare un hash in cui le chiavi sono valori univoci, quindi estrarre le chiavi in ​​un nuovo elenco.Con LINQ potresti semplicemente fare questo:

int[] data = { 0, 1, 3, 3, 7, 8, 0, 9, 2, 1 };

var uniqueData = data.GroupBy(i => i).Select(g => g.Key);

Answer 5

Poiché linq è in realtà una monade vestita da SQL, la sto utilizzando su un progetto per effettuare richieste Web asincrone con la monade di continuazione e si sta rivelando funzionare davvero bene!

Dai un'occhiata a questi articoli:http://www.aboutcode.net/2008/01/14/Async+WebRequest+Using+LINQ+Syntax.aspx http://blogs.msdn.com/wesdyer/archive/2008/01/11/the-marvels-of-monads.aspx

Dal primo articolo:

    var requests = new[] 
    {
        WebRequest.Create("http://www.google.com/"),
        WebRequest.Create("http://www.yahoo.com/"),
        WebRequest.Create("http://channel9.msdn.com/")
    };

    var pages = from request in requests
                select
                    from response in request.GetResponseAsync()
                    let stream = response.GetResponseStream()
                    from html in stream.ReadToEndAsync()
                    select new { html, response };

    foreach (var page in pages)
    {
        page(d =>
        {
            Console.WriteLine(d.response.ResponseUri.ToString());
            Console.WriteLine(d.html.Substring(0, 40));
            Console.WriteLine();
        });
    }

Answer 6

Il punto è che LINQ integra le tue query nel tuo linguaggio di programmazione principale, consentendo al tuo IDE di fornirti alcune funzionalità (Intellisense e supporto per il debug, ad esempio) che altrimenti non avresti e di consentire al compilatore di controllare il tipo di SQL codice (che è impossibile con una normale query di stringa).