public interface ICustomerQuery {
  Customer GetCustomerById(int id)
}

public class SqlCustomerQuery : ICustomerQuery {
  public Customer GetCustomerById(int id) { /* implementation */ }
}

public class CustomerThingy {  
  private ICustomerQuery _custQuery;

  public CustomerThingy(ICustomerQuery custQuery)
  {
    _custQuery = custQuery;
  }

  public bool SelectedCustomerIsActive()
  {
    var customer = _custQuery.GetCustomerById(selectedCustomerId);
    return !customer.disabled && customer.Orders.Max(o => o.OrderDate) > GetDate().SubtractDays(30);
  }
}

Dietrich fucked around with this message at 18:10 on Jul 10, 2013

• They do not create any sort of global state (singletons are anathema to good testing practices!)
  
• They use no external dependencies (databases, web services, current date/time, the file system, etc)
  

Sab669 fucked around with this message at 19:11 on Jul 11, 2013

public class ServiceCode
{
     a few global variables;

     public ServiceCode(bool liveOrDev)
     {
          constructor logic based on liveOrDev;
     }

     public lots of functions(whatever)
     {
          returns the whatever;
     }
}

public class WebService : System.Web.Services.WebService
{
     public ServiceCode service;

     public WebService()
     {
         constructor logic, determines live or dev;
         service = new ServiceCode(liveOrDevBool);
     }

     [WebMethod]
     public whatever function(whatever)
     {
          return service.whatever function(whatever);
     }
}

[WebMethod]
public whatever function(whatever)
{
     whatever result = new whatever;

     using (ServiceCode service = new ServiceCode(liveOrDevBool))
     {
          result = service.whatever(whatever);
     }
     
     return result;
}

public void Dispose()
{
     releasing all the global variables;
}

System.ObjectDisposedException: Safe handle has been closed
   at System.Threading.WaitHandle.WaitOneNative(SafeWaitHandle waitHandle, UInt32 millisecondsTimeout, 
Boolean hasThreadAffinity, Boolean exitContext)
   at System.Threading.WaitHandle.WaitOne(Int64 timeout, Boolean exitContext)
   at System.Threading.WaitHandle.WaitOne(Int32 millisecondsTimeout, Boolean exitContext)
   at System.Threading.WaitHandle.WaitOne()

//in general declarations
private static Mutex _mutex = new Mutex();

//in constructor logic
if (_sessionFactory == null)
{
     _mutex.WaitOne();
     if (_sessionFactory == null)
     {
          _sessionFactory = createISeriesSessionFactory(liveOrDev);
     }
     _mutex.ReleaseMutex();
}

CapnAndy fucked around with this message at 21:35 on Jul 11, 2013

<form action="rank_overall.asp" method="POST">

static void Main(string[] args)
        {
            //"class=Pro&rankyear=2013&x=26&y=10"
            //classes: Pro, All+Women, All+Amateurs, All+Masters, All+Lightweight
            const string classType = "Pro";
            using (WebClient client = new WebClient())
            {
                NameValueCollection formValues = new NameValueCollection
                    {
                        {"class", classType},
                        {"rankyear", "2013"},
                        {"x", "26"},
                        {"y", "10"}
                    };
                byte[] byteArray = client.UploadValues("http://nasgaweb.com/dbase/rank_overall.asp", formValues);
                string rawHtml = Encoding.ASCII.GetString(byteArray);
                bool isAthleteInResults = rawHtml.Contains("Matt Vincent");
            }

Uziel fucked around with this message at 22:45 on Jul 13, 2013

wwb fucked around with this message at 00:57 on Jul 18, 2013

public static class ReceivableMessageFactory
{
    public static IReceivableMessage ParseMessage(string message)
    {
        if (message.StartsWith("WHATEVER"))
        {
            return new FooMessage(message); // logic for actually parsing this particular type of message lives in the class itself, irrelevant here
        }
        return new UnknownMessage(message);
    }
}

IReceivableMessage message = ReceivableMessageFactory.ParseMessage("WHATEVER");
if (message is FooMessage && OnFooMessage != null) 
{
	OnFooMessage(this, (FooMessage)message);
}

private bool TryPropogateMessage<T>(IReceivableMessage message, EventHandler<T> e)
{
    if (!(message is T))
    {
        return false;
    }

    if (e != null)
    {
        e(this, (T)message);
    }

    return true;
}

private void ParseMessage() 
{
    IReceivableMessage message = ReceivableMessageFactory.ParseMessage("WHATEVER");
    var propogationAttempts = new List<Func<bool>> 
    {
        () => this.TryPropogateMessage(message, this.OnFooMessage),
        () => this.TryPropogateMessage(message, this.OnUnknownMessage) //etc 
    };
    
    propogationAttempts.Any(attempt => attempt());
}

New Yorp New Yorp fucked around with this message at 01:04 on Jul 18, 2013