1. Sign in to Gmail.
2. Click the gear icon in the upper-right and select Mail settings .
3. Click Forwarding and POP/IMAP.
4. Select Enable POP for all mail or Enable POP for mail that arrives from now on.
5. Now you are able to connect to your Gmail account with Mail.dll POP3 library.

Remember that Gmail only allows secure SSL connections so you need to use ConnectSSL method.

Now you can download emails from Gmail using POP3 protocol.

1. Sign in to Gmail.
2. Click the gear icon in the upper-right and select Mail settings .
3. Click Forwarding and POP/IMAP.
4. Select Enable IMAP.
5. Now you are able to connect to your Gmail account with Mail.dll IMAP library.

Remember that Gmail only allows secure SSL connections so you need to use ConnectSSL method.

Now you can download emails from Gmail using IMAP protocol.

public class MainViewModel : ViewModelBase
{
    [NotifyPropertyChanged]
    public string Title { get; set; }
}

You can use PostSharp for that, you should at least use lambda expressions instead of strings.

Here’s how to do it without 3rd party software:

1.
In your project declare base view model:

public class ViewModelBase : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged
        = delegate { };

    protected void OnPropertyChanged(string propertyName)
    {
        this.PropertyChanged(
            this,
            new PropertyChangedEventArgs(propertyName));
    }
};

2.
Declare the attribute

It will be used to mark properties that should raise the PropertyChanged event.

[AttributeUsage(AttributeTargets.Property)]
public class NotifyPropertyChangedAttribute : Attribute
{
}

3.
Create new MSBuildTasks library project (it can be in different solution)

Add references to:

• Mono.Cecil.dll
• Mono.Cecil.Pdb.dll (this needed so Cecil can updated pdb file, which is need for debugging the modified assembly)
• MSBuild assemblies

4.
Create new MSBuild task

It will inject PropertyChanged event invocation on properties marked with NotifyPropertyChanged attribute.

using System;
using System.IO;
using Microsoft.Build.Framework;
using Microsoft.Build.Utilities;
using Mono.Cecil;
using Mono.Cecil.Cil;

namespace MSBuildTasks
{
    public class NotifyPropertyChangedTask : Task
    {
        public override bool Execute()
        {
            InjectMsil();
            return true;
        }

        private void InjectMsil()
        {
            var assemblyDefinition = AssemblyDefinition.ReadAssembly(
                AssemblyPath,
                new ReaderParameters { ReadSymbols = true });

            var module = assemblyDefinition.MainModule;

            foreach (var type in module.Types)
            {
                foreach (var prop in type.Properties)
                {
                    foreach (var attribute in prop.CustomAttributes)
                    {
                        string fullName = attribute.Constructor.DeclaringType.FullName;
                        if (fullName.Contains("NotifyPropertyChanged"))
                        {
                            InjectMsilInner(module, type, prop);
                        }
                    }
                }
            }
            assemblyDefinition.Write(
                this.AssemblyPath,
                new WriterParameters { WriteSymbols = true });
        }

        private static void InjectMsilInner(
            ModuleDefinition module,
            TypeDefinition type,
            PropertyDefinition prop)
        {
            var msilWorker = prop.SetMethod.Body.GetILProcessor();
            var ldarg0 = msilWorker.Create(OpCodes.Ldarg_0);

            MethodDefinition raisePropertyChangedMethod =
                FindRaisePropertyChangedMethod(type);
            if (raisePropertyChangedMethod == null)
                throw new Exception(
                    "RaisePropertyChanged method was not found in type "
                    + type.FullName);

            var raisePropertyChanged = module.Import(
                raisePropertyChangedMethod);
            var propertyName = msilWorker.Create(
                OpCodes.Ldstr,
                prop.Name);
            var callRaisePropertyChanged = msilWorker.Create(
                OpCodes.Callvirt,
                raisePropertyChanged);

            msilWorker.InsertBefore(
                prop.SetMethod.Body.Instructions[
                    prop.SetMethod.Body.Instructions.Count - 1],
                ldarg0);

            msilWorker.InsertAfter(ldarg0, propertyName);
            msilWorker.InsertAfter(
                propertyName,
                callRaisePropertyChanged);
        }

