why statement namespace instruction end c# using using-statement

statement - ¿Cuáles son los usos de "usar" en C#



using namespace c# (29)

Los usuarios kokos respondieron a la maravillosa pregunta de Características ocultas de C # mencionando la palabra clave using . Puedes profundizar sobre eso? ¿Cuáles son los usos de using ?

el uso como declaración llama automáticamente a disponer en el objeto especificado. El objeto debe implementar la interfaz IDisposable. Es posible usar varios objetos en una declaración siempre y cuando sean del mismo tipo.

El CLR convierte tu código en MSIL. Y la declaración de uso se traduce en un bloque de prueba y finalmente. Así es como se representa la instrucción using en IL. Una declaración de uso se traduce en tres partes: adquisición, uso y eliminación. El recurso se adquiere por primera vez, luego el uso se incluye en una declaración de prueba con una cláusula finally. El objeto entonces se dispone en la cláusula finalmente.

Como mucha gente todavía lo hace:

using (System.IO.StreamReader r = new System.IO.StreamReader("")) using (System.IO.StreamReader r2 = new System.IO.StreamReader("")) { //code }

Supongo que mucha gente aún no sabe que puedes hacer:

using (System.IO.StreamReader r = new System.IO.StreamReader(""), r2 = new System.IO.StreamReader("")) { //code }

Cosas como esta:

using (var conn = new SqlConnection("connection string")) { conn.Open(); // Execute SQL statement here on the connection you created }

Esta SqlConnection se cerrará sin la necesidad de llamar explícitamente a la función .Close() , y esto ocurrirá incluso si se lanza una excepción , sin la necesidad de try / catch / finally .

Cuando use ADO.NET, puede usar el trabajo de teclas para cosas como su objeto de conexión o su objeto lector. De esa manera, cuando el bloque de código se complete, se eliminará automáticamente de su conexión.

Curiosamente, también puede utilizar el patrón de uso / IDisposable para otras cosas interesantes (como el otro punto de la forma en que Rhino Mocks lo utiliza). Básicamente, puede aprovechar el hecho de que el compilador siempre llamará .Disponer en el objeto "usado". Si tiene algo que debe suceder después de una determinada operación ... algo que tiene un inicio y un final definidos ... entonces simplemente puede hacer una clase IDisposable que inicie la operación en el constructor, y luego finalice con el método de Disposición.

Esto le permite usar la sintaxis realmente agradable para denotar el inicio y el final explícitos de dicha operación. Así es también como funcionan las cosas de System.Transactions.

El motivo de la declaración de using es garantizar que el objeto se elimine tan pronto como salga de su alcance y que no requiera un código explícito para garantizar que esto suceda.

Como en Entendiendo la declaración de ''uso'' en C # , el .NET CLR convierte

using (MyResource myRes = new MyResource()) { myRes.DoSomething(); }

a

{ // 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(); } }

El uso de Cláusula se utiliza para definir el alcance de la variable en particular. Por ejemplo:

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. }

En conclusión, cuando usa una variable local de un tipo que implementa IDisposable , siempre , sin excepción, use using 1 .

Si usa variables IDisposable no IDisposable , entonces siempre implemente el patrón IDisposable .

Dos reglas simples, sin excepción 1 . Prevenir las fugas de recursos de lo contrario es un verdadero dolor en la * ss.

1) : la única excepción es cuando se manejan excepciones. Podría entonces haber menos código para llamar a Dispose explícitamente en el bloque finally .

Gracias a los comentarios a continuación, limpiaré esta publicación un poco (no debería haber usado las palabras ''recolección de basura'' en ese momento, disculpas):
Cuando lo use, llamará al método Dispose () en el objeto al final del alcance del uso. Por lo tanto, puede tener un buen código de limpieza en su método Dispose ().
Un punto importante aquí que quizás obtenga este desmarque: si implementas IDisposable, asegúrate de llamar a GC.SuppressFinalize () en tu implementación de Dispose (), ya que de lo contrario la recolección automática de basura intentará aparecer y finalizarla de alguna manera punto, que al menos sería un desperdicio de recursos si ya tiene Dispose () d de él.

Hay dos usos del uso de palabras clave en C # de la siguiente manera.

  1. como una directiva

En general, usamos la palabra clave using para agregar espacios de nombres en los archivos de código subyacente y de clase. Luego pone a disposición todas las clases, interfaces y clases abstractas y sus métodos y propiedades en la página actual.

Ex:

using System.IO;

  1. como una declaración

Esta es otra forma de usar la palabra clave using en C #. Juega un papel vital en la mejora del rendimiento en la recolección de basura. La declaración de uso garantiza que se llame a Dispose () incluso si se produce una excepción al crear objetos y métodos de llamada, propiedades, etc. Dispose () es un método que está presente en la interfaz IDisposable que ayuda a implementar la recolección de basura personalizada. En otras palabras, si estoy haciendo alguna operación de base de datos (Insertar, Actualizar, Eliminar) pero de alguna manera ocurre una excepción, aquí la instrucción de uso cierra la conexión automáticamente. No es necesario llamar explícitamente al método de conexión Close ().

Otro factor importante es que ayuda en la agrupación de conexiones. La agrupación de conexiones en .NET ayuda a eliminar el cierre de una conexión de base de datos varias veces. Envía el objeto de conexión a un grupo para su uso futuro (próxima llamada a la base de datos). La próxima vez que se llame a una conexión de base de datos desde su aplicación, el grupo de conexiones buscará los objetos disponibles en el grupo. Así que ayuda a mejorar el rendimiento de la aplicación. Por lo tanto, cuando usamos la declaración de uso, el controlador envía el objeto a la agrupación de conexiones automáticamente, no hay necesidad de llamar a los métodos Cerrar () y Dispose () explícitamente.

Puede hacer lo mismo que hace la instrucción utilizando el bloque try-catch y llamar a Dispose () dentro del bloque finally de manera explícita. Pero la declaración de uso realiza las llamadas automáticamente para hacer que el código sea más limpio y elegante. Dentro del bloque que usa, el objeto es de solo lectura y no se puede modificar ni reasignar.

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)); } }

