Try using this.

    /// &lt;summary&gt;
    /// &lt;para&gt;Paragraph 1.&lt;/para&gt;
    /// &lt;para&gt;Paragraph 2.&lt;/para&gt;
    /// &lt;/summary&gt;

But I don&#39;t think you can have an actual empty line.
Empty para tag gets ignored.

Try this:

    /// &lt;summary&gt;
    /// &lt;para&gt;&#160;[Non-Breaking Space]&#160;&lt;/para&gt;
    /// &lt;/summary&gt;

`[Non-Breaking Space]` is obtained using &lt;kbd&gt;Alt&lt;/kbd&gt;+&lt;kbd&gt;255&lt;/kbd&gt; (using the Numpad).

It will show up as an empty new line.  I know this is old, but it worked for me today.

    /// &lt;summary&gt;&lt;br /&gt;
    /// &lt;para&gt;To treat comment line like a DIV tag, surround them with PARA tags.&lt;/para&gt;&lt;br /&gt;
    /// &lt;para&gt;To add a break with whitespace, add the following line:&lt;/para&gt;&lt;br /&gt;
    /// &lt;para&gt;&amp;#160;&lt;/para&gt;&lt;br /&gt;
    /// &lt;/summary&gt;

Your only hope is probably something cludgy like this:

    /// &lt;summary&gt;
    /// &lt;para&gt;line one&lt;/para&gt;
    /// &lt;para&gt;_&lt;/para&gt;
    /// &lt;para&gt;line two&lt;/para&gt;
    /// &lt;/summary&gt;



Well, it is Xml.  Maybe `&amp;#10;&amp;#13;`

Computer Haiku  
How would you write a program  
To make them for you

How would you write a program to generate Haiku?

Is it safe to assume that `NULL` always translates to false in C?

    void *somePtr = NULL;
    
    if (!somePtr) {
      /* This will always be executed? */
    }

Or should an explicit check against the value of `NULL` be made?

Is NULL always false?

Does anyone know how to insert a line break into a summary comment in order for the line break to be reflected in Intellisense documentation? 

To clarify, assume code documentation..

    /// &lt;summary&gt;
    /// Some text documentation
    ///  - a line break - 
    /// Some more documentation
    /// &lt;/summary&gt;
    public void SomeMethod() { }

So when using this method Intellisense offers a summary for the method formatted like this:

&gt;Some text documentation
&gt;
&gt;Some more documentation

