【数组】C#数组是个很重要的概念，在C#类库中，它属于基本常用的类型，和int,string等是一级别的，是C#最基础、最核心的部分，它是相同类型的一组集合，当然，它也是安全的；但数组确实也比较奇怪，它到底属于什么类型？比如int[] a,A[] a1;确实找不到a或a1的类型定义，即使在CIL中也无此定义，如果用a.GetType(),你得到是System.int32[]----这不纯属扯淡嘛，这种类型找的着吗？
但有两点需要注意：其一，数组也是一个对象，它派生于抽象类Array；其二，数组对象的实例化和C#中其它任何引用类型的实例化都不相同，引用类型是.newobj,而数组是.newarr指令。这两点很重要，我们可以推测下数组对象的类型到底是什么，诸如C#编译器遇到int[]，A[],B[]……..等时，应该映射成各个继承Array的可类，然后才是实例化，这咋一看有理，再想想就可笑了，IL只有个.newarr指令；如果我们要用C#设计一个高效可重用的数组类，我们怎么办？这几乎是不可能的，其实数组很容易理解，刚才的newarr就说明了一切，C#中的数组操作已经固化成一个特定的指令了，这样它就和其它类型不一样了，显得低级化了；实际看来，C#数组和泛型的效率至少不低于C/C++及STL，它们不是被面向对象化了，而是虚拟了面向对象，这样看来，它们的实现不是面向对象的封装，至少是C/C++级别的特定安全实现，甚至是用汇编或机器指令写的，如此看来，再索求数组和泛型是什么类型时倒显得有些荒唐了，我们姑且就认为它是面向对象化了，当然看到的都是假象，这些假象中又最重要的一点---这个所谓的假数组对象也有一个假的索引器，这样看起来和真实对象的索引器就是一个概念。
C#数组对象的特点就是虚拟成了面向对象，有了索引器概念，是面向对象的，是安全的，又是很高效的，当然也是最不灵活的！
【集合】由于要灵活，集合就产生了，它是做为一个通用的算法产生的，有ArrayList,Stack….提供了常用的容器，这种通用性是用万能的object实现的；
特点就是：可以装各个类型(这违背了数组单一化原则，除非迫不得已，千万不要这么做)，存在类型不安全因素，性能差劲！
针对此，出现了自定义的加强版的集合-----强类型集合，它解决了安全性，但是通用性差，性能低。
由此可年，通吃各种类型到成了唯一的特点，除非迫不得已，不要用。
【泛型集合】于是，除了有灵活性和通用性特点外，安全和高效的集合便诞生了，同时，泛型的概念也推广话了
在自定义泛型集合中，引出了约束占位符类型的语法规则，要了解一下！
泛型思考，泛型是一种思想，主要体现在算法上，它最大特点就是在不牺牲效率的前提下实现算法的通用性-----真正实现代码的重用，其抽象级别要比面向对象高；泛型是面向算法(过程)编程，脱离数据，实现算法(模式)的重用性；面向对象是面向大型软件的编程，封装数据和算法，通过继承和组合实现组件(代码)的可重用性。
泛型类、泛型接口、泛型代理、泛型方法；
泛型类相比类而言，更抽象，跟应该体现在算法和数据容器的作用，除此以外，慎用泛型，它并不是万能的！
泛型接口相比接口而言，更体现接口约定的抽象性
泛型代理更能体现方法类型的抽象性
泛型方法更能体现算法的抽象性，泛型方法能实现的算法，一定能用函数重载实现，而函数的重载不一定能用泛型方法实现，最重要的是泛型方法内不允许有占位符类型参与各种运算操作，这大大限制了泛型的功能。
总结：泛型类型是定义时用占位符， 占位符只能出现在泛型类型定义内或泛型方法内
141 个解决方案
#1
该回复于2011-12-26 09:19:24被版主删除
#2
编译器的基本的功能就是让我们用更加面向开发人员（大都数都是业余人员）的思维方式来搞程序设计，而不是用汇编或者机器码的方式来设计程序。
#3
所以说这个地方哪个是本质，不同的人有不同的看法。我的看法，（越是）高级语言才是人类编程语言的本质。而低级语言那些只能算是实现高级语言的底层基础。
#4
您总喜欢看别人的脚，不看别人的脸
#5
您应该搞玄学 技术是什么就是什么 原理是唯一的 但是不同人对这个过程的思考可以百花齐放
#6
什么叫做“是什么就是什么”呢？这显然是有差别的。比如我们的目的是去工地上当小工，那么我们眼中就是一砖一瓦才叫“唯一”的建筑。但是许多建筑师甚至从来亲自浇筑过混凝土，它知道建筑的本质不是低级的去拼凑一砖一瓦，不是越低级地拼凑就越意味着以后可以成为设计师。作为设计师，首先搞清楚自己最适当的层次然后进行概念设计，绝对不是越低级越好。
#7
从来亲自浇筑过混凝土，它知道建筑的本质 --> 从未亲自浇筑过混凝土，它知道建筑的本质
所以这里最容易搞混的就是把底层跟本质混为一谈，成了“技术”概念的奴隶。
所以这里最容易搞混的就是把底层跟本质混为一谈，成了“技术”概念的奴隶。
#8
当你介绍c#甚至.net如何实现一些编程概念时，那么没有什么问题。但是当你用来引申到一个东西的应用目的时，其实很多设计需求是以
面向应用领域为基础的，对应用的理解越深多越好，此时要避免纠缠计算机底层概念来随便评判应用的。
#9
这排版看起来忒累了....
#10
您是自己立个命题，然后再自己打到自己
全篇我都没有一个片字 “越低级越好”
至于您大唱设计，唱衰“技术” 实在不敢苟同
全篇我都没有一个片字 “越低级越好”
至于您大唱设计，唱衰“技术” 实在不敢苟同
#11
这个我同意 我没有否定的意思 凡是大谈天下软件“以设计为中心” 我估计这样的人是疯了
#12
很正常，有人工作了10几年还不彻底了解if语句呢 就是对C#而言，多少工作几年像你一样有经验的人甚至连类型名标志规则都不完全懂 ，更不要提where限定这一类的关键字的灵活应用了
但这并不影响你们工作、你们继续积累经验，只能说明你们对技术细节把握不够，学习Java和C#这类语言，你不需要全部都懂，但是你上手搞应用却很快，这注定学Java和C#的人都是纯粹应用型的人，所以说Java和C#让编程公众化了，简单化了
但是学C/C++就不一样，必须得注意语言的细节，必须了解实现机制和背后隐藏的东西，如果这些你搞不懂，你根本做不出来成熟的应用，所以您要戒骄戒躁，勿以为有几年Java经验就怎么怎么样，其实那根本不值得一提，是个人像你一样工作几年都会有经验
#13
顶一个！！！上面的两位技术前辈，表示都很崇拜
#14
这个我顶，底层的原理还是很有必要掌握的
#15
我想告诉你的是，List泛型集合内部也是使用了ArrayList
#16
所以List泛型集合不是你想象的那么好
#17
泛型借鉴了非泛型来实现 ，您能说一下吗？我是百思不得其解？？？？
#18
看到这排版已经不想看了。
#19
public class List<T> : IList<T>, ICollection<T>, IEnumerable<T>, IList, ICollection, IEnumerable
{
// Fields
private const int _defaultCapacity = 4;
private static T[] _emptyArray;
private T[] _items;
private int _size;
[NonSerialized]
private object _syncRoot;
private int _version;
// Methods
static List();
public List();
public List(IEnumerable<T> collection);
public List(int capacity);
public void Add(T item);
public void AddRange(IEnumerable<T> collection);
public ReadOnlyCollection<T> AsReadOnly();
public int BinarySearch(T item);
public int BinarySearch(T item, IComparer<T> comparer);
public int BinarySearch(int index, int count, T item, IComparer<T> comparer);
public void Clear();
public bool Contains(T item);
public List<TOutput> ConvertAll<TOutput>(Converter<T, TOutput> converter);
public void CopyTo(T[] array);
public void CopyTo(T[] array, int arrayIndex);
public void CopyTo(int index, T[] array, int arrayIndex, int count);
private void EnsureCapacity(int min);
public bool Exists(Predicate<T> match);
public T Find(Predicate<T> match);
public List<T> FindAll(Predicate<T> match);
public int FindIndex(Predicate<T> match);
public int FindIndex(int startIndex, Predicate<T> match);
public int FindIndex(int startIndex, int count, Predicate<T> match);
public T FindLast(Predicate<T> match);
public int FindLastIndex(Predicate<T> match);
public int FindLastIndex(int startIndex, Predicate<T> match);
public int FindLastIndex(int startIndex, int count, Predicate<T> match);
public void ForEach(Action<T> action);
public Enumerator<T> GetEnumerator();
public List<T> GetRange(int index, int count);
public int IndexOf(T item);
public int IndexOf(T item, int index);
public int IndexOf(T item, int index, int count);
public void Insert(int index, T item);
public void InsertRange(int index, IEnumerable<T> collection);
private static bool IsCompatibleObject(object value);
public int LastIndexOf(T item);
public int LastIndexOf(T item, int index);
public int LastIndexOf(T item, int index, int count);
public bool Remove(T item);
public int RemoveAll(Predicate<T> match);
public void RemoveAt(int index);
public void RemoveRange(int index, int count);
public void Reverse();
public void Reverse(int index, int count);
public void Sort();
public void Sort(IComparer<T> comparer);
public void Sort(Comparison<T> comparison);
public void Sort(int index, int count, IComparer<T> comparer);
IEnumerator<T> IEnumerable<T>.GetEnumerator();
void ICollection.CopyTo(Array array, int arrayIndex);
IEnumerator IEnumerable.GetEnumerator();
int IList.Add(object item);
bool IList.Contains(object item);
int IList.IndexOf(object item);
void IList.Insert(int index, object item);
void IList.Remove(object item);
public T[] ToArray();
public void TrimExcess();
public bool TrueForAll(Predicate<T> match);
private static void VerifyValueType(object value);
// Properties
public int Capacity { get; set; }
public int Count { get; }
public T this[int index] { get; set; }
bool ICollection<T>.IsReadOnly { get; }
bool ICollection.IsSynchronized { get; }
object ICollection.SyncRoot { get; }
bool IList.IsFixedSize { get; }
bool IList.IsReadOnly { get; }
object IList.this[int index] { get; set; }
// Nested Types
[Serializable, StructLayout(LayoutKind.Sequential)]
public struct Enumerator : IEnumerator<T>, IDisposable, IEnumerator
{
private List<T> list;
private int index;
private int version;
private T current;
internal Enumerator(List<T> list);
public void Dispose();
public bool MoveNext();
private bool MoveNextRare();
public T Current { get; }
object IEnumerator.Current { get; }
void IEnumerator.Reset();
}
}
在实现中我通篇看不到你所说的List内部用ArrayList,麻烦你给出证据！！！
#20
public class ArrayList : IList, ICollection, IEnumerable, ICloneable
{
// Fields
private const int _defaultCapacity = 4;
private object[] _items;
private int _size;
[NonSerialized]
private object _syncRoot;
private int _version;
private static readonly object[] emptyArray;
注意ArrayList的_items字段
public class List<T> : IList<T>, ICollection<T>, IEnumerable<T>, IList, ICollection, IEnumerable
{
// Fields
private const int _defaultCapacity = 4;
private static T[] _emptyArray;
private T[] _items;
private int _size;
[NonSerialized]
private object _syncRoot;
private int _version;
再看看List的_items字段
如果谁能从源代码级别看的出来List内部调用ArrayList---你真是神！！！！
莫非是我比较浅薄，麻烦您给下分析
#21
我不是神，看不出
#22
支持P1234 的思维方式，
语言嘛， 就是越简单越好！
象楼主的长编大论，谁还看得明？
语言嘛， 就是越简单越好！
象楼主的长编大论，谁还看得明？
#23
支持lz的原创分享心得。
不过在叙述组织上，概念的严谨上还有些改进的余地。
不过在叙述组织上，概念的严谨上还有些改进的余地。
#24
以上有人说List的实现中用到了ArrayList,在C#级别的源代码中我是没有发现，我是百思不得其解，您是怎么认为？
#25
对于系统类库，我觉得最应该从使用者的角度看待问题，把库当成黑盒，当你设计库给别人用的时候，也应该隐藏库本身的复杂性。
我们不是不可以比较汽车和马匹，但是汽车绝对不是不吃草的马匹。你也不会把痰盂当成大号的茶杯。理解每个库，各自的用途，虽然有些场合他们的用途有重叠，但是大部分情况下，各自的用途是明显的。相反的，他们的实现、性能、技巧之类的可能不是很重要，比如Java或者C++也有类似的数组、集合，大部分情况他们的用途、用法和C#一致，虽然内部实现可能大不相同。C# 3.0里面，一个数组可能实现了List的方法，你也可以把它当作List，所以理解用途比单纯讨论他们的区别、联系、优点、缺点更有意义，你觉得呢？
我们不是不可以比较汽车和马匹，但是汽车绝对不是不吃草的马匹。你也不会把痰盂当成大号的茶杯。理解每个库，各自的用途，虽然有些场合他们的用途有重叠，但是大部分情况下，各自的用途是明显的。相反的，他们的实现、性能、技巧之类的可能不是很重要，比如Java或者C++也有类似的数组、集合，大部分情况他们的用途、用法和C#一致，虽然内部实现可能大不相同。C# 3.0里面，一个数组可能实现了List的方法，你也可以把它当作List，所以理解用途比单纯讨论他们的区别、联系、优点、缺点更有意义，你觉得呢？
#26
我不是很了解这个问题。但是我想，List应该不会用到ArrayList，如果让我来设计类库的话。如果你有兴趣，你可以帮我证实下。
#27
从实用角度来看，的确如你所说，但是像Java和C#这样的语言，在一些类库特性上并不是C#或Java它们自身实现的，比如这个数组和泛型，它们的确存在所谓的操作黑箱，它们背地里估计用C/C++实现的
正因为此，C++之父才批评它们，说它们是”小偷“
刚才有人却说List内部调用ArrayList，如果不是真的，就是那个人在胡扯
#28
哈哈，楼主真爱较劲啊
为什么你发的每个帖子都要和别人抬杠呢？
真不知道你技术有多牛，
就算是在牛，你连分享的文章别人有不同意见都不允许，
又有什么用呢？
你要是出生早点有机会当个暴君啊，
当然，也有可能是个死得很惨的固执的学者。
做人大肚点，学术研究高值得人尊重，
如果心胸再宽广点你就是个伟人啊。
不一定非要别人都说你是对的。
别跟我争哈，我没你研究的那么底层，
我就是个it民工：）
为什么你发的每个帖子都要和别人抬杠呢？
真不知道你技术有多牛，
就算是在牛，你连分享的文章别人有不同意见都不允许，
又有什么用呢？
你要是出生早点有机会当个暴君啊，
当然，也有可能是个死得很惨的固执的学者。
做人大肚点，学术研究高值得人尊重，
如果心胸再宽广点你就是个伟人啊。
不一定非要别人都说你是对的。
别跟我争哈，我没你研究的那么底层，
我就是个it民工：）
#29
这个C#源代码中可以证实根本没有ArrayList的调用，至于泛型，就是IL代码也是泛型标志，这是个黑箱，就像newarr指令
#30
又是一个只看别人脚的人，真诚的建议你别搞这一行（发现您不太合适）
#31
我并不是争论什么，我只是想知道答案，记住，答案只会越变越明，做技术的就要心细，钻研，它和做人，办人情事，搞政治的完全不相同
#32
在您那篇c#之父的帖子中已经这么评价过在下了
您真的是血气方刚啊。
我刚才一直都是在建议，
你有没有考虑过为什么这么多人都爱看你的脚呢？
大家全疯了，就您清醒？
如果真是这样对您也不是什么好事儿啊。
只是建议您别一点别人的话也听不进去，
不一定所有的事儿你都是对的。
至于您所说的我不适合做it，
也许真的很有道理，
我考虑一下。
您真的是血气方刚啊。
我刚才一直都是在建议，
你有没有考虑过为什么这么多人都爱看你的脚呢？
大家全疯了，就您清醒？
如果真是这样对您也不是什么好事儿啊。
只是建议您别一点别人的话也听不进去，
不一定所有的事儿你都是对的。
至于您所说的我不适合做it，
也许真的很有道理，
我考虑一下。
#33
我对您并没有什么恶意，可能是有些言辞过于激烈些，让你这类人受不了，我是真诚希望大家抛开表面的态度之见，重点争论下技术本身，这样思维容易开阔，很有思辨性，我想结果对大家而言都是有益的
就刚才那个List问题而言，我不关心那个人对我的态度，我是在意他的那句技术论点，我真的是很想知道，所以就发了一些我对List的佐证，真心希望他也阐述下自己的观点
#34
你看，这样说话别人很容易会去想和你沟通，
像上个帖子那样别人给你点建议就骂人，
不太适合搞学问的人做。
还有就是如果全世界都说你错，
哪怕你是对的，
你也很难有机会去证明。
其实你说的东西很有说服力，
从知识上顶你一下，
希望你以后能做中国的n#之父。
手机没电了，最后一句话：
加油！
像上个帖子那样别人给你点建议就骂人，
不太适合搞学问的人做。
还有就是如果全世界都说你错，
哪怕你是对的，
你也很难有机会去证明。
其实你说的东西很有说服力，
从知识上顶你一下，
希望你以后能做中国的n#之父。
手机没电了，最后一句话：
加油！
#35
我纠正下你的观点，不是说IT民工不管底层只管调用，而搞这一行必须刨根问底。
事实上，随着IT技术的发展，技术堆栈日益庞大，现在不可能有人从最低层到最高层无所不通无所不晓，这是一方面，另一方面，计算机科学系体完备，现在已经远离了那个靠个人技巧诞生很多奇妙软件的年代了。这就是说，实际上，你把计算机科学理论知识掌握，再去看一些源代码，绝大部分源代码采用的算法、优化手段基本上不会超出你的预期判断。
如果真的有什么特别的地方，文档也会详细说明这一点，并且我认为，如果你的“黑盒”有和它的表征不同的地方，向调用者说明，是系统类库开发者的责任。
所以优秀的程序员可以放心地使用设计完善的类库，并且好像这些库是他自己写的那样。仅仅在一些场合，才需要去研究更低层的技术。就算这样，也有很多逆向工程、跟踪调试或者别的手段。
更多的情况是，底层代码采用的那种实现本身没有什么研究的意义，如同正负电荷的定义，以及为什么 x86 使用大端存储一样。
事实上，随着IT技术的发展，技术堆栈日益庞大，现在不可能有人从最低层到最高层无所不通无所不晓，这是一方面，另一方面，计算机科学系体完备，现在已经远离了那个靠个人技巧诞生很多奇妙软件的年代了。这就是说，实际上，你把计算机科学理论知识掌握，再去看一些源代码，绝大部分源代码采用的算法、优化手段基本上不会超出你的预期判断。
如果真的有什么特别的地方，文档也会详细说明这一点，并且我认为，如果你的“黑盒”有和它的表征不同的地方，向调用者说明，是系统类库开发者的责任。
所以优秀的程序员可以放心地使用设计完善的类库，并且好像这些库是他自己写的那样。仅仅在一些场合，才需要去研究更低层的技术。就算这样，也有很多逆向工程、跟踪调试或者别的手段。
更多的情况是，底层代码采用的那种实现本身没有什么研究的意义，如同正负电荷的定义，以及为什么 x86 使用大端存储一样。
#36
谢谢你的鼓励，我本人不是什么高手，但我一直抱着浓厚的兴趣研究技术问题，本人有时言辞有些偏激甚至有些自负，但绝不是那种不地道，*，阴险，不愿和别人交朋友那种
同时与你共勉：加油！
#37
是啊，很多人认为搞C/C++就是本质，完全的扯蛋。
#38
整个一大牛辩论赛呀 不错！
#39
我们宿舍搞c++的经常bs我这个c#
#40
刨根问底到不是不提倡
我们只是不主张。
相对来说，老p说的没错。不能拿以前的老眼光就看这行，不是你知道01010是啥就是好程序员。
30年前，那是技术上就只能这么办。而30年后，你则不需要如此
100年前造个飞机得一个螺丝一个螺丝的研究
100年后还拿着螺丝较劲滴那就不合时宜了
我们只是不主张。
相对来说，老p说的没错。不能拿以前的老眼光就看这行，不是你知道01010是啥就是好程序员。
30年前，那是技术上就只能这么办。而30年后，你则不需要如此
100年前造个飞机得一个螺丝一个螺丝的研究
100年后还拿着螺丝较劲滴那就不合时宜了
#41
LZ是打破沙锅问到底的人（技术达人），签定完毕。
不过，现在的电脑cpu等硬件处理速度越来越快，性能方面，客户不投诉，问题就不大，如果性能不能继续升级硬件。硬件这东西3，5年就淘汰的。
不过，现在的电脑cpu等硬件处理速度越来越快，性能方面，客户不投诉，问题就不大，如果性能不能继续升级硬件。硬件这东西3，5年就淘汰的。
#42
LZ是打破沙锅问到底的人（技术达人），值得学习。
#43
比较赞同sp1234的观点。
比如我买了一辆汽车，我觉得本质应该是我如何把这车开好，怎么样安全快速不违反交通规则的把我自己送到我想去的地方，最多捎带着学习一些简单的故障修理，而不是研究发动机是怎么装配的，螺丝钉是怎么制造出来的这种底层问题。
汽车装配厂的人则要关注如何将这些零件组装成一台满足性能指标的汽车，他们会关注每个零件的性能，之间的匹配性。
而汽车零件生产厂则关注如何将钢铁制造出来合格的汽车零件。
钢铁厂则关注如何生产出来符合要求的钢材。
作为一个C#开发者，其实更像是买车的或者装配车的，非要去关注钢铁是怎样炼成的意义不大。
比如我买了一辆汽车，我觉得本质应该是我如何把这车开好，怎么样安全快速不违反交通规则的把我自己送到我想去的地方，最多捎带着学习一些简单的故障修理，而不是研究发动机是怎么装配的，螺丝钉是怎么制造出来的这种底层问题。
汽车装配厂的人则要关注如何将这些零件组装成一台满足性能指标的汽车，他们会关注每个零件的性能，之间的匹配性。
而汽车零件生产厂则关注如何将钢铁制造出来合格的汽车零件。
钢铁厂则关注如何生产出来符合要求的钢材。
作为一个C#开发者，其实更像是买车的或者装配车的，非要去关注钢铁是怎样炼成的意义不大。
#44
该回复于2011-12-26 14:51:42被版主删除
#45
为了2分没办法，要回下
#46
#47
原理上的东西，
的确要明白。要明白计算机的运行方式，
看来真的要深进 机器码。
到了机器码还不算，还要到达数字电路，（如与非门，js触发器，销存器等等），
到了数字电路还不算，还要深入进晶体管 特性曲线，晶振，等等原理，
到了晶体管还不算，还要了解半导体 （硅）的特性。
可惜，人的寿命长度有限，
不可能什么都要会。
同理，
运用 C# 搞熟了，搞精了，
就可以 开发出以C# 为基础更高级，更容易入门，更容易学的语言。
C/C++ ？ 那些家伙正是搞精了C++ ，才知他的不足，推出JAVA ，C# 的啊
所以，千万不要 bs 学C#的。
C# ，到了如火纯真时，正是新语言的诞生之时！
的确要明白。要明白计算机的运行方式，
看来真的要深进 机器码。
到了机器码还不算，还要到达数字电路，（如与非门，js触发器，销存器等等），
到了数字电路还不算，还要深入进晶体管 特性曲线，晶振，等等原理，
到了晶体管还不算，还要了解半导体 （硅）的特性。
可惜，人的寿命长度有限，
不可能什么都要会。
同理，
运用 C# 搞熟了，搞精了，
就可以 开发出以C# 为基础更高级，更容易入门，更容易学的语言。
C/C++ ？ 那些家伙正是搞精了C++ ，才知他的不足，推出JAVA ，C# 的啊
所以，千万不要 bs 学C#的。
C# ，到了如火纯真时，正是新语言的诞生之时！
#48
争论不是吵架..
#49
各有各的用途~
#50
都是牛人，能自己说服自己就好了。。。
#1
该回复于2011-12-26 09:19:24被版主删除
#2
编译器的基本的功能就是让我们用更加面向开发人员（大都数都是业余人员）的思维方式来搞程序设计，而不是用汇编或者机器码的方式来设计程序。
#3
所以说这个地方哪个是本质，不同的人有不同的看法。我的看法，（越是）高级语言才是人类编程语言的本质。而低级语言那些只能算是实现高级语言的底层基础。
#4
您总喜欢看别人的脚，不看别人的脸
#5
您应该搞玄学 技术是什么就是什么 原理是唯一的 但是不同人对这个过程的思考可以百花齐放
#6
什么叫做“是什么就是什么”呢？这显然是有差别的。比如我们的目的是去工地上当小工，那么我们眼中就是一砖一瓦才叫“唯一”的建筑。但是许多建筑师甚至从来亲自浇筑过混凝土，它知道建筑的本质不是低级的去拼凑一砖一瓦，不是越低级地拼凑就越意味着以后可以成为设计师。作为设计师，首先搞清楚自己最适当的层次然后进行概念设计，绝对不是越低级越好。
#7
从来亲自浇筑过混凝土，它知道建筑的本质 --> 从未亲自浇筑过混凝土，它知道建筑的本质
所以这里最容易搞混的就是把底层跟本质混为一谈，成了“技术”概念的奴隶。
所以这里最容易搞混的就是把底层跟本质混为一谈，成了“技术”概念的奴隶。
#8
当你介绍c#甚至.net如何实现一些编程概念时，那么没有什么问题。但是当你用来引申到一个东西的应用目的时，其实很多设计需求是以
面向应用领域为基础的，对应用的理解越深多越好，此时要避免纠缠计算机底层概念来随便评判应用的。
#9
这排版看起来忒累了....
#10
您是自己立个命题，然后再自己打到自己
全篇我都没有一个片字 “越低级越好”
至于您大唱设计，唱衰“技术” 实在不敢苟同
全篇我都没有一个片字 “越低级越好”
至于您大唱设计，唱衰“技术” 实在不敢苟同
#11
这个我同意 我没有否定的意思 凡是大谈天下软件“以设计为中心” 我估计这样的人是疯了
#12
很正常，有人工作了10几年还不彻底了解if语句呢 就是对C#而言，多少工作几年像你一样有经验的人甚至连类型名标志规则都不完全懂 ，更不要提where限定这一类的关键字的灵活应用了
但这并不影响你们工作、你们继续积累经验，只能说明你们对技术细节把握不够，学习Java和C#这类语言，你不需要全部都懂，但是你上手搞应用却很快，这注定学Java和C#的人都是纯粹应用型的人，所以说Java和C#让编程公众化了，简单化了
但是学C/C++就不一样，必须得注意语言的细节，必须了解实现机制和背后隐藏的东西，如果这些你搞不懂，你根本做不出来成熟的应用，所以您要戒骄戒躁，勿以为有几年Java经验就怎么怎么样，其实那根本不值得一提，是个人像你一样工作几年都会有经验
#13
顶一个！！！上面的两位技术前辈，表示都很崇拜
#14
这个我顶，底层的原理还是很有必要掌握的
#15
我想告诉你的是，List泛型集合内部也是使用了ArrayList
#16
所以List泛型集合不是你想象的那么好
#17
泛型借鉴了非泛型来实现 ，您能说一下吗？我是百思不得其解？？？？
#18
看到这排版已经不想看了。
#19
public class List<T> : IList<T>, ICollection<T>, IEnumerable<T>, IList, ICollection, IEnumerable
{
// Fields
private const int _defaultCapacity = 4;
private static T[] _emptyArray;
private T[] _items;
private int _size;
[NonSerialized]
private object _syncRoot;
private int _version;
// Methods
static List();
public List();
public List(IEnumerable<T> collection);
public List(int capacity);
public void Add(T item);
public void AddRange(IEnumerable<T> collection);
public ReadOnlyCollection<T> AsReadOnly();
public int BinarySearch(T item);
public int BinarySearch(T item, IComparer<T> comparer);
public int BinarySearch(int index, int count, T item, IComparer<T> comparer);
public void Clear();
public bool Contains(T item);
public List<TOutput> ConvertAll<TOutput>(Converter<T, TOutput> converter);
public void CopyTo(T[] array);
public void CopyTo(T[] array, int arrayIndex);
public void CopyTo(int index, T[] array, int arrayIndex, int count);
private void EnsureCapacity(int min);
public bool Exists(Predicate<T> match);
public T Find(Predicate<T> match);
public List<T> FindAll(Predicate<T> match);
public int FindIndex(Predicate<T> match);
public int FindIndex(int startIndex, Predicate<T> match);
public int FindIndex(int startIndex, int count, Predicate<T> match);
public T FindLast(Predicate<T> match);
public int FindLastIndex(Predicate<T> match);
public int FindLastIndex(int startIndex, Predicate<T> match);
public int FindLastIndex(int startIndex, int count, Predicate<T> match);
public void ForEach(Action<T> action);
public Enumerator<T> GetEnumerator();
public List<T> GetRange(int index, int count);
public int IndexOf(T item);
public int IndexOf(T item, int index);
public int IndexOf(T item, int index, int count);
public void Insert(int index, T item);
public void InsertRange(int index, IEnumerable<T> collection);
private static bool IsCompatibleObject(object value);
public int LastIndexOf(T item);
public int LastIndexOf(T item, int index);
public int LastIndexOf(T item, int index, int count);
public bool Remove(T item);
public int RemoveAll(Predicate<T> match);
public void RemoveAt(int index);
public void RemoveRange(int index, int count);
public void Reverse();
public void Reverse(int index, int count);
public void Sort();
public void Sort(IComparer<T> comparer);
public void Sort(Comparison<T> comparison);
public void Sort(int index, int count, IComparer<T> comparer);
IEnumerator<T> IEnumerable<T>.GetEnumerator();
void ICollection.CopyTo(Array array, int arrayIndex);
IEnumerator IEnumerable.GetEnumerator();
int IList.Add(object item);
bool IList.Contains(object item);
int IList.IndexOf(object item);
void IList.Insert(int index, object item);
void IList.Remove(object item);
public T[] ToArray();
public void TrimExcess();
public bool TrueForAll(Predicate<T> match);
private static void VerifyValueType(object value);
// Properties
public int Capacity { get; set; }
public int Count { get; }
public T this[int index] { get; set; }
bool ICollection<T>.IsReadOnly { get; }
bool ICollection.IsSynchronized { get; }
object ICollection.SyncRoot { get; }
bool IList.IsFixedSize { get; }
bool IList.IsReadOnly { get; }
object IList.this[int index] { get; set; }
// Nested Types
[Serializable, StructLayout(LayoutKind.Sequential)]
public struct Enumerator : IEnumerator<T>, IDisposable, IEnumerator
{
private List<T> list;
private int index;
private int version;
private T current;
internal Enumerator(List<T> list);
public void Dispose();
public bool MoveNext();
private bool MoveNextRare();
public T Current { get; }
object IEnumerator.Current { get; }
void IEnumerator.Reset();
}
}
在实现中我通篇看不到你所说的List内部用ArrayList,麻烦你给出证据！！！
#20
public class ArrayList : IList, ICollection, IEnumerable, ICloneable
{
// Fields
private const int _defaultCapacity = 4;
private object[] _items;
private int _size;
[NonSerialized]
private object _syncRoot;
private int _version;
private static readonly object[] emptyArray;
注意ArrayList的_items字段
public class List<T> : IList<T>, ICollection<T>, IEnumerable<T>, IList, ICollection, IEnumerable
{
// Fields
private const int _defaultCapacity = 4;
private static T[] _emptyArray;
private T[] _items;
private int _size;
[NonSerialized]
private object _syncRoot;
private int _version;
再看看List的_items字段
如果谁能从源代码级别看的出来List内部调用ArrayList---你真是神！！！！
莫非是我比较浅薄，麻烦您给下分析
#21
我不是神，看不出
#22
支持P1234 的思维方式，
语言嘛， 就是越简单越好！
象楼主的长编大论，谁还看得明？
语言嘛， 就是越简单越好！
象楼主的长编大论，谁还看得明？
#23
支持lz的原创分享心得。
不过在叙述组织上，概念的严谨上还有些改进的余地。
不过在叙述组织上，概念的严谨上还有些改进的余地。
#24
以上有人说List的实现中用到了ArrayList,在C#级别的源代码中我是没有发现，我是百思不得其解，您是怎么认为？
#25
对于系统类库，我觉得最应该从使用者的角度看待问题，把库当成黑盒，当你设计库给别人用的时候，也应该隐藏库本身的复杂性。
我们不是不可以比较汽车和马匹，但是汽车绝对不是不吃草的马匹。你也不会把痰盂当成大号的茶杯。理解每个库，各自的用途，虽然有些场合他们的用途有重叠，但是大部分情况下，各自的用途是明显的。相反的，他们的实现、性能、技巧之类的可能不是很重要，比如Java或者C++也有类似的数组、集合，大部分情况他们的用途、用法和C#一致，虽然内部实现可能大不相同。C# 3.0里面，一个数组可能实现了List的方法，你也可以把它当作List，所以理解用途比单纯讨论他们的区别、联系、优点、缺点更有意义，你觉得呢？
我们不是不可以比较汽车和马匹，但是汽车绝对不是不吃草的马匹。你也不会把痰盂当成大号的茶杯。理解每个库，各自的用途，虽然有些场合他们的用途有重叠，但是大部分情况下，各自的用途是明显的。相反的，他们的实现、性能、技巧之类的可能不是很重要，比如Java或者C++也有类似的数组、集合，大部分情况他们的用途、用法和C#一致，虽然内部实现可能大不相同。C# 3.0里面，一个数组可能实现了List的方法，你也可以把它当作List，所以理解用途比单纯讨论他们的区别、联系、优点、缺点更有意义，你觉得呢？
#26
我不是很了解这个问题。但是我想，List应该不会用到ArrayList，如果让我来设计类库的话。如果你有兴趣，你可以帮我证实下。
#27
从实用角度来看，的确如你所说，但是像Java和C#这样的语言，在一些类库特性上并不是C#或Java它们自身实现的，比如这个数组和泛型，它们的确存在所谓的操作黑箱，它们背地里估计用C/C++实现的
正因为此，C++之父才批评它们，说它们是”小偷“
刚才有人却说List内部调用ArrayList，如果不是真的，就是那个人在胡扯
#28
哈哈，楼主真爱较劲啊
为什么你发的每个帖子都要和别人抬杠呢？
真不知道你技术有多牛，
就算是在牛，你连分享的文章别人有不同意见都不允许，
又有什么用呢？
你要是出生早点有机会当个暴君啊，
当然，也有可能是个死得很惨的固执的学者。
做人大肚点，学术研究高值得人尊重，
如果心胸再宽广点你就是个伟人啊。
不一定非要别人都说你是对的。
别跟我争哈，我没你研究的那么底层，
我就是个it民工：）
为什么你发的每个帖子都要和别人抬杠呢？
真不知道你技术有多牛，
就算是在牛，你连分享的文章别人有不同意见都不允许，
又有什么用呢？
你要是出生早点有机会当个暴君啊，
当然，也有可能是个死得很惨的固执的学者。
做人大肚点，学术研究高值得人尊重，
如果心胸再宽广点你就是个伟人啊。
不一定非要别人都说你是对的。
别跟我争哈，我没你研究的那么底层，
我就是个it民工：）
#29
这个C#源代码中可以证实根本没有ArrayList的调用，至于泛型，就是IL代码也是泛型标志，这是个黑箱，就像newarr指令
#30
又是一个只看别人脚的人，真诚的建议你别搞这一行（发现您不太合适）
#31
我并不是争论什么，我只是想知道答案，记住，答案只会越变越明，做技术的就要心细，钻研，它和做人，办人情事，搞政治的完全不相同
#32
在您那篇c#之父的帖子中已经这么评价过在下了
您真的是血气方刚啊。
我刚才一直都是在建议，
你有没有考虑过为什么这么多人都爱看你的脚呢？
大家全疯了，就您清醒？
如果真是这样对您也不是什么好事儿啊。
只是建议您别一点别人的话也听不进去，
不一定所有的事儿你都是对的。
至于您所说的我不适合做it，
也许真的很有道理，
我考虑一下。
您真的是血气方刚啊。
我刚才一直都是在建议，
你有没有考虑过为什么这么多人都爱看你的脚呢？
大家全疯了，就您清醒？
如果真是这样对您也不是什么好事儿啊。
只是建议您别一点别人的话也听不进去，
不一定所有的事儿你都是对的。
至于您所说的我不适合做it，
也许真的很有道理，
我考虑一下。
#33
我对您并没有什么恶意，可能是有些言辞过于激烈些，让你这类人受不了，我是真诚希望大家抛开表面的态度之见，重点争论下技术本身，这样思维容易开阔，很有思辨性，我想结果对大家而言都是有益的
就刚才那个List问题而言，我不关心那个人对我的态度，我是在意他的那句技术论点，我真的是很想知道，所以就发了一些我对List的佐证，真心希望他也阐述下自己的观点
#34
你看，这样说话别人很容易会去想和你沟通，
像上个帖子那样别人给你点建议就骂人，
不太适合搞学问的人做。
还有就是如果全世界都说你错，
哪怕你是对的，
你也很难有机会去证明。
其实你说的东西很有说服力，
从知识上顶你一下，
希望你以后能做中国的n#之父。
手机没电了，最后一句话：
加油！
像上个帖子那样别人给你点建议就骂人，
不太适合搞学问的人做。
还有就是如果全世界都说你错，
哪怕你是对的，
你也很难有机会去证明。
其实你说的东西很有说服力，
从知识上顶你一下，
希望你以后能做中国的n#之父。
手机没电了，最后一句话：
加油！
#35
我纠正下你的观点，不是说IT民工不管底层只管调用，而搞这一行必须刨根问底。
事实上，随着IT技术的发展，技术堆栈日益庞大，现在不可能有人从最低层到最高层无所不通无所不晓，这是一方面，另一方面，计算机科学系体完备，现在已经远离了那个靠个人技巧诞生很多奇妙软件的年代了。这就是说，实际上，你把计算机科学理论知识掌握，再去看一些源代码，绝大部分源代码采用的算法、优化手段基本上不会超出你的预期判断。
如果真的有什么特别的地方，文档也会详细说明这一点，并且我认为，如果你的“黑盒”有和它的表征不同的地方，向调用者说明，是系统类库开发者的责任。
所以优秀的程序员可以放心地使用设计完善的类库，并且好像这些库是他自己写的那样。仅仅在一些场合，才需要去研究更低层的技术。就算这样，也有很多逆向工程、跟踪调试或者别的手段。
更多的情况是，底层代码采用的那种实现本身没有什么研究的意义，如同正负电荷的定义，以及为什么 x86 使用大端存储一样。
事实上，随着IT技术的发展，技术堆栈日益庞大，现在不可能有人从最低层到最高层无所不通无所不晓，这是一方面，另一方面，计算机科学系体完备，现在已经远离了那个靠个人技巧诞生很多奇妙软件的年代了。这就是说，实际上，你把计算机科学理论知识掌握，再去看一些源代码，绝大部分源代码采用的算法、优化手段基本上不会超出你的预期判断。
如果真的有什么特别的地方，文档也会详细说明这一点，并且我认为，如果你的“黑盒”有和它的表征不同的地方，向调用者说明，是系统类库开发者的责任。
所以优秀的程序员可以放心地使用设计完善的类库，并且好像这些库是他自己写的那样。仅仅在一些场合，才需要去研究更低层的技术。就算这样，也有很多逆向工程、跟踪调试或者别的手段。
更多的情况是，底层代码采用的那种实现本身没有什么研究的意义，如同正负电荷的定义，以及为什么 x86 使用大端存储一样。
#36
谢谢你的鼓励，我本人不是什么高手，但我一直抱着浓厚的兴趣研究技术问题，本人有时言辞有些偏激甚至有些自负，但绝不是那种不地道，*，阴险，不愿和别人交朋友那种
同时与你共勉：加油！
#37
是啊，很多人认为搞C/C++就是本质，完全的扯蛋。
#38
整个一大牛辩论赛呀 不错！
#39
我们宿舍搞c++的经常bs我这个c#
#40
刨根问底到不是不提倡
我们只是不主张。
相对来说，老p说的没错。不能拿以前的老眼光就看这行，不是你知道01010是啥就是好程序员。
30年前，那是技术上就只能这么办。而30年后，你则不需要如此
100年前造个飞机得一个螺丝一个螺丝的研究
100年后还拿着螺丝较劲滴那就不合时宜了
我们只是不主张。
相对来说，老p说的没错。不能拿以前的老眼光就看这行，不是你知道01010是啥就是好程序员。
30年前，那是技术上就只能这么办。而30年后，你则不需要如此
100年前造个飞机得一个螺丝一个螺丝的研究
100年后还拿着螺丝较劲滴那就不合时宜了
#41
LZ是打破沙锅问到底的人（技术达人），签定完毕。
不过，现在的电脑cpu等硬件处理速度越来越快，性能方面，客户不投诉，问题就不大，如果性能不能继续升级硬件。硬件这东西3，5年就淘汰的。
不过，现在的电脑cpu等硬件处理速度越来越快，性能方面，客户不投诉，问题就不大，如果性能不能继续升级硬件。硬件这东西3，5年就淘汰的。
#42
LZ是打破沙锅问到底的人（技术达人），值得学习。
#43
比较赞同sp1234的观点。
比如我买了一辆汽车，我觉得本质应该是我如何把这车开好，怎么样安全快速不违反交通规则的把我自己送到我想去的地方，最多捎带着学习一些简单的故障修理，而不是研究发动机是怎么装配的，螺丝钉是怎么制造出来的这种底层问题。
汽车装配厂的人则要关注如何将这些零件组装成一台满足性能指标的汽车，他们会关注每个零件的性能，之间的匹配性。
而汽车零件生产厂则关注如何将钢铁制造出来合格的汽车零件。
钢铁厂则关注如何生产出来符合要求的钢材。
作为一个C#开发者，其实更像是买车的或者装配车的，非要去关注钢铁是怎样炼成的意义不大。
比如我买了一辆汽车，我觉得本质应该是我如何把这车开好，怎么样安全快速不违反交通规则的把我自己送到我想去的地方，最多捎带着学习一些简单的故障修理，而不是研究发动机是怎么装配的，螺丝钉是怎么制造出来的这种底层问题。
汽车装配厂的人则要关注如何将这些零件组装成一台满足性能指标的汽车，他们会关注每个零件的性能，之间的匹配性。
而汽车零件生产厂则关注如何将钢铁制造出来合格的汽车零件。
钢铁厂则关注如何生产出来符合要求的钢材。
作为一个C#开发者，其实更像是买车的或者装配车的，非要去关注钢铁是怎样炼成的意义不大。
#44
该回复于2011-12-26 14:51:42被版主删除
#45
为了2分没办法，要回下
#46
#47
原理上的东西，
的确要明白。要明白计算机的运行方式，
看来真的要深进 机器码。
到了机器码还不算，还要到达数字电路，（如与非门，js触发器，销存器等等），
到了数字电路还不算，还要深入进晶体管 特性曲线，晶振，等等原理，
到了晶体管还不算，还要了解半导体 （硅）的特性。
可惜，人的寿命长度有限，
不可能什么都要会。
同理，
运用 C# 搞熟了，搞精了，
就可以 开发出以C# 为基础更高级，更容易入门，更容易学的语言。
C/C++ ？ 那些家伙正是搞精了C++ ，才知他的不足，推出JAVA ，C# 的啊
所以，千万不要 bs 学C#的。
C# ，到了如火纯真时，正是新语言的诞生之时！
的确要明白。要明白计算机的运行方式，
看来真的要深进 机器码。
到了机器码还不算，还要到达数字电路，（如与非门，js触发器，销存器等等），
到了数字电路还不算，还要深入进晶体管 特性曲线，晶振，等等原理，
到了晶体管还不算，还要了解半导体 （硅）的特性。
可惜，人的寿命长度有限，
不可能什么都要会。
同理，
运用 C# 搞熟了，搞精了，
就可以 开发出以C# 为基础更高级，更容易入门，更容易学的语言。
C/C++ ？ 那些家伙正是搞精了C++ ，才知他的不足，推出JAVA ，C# 的啊
所以，千万不要 bs 学C#的。
C# ，到了如火纯真时，正是新语言的诞生之时！
#48
争论不是吵架..
#49
各有各的用途~
#50
都是牛人，能自己说服自己就好了。。。