Per the MSDN:

&quot;You have added a reference to an assembly (assembly1) that has the Embed Interop Types property set to True. This instructs the compiler to embed interop type information from that assembly. However, the compiler cannot embed interop type information from that assembly because another assembly that you have referenced (assembly2) also references that assembly (assembly1) and has the Embed Interop Types property set to False.&quot;

To address this warning

**To embed interop type information for both assemblies, set the Embed Interop Types property on all references to assembly1 to True.**

**This means you must change &#39;Embed Interop Types=true&#39; on System.Windows.Forms.dll** 

or

To remove the warning, you can set the Embed Interop Types property of assembly1 to False. In this case, interop type information is provided by a primary interop assembly (PIA).

I&#39;m interested in building a small real-time multiplayer game, using HTML5/JavaScript for the client and probably Java for the server software.

I looked into WebSockets a bit, but it appears I had misconceptions on what WebSockets actually are.  I had initially thought of WebSockets as just JavaScript&#39;s way of handling TCP sockets, just as they are used in Java and other languages, but it appears there is a whole handshaking process that must take place, and each transmission includes much HTTP overhead (and in that case, the benefits over Ajax do not seem as exciting as at a first glance)?

On a related topic, are there any better alternatives to WebSockets for this purpose (real-time multiplayer games in JavaScript)?

Are WebSockets suitable for real-time multiplayer games?

I ran into this question in an interview and couldn&#39;t come up with a solution. I know the vice versa can be done as shown in https://stackoverflow.com/questions/7456462/what-does-the-operator-do-in-java 

So the question was like below.

    ..... x = .....;
    ..... y = .....;

    x += y; //compile error
    x = x + y; //works properly

How do you declare x and y so that x+=y gives a compilation error and x=x+y not?

I am getting the following warning:

&gt; A reference was created to embedded interop assembly 
&gt; `c:\Program Files (x86)\Reference
&gt; Assemblies\Microsoft\Framework\.NETFramework\v4.0\Accessibility.dll`
&gt; because of an indirect reference to that assembly created by assembly 
&gt; `c:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.0\System.Windows.Forms.dll`.
&gt; Consider changing the &#39;Embed Interop Types&#39; property on either assembly.`

My assembly contains a reference to both Accessibility.dll and System.Windows.Forms.dll.  Why am I getting this warning?

Btw, the Accessibility.dll has &#39;Embed Interop Types=true&#39; while System.Windows.Forms.dll has it set to false.

What does &quot;reference was created to embedded interop assembly&quot; mean?

