it-swarm-id.com

Apa kegunaan dari "menggunakan" di C #

Pengguna kokos menjawab pertanyaan indah Fitur Tersembunyi dari C # dengan menyebutkan kata kunci using. Dapatkah Anda menguraikan itu? Apa kegunaan using?

295
ubermonkey

Alasan untuk pernyataan using adalah untuk memastikan bahwa objek dibuang segera setelah keluar dari ruang lingkup, dan itu tidak memerlukan kode eksplisit untuk memastikan bahwa ini terjadi.

Seperti dalam Memahami pernyataan 'using' dalam C #, .NET CLR mengkonversi

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

untuk

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

Karena banyak orang masih melakukan:

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

Saya kira banyak orang masih tidak tahu yang dapat Anda lakukan:

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

Hal-hal seperti ini:

using (var conn = new SqlConnection("connection string"))
{
   conn.Open();

    // Execute SQL statement here on the connection you created
}

SqlConnection ini akan ditutup tanpa perlu secara eksplisit memanggil fungsi .Close(), dan ini akan terjadi bahkan jika pengecualian dilemparkan, tanpa perlu try/catch/finally.

96
Joel Coehoorn

menggunakan dapat digunakan untuk memanggil IDisposable. Itu juga dapat digunakan untuk jenis alias.

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

menggunakan, dalam arti

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

Sebenarnya singkatan untuk mencoba/akhirnya memblokir. Itu sama dengan kode:

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

Anda tentu saja akan mencatat bahwa cuplikan pertama jauh lebih ringkas daripada yang kedua dan juga ada banyak hal yang mungkin ingin Anda lakukan sebagai pembersihan meskipun pengecualian dilemparkan. Karena itu, kami membuat kelas yang kami sebut Lingkup yang memungkinkan Anda untuk mengeksekusi kode arbitrer dalam metode Buang. Jadi, misalnya, jika Anda memiliki properti bernama IsWorking yang Anda selalu ingin setel ke false setelah mencoba melakukan operasi, Anda akan melakukannya seperti ini:

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

Anda dapat membaca lebih lanjut tentang solusi kami dan bagaimana kami mendapatkannya di sini .

21
David Mitchell

Dokumentasi Microsoft menyatakan bahwa menggunakan memiliki fungsi ganda ( https://msdn.Microsoft.com/en-us/library/zhdeatwt. aspx ), baik sebagai direktif dan dalam pernyataan . Sebagai pernyataan , seperti yang ditunjukkan di sini dalam jawaban lain, kata kunci tersebut pada dasarnya adalah gula sintaksis untuk menentukan ruang lingkup untuk membuang IDisposable objek. Sebagai direktif , ini secara rutin digunakan untuk mengimpor ruang nama dan tipe. Juga sebagai arahan, Anda dapat membuat alias untuk ruang nama dan jenis, seperti yang ditunjukkan dalam buku "C # 5.0 Singkatnya: Panduan Definitif" ( http: //www.Amazon.com/5-0-Nutshell-The-Definitive-Reference-ebook/dp/B008E6I1K8 ), oleh Joseph dan Ben Albahari. Satu contoh:

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

Ini adalah sesuatu untuk diadopsi dengan bijak, karena penyalahgunaan praktik ini dapat melukai kejelasan kode seseorang. Ada penjelasan yang bagus tentang alias C #, juga menyebutkan pro dan kontra, di DotNetPearls ( http://www.dotnetperls.com/using-alias ).

10

Saya sudah banyak menggunakannya di masa lalu untuk bekerja dengan input dan output stream. Anda dapat membuat sarang dengan baik dan menghilangkan banyak masalah potensial yang biasanya Anda alami (dengan secara otomatis menelepon buang). Sebagai contoh:

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

Hanya menambahkan sedikit sesuatu yang saya terkejut tidak muncul. Fitur yang paling menarik dari menggunakan (menurut saya) adalah tidak peduli bagaimana Anda keluar dari blok menggunakan, ia akan selalu membuang objek. Ini termasuk pengembalian dan pengecualian.

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

Tidak masalah jika pengecualian dilemparkan atau daftar dikembalikan. Objek DbContext akan selalu dibuang.

8
Pluc

Penggunaan besar lainnya dari penggunaan adalah ketika memulai dialog modal.

Using frm as new Form1

Form1.ShowDialog

' do stuff here

End Using
6
Lucas

Anda dapat menggunakan alias namespace dengan contoh berikut:

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

Ini disebut menggunakan alias direktif seperti yang Anda lihat, ini dapat digunakan untuk menyembunyikan referensi yang bertele-tele jika Anda ingin membuatnya jelas dalam kode Anda apa yang Anda rujuk misalnya.

LegacyEntities.Account

dari pada

CompanyFoo.CoreLib.x86.VBComponents.CompanyObjects.Account

atau sederhana

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

Kesimpulannya, ketika Anda menggunakan variabel lokal dari tipe yang mengimplementasikan IDisposable, selalu , tanpa kecuali, gunakan using1.

Jika Anda menggunakan variabel IDisposable nonlocal, maka selalu mengimplementasikan IDisposable pola .

Dua aturan sederhana, tidak terkecuali1. Mencegah kebocoran sumber daya sebaliknya adalah rasa sakit yang nyata di * ss.


1): Satu-satunya pengecualian adalah - saat Anda menangani pengecualian. Maka mungkin lebih sedikit kode untuk memanggil Dispose secara eksplisit di blok finally.

