What&#39;s the difference between struct and class in .NET?

A String is a reference type even though it has most of the characteristics of a value type such as being immutable and having == overloaded to compare the text rather than making sure they reference the same object.

Why isn&#39;t string just a value type then?

In C#, why is String a reference type that behaves like a value type?

I am wondering if there is any way to declare a byte variable in a short way like floats or doubles? I mean like `5f` and `5d`. Sure I could write `byte x = 5`, but that&#39;s a bit inconsequential if you use `var` for local variables.

Literal suffix for byte in .NET?

There is something that I don&#39;t entirely understand when it comes to mutating value types in Swift.

As the &quot;The Swift Programming Language&quot; iBook states:  ***By default, the properties of a value type cannot be modified from within its instance methods.***

And so to make this possible we can declare methods with the `mutating` keyword inside structs and enums.

The thing that is not entirely clear to me is this:
You can change a var from outside a struct, but you cannot change it from its own methods. This seems counter-intuitive to me, as in Object Oriented languages, you generally try to encapsulate variables so they can only be changed from within. With structs this appears to be the other way around. To elaborate, here&#39;s a code snippet:

    struct Point {
        var x = 0, y = 0
        mutating func moveToX(x: Int, andY y:Int) { //Needs to be a mutating method in order to work
            self.x = x
            self.y = y
        }
    }

    var p = Point(x: 1, y: 2)
    p.x = 3 //Works from outside the struct!
    p.moveToX(5, andY: 5) 



Does anyone know the reason why structs cannot change their content from inside their own context, while the contents can easily be changed elsewhere?

Swift and mutating struct

Some guy asked me this question couple of months ago and I couldn&#39;t explain it in detail. What is the difference between a reference type and a value type in C#?

I know that value types are `int`, `bool`, `float`, etc and reference types are `delegate`, `interface`, etc. Or is this wrong, too?

Can you explain it to me in a professional way?

What is the difference between a reference type and value type in c#?

I don&#39;t understand when to use `AnyObject` and when to use `Any` in Swift.

In my case, I&#39;ve a `Dictionary`

&gt; [String: ???]

??? : Can be `Int`, `Double`, `Float`, `String`, `Array`, `Dictionary`

Can someone explain me the difference between `Any` and `AnyObject`
and which one to use in my case.


AnyObject and Any in Swift

Consider a function which returns two values. We can write:

    // Using out:
    string MyFunction(string input, out int count)
        
    // Using Tuple class:
    Tuple&lt;string, int&gt; MyFunction(string input)
    
    // Using struct:
    MyStruct MyFunction(string input)

Which one is best practice and why?


Returning two values, Tuple vs &#39;out&#39; vs &#39;struct&#39;

I would like to know if &#39;theObject&#39; is an enum (of any enum type) 

     foreach (var item in Enum.GetValues(theObject.GetType())) {

         //do something
     }

Test if an object is an Enum

C# doesn&#39;t allow structs to derive from classes, but all ValueTypes derive from Object. Where is this distinction made?

How does the CLR handle this?

How do ValueTypes derive from Object (ReferenceType) and still be ValueTypes?

I&#39;m trying to collect all of the situations in which boxing occurs in C#:

* Converting value type to `System.Object` type:

        struct S { }
        object box = new S();

* Converting value type to `System.ValueType` type:

        struct S { }
        System.ValueType box = new S();

* Converting value of enumeration type to `System.Enum` type:

        enum E { A }
        System.Enum box = E.A;

* Converting value type into interface reference:

        interface I { }
        struct S : I { }
        I box = new S();

* Using value types in C# string concatenation:

        char c = F();
        string s1 = &quot;char value will box&quot; + c;

  **note:** constants of `char` type are concatenated at compile time

  **note:** since version 6.0 C# compiler [optimizes concatenation][1] involving `bool`, `char`, `IntPtr`, `UIntPtr` types

* Creating delegate from value type instance method:

        struct S { public void M() {} }
        Action box = new S().M;

* Calling non-overridden virtual methods on value types:

        enum E { A }
        E.A.GetHashCode();

* Using C# 7.0 constant patterns under `is` expression:

        int x = …;
        if (x is 42) { … } // boxes both &#39;x&#39; and &#39;42&#39;!

* Boxing in C# tuple types conversions:

        (int, byte) _tuple;

        public (object, object) M() {
          return _tuple; // 2x boxing
        }

* Optional parameters of `object` type with value type default values:

        void M([Optional, DefaultParameterValue(42)] object o);
        M(); // boxing at call-site

* Checking value of unconstrained generic type for `null`:

        bool M&lt;T&gt;(T t) =&gt; t != null;
        string M&lt;T&gt;(T t) =&gt; t?.ToString(); // ?. checks for null
        M(42);

  **note:** this may be optimized by JIT in some .NET runtimes