I am getting the following warning:
> A reference was created to embedded interop assembly
> <code>c:\Program Files (x86)\Reference > Assemblies\Microsoft\Framework\.NETFramework\v4.0\Accessibility.dll</code>
> because of an indirect reference to that assembly created by assembly
> <code>c:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.0\System.Windows.Forms.dll</code>.
> Consider changing the 'Embed Interop Types' property on either assembly.`
My assembly contains a reference to both Accessibility.dll and System.Windows.Forms.dll. Why am I getting this warning?
Btw, the Accessibility.dll has 'Embed Interop Types=true' while System.Windows.Forms.dll has it set to false.

I have heard that Json.NET is faster than DataContractJsonSerializer, and wanted to give it a try... 

But I couldn&#39;t find any methods on JsonConvert that take a stream rather than a string.  

For deserializing a file containing JSON on WinPhone, for example, I use the following code to read the file contents into a string, and then deserialize into JSON.  It appears to be about 4 times slower in my (very ad-hoc) testing than using DataContractJsonSerializer to deserialize straight from the stream... 

    // DCJS
    DataContractJsonSerializer dc = new DataContractJsonSerializer(typeof(Constants));
    Constants constants = (Constants)dc.ReadObject(stream);

    // JSON.NET
    string json = new StreamReader(stream).ReadToEnd();
    Constants constants = JsonConvert.DeserializeObject&lt;Constants&gt;(json);

Am I doing it wrong?

Can Json.NET serialize / deserialize to / from a stream?

I have .NET program that can&#39;t be run from Visual Studio for some reasons (Excel file created from an Excel 2010 template project) for which I need to debug startup events.

If I want to debug events that comes after program initialisation there is no problem. I run the program from the explorer, attach the process to Visual Studio and add some breakpoints in the code. But here, I need to put breakpoints on the startup events. I need to be able to attach processes to Visual Studio, not depending on a PID, but on a specific process name or whatever other solution that would work.

Of course adding a `Thread.Sleep(1000)` in my startup events to give me some time to attach the process in Visual Studio is out of the question!


How do I attach Visual Studio to a process that is not started yet?

D[](http://www.google.com)ear all, I wonder what is the type of `null` literal in C#?

In Java, the `null` literal [is of the special _null type_](http://java.sun.com/docs/books/jls/second_edition/html/typesValues.doc.html#11128):

&gt; There is also a special _null type_, the type of the expression `null`, which has no name. Because the null type has no name, it is impossible to declare a variable of the null type or to cast to the null type. The null reference is the only possible value of an expression of null type. The null reference can always be cast to any reference type.

In C++11, there is `nullptr` (the recommended version of the old buddy `NULL`), which [is of type `std::nullptr_t`](http://en.cppreference.com/w/cpp/language/nullptr).

I searched MSDN about C#, but the [specification](http://msdn.microsoft.com/en-us/library/ms228593.aspx) doesn&#39;t seem to say anything about that.

What is the type of null literal?

&gt; **Possible Duplicate:**  
&gt; [Convert string to DateTime in c#](https://stackoverflow.com/questions/1592653/convert-string-to-datetime-in-c-sharp)  

&lt;!-- End of automatically inserted text --&gt;

A question

I got a string value that actually get from directoryInfo.
What i wanted to accomplish is to convert the string value to a date value for making comparison.

The folder name is sample like this C:\FOLD\20111120
and properly another folder path is like this 
C:\FOLD\20111021

20111120 is actually a date format. I am trying to convert it into date format to made some comparison decide to deleting the whole directory or not.

I think i shall paste my code here

    DirectoryInfo dir = new DirectoryInfo(_FolderPath);

    foreach (DirectoryInfo f in dir.GetDirectories())
    {
         String folderName = f.ToString();
         DateTime ConDt = Convert.ToDateTime(folderName);
         Console.WriteLine(ConDt);
         Console.WriteLine(ConDt.GetType());
       //Console.WriteLine(folderName.GetType());
       //Console.WriteLine(f.GetType());
    }

I tried with Convert.toDatetime() and i get error that unable to made the converstion.How can i do so with this?

Convert YYYYMMDD string date to a datetime value

Am I right in thinking this is the correct use of a Concurrent Dictionary

    private ConcurrentDictionary&lt;int,long&gt; myDic = new ConcurrentDictionary&lt;int,long&gt;();
    
    //Main thread at program startup
    
    for(int i = 0; i &lt; 4; i++)
    {
      myDic.Add(i, 0);
    }
    
    //Separate threads use this to update a value
    
    myDic[InputID] = newLongValue;

I have no locks etc and am just updating the value in the dictionary even though multiple threads might be trying to do the same.

Concurrent Dictionary Correct Usage

I have two classes that perform date date range data fetching for particular days.

    public class IterationLookup&lt;TItem&gt;
    {
        private IList&lt;Item&gt; items = null;
    
        public IterationLookup(IEnumerable&lt;TItem&gt; items, Func&lt;TItem, TKey&gt; keySelector)
        {
            this.items = items.OrderByDescending(keySelector).ToList();
        }
    
        public TItem GetItem(DateTime day)
        {
            foreach(TItem i in this.items)
            {
               if (i.IsWithinRange(day))
               {
                   return i;
               }
            }
            return null;
        }
    }
    
    
    public class LinqLookup&lt;TItem&gt;
    {
        private IList&lt;Item&gt; items = null;
    
        public IterationLookup(IEnumerable&lt;TItem&gt; items, Func&lt;TItem, TKey&gt; keySelector)
        {
            this.items = items.OrderByDescending(keySelector).ToList();
        }
    
        public TItem GetItem(DateTime day)
        {
            return this.items.FirstOrDefault(i =&gt; i.IsWithinRange(day));
        }
    }

Then I do speed tests which show that Linq version is about **5 times slower**. This would make sense when I would store items locally without enumerating them using `ToList`. This would make it much slower, because with every call to `FirstOrDefault`, linq would also perform `OrderByDescending`. But that&#39;s not the case so I don&#39;t really know what&#39;s going on. **Linq should perform very similar to iteration.**

This is the code excerpt that measures my timings
--

    IList&lt;RangeItem&gt; ranges = GenerateRanges(); // returns List&lt;T&gt;

    var iterLookup = new IterationLookup&lt;RangeItems&gt;(ranges, r =&gt; r.Id);
    var linqLookup = new LinqLookup&lt;RangeItems&gt;(ranges, r =&gt; r.Id);

    Stopwatch timer = new Stopwatch();

    timer.Start();
    for(int i = 0; i &lt; 1000000; i++)
    {
        iterLookup.GetItem(GetRandomDay());
    }
    timer.Stop();
    // display elapsed time
    
    timer.Restart();
    for(int i = 0; i &lt; 1000000; i++)
    {
        linqLookup.GetItem(GetRandomDay());
    }
    timer.Stop();
    // display elapsed time

Why do I know it should perform better? Because when I write a very similar code without using these lookup classes, Linq performs very similar to `foreach` iterations...

    // continue from previous code block

    // items used by both order as they do in classes as well
    IList&lt;RangeItem&gt; items = ranges.OrderByDescending(r =&gt; r.Id).ToList();
    
    timer.Restart();
    for(int i = 0; i &lt; 1000000; i++)
    {
        DateTime day = GetRandomDay();
        foreach(RangeItem r in items)
        {
            if (r.IsWithinRange(day))
            {
                // RangeItem result = r;
                break;
            }
        }
    }    
    timer.Stop();
    // display elapsed time

    timer.Restart();
    for(int i = 0; i &lt; 1000000; i++)
    {
       DateTime day = GetRandomDay();
       items.FirstOrDefault(i =&gt; i.IsWithinRange(day));
    }
    timer.Stop();
    // display elapsed time

This is by my opinion highly similar code. `FirstOrDefault` as much as I know also iterate for only as long until it gets to a valid item or until it reaches the end. And this is somehow the same as `foreach` with `break`.

But even iteration class performs worse than my simple `foreach` iteration loop which is also a mystery because all the overhead it has is the call to a method within a class compared to direct access.

Question
--
What am I doing wrong in my LINQ class that it performs so very slow?  
What am I doing wrong in my Iteration class so it performs twice as slow as direct `foreach` loop?

Which times are being measured?
--
I do these steps:

1. Generate ranges (as seen below in results)
2. Create object instances for IterationLookup, LinqLookup (and my optimized date range class BitCountLookup which is not part of discussion here)
3. Start timer and execute 1 million lookups on random days within maximum date range (as seen in results) by using previously instantiated IterationLookup class.
4. Start timer and execute 1 million lookups on random days within maximum date range (as seen in results) by using previously instantiated LinqLookup class.
5. Start timer and execute 1 million lookups (6 times) using manual foreach+break loops and Linq calls.

As you can see **object instantiation is not measured**.

Appendix I: Results over million lookups
--
Ranges displayed in these results don&#39;t overlap, which should make both approaches even more similar in case LINQ version doesn&#39;t break loop on successful match (which it highly likely does).

&lt;pre&gt;
Generated Ranges:

ID Range        000000000111111111122222222223300000000011111111112222222222
                123456789012345678901234567890112345678901234567890123456789
09 22.01.-30.01.                     |-------|
08 14.01.-16.01.             |-|
07 16.02.-19.02.                                              |--|
06 15.01.-17.01.              |-|
05 19.02.-23.02.                                                 |---|
04 01.01.-07.01.|-----|
03 02.01.-10.01. |-------|
02 11.01.-13.01.          |-|
01 16.01.-20.01.               |---|
00 29.01.-06.02.                            |-------|

Lookup classes...

- Iteration: 1028ms
&lt;b&gt;- Linq: 4517ms   !!! THIS IS THE PROBLEM !!!&lt;/b&gt;
- BitCounter: 401ms

Manual loops...

- Iter: 786ms
- Linq: 981ms
- Iter: 787ms
- Linq: 996ms
- Iter: 787ms
- Linq: 977ms
- Iter: 783ms
- Linq: 979ms
&lt;/pre&gt;

Appendix II: GitHub:Gist code to test for yourself
--
I&#39;ve put up a Gist so you can get the full code yourself and see what&#39;s going on. Create a **Console** application and copy *Program.cs* into it an add other files that are part of this gist.

Grab it [here](https://gist.github.com/1385081).

Appendix III: Final thoughts and measurement tests
--
The most problematic thing was of course LINQ implementatino that was awfully slow. Turns out that this has all to do with delegate compiler optimization. [LukeH provided the best and most usable solution](https://stackoverflow.com/q/8225900/75642) that actually made me try different approaches to this. I&#39;ve tried various different approaches in the `GetItem` method (or `GetPointData` as it&#39;s called in Gist):

1. the usual way that most of developers would do (and is implemented in Gist as well and wasn&#39;t updated after results revealed this is not the best way of doing it):

        return this.items.FirstOrDefault(item =&gt; item.IsWithinRange(day));

2. by defining a local predicate variable:

        Func&lt;TItem, bool&gt; predicate = item =&gt; item.IsWithinRange(day);
        return this.items.FirstOrDefault(predicate);

3. local predicate builder:

        Func&lt;DateTime, Func&lt;TItem, bool&gt;&gt; builder = d =&gt; item =&gt; item.IsWithinRange(d);
        return this.items.FirstOrDefault(builder(day));

4. local predicate builder and local predicate variable:


        Func&lt;DateTime, Func&lt;TItem, bool&gt;&gt; builder = d =&gt; item =&gt; item.IsWithinRange(d);
        Func&lt;TItem, bool&gt; predicate = builder(day);
        return this.items.FirstOrDefault(predicate);

5. class level (static or instance) predicate builder:

        return this.items.FirstOrDefault(classLevelBuilder(day));

6. externally defined predicate and provided as method parameter

        public TItem GetItem(Func&lt;TItem, bool&gt; predicate)
        {
            return this.items.FirstOrDefault(predicate);
        }

    when executing this method I also took two approaches:

    1. predicate provided directly at method call within `for` loop:

            for (int i = 0; i &lt; 1000000; i++)
            {
                linqLookup.GetItem(item =&gt; item.IsWithinRange(GetRandomDay()));
            }

    2. predicate builder defined outside `for` loop:

            Func&lt;DateTime, Func&lt;Ranger, bool&gt;&gt; builder = d =&gt; r =&gt; r.IsWithinRange(d);
            for (int i = 0; i &lt; 1000000; i++)
            {
                linqLookup.GetItem(builder(GetRandomDay()));
            }

###Results - what performs best
For comparison when using iteration class, it takes it approx. **770ms** to execute 1 million lookups on randomly generated ranges.

1. #3 local predicate builder turns out to be best compiler optimized so it performs almost as fast as usual iterations. **800ms**.
2. #6.2 predicate builder defined outside `for` loop: **885ms**
3. #6.1 predicate defined within `for` loop: **1525ms**
4. all others took somewhere between **4200ms - 4360ms** and are thus considered unusable.

So whenever you use a predicate in externally frequently callable method, define a builder and execute that. This will yield best results.

The biggest surprise to me about this is that delegates (or predicates) may be this much time consuming.


foreach + break vs linq FirstOrDefault performance difference

I&#39;d like to add caching capabilities to my application using the `System.Runtime.Caching` namespace, and would probably want to use caching in several places and in different contexts.
To do so, I want to use several MemoryCache instances.

However, I see [here][1] that using more than one instance of MemoryCache is discouraged:
&gt;MemoryCache is not a singleton, but you should create only a few or potentially only one MemoryCache instance and code that caches items should use those instances.

How would multiple MemoryCache instances affect my application?
I find this kind of weird because it seems to me that using multiple caches in an application is a pretty common scenario.

**EDIT:** More specifically, I have a class that should keep a cache for each instance. Should I avoid using `MemoryCache` and look for a different caching solution? Is using `MemoryCache` in this situation considered bad, and if so, why?

 [1]: http://msdn.microsoft.com/en-us/library/system.runtime.caching.objectcache.aspx

Using multiple instances of MemoryCache

Imagine that I have a dynamic variable:

    dynamic d = *something*

Now, I create properties for `d` which I have on the other hand from a string array:

    string[] strarray = { &#39;property1&#39;,&#39;property2&#39;,..... }

I don&#39;t know the property names in advance.

How in code, once `d` is created and strarray is pulled from DB, can I get the values?

I want to get `d.property1 , d.property2`.

I see that the object has a `_dictionary` internal dictionary that contains the keys and the values, how do I retrieve them?

Get property value from C# dynamic object by string (reflection?)

I have a `private readonly` list of `LinkLabel`s (`IList&lt;LinkLabel&gt;`). I later add `LinkLabel`s to this list and add those labels to a `FlowLayoutPanel` like follows:


    foreach(var s in strings)
    {
        _list.Add(new LinkLabel{Text=s});
    }

    flPanel.Controls.AddRange(_list.ToArray());

Resharper shows me a warning: `Co-variant array conversion from LinkLabel[] to Control[] can cause run-time exception on write operation`. 

Please help me to figure out:

  1. What does this means? 
  2. This is a user control and will not be accessed by multiple objects to setup labels,
     so keeping code as such will not affect it.


Content Type	Original Author	Original Content on Stackoverflow
Question	AngryHacker	View Question on Stackoverflow
Solution 1 - .Net	KreepN	View Answer on Stackoverflow

What does "reference was created to embedded interop assembly" mean?

.Net Problem Overview

.Net Solutions

Solution 1 - .Net

How do you declare x and y so that x+=y gives a compilation error and x=x+y not?

Are WebSockets suitable for real-time multiplayer games?

Attributions