public static IEnumerable<TSource> DelegateUnion<TSource>(
     this IEnumerable<TSource> left, 
     IEnumerable<TSource> right, 
     Func<TSource, TSource, bool> comparator)
{
    var sent = new List<TSource>();
    Func<TSource, bool> partialComp = (thingy) => sent.Any(sentMember => comparator(sentMember, thingy));
    foreach (var sourceThingy in left.Concat(right))
    {
        if (sent.Any(partialComp)) continue;
        yield return sourceThingy;
        sent.Add(sourceThingy);
    }
}

//usage:
listA.DelegateUnion(listB, (l, r) => l.A == r.A && l.B == r.B)

Munkeymon fucked around with this message at 23:13 on Nov 18, 2014

Che Delilas fucked around with this message at 03:24 on Nov 19, 2014

Bognar fucked around with this message at 06:20 on Nov 19, 2014

public static IEnumerable<T> UnionBy<T>(this IEnumerable<T> left, IEnumerable<T> right, Func<T, IStructuralEquatable> selector)
{
    return left.Concat(right).ToLookup(selector).Select(x => x.First());
}

class MyClass
{
    public int A { get; set; }
    public int B { get; set; }
    public int C { get; set; }
}

var listA = new List<MyClass> { new MyClass { A = 1, B = 2, C = 3 } };
var listB = new List<MyClass> { new MyClass { A = 1, B = 2, C = 5 } };

listA.UnionBy(listB, x => Tuple.Create(x.A, x.B)).Count();      // 1
listA.UnionBy(listB, x => Tuple.Create(x.A, x.B, x.C)).Count(); // 2

var a = Tuple.Create(1,2);
var b = Tuple.Create(1,2);

a == b      // false
a.Equals(b) // true

c.DelegateUnion(d, (l, r) => l.Item1 == r.Item1 && l.Item2 == r.Item2).Count()

// the expression above implements the default Tuple equality
c.DelegateUnion(d, (l, r) => l.Equals(r)).Count()

// the method group is a bit cleaner
c.DelegateUnion(d, Object.Equals).Count()

// and the above expression is the same as the default Union
c.Union(d).Count()

Sedro fucked around with this message at 17:10 on Nov 19, 2014

Munkeymon fucked around with this message at 17:56 on Nov 19, 2014

Dim s3Client As IAmazonS3 = New AmazonS3Client("AWSAccessKey", "AWSSecretKey", RegionEndpoint.USWest2)
Dim files
files = Directory.EnumerateFiles("c:\tonsofimages\", "*.jpg")
For Each filename As String In files
   Dim reqUp As New PutObjectRequest()
   reqUp.BucketName = strBucket
   reqUp.Key = Path.GetFileName(filename)
   reqUp.FilePath = filename
   s3Client.PutObject(reqUp)
Next

Dim s3FI As New S3FileInfo(s3Client, strBucket, filename)
   If s3FI.Exists Then
    'Stuff
   End If

Scaramouche fucked around with this message at 22:46 on Nov 19, 2014

public dynamic GetSelectedInjuries()
{
    if (InjuryIDList != null && InjuryIDList.Count > 0)
    {
        return AllowMultipleInjuries ? (dynamic) InjuryIDList : InjuryIDList.First();
    }

    return null;
}

Cancelbot fucked around with this message at 01:12 on Nov 20, 2014

Gildiss fucked around with this message at 03:11 on Nov 20, 2014

return _db.Single<Customer>("SELECT * FROM customer WHERE Id = @0", id);

Mr Shiny Pants fucked around with this message at 10:03 on Nov 20, 2014

• Create a simple data context object that has a list of all the tables.
  
• Keep queries in the component that wants to use the queries. For very commonly used queries, I have made some general purpose CommonQueries class or for small projects just stuck them in the data context.
  
• Create a data model that models your database structure 1:1. Do not do anything fancy!
  
• Use your data model as a 1:1 representation of your database. Read rows from tables. Insert rows into tables. Update rows in tables. Delete rows from tables. Everything is rows and tables. No smart logic, do not even use reference properties. Never use the built-in lazy loading.
  

public class MyDataContext : DbContext
{
    public DbSet<CustomerRow> Customers { get; set; }
    public DbSet<CompanyRow> Companies { get; set; }

    public MyDataContext(string connectionStringName) : base(connectionStringName)
    {
    }

    public MyDataContext()
    {
    }
}

[Table("Customers")]
public class CustomerRow
{
    [Key]
    public Guid Id { get; set; }

    public DateTimeOffset Created { get; set; }
    public DateTimeOffset? Deleted { get; set; }

    public string Name { get; set; }

    public Guid CompanyId { get; set; }

    // Just to let Entity Framework understand that the relationship exists (for ordering of statements).
    // Never actually used in my code.
    internal virtual CompanyRow Company { get; set; }
}

...

using (var dc = new MyDataContext())
{
    dc.Customers.Add(new Customer { });
    await dc.SaveChangesAsync();
}

Mr Shiny Pants fucked around with this message at 21:16 on Nov 20, 2014

bpower fucked around with this message at 00:50 on Nov 21, 2014