Các ứng dụng của sử dụng trên mạng trong C # là gì?

Người dùng kokos đã trả lời các Tính năng ẩn tuyệt vời của câu hỏi C # bằng cách đề cập đến usingtừ khóa. bạn có thể giải thích về điều đó không? Công dụng của là usinggì?

Lý do của usingtuyên bố là để đảm bảo rằng đối tượng được xử lý ngay khi nó ra khỏi phạm vi và nó không yêu cầu mã rõ ràng để đảm bảo rằng điều này xảy ra.

Như trong Tìm hiểu câu lệnh 'bằng cách sử dụng' trong C # (codeproject) và Sử dụng các đối tượng triển khai IDis Dùng (microsoft) , trình biên dịch C # chuyển đổi

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

đến

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

C # 8 giới thiệu một cú pháp mới, được đặt tên là " sử dụng khai báo ":

Một khai báo sử dụng là một khai báo biến trước từ khóa sử dụng. Nó báo cho trình biên dịch rằng biến được khai báo nên được xử lý ở cuối phạm vi kèm theo.

Vì vậy, mã tương đương ở trên sẽ là:

using var myRes = new MyResource();
myRes.DoSomething();

Và khi điều khiển rời khỏi phạm vi chứa (thường là một phương thức, nhưng nó cũng có thể là một khối mã), myRessẽ bị loại bỏ.

Vì nhiều người vẫn làm:

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

Tôi đoán rất nhiều người vẫn không biết rằng bạn có thể làm:

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

Những thứ như thế này:

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

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

Điều này SqlConnectionsẽ được đóng lại mà không cần phải gọi .Close()hàm một cách rõ ràng , và điều này sẽ xảy ra ngay cả khi một ngoại lệ được ném , mà không cần a try/ catch/ finally.

sử dụng có thể được sử dụng để gọi IDis Dùng. Nó cũng có thể được sử dụng để các loại bí danh.

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

sử dụng, theo nghĩa

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

Thực sự là tốc ký cho một khối thử / cuối cùng. Nó tương đương với mã:

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

Tất nhiên, bạn sẽ lưu ý rằng đoạn mã đầu tiên ngắn gọn hơn đoạn thứ hai và cũng có nhiều loại mà bạn có thể muốn làm như dọn dẹp ngay cả khi ném ngoại lệ. Vì điều này, chúng tôi đã đưa ra một lớp mà chúng tôi gọi là Phạm vi cho phép bạn thực thi mã tùy ý trong phương thức Vứt bỏ. Vì vậy, ví dụ, nếu bạn có một thuộc tính có tên IsWorking mà bạn luôn muốn đặt thành false sau khi thử thực hiện một thao tác, bạn sẽ làm như thế này:

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

Bạn có thể đọc thêm về giải pháp của chúng tôi và cách chúng tôi bắt nguồn từ đây .