5
Konrad Rudolph

Menariknya, Anda juga dapat menggunakan pola using/IDisposable untuk hal-hal menarik lainnya (seperti titik lain cara Rhino Mocks menggunakannya). Pada dasarnya, Anda dapat mengambil keuntungan dari fakta bahwa kompiler akan selal memanggil .Dosisikan pada objek "bekas". Jika Anda memiliki sesuatu yang perlu terjadi setelah operasi tertentu ... sesuatu yang memiliki awal dan akhir yang pasti ... maka Anda bisa membuat kelas IDisposable yang memulai operasi di konstruktor, dan selesai di metode Buang.

Ini memungkinkan Anda untuk menggunakan sintaks menggunakan Nice untuk menunjukkan awal dan akhir operasi yang eksplisit tersebut. Ini juga cara kerja System.Transactions.

4
Joel Martinez
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 
            }
    }
3
Shiraj Momin

Saat menggunakan ADO.NET Anda dapat menggunakan keywork untuk hal-hal seperti objek koneksi Anda atau objek pembaca. Dengan begitu ketika blok kode selesai akan secara otomatis membuang koneksi Anda.

3
Joseph Daigle

"using" juga dapat digunakan untuk menyelesaikan konflik ruang nama. Lihat http://www.davidarno.org/c-howtos/aliases-overcoming-name-conflicts/ untuk tutorial singkat yang saya tulis tentang masalah ini.

3
David Arno

sing digunakan ketika Anda memiliki sumber daya yang ingin Anda buang setelah digunakan.

Misalnya jika Anda mengalokasikan sumber daya File dan hanya perlu menggunakannya dalam satu bagian kode untuk sedikit membaca atau menulis, menggunakan sangat membantu untuk membuang sumber daya File segera setelah Anda selesai.

Sumber daya yang digunakan perlu menerapkan IDisposable agar berfungsi dengan benar.

Contoh:

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

Pernyataan menggunakan memberitahu .NET untuk melepaskan objek yang ditentukan dalam blok menggunakan setelah tidak lagi diperlukan. Jadi, Anda harus menggunakan blok 'using' untuk kelas yang membutuhkan pembersihan setelah mereka, seperti Jenis System.IO.

1

Ada dua penggunaan menggunakan kata kunci di C # sebagai berikut.

  1. sebagai arahan

Secara umum kami menggunakan kata kunci menggunakan untuk menambahkan ruang nama dalam kode di belakang dan file kelas. Kemudian tersedia semua kelas, antarmuka, dan kelas abstrak serta metode dan propertinya di halaman saat ini.

Ex:

using System.IO;  
  1. sebagai pernyataan

Ini adalah cara lain untuk menggunakan kata kunci menggunakan di C #. Ini memainkan peran penting dalam meningkatkan kinerja dalam Pengumpulan Sampah. Pernyataan menggunakan memastikan bahwa Buang () dipanggil bahkan jika pengecualian terjadi ketika Anda membuat objek dan metode panggilan, properti, dan sebagainya. Buang () adalah metode yang ada di antarmuka IDisposable yang membantu menerapkan Pengumpulan Sampah kustom. Dengan kata lain jika saya melakukan beberapa operasi database (Sisipkan, Perbarui, Hapus) tetapi entah bagaimana pengecualian terjadi maka di sini pernyataan menggunakan menutup koneksi secara otomatis. Tidak perlu memanggil metode koneksi Tutup () secara eksplisit.

