Difference among .NET Mutable, Readonly, Immutable, and Freezable Collections

Mutable 

Mutable is the most common collection type in the .NET world. These are collections such as List; that allow reading, as well as adding, removing and changing items.

Read-Only

Read-Only These are collections that can't be modified from the outside. However, this notion of collections doesn't guarantee that its contents will never change. For example, a dictionary's keys and values collections can't be updated directly, but adding to the dictionary indirectly updates the keys and values collections. You can create your own read only collection by inheriting from ReadOnlyCollection.

Immutable

Immutable These are collections that, once created, are guaranteed to never be changed and thread-safe. If a complicated data structure is fully immutable, it can always be safely passed to a background worker. You don't need to worry about someone modifying it at the same time. This collection type is not provided by the Microsoft .NET Framework base class library (BCL) today. You can download from NuGet by searching for Microsoft.Immutable.Collections.

Freezable

Freezable These collections behave like mutable collections until they're frozen. Then they behave like immutable collections. Although the BCL doesn't define these collections, you can find them in Windows Presentation Foundation.

What’s New and Improved in Resharper 2017.1

If JetBrains is a sports team, I’d be a fan of it, just like I am a fan of Houston Rockets. JetBrains has so many good products, Resharper, dotMemory, dotCover, and dotTrace. Don’t forget TeamCity, it is really an awesome build tool.

I agreed to a saying at Houston TechFest 2016, from a great speaker Curtis Schlak, that Visual Studio and Resharper make the developer’s mind dull because the tools like Resharper do a lot and developers start to lose the skills to do it manually. Sadly that’s the side effect for using Resharper. Just like I won't be able to remember my best friend's phone number any more after my iPhone can remember the numbers for me. I guess there are always pros and cons. I  think I need to be aware of the side effects to use Reshaper. But I don’t think I’ll let Resharper go out of my developer’s life.

Way to go JetBrains Resharper. Here are the good stuff  in 2017.1. 

• C# 7 support with new inspections and quick-fixes
• Support for the Lightweight solution load mod
• .NET Core unit testing support in Visual Studio 2017
• Many code formatting improvements including support for EditorConfig
• Filtering options in Find Results , Go to Everything , and Go to Text
• Full support for TypeScript 2.1 and initial support for TypeScript 2.2
• Initial support for Angular 2

First impression on Visual Studio 2017

Visual studio 2/017 gets it right this time.
Even the icon looks cool.

VS 2017 Installation Screen Shot

Improved startup and improved project load. Lightweight solution loading, and many more enhancements come together to make Visual Studio 2017 start up to 3 times faster than Visual Studio 2015. Solution load times are 2-4 times shorter, and build performance is faster too.

Snappier XAML Editor. It  is snappier, a lot. It’s so much faster than 2015 – lighting faster. This is because Visual Studio 2017 leverages the XAML Language Service’s knowledge of the XAML file to determine the names and types of the fields to populate IntelliSense, and then update the g.i.* file using Roslyn on a background thread.

dotted lines for XAML

Dot Lines are awesome in the C# editor and XAML editor.

Launch Prepopulated New Email Message in WPF/WinForm

This article discussed three options to launch prepopulated New Email Window from your WPF/WinForm desktop application. The prepopulated fields can include From, To, Subject, Content, and Attachments etc.

 

Option 1: MailTo URL

Pros: MailTo protocol is the easiest and the cleanest way to launch the New Mail Message window. All you need to do is to create the URL and launch it using in a separated process.

        var url = @"mailto:user@example.com?subject=Message Title&body=Message Content";
        System.Diagnostics.Process.Start(url);

Cons: There is no official way to attach files using "mailto" protocol, likely because of the security reasons. It’s not support HTML content. More information can be found in MSDN.

 

Option 2: EML File

