// Open the central administration
SPSite centralAdminSite = SPAdministrationWebApplication.Local.Sites[0];

// Open the user profile manager context
SPServiceContext context = SPServiceContext.GetContext(centralAdminSite);
UserProfileManager userProfileManager = new UserProfileManager(context);
UserProfileConfigManager userProfileConfigManager = new UserProfileConfigManager(context);

string connectionName = "My Connection"; //
string systemName = "UserProfileLOBSystemInstance"; // The LobSystemInstance name
string entityName = "UserProfileEntity"; // The Entity name
string filterName = ""; // The filter ??
string entityNamespace = "UserProfiles.BdcModel1"; // Namespace of the project
string profilePropertyName = "AccountName"; // The unique SharePoint property to map the BDC to
string mappedAttribute = "ID"; // The unique BDC property

List<DSMLAttribute> dsmlAttributes = new List<DSMLAttribute>();
DSMLAttribute attr = null;

// Loop through all items from some sort of resource, E.G. an XML file
// The DSML attributes seem to be required so the connection knows these properties are available for mapping
// and that these properties can be mapped to a BDC field
foreach (var item in items)
{
   attr = new DSMLAttribute(); // create a new attribute
   attr.Indexible = bool.Parse(item.indexible);
   attr.Name = item.name; // the name of de BDC property
   attr.ID = item.id;
   attr.SingleValued = bool.Parse(item.singledValue);
   attr.Syntax = (DSMLSyntax)Enum.Parse(typeof(DSMLSyntax), item.syntax);
   dsmlAttributes.Add(attr);
}

try
{
 // Create the new user profile synchronisation connection
 userProfileConfigManager.ConnectionManager.AddBusinessDataCatalogConnection(
         connectionName, systemName, entityName, entityNamespace, profilePropertyName,
                filterName, mappedAttribute, dsmlAttributes);
}
catch (SystemException sex)
{
 // In some way, sometimes there is thrown an exception when nothing was wrong
}
catch (Exception ex)
{

}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml.Linq;
using System.ComponentModel;

namespace myProject
{
    public class WorkflowAssociationData
    {
        #region properties
        public enum AccounTypeOption { User, SharePointGroup };
        public enum AssignmentTypeOption
        {
            [Description("Allemaal tegelijk (parallel)")]   parallel,
            [Description("Eén tegelijk (serieel)")] serial
        };

        public enum DurationUnitsOption
        {
            [Description("Dag(en)")]    day,
            [Description("We(e)k(en)")] week,
            [Description("Maand(en)")]  month
        };

        private XDocument xmlData;
        public XDocument XmlData
        {
            get { return xmlData; }
            set { xmlData = value; }
        }

        public string NotificationMessage
        {
            get { return readNodeValue("NotificationMessage"); }
            set { setNodeValue("NotificationMessage", value); }
        }

        public int DurationforSerialTasks
        {
            get { return int.Parse(readNodeValue("DurationforSerialTasks")); }
            set { setNodeValue("DurationforSerialTasks", value.ToString()); }
        }

        public DurationUnitsOption DurationUnits
        {
            get { return ((DurationUnitsOption)Enum.Parse(typeof(DurationUnitsOption), readNodeValue("DurationUnits"))); }
            set { setNodeValue("DurationUnits", value.GetDescription()); }
        }

        public bool CancelonRejection
        {
            get { return bool.Parse(readNodeValue("CancelonRejection")); }
            set { setNodeValue("CancelonRejection", value.ToString().ToLower()); }
        }

        public bool CancelonChange
        {
            get { return bool.Parse(readNodeValue("CancelonChange")); }
            set { setNodeValue("CancelonChange", value.ToString().ToLower()); }
        }

        public bool EnableContentApproval
        {
            get { return bool.Parse(readNodeValue("EnableContentApproval")); }
            set { setNodeValue("EnableContentApproval", value.ToString().ToLower()); }
        }

        public AssignmentTypeOption AssignmentType
        {
            get { return ((AssignmentTypeOption)Enum.Parse(typeof(AssignmentTypeOption), readNodeValue("AssignmentType"))); }
            set { setNodeValue("AssignmentType", value.GetDescription()); }
        }
        #endregion

        private WorkflowAssociationData() { }

        /// <summary>
        /// Create a new object with the default or existing XML
        /// </summary>
        /// <param name="xml"></param>
        public WorkflowAssociationData(string inputXml)
        {
            XmlData = XDocument.Parse(inputXml);
        }

        /// <summary>
        /// Update the approvers for this workflow
        /// </summary>
        /// <param name="displayName"></param>
        /// <param name="accountName"></param>
        /// <param name="accountType"></param>
        public void UpdateApprovers(string displayName, string accountName, AccounTypeOption accountType)
        {
            insertPersonElement("Assignee", displayName, accountName, accountType);
        }

        /// <summary>
        /// Update the CC receivers for this workflow
        /// </summary>
        /// <param name="displayName"></param>
        /// <param name="accountName"></param>
        /// <param name="accountType"></param>
        public void UpdateCc(string displayName, string accountName, AccounTypeOption accountType)
        {
            insertPersonElement("CC", displayName, accountName, accountType);
        }

