你们看这段代码就不要索引符

weikeli19 2016-05-12 10:17:48

你们看这段代码就不需要索引符照样可以像数组一样运行索引符是多余的你们看这两段代码相比较一下就知道了:
你们说在程序里添加索引符有必要吗？
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Collections;

namespace delete
{
class Program
{
static void Main(string[] args)
{
IList f = new Animals();
f.Add(1); f.Add(2); f[0] = 7;
foreach (int c in f)
Console.WriteLine(c);
Console.WriteLine("{0} {1}", f[0], f[1]);

}
}
public class Animal
{ }
public class Animals : CollectionBase
{
public void Add(int newAnimal)
{

IList d = new Animals();
d.Add(newAnimal);
}

}
}
----------------------------------------------------------------------------------------
这一段把索引符去掉则会出错
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Collections;

namespace delete
{
class Program
{
static void Main(string[] args)
{
Animals a = new Animals();
a.Add(1); a.Add(2);
foreach (int c in a)
Console.WriteLine(c);
a[0] = 3;
foreach (int c in a)
Console.WriteLine(c);

}
}
public class Animal
{ }
public class Animals : CollectionBase
{
public void Add(int newAnimal)
{
List.Add(newAnimal);

}
public int this[int index]
{
get
{
return (int)List[index];
}
set
{
List[index] = value;
}
}
}
}

...全文

334 22 打赏收藏举报

写回复

用AI写文章

22 条回复

切换为时间正序

请发表友善的回复…

发表回复

crystal_lz 2016-05-12

打赏
举报

引用 11 楼 weikeli19 的回复:

[quote=引用 10 楼 crystal_lz 的回复:] [quote=引用 5 楼 weikeli19 的回复:] [quote=引用 1 楼 crystal_lz 的回复:] public void Add(int newAnimal) { IList d = new Animals(); d.Add(newAnimal); } 你确定你的第一段代码是对的？、、、、、、、

我确定不信你可以上机实验一下[/quote] 那他会执行吗？。。。[/quote] 会你试验一下不就知道了嘛[/quote] 你是从哪里判断它执行了的？。。。就应为你确实添加进去了数据吗？。。你访问当的压根就不是 Animals.Add 而是 IList.Add 如果上面的代码真的是执行了的话那就只能得到一个异常 stackoverflowexception 栈溢出很简单那代码看上去就和死递归没什么区别

xuzuning 2016-05-12

打赏
举报

1. 直接下载.NET Framework源代码（下载地址），然后用Visual Studio打开查看。 2. 在线查看，网址：http://referencesource.microsoft.com/ 。 VS 的联机帮助里也可看到

weikeli19 2016-05-12

打赏
举报

引用 10 楼 crystal_lz 的回复:

[quote=引用 5 楼 weikeli19 的回复:] [quote=引用 1 楼 crystal_lz 的回复:] public void Add(int newAnimal) { IList d = new Animals(); d.Add(newAnimal); } 你确定你的第一段代码是对的？、、、、、、、

我确定不信你可以上机实验一下[/quote] 那他会执行吗？。。。[/quote] 会你试验一下不就知道了嘛

crystal_lz 2016-05-12

打赏
举报

引用 5 楼 weikeli19 的回复:

[quote=引用 1 楼 crystal_lz 的回复:] public void Add(int newAnimal) { IList d = new Animals(); d.Add(newAnimal); } 你确定你的第一段代码是对的？、、、、、、、

我确定不信你可以上机实验一下[/quote] 那他会执行吗？。。。

weikeli19 2016-05-12

打赏
举报

引用 8 楼 xuzuning 的回复:

操作的对象不同，自然用法上也有所不同 IList f = new Animals(); f 是 IList 类型的，IList 本身支持枚举，所以你可以 f[0]、f[1] 这样 Animals a = new Animals(); a 是 Animals 类型的，枚举是通过索引器定义的，你把索引器去掉，就不能 a[0]、a[1] 了

我问一下以专业开发人员为伍的代码是从哪里查到的就是3楼的代码

xuzuning 2016-05-12

打赏
举报

操作的对象不同，自然用法上也有所不同 IList f = new Animals(); f 是 IList 类型的，IList 本身支持枚举，所以你可以 f[0]、f[1] 这样 Animals a = new Animals(); a 是 Animals 类型的，枚举是通过索引器定义的，你把索引器去掉，就不能 a[0]、a[1] 了