**(Note - the &#39;para&#39; tag doesn&#39;t create empty line breaks - I&#39;ve tried it!)**

Adding line breaks to comments for Intellisense

Does anyone know how to insert a line break into a summary comment in order for the line break to be reflected in Intellisense documentation?
To clarify, assume code documentation..
<pre><code class="hljs language-csharp">/// &#x3C;summary>
/// Some text documentation
/// - a line break - 
/// Some more documentation
/// &#x3C;/summary>
public void SomeMethod() { }
</code></pre>
So when using this method Intellisense offers a summary for the method formatted like this:
>Some text documentation
>
>Some more documentation
(Note - the 'para' tag doesn't create empty line breaks - I've tried it!)

I know this may sounds like a pointless question, but hear me out...

I basically want to know if I can trust the GUID to generate a value which will be unique 100% of the time and impossible to predict.

I&#39;m basically rolling my on login system for a website and want to know if the GUID is secure enough for session cookies.

Any background on how the GUID is generated would be much appreciated in evaluating the answers.

**Thanks for the links to duplicate questions, however, my question is specific to the .Net framework.**

How Random is System.Guid.NewGuid()?

I&#39;ve written the following routine to manually traverse through a directory and calculate its size in C#/.NET:

&lt;pre&gt;
&lt;code&gt;
protected static float CalculateFolderSize(string folder)
{
    float folderSize = 0.0f;
    try
    {
        //Checks if the path is valid or not
        if (!Directory.Exists(folder))
            return folderSize;
        else
        {
            try
            {
                foreach (string file in Directory.GetFiles(folder))
                {
                    if (File.Exists(file))
                    {
                        FileInfo finfo = new FileInfo(file);
                        folderSize += finfo.Length;
                    }
                }

                foreach (string dir in Directory.GetDirectories(folder))
                    folderSize += CalculateFolderSize(dir);
            }
            catch (NotSupportedException e)
            {
                Console.WriteLine(&quot;Unable to calculate folder size: {0}&quot;, e.Message);
            }
        }
    }
    catch (UnauthorizedAccessException e)
    {
        Console.WriteLine(&quot;Unable to calculate folder size: {0}&quot;, e.Message);
    }
    return folderSize;
}
&lt;/code&gt;
&lt;/pre&gt;

I have an application which is running this routine repeatedly for a large number of folders.  I&#39;m wondering if there&#39;s a more efficient way to calculate the size of a folder with .NET?  I didn&#39;t see anything specific in the framework.  Should I be using P/Invoke and a Win32 API?  What&#39;s the most efficient way of calculating the size of a folder in .NET?

What&#39;s the best way to calculate the size of a directory in .NET?

**Edit:** I apologize everybody. I used the term &quot;jagged array&quot; when I actually meant to say &quot;multi-dimensional array&quot; (as can be seen in my example below). I apologize for using the incorrect name. I actually found jagged arrays to be faster than multi-dimensional ones! I have added my measurements for jagged arrays.

I was trying to use a &lt;del&gt;jagged&lt;/del&gt; multi-dimensional array today, when I noticed that it&#39;s performance is not as I would have expected. Using a single-dimensional array and manually calculating indices was much faster (almost two times) than using a 2D array. I wrote a test using  `1024*1024` arrays (initialized to random values), for 1000 iterations, and I got the following results on my machine:

    sum(double[], int): 2738 ms (100%)
    sum(double[,]):     5019 ms (183%)
    sum(double[][]):    2540 ms ( 93%)

This is my test code:

    public static double sum(double[] d, int l1) {
        // assuming the array is rectangular
        double sum = 0;
        int l2 = d.Length / l1;
        for (int i = 0; i &lt; l1; ++i)
            for (int j = 0; j &lt; l2; ++j)
                sum += d[i * l2 + j];
        return sum;
    }

    public static double sum(double[,] d) {
        double sum = 0;
        int l1 = d.GetLength(0);
        int l2 = d.GetLength(1);
        for (int i = 0; i &lt; l1; ++i)
            for (int j = 0; j &lt; l2; ++j)
                sum += d[i, j];
        return sum;
    }

    public static double sum(double[][] d) {
        double sum = 0;
        for (int i = 0; i &lt; d.Length; ++i)
            for (int j = 0; j &lt; d[i].Length; ++j)
                sum += d[i][j];
        return sum;
    }

    public static void Main() {
        Random random = new Random();
        const int l1  = 1024, l2 = 1024;
        double[ ] d1  = new double[l1 * l2];
        double[,] d2  = new double[l1 , l2];
        double[][] d3 = new double[l1][];

        for (int i = 0; i &lt; l1; ++i) {
            d3[i] = new double[l2];
            for (int j = 0; j &lt; l2; ++j)
                d3[i][j] = d2[i, j] = d1[i * l2 + j] = random.NextDouble();
        }
        //
        const int iterations = 1000;
        TestTime(sum, d1, l1, iterations);
        TestTime(sum, d2, iterations);
        TestTime(sum, d3, iterations);
    }

Further investigation showed that the IL for the second method is 23% larger than that of the first method. (Code size 68 vs 52.) This is mostly due to calls to `System.Array::GetLength(int)`. The compiler also emits calls to `Array::Get` for the &lt;del&gt;jagged&lt;/del&gt; multi-dimensional array, whereas it simply calls `ldelem` for the simple array.

So I am wondering, why is access through multi-dimensional arrays slower than normal arrays? I would have assumed the compiler (or JIT) would do something similar to what I did in my first method, but this was not actually the case.

Could you plese help me understand why this is happening the way it is?

----------

**Update:** Following Henk Holterman&#39;s suggestion, here is the implementation of `TestTime`:

    public static void TestTime&lt;T, TR&gt;(Func&lt;T, TR&gt; action, T obj,
                                       int iterations)
    {
        Stopwatch stopwatch = Stopwatch.StartNew();
        for (int i = 0; i &lt; iterations; ++i)
            action(obj);
        Console.WriteLine(action.Method.Name + &quot; took &quot; + stopwatch.Elapsed);
    }

    public static void TestTime&lt;T1, T2, TR&gt;(Func&lt;T1, T2, TR&gt; action, T1 obj1,
                                            T2 obj2, int iterations)
    {
        Stopwatch stopwatch = Stopwatch.StartNew();
        for (int i = 0; i &lt; iterations; ++i)
            action(obj1, obj2);
        Console.WriteLine(action.Method.Name + &quot; took &quot; + stopwatch.Elapsed);
    }


Why are multi-dimensional arrays in .NET slower than normal arrays?

I need to remove multiple items from a Dictionary.
A simple way to do that is as follows :

      List&lt;string&gt; keystoremove= new List&lt;string&gt;();
      foreach (KeyValuePair&lt;string,object&gt; k in MyCollection)
         if (k.Value.Member==foo)
            keystoremove.Add(k.Key);
      foreach (string s in keystoremove)
            MyCollection.Remove(s);

The reason why I can&#39;t directly Remove the items in the foreach block is that this would throw an Exception (&quot;Collection was modified...&quot;)

I&#39;d like to do the following :

     MyCollection.RemoveAll(x =&gt;x.Member==foo)

But the Dictionary&lt;&gt; class doesn&#39;t expose a RemoveAll(Predicate&lt;&gt; Match) method, like the List&lt;&gt; Class does.

What&#39;s the best way (both performance wise and elegant wise) to do that?


Best way to remove multiple items matching a predicate from a .NET Dictionary?

I want to wait for a process to finish, but `process.WaitForExit()` hangs my GUI.  Is there an event-based way, or do I need to spawn a thread to block until exit, then delegate the event myself?

process.WaitForExit() asynchronously

I&#39;m being driven to insanity trying to figure out why Intellisense just fails to work at all. The server I&#39;m using is local and is 2008, the database is set to 2008 compatibility, Intellisense is on in every menu I can find, and yet no member list will pop up even with a CTRL-J.

Has anyone experienced something like this and found a way to fix it? I really can&#39;t bring myself to start work unless I have Intellisense working.

Why is SQL Server 2008 Management Studio Intellisense not working?

Is there an equivalent to &#39;intellisense&#39; for Python?

Perhaps i shouldn&#39;t admit it but I find having intellisense really speeds up the &#39;discovery phase&#39; of learning a new language.  For instance switching from VB.net to C# was a breeze due to snippets and intellisense helping me along.

Python and Intellisense

Is there a quick way to find all of the implementations of, not references to, an interface&#39;s method/property/etc?  Here&#39;s some sample code: 

    public class SomeClass : IBaseClass
    {
      public Int32 GetInt()
      {
         return 1;
      }
    }
    
    public interface IBaseClass
    {
      public Int32 GetInt();
    }
    
    public class SomeOtherClass
    {
      IBaseClass _someClass;
      private TestMethod()
      {
        _someClass = new SomeClass();
        _someClass.GetInt();
      }
    }

I want to quickly get to SomeClass.GetInt() while reviewing SomeOtherClass.TestMethod().  If I right click on _someClass.GetInt() and click &#39;Go To Definition&#39;, it takes me to the interface.  If I click &#39;Find All References&#39;, I could potentially see a list of all uses ... not just the classes that implement the GetInt() method.  

Is there a faster way to find this?  Any tips from other developers?  We are using D.I. for most of our dependencies, which means that tracing through deeply nested code takes *forever*.

How do you quickly find the implementation(s) of an interface&#39;s method?

I have a pretty annoying problem with the IntelliSense in Visual Studio 2010:

Every now and then (but not always - just out of my control) the Intellisense engine chooses to &quot;mark&quot; an option, instead of actually selecting it. This means that instead of typing &lt;kbd&gt;e&lt;/kbd&gt; &lt;kbd&gt;n&lt;/kbd&gt; &lt;kbd&gt;Enter&lt;/kbd&gt; to access the default option starting with &quot;En...&quot;, I have to type &lt;kbd&gt;e&lt;/kbd&gt; &lt;kbd&gt;n&lt;/kbd&gt; &lt;kbd&gt;**down**&lt;/kbd&gt; &lt;kbd&gt;Enter&lt;/kbd&gt;.

Usually it works like this for a while, and then, suddenly, the behavior I want is back. My conclusion is that there is some option somewhere that is set automatically, and that I don&#39;t know how to control.

How do I make sure that the default option is always selected, and not just &quot;marked&quot;?

For reference: This is Visual Studio 2010 RC, with CodeRush Xpress 10.1.

Visual Studio 2010 IntelliSense doesn&#39;t select a default value - it just marks it

I just moved from [Visual Studio 2008][1] to [Visual&amp;nbsp;Studio&amp;nbsp;2010][2] (final) and noticed one major flaw:

When I try to use AutoComplete in a C++ source file for managed C++, a small note in the footer appears:

**IntelliSense for C++/CLI is not available**

Uh, has IntelliSense for C++/CLI been dropped from Visual&amp;nbsp;Studio&amp;nbsp;2010? Is there any way to get this back? It *is* rather useful...

  [1]: http://en.wikipedia.org/wiki/Microsoft_Visual_Studio#Visual_Studio_2008
  [2]: http://en.wikipedia.org/wiki/Microsoft_Visual_Studio#Visual_Studio_2010


No IntelliSense for C++/CLI in Visual Studio 2010?

For each class in the project, SandCastle creates (among others) two pages:

  * The main page, called as `T_class_full_name`, with the description, Syntax, Inheritance Hierarchy and See Also
  * The members page, called as `AllMembers_T_class_full_name`, with Constructors, Methods, Fields, etc.

Is there a way to merge these two together - with the `members page` being appended to the main page?

Is it possible to merge two pages created by SandCastle into a single main page?

I know that it isn&#39;t the most vital of issues, but I just realised that I can put the javadoc comment block before or after the annotation. What would we want to adopt as a coding standard?


    /**
     * This is a javadoc comment before the annotation 
     */
    @Component
    public class MyClass {

        @Autowired
        /**
         * This is a javadoc comment after the annotation
         */
        private MyOtherClass other;
    }

codestyle; put javadoc before or after annotation?

I&#39;m currently using [JSDoc Toolkit](http://code.google.com/p/jsdoc-toolkit/) to document my code, but it doesn&#39;t quite fit - namely, it seem to struggle with describing namespaces properly. Say you have two simple classes in each their files:

`lib/database/foo.js`:

    /** @class */
    function Foo(...) {...}

    /** @function ... */
    Foo.prototype.init(..., cb) { return cb(null, ...); };

    module.exports = foo;

And then something inherited `lib/database/bar.js`:

    var Foo = require(&#39;./foo&#39;);

    /**
     * @class
     * @augments Foo
     */
    function Bar(....) {...}

    util.inherits(Bar, Foo);

    Bar.prototype.moreInit(..., cb) { return cb(null, ...); };

In the generated documentation, this is output simply as `Foo` and `Bar`, without the leading `database` (or `lib.database`), which are quite necessary when you don&#39;t have everything in a global scope.

I&#39;ve tried throwing `@namespace database` and `@name database.Foo` at it, but it doesn&#39;t turn out nice.

Any ideas for making JSDoc output something more suitable, or some entirely different tool that works better with Node.js? (I looked briefly at Natural Docs, JSDuck and breezed over quite a few others that looked quite obsolete...)

Documenting Node.js projects

I haven&#39;t been able to figure out what the `&gt;&gt;&gt;` does, even though I often see it often in source code.

What do the three arrow (&quot;&gt;&gt;&gt;&quot;) signs mean?

I am having a function that accepts one string parameter. This parameter can have only one of a few defined possible values. What is the best way to document the same? Should shapeType be defined as enum or TypeDef or something else?

    Shape.prototype.create = function (shapeType) {
        // shapeType can be &quot;rect&quot;, &quot;circle&quot; or &quot;ellipse&quot;...
        this.type = shapeType;
    };

    Shape.prototype.getType = function (shapeType) {
        // shapeType can be &quot;rect&quot;, &quot;circle&quot; or &quot;ellipse&quot;...
        return this.type;
    };

The second part of the problem is that the possible values of `shapeType` is not known in the file that defines `shapeType` as whatever you suggest. There are multiple files contributed by several developers who might add to the possible values of `shapeType`.

PS: Am using `jsdoc3`

Content Type	Original Author	Original Content on Stackoverflow
Question	flesh	View Question on Stackoverflow
Solution 1 - .Net	Brian Kim	View Answer on Stackoverflow
Solution 2 - .Net	theKRAY	View Answer on Stackoverflow
Solution 3 - .Net	Al Erickson	View Answer on Stackoverflow
Solution 4 - .Net	Andrew Hare	View Answer on Stackoverflow
Solution 5 - .Net	Joel Coehoorn	View Answer on Stackoverflow

Adding line breaks to comments for Intellisense

.Net Problem Overview

.Net Solutions

Solution 1 - .Net

Solution 2 - .Net

Solution 3 - .Net

Solution 4 - .Net

Solution 5 - .Net

Is NULL always false?

How would you write a program to generate Haiku?

Attributions