        private static MethodDefinition FindRaisePropertyChangedMethod(
            TypeDefinition type)
        {
            foreach (var method in type.Methods)
            {
                if (method.Name == "RaisePropertyChanged"
                    &&  method.Parameters.Count == 1
                    &&  method.Parameters[0].ParameterType.FullName
                        == "System.String")
                {
                    return method;
                }
            }
            if (type.BaseType.FullName == "System.Object")
                return null;
            return FindRaisePropertyChangedMethod(
                type.BaseType.Resolve());
        }

        [Required]
        public string AssemblyPath { get; set; }
    }
}

5.
Compile the task assembly,

and copy it to “$(SolutionDir)..libMSBuildMSBuildTasks.dll” folder along with Mono.Cecil.dll and Mono.Cecil.Pdb.dll assemblies.

4.
Finally modify your Silverlight/WPF project (.csproj file):

<project>
  ...
  <usingTask TaskName="MSBuildTasks.NotifyPropertyChangedTask" AssemblyFile="$(SolutionDir)..libMSBuildMSBuildTasks.dll" />
  <target Name="AfterCompile">
    <msbuildTasks.NotifyPropertyChangedTask AssemblyPath="$(ProjectDir)obj$(Configuration)$(TargetFileName)" />
  </target>
</project>

Voila! Enjoy!

Here’s the source code of the MSBuildTasks project:
MSBuildTasks

In WPF you could use UpdateSourceTrigger=PropertyChanged, which is not available in Silverlight.

Anyway here’s the nice Silverlight behavior to add this feature to Silverlight:

// Please note that Behavior class is from
// System.Windows.Interactivity assembly that is available
// after you have installed Expression Blend.
// (C:Program FilesMicrosoft SDKsExpressionBlendSilverlightv4.0
//  LibrariesSystem.Windows.Interactivity.dll)

public class UpdateOnTextChangedBehavior : Behavior<textBox>
{
    protected override void OnAttached()
    {
        base.OnAttached();

        this.AssociatedObject.TextChanged +=
                AssociatedObject_TextChanged;
    }

    void AssociatedObject_TextChanged(
        object sender,
        TextChangedEventArgs e)
    {
        BindingExpression binding =
            this.AssociatedObject.GetBindingExpression(
                TextBox.TextProperty);

        if (binding != null)
        {
            binding.UpdateSource();
        }
    }

    protected override void OnDetaching()
    {
        base.OnDetaching();

        this.AssociatedObject.TextChanged -=
                AssociatedObject_TextChanged;
    }
}

And usage:

<textBox Text="{Binding Title, Mode=TwoWay}">
   <i:Interaction.Behaviors>
      <local:UpdateOnTextChangedBehavior/>
   </i:Interaction.Behaviors>
</textBox>

This article describes how to force SSL3 or SSL2 in Mail.dll or in regular .NET SslStream class.

Here’s the code for Mail.dll

// C# version
using (Imap client = new Imap())
{
   // Force to use SSL3
   client.SSLConfiguration.EnabledSslProtocols = SslProtocols.Ssl3;
   // Ignore certificate errors
   client.ServerCertificateValidate += (sender, e) => { e.IsValid = true; };
   client.ConnectSSL("imap.gmail.com");
   client.Login("user@gmail.com", "password");

   client.SelectInbox();
   foreach(long uid in client.SearchFlag(Flag.Unseen))
   {
       string eml = client.GetMessageByUID(uid);
       IMail email = new MailBuilder().CreateFromEml(eml);
       Console.WriteLine(email.Subject);
   }
   client.Close();
}

' VB.NET version