En el código anterior no estoy cerrando ninguna conexión, se cerrará automáticamente. La declaración de uso llamará a conn.Close () automáticamente debido a la declaración de uso (utilizando (SqlConnection conn = new SqlConnection (connString)) y lo mismo para un objeto SqlDataReader. Y también, si se produce alguna excepción, cerrará la conexión automáticamente.

Para obtener más información, visite https://www.c-sharpcorner.com/UploadFile/manas1/usage-and-importance-of-using-in-C-Sharp472/

La declaración de uso le dice a .NET que libere el objeto especificado en el bloque de uso una vez que ya no sea necesario. Por lo tanto, debe usar el bloque ''using'' para las clases que requieren limpieza después de ellas, como los tipos System.IO.

La declaración de uso proporciona un mecanismo de conveniencia para usar correctamente objetos IDisposibles. Como regla general, cuando utiliza un objeto IDisposable, debe declararlo y crear una instancia en una instrucción using. La declaración de uso llama al método Dispose sobre el objeto de la manera correcta y (cuando lo usa como se muestra anteriormente) también hace que el objeto salga del ámbito tan pronto como se llame a Dispose. Dentro del bloque que usa, el objeto es de solo lectura y no se puede modificar ni reasignar.

Esto viene de: here

La documentación de Microsoft indica que el uso tiene una doble función ( https://msdn.microsoft.com/en-us/library/zhdeatwt.aspx ), tanto como directiva como en declaraciones . Como una declaración , como se señaló aquí en otras respuestas, la palabra clave es básicamente azúcar sintáctica para determinar un alcance para disponer un objeto IDisponible . Como directiva , se usa de manera rutinaria para importar espacios de nombres y tipos. También como directiva, puede crear alias para espacios de nombres y tipos, como se señala en el libro "C # 5.0 En pocas palabras: la guía definitiva" ( http://www.amazon.com/5-0-Nutshell-The-Definitive-Reference-ebook/dp/B008E6I1K8 ), de Joseph y Ben Albahari. Un ejemplo:

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; } } }

Esto es algo que debe adoptarse con prudencia, ya que el abuso de esta práctica puede dañar la claridad del código de una persona. Hay una buena explicación sobre los alias de C #, que también mencionan ventajas y desventajas, en DotNetPearls ( http://www.dotnetperls.com/using-alias ).

La palabra clave using define el alcance del objeto y luego lo desecha cuando el alcance está completo. Por ejemplo.

