Yield we will use when we want to return a collection (i.e. IEnumerable).

For example small console application:

namespace Yield
{
  using System;
  using System.Collections.Generic;

  class Program
  {
    static void Main(string[] args)
    {
      IEnumerable<string> aaa;
      foreach (var a in YieldTest())
      {
        Console.WriteLine(a);
      }
      Console.ReadKey();
    }

    private static IEnumerable<string> YieldTest()
    {
      string[] myTestsStrings = new[] { "One", "Two" };

      foreach (var myTest in myTestsStrings)
      {
        yield return myTest;
      }
    }
  }
}

As a result we will see something like:

One
Two

Note line:

yield return myTest;

If we remove "yield" from that line, we will receive the error:

Cannot implicitly convert type 'string' to 'System.Collections.Generic.IEnumerable<string>'

Our YieldTest method can look like:

private static IEnumerable<string> YieldTest()
{
	string[] myTestsStrings = new[] { "One", "Two" };

	foreach (var myTest in myTestsStrings)
	{
		return new[] { myTest };
	}
	return null;
}

Notice that instead of:

yield return myTest;

Now we have:

return new[] { myTest };

Which will give as result something like:

One

Just one record.

I had task to check if XML nodes are in correct order. After some research basically all I needed was this line:

var nodes = myXml.Elements().ToList();

So, code would look something like this:

var nodes = myXml.Elements().ToList();

var expectedOrder = new[] { "first", "second", "third", "fourth" }.ToList();

var actualOrder = nodes.Select(node => node.Name.LocalName).ToList();

Assert.AreEqual(string.Join(",", expectedOrder), string.Join(",", actualOrder));

Mocks are "fake" objects, that means that with mock you can create object which will have fake values.
For example, lets declare one interface without implentation, something like:

public interface ICalculator
{
	int Summation(int a, int b);
}


Now, our test method will look like something like this:

public void SetupMoqExampleTestMethod()
{
	var mock = new Mock<ICalculator>();
	mock.Setup(m => m.Summation(It.IsAny<int>(), It.IsAny<int>())).Returns(10);
	Assert.AreEqual(mock.Object.Summation(1, 1), 10);
}


Notice the line:

mock.Setup(m => m.Summation(It.IsAny<int>(), It.IsAny<int>())).Returns(10);


With that line we said that which ever parameter we send to the "Summation" method, result will be always 10.
That is why our test will not fail.

Example you can download from here.

 

Create new console project, and create base class like this:

public class BaseClass
{
	public BaseClass(int value)
	{
		Console.WriteLine("BaseClass constructor with value: " + value.ToString());
	}
}


Now, let's derive class from our BaseClass:

class DerivedClass: BaseClass
{
	public DerivedClass(int value)
	: base(value)
	{
		Console.WriteLine("DerivedClass constructor with value: " + value.ToString());
	}
}


If we create our Main method like this:

class Program
{
	static void Main(string[] args)
	{
		BaseClass a = new BaseClass(10);
		DerivedClass b = new DerivedClass(20);
		Console.ReadKey();
	}
}


Result will be like this:

BaseClass constructor with value: 10
BaseClass constructor with value: 20
DerivedClass constructor with value: 20

Example project you can download from here.