Tài liệu của Microsoft tuyên bố rằng việc sử dụng có chức năng kép ( https://msdn.microsoft.com/en-us/l Library / zdeatwt.aspx ), cả dưới dạng chỉ thị và trong câu lệnh . Như một tuyên bố , như đã được chỉ ra ở đây trong các câu trả lời khác, từ khóa về cơ bản là đường cú pháp để xác định phạm vi để loại bỏ một đối tượng IDis Dùng . Theo chỉ thị , nó thường được sử dụng để nhập các không gian tên và kiểu. Cũng như một chỉ thị, bạn có thể tạo bí danh cho không gian tên và loại, như được chỉ ra trong cuốn sách "C # 5.0 In a Nutshell: The Definitive Guide" ( http://www.amazon.com/5-0-Nutshell-The- Definitive-Reference-ebook / dp / B008E6I1K8), bởi Joseph và Ben Albahari. Một ví dụ:

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

Đây là một cái gì đó để áp dụng một cách khôn ngoan, vì việc lạm dụng thực hành này có thể làm tổn thương sự rõ ràng của mã của một người. Có một lời giải thích hay về bí danh C #, cũng đề cập đến ưu và nhược điểm, trong DotNetPearls ( http://www.dotnetperls.com/USE-alias ).

Tôi đã sử dụng nó rất nhiều trong quá khứ để làm việc với các luồng đầu vào và đầu ra. Bạn có thể lồng chúng độc đáo và nó sẽ loại bỏ rất nhiều vấn đề tiềm ẩn mà bạn thường gặp phải (bằng cách tự động gọi xử lý). Ví dụ:

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

Chỉ cần thêm một chút gì đó mà tôi đã ngạc nhiên đã không đến. Tính năng thú vị nhất của việc sử dụng (theo ý kiến ​​của tôi) là không có vấn đề gì về cách bạn thoát khỏi khối sử dụng, nó sẽ luôn loại bỏ đối tượng. Điều này bao gồm lợi nhuận và ngoại lệ.

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

Không có vấn đề gì nếu ngoại lệ được ném hoặc danh sách được trả về. Đối tượng DbContext sẽ luôn được xử lý.

Một công dụng tuyệt vời khác của việc sử dụng là khi khởi tạo một hộp thoại phương thức.

Using frm as new Form1

Form1.ShowDialog

' do stuff here

End Using

Tóm lại, khi bạn sử dụng biến cục bộ của loại thực hiện IDisposable, luôn luôn , không có ngoại lệ, hãy sử dụng using¹ .

Nếu bạn sử dụng IDisposablecác biến không nhắm mục tiêu , thì luôn luôn thực hiện IDisposablemẫu .

Hai quy tắc đơn giản, không có ngoại lệ ¹ . Ngăn chặn rò rỉ tài nguyên nếu không là một nỗi đau thực sự trong * ss.

¹⁾ : Ngoại lệ duy nhất là - khi bạn xử lý ngoại lệ. Sau đó, nó có thể là ít mã hơn để gọi Disposerõ ràng trong finallykhối.

Bạn có thể sử dụng không gian tên bí danh bằng ví dụ sau:

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

Đây được gọi là một chỉ thị bí danh như bạn có thể thấy, nó có thể được sử dụng để ẩn các tham chiếu dài dòng nếu bạn muốn làm cho nó rõ ràng trong mã của bạn những gì bạn đang đề cập đến, vd

LegacyEntities.Account

thay vì

CompanyFoo.CoreLib.x86.VBComponents.CompanyObjects.Account

hoặc đơn giản

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

Thật thú vị, bạn cũng có thể sử dụng mẫu sử dụng / IDis Dùng cho những thứ thú vị khác (chẳng hạn như điểm khác của cách Rhino Mocks sử dụng nó). Về cơ bản, bạn có thể tận dụng thực tế là trình biên dịch sẽ luôn gọi .Dispose trên đối tượng "đã sử dụng". Nếu bạn có một cái gì đó cần phải xảy ra sau một hoạt động nhất định ... một cái gì đó có bắt đầu và kết thúc rõ ràng ... thì bạn có thể chỉ cần tạo một lớp IDis Dùng để bắt đầu hoạt động trong hàm tạo, và sau đó kết thúc trong phương thức Vứt bỏ.

Điều này cho phép bạn sử dụng cú pháp thực sự tốt đẹp để biểu thị sự bắt đầu và kết thúc rõ ràng của hoạt động nói. Đây cũng là cách các công cụ System.Transilities hoạt động.

Khi sử dụng ADO.NET, bạn có thể sử dụng keywork cho những thứ như đối tượng kết nối hoặc đối tượng người đọc. Theo cách đó, khi khối mã hoàn thành, nó sẽ tự động loại bỏ kết nối của bạn.

"Sử dụng" cũng có thể được sử dụng để giải quyết xung đột không gian tên. Xem http://www.davidarno.org/c-howtos/aliases-overasing-name-conflicts/ để biết hướng dẫn ngắn tôi đã viết về chủ đề này.

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

sử dụng được sử dụng khi bạn có một tài nguyên mà bạn muốn xử lý sau khi nó được sử dụng.

Chẳng hạn, nếu bạn phân bổ tài nguyên Tệp và chỉ cần sử dụng nó trong một phần mã để đọc hoặc viết, sử dụng rất hữu ích cho việc xử lý tài nguyên Tệp ngay khi bạn hoàn thành.

Tài nguyên đang được sử dụng cần triển khai IDis Dùng để hoạt động đúng.

Thí dụ:

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

Từ khóa sử dụng xác định phạm vi cho đối tượng và sau đó loại bỏ đối tượng khi phạm vi hoàn thành. Ví dụ.

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

Xem ở đây để biết bài viết MSDN về từ khóa C #.

Không phải là nó cực kỳ quan trọng, nhưng việc sử dụng cũng có thể được sử dụng để thay đổi tài nguyên một cách nhanh chóng. Có dùng một lần như đã đề cập trước đó, nhưng có lẽ cụ thể là bạn không muốn các tài nguyên mà chúng không khớp với các tài nguyên khác trong suốt thời gian thực hiện. Vì vậy, bạn muốn loại bỏ nó để nó không can thiệp vào nơi khác.

Nhờ các bình luận bên dưới, tôi sẽ dọn dẹp bài đăng này một chút (Tôi không nên sử dụng các từ 'bộ sưu tập rác' vào lúc đó, xin lỗi):
Khi bạn sử dụng, nó sẽ gọi phương thức Dispose () trên đối tượng ở cuối phạm vi sử dụng. Vì vậy, bạn có thể có khá nhiều mã dọn dẹp tuyệt vời trong phương thức Dispose () của mình.
Một gạch đầu dòng ở đây hy vọng có thể có được sự không đánh dấu này: Nếu bạn triển khai IDis Dùng một lần, hãy đảm bảo bạn gọi cho GC.SuppressFinalize () trong triển khai Dispose () của bạn, vì nếu không, bộ sưu tập rác tự động sẽ cố gắng đi cùng và Hoàn thiện nó tại một số điểm, mà ít nhất sẽ là một sự lãng phí tài nguyên nếu bạn đã vứt bỏ () d của nó.

Một ví dụ khác về việc sử dụng hợp lý trong đó đối tượng được xử lý ngay lập tức:

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

Tất cả mọi thứ bên ngoài dấu ngoặc nhọn đều được xử lý, vì vậy thật tuyệt vời khi loại bỏ các đối tượng của bạn nếu bạn không sử dụng chúng. Điều này là như vậy bởi vì nếu bạn có một đối tượng SqlDataAd CHƯƠNG và bạn chỉ sử dụng nó một lần trong vòng đời ứng dụng và bạn chỉ điền vào một tập dữ liệu và bạn không cần nó nữa, bạn có thể sử dụng mã:

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

Câu lệnh sử dụng cung cấp một cơ chế tiện lợi để sử dụng chính xác các đối tượng IDis Dùng. Theo quy định, khi bạn sử dụng một đối tượng IDis Dùng một lần, bạn nên khai báo và khởi tạo nó trong một câu lệnh sử dụng. Câu lệnh sử dụng gọi phương thức Dispose trên đối tượng theo đúng cách và (khi bạn sử dụng nó như được hiển thị trước đó), nó cũng làm cho chính đối tượng đi ra khỏi phạm vi ngay khi được gọi là Dispose. Trong khối sử dụng, đối tượng chỉ đọc và không thể sửa đổi hoặc gán lại.

Điều này đến từ: đây

Đối với tôi, tên "bằng cách sử dụng" hơi khó hiểu, bởi vì có thể là một lệnh để nhập một Không gian tên hoặc một câu lệnh (như câu lệnh được thảo luận ở đây) để xử lý lỗi.

Một tên khác để xử lý lỗi sẽ rất hay và có thể là một tên rõ ràng hơn.

Nó cũng có thể được sử dụng để tạo phạm vi cho Ví dụ:

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

}

