Tại sao C # không triển khai các thuộc tính được lập chỉ mục?

Tôi biết, tôi biết ... Câu trả lời của Eric Lippert cho loại câu hỏi này thường là " bởi vì nó không đáng với chi phí thiết kế, thực hiện, thử nghiệm và ghi lại nó ".

Nhưng tôi vẫn muốn có một lời giải thích tốt hơn ... Tôi đang đọc bài đăng trên blog này về các tính năng mới của C # 4 và trong phần về COM Interop, phần sau thu hút sự chú ý của tôi:

Nhân tiện, đoạn mã này sử dụng một tính năng mới nữa: thuộc tính được lập chỉ mục (hãy xem kỹ các dấu ngoặc vuông sau Phạm vi.) Nhưng tính năng này chỉ khả dụng cho COM interop; bạn không thể tạo các thuộc tính được lập chỉ mục của riêng mình trong C # 4.0 .

Được rôi nhưng tại sao ? Tôi đã biết và rất tiếc vì không thể tạo các thuộc tính được lập chỉ mục trong C #, nhưng câu này khiến tôi nghĩ lại về nó. Tôi có thể thấy một số lý do chính đáng để triển khai nó:

• CLR hỗ trợ nó (ví dụ: PropertyInfo.GetValuecó một indextham số), vì vậy thật đáng tiếc chúng ta không thể tận dụng nó trong C #
• nó được hỗ trợ cho COM interop, như được hiển thị trong bài viết (sử dụng điều phối động)
• nó được thực hiện trong VB.NET
• đã có thể tạo chỉ mục, tức là áp dụng chỉ mục cho chính đối tượng, vì vậy có lẽ sẽ không có vấn đề gì lớn nếu mở rộng ý tưởng cho các thuộc tính, giữ nguyên cú pháp và chỉ thay thế thisbằng tên thuộc tính.

Nó sẽ cho phép viết những thứ như vậy:

public class Foo
{
    private string[] _values = new string[3];
    public string Values[int index]
    {
        get { return _values[index]; }
        set { _values[index] = value; }
    }
}

Hiện tại, cách giải quyết duy nhất mà tôi biết là tạo một lớp bên trong ( ValuesCollectionví dụ) thực hiện một trình chỉ mục và thay đổi thuộc Valuestính để nó trả về một thể hiện của lớp bên trong đó.

Điều này rất dễ làm, nhưng khó chịu ... Vì vậy, có lẽ trình biên dịch có thể làm điều đó cho chúng ta! Một tùy chọn sẽ là tạo một lớp bên trong triển khai trình chỉ mục và hiển thị nó thông qua một giao diện chung chung:

// interface defined in the namespace System
public interface IIndexer<TIndex, TValue>
{
    TValue this[TIndex index]  { get; set; }
}

public class Foo
{
    private string[] _values = new string[3];

    private class <>c__DisplayClass1 : IIndexer<int, string>
    {
        private Foo _foo;
        public <>c__DisplayClass1(Foo foo)
        {
            _foo = foo;
        }

        public string this[int index]
        {
            get { return _foo._values[index]; }
            set { _foo._values[index] = value; }
        }
    }

    private IIndexer<int, string> <>f__valuesIndexer;
    public IIndexer<int, string> Values
    {
        get
        {
            if (<>f__valuesIndexer == null)
                <>f__valuesIndexer = new <>c__DisplayClass1(this);
            return <>f__valuesIndexer;
        }
    }
}

Nhưng tất nhiên, trong trường hợp đó thuộc tính thực sự sẽ trả về a IIndexer<int, string>, và sẽ không thực sự là thuộc tính được lập chỉ mục ... Sẽ tốt hơn nếu tạo thuộc tính được lập chỉ mục CLR thực.

Bạn nghĩ sao ? Bạn có muốn xem tính năng này trong C # không? Nếu không, tại sao?

Đây là cách chúng tôi thiết kế C # 4.

Đầu tiên, chúng tôi lập danh sách mọi tính năng khả thi mà chúng tôi có thể nghĩ đến để thêm vào ngôn ngữ.

