Basic network data capture using Wireshark

I needed to use Wireshark once for debugging purpose & needed to spend an hour or  so to understand how it is used. Here are pretty basic steps in the form of  screenshot that should help

Detailed info can be found at Wireshark documentation here.

Avoid Boxing & Unboxing to improve performance

While writing code we generally don’t pay much attention to boxing & unboxing. It does matter in performance.

Here is an excerpt from MSDN article:

In relation to simple assignments, boxing and unboxing are computationally expensive processes. When a value type is boxed, a new object must be allocated and constructed. To a lesser degree, the cast required for unboxing is also expensive computationally.

Side effects of boxing & unboxing:

1. Boxed value type objects take up more memory
2. Boxed value type objects require an additional read
3. Short-lived value type objects eat up Gen 0 heap & this forces frequent garbage collections
4. Boxing and unboxing operations consume CPU & time
5. Casting is required & it can be costly

How to prevent boxing & unboxing:

1. Use ToString method of numeric data types such as int, double, float etc.
2. Use for loop to enumerate on value type arrays or lists (do not use foreach loop or LINQ queries)
3. Use for loop to enumerate on characters of string (do not use foreach loop or LINQ queries)
4. If you define your own value type then override implementation of basic object methods.
5. Don’t assign value type instance to object unless unavoidable
6. Use generic List<>, Dictionary<> (et al) instead of ArrList & HashTable.
7. Use Nullable<> value types (examples int?, float? etc)
8. When using string.Format (SrtingBuilder.AppendFormat) or similar API's that use 'params object[]' pass on value type objects by calling 'ToString()' method

Pay attention for below mentioned things & do some code refactoring

1. Implicit boxing (Example: object num = 1; )
2. Use of foreach on value types
3. LINQ queries on value type collections
4. Casting to value types

Using StringBuilder for Performance

High performance of application is implicit requirement, no one states it, and however it’s there and supposed to be taken care of. Here is my first blog on StringBuilder that hopefully help you.

Using StringBuilder is the most recommended way to concatenate large chunks of strings , mostly this happens in loop. It is the best approach to take, and despite this I have seen many developers not to follow this practice.

I have also seen developer’s instantiating StringBuilder in an inefficient ways too. Below are the guidelines for some efficient ways to use StringBuilder & get some performance.

• Always try to instantiate StringBuilder with some default value or capacity
• Use in large loops or at places where most of the concatenations are happening
• Use the same instance of StringBuilder in all methods that construct a single string

Example code:

static void Main(string[] args)

{

    int guessLength = 30;

    StringBuilder sb = new StringBuilder(100 * guessLength); //Give capacity or value as far as possible

    for (int loop = 0; loop < 100; loop++)

    {

        sb.Append(loop).Append(":").AppendLine();

    }

    ConstructMessage(sb);

    ConstructAdditionalMessage(sb);

    Console.WriteLine(sb);

}

static void ConstructMessage(StringBuilder sb)

{

    for (int loop = 0; loop < 5; loop++)

    {

        sb.AppendFormat("{0}:{1}", loop.ToString(CultureInfo.InvariantCulture), Environment.NewLine);

    }

}

static void ConstructAdditionalMessage(StringBuilder sb)

{

    sb.AppendLine();

    for (int loop = 0; loop < 5; loop++)

    {

        sb.AppendFormat("{0}:{1}", loop.ToString(CultureInfo.InvariantCulture), Environment.NewLine);

    }

}

Can you guess why I have used “loop.ToString(CultureInfo.InvariantCulture)” in the above example code?

Related readings:

https://www.dotnetperls.com/stringbuilder-performance

http://stackoverflow.com/questions/1612797/string-concatenation-vs-string-builder-performance

Avoid debug builds

I think debug builds should be avoided, and here is my view on this. 

There could be below potential benefits of giving away debug builds –

1. Improved overall build time duration

2. Issue resolution & debugging is required only for release builds

3. Developers can concentrate on verifying/working on actual deliverable release bits instead of non-deliverable debug builds

About Debug builds –

1. Debug builds are generally not smoke tested

2. Binaries that have debug specific code, anyway cannot be tested for product being shipped

3. For .NET components, it is easy to debug release binaries (and generally we must avoid writing debug specific code)

4. Generally we require debugging on dev machine, so we can manually compile with debug setting and then debug (and in many cases usually trace is sufficient)

5. If needed, it is easily possible to generate debug binary for detailed debugging purpose

About Life

Life is what, nothing but a game
Who can understand rules, is able to play

Life is what, nothing but a stock market
Who can bet, gets all the wealth

Life is what, nothing but a temptation, Needs lot of determination
If you have the motivation, you can alter any situation

Life is what, nothing but a teacher
First try to learn, then you can earn

Life is what, nothing but a cake
Who can share, will get the fame

Life is what, nothing but a joy
Who can extract, can learn to fly
Life gives what, nothing but pain
But don’t you cry, just always try
The reward you will get gives all the joy

Life needs what, a goal to achieve
Who can set, enjoy up to the best

Life is what, a puzzle to be solved
Who can solve, please ask to almighty GOD

Love and betrayals are part of Life
When things aren’t right, situation is tight,
You need to fight, only then you can survive

Ultimately Life is a mystery; know one knows its history
If you understand its chemistry, please tell me immediately :)

- Vaibhav M. Gawali