weikeli19 2016-05-12

打赏
举报

引用 4 楼 sp1234 的回复:

它定义了几个父类接口方法不能直接使用，必须通过父类类型间接调用。我上面说的“现在c#版本对索引操作符是不支持继承的”这个可能是不对的（你另外在测试一下），至少这里CollectionBase 定义中明确定义了必须通过 IList 来调用。

object IList.this[int index] { get { if ((index < 0) || (index >= this.Count)) { throw new ArgumentOutOfRangeException("index", Environment.GetResourceString("ArgumentOutOfRange_Index")); } return this.InnerList[index]; } set { if ((index < 0) || (index >= this.Count)) { throw new ArgumentOutOfRangeException("index", Environment.GetResourceString("ArgumentOutOfRange_Index")); } this.OnValidate(value); object oldValue = this.InnerList[index]; this.OnSet(index, oldValue, value); this.InnerList[index] = value; try { this.OnSetComplete(index, oldValue, value); } catch { this.InnerList[index] = oldValue; throw; } } } 你这个代码是从哪里看到的？

以专业开发人员为伍 2016-05-12

打赏
举报

奇怪，我明明输入且提交的内容，csdn服务器刷新页面之后怎么直接丢掉了内容呢？！不管关于“索引操作符不支持继承”的原因是c#编译器的缘故还是.net 类库中定义为间接引用父类（父接口）的缘故——实际上应该是后者的缘故，总之注意点都是一样的。这里你恰好遇到了两个及不符合面向对象分析设计规范的例子，一个是“子类使用相同签名的方法，已完全无关的内容，去重载父类的相同签名的方法”，第二个是“子类可以断然声明不支持父类/接口的方法”。这两个都是上个世纪末在ＯＯ　最终技术流行起来之前的风格，比较随意的 c++ 代码中才会常见。如今只能注意避免踩上这些“坑”代码，如果你觉得这两个比较容易弄乱OOPL程序设计，我是同意的。如果遇到更好地编程语言或者开发平台，可以考虑因这些不符合OOAD的编程特性而扔掉c#和. net，选择更好地 OOPL

weikeli19 2016-05-12

打赏
举报

引用 1 楼 crystal_lz 的回复:

public void Add(int newAnimal) { IList d = new Animals(); d.Add(newAnimal); } 你确定你的第一段代码是对的？、、、、、、、

我确定不信你可以上机实验一下

以专业开发人员为伍 2016-05-12

打赏
举报

它定义了几个父类接口方法不能直接使用，必须通过父类类型间接调用。我上面说的“现在c#版本对索引操作符是不支持继承的”这个可能是不对的（你另外在测试一下），至少这里CollectionBase 定义中明确定义了必须通过 IList 来调用。

以专业开发人员为伍 2016-05-12

打赏
举报

嗯，重新看了一下 CollectionBase 定义的源代码，它的定义是这样的

[Serializable, ComVisible(true), __DynamicallyInvokable]
public abstract class CollectionBase : IList, ICollection, IEnumerable
{
    // Fields
    private ArrayList list;

    // Methods
    protected CollectionBase()
    {
        this.list = new ArrayList();
    }

    protected CollectionBase(int capacity)
    {
        this.list = new ArrayList(capacity);
    }

    [__DynamicallyInvokable]
    public void Clear()
    {
        this.OnClear();
        this.InnerList.Clear();
        this.OnClearComplete();
    }

    [__DynamicallyInvokable]
    public IEnumerator GetEnumerator()
    {
        return this.InnerList.GetEnumerator();
    }

    protected virtual void OnClear()
    {
    }

    protected virtual void OnClearComplete()
    {
    }

    protected virtual void OnInsert(int index, object value)
    {
    }

    protected virtual void OnInsertComplete(int index, object value)
    {
    }

    protected virtual void OnRemove(int index, object value)
    {
    }

    protected virtual void OnRemoveComplete(int index, object value)
    {
    }

    protected virtual void OnSet(int index, object oldValue, object newValue)
    {
    }

    protected virtual void OnSetComplete(int index, object oldValue, object newValue)
    {
    }

    protected virtual void OnValidate(object value)
    {
        if (value == null)
        {
            throw new ArgumentNullException("value");
        }
    }