Sau đó, chúng tôi chèn các tính năng thành "điều này thật tệ, chúng tôi không bao giờ được làm điều đó", "điều này thật tuyệt vời, chúng tôi phải làm nó", và "điều này là tốt nhưng chúng ta đừng làm điều đó lần này".

Sau đó, chúng tôi xem xét số ngân sách chúng tôi có để thiết kế, thực hiện, thử nghiệm, lập tài liệu, vận chuyển và duy trì các tính năng "phải có" và phát hiện ra rằng chúng tôi đã vượt quá ngân sách 100%.

Vì vậy, chúng tôi đã chuyển một loạt nội dung từ nhóm "phải có" sang nhóm "tốt khi có".

Các thuộc tính được lập chỉ mục không bao giờ ở gần đầu danh sách "phải có". Họ rất thấp trong danh sách "tốt đẹp" và tán tỉnh trong danh sách "ý tưởng tồi".

Mỗi phút chúng ta dành để thiết kế, triển khai, thử nghiệm, ghi lại hoặc duy trì tính năng tốt đẹp X là một phút chúng ta không thể dành cho các tính năng tuyệt vời A, B, C, D, E, F và G. Chúng ta phải ưu tiên một cách tàn nhẫn để chúng ta chỉ làm các tính năng tốt nhất có thể. Các thuộc tính được lập chỉ mục sẽ rất tốt, nhưng không phải ở đâu cũng đủ tốt để thực sự được triển khai.

AC # indexer là một thuộc tính được lập chỉ mục. Nó được đặt tên Itemtheo mặc định (và bạn có thể tham khảo nó như vậy từ ví dụ VB), và bạn có thể thay đổi nó bằng IndexerNameAttribute nếu bạn muốn.

Tôi không rõ tại sao, cụ thể là tại sao nó lại được thiết kế theo cách đó, nhưng nó dường như là một hạn chế có chủ ý. Tuy nhiên, nó phù hợp với Nguyên tắc thiết kế khung, khuyến nghị cách tiếp cận của thuộc tính không được lập chỉ mục trả về một đối tượng có thể lập chỉ mục cho các tập hợp thành viên. Tức là "có thể lập chỉ mục" là một đặc điểm của một loại; nếu nó có thể lập chỉ mục theo nhiều cách, thì nó thực sự nên được chia thành nhiều loại.

Bởi vì bạn đã có thể làm điều đó, và nó buộc bạn phải suy nghĩ theo khía cạnh OO, việc thêm các thuộc tính được lập chỉ mục sẽ chỉ làm tăng thêm tiếng ồn cho ngôn ngữ. Và chỉ là một cách khác để làm một việc khác.

class Foo
{
    public Values Values { ... }
}

class Values
{
    public string this[int index] { ... }    
}

foo.Values[0]

Cá nhân tôi chỉ muốn xem một cách duy nhất để làm điều gì đó hơn là 10 cách. Nhưng tất nhiên đây là ý kiến ​​chủ quan.

Tôi sử dụng để ủng hộ ý tưởng của các thuộc tính được lập chỉ mục nhưng sau đó nhận ra nó sẽ làm tăng thêm sự nhập nhằng kinh khủng và thực sự disincentivize chức năng. Các thuộc tính được lập chỉ mục có nghĩa là bạn không có phiên bản tập hợp con. Điều đó vừa tốt vừa xấu. Sẽ ít rắc rối hơn khi triển khai và bạn không cần tham chiếu trở lại lớp chủ sở hữu bao quanh. Nhưng nó cũng có nghĩa là bạn không thể chuyển tập hợp con đó cho bất cứ thứ gì; bạn có thể phải liệt kê mọi lúc. Bạn cũng không thể làm gì trước về nó. Tệ nhất là bạn không thể biết được khi nhìn vào một thuộc tính được lập chỉ mục là thuộc tính đó hay thuộc tính bộ sưu tập.

Ý tưởng là hợp lý nhưng nó chỉ dẫn đến sự thiếu linh hoạt và đột ngột khó xử.

