.NET中的结构和类有什么区别?


当前回答

在.NET中,结构和类声明区分引用类型和值类型。

传递引用类型时,实际存储的只有一个。访问实例的所有代码都在访问同一个实例。

传递值类型时,每个值类型都是副本。所有代码都在自己的副本上运行。

这可以用一个例子来说明:

struct MyStruct 
{
    string MyProperty { get; set; }
}

void ChangeMyStruct(MyStruct input) 
{ 
   input.MyProperty = "new value";
}

...

// Create value type
MyStruct testStruct = new MyStruct { MyProperty = "initial value" }; 

ChangeMyStruct(testStruct);

// Value of testStruct.MyProperty is still "initial value"
// - the method changed a new copy of the structure.

对于一个班级来说,这将是不同的

class MyClass 
{
    string MyProperty { get; set; }
}

void ChangeMyClass(MyClass input) 
{ 
   input.MyProperty = "new value";
}

...

// Create reference type
MyClass testClass = new MyClass { MyProperty = "initial value" };

ChangeMyClass(testClass);

// Value of testClass.MyProperty is now "new value" 
// - the method changed the instance passed.

类可以是空的-引用可以指向空。

结构是实际值-它们可以为空,但决不能为空。因此,结构总是有一个没有参数的默认构造函数——它们需要一个“起始值”。

其他回答

如前所述:类是引用类型,而结构是具有所有后果的值类型。

根据经验,框架设计指南建议在以下情况下使用结构而不是类:

它的实例大小小于16字节它逻辑上表示单个值,类似于原始类型(int、double等)它是不可变的它不必经常装箱

在.NET中,有两类类型,引用类型和值类型。

结构是值类型,类是引用类型。

一般的区别是,引用类型存在于堆中,值类型存在于内联中,也就是说,在定义变量或字段的任何位置。

包含值类型的变量包含整个值类型值。对于结构,这意味着变量包含整个结构及其所有字段。

包含引用类型的变量包含指针,或对内存中实际值所在位置的引用。

首先,这有一个好处:

值类型始终包含值引用类型可以包含空引用,这意味着它们此刻根本不引用任何内容

在内部,引用类型被实现为指针,并且知道变量赋值是如何工作的,还有其他行为模式:

将值类型变量的内容复制到另一个变量中,将整个内容复制到新变量中,使这两个变量不同。换句话说,复制后,对其中一个的更改不会影响另一个将一个引用类型变量的内容复制到另一个变量中,就会复制引用,这意味着现在有两个引用指向实际数据的同一个存储位置。换句话说,在复制之后,更改一个引用中的数据似乎也会影响另一个引用,但这只是因为您实际上只是在两个地方查看相同的数据

当您声明变量或字段时,以下是两种类型的区别:

变量:值类型位于堆栈上,引用类型位于堆栈中,作为指向堆内存中实际内存所在位置的指针(请注意EricLipperts系列文章:堆栈是一个实现细节)类/结构字段:值类型完全位于类型内部,引用类型位于类型内部作为指向堆内存中实际内存所在位置的指针。

除了访问说明符的基本区别,以及上面提到的几个区别之外,我还想添加一些主要区别,包括上面提到的一些区别,以及带有输出的代码示例,这将提供对引用和值的更清晰的了解

结构:

是值类型,不需要堆分配。内存分配不同,存储在堆栈中适用于小型数据结构影响性能,当我们将值传递给方法时,我们会传递整个数据结构,所有数据都传递给堆栈。构造函数只返回结构值本身(通常在堆栈上的临时位置),然后根据需要复制该值每个变量都有自己的数据副本,其中一个变量的操作不可能影响另一个变量。不支持用户指定的继承,它们隐式继承自类型对象

类别:

参考类型值存储在堆中存储对动态分配对象的引用构造函数是用new运算符调用的,但它不会在堆上分配内存多个变量可以引用同一对象对一个变量的操作可能会影响另一个变量引用的对象