Câu lệnh sử dụng yêu cầu .NET giải phóng đối tượng được chỉ định trong khối sử dụng một khi nó không còn cần thiết nữa. Vì vậy, bạn nên sử dụng khối 'bằng cách sử dụng' cho các lớp yêu cầu dọn dẹp sau chúng, như Kiểu System.IO.

Có hai cách sử dụng usingtừ khóa trong C # như sau.

1. Như một chỉ thị

   Nói chung, chúng tôi sử dụng usingtừ khóa để thêm các không gian tên trong các tệp mã phía sau và lớp. Sau đó, nó làm cho tất cả các lớp, giao diện và các lớp trừu tượng cũng như các phương thức và thuộc tính của chúng trong trang hiện tại.

   Thí dụ:

   using System.IO;

2. Như một tuyên bố

   Đây là một cách khác để sử dụng usingtừ khóa trong C #. Nó đóng một vai trò quan trọng trong việc cải thiện hiệu suất trong Bộ sưu tập rác.

   Câu usinglệnh đảm bảo rằng Dispose () được gọi ngay cả khi có ngoại lệ xảy ra khi bạn đang tạo đối tượng và gọi phương thức, thuộc tính, v.v. Vứt bỏ () là một phương thức có trong giao diện IDis Dùng để thực hiện Bộ sưu tập Rác tùy chỉnh. Nói cách khác, nếu tôi đang thực hiện một số thao tác cơ sở dữ liệu (Chèn, Cập nhật, Xóa) nhưng bằng cách nào đó, một ngoại lệ xảy ra thì ở đây câu lệnh sử dụng sẽ tự động đóng kết nối. Không cần gọi phương thức Close () một cách rõ ràng.

   Một yếu tố quan trọng khác là nó giúp kết nối Pooling. Kết nối Pooling trong .NET giúp loại bỏ việc đóng kết nối cơ sở dữ liệu nhiều lần. Nó sẽ gửi đối tượng kết nối đến một nhóm để sử dụng trong tương lai (cuộc gọi cơ sở dữ liệu tiếp theo). Lần sau, một kết nối cơ sở dữ liệu được gọi từ ứng dụng của bạn, nhóm kết nối sẽ tìm nạp các đối tượng có sẵn trong nhóm. Vì vậy, nó giúp cải thiện hiệu suất của ứng dụng. Vì vậy, khi chúng ta sử dụng câu lệnh sử dụng, bộ điều khiển sẽ tự động gửi đối tượng đến nhóm kết nối, không cần phải gọi các phương thức Close () và Dispose () một cách rõ ràng.

   Bạn có thể làm tương tự như những gì câu lệnh đang sử dụng đang làm bằng cách sử dụng khối try-Catch và gọi Dispose () bên trong khối cuối cùng một cách rõ ràng. Nhưng câu lệnh sử dụng thực hiện các cuộc gọi tự động để làm cho mã sạch hơn và thanh lịch hơn. Trong khối sử dụng, đối tượng chỉ đọc và không thể sửa đổi hoặc gán lại.

   Thí dụ:

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