using (Font font2 = new Font("Arial", 10.0f)) { // use font2 }

Consulte here el artículo de MSDN sobre la palabra clave C #.

Lo he usado mucho en el pasado para trabajar con flujos de entrada y salida. Puede anidarlos bien y elimina muchos de los problemas potenciales con los que normalmente se encuentra (mediante la eliminación automática de llamadas). Por ejemplo:

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(); } } }

No es que sea muy importante, pero el uso también se puede usar para cambiar recursos sobre la marcha. Sí, disponible como se mencionó anteriormente, pero tal vez específicamente no desea que los recursos no coincidan con otros recursos durante el resto de su ejecución. Así que quieres deshacerte de él para que no interfiera en ningún otro lado.

Otro ejemplo de un uso razonable en el que el objeto se elimina inmediatamente:

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); } }

Otro gran uso del uso es cuando se crea una instancia de un diálogo modal.

Using frm as new Form1 Form1.ShowDialog '' do stuff here End Using

Para mí, el nombre "usar" es un poco confuso, porque puede ser una directiva para importar un espacio de nombres o una declaración (como la que se analiza aquí) para el manejo de errores.

Un nombre diferente para el manejo de errores hubiera sido bueno, y tal vez uno más obvio.

Puede utilizar el espacio de nombres de alias mediante el siguiente ejemplo:

using LegacyEntities = CompanyFoo.CoreLib.x86.VBComponents.CompanyObjects;

Esto se denomina una directiva de alias de uso , como puede ver, se puede usar para ocultar referencias largas si quiere que sea evidente en su código a qué se refiere, por ejemplo

LegacyEntities.Account

en lugar de

CompanyFoo.CoreLib.x86.VBComponents.CompanyObjects.Account

o simplemente

Account // It is not obvious this is a legacy entity

Solo añadiendo un poco de algo que me sorprendió no salió. La característica más interesante de usar (en mi opinión) es que no importa cómo salga del bloque de uso, siempre eliminará el objeto. Esto incluye devoluciones y excepciones.

using (var db = new DbContext()) { if(db.State == State.Closed) throw new Exception("Database connection is closed."); return db.Something.ToList(); }

No importa si se lanza la excepción o se devuelve la lista. El objeto DbContext siempre será eliminado.

También se puede utilizar para crear ámbitos para el Ejemplo:

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); } } } }

Todo lo que se encuentra fuera de las llaves está dispuesto, por lo que es bueno desechar sus objetos si no los está utilizando. Esto es así porque si tiene un objeto SqlDataAdapter y lo está usando solo una vez en el ciclo de vida de la aplicación y está llenando solo un conjunto de datos y ya no lo necesita, puede usar el código:

using(SqlDataAdapter adapter_object = new SqlDataAdapter(sql_command_parameter)) { // do stuff } // here adapter_object is disposed automatically

Usando se puede utilizar para llamar a IDisposable. También se puede utilizar para tipos de alias.

using (SqlConnection cnn = new SqlConnection()) { /*code*/} using f1 = System.Windows.Forms.Form;

se utiliza cuando tiene un recurso que desea eliminar después de que se haya utilizado.

Por ejemplo, si asigna un recurso de archivo y solo necesita usarlo en una sección del código para leer o escribir un poco, usarlo es útil para deshacerse del recurso de archivo tan pronto como lo haya hecho.

El recurso que se utiliza necesita implementar IDisposable para funcionar correctamente.

Ejemplo:

using (File file = new File (parameters)) { *code to do stuff with the file* }

utilizando, en el sentido de

using (var foo = new Bar()) { Baz(); }

En realidad es taquigrafía para un bloque try / finally. Es equivalente al código:

var foo = new Bar(); try { Baz(); } finally { foo.Dispose(); }

Notarás, por supuesto, que el primer fragmento es mucho más conciso que el segundo y también que hay muchos tipos de cosas que podrías querer hacer como limpieza incluso si se lanza una excepción. Debido a esto, hemos creado una clase que llamamos Ámbito que le permite ejecutar código arbitrario en el método Dispose. Entonces, por ejemplo, si tuviera una propiedad llamada IsWorking que siempre quiso establecer en falso después de intentar realizar una operación, lo haría así:

using (new Scope(() => IsWorking = false)) { IsWorking = true; MundaneYetDangerousWork(); }

Puede leer más sobre nuestra solución y cómo la obtuvimos here .

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 } }