    [__DynamicallyInvokable]
    public void RemoveAt(int index)
    {
        if ((index < 0) || (index >= this.Count))
        {
            throw new ArgumentOutOfRangeException("index", Environment.GetResourceString("ArgumentOutOfRange_Index"));
        }
        object obj2 = this.InnerList[index];
        this.OnValidate(obj2);
        this.OnRemove(index, obj2);
        this.InnerList.RemoveAt(index);
        try
        {
            this.OnRemoveComplete(index, obj2);
        }
        catch
        {
            this.InnerList.Insert(index, obj2);
            throw;
        }
    }

    void ICollection.CopyTo(Array array, int index)
    {
        this.InnerList.CopyTo(array, index);
    }

    int IList.Add(object value)
    {
        this.OnValidate(value);
        this.OnInsert(this.InnerList.Count, value);
        int index = this.InnerList.Add(value);
        try
        {
            this.OnInsertComplete(index, value);
        }
        catch
        {
            this.InnerList.RemoveAt(index);
            throw;
        }
        return index;
    }

    bool IList.Contains(object value)
    {
        return this.InnerList.Contains(value);
    }

    int IList.IndexOf(object value)
    {
        return this.InnerList.IndexOf(value);
    }

    void IList.Insert(int index, object value)
    {
        if ((index < 0) || (index > this.Count))
        {
            throw new ArgumentOutOfRangeException("index", Environment.GetResourceString("ArgumentOutOfRange_Index"));
        }
        this.OnValidate(value);
        this.OnInsert(index, value);
        this.InnerList.Insert(index, value);
        try
        {
            this.OnInsertComplete(index, value);
        }
        catch
        {
            this.InnerList.RemoveAt(index);
            throw;
        }
    }

    void IList.Remove(object value)
    {
        this.OnValidate(value);
        int index = this.InnerList.IndexOf(value);
        if (index < 0)
        {
            throw new ArgumentException(Environment.GetResourceString("Arg_RemoveArgNotFound"));
        }
        this.OnRemove(index, value);
        this.InnerList.RemoveAt(index);
        try
        {
            this.OnRemoveComplete(index, value);
        }
        catch
        {
            this.InnerList.Insert(index, value);
            throw;
        }
    }

    // Properties
    [ComVisible(false)]
    public int Capacity
    {
        get
        {
            return this.InnerList.Capacity;
        }
        set
        {
            this.InnerList.Capacity = value;
        }
    }

    public int Count
    {
        [__DynamicallyInvokable]
        get
        {
            if (this.list != null)
            {
                return this.list.Count;
            }
            return 0;
        }
    }

    protected ArrayList InnerList
    {
        get
        {
            if (this.list == null)
            {
                this.list = new ArrayList();
            }
            return this.list;
        }
    }

    protected IList List
    {
        get
        {
            return this;
        }
    }

    bool ICollection.IsSynchronized
    {
        get
        {
            return this.InnerList.IsSynchronized;
        }
    }

    object ICollection.SyncRoot
    {
        get
        {
            return this.InnerList.SyncRoot;
        }
    }

    bool IList.IsFixedSize
    {
        get
        {
            return this.InnerList.IsFixedSize;
        }
    }

    bool IList.IsReadOnly
    {
        get
        {
            return this.InnerList.IsReadOnly;
        }
    }

    object IList.this[int index]
    {
        get
        {
            if ((index < 0) || (index >= this.Count))
            {
                throw new ArgumentOutOfRangeException("index", Environment.GetResourceString("ArgumentOutOfRange_Index"));
            }
            return this.InnerList[index];
        }
        set
        {
            if ((index < 0) || (index >= this.Count))
            {
                throw new ArgumentOutOfRangeException("index", Environment.GetResourceString("ArgumentOutOfRange_Index"));
            }
            this.OnValidate(value);
            object oldValue = this.InnerList[index];
            this.OnSet(index, oldValue, value);
            this.InnerList[index] = value;
            try
            {
                this.OnSetComplete(index, oldValue, value);
            }
            catch
            {
                this.InnerList[index] = oldValue;
                throw;
            }
        }
    }
}

 
Collapse Methods

它在最后的

以专业开发人员为伍 2016-05-12

打赏
举报

你碰到了 .net 在15年前从c++里边继承来的一个糟粕，加上所谓“索引符”的使用，混淆在一起了。当你写

    public class Animals : CollectionBase
    {
        //public void Add(int newAnimal)
        //{

        //    IList d = new Animals();
        //    d.Add(newAnimal);
        //}

    }

