C# – Capitalization convention for C# protected fields

The only thing you should care about is that you're working in a team where people don't care about cleaning up things a bit. That is very sad.

Do what you do, continue to use the modern style and invite people (but not force them) to adopt it as well. It will take time of course. After some time you will see whether it's going anywhere and what you might be doing next.

P.S. How about arranging a meeting on this issue and invite everyone involved. Then you will get their full attention, denote the problem and present your approach. It will give them something to think about. Perhaps from your local attempts they're not taking you very seriously.

The two features of fields that I feel you might run into more commonly that you would lose by converting them to properties are the following:

1. You can't modify members of a property value if it's a value type.

   // Rectangle is a value type:
   struct Rectangle { int X, Y, Width, Height; }
   
   Rectangle rect;
   Rectangle RectProperty { get; set; }
   
   void Test()
   {
       // This works with a field:
       rect.X = 45;
   
       // but fails with a property:
       RectProperty.X = 45; // compiler error
   
       // The only way to update a value-type property 
       // is to construct & assign a completely new value:
       RectProperty = new Rectangle(45, RectProperty.Y, RectProperty.Width, RectProperty.Height);
   }
   

2. You can't pass a property as an out or ref parameter

   int field;
   int SomeProperty { get; set; }
   
   void Test()
   {
       // Works with a field:
       int.TryParse("some text", out field); 
   
       // but fails with a property:
       int.TryParse("some text", out SomeProperty); // compiler error.
   
       // you need to create temporary storage instead:
       int x;
       if (int.TryParse("some text", out x)) { SomeProperty = x; }
   }
   

If neither of these is an issue for you, then you probably won't notice the difference. There are of course other differences if you're reflecting over your type, or using libraries that reflect over your type and expect things to be properties or fields, etc.