In C#, you can declare a class as static, which requires all members to also be static. Is there any advantage (e.g. performance) to be gained by doing so? Or is it only a matter of making sure you don't accidentally declare instance members in your class?
56900
Here's what :   static class CompanyInfo {     public static string GetCompanyName() { return "CompanyName"; }     public static string GetCompanyAddress() { return "CompanyAddress"; }     //... }       Use a static class as a unit of   organization for methods not   associated with particular objects.   Also, a static class can make your   implementation simpler and faster   because you do not have to create an   object in order to call its methods.   It is useful to organize the methods   inside the class in a meaningful way,   such as the methods of the Math class   in the System namespace.   To me, that example doesn't seem to cover very many possible usage scenarios for static classes. In the past I've used static classes for stateless suites of related functions, but that's about it. So, under what circumstances should (and shouldn't) a class be declared static?
91389
I can't seem to access instance members of the surrounding class from inside an enum, as I could from inside an inner class. Does that mean enums are static? Is there any access to the scope of the surrounding class's instance, or do I have to pass the instance into the enum's method where I need it?  public class Universe {     public final int theAnswer;      public enum Planet {         // ...         EARTH(...);         // ...          // ... constructor etc.          public int deepThought() {             // -&gt; "No enclosing instance of type 'Universe' is accessible in this scope"             return Universe.this.theAnswer;         }     }      public Universe(int locallyUniversalAnswer) {         this.theAnswer = locallyUniversalAnswer;     } }
574
In other words, is this Singleton implementation thread safe:  public class Singleton {     private static Singleton instance;      private Singleton() { }      static Singleton()     {         instance = new Singleton();     }      public static Singleton Instance     {         get { return instance; }     } }
93507
In C#, is there a way to instantiate an instance of a class without invoking its constructor?  Assume the class is public and is defined in a 3rd party library and the constructor is internal.  The reasons I want to do this are complicated but it would be helpful to know if it's possible using some kind of C# hackery.  NOTE: I specifically do not want to call any constructor so using reflection to access the internal constructor is not an option.
54427
I have two classes: Action and MyAction. The latter is declared as:  class MyAction extends Action {/* some methods here */}   All I need is method in the Action class (only in it, because there will be a lot of inherited classes, and I don’t want to implement this method in all of them), which will return classname from a static call. Here is what I’m talking about:  Class Action {  function n(){/* something */} }   And when I call it:  MyAction::n(); // it should return "MyAction"   But each declaration in the parent class has access only to the parent class __CLASS__ variable, which has the value “Action”.  Is there any possible way to do this?
28775
Is it better to initialize class member variables on declaration  private List&lt;Thing&gt; _things = new List&lt;Thing&gt;(); private int _arb = 99;   or in the default constructor?  private List&lt;Thing&gt; _things; private int _arb;  public TheClass() {   _things = new List&lt;Thing&gt;();   _arb = 99; }   Is it simply a matter of style or are there performance trade-offs, one way or the other?
12557
What are the benefits of having a member variable declared as read only?  Is it just protecting against someone changing its value during the lifecycle of the class or does using this keyword result in any speed or efficiency improvements?
114660
Is it better to have all the private members, then all the protected ones, then all the public ones?  Or the reverse?  Or should there be multiple private, protected and public labels so that the operations can be kept separate from the constructors and so on?  What issues should I take into account when making this decision?
85865
As just stated in a recent  and , you can't inherit from a static class.  How does one enforce the rules that go along with static classes inside VB.NET?  Since the framework is compatible between C# and VB it would make sense that there would be a way to mark a class static, but there doesn't seem to be a way.
58176
I was looking at C# collection initializers and found the implementation to be very pragmatic but also very unlike anything else in C#  I am able to create code like this:  using System; using System.Collections;  class Program {     static void Main()     {         Test test = new Test { 1, 2, 3 };     } }  class Test : IEnumerable {     public IEnumerator GetEnumerator()     {         throw new NotImplementedException();     }      public void Add(int i) { } }   Since I have satisfied the minimum requirements for the compiler (implemented IEnumerable and a public void Add) this works but obviously has no value.  I was wondering what prevented the C# team from creating a more strict set of requirements?  In other words why, in order for this syntax to compile, does the compiler not require that the type implement ICollection?  That seems more in the spirit of other C# features.
6968
On an ASP.NET website, are static classes unique to each web request, or are they instantiated whenever needed and GCed whenever the GC decides to disposed of them?  The reason I ask is because I've written some static classes before in C# and the behavior is different than I would have expected. I would have expected static classes to be unique to each request, but it doesn't seem like that is the case.  If they are not unique to each request, is there a way to allow them to be?  UPDATE: The answer driis gave me was exactly what I needed. I was already using a singleton class, however it was using a static instance and therefore was being shared between requests even if the users were different which in this case was a bad thing. Using HttpContext.Current.Items solves my problem perfectly. For anyone who stumbles upon this question in the future, here is my implementation, simplified and shortened so that it easy to understand the pattern:  using System.Collections; using System.Web;  public class GloballyAccessibleClass {     private GloballyAccessibleClass() { }      public static GloballyAccessibleClass Instance     {         get         {             IDictionary items = HttpContext.Current.Items;             if(!items.Contains("TheInstance"))             {                 items["TheInstance"] = new GloballyAccessibleClass();             }             return items["TheInstance"] as GloballyAccessibleClass;         }     } }
22005
I see a lot of example code for C# classes that does this:  public class Point {     public int x { get; set; }     public int y { get; set; } }   Or, in older code, the same with an explicit private backing value and without the new auto-implemented properties:  public class Point {     private int _x;     private int _y;      public int x {         get { return _x; }         set { _x = value; }     }      public int y {         get { return _y; }         set { _y = value; }     } }   My question is why. Is there any functional difference between doing the above and just making these members public fields, like below?  public class Point {     public int x;     public int y; }   To be clear, I understand the value of getters and setters when you need to do some translation of the underlying data. But in cases where you're just passing the values through, it seems needlessly verbose.
26616
In PHP, if a static attribute is defined in the parent class, it cannot be overridden in a child class. But I'm wondering if there's any way around this.   I'm trying to write a wrapper for someone else's (somewhat clunky) function. The function in question can be applied to lots of different data types but requires different flags and options for each. But 99% of the time, a default for each type would suffice.  It would be nice if this could be done with inheritance, without having to write new functions each time. For example:  class Foo {     public static $default = 'DEFAULT';      public static function doSomething ($param = FALSE ) {         $param = ($param === FALSE) ? self::$default : $param;         return $param;     } }  class Bar extends Foo {     public static $default = 'NEW DEFAULT FOR CHILD CLASS'; }  echo Foo::doSomething() . "\n";  // echoes 'DEFAULT'  echo Bar::doSomething() . "\n";  // echoes 'DEFAULT' not 'NEW DEFAULT FOR CHILD CLASS'  // because it references $default in the parent class :(
34071
Consider this:  public class TestClass {      private String a;     private String b;      public TestClass()     {     a = "initialized";     }      public void doSomething()     {     String c;          a.notify(); // This is fine     b.notify(); // This is fine - but will end in an exception     c.notify(); // "Local variable c may not have been initialised"     }  }   I don't get it. "b" is never initialized but will give the same run-time error as "c", which is a compile-time error. Why the difference between local variables and members?  Edit: making the members private was my initial intention, and the question still stands...
67686
Suppose you need to define a class which all it does is hold constants.  public static final String SOME_CONST = "SOME_VALUE";   What is the preferred way of doing this?   Interface Abstract Class Final Class   Which one should I use and why?   Clarifications to some answers:  Enums - I'm not going to use enums, I am not enumerating anything, just collecting some constants which are not related to each other in any way.  Interface - I'm not going to set any class as one that implements the interface. Just want to use the interface to call constants like so: ISomeInterface.SOME_CONST.
10953
Just got a review comment that my static import of the method was not a good idea. The static import was of a method from a DA class, which has mostly static methods. So in middle of the business logic I had a da activity that apparently seemed to belong to the current class:  import static some.package.DA.*; class BusinessObject {   void someMethod() {     ....     save(this);   } }    The reviewer was not keen that I change the code and I didn't but I do kind of agree with him. One reason given for not static-importing was it was confusing where the method was defined, it wasn't in the current class and not in any superclass so it too some time to identify its definition (the web based review system does not have clickable links like IDE :-) I don't really think this matters, static-imports are still quite new and soon we will all get used to locating them.  But the other reason, the one I agree with, is that an unqualified method call seems to belong to current object and should not jump contexts. But if it really did belong, it would make sense to extend that super class.  So, when does it make sense to static import methods? When have you done it? Did/do you like the way the unqualified calls look?  EDIT: The popular opinion seems to be that static-import methods if nobody is going to confuse them as methods of the current class. For example methods from java.lang.Math and java.awt.Color. But if abs and getAlpha are not ambiguous I don't see why readEmployee is. As in lot of programming choices, I think this too is a personal preference thing.   Thanks for your response guys, I am closing the question.
88819
Could you please explain what the practical usage is for the internal keyword in C#?  I know that the internal modifier limits access to the current assembly, but when and in which circumstance should I use it?