也就是把所谓 Add 注释掉，第一段照样可以执行。面向对象的分析和设计技术中，实际上应该避免这种用 Add 来篡改 Add 的行为。Add 要么用 override 方式来重写父类的方法，要么（当父类不允许子类重写此方法时）就应该编译时报错。而.net 最初从c++中恰好继承了这个“可用完全无关的 Add 方法来重载父类Add方法”的特性，这本身是违反面向对象设计原则的，是容易让人产生误解的。接下来，对于“索引符”，c#编译器要求必须是你声明的变量类型本身就定义有索引操作定义，而不管类型的父类/接口有没有可用的操作定义。因为这个[ ] 是一个语法糖，是c#的特性而不是 .net 的特性。（vb.net 中另外定义了其它语法形式的索引操作定义）因此在这个索引操作符方面，其实c#也并没有按照面向对象的规范去定义，也是个特例。

crystal_lz 2016-05-12

打赏
举报

public void Add(int newAnimal) { IList d = new Animals(); d.Add(newAnimal); } 你确定你的第一段代码是对的？、、、、、、、

xuzuning 2016-05-12

打赏
举报

当然是不行！泛型没学过的话，这个应该没有问题了吧？

        static void Main(string[] args)
        {
            int[] a = { 1, 2, 3, 4, 5 }; //这是一个数组
            Console.WriteLine("{0} {1}", a[0], a[1]); //所以你可以用下标访问

            var b = new B(); //这是一个对象
            Console.WriteLine("{0} {1}", b.b[0], b.b[1]); //b.b 是公共的，所以你可以这样访问，如果是私有（保护）的，就访问不到了
            Console.WriteLine("{0} {1}", b[0], b[1]); //如果没有索引器，你就不能这样访问

            Console.ReadKey();
        }
        class B
        {
            public int[] b = { 1, 2, 3, 4, 5 };
            public int this[int index] //索引器
            {
                get { return b[index]; }
            }
        }

我想，你是在这里被绕住了

Poopaye 2016-05-12

打赏
举报

引用 14 楼 weikeli19 的回复:

[quote=引用 8 楼 xuzuning 的回复:] 操作的对象不同，自然用法上也有所不同 IList f = new Animals(); f 是 IList 类型的，IList 本身支持枚举，所以你可以 f[0]、f[1] 这样 Animals a = new Animals(); a 是 Animals 类型的，枚举是通过索引器定义的，你把索引器去掉，就不能 a[0]、a[1] 了

你说的这句话我理解不了 f 是 IList 类型的，IList 本身支持枚举，所以你可以 f[0]、f[1] 这样怎么是枚举啊 enum啊？怎么会是枚举呢[/quote] 他说的枚举是一个动词，你说的enum是一种数据类型

weikeli19 2016-05-12

打赏
举报

引用 17 楼 xuzuning 的回复:

你又在钻牛角尖了吧？如果 a = new List<int>() {1,2,3} 那你就可以 a[0]、a[1]、a[2] 访问他的成员如果 class A { List<int> a = new List<int>() {1,2,3}; } a = new A() 你还可以 a[0]、a[1]、a[2] 这样访问吗？

是不是此枚举非彼枚举？

weikeli19 2016-05-12

打赏
举报

引用 17 楼 xuzuning 的回复:

你又在钻牛角尖了吧？如果 a = new List<int>() {1,2,3} 那你就可以 a[0]、a[1]、a[2] 访问他的成员如果 class A { List<int> a = new List<int>() {1,2,3}; } a = new A() 你还可以 a[0]、a[1]、a[2] 这样访问吗？

你现在只要回答是还是不是就行了

weikeli19 2016-05-12

打赏
举报

引用 17 楼 xuzuning 的回复:

你又在钻牛角尖了吧？如果 a = new List<int>() {1,2,3} 那你就可以 a[0]、a[1]、a[2] 访问他的成员如果 class A { List<int> a = new List<int>() {1,2,3}; } a = new A() 你还可以 a[0]、a[1]、a[2] 这样访问吗？

泛型没学过我没钻牛角尖这是我学习应有的态度啊

xuzuning 2016-05-12

打赏
举报

你又在钻牛角尖了吧？如果 a = new List<int>() {1,2,3} 那你就可以 a[0]、a[1]、a[2] 访问他的成员如果 class A { List<int> a = new List<int>() {1,2,3}; } a = new A() 你还可以 a[0]、a[1]、a[2] 这样访问吗？

weikeli19 2016-05-12