Faktor penting lainnya adalah membantu dalam Connection Pooling. Koneksi Pooling di .NET membantu menghilangkan penutupan koneksi database beberapa kali. Ini mengirimkan objek koneksi ke kolam untuk digunakan di masa depan (panggilan database berikutnya). Lain kali koneksi database dipanggil dari aplikasi Anda pool koneksi mengambil objek yang tersedia di pool. Sehingga sangat membantu untuk meningkatkan kinerja aplikasi. Jadi ketika kita menggunakan statemen using the controller mengirimkan objek ke pool koneksi secara otomatis, tidak perlu memanggil metode Close () dan Dispose () secara eksplisit.

Anda dapat melakukan hal yang sama seperti apa yang dilakukan pernyataan menggunakan dengan menggunakan blok coba-tangkap dan panggil Buang () di dalam blok akhirnya secara eksplisit. Tetapi pernyataan menggunakan melakukan panggilan secara otomatis untuk membuat kode lebih bersih dan lebih elegan. Di dalam blok menggunakan, objek hanya-baca dan tidak dapat dimodifikasi atau dipindahkan.

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

Dalam kode sebelumnya saya tidak menutup koneksi apa pun, itu akan menutup secara otomatis. Pernyataan using akan memanggil conn.Close () secara otomatis karena pernyataan using (using (SqlConnection conn = new SqlConnection (connString)) dan hal yang sama untuk objek SqlDataReader. Dan juga jika ada pengecualian, ia akan menutup koneksi secara otomatis.

Untuk info lebih lanjut -> https://www.c-sharpcorner.com/UploadFile/manas1/usage-and-importance-of-using-in-C-Sharp472/

1

Bagi saya nama "using" sedikit membingungkan, karena ini bisa menjadi arahan untuk mengimpor Namespace atau pernyataan (seperti yang dibahas di sini) untuk penanganan kesalahan.

Nama yang berbeda untuk penanganan kesalahan pasti Nice, dan mungkin yang entah bagaimana lebih jelas.

1
Seb

Ini juga dapat digunakan untuk membuat cakupan untuk Contoh:

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

}
1
Siamand

Bukan berarti itu sangat penting, tetapi menggunakan juga dapat digunakan untuk mengubah sumber daya dengan cepat. Ya sekali pakai seperti yang disebutkan sebelumnya, tetapi mungkin secara khusus Anda tidak ingin sumber daya mereka tidak cocok dengan sumber daya lainnya selama sisa eksekusi Anda. Jadi, Anda ingin membuangnya agar tidak mengganggu di tempat lain.

1
Scot McPherson

The Rhino Mocks Record-playback Syntax membuat penggunaan menarik using.

1
Gilligan

Pernyataan menggunakan menyediakan mekanisme kenyamanan untuk menggunakan objek IDisposable dengan benar. Sebagai aturan, ketika Anda menggunakan objek IDisposable, Anda harus mendeklarasikan dan membuat instance dalam pernyataan menggunakan. Pernyataan menggunakan memanggil metode Buang pada objek dengan cara yang benar, dan (ketika Anda menggunakannya seperti yang ditunjukkan sebelumnya) juga menyebabkan objek itu sendiri keluar dari ruang lingkup segera setelah Buang disebut. Di dalam blok menggunakan, objek hanya-baca dan tidak dapat dimodifikasi atau dipindahkan.

Ini berasal dari: di sini

1
snowell

Berkat komentar di bawah ini, saya akan sedikit membersihkan posting ini (saya seharusnya tidak menggunakan kata-kata 'pengumpulan sampah' pada saat itu, permintaan maaf):
Saat Anda menggunakan menggunakan, itu akan memanggil metode Buang () pada objek di akhir ruang lingkup menggunakan. Jadi Anda dapat memiliki sedikit kode pembersihan yang hebat dalam metode Buang () Anda.
. dan selesaikan di beberapa titik, yang setidaknya akan membuang-buang sumber daya jika Anda sudah Buang () d dari itu.

1
Grank

Segala sesuatu di luar kurung keriting dibuang, jadi itu bagus untuk membuang benda Anda jika Anda tidak menggunakannya. Ini karena jika Anda memiliki objek SqlDataAdapter dan Anda menggunakannya hanya sekali dalam siklus hidup aplikasi dan Anda mengisi hanya satu dataset dan Anda tidak membutuhkannya lagi, Anda dapat menggunakan kode:

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

Kata kunci yang menggunakan mendefinisikan lingkup untuk objek dan kemudian membuang objek ketika cakupan selesai. Sebagai contoh.

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

Lihat di sini untuk artikel MSDN di C # menggunakan kata kunci.

1
David Basarab

Contoh lain dari penggunaan yang wajar di mana objek tersebut segera dibuang:

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);
    }
}
1
Brendan Kendrick