Using client As New Imap()
	' Force to use SSL3
	client.SSLConfiguration.EnabledSslProtocols = SslProtocols.Ssl3
	' Ignore certificate errors
	AddHandler client.ServerCertificateValidate, AddressOf Validate
	client.ConnectSSL("imap.gmail.com")
	client.Login("user@gmail.com", "password")

	client.SelectInbox()
	For Each uid As Long In client.SearchFlag(Flag.Unseen)
		Dim eml As String = client.GetMessageByUID(uid)
		Dim email As IMail = New MailBuilder().CreateFromEml(eml)
		Console.WriteLine(email.Subject)
	Next
	client.Close()
End Using

Private Sub ValidateCerificate( _
    ByVal sender As Object, _
    ByVal e As ServerCertificateValidateEventArgs)

    Const ignoredErrors As SslPolicyErrors = _
        SslPolicyErrors.RemoteCertificateChainErrors Or _
        SslPolicyErrors.RemoteCertificateNameMismatch

    If (e.SslPolicyErrors And Not ignoredErrors) = SslPolicyErrors.None Then
        e.IsValid = True
        Return
    End If
    e.IsValid = False
End Sub

Here’s the code for SslStream:

// C# version
const string host = "imap.gmail.com";

Socket socket = new Socket(
   AddressFamily.InterNetwork,
   SocketType.Stream,
   ProtocolType.Tcp);
socket.Connect(host, 993);
using(SslStream ssl = new SslStream(new NetworkStream(socket), true))
{
   ssl.AuthenticateAsClient(
      host,
      new X509CertificateCollection(),
      SslProtocols.Ssl3,
      true);
   using(StreamReader reader = new StreamReader(ssl))
   {
       Console.WriteLine(reader.ReadLine());
   }
}
socket.Close();

' VB.NET version

Const  host As String = "imap.gmail.com"

Dim socket As New Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)
socket.Connect(host, 993)
Using ssl As New SslStream(New NetworkStream(socket), True)
	ssl.AuthenticateAsClient(host, New X509CertificateCollection(), SslProtocols.Ssl3, True)
	Using reader As New StreamReader(ssl)
		Console.WriteLine(reader.ReadLine())
	End Using
End Using
socket.Close()

// Before:

using(Pop3 client = new Pop3())
{
    client.GetAccountStat();
    Console.WriteLine(
        "Inbox has {0} emails.",
        client.MessageCount);
}

There are several things wrong with this code.

• The method is called Get… but it does not get anything, it changes the internal state of the object.
• Message count is stored in Pop3 object:
  • If the user of your API connects later to a different server you need to remember to reset this variable.
  • If the user of your API forgets to call GetAccountStat, message count is undefined (Should it be null?)

It’s really hard to say that this is a friendly API, as it requires the user to perform actions in specific order (call GetAccountStat before accessing message count).

Another problem is that GetAccountStat method is responsible for parsing the server response. It’s not necessary a bad thing, but if you have hundreds such methods then Pop3 class gets bloated with hard-to-test parsing logic.

Now lets take a look at the After code:

// After:

using(Pop3 client = new Pop3())
{
    AccountStats stats = client.GetAccountStat();
    Console.WriteLine(
        "Inbox has {0} emails.",
        stats.MessageCount);

}

Here we can see a good API:

• Method is called Get…. and it actually gets something.
• No specific call order is required, you simply call one method and act on the result.
• Parsing logic was moved to the AccountStats class.

This is not seen here but AccountStats method has a static Parse method…and look how easy is to write unit test for it’s behavior:

[Test]
public void Parse_MessageCountAndMailboxSize_AreFilled()
{
    AccountStats stats = AccountStats.Parse("2 373766");
    Assert.AreEqual(2, stats.MessageCount);
    Assert.AreEqual(373766, stats.MailboxSize);
}

Note also that actually we have NOT introduced a breaking change to our public API. Following code still works:

using(Pop3 client = new Pop3())
{
    client.GetAccountStat();
    Console.WriteLine(
        "Inbox has {0} emails.",
        client.MessageCount);
}

You’ll get 2 obsolete warnings:

warning CS0618: 'Limilabs.Client.POP3.Pop3.MessageCount' is obsolete: 'Please use the return value of GetAccountStat method instead.'

warning CS0618: 'Limilabs.Client.POP3.Pop3.MailboxSize' is obsolete: 'Please use the return value of GetAccountStat method instead.'

As we marked MessageCount and MailboxSize with [obsolete] attribute, but that’s it!

public class StringWalker
{
	string _s;
	public int Index { get; set; }

	public StringWalker(string s)
	{
		_s = s;
		Index = -1;
	}

	public bool MoveNext()
	{
		if (Index == _s.Length - 1)
			return false;
		Index++;
		return true;
	}

	public char CharAtIndex()
	{
		return _s[Index];
	}
};

IndentWriter class:

public class IndentWriter
{
	StringBuilder _sb = new StringBuilder();
	int _indent;

	public void Indent()
	{
		_indent++;
	}

	public void UnIndent()
	{
		if (_indent > 0)
			_indent--;
	}

	public void WriteLine(string line)
	{
		_sb.AppendLine(CreateIndent() + line);
	}

	private string CreateIndent()
	{
		StringBuilder indentString = new StringBuilder();
		for(int i = 0; i< _indent; i++)
			indentString.Append("    ");
		return indentString.ToString();
	}

	public override string ToString()
	{
		return _sb.ToString();
	}
};

JSON formatter class:

public class JsonFormatter
{
	StringWalker _walker;
	IndentWriter _writer = new IndentWriter();
	StringBuilder _currentLine = new StringBuilder();
	bool _quoted;

	public JsonFormatter(string json)
	{
		_walker = new StringWalker(json);
		ResetLine();
	}

	public void ResetLine()
	{
		_currentLine.Length = 0;
	}

	public string Format()
	{
		while(MoveNextChar())
		{
			if (this._quoted == false && this.IsOpenBracket())
			{
				this.WriteCurrentLine();
				this.AddCharToLine();
				this.WriteCurrentLine();
				_writer.Indent();
			}
			else if (this._quoted == false && this.IsCloseBracket())
			{
				this.WriteCurrentLine();
				_writer.UnIndent();
				this.AddCharToLine();
			}
			else if (this._quoted == false && this.IsColon())
			{
				this.AddCharToLine();
				this.WriteCurrentLine();
			}
			else
			{
				AddCharToLine();
			}
		}
		this.WriteCurrentLine();
		return _writer.ToString();
	}

	private bool MoveNextChar()
	{
		bool success = _walker.MoveNext();
		if (this.IsApostrophe())
		{
			this._quoted = !_quoted;
		}
		return success;
	}

	public bool IsApostrophe()
	{
		return this._walker.CharAtIndex() == '"';
	}

	public bool IsOpenBracket()
	{
		return this._walker.CharAtIndex() == '{'
			|| this._walker.CharAtIndex() == '[';
	}

	public bool IsCloseBracket()
	{
		return this._walker.CharAtIndex() == '}'
			|| this._walker.CharAtIndex() == ']';
	}

	public bool IsColon()
	{
		return this._walker.CharAtIndex() == ',';
	}

	private void AddCharToLine()
	{
		this._currentLine.Append(_walker.CharAtIndex());
	}

	private void WriteCurrentLine()
	{
		string line = this._currentLine.ToString().Trim();
		if (line.Length > 0)
		{
			_writer.WriteLine(line);
		}
		this.ResetLine();
	}
};

Few samples:

Console.WriteLine(new JsonFormatter(
	@"{""parameter"" : ""value"" , { ""parameter2"" : ""value2"" },{ ""parameter3"" : ""value3"" } }").Format());
Console.WriteLine(new JsonFormatter(
	@"{""parameter"":[""value1"",""value2"",""value3""] }").Format());