Trong mã trước tôi không đóng bất kỳ kết nối nào; nó sẽ tự động đóng lại. Câu usinglệnh sẽ tự động gọi Conn.Close () do usingcâu lệnh ( using (SqlConnection conn = new SqlConnection(connString)) và tương tự cho một đối tượng SqlDataReader. Và nếu có bất kỳ ngoại lệ nào xảy ra, nó sẽ tự động đóng kết nối.

Để biết thêm thông tin, hãy xem Cách sử dụng và Tầm quan trọng của việc Sử dụng trong C # .

Các Rhino Mocks Ghi-playback Cú pháp làm cho việc sử dụng thú vị của using.

sử dụng như một câu lệnh sẽ tự động gọi xử lý trên đối tượng được chỉ định. Đối tượng phải thực hiện giao diện IDis Dùng. Có thể sử dụng một số đối tượng trong một câu lệnh miễn là chúng cùng loại.

CLR chuyển đổi mã của bạn thành MSIL. Và câu lệnh sử dụng được dịch thành một khối thử và cuối cùng. Đây là cách sử dụng câu lệnh được trình bày trong IL. Một tuyên bố sử dụng được dịch thành ba phần: mua lại, sử dụng và xử lý. Tài nguyên được lấy trước tiên, sau đó việc sử dụng được đặt trong một câu lệnh thử với mệnh đề cuối cùng. Đối tượng sau đó được xử lý trong mệnh đề cuối cùng.

Sử dụng khoản được sử dụng để xác định phạm vi cho biến cụ thể. Ví dụ:

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