        /// <summary>
        /// Attach the person element to the node <nodeName>
        /// </summary>
        /// <param name="nodeName"></param>
        /// <param name="displayName"></param>
        /// <param name="accountName"></param>
        /// <param name="accountType"></param>
        private void insertPersonElement(string nodeName, string displayName, string accountName, AccounTypeOption accountType)
        {
            XNamespace d = ""http://schemas.microsoft.com/office/infopath/2009/WSSList/dataFields">http://schemas.microsoft.com/office/infopath/2009/WSSList/dataFields";
            XNamespace pc = ""http://schemas.microsoft.com/office/infopath/2007/PartnerControls">http://schemas.microsoft.com/office/infopath/2007/PartnerControls";

            XElement dElement = XmlData.Descendants(d + nodeName).First();
            if (dElement.Descendants().Count() == 0)
            {
                XElement el = new XElement(pc + "Person",
                                    new XElement(pc + "DisplayName", displayName),
                                    new XElement(pc + "AccountId", accountName),
                                    new XElement(pc + "AccountType", accountType.ToString())
                                );
                dElement.Add(el);
            }
        }

        private string readNodeValue(string name)
        {
            XNamespace d = ""http://schemas.microsoft.com/office/infopath/2009/WSSList/dataFields">http://schemas.microsoft.com/office/infopath/2009/WSSList/dataFields";
            XElement el = XmlData.Descendants(d + name).First();
            return el.Value;
        }

        private void setNodeValue(string name, string value)
        {
            XNamespace d = ""http://schemas.microsoft.com/office/infopath/2009/WSSList/dataFields">http://schemas.microsoft.com/office/infopath/2009/WSSList/dataFields";
            XElement el = XmlData.Descendants(d + name).First();
            el.Value = value;
        }
    }

    public static class EnumMethods
    {
        /// <summary>
        /// Get the description from the enum
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        public static string GetDescription(this Enum value)
        {
            FieldInfo fi = value.GetType().GetField(value.ToString());
            DescriptionAttribute[] attributes = (DescriptionAttribute[])fi.GetCustomAttributes(typeof(DescriptionAttribute), false);
            return (attributes.Length > 0) ? attributes[0].Description : value.ToString();
        }
    }
}

// defaultXml is the default XML from a new SPWorkflowAssociation
WorkflowAssociationData data = new WorkflowAssociationData(defaultXml);
data.UpdateApprovers("Site Approvers Group", "Site Approvers Group", WorkflowAssociationData.AccounTypeOption.SharePointGroup);
data.NotificationMessage = "Please approve this item";
workflowAssociation.AssociationData = data.XmlData.ToString();

// list is an SPList object, workflowAssociation is an SPWorkflowAssociation object
SPDocumentLibrary docLib = (SPDocumentLibrary)list; // cast
docLib.WorkflowAssociations.Add(workflowAssociation); // attach
docLib.DefaultContentApprovalWorkflowId = workflowAssociation.Id; // set property
list.Update(); // save the list

// Set the path to the zip file and the name of the document library
string path = "c:\temp\testfile.zip";
string documentLibraryName = "WSPListener document library";

// Get the central administration web application and the upload folder
SPWeb centralAdminWeb = SPAdministrationWebApplication.Local.Sites[0].OpenWeb();
SPFolder uploadFolder = centralAdminWeb.Folders[documentLibraryName];
bool replaceExistingFiles = true;

SPFolder myLibrary = centralAdminWeb.Folders[documentLibraryName];

// Open a file stream to add the file in the document library
using (FileStream fileStream = File.OpenRead(path))
{
   SPFile spFile = myLibrary.Files.Add(fi.Name, fileStream, replaceExistingFiles);
   myLibrary.Update(); // save the file

   // Get the corresponding SPItem to update some properties and start the installation
   SPListItem item = spFile.Item;
   item["InstallationStartTime"] = null;
   item["InstallationEndTime"] = null;
   item["InstallationStatus"] = "Install";
   item["InstallationResult"] = "";
   item.Update();
}

// item is an SPListItem
SPFile myFile = item.File;
DestinationFile = Path.Combine(@"c:\temp", myFile.Name);
if (File.Exists(DestinationFile))
{
   // Remove the old file
   File.Delete(DestinationFile);
}

// Open the binary data
byte[] data = myFile.OpenBinary();
using (FileStream stream = new FileStream(DestinationFile, FileMode.CreateNew))
{
   // Save the file
   BinaryWriter writer = new BinaryWriter(stream);
   writer.Write(data, 0, (int)myFile.Length);
   writer.Close();
   stream.Close();
}

SPWeb web = SPContext.Current.Site.OpenWeb();
PublishingWeb pubWeb = PublishingWeb.GetPublishingWeb(childWeb);
SPFile defaultPage = pubWeb.DefaultPage;

defaultPage.CheckOut();
defaultPage.Update();

defaultPage.Item["Title"] = "My title";
defaultPage.Item.Update();

defaultPage.CheckIn("My comment");
defaultPage.Update();

int result = DateTime.Compare(date1, date2)

// copy the table definition from source to destination table
DataTable destinationTable = sourceTable.Clone();

foreach (DataRow dr in sourceTable)
{
   destinationTable.ImportRow(dr);
}

public void ExecuteStoredProcedure(string name, string[] parameters, object[] values)
{
    using (SqlConnection connection = new SqlConnection(ConnectionString))
   {
      connection.Open();

      try
      {
         SqlCommand command = new SqlCommand(name, connection);
         command.CommandType = CommandType.StoredProcedure;

         for (int i = 0; i < parameters.Length; i++)
         {
            command.Parameters.Add(new SqlParameter(parameters[i], values[i]));
         }
                   
         command.ExecuteNonQuery();
      }
      catch (Exception ex)
      {

      }
      finally
      {
         connection.Close();
       }
   }
}

using (SqlConnection connection = new SqlConnection(myConnectionString))
{
   using (SqlBulkCopy bulkCopy = new SqlBulkCopy(connection))
   {
      bulkCopy.DestinationTableName = "myNewTable";
      bulkCopy.WriteToServer(dt);
   }
}