Tôi thấy việc thiếu các thuộc tính được lập chỉ mục rất khó chịu khi cố gắng viết mã ngắn gọn, rõ ràng. Thuộc tính được lập chỉ mục có nội hàm rất khác với việc cung cấp một tham chiếu lớp được lập chỉ mục hoặc cung cấp các phương thức riêng lẻ. Tôi thấy hơi phiền khi cung cấp quyền truy cập vào một đối tượng bên trong triển khai một thuộc tính được lập chỉ mục thậm chí còn được coi là có thể chấp nhận được vì điều đó thường phá vỡ một trong những thành phần chính của hướng đối tượng: tính đóng gói.

Tôi gặp phải vấn đề này thường xuyên, nhưng tôi lại gặp phải nó hôm nay nên tôi sẽ cung cấp một ví dụ về mã trong thế giới thực. Giao diện và lớp được viết lưu trữ cấu hình ứng dụng là một tập hợp các thông tin liên quan lỏng lẻo. Tôi cần thêm các đoạn tập lệnh được đặt tên và việc sử dụng trình lập chỉ mục lớp không tên sẽ ngụ ý một ngữ cảnh rất sai vì các đoạn tập lệnh chỉ là một phần của cấu hình.

Nếu các thuộc tính được lập chỉ mục có sẵn trong C #, tôi có thể đã triển khai mã bên dưới (cú pháp là [key] này được thay đổi thành PropertyName [key]).

public interface IConfig
{
    // Other configuration properties removed for examp[le

    /// <summary>
    /// Script fragments
    /// </summary>
    string Scripts[string name] { get; set; }
}

/// <summary>
/// Class to handle loading and saving the application's configuration.
/// </summary>
internal class Config : IConfig, IXmlConfig
{
  #region Application Configuraiton Settings

    // Other configuration properties removed for examp[le

    /// <summary>
    /// Script fragments
    /// </summary>
    public string Scripts[string name]
    {
        get
        {
            if (!string.IsNullOrWhiteSpace(name))
            {
                string script;
                if (_scripts.TryGetValue(name.Trim().ToLower(), out script))
                    return script;
            }
            return string.Empty;
        }
        set
        {
            if (!string.IsNullOrWhiteSpace(name))
            {
                _scripts[name.Trim().ToLower()] = value;
                OnAppConfigChanged();
            }
        }
    }
    private readonly Dictionary<string, string> _scripts = new Dictionary<string, string>();

  #endregion

    /// <summary>
    /// Clears configuration settings, but does not clear internal configuration meta-data.
    /// </summary>
    private void ClearConfig()
    {
        // Other properties removed for example
        _scripts.Clear();
    }

  #region IXmlConfig

    void IXmlConfig.XmlSaveTo(int configVersion, XElement appElement)
    {
        Debug.Assert(configVersion == 2);
        Debug.Assert(appElement != null);

        // Saving of other properties removed for example

        if (_scripts.Count > 0)
        {
            var scripts = new XElement("Scripts");
            foreach (var kvp in _scripts)
            {
                var scriptElement = new XElement(kvp.Key, kvp.Value);
                scripts.Add(scriptElement);
            }
            appElement.Add(scripts);
        }
    }

    void IXmlConfig.XmlLoadFrom(int configVersion, XElement appElement)
    {
        // Implementation simplified for example

        Debug.Assert(appElement != null);
        ClearConfig();
        if (configVersion == 2)
        {
            // Loading of other configuration properites removed for example

            var scripts = appElement.Element("Scripts");
            if (scripts != null)
                foreach (var script in scripts.Elements())
                    _scripts[script.Name.ToString()] = script.Value;
        }
        else
            throw new ApplicaitonException("Unknown configuration file version " + configVersion);
    }

  #endregion
}

Thật không may, các thuộc tính được lập chỉ mục không được triển khai vì vậy tôi đã triển khai một lớp để lưu trữ chúng và cung cấp quyền truy cập vào đó. Đây là một triển khai không mong muốn vì mục đích của lớp cấu hình trong mô hình miền này là đóng gói tất cả các chi tiết. Khách hàng của lớp này sẽ truy cập các đoạn script cụ thể theo tên và không có lý do gì để đếm hoặc liệt kê chúng.

