Welchen Nutzen hat „using“ in C#?
https://stackoverflow.com/questions/75401
-
09-06-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianFrage
Benutzer Kokos antwortete das Wunderbare Versteckte Funktionen von C# Frage durch Erwähnung der using Stichwort.Können Sie das näher erläutern?Was sind die Verwendungszwecke von using?
Lösung
Der Grund für die using Aussage ist, um sicherzustellen, dass das Objekt so schnell angeordnet ist, wie es aus dem Geltungsbereich, und es nicht explizit Code, um sicherzustellen, erfordert, dass dies geschieht.
Wie in die 'mit' Anweisung in C # zu verstehen , der .NET CLR Konvertiten
using (MyResource myRes = new MyResource())
{
myRes.DoSomething();
}
{ // Limits scope of myRes
MyResource myRes= new MyResource();
try
{
myRes.DoSomething();
}
finally
{
// Check for a null resource.
if (myRes != null)
// Call the object's Dispose method.
((IDisposable)myRes).Dispose();
}
}
Andere Tipps
Da viele Menschen immer noch tun:
using (System.IO.StreamReader r = new System.IO.StreamReader(""))
using (System.IO.StreamReader r2 = new System.IO.StreamReader("")) {
//code
}
Ich denke, eine Menge Leute immer noch nicht wissen, dass Sie tun können:
using (System.IO.StreamReader r = new System.IO.StreamReader(""), r2 = new System.IO.StreamReader("")) {
//code
}
Dinge wie diese:
using (var conn = new SqlConnection("connection string"))
{
conn.Open();
// Execute SQL statement here on the connection you created
}
Dieses SqlConnection wird, ohne dass geschlossen werden explizit die .Close() Funktion aufzurufen, und dies wird geschehen auch wenn eine Ausnahme ausgelöst wird , ohne die Notwendigkeit für eine try / catch / finally.
verwenden, können verwendet werden, IDisposable zu nennen. Es kann auch zu Alias-Typen verwendet werden.
using (SqlConnection cnn = new SqlConnection()) { /*code*/}
using f1 = System.Windows.Forms.Form;
verwendet wird, im Sinne von
using (var foo = new Bar())
{
Baz();
}
Ist eigentlich eine Abkürzung für einen try / finally-Block. Es entspricht den Code:
var foo = new Bar();
try
{
Baz();
}
finally
{
foo.Dispose();
}
Sie werden bemerken, natürlich, dass der erste Schnipsel viel prägnanter ist als die zweiten und auch, dass es viele Arten von Dingen, die Sie vielleicht als Bereinigung tun, auch wenn eine Ausnahme ausgelöst wird. Aus diesem Grund haben wir mit einer Klasse kommen, die wir Scope nennen, die Sie beliebigen Code in der Dispose-Methode ausführen können. So zum Beispiel, wenn Sie eine Eigenschaft hatte genannt IsWorking, die Sie immer auf false gesetzt wollte, nachdem er versucht, eine Operation auszuführen, können Sie es wie folgt tun würde:
using (new Scope(() => IsWorking = false))
{
IsWorking = true;
MundaneYetDangerousWork();
}
Sie können mehr über unsere Lösung lesen und wie wir es abgeleitet hier .
Ich habe es früher viel in der Vergangenheit mit Eingangs- und Ausgangsströmen zu arbeiten. Sie können Nest sie schön und es braucht viel der möglichen Probleme weg Sie in der Regel den Weg laufen (durch die automatische Aufruf entsorgen). Zum Beispiel:
using (FileStream fs = new FileStream("c:\file.txt", FileMode.Open))
{
using (BufferedStream bs = new BufferedStream(fs))
{
using (System.IO.StreamReader sr = new StreamReader(bs))
{
string output = sr.ReadToEnd();
}
}
}
Microsoft-Dokumentation besagt, dass mit hat eine Doppelfunktion ( https://msdn.microsoft.com/en-us/library/zhdeatwt.aspx ), die beide als Richtlinie und in Aussagen . Als Aussage , wie es war hier in anderen Antworten erwähnt, ist das Schlüsselwort im Grunde syntaktischer Zucker einen Bereich zu bestimmen, ein IDisposable Objekt zu entsorgen. Als Richtlinie , wird routinemäßig verwendet Namespaces und Typen zu importieren. Auch als eine Richtlinie, können Sie Aliase für Namespaces und Typen erstellen, wie in dem Buch darauf hingewiesen, "C # 5.0 in Kürze: The Definitive Guide" ( http://www.amazon.com/5-0-Nutshell-The-Definitive-Reference-ebook/dp/B008E6I1K8 ) von Joseph und Ben Albahari. Ein Beispiel:
namespace HelloWorld
{
using AppFunc = Func<IDictionary<DateTime, string>, List<string>>;
public class Startup
{
public static AppFunc OrderEvents()
{
AppFunc appFunc = (IDictionary<DateTime, string> events) =>
{
if ((events != null) && (events.Count > 0))
{
List<string> result = events.OrderBy(ev => ev.Key)
.Select(ev => ev.Value)
.ToList();
return result;
}
throw new ArgumentException("Event dictionary is null or empty.");
};
return appFunc;
}
}
}
Das ist etwas, mit Bedacht zu übernehmen, da der Missbrauch dieser Praxis eines der Klarheit des Code der verletzen können. Es gibt eine schöne Erklärung auf C # Aliase, auch Vor- und Nachteile, in DotNetPearls zu erwähnen ( http: //www.dotnetperls .com / using-alias ).
Hinzufügen einfach ein wenig etwas, dass ich überrascht war nicht gekommen. Das interessanteste Merkmal der Verwendung von (meiner Meinung nach) ist, dass keine mater, wie Sie die Verwendung von Block verlassen, es wird immer das Objekt entsorgen. Dazu gehören Erträge und Ausnahmen.
using (var db = new DbContext())
{
if(db.State == State.Closed) throw new Exception("Database connection is closed.");
return db.Something.ToList();
}
Es spielt keine Rolle, ob die Ausnahme ausgelöst wird oder die Liste zurückgegeben. Das DbContext Objekt wird immer entsorgt werden.
Ein weiterer großer Einsatz der Verwendung ist, wenn ein modaler Dialog instanziieren.
Using frm as new Form1
Form1.ShowDialog
' do stuff here
End Using
Abschließend, wenn Sie eine lokale Variable eines Typs verwenden, die IDisposable implementiert, immer , ohne Ausnahme, verwendet using 1 .
Wenn Sie nicht lokale IDisposable Variablen verwenden, dann immer implementieren, um die IDisposable Muster .
Zwei einfache Regeln, keine Ausnahme 1 . Ressource zu verhindern Lecks sonst ist ein echten Schmerzen in der * ss.
1) : Die einzige Ausnahme ist - wenn Sie Ausnahmen sind Handhabung. Es könnte dann weniger Code explizit im Dispose Block zu nennen finally.
Interessanterweise können Sie auch die Verwendung von / IDisposable Muster für andere interessante Dinge (wie die anderen Punkt der Art und Weise, die Rhino Mocks verwendet es) verwenden. Grundsätzlich können Sie die Vorteile der Tatsache, dass der Compiler immer rufen .Dispose auf „verwendet“ Objekt. Wenn Sie etwas haben, das nach einer bestimmten Operation passieren muss ... etwas, das einen bestimmten Anfang und Ende hat ... dann können Sie einfach eine IDisposable-Klasse machen, die den Betrieb im Konstruktor beginnt und endet dann in der Dispose-Methode.
Auf diese Weise können Sie die wirklich schön mit Syntax verwenden, um den expliziten Anfang und Ende zu bezeichnen, die Operation. Dies ist auch, wie die System.Transactions Werke stopfen.
Sie können den Alias-Namensraum über das folgende Beispiel machen:
using LegacyEntities = CompanyFoo.CoreLib.x86.VBComponents.CompanyObjects;
Dies wird als ein mit alias Richtlinie wie Sie sehen können, kann es langatmig Referenzen verstecken verwendet werden sollte, Sie wollen es in Ihrem Code offensichtlich machen, was Sie sich beziehen z.
LegacyEntities.Account
statt
CompanyFoo.CoreLib.x86.VBComponents.CompanyObjects.Account
oder einfach
Account // It is not obvious this is a legacy entity
Wenn ADO.NET verwenden, können Sie die keywork für Dinge wie Ihr Verbindungsobjekt oder Leser-Objekt verwenden. Auf diese Weise, wenn der Codeblock vervollständigt wird automatisch Ihre Verbindung entsorgen.
„Verwendung“ kann auch Namensraum Konflikte verwendet werden, zu lösen. Siehe http://www.davidarno.org/c-howtos/ Aliase-Überwindung-name-Konflikte / für einen kurzen Tutorial ich zu diesem Thema geschrieben.
public class ClassA:IDisposable
{
#region IDisposable Members
public void Dispose()
{
GC.SuppressFinalize(this);
}
#endregion
}
public void fn_Data()
{
using (ClassA ObjectName = new ClassA())
{
//use objectName
}
}
mit wird verwendet, wenn Sie eine Ressource, die Sie angeordneten wollen, nachdem es verwendet worden ist.
Zum Beispiel, wenn Sie eine Datei Ressource zuweisen und müssen es nur für ein wenig Lesen oder Schreiben in einem Abschnitt von Code verwenden, ist hilfreich für so bald der Datei Ressource Entsorgung als getan.
Der Bedarf an Ressourcen verwendet wird IDisposable implementieren richtig zu arbeiten.
Beispiel:
using (File file = new File (parameters))
{
*code to do stuff with the file*
}
Die Verwendung von Keyword definiert den Rahmen für das Objekt und verfügt dann über das Objekt, wenn der Umfang abgeschlossen ist. Zum Beispiel.
using (Font font2 = new Font("Arial", 10.0f))
{
// use font2
}
Siehe hier für den MSDN-Artikel auf dem C # Schlüsselwort.
Nicht, dass es ist extrem wichtig, wobei jedoch auch Ressourcen verwendet wird, im laufenden Betrieb zu ändern. Ja Einweg wie bereits erwähnt, aber vielleicht gerade Sie nicht möchten, dass die Ressourcen, die sie während des Restes Ihrer Ausführung mit anderen Ressourcen stimmen nicht überein. So möchten Sie darüber verfügen, damit es nicht an anderer Stelle nicht stört.
Dank den Kommentaren unten, werde ich diese reinigen etwas schreiben (ich hätte die Worte ‚Garbage Collection‘ zu der Zeit, Entschuldigungen nicht verwendet):
Wenn Sie verwenden verwenden, wird die Dispose () -Methode für das Objekt am Ende des Anwendungsbereichs der Verwendung nennen. So kann man ziemlich viel von großem Bereinigungscode hat in Ihrer Dispose () -Methode.
Ein Aufzählungspunkt hier die hoffentlich vielleicht dieses un-markeddown erhalten: Wenn Sie IDisposable implementieren, stellen Sie sicher, dass Sie GC.SuppressFinalize () in der Dispose () aufrufen, Implementierung, da sonst die automatische Garbage Collection werden versuchen, zusammen zu kommen und finalisieren es an einigen Punkt, der zumindest eine Verschwendung von Ressourcen wäre, wenn Sie bereits () d entsorgen haben.
Ein weiteres Beispiel für einen sinnvollen Einsatz in dem das Objekt unmittelbar angeordnet ist:
using (IDataReader myReader = DataFunctions.ExecuteReader(CommandType.Text, sql.ToString(), dp.Parameters, myConnectionString))
{
while (myReader.Read())
{
MyObject theObject = new MyObject();
theObject.PublicProperty = myReader.GetString(0);
myCollection.Add(theObject);
}
}
Alles außerhalb der geschweiften Klammern angeordnet ist, so ist es toll, Ihre Objekte zu entsorgen, wenn Sie sie nicht verwenden. Dies ist so, weil, wenn Sie ein Objekt SqlDataAdapter haben und Sie verwenden sie nur einmal im Anwendungslebenszyklus und Sie füllen nur ein Datensatz und Sie es nicht mehr benötigen, können Sie den Code verwenden:
using(SqlDataAdapter adapter_object = new SqlDataAdapter(sql_command_parameter))
{
// do stuff
} // here adapter_object is disposed automatically
Die using-Anweisung stellt einen Komfort-Mechanismus richtig IDisposable Objekte zu verwenden. In der Regel, wenn Sie ein IDisposable-Objekt verwenden, sollten Sie es in einer using-Anweisung deklarieren und instanziieren. Die Verwendung Anweisung ruft die Dispose-Methode auf dem Objekt in der richtigen Art und Weise, und (wenn Sie es verwenden, wie zuvor gezeigt) es verursacht auch das Objekt selbst so schnell aus Umfang zu gehen, wie Entsorgen genannt wird. Innerhalb des mit Block wird das Objekt nur gelesen und nicht geändert werden kann oder neu zugewiesen.
Das kommt von: hier
Für mich ist der Name „mit“ ist ein wenig verwirrend, da ist, kann eine Richtlinie sein, einen Namespace oder eine Erklärung zu importieren (wie hier beschrieben) für die Fehlerbehandlung.
Ein anderer Name für die Fehlerbehandlung wäre schön gewesen, und vielleicht auch ein irgendwie offensichtlich ein.
Es kann auch für die Erstellung von Bereichen zum Beispiel verwendet werden:
class LoggerScope:IDisposable {
static ThreadLocal<LoggerScope> threadScope =
new ThreadLocal<LoggerScope>();
private LoggerScope previous;
public static LoggerScope Current=> threadScope.Value;
public bool WithTime{get;}
public LoggerScope(bool withTime){
previous = threadScope.Value;
threadScope.Value = this;
WithTime=withTime;
}
public void Dispose(){
threadScope.Value = previous;
}
}
class Program {
public static void Main(params string[] args){
new Program().Run();
}
public void Run(){
log("something happend!");
using(new LoggerScope(false)){
log("the quick brown fox jumps over the lazy dog!");
using(new LoggerScope(true)){
log("nested scope!");
}
}
}
void log(string message){
if(LoggerScope.Current!=null){
Console.WriteLine(message);
if(LoggerScope.Current.WithTime){
Console.WriteLine(DateTime.Now);
}
}
}
}
Die Anweisung using sagt .NET das Objekt in der Verwendung von Block angegeben freizugeben, sobald es nicht mehr benötigt wird. So sollten Sie ‚mit‘ Block für die Klassen verwenden, die nach ihnen erfordern Reinigung, wie System.IO Typen.
Es gibt zwei Verwendungszwecke für die Verwendung von Schlüsselwörtern in C#:
- als Richtlinie
Im Allgemeinen verwenden wir das Schlüsselwort using, um Namespaces in Code-Behind- und Klassendateien hinzuzufügen.Anschließend werden alle Klassen, Schnittstellen und abstrakten Klassen sowie deren Methoden und Eigenschaften auf der aktuellen Seite verfügbar gemacht.
Ex:
using System.IO;
- als Aussage
Dies ist eine weitere Möglichkeit, das Schlüsselwort using in C# zu verwenden.Es spielt eine entscheidende Rolle bei der Verbesserung der Leistung bei der Garbage Collection.Die using-Anweisung stellt sicher, dass Dispose() auch dann aufgerufen wird, wenn beim Erstellen von Objekten und beim Aufrufen von Methoden, Eigenschaften usw. eine Ausnahme auftritt.Dispose() ist eine Methode, die in der IDisposable-Schnittstelle vorhanden ist und bei der Implementierung einer benutzerdefinierten Garbage Collection hilft.Mit anderen Worten: Wenn ich eine Datenbankoperation ausführe (Einfügen, Aktualisieren, Löschen), aber irgendwie eine Ausnahme auftritt, schließt die using-Anweisung hier die Verbindung automatisch.Es ist nicht erforderlich, die Verbindungsmethode Close() explizit aufzurufen.
Ein weiterer wichtiger Faktor ist, dass es beim Connection Pooling hilft.Connection Pooling in .NET trägt dazu bei, das mehrmalige Schließen einer Datenbankverbindung zu vermeiden.Es sendet das Verbindungsobjekt zur zukünftigen Verwendung (nächster Datenbankaufruf) an einen Pool.Wenn das nächste Mal eine Datenbankverbindung von Ihrer Anwendung aufgerufen wird, ruft der Verbindungspool die im Pool verfügbaren Objekte ab.Dies trägt dazu bei, die Leistung der Anwendung zu verbessern.Wenn wir also die using-Anweisung verwenden, sendet der Controller das Objekt automatisch an den Verbindungspool, es besteht keine Notwendigkeit, die Methoden Close() und Dispose() explizit aufzurufen.
Sie können das Gleiche tun wie die using-Anweisung, indem Sie den Try-Catch-Block verwenden und Dispose() innerhalb des Final-Blocks explizit aufrufen.Aber die using-Anweisung führt die Aufrufe automatisch durch, um den Code sauberer und eleganter zu machen.Innerhalb des using-Blocks ist das Objekt schreibgeschützt und kann nicht geändert oder neu zugewiesen werden.
Ex:
string connString = "Data Source=localhost;Integrated Security=SSPI;Initial Catalog=Northwind;";
using (SqlConnection conn = new SqlConnection(connString))
{
SqlCommand cmd = conn.CreateCommand();
cmd.CommandText = "SELECT CustomerId, CompanyName FROM Customers";
conn.Open();
using (SqlDataReader dr = cmd.ExecuteReader())
{
while (dr.Read())
Console.WriteLine("{0}\t{1}", dr.GetString(0), dr.GetString(1));
}
}
Im vorherigen Code schließe ich keine Verbindung, sie wird automatisch geschlossen.Die using-Anweisung ruft conn.Close() aufgrund der using-Anweisung automatisch auf (using (SqlConnection conn = new SqlConnection(connString)) und dasselbe gilt für ein SqlDataReader-Objekt.Und auch wenn eine Ausnahme auftritt, wird die Verbindung automatisch geschlossen.
Für weitere Informationen -> https://www.c-sharpcorner.com/UploadFile/manas1/usage-and-importance-of-using-in-C-Sharp472/
Das Rhino Mocks Aufzeichnung-Wiedergabe Syntax macht eine interessante Anwendung von using.
Verwendung als eine Anweisung automatisch die Dispose auf dem angegebenen ruft Objekt. Das Objekt muss die IDisposable-Schnittstelle implementieren. Es ist so lange möglich, mehrere Objekte in einer Anweisung zu verwenden, wie sie sind des gleichen Typs.
Die CLR wandelt den Code in MSIL. Und die using-Anweisung wird in einem Versuch übersetzt und schließlich blockieren. Dies ist, wie die Verwendung von Anweisung in IL dargestellt. Eine using-Anweisung ist in drei Teile übersetzt: Beschaffung, Nutzung und Entsorgung. Die Ressource wird zuerst erworben hat, wird die Verwendung in einer try-Anweisung mit einer finally-Klausel eingeschlossen. Das Objekt dann wird in der finally angeordnet ist.
Mit Klausel wird verwendet, um den Raum für die bestimmte Variable zu definieren. Zum Beispiel:
Using(SqlConnection conn=new SqlConnection(ConnectionString)
{
Conn.Open()
// Execute sql statements here.
// You do not have to close the connection explicitly here as "USING" will close the connection once the object Conn becomes out of the defined scope.
}
