In my scenario I am using iBATIS, which is a lightweight and flexible ORM that provides some easy mechanisms for handling these edge cases. If you were using standard ADO.NET you could also leverage the new Table-Valued Parameters to pass in the sets of Parent and Child data.

For the example I will use two tables, Parent and Child:

 
CREATE TABLE Parent(
      Id INT NOT NULL IDENTITY(1,1) PRIMARY KEY,
      Name VARCHAR(255) NOT NULL,
      SequenceNumber INT NOT NULL)
 
GO 
 
CREATE TABLE Child(
      Id INT NOT NULL IDENTITY(1,1) PRIMARY KEY,
      ParentId INT NOT NULL REFERENCES Parent(ParentID),
      Name VARCHAR255) NOT NULL)
GO
 

I have corresponding Parent and Child classes:

 
public class Parent
{
    public int Id { get; set;}
    public string Name { get; set; }
    public IList<Child> Children { get; set; }
}
 
public class Child
{
    public int Id { get; set; }
    public string Name { get; set; }
}
 

The SequenceNumber in the Parent table is just a surrogate key used to match the Parents in the batch back to the Children in that same batch, but I don't want it to pollute my Domain classes, so I will merely create a sequence number right before I send it to the iBATIS map using linq and anonymous types:

 
public static int InsertBatch(IList<Parent> parentList)
{
    var sequencedParents = parentList.Select(
        (parent, index) =>
        new
            {
                SequenceNumber = index,
                Parent = parent,
                Children = parent.Children.Select(
                child =>
                new
                    {
                        SequenceNumber = index,
                        Child = child
                     }).ToList()
            });
 
    var sequencedChildren = sequencedParents.Select(p => p.Children);
 
    var args = new Hashtable
                       {
                           {"Parents", sequencedParents},
                           {"Children", sequencedChildren}
                       };
 
    return Mapper.Instance().Update("InsertParentBatch", args);
}
 

The InsertBatch method is sending two separate lists to the iBATIS Mapped Statement, the list of Parents and the list of Children, which are associated by the sequence number we assigned which is unique for each Parent in this batch. We will use this to join them when we build the SQL in the following iBATIS map:

 
<statement id="InsertParentBatch" parameterClass="map">
	DECLARE @Inserted TABLE (
	  ID int,
	  SequenceNumber int
	)
 
	<isNotEmpty property="Parents">
		INSERT INTO Parent
		(
			Name,
			SequenceNumber
		)
		OUTPUT INSERTED.Id, INSERTED.SequenceNumber INTO @Inserted
		SELECT Name, SequenceNumber FROM (
		<iterate property="Parents" conjunction=" UNION ALL">
		  SELECT
		  #Parents[].Parent.Name# Name,
		  #Parents[].SequenceNumber# SequenceNumber
		</iterate>
		) P
	</isNotEmpty>
	<isNotEmpty property="Children">
		INSERT INTO Children (ParentId, Name)
		SELECT
			INS.Id,
			C.Name
		FROM
		(
		<iterate property="Children" conjunction=" UNION ">
		SELECT
		#Children[].Child.Name# Name,
		#Children[].SequenceNumber# SequenceNumber
		</iterate>
		) C
		INNER JOIN @Inserted INS ON
		INS.SequenceNumber = C.SequenceNumber
	</isNotEmpty>
</statement>
 

The above map generates a single SQL Server statement that declares a SQL table variable to store the inserted Id's and the corresponding Sequence Numbers that the OUTPUT clause is returning back from our insert Parents statement. The iBATIS iterate property is simply iterating the list of Parents we sent to the map and doing an inline UNION ALL so we can insert them in one step. The insert into Children statement joins back to the @Inserted table variable on the Sequence number to get the Id for it's Parent.

Although the solution requires the addition of the SequenceNumber column which is only used for this purpose and un-related to our data model, it can be worth the performance increase if you are facing a situation where you have high volumes of data being submitted to your application in batches. By using the anonymous types in the persistence layer and keeping the SequenceNumber out of our domain model we can limit it to an edge case performance optimization that should be well encapsulated.

static public void RaiseEvent(this EventHandler theEvent, object sender, EventArgs e)
{
    if (theEvent != null)
        theEvent(sender, e);
}
 
static public void RaiseEvent<T>(this EventHandler<T> theEvent, object sender, T e)
    where T : EventArgs
{
    if (theEvent != null)
        theEvent(sender, e);
}
 

which can be used like such:

SomthingHappenedEvent.RaiseEvent(this, new EventArgs());

another useful extension method for passing in a property name without using hardcoded strings:

public static string GetPropertyName<T, S>(this T obj, Expression<Func<T, S>> expr)
{
	return ((MemberExpression)expr.Body).Member.Name;
}

which can be used as such:

var ob = new { SomeProp = "abc"};
string propName = ob.GetPropertyName(a => a.SomeProp);

and finally, another handy set for quickly serializing any object to JSON:

public static string ToJson(this object obj)
{
    var serializer = new JavaScriptSerializer();
    return serializer.Serialize(obj);
}
 
public static string ToJson(this object obj, int recursonDepth)
{
    var serializer = new JavaScriptSerializer();
    serializer.RecursionLimit = recursonDepth;
    return serializer.Serialize(obj);
}

http://sourcemaking.com/design-patterns-and-tips

It contains an assortment/reference of design patterns, refactorings and other useful programming tips.

I wanted to use my real SSL Certificate that I had for my website to secure the communication
to my FTP Server and couldn't find any instructions on how to do so. After a little
searching and some trial and error this is the solution I have come up with, I hope
someone finds this useful.

The real certificate was set up and installed in IIS6, so the first step is to export
the cert from IIS. The Directory Security tab in the properties section of your website
in IIS has a button labelled "Server Certificate" which will launch the Web Server
Certificate wizard. Once the wizard launches, click next and choose the option "Export
the current certificate to a .pfx file:

Enter the name and the path of the file and click next. Choose a password to encrypt
the exported file with and click next, then finish.

The program I used to convert the certificate is called XCA and
can be downloaded from SourceForge.
Once you have XCA installed launch the application, and under the certificates tab
select "Import PKCS#12" and browse to the .pfx file that was exported from IIS:

It will prompt you for the password to decrypt the .pfx file and you will need to
use the password chosen when you exported it from IIS. In the next dialog, chose "import
all".
You should now see an entry under the keys tab named "unnamed" and an entry under
the certificates for your imported certificate.

Now we are going to export the Key file and certificate file required by FileZilla.
To export the key select the "unnamed" key and chose export, check off option to Encrypt
the key with a password, the format will be PEM:

Then export the certificate in the PEM format also:

The final step is to configure FileZilla to use your key and certificate. Browse to
the key and certificate files and enter the password you used to encrypt your key:

FileZilla will now use your real SSL Certificate and you will be able to secure your
FTP communications to your server!