C\#포장 과 분해 깊이 이해(정리 편)

포장(boxing)과 분해(unboxing)는 C\#유형 시스템 의 핵심 개념 입 니 다.C 와 C++와 는 다른 신 개념 입 니 다!포장 과 뜯 기 작업 을 통 해 값 유형 과 인용 유형 에 다 리 를 놓 을 수 있 습 니 다.다시 말 하면 값 유형 과 인용 유형의 상호 전환 을 쉽게 실현 할 수 있 습 니 다.포장 과 뜯 기 는 시스템 을 통일 적 으로 고찰 할 수 있 고 모든 유형의 값 은 최종 적 으로 대상 에 따라 처리 할 수 있 습 니 다.
포장 과 뜯 기 는 값 형식 과 인용 형식 간 의 상호 전환 이 실 행 될 작업 입 니 다.
1. 포장 은 값 형식 에서 인용 형식 으로 전환 할 때 발생 합 니 다.
2. 상 자 를 뜯 는 것 은 참조 형식 에서 값 형식 으로 전환 할 때 발생 합 니 다.

//1、
//                
//2、
//                  ；               
//            ，             Object         ， //            
//  ：
int val = 100;
object obj = val;
Console.WriteLine (“     = {0}", obj);
//         ，               
int val = 100;
object obj = val;
int num = (int) obj;
Console.WriteLine ("num: {0}", num);
//         ，            ，               
// ：            
//3、
 //   .NET ，             (    C++   )  ，    ， //           ，   ，   ，  ：    。
 //            。
  //              。
  //           。
//4：  /     ？
//  ：              。        object           //             。
//  ：  object                            。
//5：      ？(             ？)
//         ，        Object      ， Object      // ，    。          ( Int32)   ，    。
//      ，        ，         ，         //Object。  ，            ，    。
//6：  /       。
//  ：
//               ，            。     。
//   ：        (                      //SyncBlockIndex)。
//   ：                   。
//   ：              。                。
//      ：   Int32  ，     ，       Int32。      //      ，        ，      ，    Int32        //(     )。
//  ：
//      ，               。               。
//    ，                     ，            //  。        。              ，            // ，    ， IL  ，       ，    ，        GetType //             (        )。
//7：  /          
//  ，        ，   ，           ，       ，   //      。
//      ？
//  ，        。
//    2     ，     ，       ，           。  //   ，          。
//  ，       ，                ，     ，     //   。
//    /       ，  C#            ，  ，       //      ，                      IL  。  ：   //           ，                 。
//8：   /         
//  /               ，  ：   ，      ，      //    ，       ？
//              。
//    。
Struct A : ICloneable
{
public Int32 x;
public override String ToString() {
return String.Format(”{0}”,x);
}
public object Clone() {
return MemberwiseClone();
}
}
static void main()
{
A a;
a.x = 100;
Console.WriteLine(a.ToString());
Console.WriteLine(a.GetType());
A a2 = (A)a.Clone();
ICloneable c = a2;
Ojbect o = c.Clone();
}
//5.0：a.ToString()。     A   ToString  ，     ToString  // 。  A    ，           。  ，    ，   。//( ：ToString A   System.ValueType   )
//5.1：a.GetType()，GetType    System.ValueType   ，    ，//         ，  a    ，         ，     //System.ValueType。(   ，           System.ValueType  // )。
//5.2：a.Clone()，  A   Clone  ，      。
//5.3：ICloneable  ： a2        ，    ，           // 。
//5.4：c.Clone()。    ，                   。
// ：              ，                ，  ，  //                。  ，           。  ，    // ，        C++       ，                  //  。
//9：          
//        ，             ，       ，     ，  //   ，        ，         。    ，       。   //     ：(      change  )
public void Change(Int32 x) {
this.x = x;
}
//  ：
A a = new A();
a.x = 100;
Object o = a; //   o，  ，   o  。
((A)o).Change(200); //    ？   。
//       o    ，          A，  ，       A ，  //      。
//( ：   C++ ，                   ，     ， C#//  。)
//      ？
// ，      ，         。
//    ：
interface IChange {
void Change(Int32 x);
}
struct A : IChange {
…
}
//  ：
((IChange)o).Change(200);//    ？   。
//       ？
//  o   IChange ，          ，       ，  o     //  ，     IChange  ，        Change，  ，       //         ，       。
//10、--------------------------
 //              ，        (boxing)：
//1、                    。
//2、                    。
//3、              。
//    ，                              。
//           ，        (unboxing)：
//1、                     ，            。
//2、                         。
//   2 ，      boxing     。        ，      ， //                boxing         。
//11、-------------------------
//NET          System.Object     ，          ：int, //byte, short，bool  ，            。             // (HEAP)     ，        ！(                   //      ！)
//.NET          ？           (value)    //(regerencetype)，C#            （Sbyte、Byte、Short、//Ushort、Int、Uint、Long、Ulong、Char、Float、Double、Bool、//Decimal）、  (enum)、  (struct)，      ： 、  、  、  、//    。
//           ，          ，       NULL；
//           ，    null，      GARBAGE COLLECTION //     ，    ，       ，        ！
//             ！
//                    。  ：
int i=0;
Syste.Object obj=i;
//        ！   i  ！
//                   ！  ：
int i=0;
System.Object obj=i;
int j=(int)obj;
//     2   i  ，     obj  ！1、

총결산
위 에서 말 한 것 은 편집장 이 여러분 에 게 소개 한 C\#포장 과 개봉(정리 편)입 니 다.여러분 에 게 도움 이 되 기 를 바 랍 니 다.궁금 한 점 이 있 으 시 면 저 에 게 메 시 지 를 남 겨 주세요.편집장 은 제때에 답 해 드 리 겠 습 니 다.여기 서도 저희 사이트 에 대한 여러분 의 지지 에 감 사 드 립 니 다!