Console.WriteLine(new JsonFormatter(
	@"{""parameter"": ""value with {brackets}"" }").Format());

…and results:

{
    "parameter" : "value" ,
    {
        "parameter2" : "value2"
    },
    {
        "parameter3" : "value3"
    }
}

{
    "parameter":
    [
        "value1",
        "value2",
        "value3"
    ]
}

{
    "parameter": "value with {brackets}"
}

using(TcpClient client = new TcpClient())
{
    // Set timeout
    client.ReceiveTimeout =
        (int)TimeSpan.FromSeconds(1).TotalMilliseconds;

    // Connect to perfectly working imap server
    client.Connect("mail.limilabs.com", 143);

    // Create reader and writer
    NetworkStream stream = client.GetStream();
    StreamReader reader = new StreamReader(stream);
    StreamWriter writer = new StreamWriter(stream);

    // Read hello line
    Console.WriteLine(reader.ReadLine());

    // this works with no problems
    writer.WriteLine("a NOOP");             // No operation command
    writer.Flush();
    Console.WriteLine(reader.ReadLine());   // No operation response

    try
    {
        reader.ReadLine();                  // Nothing to read
    }
    catch (Exception ex)                    // Timeout
    {
        Console.WriteLine("timeout");       // This is expected
    }

    writer.WriteLine("b NOOP");             // No operation command
    writer.Flush();

    // SocketException: A non-blocking socket operation
    // could not be completed immediately
    Console.WriteLine(reader.ReadLine());

    client.Close();
}

The above code runs as expected on Mono and on .NET 4.0.

The problem is in UpdateStatusAfterSocketError internal Socket method that executes SetToDisconnected method when any exception is thrown, including timeout exception.

We have a Person class correctly mapped in NHibernate:

public class Person
{
	public int Id { get; set; }
	public int Name { get; set; }
}

We saw that sometimes we were getting a Person with Id equal to zero, from our repository:

public class PersonRepository
{
	private ISession _session;

	//...

	public Person LoadById(int id)
	{
		return _session.Load<person>(id);
	}
}

We narrowed the problem down and wrote this little test:

[Test]
public void LoadById_Loads_IdIsSet()
{
    _context.ExecuteInTransaction(() =>
		{
			Person person = _context.PersonRepository.LoadById(7);
			Assert.AreEqual(7, person.Id);
		}
	);
}

…which of course failed.

After initial surprise, we took a second look at the Person class and we saw that we are missing virtual keyword on properties. NHibernate is not able to create a correct Proxy object.

public class Person
{
	public virtual int Id { get; set; }
	public virtual int Name { get; set; }
}

This fixed the issue.
Strange thing is that we expect that NHibernate would throw an exception is such case.

One that I particularly like is by using PostSharp to implement INotifyPropertyChanged.

If you are not comfortable with PostSharp you can at least get rid of those nasty strings in standard implementation:

public class Model : ViewModeBase
{
    private string _status;
    public string Status
    {
        get { return _status; }
        set
        {
            _status = value;
            OnPropertyChanged("Status");
        }
    }
};

Labda expressions look nicer and are easier to refactor:

public class MyModel : ViewModeBase
{
    private string _status;
    public string Status
    {
        get { return _status; }
        set
        {
            _status = value;
            OnPropertyChanged(() => Status);
        }
    }
};

First thing we need to do is to create base class for all our ViewModels:

public class ViewModelBase
{
    public event PropertyChangedEventHandler PropertyChanged
        = delegate { };

    protected void OnPropertyChanged(
        Expression<func<object>> expression)
    {
        string propertyName = PropertyName.For(expression);
        this.PropertyChanged(
            this,
            new PropertyChangedEventArgs(propertyName));
    }
};

The implementation of PropertyName.For is very straightforward: How to get property name from lambda.

That’s it!
Nice, easy to refactor, compile-time checked INotifyPropertyChanged implementation.