Tôi có thể đã thực hiện điều này như:

public string ScriptGet(string name)
public void ScriptSet(string name, string value)

Điều mà tôi có lẽ nên có, nhưng đây là một minh họa hữu ích về lý do tại sao việc sử dụng các lớp được lập chỉ mục để thay thế cho tính năng bị thiếu này thường không phải là một sự thay thế hợp lý.

Để triển khai khả năng tương tự như một thuộc tính được lập chỉ mục, tôi phải viết đoạn mã dưới đây mà bạn sẽ nhận thấy là dài hơn, phức tạp hơn đáng kể và do đó khó đọc, hiểu và duy trì hơn.

public interface IConfig
{
    // Other configuration properties removed for examp[le

    /// <summary>
    /// Script fragments
    /// </summary>
    ScriptsCollection Scripts { get; }
}

/// <summary>
/// Class to handle loading and saving the application's configuration.
/// </summary>
internal class Config : IConfig, IXmlConfig
{
    public Config()
    {
        _scripts = new ScriptsCollection();
        _scripts.ScriptChanged += ScriptChanged;
    }

  #region Application Configuraiton Settings

    // Other configuration properties removed for examp[le

    /// <summary>
    /// Script fragments
    /// </summary>
    public ScriptsCollection Scripts
    { get { return _scripts; } }
    private readonly ScriptsCollection _scripts;

    private void ScriptChanged(object sender, ScriptChangedEventArgs e)
    {
        OnAppConfigChanged();
    }

  #endregion

    /// <summary>
    /// Clears configuration settings, but does not clear internal configuration meta-data.
    /// </summary>
    private void ClearConfig()
    {
        // Other properties removed for example
        _scripts.Clear();
    }

  #region IXmlConfig

    void IXmlConfig.XmlSaveTo(int configVersion, XElement appElement)
    {
        Debug.Assert(configVersion == 2);
        Debug.Assert(appElement != null);

        // Saving of other properties removed for example

        if (_scripts.Count > 0)
        {
            var scripts = new XElement("Scripts");
            foreach (var kvp in _scripts)
            {
                var scriptElement = new XElement(kvp.Key, kvp.Value);
                scripts.Add(scriptElement);
            }
            appElement.Add(scripts);
        }
    }

    void IXmlConfig.XmlLoadFrom(int configVersion, XElement appElement)
    {
        // Implementation simplified for example

        Debug.Assert(appElement != null);
        ClearConfig();
        if (configVersion == 2)
        {
            // Loading of other configuration properites removed for example

            var scripts = appElement.Element("Scripts");
            if (scripts != null)
                foreach (var script in scripts.Elements())
                    _scripts[script.Name.ToString()] = script.Value;
        }
        else
            throw new ApplicaitonException("Unknown configuration file version " + configVersion);
    }

  #endregion
}

public class ScriptsCollection : IEnumerable<KeyValuePair<string, string>>
{
    private readonly Dictionary<string, string> Scripts = new Dictionary<string, string>();

    public string this[string name]
    {
        get
        {
            if (!string.IsNullOrWhiteSpace(name))
            {
                string script;
                if (Scripts.TryGetValue(name.Trim().ToLower(), out script))
                    return script;
            }
            return string.Empty;
        }
        set
        {
            if (!string.IsNullOrWhiteSpace(name))
                Scripts[name.Trim().ToLower()] = value;
        }
    }

    public void Clear()
    {
        Scripts.Clear();
    }

    public int Count
    {
        get { return Scripts.Count; }
    }

    public event EventHandler<ScriptChangedEventArgs> ScriptChanged;

    protected void OnScriptChanged(string name)
    {
        if (ScriptChanged != null)
        {
            var script = this[name];
            ScriptChanged.Invoke(this, new ScriptChangedEventArgs(name, script));
        }
    }

  #region IEnumerable

    public IEnumerator<KeyValuePair<string, string>> GetEnumerator()
    {
        return Scripts.GetEnumerator();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }

  #endregion
}

public class ScriptChangedEventArgs : EventArgs
{
    public string Name { get; set; }
    public string Script { get; set; }

