darrenkopp

    public class DataTranslator
    {
        public static Func<IDataRecord, T> CreateTranslator<T>(IDataRecord record)
        {            
            Type targetType = typeof(T);
            string cacheKey = string.Format("{0}-Translator", targetType);

            var cachedTranslator = WebContextCache.GetItem<Func<IDataRecord, T>>(cacheKey);

            if (cachedTranslator != null)

mhart

public class QueryOverStub<TRoot, TSub> : IQueryOver<TRoot, TSub>
{
    private readonly TRoot _singleOrDefault;
    private readonly IList<TRoot> _list;
    private readonly ICriteria _root = MockRepository.GenerateStub<ICriteria>();

    public QueryOverStub(IList<TRoot> list)
    {
        _list = list;
    }

danielwertheim

public static class Factory<T> where T : class 
{
	private static readonly Func<T> FactoryFn;

	static Factory()
	{
		//FactoryFn = CreateUsingActivator();

		FactoryFn = CreateUsingLambdas();
	}

giggio

using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace TestProject3
{
    [TestClass]
    public class BindingTest
    {
        [TestMethod]
        public void EstaticoString()
        {

NOtherDev

internal class NodeBuilder
{
    private readonly XmlDocument _doc;
    private readonly XmlNode _node;

    public NodeBuilder(XmlDocument doc, XmlNode node)
    {
        _doc = doc;
        _node = node;
    }

philipmat

void Main()
{
	var co = new Company { Id = 1, Name = "Moof Inc." };
	var clarus = new Contact { Id = 1, Name = "Clarus" };
	var mark = new Contact { Id = 2, Name = "Mark" };
	co.AddContact(clarus);
	co.AddContact(mark);
	co.MainContact = clarus;

	// Attempt #1: Straight up, no converter

liammclennan

From wikipedia:

Two software components are connascent if a change in one would require the other to be modified in order to maintain the overall correctness of the system.

Connascence is a useful tool for discussing different types of coupling that occur within software.

Again from wikipedia, "connascence of name is when multiple components must agree on the name of an entity". Connascence of name one is of the list harmful and most unavoidable types of connascence because it is simple to reason about and change. While connascence of name is still connascence, and therefore bad, it is among the most amenable to refactoring. If the name of something changes then everything that refers to that thing by name must also change. This is a simple change that can be mostly statically determined and applied by tools.

Connascence of position is present when changing the order of something necessitates a change elsewhere. An example is the order of function arguments. If the order of a function's arguments is

JulianRooze

class Employee
{
  public IList<Order> Orders { get; set; }
}

class Order
{
  public int OrderID { get; set; }

  public IList<Customer> Customers { get; set; }

luis-fss

Nuget command line – uninstall package from all projects
	> Get-Project -All | Uninstall-Package <package name>

NOtherDev

// ASP.NET MVC: Replacing the default ActionInvoker to do something useful with non-ActionResult return types
// See more: http://notherdev.blogspot.com/2012/09/non-actionresult-return-type-aspnet-mvc.html
public class MyControllerFactory : DefaultControllerFactory
{
    public override IController CreateController(RequestContext context, string controllerName)
    {
        var controller = base.CreateController(context, controllerName);
        return ReplaceActionInvoker(controller);
    }