* Type testing value of unconstrained or `struct` generic type with `is`/`as` operators:

        bool M&lt;T&gt;(T t) =&gt; t is int;
        int? M&lt;T&gt;(T t) =&gt; t as int?;
        IEquatable&lt;T&gt; M&lt;T&gt;(T t) =&gt; t as IEquatable&lt;T&gt;;
        M(42);

  **note:** this may be optimized by JIT in some .NET runtimes

Are there any more situations of boxing, maybe hidden, that you know of?


  [1]: https://github.com/dotnet/roslyn/pull/415



Boxing Occurrence in C#

I know that value types should be immutable, but that&#39;s just a suggestion, not a rule, right?
So why can&#39;t I do something like this:

    struct MyStruct
    {
        public string Name { get; set; }
    }

     public class Program
    {
        static void Main(string[] args)
        {
            MyStruct[] array = new MyStruct[] { new MyStruct { Name = &quot;1&quot; }, new MyStruct { Name = &quot;2&quot; } };
            foreach (var item in array)
            {
                item.Name = &quot;3&quot;;
            }
            //for (int i = 0; i &lt; array.Length; i++)
            //{
            //    array[i].Name = &quot;3&quot;;
            //}

            Console.ReadLine();
        }
    }

The foreach loop in the code doesn&#39;t compile while the commented for loop works fine. The error message:

&gt; Cannot modify members of &#39;item&#39; because it is a &#39;foreach iteration variable&#39;

Why is that?


In C#, why can&#39;t I modify the member of a value type instance in a foreach loop?