Pros: Save System.Net.Mail.MailMessage to a .EML file and open the .EML file with default mail application. It supports attachment. It supports HTML content.

        var mailMessage = new MailMessage();
        mailMessage.From = new MailAddress("someone@yourdomain.com");
        mailMessage.Subject = "Your subject here";
        mailMessage.IsBodyHtml = true;
        mailMessage.Body = "<span style='font-size: 12pt; color: red;'>My HTML formatted body</span>";
        mailMessage.Attachments.Add(new Attachment("C://Myfile.pdf"));
        var filename = "C://Temp/mymessage.eml";
        mailMessage.Save(filename);
        Process.Start(filename);

        public static void Save(this MailMessage message, string filename, bool addUnsentHeader = true)
        {
            using (var filestream = File.Open(filename, FileMode.Create))
            {
                if (addUnsentHeader)
                {
                    var binaryWriter = new BinaryWriter(filestream);
                    binaryWriter.Write(System.Text.Encoding.UTF8.GetBytes("X-Unsent: 1" + Environment.NewLine));
                }

                var assembly = typeof(SmtpClient).Assembly;
                var mailWriterType = assembly.GetType("System.Net.Mail.MailWriter");

                var mailWriterContructor = mailWriterType.GetConstructor(BindingFlags.Instance | BindingFlags.NonPublic, null, new[] { typeof(Stream) }, null);

                var mailWriter = mailWriterContructor.Invoke(new object[] { filestream });
                var sendMethod = typeof(MailMessage).GetMethod("Send", BindingFlags.Instance | BindingFlags.NonPublic);

                sendMethod.Invoke(message, BindingFlags.Instance | BindingFlags.NonPublic, null, new object[] { mailWriter, true, true }, null);

                var closeMethod = mailWriter.GetType().GetMethod("Close", BindingFlags.Instance | BindingFlags.NonPublic);

                closeMethod.Invoke(mailWriter, BindingFlags.Instance | BindingFlags.NonPublic, null, new object[] { }, null);
            }
        }

 

Cons: Some email servers can’t send out email because of security settings for From: and Sender:. You will probably get exceptions like this.

“You can't send a message on behalf of this user unless you have permission to do so. Please make sure you're sending on behalf of the correct sender, or request the necessary permission. If the problem continues, please contact your helpdesk.”

 

Option 3: Microsoft.Office.Interop.Outlook

Pros: A feasible option is to utilize Microsoft.Office.Interop.Outlook. I’ve tested different versions for Microsoft.Office.Interop.Outlook, for example 12.0.4518.1014 and 15.0.4797.1003, using the nugget packages. They all work either Office 2010 (14.0.x) or Office 365 (16.0.x). It looks like the COM API hasn’t changed from 14.0 to 16.0 to create new mail item.

With the reference property set to Embed Interop Types, the compiler will include the COM calls directly into Atlas assembly. Therefore, we don’t have to ship a specific version of a Microsoft Office Interop assembly with our product. Exceptions can be caught if any.

            
     var outlookType = Type.GetTypeFromProgID("Outlook.Application");
            if (outlookType == null)
            {
                throw new System.Exception("Microsoft Office Outlook is not installed.");
            }

            
            var oApp = new Application();
            var oMsg = (MailItem) oApp.CreateItem(OlItemType.olMailItem);
            oMsg.To = "someone@yourdomain.com";
            oMsg.Subject = subject;
            oMsg.BodyFormat = OlBodyFormat.olFormatHTML;
            oMsg.HTMLBody = ""; 
            oMsg.Attachments.Add(fullPath, OlAttachmentType.olByValue, Type.Missing, Type.Missing);
            oMsg.Display(false); 

 

Cons: It only works for Outlook.

C# Switch on Type

I want to write readable code like below to handle different sub types. Let’s say if I want to take a shower for my pets. Depending on the pet type, I will like to handle it differently. As you can tell, if statements can do the work but it will be very messy. I would like to use switch statement. However, C# compiler doesn’t want to get into this business. That’s alright. I will like to do it myself. Here is a clean solution. The ultmiate code is very easy to read. No if statements. Zero. None. Nil. There are 3 simple steps.

myPet.Switch()
     .Case<Dog>(x => HandleDog(x))
     .Case<Cat>(x => HandleCat(x))
     .Case<Parrot>(x => HandleParrot(x))
     .Default<Pet>(x => HandleDefault(x));

