Triển khai IDis Dùng chính xác

Trong các lớp học của tôi, tôi triển khai IDis Dùng như sau:

public class User : IDisposable
{
    public int id { get; protected set; }
    public string name { get; protected set; }
    public string pass { get; protected set; }

    public User(int UserID)
    {
        id = UserID;
    }
    public User(string Username, string Password)
    {
        name = Username;
        pass = Password;
    }

    // Other functions go here...

    public void Dispose()
    {
        // Clear all property values that maybe have been set
        // when the class was instantiated
        id = 0;
        name = String.Empty;
        pass = String.Empty;
    }
}

Trong VS2012, Phân tích mã của tôi nói rằng triển khai IDis Dùng chính xác, nhưng tôi không chắc mình đã làm gì sai ở đây.
Văn bản chính xác như sau:

CA1063 Triển khai IDis Dùng chính xác Cung cấp một triển khai Vượt qua (bool) có thể vượt quá trên 'Người dùng' hoặc đánh dấu loại là được niêm phong. Một cuộc gọi đến Vứt bỏ (sai) chỉ nên dọn sạch các tài nguyên bản địa. Một cuộc gọi đến Vứt bỏ (đúng) sẽ dọn sạch cả tài nguyên gốc và được quản lý. người dùng st.cs 10

Để tham khảo: CA1063: Triển khai IDis Dùng chính xác

Tôi đã đọc qua trang này, nhưng tôi sợ tôi không thực sự hiểu những gì cần phải làm ở đây.

Nếu bất cứ ai có thể giải thích bằng nhiều thuật ngữ hơn về vấn đề là gì và / hoặc cách IDis Dùng nên được thực hiện, điều đó sẽ thực sự có ích!

Đây sẽ là cách thực hiện chính xác, mặc dù tôi không thấy bất cứ điều gì bạn cần loại bỏ trong mã bạn đã đăng. Bạn chỉ cần thực hiện IDisposablekhi:

1. Bạn có tài nguyên không được quản lý
2. Bạn đang giữ các tài liệu tham khảo về những thứ mà bản thân chỉ dùng một lần.

Không có gì trong mã bạn đăng cần phải được xử lý.

public class User : IDisposable
{
    public int id { get; protected set; }
    public string name { get; protected set; }
    public string pass { get; protected set; }

    public User(int userID)
    {
        id = userID;
    }
    public User(string Username, string Password)
    {
        name = Username;
        pass = Password;
    }

    // Other functions go here...

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    protected virtual void Dispose(bool disposing)
    {
        if (disposing) 
        {
            // free managed resources
        }
        // free native resources if there are any.
    }
}

Trước hết, bạn không cần phải "dọn dẹp" stringvà intchúng sẽ được người thu gom rác tự động chăm sóc. Điều duy nhất cần được làm sạch Disposelà các tài nguyên không được quản lý hoặc các nguồn được quản lý thực hiện IDisposable.

Tuy nhiên, giả sử đây chỉ là một bài tập học tập, cách thực hiện được đề xuấtIDisposable là thêm "bắt an toàn" để đảm bảo rằng bất kỳ tài nguyên nào không được xử lý hai lần:

public void Dispose()
{
    Dispose(true);

    // Use SupressFinalize in case a subclass 
    // of this type implements a finalizer.
    GC.SuppressFinalize(this);   
}
protected virtual void Dispose(bool disposing)
{
    if (!_disposed)
    {
        if (disposing) 
        {
            // Clear all property values that maybe have been set
            // when the class was instantiated
            id = 0;
            name = String.Empty;
            pass = String.Empty;
        }

        // Indicate that the instance has been disposed.
        _disposed = true;   
    }
}

Ví dụ sau đây cho thấy thực tiễn tốt nhất chung để thực hiện IDisposablegiao diện. Tài liệu tham khảo

Hãy nhớ rằng bạn cần một hàm hủy (bộ hoàn thiện) chỉ khi bạn có tài nguyên không được quản lý trong lớp. Và nếu bạn thêm một hàm hủy, bạn nên triệt tiêu Finalization trong Dispose , nếu không nó sẽ khiến các đối tượng của bạn nằm trong bộ nhớ trong hai chu kỳ rác (Lưu ý: Đọc cách Finalization hoạt động ). Dưới đây ví dụ chi tiết tất cả ở trên.

public class DisposeExample
{
    // A base class that implements IDisposable. 
    // By implementing IDisposable, you are announcing that 
    // instances of this type allocate scarce resources. 
    public class MyResource: IDisposable
    {
        // Pointer to an external unmanaged resource. 
        private IntPtr handle;
        // Other managed resource this class uses. 
        private Component component = new Component();
        // Track whether Dispose has been called. 
        private bool disposed = false;

        // The class constructor. 
        public MyResource(IntPtr handle)
        {
            this.handle = handle;
        }

        // Implement IDisposable. 
        // Do not make this method virtual. 
        // A derived class should not be able to override this method. 
        public void Dispose()
        {
            Dispose(true);
            // This object will be cleaned up by the Dispose method. 
            // Therefore, you should call GC.SupressFinalize to 
            // take this object off the finalization queue 
            // and prevent finalization code for this object 
            // from executing a second time.
            GC.SuppressFinalize(this);
        }

