Warum bevorzugen wir immer die Verwendung von Parametern in SQL-Anweisungen?

Du hast Recht, dies ist im Zusammenhang mit SQL-injection, das ist eine Verwundbarkeit, die einem malicioius Benutzer zum ausführen von beliebigen Anweisungen gegen die Datenbank. Diese alte Zeit Lieblings - XKCD-comic veranschaulicht das Konzept:

In deinem Beispiel, wenn Sie gerade verwenden:

var query = "SELECT empSalary from employee where salary = " + txtSalary.Text;
//and proceed to execute this query

Sind Sie offen für SQL-injection. Zum Beispiel, sagen, jemand betritt txtSalary:

1; UPDATE employee SET salary = 9999999 WHERE empID = 10; --
1; DROP TABLE employee; --
//etc.

Wenn Sie diese Abfrage ausführen, wird ein SELECT und ein UPDATE oder DROP oder was auch immer Sie wollten. Die -- am Ende einfach Kommentare aus dem rest der Abfrage, die nützlich sein würde in den Angriff, wenn Sie die Verkettung alles nach txtSalary.Text.

Der richtige Weg ist die Verwendung von parametrisierten Abfragen, z.B. (C#):

SqlCommand query =  new SqlCommand("SELECT empSalary FROM employee 
                                    WHERE salary = @sal;");
query.Parameters.AddWithValue("@sal", txtSalary.Text);

Mit, dass, können Sie sicher die Abfrage auszuführen.

Referenz zur Vermeidung von SQL-injection in mehreren anderen Sprachen überprüfen bobby-tables.com, eine website verwaltet von einer ALSO Benutzer.

InformationsquelleAutor der Antwort NullUserException

Anderen Antworten abdecken, warum die Parameter sind wichtig, aber es gibt einen Nachteil! In .net, gibt es mehrere Methoden für die Erstellung von Parameter (- Add, AddWithValue), aber Sie alle verlangen, dass Sie sich sorgen zu machen, unnötig, über die parameter name, und Sie verringern die Lesbarkeit der SQL im code. Rechts, wenn Sie versuchen zu meditieren, die auf die SQL, die Sie benötigen zu jagen, um oben oder unten, um zu sehen, welcher Wert wurde im parameter.

Möchte ich in aller Bescheidenheit behaupten, meine kleine SqlBuilder Klasse ist die eleganteste Art, zu schreiben, parametrisierte Abfragen. Ihr code wird wie folgt Aussehen...

C#

var bldr = new SqlBuilder( myCommand );
bldr.Append("SELECT * FROM CUSTOMERS WHERE ID = ").Value(myId);
//or
bldr.Append("SELECT * FROM CUSTOMERS WHERE NAME LIKE ").FuzzyValue(myName);
myCommand.CommandText = bldr.ToString();

Ihr code wird kürzer und viel besser lesbar. Sie brauchen noch nicht einmal zusätzliche Leitungen, und, wenn Sie Lesen, zurück, Sie brauchen nicht auf die Jagd um für den Wert der Parameter. Die Klasse, die Sie brauchen, ist hier...

using System;
using System.Collections.Generic;
using System.Text;
using System.Data;
using System.Data.SqlClient;

public class SqlBuilder
{
private StringBuilder _rq;
private SqlCommand _cmd;
private int _seq;
public SqlBuilder(SqlCommand cmd)
{
    _rq = new StringBuilder();
    _cmd = cmd;
    _seq = 0;
}
public SqlBuilder Append(String str)
{
    _rq.Append(str);
    return this;
}
public SqlBuilder Value(Object value)
{
    string paramName = "@SqlBuilderParam" + _seq++;
    _rq.Append(paramName);
    _cmd.Parameters.AddWithValue(paramName, value);
    return this;
}
public SqlBuilder FuzzyValue(Object value)
{
    string paramName = "@SqlBuilderParam" + _seq++;
    _rq.Append("'%' + " + paramName + " + '%'");
    _cmd.Parameters.AddWithValue(paramName, value);
    return this;
}
public override string ToString()
{
    return _rq.ToString();
}
}

InformationsquelleAutor der Antwort bbsimonbb

Zwei Jahre nach meine erste, ich bin recidivating...

Warum ziehen wir Parameter? SQL-injection ist natürlich ein großer Grund, aber könnte es sein, dass wir uns heimlich danach sehnen, wieder zurück zu SQL als Sprache. SQL in string-literalen ist schon eine seltsame kulturelle Praxis, aber mindestens Sie können kopieren und fügen Sie Ihre Anfrage in das management-studio. SQL dynamisch aufgebaut mit der host-Sprache Vergleichsoperatoren und Kontrollstrukturen, wenn SQL hat Vergleichsoperatoren und Kontrollstrukturen, ist nur level 0 Barbarei. Sie müssen führen Sie Ihre app im debug, oder mit einer Spur, um zu sehen, was von SQL, die es erzeugt.

Don ' T stop mit nur Parameter. Gehen alle den Weg und nutzen QueryFirst (disclaimer: was ich schrieb). Ihre SQL Leben in einem .sql-Datei. Sie Bearbeiten es in die fabelhafte TSQL-editor mit syntax-Validierung und Intellisense für Ihre Tabellen und Spalten. Zuordnen können Sie test-Daten in den speziellen Kommentaren Abschnitt, und klicken Sie auf "play", um führen Sie Ihre Abfrage direkt in das Fenster. Erstellen Sie einen parameter genauso einfach wie mit "@myParam" in Ihrer SQL. Dann, jedes mal, wenn Sie sparen, QueryFirst generiert die C# - wrapper für Ihre Abfrage. Ihre Parameter pop-up, stark typisiert sind, die als Argumente an die Execute () - Methoden. Ihre Ergebnisse zurückgegeben werden, in ein IEnumerable oder die Liste der stark typisierten POCOs, die Arten erzeugt aus dem schema von der Abfrage zurückgegebenen. Wenn Ihre Abfrage nicht ausgeführt werden kann, Ihre app nicht kompiliert. Wenn Sie Ihre db-schema-änderungen und Ihre Abfrage ausgeführt wird, aber einige Spalten verschwinden, die compile-Fehler, Punkte zu die Zeile in Ihrem code, die versucht, Zugriff auf die Daten fehlen. Und es gibt noch zahlreiche weitere Vorteile. Warum würden Sie wollen, um access-Daten anderen Weg?

InformationsquelleAutor der Antwort bbsimonbb