Step 1: Create a Switch class.

public class Switch
{
    public Switch(object o)
    {
        Target = o;
    }

    public object Target { get; set; }
}

 

Step 2: Create extension methods to support fluent API, supporting, predict, fall through, and default.

public static class SwitchExtensions
{
    public static Switch Case<T>(this Switch switcher, 
        Action<T> action) where T : class
    {
        return Case(switcher, o => true, action, false);
    }

    public static Switch Case<T>(this Switch switcher, 
        Action<T> action, 
        bool fallThrough) where T : class
    {
        return Case(switcher, o => true, action, fallThrough);
    }

    public static Switch Case<T>(this Switch switcher, 
        Func<T, bool> predicate, 
        Action<T> action) where T : class
    {
        return Case(switcher, predicate, action, false);
    }

    public static Switch Case<T>(this Switch s, 
        Func<T, bool> predicate, 
        Action<T> action, 
        bool fallThrough) where T : class
    {
        if (s == null)
        {
            return null;
        }

        var t = s.Target as T;
        if (t == null)
        {
            return s;
        }

        if (!predicate(t))
        {
            return s;
        }

        action(t);
        return fallThrough ? s : null;
    }

    public static void Default<T>(this Switch switcher, 
        Action<T> action) where T : class
    {
        if (switcher == null)
        {
            return;
        }

        var t = switcher.Target as T;
        if (t == null)
        {
            return;
        }

        action(t);
    }
}

Step 3: Finally, add an extension method for System.Object so that any object can call Switch() method.

public static class ObjectSwitchExtensions
{
    public static Switch Switch(this object Object)
    {
        return new Switch(Object);
    }
}

Resharper 10–Resharper Build

Resharper Build is the new feature introduced by JetBrains with Resharper 10. I really like this feature. Put simply, ReSharper Build manages the build process, and decides if each individual project needs to be built, or not. When building a solution, if a project doesn’t need to be rebuilt, it is intelligently skipped — what’s faster than doing nothing?

• Build happens out of process

• Efficient timestamp monitoring

• Public API surface monitoring.

When a project is built, ReSharper will scan the just compiled output assembly. If its public API hasn’t changed, then ReSharper Build knows that it doesn’t need to build any of the referencing projects, and they are intelligently skipped. This has a huge impact on larger solutions. If a change is made to the business logic of a root assembly, then traditionally, that would require the rest of the solution to be rebuilt. ReSharper Build will only rebuild the root assembly, and skip the rest. 

When Resharper Build is working. You can see the progress of the window of Build and Run. There are some projects are built in parallel and some are built in sequentially. It is, in fact, visually intuitive.

Visual Studio 2015 In Action - 1

After playing with VS 2015 for a week, I am pretty happy and impressed by it. It has been greatly improved over VS 2013. Don't forget to install Color Schema Editor. It comes with 11 color themes. Solarized (Dark) is my favorite color theme. 

What’s new in C# 6?

1.       Roslyn compiler. Now you can ship your API with analyzer and fixer.

2.       Using static... for example using static System.Console;

3.       Immutable object. Now it’s so much easier with getter-only properties with readonly backup fields. You can set the getter-only properties in the constructor.

4.       property Lamda expression.

5.       $ sign to string formatting. So now you can string.Format($”{x} – {Y}”);

6.       Keyword for nameof , now you can use the name of the variable and it’s very refactoring friendly.

7.       Null checker ?.

8.       Added finally to await.

What’s new in IntelliTrace in VS 2015

1.       You can filter by Category like ADO, gestures.

2.       You can zoom in the timeline.

3.       You can view historical stack trace code.

4.       Standalone version of IntelliTrace.

What’s new in WPF in 2015

1.       Blend for Visual Studio 2015

2.       In-place change the template without showing the different document

3.       UI debugging tools for WPF

In previous versions of Visual Studio, sharing code meant going to a website to manually publish a repository, jumping through a myriad of workflows and manual steps like creating accounts and services just to start sharing code. In Visual Studio 2015, the process of getting your local repository onto Visual Studio Online (VSO) has been dramatically simplified.