字段是类中的变量。字段是可以通过使用访问修饰符封装的数据。

财产与字段类似，它们定义与对象关联的状态和数据。

与字段不同，属性有一种特殊的语法来控制用户如何读取数据和写入数据，这些被称为get和set运算符。集合逻辑通常可用于进行验证。

看完所有答案后，我没有找到关于并发访问的答案。

假设您有一个可以异步访问的API端点，并且您使用静态字段存储数据，并且需要对静态字段进行独占访问。

为了重现这个示例，您需要一个负载测试来同时访问端点。

当使用静态int计数器字段时，端点在两次或多次访问中获得相同的值。

当使用静态int计数器属性时，端点处理并发性，并始终获取计数器的新值。

这根本不能回答问题，但在使用其中一种或另一种时，必须考虑到这种行为。

财产显示字段。字段应该（几乎总是）对类保持私有，并通过get和set财产进行访问。财产提供了一个抽象级别，允许您更改字段，同时不影响使用类的事物访问字段的外部方式。

public class MyClass
{
    // this is a field.  It is private to your class and stores the actual data.
    private string _myField;

    // this is a property. When accessed it uses the underlying field,
    // but only exposes the contract, which will not be affected by the underlying field
    public string MyProperty
    {
        get
        {
            return _myField;
        }
        set
        {
            _myField = value;
        }
    }

    // This is an AutoProperty (C# 3.0 and higher) - which is a shorthand syntax
    // used to generate a private field for you
    public int AnotherProperty { get; set; } 
}

@Kent指出，财产不需要封装字段，它们可以对其他字段进行计算，也可以用于其他目的。

@GSS指出，您还可以在访问属性时执行其他逻辑，例如验证，这是另一个有用的功能。

面向对象的编程原则表明，类的内部工作应该对外界隐藏。如果公开一个字段，本质上就是公开类的内部实现。因此，我们用财产（Properties）（或Java中的方法）包装字段，使我们能够在不破坏代码的情况下更改实现。考虑到我们可以在Property中放置逻辑，还允许我们在需要时执行验证逻辑等。C#有一个可能令人困惑的自动属性概念。这允许我们简单地定义Property，而C#编译器将为我们生成私有字段。

public class Person
{
   private string _name;

   public string Name
   {
      get
      {
         return _name;
      }
      set
      {
         _name = value;
      }
   }
   public int Age{get;set;} //AutoProperty generates private field for us
}

这里的第二个问题，“什么时候应该使用字段而不是属性？”，在另一个答案中只简短地提到了这个问题，也有点像这个问题，但没有太多细节。

总的来说，所有其他答案都是关于良好设计的一针见血的：比起暴露字段，更喜欢暴露财产。虽然你可能不会经常说“哇，想象一下，如果我把这里变成了一块地而不是一块地，情况会变得多么糟糕”，但想到你会说“哇！谢天谢地，我在这里用了一块土地而不是一处地”的情况，那就难得多了

但与财产相比，字段有一个优点，那就是它们可以用作“ref”/“out”参数。假设您有一个具有以下签名的方法：

public void TransformPoint(ref double x, ref double y);

假设您希望使用该方法来转换如下创建的数组：

System.Windows.Point[] points = new Point[1000000];
Initialize(points);

因为X和Y是财产，所以我认为这是最快的方法：

for (int i = 0; i < points.Length; i++)
{
    double x = points[i].X;
    double y = points[i].Y;
    TransformPoint(ref x, ref y);
    points[i].X = x;
    points[i].Y = y;
}

这会很好的！除非你的测量结果证明了这一点，否则没有理由大惊小怪。但我认为，从技术上来说，它并不能保证像这样快：

internal struct MyPoint
{
    internal double X;
    internal double Y;
}

// ...

MyPoint[] points = new MyPoint[1000000];
Initialize(points);

// ...

for (int i = 0; i < points.Length; i++)
{
    TransformPoint(ref points[i].X, ref points[i].Y);
}

我自己进行了一些测量，带字段的版本与带财产的版本（.NET 4.6、Windows 7、x64、发布模式、未附加调试程序）相比，大约需要61%的时间。TransformPoint方法的成本越高，差异就越不明显。若要自己重复此操作，请将第一行注释掉，并将其未注释掉。

即使上述方法没有性能优势，但在其他地方使用ref和out参数可能会有好处，例如在调用Interlocked或Volatile方法家族时。注意：如果这对您来说是新的，Volatile基本上是一种获得Volatile关键字提供的相同行为的方法。因此，就像volatile一样，它并没有像名字所暗示的那样神奇地解决所有线程安全问题。

我当然不想让人觉得我在提倡你说“哦，我应该开始公开字段，而不是财产。”关键是，如果你需要在调用中定期使用这些成员来接受“ref”或“out”参数，尤其是在可能是简单值类型的东西上，它不太可能需要财产的任何增值元素，那么可以进行一个参数。

基本区别和一般区别是：

领域

始终给予get和set访问权限不会造成副作用（引发异常、调用方法、更改字段（获取/设置的字段除外）等）

财产

并非总是同时提供get和set访问权限CAN导致副作用