        // Dispose(bool disposing) executes in two distinct scenarios. 
        // If disposing equals true, the method has been called directly 
        // or indirectly by a user's code. Managed and unmanaged resources 
        // can be disposed. 
        // If disposing equals false, the method has been called by the 
        // runtime from inside the finalizer and you should not reference 
        // other objects. Only unmanaged resources can be disposed. 
        protected virtual void Dispose(bool disposing)
        {
            // Check to see if Dispose has already been called. 
            if(!this.disposed)
            {
                // If disposing equals true, dispose all managed 
                // and unmanaged resources. 
                if(disposing)
                {
                    // Dispose managed resources.
                    component.Dispose();
                }

                // Call the appropriate methods to clean up 
                // unmanaged resources here. 
                // If disposing is false, 
                // only the following code is executed.
                CloseHandle(handle);
                handle = IntPtr.Zero;

                // Note disposing has been done.
                disposed = true;

            }
        }

        // Use interop to call the method necessary 
        // to clean up the unmanaged resource.
        [System.Runtime.InteropServices.DllImport("Kernel32")]
        private extern static Boolean CloseHandle(IntPtr handle);

        // Use C# destructor syntax for finalization code. 
        // This destructor will run only if the Dispose method 
        // does not get called. 
        // It gives your base class the opportunity to finalize. 
        // Do not provide destructors in types derived from this class.
        ~MyResource()
        {
            // Do not re-create Dispose clean-up code here. 
            // Calling Dispose(false) is optimal in terms of 
            // readability and maintainability.
            Dispose(false);
        }
    }
    public static void Main()
    {
        // Insert code here to create 
        // and use the MyResource object.
    }
}

IDisposabletồn tại để cung cấp một phương tiện để bạn dọn sạch các tài nguyên không được quản lý mà Bộ thu gom rác sẽ không được dọn sạch tự động.

Tất cả các tài nguyên mà bạn đang "dọn dẹp" đều là các tài nguyên được quản lý và do đó Disposephương pháp của bạn không thực hiện được gì. Lớp học của bạn không nên thực hiện IDisposableở tất cả. Garbage Collector sẽ tự mình xử lý tất cả các lĩnh vực đó.

Bạn cần sử dụng Mẫu dùng một lần như thế này:

private bool _disposed = false;

protected virtual void Dispose(bool disposing)
{
    if (!_disposed)
    {
        if (disposing)
        {
            // Dispose any managed objects
            // ...
        }

        // Now disposed of any unmanaged objects
        // ...

        _disposed = true;
    }
}

public void Dispose()
{
    Dispose(true);
    GC.SuppressFinalize(this);  
}

// Destructor
~YourClassName()
{
    Dispose(false);
}

Bạn không cần phải thực hiện Userlớp của mình IDisposablevì lớp không thu được bất kỳ tài nguyên không được quản lý nào (tệp, kết nối cơ sở dữ liệu, v.v.). Thông thường, chúng tôi đánh dấu các lớp như IDisposablethể chúng có ít nhất một IDisposabletrường hoặc / và thuộc tính. Khi thực hiện IDisposable, tốt hơn nên đặt nó theo sơ đồ điển hình của Microsoft:

public class User: IDisposable {
  ...
  protected virtual void Dispose(Boolean disposing) {
    if (disposing) {
      // There's no need to set zero empty values to fields 
      // id = 0;
      // name = String.Empty;
      // pass = String.Empty;

      //TODO: free your true resources here (usually IDisposable fields)
    }
  }

  public void Dispose() {
    Dispose(true);

    GC.SuppressFinalize(this);
  } 
}

Idis Dùng được thực hiện bất cứ khi nào bạn muốn một bộ sưu tập rác xác định (xác nhận).

class Users : IDisposable
    {
        ~Users()
        {
            Dispose(false);
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
            // This method will remove current object from garbage collector's queue 
            // and stop calling finilize method twice 
        }    

        public void Dispose(bool disposer)
        {
            if (disposer)
            {
                // dispose the managed objects
            }
            // dispose the unmanaged objects
        }
    }

Khi tạo và sử dụng lớp Người dùng, hãy sử dụng khối "sử dụng" để tránh gọi phương thức xử lý rõ ràng:

using (Users _user = new Users())
            {
                // do user related work
            }

kết thúc khối sử dụng đã tạo Đối tượng người dùng sẽ được xử lý bằng cách gọi ẩn phương thức xử lý.

Tôi thấy rất nhiều ví dụ về mẫu Microsoft Dispose thực sự là một mẫu chống. Như nhiều người đã chỉ ra mã trong câu hỏi không yêu cầu IDis Dùng một chút nào. Nhưng nếu bạn sẽ triển khai nó ở đâu, vui lòng không sử dụng mẫu Microsoft. Câu trả lời tốt hơn sẽ được làm theo các gợi ý trong bài viết này:

https://www.codeproject.com/Articles/29534/IDisay-What-Your-Mother-Never-Told-You- About

Điều khác duy nhất có thể hữu ích là ngăn chặn cảnh báo phân tích mã đó ... https://docs.microsoft.com/en-us/visualstudio/code-quality/in-source-suppression-overview?view=vs- 2017