    public ScriptChangedEventArgs(string name, string script)
    {
        Name = name;
        Script = script;
    }
}

Một giải pháp khác được liệt kê tại Dễ dàng tạo các thuộc tính hỗ trợ lập chỉ mục trong C # , yêu cầu ít công việc hơn.

CHỈNH SỬA : Tôi cũng nên nói thêm rằng để trả lời cho câu hỏi ban đầu, rằng nếu chúng ta có thể hoàn thành cú pháp mong muốn, với sự hỗ trợ của thư viện, thì tôi nghĩ cần phải có một trường hợp rất mạnh để thêm nó trực tiếp vào ngôn ngữ, để giảm thiểu sự cồng kềnh ngôn ngữ.

Tôi có thể nói rằng họ đã không thêm nó vào vì nó không đáng với chi phí thiết kế, thực hiện, thử nghiệm và ghi lại nó.

Nói đùa sang một bên, có lẽ vì cách giải quyết đơn giản và tính năng không bao giờ khiến thời gian so với lợi ích bị cắt giảm. Tuy nhiên, tôi sẽ không ngạc nhiên khi thấy điều này xuất hiện dưới dạng một sự thay đổi.

Bạn cũng quên đề cập rằng một cách giải quyết dễ dàng hơn chỉ là tạo một phương pháp thông thường:

public void SetFoo(int index, Foo toSet) {...}
public Foo GetFoo(int index) {...}

Có một giải pháp chung đơn giản sử dụng lambdas để ủy quyền cho chức năng lập chỉ mục

Để lập chỉ mục chỉ đọc

public class RoIndexer<TIndex, TValue>
{
    private readonly Func<TIndex, TValue> _Fn;

    public RoIndexer(Func<TIndex, TValue> fn)
    {
        _Fn = fn;
    }

    public TValue this[TIndex i]
    {
        get
        {
            return _Fn(i);
        }
    }
}

Để lập chỉ mục có thể thay đổi

public class RwIndexer<TIndex, TValue>
{
    private readonly Func<TIndex, TValue> _Getter;
    private readonly Action<TIndex, TValue> _Setter;

    public RwIndexer(Func<TIndex, TValue> getter, Action<TIndex, TValue> setter)
    {
        _Getter = getter;
        _Setter = setter;
    }

    public TValue this[TIndex i]
    {
        get
        {
            return _Getter(i);
        }
        set
        {
            _Setter(i, value);
        }
    }
}

và một nhà máy

public static class Indexer
{
    public static RwIndexer<TIndex, TValue> Create<TIndex, TValue>(Func<TIndex, TValue> getter, Action<TIndex, TValue> setter)
    {
        return new RwIndexer<TIndex, TValue>(getter, setter);
    } 
    public static RoIndexer<TIndex, TValue> Create<TIndex, TValue>(Func<TIndex, TValue> getter)
    {
        return new RoIndexer<TIndex, TValue>(getter);
    } 
}

trong mã của riêng tôi, tôi sử dụng nó như

public class MoineauFlankContours
{

    public MoineauFlankContour Rotor { get; private set; }

    public MoineauFlankContour Stator { get; private set; }

     public MoineauFlankContours()
    {
        _RoIndexer = Indexer.Create(( MoineauPartEnum p ) => 
            p == MoineauPartEnum.Rotor ? Rotor : Stator);
    }
    private RoIndexer<MoineauPartEnum, MoineauFlankContour> _RoIndexer;

    public RoIndexer<MoineauPartEnum, MoineauFlankContour> FlankFor
    {
        get
        {
            return _RoIndexer;
        }
    }

}

và với một phiên bản của MoineauFlankContours tôi có thể làm

MoineauFlankContour rotor = contours.FlankFor[MoineauPartEnum.Rotor];
MoineauFlankContour stator = contours.FlankFor[MoineauPartEnum.Stator];

Tôi cũng tự nhận ra rằng bạn có thể sử dụng các giao diện được triển khai rõ ràng để đạt được điều này, như được hiển thị ở đây: Thuộc tính được lập chỉ mục có tên trong C #? (xem cách thứ hai được hiển thị trong câu trả lời đó)