代码很简单,提示的错误我也明白,但我觉得不应该这样。求解using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;namespace Hello_World
{
        class Program
    {
        public static void PrintArray(object[] objArray)
        {
            foreach (object temObject in objArray)
            {
                Console.WriteLine(temObject.ToString());
            }            Console.WriteLine("\n"); 
        }        static void Main(string[] args)
        {
            int[] intArray = new int[5];
            PrintArray(intArray);
          
         }
    }
}编译的时候提示 无法将 int[] 转换为 object[] 但是objece 不是一切对象的根么?为什么不可以这样用呢?

解决方案 »

  1.   

    vs2008PrintArray(intArray.Cast<Object>().ToArray());
      

  2.   

    楼主的问题有同感,我也在找这个答案。好像反过来,object[] -> int[]也是不行的。
      

  3.   

                int[] intArray = new int[3]{1,2,2};
                object[] objArry=new object[3];
                Array.Copy(intArray, objArry, 3);
                PrintArray(objArry); 
      

  4.   

    int是从object继承下来不错,但int[]不是从object[]继承下来的,两者都是从System.Array继承下来,所以将参数换成object[]和int[]共有的接口,下面是改正后的代码:    class Program
        {
            static void Main(string[] args)
            {
                PrintCollection(new int[5]);
            }        static void PrintCollection(IEnumerable collection)
            {
                foreach (object item in collection)
                {
                    Console.WriteLine(item);
                }
            }
        }
      

  5.   


    这样写是OK的,但是并不是针对object[]和int[]之间的处理
      

  6.   

    同意 hustcyb:“int是从object继承下来不错,但int[]不是从object[]继承下来的,两者都是从System.Array继承下来”int[] intArray = new int[5]; 
    object[]   objArray  =   (object[])System.Collections.ArrayList.Adapter((Array)intArray ).ToArray(typeof(object)); 
      

  7.   

            private void PrintArray( object objArray ) {
                if ( objArray is Array ) {
                    foreach ( object temObject in ( objArray as Array ) ) {
                        Console.WriteLine( temObject.ToString() );
                    }
                } else {
                    Console.WriteLine( objArray.ToString() );
                }
                Console.WriteLine( "\n" );
            }        private  void TestMain( ) {
                int[] intArray = new int[ 5 ] { 1,2,3,4,5};
                PrintArray( intArray );
            } 
    我稍微改了一下代码,如果把 private void PrintArray( object[] objArray )
    改为 private void PrintArray( object objArray )这样的话就可行了。
    只是还是没有搞清 object[] 和 int[] 之间为什么不能简单地强制转换。
      

  8.   

    正如5楼所说“int[]不是从object[]继承下来的,两者都是从System.Array继承下来”。
    只要将代码稍作改动,即可发现里面的窍门了:
    将楼主那代码中的
    public static void PrintArray(object[] objArray) 
    改为
    public static void PrintArray(Array objArray) 
      

  9.   

    int[] 是从 Array 来的
    而 Array 是某种加工过的 object * 1个
    同样道理
    object[] 也是从Array 来的,也是 object * 1个那样 作为根的那个 object 其实是个怪物了。
    只不过它的名称也正好是叫做 object 罢了。
    结论就是我们程序员是无法操作它的了?吗~?
    (我在怀疑这个结论,但是没有好的理由来解释) 
      

  10.   

    object[] 和 int[] 是两个集合,其中的元素一级是包含状态。作为集合一级有不同的特性:值域不同。集合不是包含的从属关系。
      

  11.   

    接 #12楼:您的高见没有错,不过请看如下现象,又当作何解释?
    前提:
            private void PrintArray( object[] objArray ) { 
                if ( objArray is Array ) { 
                    foreach ( object temObject in ( objArray as Array ) ) { 
                        Console.WriteLine( temObject.ToString() ); 
                    } 
                } else { 
                    Console.WriteLine( objArray.ToString() ); 
                } 
                Console.WriteLine( "\n" ); 
            } 
    调用1:
            private  void TestMain( ) {
                object[] objArray = new object[ 5 ] { "1", "2", "3", "4", "5" };
                if ( objArray is Array )
                    Console.WriteLine( "objArray is Array" );
                Array aryObj = objArray;
                object[] objTmp = aryObj as object[];
                PrintArray( objTmp );
            } 
    结果1:编译和执行都通过了
    调用2:
            private  void TestMain( ) {
                object[] objArray = new object[ 5 ] { "1", "2", "3", "4", "5" };
                if ( objArray is Array )
                    Console.WriteLine( "objArray is Array" );
                Array aryObj = objArray;
                PrintArray( aryObj as object[] );
    // 以上的调用通过测试
                int[] intArray = new int[ 5 ] { 1, 2, 3, 4, 5 };
                Array aryInt = intArray;
                if ( aryInt is Array )
                    Console.WriteLine( "aryInt is Array" );
                PrintArray( aryInt as object[] );
            } 
    结果2:编译通过,执行报错:在 Console.WriteLine( objArray.ToString() ); 
          追踪其值:objArray = null
          也就是说:aryInt as object[] 没有成功。
           究其原因:又回到了 int[] 和 object[] 之间的转换问题了。
                     
      

  12.   


    (1) C#中不同类型之间的对象,其构成元素相同的可以转化。
    (2) null 表示空,对没有实例化的对象引用会报错(不只是在这个环境中)。
      

  13.   

    呵呵,做一下解释。1、object确实是一切类的最终基类。2、数组是一种引用类型,它的数据存储在托管堆上。3、数组是一种数据结构,它的内容必须对应到类型。所以,直接在数组间的转换是不行的。即 object[] o=(object[])new int[3];是不行的。即使是整型间long[] l=(long[])new int[3]{1,2,3};也是不行的。只能针对数组中的具体内容的类型进行处理。aryInt as object[] 因为不能转换,所以 aryInt = null; 4、数组间因为不能直接转换(无论是隐式还是显式),所以,数组提供了copy方法来进行内容的复制。即,Array.Copy(intArray, objArry, 3);最终结论,对数组的操作只能对其内容的操作,数组这个整体是无法直接进行转换的
      

  14.   

    2楼正确,使用Cast<object>()既可这个是net3.0以上版本固有的一些不能算“bug”的bugnet4对此做了新的改善,请参考 net4中有关 泛型的逆变与协变 相关资料
      

  15.   

    object[] objArray
    表示该数组中的每个元素是object类型,可以为任何类型
    但object[]是继承于Array的,
    你可能会认为即使Array的话,object也是其基类啊,为什么不可以转换呢
    如果这样想的话,岂不表示object也是object[]的基类呢,显示是不对的
    我只能说
    object和object[]是两种不同的东西同时请参才下面的回答
      

  16.   

     int[] ccc = new int[5];
     object[] bb = ccc.Cast<object>().ToArray(); 既可,微软当初这么设计是为了兼容java的特性,不过缺少泛型的逆变和协变特性也的确对程序员们造成很多困惑,所以net4中特意加入了相关语法特性
      

  17.   

    object[] 和 object两种截然不同的类型,但object[]是间接继承于object,
    而int[]也是同样的情况,而object[]和int[]之前完全没有任何直属关系,
    只不过数组中的元素,是直属关系而已,当然他们都是继承自迭代类
      

  18.   

    这里可以使用装箱和拆箱的概念来补充一下。int i=0;
    object o =i; //装箱,使用一个引用类型来保存值类型的一个副本
    int j =(int)o; //拆箱,显式将引用类型的内容转换为具体的值类型
    数组中,同样存在这个概念。但是,前面说了,数组这个数据结构是无法整体转换的,因为它的存储结构不同,CLR在给数组分配内存时就确定了它存储内容的类型。object[]存储的内容可以是oject,也可以是装箱后的某个值类型的副本。int[]存储的是具体的int整型值类型。两个的存储结构不同,所以是无法整体转换的。
    所以,泛型这个间接的解决方案是可行的。
    class Stack<T>
    {
      public void push(T t){};
      public void pop{};
    }完全可以使用泛型来处理是需要使用存储内容为 object的数组还是int德数组的问题。泛型其实只是一个模板具体到泛型的对象分配内存时,同样是根据代码中声明的类型来确定泛型类型存储的结构内容了
      

  19.   

    object 是一个数据类型
    object [] 也是一个数据类型所有的int 都是object
    但是所有的 int [] 都不是 object []object [] 和 string [] 、double[] 一概没关系。。
      

  20.   

    先 object =int []
    后 int [] = object 
      

  21.   

    不要仅针对array,就算是List<object> 与List<string>都是不可以照这个思路多态的
    两者是兄弟关系,不是继承关系。他们是不同的类型,跟集合中的数据类型没关系
    lz大概被迷惑了,object[]和object级别差远了,完全不是一个概念层次。
      

  22.   

    讨论得很激烈,有一点比较迷惑,在做objece[] int[]的转换报错,但是换成字符串数组或者自定义类的时候这种转换就是成功的,这又作何解呢? 
      

  23.   


    值类型的数组和object[]数组是无法转换的,因为它是值类型。引用类型的数组可以转换,因为字符串数组string[]也是引用类型(字符串string也是引用类型),还有自定义类,即对象,都是引用类型,所以实际上是指针的调用。下面的代码:string[] s=new string[2]{"",""};object[] t = s;t[1] = "11";string[] tt=(string[])t;tt[1] = "22";你会看到数组中的内容发生了变化之后(只对这几个数组变量中的任一个进行赋值操作),其它的数组内容都变化了,说明这个只是引用了数组的指针而已,实际操作的是同一个托管堆对象。
      

  24.   

    int 和 object存储类型不同的,int为值类型存储,object为引用类型存储,数组存储的是连续存储区域的首地址,而且数组初始化必须指定数据类型和长度,所以,尽管int继承自object,但是int[]和object[]是不同的结构,frameword 2.0 之后,有泛型的概念,类似于C++中的模板,用来模糊处理所有类型,以避免用object的方式,因为object是需要装箱/拆箱的,而泛型方法不需要
      

  25.   

    回34楼的,我在25楼已经对泛型做了一点点解释不是说泛型不需要装箱拆箱,因为它在代码中使用时已经指定了具体的类型。比如 Stack<int> tt= new Stack<int>;所以在运行时,CLR在给它分配内存时会按int类型给它指定该泛型类中对应T的类型了。即在new的时候,在托管堆上该泛型类的数据结构已经确定。
      

  26.   

    回10楼,单纯的用 object 代替object[] 会导致foreach无法使用。当然这个可以用for 来代替。
      

  27.   

    问题的焦点在 int[] <-> object[] 不可
                 string[] <-> object[] 确实可以的我的理解是 int[] 作为数组对象 也是引用类型,只是其中的元素是值类型。 问题导论到这里其实有点钻牛角尖的意思了,但还是希望有人能简单的说明一下这是为什么,希望通俗易懂。
      

  28.   

    int是自Object继承来的,int[]不是自Object继承来的,说的真好。
      

  29.   

    不知道你有没有试过,如果你int[]不是数组而是int这时你赋给object是可以的,c#自动装箱,如果你是int[]也就是int【】本身是引用类型,而其中每个值却是值类型,是需要装箱的,但是C#是不能对int【】装箱的不管是隐式还是显式,毕竟它是电脑不是人,呵呵