Gibt es eine Möglichkeit, eine LINQ-to-SQL Abfrage, dynamisch zur Laufzeit zu erstellen.
Man weiß also erst zur Laufzeit, welche where/and/orderby usw. Konstrukte benötigt werden.
Z.B.: Ein User kann einen Abfrage-Filter mit unterschiedlichen Bedingungen setzen, bzw. nicht setzen. Bisher hat man dazu einen (parametrisierten)SQL-Str. zur Laufzeit zusammengebastelt
und zur DB geschickt. (Dies kann man über einen LINQ-DataKontext übrigends immer noch)

Z.B. so kannst du deine Query weiter bearbeiten.

IQueryable<myEntity> myQuery = from p in context.TableXy select p;
if(bedingung)
  myQuery = myQuery.Where(x => x.column1 == "ab");
if(sort)
  myQuery = myQuery.OrderBy(x => x.column4);

Ausgeführt wird die Query erst beim ersten Zugriff. Schau die den SQL-Profiler an.
Komplexere Aufgaben erledigst du mit LambdaExpressions, ist nicht ganz einfach, aber es finden sich gute Beispiele im Internet.

PS: Ich arbeite mit dem EntityFramework, aber meine Antwort müsste auch für LINQ-to-SQL gültig sein.

Ich habe eine Vorschlag den ich dir mal prototypisch runtercode. Hiermit kannst Du Deine Where Bedingung ausserhalb einer Funktion definieren.

Aufruf

DeleteMyEntries(Function(o) o.MyEntry Is Nothing And o.MarkedInGUI.GetValueOrDefault)

Funktion

Private Sub DeleteMyEntries(ByVal where As Func(Of MyTable, Boolean))
        Dim context As DBEntities = _dataService.GetGlobalEntities()

        With context
            .MyTable.Where(where).ForEach(Sub(p) context.DeleteObject(p))
            .SaveChanges()
        End With
    End Sub

Der Knackpunkt ist einfach das Du die (Lösch)funktion mit einer beliebigen Einschränkung aufrufen kannst indem Du die WHERE Clause als Lambda in die Funktion hinein gibst.

PS: Ich arbeite mit dem EntityFramework, aber meine Antwort müsste auch für LINQ-to-SQL gültig sein. ;)

Gruß
Thomas Sczyrba

Hi,
wir hatten ein ähnliches Problem.
Wir hatten ein Object z.B. Person, dass nach verschiedenen Kriterien (Vorname, Nachname, Land etc.) gefiltert werden sollte.
Wir haben eine Extension Method angelegt. AsFilterExpression. Der Rückgabewert war ein Expression.
Nun haben wir folgende Vereinbarung getroffen:
Sind Felder null, werden sie beim Filtern nicht berücksichtigt. Wenn sie !=null sind auch string.Empty, dann werden sie berücksichtigt. Das setzt voraus, dass in der DB Tabelle auch keine Felder nullable sind.
Bsp.:

public Expression<Func<Person, bool>> AsFilterExpression(this Person p) {
 Expression<Func<Person, bool>> result = x =>
  ((p.City == null) ? true : x.City.StartsWith(temp.City))
                && ((p.Forename == null) ? true : x.Forename == p.Forename)
                && ((p.Language == null) ? true : x.Language == p.Language)
                && ((p.Salutation == null) ? true : x.Salutation == p.Salutation)
                && ((p.State == null) ? true : x.State == p.State)
                && ((p.Street == null) ? true : x.Street == p.Street)
                && ((p.StreetExt == null) ? true : x.StreetExt == p.StreetExt)
                && ((p.Surname == null) ? true : x.Surname.StartsWith(p.Surname))
                && ((p.Title == null) ? true : x.Title == p.Title); 
             return result;
}

Viel Glück
Ralf