I have a list of structs and I want to change one element. For example :

    MyList.Add(new MyStruct(&quot;john&quot;);
    MyList.Add(new MyStruct(&quot;peter&quot;);

Now I want to change one element:

    MyList[1].Name = &quot;bob&quot;

However, whenever I try and do this I get the following error:

&gt; Cannot modify the return value of
&gt; System.Collections.Generic.List&lt;MyStruct&gt;.this[int]‘ because it is not
&gt; a variable

If I use a list of classes, the problem doesn&#39;t occur.

I guess the answer has to do with structs being a value type.

So, if I have a list of structs should I treat them as *read-only*? If I need to change elements in a list then I should use classes and not structs?



Changing the value of an element in a list of structs

Being primarily a C++ developer the absence of [RAII (Resource Acquisition Is Initialization)](http://en.wikipedia.org/wiki/Resource_acquisition_is_initialization) in Java and .NET has always bothered me. The fact that the onus of cleaning up is moved from the class writer to its consumer (by means of `try finally` or .NET&#39;s [`using` construct](http://blogs.msdn.com/cyrusn/archive/2005/05/10/415956.aspx)) seems to be markedly inferior.

I see why in Java there is no support for RAII since all objects are located on the heap and the garbage collector inherently doesn&#39;t support deterministic destruction, but in .NET with the introduction of value-types (`struct`) we have the (seemingly) perfect candidate for RAII. A value type that&#39;s created on the stack has a well defined scope and C++ destructor semantics can be used. However the CLR does not permit a value-type to have a destructor.

My random searches found one argument that if a value-type is [boxed](http://www.csharphelp.com/archives/archive100.html) it falls under the jurisdiction of the garbage collector and therefore its destruction becomes non-deterministic. 
I feel that this argument isn&#39;t strong enough, the benefits of RAII are big enough to say that a value-type with a destructor cannot be boxed (or used as a class member).

**To cut a long story short my question is**: are there any other reasons value types can not be used in order to introduce RAII to .NET?  (or do you think my argument about RAII&#39;s obvious advantages are flawed?)

**Edit:** I must have not phrased the question clearly since the first four answers have missed the point. I *know* about `Finalize` and its non-deterministic characteristics, I know about the `using` construct and I feel these two options are inferior to RAII. `using` is one more thing the consumer of a class must remember (how many people forgot to put a `StreamReader` in a `using` block?). My question is a philosophical one about the language design, why is it the way it is and can it be improved?

For instance with a generic deterministically destructible value-type I can make the `using` and `lock` keywords redundant (achievable by library classes):

        public struct Disposer&lt;T&gt; where T : IDisposable
        {
            T val;
            public Disposer(T t) { val = t; }
            public T Value { get { return val; } }
            ~Disposer()  // Currently illegal 
            {
                if (val != default(T))
                    val.Dispose();
            }
        }
        

---

I can&#39;t help but end with a apropos quotation which I once saw but can&#39;t currently find its origin.
&gt; You can take my deterministic destruction when my cold dead hand goes out of scope.  --*Anon*


Why is there no RAII in .NET?

Apparently you can change the `this` value from anywhere in your struct (but not in classes):

	struct Point
	{
		public Point(int x, int y)
		{
			this = new Point();
			X = x; Y = y;
		}
		int X; int Y;
	}

I&#39;ve neither seen this before nor ever needed it. Why would one ever want to do that? [Eric Lippert reminds us](https://stackoverflow.com/a/4914207/146622) that a feature must be justified to be implemented. What great use case could justify this? Are there any scenarios where this is invaluable? &lt;s&gt;I couldn&#39;t find any documentation on it&lt;/s&gt;&lt;sup&gt;1&lt;/sup&gt;.

Also, for calling constructors there is already a better known alternative syntax, so this feature is sometimes redundant:

	public Point(int x, int y)
		: this()
	{
		X = x; Y = y;
	}

&lt;sub&gt;I found this feature in an example in Jeffrey Richter&#39;s [CLR via C# 4th edition](http://www.amazon.com/CLR-via-Microsoft-Developer-Reference/dp/0735667454).&lt;/sub&gt;&lt;br /&gt;
&lt;sub&gt;1) Apparently it is in the [C# specification](https://stackoverflow.com/a/14767499/146622).&lt;/sub&gt;

Changing the &#39;this&#39; variable of value types

I&#39;ve seen countless posts on how variable capture pulls in variables for the creation of the closure, however they all seem to stop short of specific details and call the whole thing &quot;compiler magic&quot;.

I&#39;m looking for a clear-cut explanation of:

 1. How local variables are *actually* captured. 
 2. The difference (if any) between capturing value types vs. reference types.
 3. And whether there is any boxing occurring with respect to value types. 

My preference would be for an answer in terms of values and pointers (closer to the heart of what happens internally), though I will accept a clear answer involving values and references as well.

Detailed Explanation of Variable Capture in Closures

I&#39;m trying to write an extension method on IEnumerable&lt;T&gt; that will only apply to value types and strings.

    public static string MyMethod&lt;T&gt;(this IEnumerable&lt;T&gt; source) where T : struct, string

However &#39;string&#39; is not a valid constraint as it is a sealed class.

Is there any way to do this?

**Edit:**

What I&#39;m actually trying to do is prepare a list of values for an &quot;IN&quot; clause in a dynamically constructed SQL.

I have lots of instances of code such as the following that I want to clean up:

    sb.AppendLine(string.Format(&quot;AND value IN ({0})&quot;, string.Join(&quot;,&quot;, Values.Select(x =&gt; x.ToSQL()).ToArray())));

Where ToSQL() has code to handle SqlInjection.

C# Generic constraints to include value types AND strings

I used Enum property in my [EntityFramework][1] 5 class,
but in the database this field is nullable. Visual studio gives the error that this property must be a nullable property. My question is: is Enum a reference type or a value type?


  [1]: http://msdn.microsoft.com/en-US/data/ef

Enum is Reference Type or Value Type?

&gt; **Possible Duplicate:**  
&gt; [Is it safe for structs to implement interfaces?](https://stackoverflow.com/questions/63671/is-it-safe-for-structs-to-implement-interfaces)  

&lt;!-- End of automatically inserted text --&gt;

Take this code:

    interface ISomeInterface
    {
        public int SomeProperty { get; }
    }
    
    struct SomeStruct : ISomeInterface
    {
        int someValue;
    
        public int SomeProperty { get { return someValue; } }
    
        public SomeStruct(int value)
        {
            someValue = value;
        }
    }

and then I do this somewhere:

    ISomeInterface someVariable = new SomeStruct(2);

is the `SomeStruct` boxed in this case?

Structs, Interfaces and Boxing

This is a weird behaviour that I cannot make sense of. In my example I have a class `Sample&lt;T&gt;` and an implicit conversion operator from `T` to `Sample&lt;T&gt;`. 

    private class Sample&lt;T&gt;
    {
       public readonly T Value;

       public Sample(T value)
       {
          Value = value;
       }

       public static implicit operator Sample&lt;T&gt;(T value) =&gt; new Sample&lt;T&gt;(value);
    }

The problem occurs when using a nullable value type for `T` such as `int?`. 

    {
       int? a = 3;
       Sample&lt;int&gt; sampleA = a;
    }

**Here is the key part:**  
In my opinion this should not compile because `Sample&lt;int&gt;` defines a conversion from `int` to `Sample&lt;int&gt;` but not from `int?` to `Sample&lt;int&gt;`. **But it compiles and runs successfully!** (By which I mean the conversion operator is invoked and `3` will be assigned to the `readonly` field.)

And it gets even worse. Here the conversion operator isn&#39;t invoked and `sampleB` will be set to `null`:

    {
       int? b = null;
       Sample&lt;int&gt; sampleB = b;
    }

A great answer would probably be split into two parts:

1. Why does the code in the first snippet compile?
2. Can I prevent the code from compiling in this scenario?

Why does an implicit conversion operator from &lt;T&gt; to &lt;U&gt; accept &lt;T?&gt;?

**WARNING: THIS CODE SUCKS, SEE ANTHONY&#39;S COMMENTS**

Which is faster?

1.

      public bool IsValueType&lt;T&gt;(T obj){
           return obj is ValueType;
      }

2.

      public bool IsValueType&lt;T&gt;(T obj){
           return obj == null ? false : obj.GetType().IsValueType;
      } 

3.

      public bool IsValueType&lt;T&gt;(T obj){
           return default(T) != null;
      }

4.Something else

All Value Type Solutions on Gang of Coders

Total of 20 Value Type Solutions

What's the difference between struct and class in .NET?