代码示例

    static void Main(string[] args)
    {
        //Struct
        myStruct objStruct = new myStruct();
        objStruct.x = 10;
        Console.WriteLine("Initial value of Struct Object is: " + objStruct.x);
        Console.WriteLine();
        methodStruct(objStruct);
        Console.WriteLine();
        Console.WriteLine("After Method call value of Struct Object is: " + objStruct.x);
        Console.WriteLine();

        //Class
        myClass objClass = new myClass(10);
        Console.WriteLine("Initial value of Class Object is: " + objClass.x);
        Console.WriteLine();
        methodClass(objClass);
        Console.WriteLine();
        Console.WriteLine("After Method call value of Class Object is: " + objClass.x);
        Console.Read();
    }
    static void methodStruct(myStruct newStruct)
    {
        newStruct.x = 20;
        Console.WriteLine("Inside Struct Method");
        Console.WriteLine("Inside Method value of Struct Object is: " + newStruct.x);
    }
    static void methodClass(myClass newClass)
    {
        newClass.x = 20;
        Console.WriteLine("Inside Class Method");
        Console.WriteLine("Inside Method value of Class Object is: " + newClass.x);
    }
    public struct myStruct
    {
        public int x;
        public myStruct(int xCons)
        {
            this.x = xCons;
        }
    }
    public class myClass
    {
        public int x;
        public myClass(int xCons)
        {
            this.x = xCons;
        }
    }

输出

Struct Object的初始值为:10

内部结构方法Struct对象的内部方法值为:20

结构对象的方法调用值为:10

类对象的初始值为:10

内部类方法类对象的内部方法值为:20

类对象的方法调用值为:20

在这里,您可以清楚地看到按值调用和按引用调用之间的区别。

结构和类别之间的差异:

结构是值类型,而类是引用类型。结构存储在堆栈上,而类存储在堆值类型将其值保存在声明它们的内存中,但引用类型保存对内存中对象的引用。值类型在作用域丢失后立即销毁,而引用类型仅在作用域丢失后销毁变量。该对象随后被垃圾收集器销毁。将结构复制到另一个结构时,该结构的新副本创建。修改的结构不会影响其他结构。将一个类复制到另一个类时,它只复制参考变量。两个引用变量都指向堆上的同一对象。对一个变量所做的更改将影响另一个参考变量。结构不能有析构函数,但类可以有析构器。结构不能具有显式无参数构造函数,而类可以。结构不支持继承,但类支持支持从接口继承。结构为密封型。

Struct Class
Type Value-type Reference-type
Where On stack / Inline in containing type On Heap
Deallocation Stack unwinds / containing type gets deallocated Garbage Collected
Arrays Inline, elements are the actual instances of the value type Out of line, elements are just references to instances of the reference type residing on the heap
Al-Del Cost Cheap allocation-deallocation Expensive allocation-deallocation
Memory usage Boxed when cast to a reference type or one of the interfaces they implement,
Unboxed when cast back to value type
(Negative impact because boxes are objects that are allocated on the heap and are garbage-collected)
No boxing-unboxing
Assignments Copy entire data Copy the reference
Change to an instance Does not affect any of its copies Affect all references pointing to the instance
Mutability Should be immutable Mutable
Population In some situations Majority of types in a framework should be classes
Lifetime Short-lived Long-lived
Destructor Cannot have Can have
Inheritance Only from an interface Full support
Polymorphism No Yes
Sealed Yes When have sealed keyword (C#), or Sealed attribute (F#)
Constructor Can not have explicit parameterless constructors Any constructor
Null-assignments When marked with nullable question mark Yes (When marked with nullable question mark in C# 8+ and F# 5+ 1)
Abstract No When have abstract keyword (C#), or AbstractClass attribute (F#)
Member Access Modifiers public, private, internal public, protected, internal, protected internal, private protected

1不鼓励在F#中使用null,请改用Option类型。